feat(boc): Complete Business Operations Center v1.0

- Go backend API with full CRUD for all modules (CRM, Sales, Finance, HR, Legal, Marketing, Support, Purchase, Inventory, Projects, Automation, Analytics)
- Rust analytics service with parallel report generation
- C runtime with POSIX shared memory IPC
- PostgreSQL schema with 30+ tables, full migrations
- Redis cache, sessions, pub/sub
- Kafka event streaming with Zookeeper
- WebSocket hub for real-time updates
- Automation engine with cron jobs, workflows, event triggers
- JWT authentication, multi-tenant from start
- Docker Compose with all services
- Nginx reverse proxy with rate limiting
- Integration tests passing
- Feature gap analysis against Fortnox/Odoo/Visma

Refs: BOC-001

quixzoom-token-system/api/node_modules/@sinonjs/commons/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2018, Sinon.JS
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

quixzoom-token-system/api/node_modules/@sinonjs/commons/README.md

@@ -0,0 +1,16 @@
+# commons
+
+[![CircleCI](https://circleci.com/gh/sinonjs/commons.svg?style=svg)](https://circleci.com/gh/sinonjs/commons)
+[![codecov](https://codecov.io/gh/sinonjs/commons/branch/master/graph/badge.svg)](https://codecov.io/gh/sinonjs/commons)
+<a href="CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg" alt="Contributor Covenant" /></a>
+
+Simple functions shared among the sinon end user libraries
+
+## Rules
+
+-   Follows the [Sinon.JS compatibility](https://github.com/sinonjs/sinon/blob/master/CONTRIBUTING.md#compatibility)
+-   100% test coverage
+-   Code formatted using [Prettier](https://prettier.io)
+-   No side effects welcome! (only pure functions)
+-   No platform specific functions
+-   One export per file (any bundler can do tree shaking)

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/called-in-order.js

@@ -0,0 +1,55 @@
+"use strict";
+
+var every = require("./prototypes/array").every;
+
+/**
+ * @private
+ */
+function hasCallsLeft(callMap, spy) {
+    if (callMap[spy.id] === undefined) {
+        callMap[spy.id] = 0;
+    }
+
+    return callMap[spy.id] < spy.callCount;
+}
+
+/**
+ * @private
+ */
+function checkAdjacentCalls(callMap, spy, index, spies) {
+    var calledBeforeNext = true;
+
+    if (index !== spies.length - 1) {
+        calledBeforeNext = spy.calledBefore(spies[index + 1]);
+    }
+
+    if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
+        callMap[spy.id] += 1;
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ * @typedef {object} SinonProxy
+ * @property {Function} calledBefore - A method that determines if this proxy was called before another one
+ * @property {string} id - Some id
+ * @property {number} callCount - Number of times this proxy has been called
+ */
+
+/**
+ * Returns true when the spies have been called in the order they were supplied in
+ * @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
+ * @returns {boolean} true when spies are called in order, false otherwise
+ */
+function calledInOrder(spies) {
+    var callMap = {};
+    // eslint-disable-next-line no-underscore-dangle
+    var _spies = arguments.length > 1 ? arguments : spies;
+
+    return every(_spies, checkAdjacentCalls.bind(null, callMap));
+}
+
+module.exports = calledInOrder;

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/called-in-order.test.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var calledInOrder = require("./called-in-order");
+var sinon = require("@sinonjs/referee-sinon").sinon;
+
+var testObject1 = {
+    someFunction: function () {
+        return;
+    },
+};
+var testObject2 = {
+    otherFunction: function () {
+        return;
+    },
+};
+var testObject3 = {
+    thirdFunction: function () {
+        return;
+    },
+};
+
+function testMethod() {
+    testObject1.someFunction();
+    testObject2.otherFunction();
+    testObject2.otherFunction();
+    testObject2.otherFunction();
+    testObject3.thirdFunction();
+}
+
+describe("calledInOrder", function () {
+    beforeEach(function () {
+        sinon.stub(testObject1, "someFunction");
+        sinon.stub(testObject2, "otherFunction");
+        sinon.stub(testObject3, "thirdFunction");
+        testMethod();
+    });
+    afterEach(function () {
+        testObject1.someFunction.restore();
+        testObject2.otherFunction.restore();
+        testObject3.thirdFunction.restore();
+    });
+
+    describe("given single array argument", function () {
+        describe("when stubs were called in expected order", function () {
+            it("returns true", function () {
+                assert.isTrue(
+                    calledInOrder([
+                        testObject1.someFunction,
+                        testObject2.otherFunction,
+                    ])
+                );
+                assert.isTrue(
+                    calledInOrder([
+                        testObject1.someFunction,
+                        testObject2.otherFunction,
+                        testObject2.otherFunction,
+                        testObject3.thirdFunction,
+                    ])
+                );
+            });
+        });
+
+        describe("when stubs were called in unexpected order", function () {
+            it("returns false", function () {
+                assert.isFalse(
+                    calledInOrder([
+                        testObject2.otherFunction,
+                        testObject1.someFunction,
+                    ])
+                );
+                assert.isFalse(
+                    calledInOrder([
+                        testObject2.otherFunction,
+                        testObject1.someFunction,
+                        testObject1.someFunction,
+                        testObject3.thirdFunction,
+                    ])
+                );
+            });
+        });
+    });
+
+    describe("given multiple arguments", function () {
+        describe("when stubs were called in expected order", function () {
+            it("returns true", function () {
+                assert.isTrue(
+                    calledInOrder(
+                        testObject1.someFunction,
+                        testObject2.otherFunction
+                    )
+                );
+                assert.isTrue(
+                    calledInOrder(
+                        testObject1.someFunction,
+                        testObject2.otherFunction,
+                        testObject3.thirdFunction
+                    )
+                );
+            });
+        });
+
+        describe("when stubs were called in unexpected order", function () {
+            it("returns false", function () {
+                assert.isFalse(
+                    calledInOrder(
+                        testObject2.otherFunction,
+                        testObject1.someFunction
+                    )
+                );
+                assert.isFalse(
+                    calledInOrder(
+                        testObject2.otherFunction,
+                        testObject1.someFunction,
+                        testObject3.thirdFunction
+                    )
+                );
+            });
+        });
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/class-name.js

@@ -0,0 +1,13 @@
+"use strict";
+
+/**
+ * Returns a display name for a value from a constructor
+ * @param  {object} value A value to examine
+ * @returns {(string|null)} A string or null
+ */
+function className(value) {
+    const name = value.constructor && value.constructor.name;
+    return name || null;
+}
+
+module.exports = className;

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/class-name.test.js

@@ -0,0 +1,37 @@
+"use strict";
+/* eslint-disable no-empty-function */
+
+var assert = require("@sinonjs/referee").assert;
+var className = require("./class-name");
+
+describe("className", function () {
+    it("returns the class name of an instance", function () {
+        // Because eslint-config-sinon disables es6, we can't
+        // use a class definition here
+        // https://github.com/sinonjs/eslint-config-sinon/blob/master/index.js
+        // var instance = new (class TestClass {})();
+        var instance = new (function TestClass() {})();
+        var name = className(instance);
+        assert.equals(name, "TestClass");
+    });
+
+    it("returns 'Object' for {}", function () {
+        var name = className({});
+        assert.equals(name, "Object");
+    });
+
+    it("returns null for an object that has no prototype", function () {
+        var obj = Object.create(null);
+        var name = className(obj);
+        assert.equals(name, null);
+    });
+
+    it("returns null for an object whose prototype was mangled", function () {
+        // This is what Node v6 and v7 do for objects returned by querystring.parse()
+        function MangledObject() {}
+        MangledObject.prototype = Object.create(null);
+        var obj = new MangledObject();
+        var name = className(obj);
+        assert.equals(name, null);
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/deprecated.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-console */
+"use strict";
+
+/**
+ * Returns a function that will invoke the supplied function and print a
+ * deprecation warning to the console each time it is called.
+ * @param  {Function} func
+ * @param  {string} msg
+ * @returns {Function}
+ */
+exports.wrap = function (func, msg) {
+    var wrapped = function () {
+        exports.printWarning(msg);
+        return func.apply(this, arguments);
+    };
+    if (func.prototype) {
+        wrapped.prototype = func.prototype;
+    }
+    return wrapped;
+};
+
+/**
+ * Returns a string which can be supplied to `wrap()` to notify the user that a
+ * particular part of the sinon API has been deprecated.
+ * @param  {string} packageName
+ * @param  {string} funcName
+ * @returns {string}
+ */
+exports.defaultMsg = function (packageName, funcName) {
+    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
+};
+
+/**
+ * Prints a warning on the console, when it exists
+ * @param  {string} msg
+ * @returns {undefined}
+ */
+exports.printWarning = function (msg) {
+    /* istanbul ignore next */
+    if (typeof process === "object" && process.emitWarning) {
+        // Emit Warnings in Node
+        process.emitWarning(msg);
+    } else if (console.info) {
+        console.info(msg);
+    } else {
+        console.log(msg);
+    }
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/deprecated.test.js

@@ -0,0 +1,101 @@
+/* eslint-disable no-console */
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var sinon = require("@sinonjs/referee-sinon").sinon;
+
+var deprecated = require("./deprecated");
+
+var msg = "test";
+
+describe("deprecated", function () {
+    describe("defaultMsg", function () {
+        it("should return a string", function () {
+            assert.equals(
+                deprecated.defaultMsg("sinon", "someFunc"),
+                "sinon.someFunc is deprecated and will be removed from the public API in a future version of sinon."
+            );
+        });
+    });
+
+    describe("printWarning", function () {
+        beforeEach(function () {
+            sinon.replace(process, "emitWarning", sinon.fake());
+        });
+
+        afterEach(sinon.restore);
+
+        describe("when `process.emitWarning` is defined", function () {
+            it("should call process.emitWarning with a msg", function () {
+                deprecated.printWarning(msg);
+                assert.calledOnceWith(process.emitWarning, msg);
+            });
+        });
+
+        describe("when `process.emitWarning` is undefined", function () {
+            beforeEach(function () {
+                sinon.replace(console, "info", sinon.fake());
+                sinon.replace(console, "log", sinon.fake());
+                process.emitWarning = undefined;
+            });
+
+            afterEach(sinon.restore);
+
+            describe("when `console.info` is defined", function () {
+                it("should call `console.info` with a message", function () {
+                    deprecated.printWarning(msg);
+                    assert.calledOnceWith(console.info, msg);
+                });
+            });
+
+            describe("when `console.info` is undefined", function () {
+                it("should call `console.log` with a message", function () {
+                    console.info = undefined;
+                    deprecated.printWarning(msg);
+                    assert.calledOnceWith(console.log, msg);
+                });
+            });
+        });
+    });
+
+    describe("wrap", function () {
+        // eslint-disable-next-line mocha/no-setup-in-describe
+        var method = sinon.fake();
+        var wrapped;
+
+        beforeEach(function () {
+            wrapped = deprecated.wrap(method, msg);
+        });
+
+        it("should return a wrapper function", function () {
+            assert.match(wrapped, sinon.match.func);
+        });
+
+        it("should assign the prototype of the passed method", function () {
+            assert.equals(method.prototype, wrapped.prototype);
+        });
+
+        context("when the passed method has falsy prototype", function () {
+            it("should not be assigned to the wrapped method", function () {
+                method.prototype = null;
+                wrapped = deprecated.wrap(method, msg);
+                assert.match(wrapped.prototype, sinon.match.object);
+            });
+        });
+
+        context("when invoking the wrapped function", function () {
+            before(function () {
+                sinon.replace(deprecated, "printWarning", sinon.fake());
+                wrapped({});
+            });
+
+            it("should call `printWarning` before invoking", function () {
+                assert.calledOnceWith(deprecated.printWarning, msg);
+            });
+
+            it("should invoke the passed method with the given arguments", function () {
+                assert.calledOnceWith(method, {});
+            });
+        });
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/every.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/**
+ * Returns true when fn returns true for all members of obj.
+ * This is an every implementation that works for all iterables
+ * @param  {object}   obj
+ * @param  {Function} fn
+ * @returns {boolean}
+ */
+module.exports = function every(obj, fn) {
+    var pass = true;
+
+    try {
+        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+        obj.forEach(function () {
+            if (!fn.apply(this, arguments)) {
+                // Throwing an error is the only way to break `forEach`
+                throw new Error();
+            }
+        });
+    } catch (e) {
+        pass = false;
+    }
+
+    return pass;
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/every.test.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var sinon = require("@sinonjs/referee-sinon").sinon;
+var every = require("./every");
+
+describe("util/core/every", function () {
+    it("returns true when the callback function returns true for every element in an iterable", function () {
+        var obj = [true, true, true, true];
+        var allTrue = every(obj, function (val) {
+            return val;
+        });
+
+        assert(allTrue);
+    });
+
+    it("returns false when the callback function returns false for any element in an iterable", function () {
+        var obj = [true, true, true, false];
+        var result = every(obj, function (val) {
+            return val;
+        });
+
+        assert.isFalse(result);
+    });
+
+    it("calls the given callback once for each item in an iterable until it returns false", function () {
+        var iterableOne = [true, true, true, true];
+        var iterableTwo = [true, true, false, true];
+        var callback = sinon.spy(function (val) {
+            return val;
+        });
+
+        every(iterableOne, callback);
+        assert.equals(callback.callCount, 4);
+
+        callback.resetHistory();
+
+        every(iterableTwo, callback);
+        assert.equals(callback.callCount, 3);
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/function-name.js

@@ -0,0 +1,28 @@
+"use strict";
+
+/**
+ * Returns a display name for a function
+ * @param  {Function} func
+ * @returns {string}
+ */
+module.exports = function functionName(func) {
+    if (!func) {
+        return "";
+    }
+
+    try {
+        return (
+            func.displayName ||
+            func.name ||
+            // Use function decomposition as a last resort to get function
+            // name. Does not rely on function decomposition to work - if it
+            // doesn't debugging will be slightly less informative
+            // (i.e. toString will say 'spy' rather than 'myFunc').
+            (String(func).match(/function ([^\s(]+)/) || [])[1]
+        );
+    } catch (e) {
+        // Stringify may fail and we might get an exception, as a last-last
+        // resort fall back to empty string.
+        return "";
+    }
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/function-name.test.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var jsc = require("jsverify");
+var refute = require("@sinonjs/referee-sinon").refute;
+
+var functionName = require("./function-name");
+
+describe("function-name", function () {
+    it("should return empty string if func is falsy", function () {
+        jsc.assertForall("falsy", function (fn) {
+            return functionName(fn) === "";
+        });
+    });
+
+    it("should use displayName by default", function () {
+        jsc.assertForall("nestring", function (displayName) {
+            var fn = { displayName: displayName };
+
+            return functionName(fn) === fn.displayName;
+        });
+    });
+
+    it("should use name if displayName is not available", function () {
+        jsc.assertForall("nestring", function (name) {
+            var fn = { name: name };
+
+            return functionName(fn) === fn.name;
+        });
+    });
+
+    it("should fallback to string parsing", function () {
+        jsc.assertForall("nat", function (naturalNumber) {
+            var name = `fn${naturalNumber}`;
+            var fn = {
+                toString: function () {
+                    return `\nfunction ${name}`;
+                },
+            };
+
+            return functionName(fn) === name;
+        });
+    });
+
+    it("should not fail when a name cannot be found", function () {
+        refute.exception(function () {
+            var fn = {
+                toString: function () {
+                    return "\nfunction (";
+                },
+            };
+
+            functionName(fn);
+        });
+    });
+
+    it("should not fail when toString is undefined", function () {
+        refute.exception(function () {
+            functionName(Object.create(null));
+        });
+    });
+
+    it("should not fail when toString throws", function () {
+        refute.exception(function () {
+            var fn;
+            try {
+                // eslint-disable-next-line no-eval
+                fn = eval("(function*() {})")().constructor;
+            } catch (e) {
+                // env doesn't support generators
+                return;
+            }
+
+            functionName(fn);
+        });
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/global.js

@@ -0,0 +1,21 @@
+"use strict";
+
+/**
+ * A reference to the global object
+ * @type {object} globalObject
+ */
+var globalObject;
+
+/* istanbul ignore else */
+if (typeof global !== "undefined") {
+    // Node
+    globalObject = global;
+} else if (typeof window !== "undefined") {
+    // Browser
+    globalObject = window;
+} else {
+    // WebWorker
+    globalObject = self;
+}
+
+module.exports = globalObject;

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/global.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var globalObject = require("./global");
+
+describe("global", function () {
+    before(function () {
+        if (typeof global === "undefined") {
+            this.skip();
+        }
+    });
+
+    it("is same as global", function () {
+        assert.same(globalObject, global);
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+module.exports = {
+    global: require("./global"),
+    calledInOrder: require("./called-in-order"),
+    className: require("./class-name"),
+    deprecated: require("./deprecated"),
+    every: require("./every"),
+    functionName: require("./function-name"),
+    orderByFirstCall: require("./order-by-first-call"),
+    prototypes: require("./prototypes"),
+    typeOf: require("./type-of"),
+    valueToString: require("./value-to-string"),
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/index.test.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var index = require("./index");
+
+var expectedMethods = [
+    "calledInOrder",
+    "className",
+    "every",
+    "functionName",
+    "orderByFirstCall",
+    "typeOf",
+    "valueToString",
+];
+var expectedObjectProperties = ["deprecated", "prototypes"];
+
+describe("package", function () {
+    // eslint-disable-next-line mocha/no-setup-in-describe
+    expectedMethods.forEach(function (name) {
+        it(`should export a method named ${name}`, function () {
+            assert.isFunction(index[name]);
+        });
+    });
+
+    // eslint-disable-next-line mocha/no-setup-in-describe
+    expectedObjectProperties.forEach(function (name) {
+        it(`should export an object property named ${name}`, function () {
+            assert.isObject(index[name]);
+        });
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/order-by-first-call.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var sort = require("./prototypes/array").sort;
+var slice = require("./prototypes/array").slice;
+
+/**
+ * @private
+ */
+function comparator(a, b) {
+    // uuid, won't ever be equal
+    var aCall = a.getCall(0);
+    var bCall = b.getCall(0);
+    var aId = (aCall && aCall.callId) || -1;
+    var bId = (bCall && bCall.callId) || -1;
+
+    return aId < bId ? -1 : 1;
+}
+
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ * @typedef {object} SinonProxy
+ * @property {Function} getCall - A method that can return the first call
+ */
+
+/**
+ * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
+ * @param  {SinonProxy[] | SinonProxy} spies
+ * @returns {SinonProxy[]}
+ */
+function orderByFirstCall(spies) {
+    return sort(slice(spies), comparator);
+}
+
+module.exports = orderByFirstCall;

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/order-by-first-call.test.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var knuthShuffle = require("knuth-shuffle").knuthShuffle;
+var sinon = require("@sinonjs/referee-sinon").sinon;
+var orderByFirstCall = require("./order-by-first-call");
+
+describe("orderByFirstCall", function () {
+    it("should order an Array of spies by the callId of the first call, ascending", function () {
+        // create an array of spies
+        var spies = [
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy(),
+            sinon.spy(),
+        ];
+
+        // call all the spies
+        spies.forEach(function (spy) {
+            spy();
+        });
+
+        // add a few uncalled spies
+        spies.push(sinon.spy());
+        spies.push(sinon.spy());
+
+        // randomise the order of the spies
+        knuthShuffle(spies);
+
+        var sortedSpies = orderByFirstCall(spies);
+
+        assert.equals(sortedSpies.length, spies.length);
+
+        var orderedByFirstCall = sortedSpies.every(function (spy, index) {
+            if (index + 1 === sortedSpies.length) {
+                return true;
+            }
+            var nextSpy = sortedSpies[index + 1];
+
+            // uncalled spies should be ordered first
+            if (!spy.called) {
+                return true;
+            }
+
+            return spy.calledImmediatelyBefore(nextSpy);
+        });
+
+        assert.isTrue(orderedByFirstCall);
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/README.md

@@ -0,0 +1,43 @@
+# Prototypes
+
+The functions in this folder are to be use for keeping cached references to the built-in prototypes, so that people can't inadvertently break the library by making mistakes in userland.
+
+See https://github.com/sinonjs/sinon/pull/1523
+
+## Without cached references
+
+```js
+// in userland, the library user needs to replace the filter method on
+// Array.prototype
+var array = [1, 2, 3];
+sinon.replace(array, "filter", sinon.fake.returns(2));
+
+// in a sinon module, the library author needs to use the filter method
+var someArray = ["a", "b", 42, "c"];
+var answer = filter(someArray, function (v) {
+    return v === 42;
+});
+
+console.log(answer);
+// => 2
+```
+
+## With cached references
+
+```js
+// in userland, the library user needs to replace the filter method on
+// Array.prototype
+var array = [1, 2, 3];
+sinon.replace(array, "filter", sinon.fake.returns(2));
+
+// in a sinon module, the library author needs to use the filter method
+// get a reference to the original Array.prototype.filter
+var filter = require("@sinonjs/commons").prototypes.array.filter;
+var someArray = ["a", "b", 42, "c"];
+var answer = filter(someArray, function (v) {
+    return v === 42;
+});
+
+console.log(answer);
+// => 42
+```

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/array.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype-methods");
+
+module.exports = copyPrototype(Array.prototype);

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var call = Function.call;
+var throwsOnProto = require("./throws-on-proto");
+
+var disallowedProperties = [
+    // ignore size because it throws from Map
+    "size",
+    "caller",
+    "callee",
+    "arguments",
+];
+
+// This branch is covered when tests are run with `--disable-proto=throw`,
+// however we can test both branches at the same time, so this is ignored
+/* istanbul ignore next */
+if (throwsOnProto) {
+    disallowedProperties.push("__proto__");
+}
+
+module.exports = function copyPrototypeMethods(prototype) {
+    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+    return Object.getOwnPropertyNames(prototype).reduce(function (
+        result,
+        name
+    ) {
+        if (disallowedProperties.includes(name)) {
+            return result;
+        }
+
+        if (typeof prototype[name] !== "function") {
+            return result;
+        }
+
+        result[name] = call.bind(prototype[name]);
+
+        return result;
+    },
+    Object.create(null));
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/copy-prototype-methods.test.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var refute = require("@sinonjs/referee-sinon").refute;
+var copyPrototypeMethods = require("./copy-prototype-methods");
+
+describe("copyPrototypeMethods", function () {
+    it("does not throw for Map", function () {
+        refute.exception(function () {
+            copyPrototypeMethods(Map.prototype);
+        });
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/function.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype-methods");
+
+module.exports = copyPrototype(Function.prototype);

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = {
+    array: require("./array"),
+    function: require("./function"),
+    map: require("./map"),
+    object: require("./object"),
+    set: require("./set"),
+    string: require("./string"),
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/index.test.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+
+var arrayProto = require("./index").array;
+var functionProto = require("./index").function;
+var mapProto = require("./index").map;
+var objectProto = require("./index").object;
+var setProto = require("./index").set;
+var stringProto = require("./index").string;
+var throwsOnProto = require("./throws-on-proto");
+
+describe("prototypes", function () {
+    describe(".array", function () {
+        // eslint-disable-next-line mocha/no-setup-in-describe
+        verifyProperties(arrayProto, Array);
+    });
+    describe(".function", function () {
+        // eslint-disable-next-line mocha/no-setup-in-describe
+        verifyProperties(functionProto, Function);
+    });
+    describe(".map", function () {
+        // eslint-disable-next-line mocha/no-setup-in-describe
+        verifyProperties(mapProto, Map);
+    });
+    describe(".object", function () {
+        // eslint-disable-next-line mocha/no-setup-in-describe
+        verifyProperties(objectProto, Object);
+    });
+    describe(".set", function () {
+        // eslint-disable-next-line mocha/no-setup-in-describe
+        verifyProperties(setProto, Set);
+    });
+    describe(".string", function () {
+        // eslint-disable-next-line mocha/no-setup-in-describe
+        verifyProperties(stringProto, String);
+    });
+});
+
+function verifyProperties(p, origin) {
+    var disallowedProperties = ["size", "caller", "callee", "arguments"];
+    if (throwsOnProto) {
+        disallowedProperties.push("__proto__");
+    }
+
+    it("should have all the methods of the origin prototype", function () {
+        var methodNames = Object.getOwnPropertyNames(origin.prototype).filter(
+            function (name) {
+                if (disallowedProperties.includes(name)) {
+                    return false;
+                }
+
+                return typeof origin.prototype[name] === "function";
+            }
+        );
+
+        methodNames.forEach(function (name) {
+            assert.isTrue(Object.prototype.hasOwnProperty.call(p, name), name);
+        });
+    });
+}

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/map.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype-methods");
+
+module.exports = copyPrototype(Map.prototype);

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/object.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype-methods");
+
+module.exports = copyPrototype(Object.prototype);

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/set.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype-methods");
+
+module.exports = copyPrototype(Set.prototype);

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/string.js

@@ -0,0 +1,5 @@
+"use strict";
+
+var copyPrototype = require("./copy-prototype-methods");
+
+module.exports = copyPrototype(String.prototype);

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/prototypes/throws-on-proto.js

@@ -0,0 +1,24 @@
+"use strict";
+
+/**
+ * Is true when the environment causes an error to be thrown for accessing the
+ * __proto__ property.
+ * This is necessary in order to support `node --disable-proto=throw`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
+ * @type {boolean}
+ */
+let throwsOnProto;
+try {
+    const object = {};
+    // eslint-disable-next-line no-proto, no-unused-expressions
+    object.__proto__;
+    throwsOnProto = false;
+} catch (_) {
+    // This branch is covered when tests are run with `--disable-proto=throw`,
+    // however we can test both branches at the same time, so this is ignored
+    /* istanbul ignore next */
+    throwsOnProto = true;
+}
+
+module.exports = throwsOnProto;

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/type-of.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var type = require("type-detect");
+
+/**
+ * Returns the lower-case result of running type from type-detect on the value
+ * @param  {*} value
+ * @returns {string}
+ */
+module.exports = function typeOf(value) {
+    return type(value).toLowerCase();
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/type-of.test.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var typeOf = require("./type-of");
+
+describe("typeOf", function () {
+    it("returns boolean", function () {
+        assert.equals(typeOf(false), "boolean");
+    });
+
+    it("returns string", function () {
+        assert.equals(typeOf("Sinon.JS"), "string");
+    });
+
+    it("returns number", function () {
+        assert.equals(typeOf(123), "number");
+    });
+
+    it("returns object", function () {
+        assert.equals(typeOf({}), "object");
+    });
+
+    it("returns function", function () {
+        assert.equals(
+            typeOf(function () {
+                return undefined;
+            }),
+            "function"
+        );
+    });
+
+    it("returns undefined", function () {
+        assert.equals(typeOf(undefined), "undefined");
+    });
+
+    it("returns null", function () {
+        assert.equals(typeOf(null), "null");
+    });
+
+    it("returns array", function () {
+        assert.equals(typeOf([]), "array");
+    });
+
+    it("returns regexp", function () {
+        assert.equals(typeOf(/.*/), "regexp");
+    });
+
+    it("returns date", function () {
+        assert.equals(typeOf(new Date()), "date");
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/value-to-string.js

@@ -0,0 +1,16 @@
+"use strict";
+
+/**
+ * Returns a string representation of the value
+ * @param  {*} value
+ * @returns {string}
+ */
+function valueToString(value) {
+    if (value && value.toString) {
+        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods
+        return value.toString();
+    }
+    return String(value);
+}
+
+module.exports = valueToString;

quixzoom-token-system/api/node_modules/@sinonjs/commons/lib/value-to-string.test.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var assert = require("@sinonjs/referee-sinon").assert;
+var valueToString = require("./value-to-string");
+
+describe("util/core/valueToString", function () {
+    it("returns string representation of an object", function () {
+        var obj = {};
+
+        assert.equals(valueToString(obj), obj.toString());
+    });
+
+    it("returns 'null' for literal null'", function () {
+        assert.equals(valueToString(null), "null");
+    });
+
+    it("returns 'undefined' for literal undefined", function () {
+        assert.equals(valueToString(undefined), "undefined");
+    });
+});

quixzoom-token-system/api/node_modules/@sinonjs/commons/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@sinonjs/commons",
+  "version": "3.0.1",
+  "description": "Simple functions shared among the sinon end user libraries",
+  "main": "lib/index.js",
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "build": "rm -rf types && tsc",
+    "lint": "eslint .",
+    "precommit": "lint-staged",
+    "test": "mocha --recursive -R dot \"lib/**/*.test.js\"",
+    "test-check-coverage": "npm run test-coverage && nyc check-coverage --branches 100 --functions 100 --lines 100",
+    "test-coverage": "nyc --reporter text --reporter html --reporter lcovonly npm run test",
+    "prepublishOnly": "npm run build",
+    "prettier:check": "prettier --check '**/*.{js,css,md}'",
+    "prettier:write": "prettier --write '**/*.{js,css,md}'",
+    "preversion": "npm run test-check-coverage",
+    "version": "changes --commits --footer",
+    "postversion": "git push --follow-tags && npm publish",
+    "prepare": "husky install"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sinonjs/commons.git"
+  },
+  "files": [
+    "lib",
+    "types"
+  ],
+  "author": "",
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/sinonjs/commons/issues"
+  },
+  "homepage": "https://github.com/sinonjs/commons#readme",
+  "lint-staged": {
+    "*.{js,css,md}": "prettier --check",
+    "*.js": "eslint"
+  },
+  "devDependencies": {
+    "@sinonjs/eslint-config": "^4.0.6",
+    "@sinonjs/eslint-plugin-no-prototype-methods": "^0.1.0",
+    "@sinonjs/referee-sinon": "^10.1.0",
+    "@studio/changes": "^2.2.0",
+    "husky": "^6.0.0",
+    "jsverify": "0.8.4",
+    "knuth-shuffle": "^1.0.8",
+    "lint-staged": "^13.0.3",
+    "mocha": "^10.1.0",
+    "nyc": "^15.1.0",
+    "prettier": "^2.7.1",
+    "typescript": "^4.8.4"
+  },
+  "dependencies": {
+    "type-detect": "4.0.8"
+  }
+}

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/called-in-order.d.ts

@@ -0,0 +1,34 @@
+export = calledInOrder;
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ * @typedef {object} SinonProxy
+ * @property {Function} calledBefore - A method that determines if this proxy was called before another one
+ * @property {string} id - Some id
+ * @property {number} callCount - Number of times this proxy has been called
+ */
+/**
+ * Returns true when the spies have been called in the order they were supplied in
+ * @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
+ * @returns {boolean} true when spies are called in order, false otherwise
+ */
+declare function calledInOrder(spies: SinonProxy[] | SinonProxy, ...args: any[]): boolean;
+declare namespace calledInOrder {
+    export { SinonProxy };
+}
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ */
+type SinonProxy = {
+    /**
+     * - A method that determines if this proxy was called before another one
+     */
+    calledBefore: Function;
+    /**
+     * - Some id
+     */
+    id: string;
+    /**
+     * - Number of times this proxy has been called
+     */
+    callCount: number;
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/class-name.d.ts

@@ -0,0 +1,7 @@
+export = className;
+/**
+ * Returns a display name for a value from a constructor
+ * @param  {object} value A value to examine
+ * @returns {(string|null)} A string or null
+ */
+declare function className(value: object): (string | null);

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/deprecated.d.ts

@@ -0,0 +1,3 @@
+export function wrap(func: Function, msg: string): Function;
+export function defaultMsg(packageName: string, funcName: string): string;
+export function printWarning(msg: string): undefined;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/every.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(obj: object, fn: Function): boolean;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/function-name.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(func: Function): string;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/global.d.ts

@@ -0,0 +1,6 @@
+export = globalObject;
+/**
+ * A reference to the global object
+ * @type {object} globalObject
+ */
+declare var globalObject: object;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/index.d.ts

@@ -0,0 +1,17 @@
+export const global: any;
+export const calledInOrder: typeof import("./called-in-order");
+export const className: typeof import("./class-name");
+export const deprecated: typeof import("./deprecated");
+export const every: (obj: any, fn: Function) => boolean;
+export const functionName: (func: Function) => string;
+export const orderByFirstCall: typeof import("./order-by-first-call");
+export const prototypes: {
+    array: any;
+    function: any;
+    map: any;
+    object: any;
+    set: any;
+    string: any;
+};
+export const typeOf: (value: any) => string;
+export const valueToString: typeof import("./value-to-string");

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/order-by-first-call.d.ts

@@ -0,0 +1,24 @@
+export = orderByFirstCall;
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ * @typedef {object} SinonProxy
+ * @property {Function} getCall - A method that can return the first call
+ */
+/**
+ * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
+ * @param  {SinonProxy[] | SinonProxy} spies
+ * @returns {SinonProxy[]}
+ */
+declare function orderByFirstCall(spies: SinonProxy[] | SinonProxy): SinonProxy[];
+declare namespace orderByFirstCall {
+    export { SinonProxy };
+}
+/**
+ * A Sinon proxy object (fake, spy, stub)
+ */
+type SinonProxy = {
+    /**
+     * - A method that can return the first call
+     */
+    getCall: Function;
+};

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/array.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/copy-prototype-methods.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(prototype: any): any;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/function.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/index.d.ts

@@ -0,0 +1,7 @@
+export declare const array: any;
+declare const _function: any;
+export { _function as function };
+export declare const map: any;
+export declare const object: any;
+export declare const set: any;
+export declare const string: any;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/map.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/object.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/set.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/string.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/prototypes/throws-on-proto.d.ts

@@ -0,0 +1,10 @@
+export = throwsOnProto;
+/**
+ * Is true when the environment causes an error to be thrown for accessing the
+ * __proto__ property.
+ * This is necessary in order to support `node --disable-proto=throw`.
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
+ * @type {boolean}
+ */
+declare let throwsOnProto: boolean;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/type-of.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(value: any): string;
+export = _exports;

quixzoom-token-system/api/node_modules/@sinonjs/commons/types/value-to-string.d.ts

@@ -0,0 +1,7 @@
+export = valueToString;
+/**
+ * Returns a string representation of the value
+ * @param  {*} value
+ * @returns {string}
+ */
+declare function valueToString(value: any): string;

quixzoom-token-system/api/node_modules/@sinonjs/fake-timers/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2010-2014, Christian Johansen, christian@cjohansen.no. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

quixzoom-token-system/api/node_modules/@sinonjs/fake-timers/README.md

@@ -0,0 +1,358 @@
+# `@sinonjs/fake-timers`
+
+[![codecov](https://codecov.io/gh/sinonjs/fake-timers/branch/main/graph/badge.svg)](https://codecov.io/gh/sinonjs/fake-timers)
+<a href="CODE_OF_CONDUCT.md"><img src="https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg" alt="Contributor Covenant" /></a>
+
+JavaScript implementation of the timer APIs; `setTimeout`, `clearTimeout`, `setImmediate`, `clearImmediate`, `setInterval`, `clearInterval`, `requestAnimationFrame`, `cancelAnimationFrame`, `requestIdleCallback`, and `cancelIdleCallback`, along with a clock instance that controls the flow of time. FakeTimers also provides a `Date` implementation that gets its time from the clock.
+
+In addition in browser environment `@sinonjs/fake-timers` provides a `performance` implementation that gets its time from the clock. In Node environments FakeTimers provides a `nextTick` implementation that is synchronized with the clock - and a `process.hrtime` shim that works with the clock.
+
+`@sinonjs/fake-timers` can be used to simulate passing time in automated tests and other
+situations where you want the scheduling semantics, but don't want to actually
+wait.
+
+`@sinonjs/fake-timers` is extracted from [Sinon.JS](https://github.com/sinonjs/sinon.js) and targets the [same runtimes](https://sinonjs.org/releases/latest/#supported-runtimes).
+
+## Autocomplete, IntelliSense and TypeScript definitions
+
+Version 7 introduced JSDoc to the codebase. This should provide autocomplete and type suggestions in supporting IDEs. If you need more elaborate type support, TypeScript definitions for the Sinon projects are independently maintained by the Definitely Types community:
+
+```
+npm install -D @types/sinonjs__fake-timers
+```
+
+## Installation
+
+`@sinonjs/fake-timers` can be used in both Node and browser environments. Installation is as easy as
+
+```sh
+npm install @sinonjs/fake-timers
+```
+
+If you want to use `@sinonjs/fake-timers` in a browser you can either build your own bundle or use [Skypack](https://www.skypack.dev).
+
+## Usage
+
+To use `@sinonjs/fake-timers`, create a new clock, schedule events on it using the timer
+functions and pass time using the `tick` method.
+
+```js
+// In the browser distribution, a global `FakeTimers` is already available
+var FakeTimers = require("@sinonjs/fake-timers");
+var clock = FakeTimers.createClock();
+
+clock.setTimeout(function () {
+    console.log(
+        "The poblano is a mild chili pepper originating in the state of Puebla, Mexico."
+    );
+}, 15);
+
+// ...
+
+clock.tick(15);
+```
+
+Upon executing the last line, an interesting fact about the
+[Poblano](https://en.wikipedia.org/wiki/Poblano) will be printed synchronously to
+the screen. If you want to simulate asynchronous behavior, please see the `async` function variants (eg `clock.tick(time)` vs `await clock.tickAsync(time)`).
+
+The `next`, `runAll`, `runToFrame`, and `runToLast` methods are available to advance the clock. See the
+API Reference for more details.
+
+### Faking the native timers
+
+When using `@sinonjs/fake-timers` to test timers, you will most likely want to replace the native
+timers such that calling `setTimeout` actually schedules a callback with your
+clock instance, not the browser's internals.
+
+Calling `install` with no arguments achieves this. You can call `uninstall`
+later to restore things as they were again.
+
+```js
+// In the browser distribution, a global `FakeTimers` is already available
+var FakeTimers = require("@sinonjs/fake-timers");
+
+var clock = FakeTimers.install();
+// Equivalent to
+// var clock = FakeTimers.install(typeof global !== "undefined" ? global : window);
+
+setTimeout(fn, 15); // Schedules with clock.setTimeout
+
+clock.uninstall();
+// setTimeout is restored to the native implementation
+```
+
+To hijack timers in another context pass it to the `install` method.
+
+```js
+var FakeTimers = require("@sinonjs/fake-timers");
+var context = {
+    setTimeout: setTimeout, // By default context.setTimeout uses the global setTimeout
+};
+var clock = FakeTimers.withGlobal(context).install();
+
+context.setTimeout(fn, 15); // Schedules with clock.setTimeout
+
+clock.uninstall();
+// context.setTimeout is restored to the original implementation
+```
+
+Usually you want to install the timers onto the global object, so call `install`
+without arguments.
+
+#### Automatically incrementing mocked time
+
+FakeTimers supports the possibility to attach the faked timers to any change
+in the real system time. This means that there is no need to `tick()` the
+clock in a situation where you won't know **when** to call `tick()`.
+
+Please note that this is achieved using the original setImmediate() API at a certain
+configurable interval `config.advanceTimeDelta` (default: 20ms). Meaning time would
+be incremented every 20ms, not in real time.
+
+An example would be:
+
+```js
+var FakeTimers = require("@sinonjs/fake-timers");
+var clock = FakeTimers.install({
+    shouldAdvanceTime: true,
+    advanceTimeDelta: 40,
+});
+
+setTimeout(() => {
+    console.log("this just timed out"); //executed after 40ms
+}, 30);
+
+setImmediate(() => {
+    console.log("not so immediate"); //executed after 40ms
+});
+
+setTimeout(() => {
+    console.log("this timed out after"); //executed after 80ms
+    clock.uninstall();
+}, 50);
+```
+
+## API Reference
+
+### `var clock = FakeTimers.createClock([now[, loopLimit]])`
+
+Creates a clock. The default
+[epoch](https://en.wikipedia.org/wiki/Epoch_%28reference_date%29) is `0`.
+
+The `now` argument may be a number (in milliseconds) or a Date object.
+
+The `loopLimit` argument sets the maximum number of timers that will be run when calling `runAll()` before assuming that we have an infinite loop and throwing an error. The default is `1000`.
+
+### `var clock = FakeTimers.install([config])`
+
+Installs FakeTimers using the specified config (otherwise with epoch `0` on the global scope). The following configuration options are available
+
+| Parameter                        | Type        | Default                                                                                                                                                                                                                        | Description                                                                                                                                                                                                                                                                                  |
+| -------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `config.now`                     | Number/Date | 0                                                                                                                                                                                                                              | installs FakeTimers with the specified unix epoch                                                                                                                                                                                                                                            |
+| `config.toFake`                  | String[]    | ["setTimeout", "clearTimeout", "setImmediate", "clearImmediate","setInterval", "clearInterval", "Date", "requestAnimationFrame", "cancelAnimationFrame", "requestIdleCallback", "cancelIdleCallback", "hrtime", "performance"] | an array with explicit function names (or objects, in the case of "performance") to hijack. _When not set, FakeTimers will automatically fake all methods **except** `nextTick`_ e.g., `FakeTimers.install({ toFake: ["setTimeout","nextTick"]})` will fake only `setTimeout` and `nextTick` |
+| `config.loopLimit`               | Number      | 1000                                                                                                                                                                                                                           | the maximum number of timers that will be run when calling runAll()                                                                                                                                                                                                                          |
+| `config.shouldAdvanceTime`       | Boolean     | false                                                                                                                                                                                                                          | tells FakeTimers to increment mocked time automatically based on the real system time shift (e.g. the mocked time will be incremented by 20ms for every 20ms change in the real system time)                                                                                                 |
+| `config.advanceTimeDelta`        | Number      | 20                                                                                                                                                                                                                             | relevant only when using with `shouldAdvanceTime: true`. increment mocked time by `advanceTimeDelta` ms every `advanceTimeDelta` ms change in the real system time.                                                                                                                          |
+| `config.shouldClearNativeTimers` | Boolean     | false                                                                                                                                                                                                                          | tells FakeTimers to clear 'native' (i.e. not fake) timers by delegating to their respective handlers. These are not cleared by default, leading to potentially unexpected behavior if timers existed prior to installing FakeTimers.                                                         |
+
+### `var id = clock.setTimeout(callback, timeout)`
+
+Schedules the callback to be fired once `timeout` milliseconds have ticked by.
+
+In Node.js `setTimeout` returns a timer object. FakeTimers will do the same, however
+its `ref()` and `unref()` methods have no effect.
+
+In browsers a timer ID is returned.
+
+### `clock.clearTimeout(id)`
+
+Clears the timer given the ID or timer object, as long as it was created using
+`setTimeout`.
+
+### `var id = clock.setInterval(callback, timeout)`
+
+Schedules the callback to be fired every time `timeout` milliseconds have ticked
+by.
+
+In Node.js `setInterval` returns a timer object. FakeTimers will do the same, however
+its `ref()` and `unref()` methods have no effect.
+
+In browsers a timer ID is returned.
+
+### `clock.clearInterval(id)`
+
+Clears the timer given the ID or timer object, as long as it was created using
+`setInterval`.
+
+### `var id = clock.setImmediate(callback)`
+
+Schedules the callback to be fired once `0` milliseconds have ticked by. Note
+that you'll still have to call `clock.tick()` for the callback to fire. If
+called during a tick the callback won't fire until `1` millisecond has ticked
+by.
+
+In Node.js `setImmediate` returns a timer object. FakeTimers will do the same,
+however its `ref()` and `unref()` methods have no effect.
+
+In browsers a timer ID is returned.
+
+### `clock.clearImmediate(id)`
+
+Clears the timer given the ID or timer object, as long as it was created using
+`setImmediate`.
+
+### `clock.requestAnimationFrame(callback)`
+
+Schedules the callback to be fired on the next animation frame, which runs every
+16 ticks. Returns an `id` which can be used to cancel the callback. This is
+available in both browser & node environments.
+
+### `clock.cancelAnimationFrame(id)`
+
+Cancels the callback scheduled by the provided id.
+
+### `clock.requestIdleCallback(callback[, timeout])`
+
+Queued the callback to be fired during idle periods to perform background and low priority work on the main event loop. Callbacks which have a timeout option will be fired no later than time in milliseconds. Returns an `id` which can be used to cancel the callback.
+
+### `clock.cancelIdleCallback(id)`
+
+Cancels the callback scheduled by the provided id.
+
+### `clock.countTimers()`
+
+Returns the number of waiting timers. This can be used to assert that a test
+finishes without leaking any timers.
+
+### `clock.hrtime(prevTime?)`
+
+Only available in Node.js, mimicks process.hrtime().
+
+### `clock.nextTick(callback)`
+
+Only available in Node.js, mimics `process.nextTick` to enable completely synchronous testing flows.
+
+### `clock.performance.now()`
+
+Only available in browser environments, mimicks performance.now().
+
+### `clock.tick(time)` / `await clock.tickAsync(time)`
+
+Advance the clock, firing callbacks if necessary. `time` may be the number of
+milliseconds to advance the clock by or a human-readable string. Valid string
+formats are `"08"` for eight seconds, `"01:00"` for one minute and `"02:34:10"`
+for two hours, 34 minutes and ten seconds.
+
+The `tickAsync()` will also break the event loop, allowing any scheduled promise
+callbacks to execute _before_ running the timers.
+
+### `clock.next()` / `await clock.nextAsync()`
+
+Advances the clock to the the moment of the first scheduled timer, firing it.
+
+The `nextAsync()` will also break the event loop, allowing any scheduled promise
+callbacks to execute _before_ running the timers.
+
+### `clock.jump(time)`
+
+Advance the clock by jumping forward in time, firing callbacks at most once.
+`time` takes the same formats as [`clock.tick`](#clockticktime--await-clocktickasynctime).
+
+This can be used to simulate the JS engine (such as a browser) being put to sleep and resumed later, skipping intermediary timers.
+
+### `clock.reset()`
+
+Removes all timers and ticks without firing them, and sets `now` to `config.now`
+that was provided to `FakeTimers.install` or to `0` if `config.now` was not provided.
+Useful to reset the state of the clock without having to `uninstall` and `install` it.
+
+### `clock.runAll()` / `await clock.runAllAsync()`
+
+This runs all pending timers until there are none remaining. If new timers are added while it is executing they will be run as well.
+
+This makes it easier to run asynchronous tests to completion without worrying about the number of timers they use, or the delays in those timers.
+
+It runs a maximum of `loopLimit` times after which it assumes there is an infinite loop of timers and throws an error.
+
+The `runAllAsync()` will also break the event loop, allowing any scheduled promise
+callbacks to execute _before_ running the timers.
+
+### `clock.runMicrotasks()`
+
+This runs all pending microtasks scheduled with `nextTick` but none of the timers and is mostly useful for libraries using FakeTimers underneath and for running `nextTick` items without any timers.
+
+### `clock.runToFrame()`
+
+Advances the clock to the next frame, firing all scheduled animation frame callbacks,
+if any, for that frame as well as any other timers scheduled along the way.
+
+### `clock.runToLast()` / `await clock.runToLastAsync()`
+
+This takes note of the last scheduled timer when it is run, and advances the
+clock to that time firing callbacks as necessary.
+
+If new timers are added while it is executing they will be run only if they
+would occur before this time.
+
+This is useful when you want to run a test to completion, but the test recursively
+sets timers that would cause `runAll` to trigger an infinite loop warning.
+
+The `runToLastAsync()` will also break the event loop, allowing any scheduled promise
+callbacks to execute _before_ running the timers.
+
+### `clock.setSystemTime([now])`
+
+This simulates a user changing the system clock while your program is running.
+It affects the current time but it does not in itself cause e.g. timers to fire;
+they will fire exactly as they would have done without the call to
+setSystemTime().
+
+### `clock.uninstall()`
+
+Restores the original methods of the native timers or the methods on the object
+that was passed to `FakeTimers.withGlobal`
+
+### `Date`
+
+Implements the `Date` object but using the clock to provide the correct time.
+
+### `Performance`
+
+Implements the `now` method of the [`Performance`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) object but using the clock to provide the correct time. Only available in environments that support the Performance object (browsers mostly).
+
+### `FakeTimers.withGlobal`
+
+In order to support creating clocks based on separate or sandboxed environments (such as JSDOM), FakeTimers exports a factory method which takes single argument `global`, which it inspects to figure out what to mock and what features to support. When invoking this function with a global, you will get back an object with `timers`, `createClock` and `install` - same as the regular FakeTimers exports only based on the passed in global instead of the global environment.
+
+## Running tests
+
+FakeTimers has a comprehensive test suite. If you're thinking of contributing bug
+fixes or suggesting new features, you need to make sure you have not broken any
+tests. You are also expected to add tests for any new behavior.
+
+### On node:
+
+```sh
+npm test
+```
+
+Or, if you prefer more verbose output:
+
+```
+$(npm bin)/mocha ./test/fake-timers-test.js
+```
+
+### In the browser
+
+[Mochify](https://github.com/mantoni/mochify.js) is used to run the tests in
+PhantomJS. Make sure you have `phantomjs` installed. Then:
+
+```sh
+npm test-headless
+```
+
+## License
+
+BSD 3-clause "New" or "Revised" License (see LICENSE file)

quixzoom-token-system/api/node_modules/@sinonjs/fake-timers/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@sinonjs/fake-timers",
+  "description": "Fake JavaScript timers",
+  "version": "10.3.0",
+  "homepage": "https://github.com/sinonjs/fake-timers",
+  "author": "Christian Johansen",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sinonjs/fake-timers.git"
+  },
+  "bugs": {
+    "mail": "christian@cjohansen.no",
+    "url": "https://github.com/sinonjs/fake-timers/issues"
+  },
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "lint": "eslint .",
+    "test-node": "mocha --timeout 200 test/ integration-test/ -R dot --check-leaks",
+    "test-headless": "mochify --no-detect-globals --timeout=10000",
+    "test-check-coverage": "npm run test-coverage && nyc check-coverage",
+    "test-cloud": "mochify --wd --no-detect-globals --timeout=10000",
+    "test-coverage": "nyc --all --reporter text --reporter html --reporter lcovonly npm run test-node",
+    "test": "npm run test-node && npm run test-headless",
+    "prettier:check": "prettier --check '**/*.{js,css,md}'",
+    "prettier:write": "prettier --write '**/*.{js,css,md}'",
+    "preversion": "./scripts/preversion.sh",
+    "version": "./scripts/version.sh",
+    "postversion": "./scripts/postversion.sh",
+    "prepare": "husky install"
+  },
+  "lint-staged": {
+    "*.{js,css,md}": "prettier --check",
+    "*.js": "eslint"
+  },
+  "files": [
+    "src/"
+  ],
+  "devDependencies": {
+    "@sinonjs/eslint-config": "^4.1.0",
+    "@sinonjs/referee-sinon": "11.0.0",
+    "husky": "^8.0.3",
+    "jsdom": "22.0.0",
+    "lint-staged": "13.2.2",
+    "mocha": "10.2.0",
+    "mochify": "9.2.0",
+    "nyc": "15.1.0",
+    "prettier": "2.8.8"
+  },
+  "main": "./src/fake-timers-src.js",
+  "dependencies": {
+    "@sinonjs/commons": "^3.0.0"
+  },
+  "nyc": {
+    "branches": 85,
+    "lines": 92,
+    "functions": 92,
+    "statements": 92,
+    "exclude": [
+      "**/*-test.js",
+      "coverage/**",
+      "types/**",
+      "fake-timers.js"
+    ]
+  }
+}

quixzoom-token-system/api/node_modules/@sinonjs/fake-timers/src/fake-timers-src.js

@@ -0,0 +1,1787 @@
+"use strict";
+
+const globalObject = require("@sinonjs/commons").global;
+
+/**
+ * @typedef {object} IdleDeadline
+ * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
+ * @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period
+ */
+
+/**
+ * Queues a function to be called during a browser's idle periods
+ *
+ * @callback RequestIdleCallback
+ * @param {function(IdleDeadline)} callback
+ * @param {{timeout: number}} options - an options object
+ * @returns {number} the id
+ */
+
+/**
+ * @callback NextTick
+ * @param {VoidVarArgsFunc} callback - the callback to run
+ * @param {...*} arguments - optional arguments to call the callback with
+ * @returns {void}
+ */
+
+/**
+ * @callback SetImmediate
+ * @param {VoidVarArgsFunc} callback - the callback to run
+ * @param {...*} arguments - optional arguments to call the callback with
+ * @returns {NodeImmediate}
+ */
+
+/**
+ * @callback VoidVarArgsFunc
+ * @param {...*} callback - the callback to run
+ * @returns {void}
+ */
+
+/**
+ * @typedef RequestAnimationFrame
+ * @property {function(number):void} requestAnimationFrame
+ * @returns {number} - the id
+ */
+
+/**
+ * @typedef Performance
+ * @property {function(): number} now
+ */
+
+/* eslint-disable jsdoc/require-property-description */
+/**
+ * @typedef {object} Clock
+ * @property {number} now - the current time
+ * @property {Date} Date - the Date constructor
+ * @property {number} loopLimit - the maximum number of timers before assuming an infinite loop
+ * @property {RequestIdleCallback} requestIdleCallback
+ * @property {function(number):void} cancelIdleCallback
+ * @property {setTimeout} setTimeout
+ * @property {clearTimeout} clearTimeout
+ * @property {NextTick} nextTick
+ * @property {queueMicrotask} queueMicrotask
+ * @property {setInterval} setInterval
+ * @property {clearInterval} clearInterval
+ * @property {SetImmediate} setImmediate
+ * @property {function(NodeImmediate):void} clearImmediate
+ * @property {function():number} countTimers
+ * @property {RequestAnimationFrame} requestAnimationFrame
+ * @property {function(number):void} cancelAnimationFrame
+ * @property {function():void} runMicrotasks
+ * @property {function(string | number): number} tick
+ * @property {function(string | number): Promise<number>} tickAsync
+ * @property {function(): number} next
+ * @property {function(): Promise<number>} nextAsync
+ * @property {function(): number} runAll
+ * @property {function(): number} runToFrame
+ * @property {function(): Promise<number>} runAllAsync
+ * @property {function(): number} runToLast
+ * @property {function(): Promise<number>} runToLastAsync
+ * @property {function(): void} reset
+ * @property {function(number | Date): void} setSystemTime
+ * @property {function(number): void} jump
+ * @property {Performance} performance
+ * @property {function(number[]): number[]} hrtime - process.hrtime (legacy)
+ * @property {function(): void} uninstall Uninstall the clock.
+ * @property {Function[]} methods - the methods that are faked
+ * @property {boolean} [shouldClearNativeTimers] inherited from config
+ */
+/* eslint-enable jsdoc/require-property-description */
+
+/**
+ * Configuration object for the `install` method.
+ *
+ * @typedef {object} Config
+ * @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)
+ * @property {string[]} [toFake] names of the methods that should be faked.
+ * @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll()
+ * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)
+ * @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)
+ * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)
+ */
+
+/* eslint-disable jsdoc/require-property-description */
+/**
+ * The internal structure to describe a scheduled fake timer
+ *
+ * @typedef {object} Timer
+ * @property {Function} func
+ * @property {*[]} args
+ * @property {number} delay
+ * @property {number} callAt
+ * @property {number} createdAt
+ * @property {boolean} immediate
+ * @property {number} id
+ * @property {Error} [error]
+ */
+
+/**
+ * A Node timer
+ *
+ * @typedef {object} NodeImmediate
+ * @property {function(): boolean} hasRef
+ * @property {function(): NodeImmediate} ref
+ * @property {function(): NodeImmediate} unref
+ */
+/* eslint-enable jsdoc/require-property-description */
+
+/* eslint-disable complexity */
+
+/**
+ * Mocks available features in the specified global namespace.
+ *
+ * @param {*} _global Namespace to mock (e.g. `window`)
+ * @returns {FakeTimers}
+ */
+function withGlobal(_global) {
+    const userAgent = _global.navigator && _global.navigator.userAgent;
+    const isRunningInIE = userAgent && userAgent.indexOf("MSIE ") > -1;
+    const maxTimeout = Math.pow(2, 31) - 1; //see https://heycam.github.io/webidl/#abstract-opdef-converttoint
+    const idCounterStart = 1e12; // arbitrarily large number to avoid collisions with native timer IDs
+    const NOOP = function () {
+        return undefined;
+    };
+    const NOOP_ARRAY = function () {
+        return [];
+    };
+    const timeoutResult = _global.setTimeout(NOOP, 0);
+    const addTimerReturnsObject = typeof timeoutResult === "object";
+    const hrtimePresent =
+        _global.process && typeof _global.process.hrtime === "function";
+    const hrtimeBigintPresent =
+        hrtimePresent && typeof _global.process.hrtime.bigint === "function";
+    const nextTickPresent =
+        _global.process && typeof _global.process.nextTick === "function";
+    const utilPromisify = _global.process && require("util").promisify;
+    const performancePresent =
+        _global.performance && typeof _global.performance.now === "function";
+    const hasPerformancePrototype =
+        _global.Performance &&
+        (typeof _global.Performance).match(/^(function|object)$/);
+    const hasPerformanceConstructorPrototype =
+        _global.performance &&
+        _global.performance.constructor &&
+        _global.performance.constructor.prototype;
+    const queueMicrotaskPresent = _global.hasOwnProperty("queueMicrotask");
+    const requestAnimationFramePresent =
+        _global.requestAnimationFrame &&
+        typeof _global.requestAnimationFrame === "function";
+    const cancelAnimationFramePresent =
+        _global.cancelAnimationFrame &&
+        typeof _global.cancelAnimationFrame === "function";
+    const requestIdleCallbackPresent =
+        _global.requestIdleCallback &&
+        typeof _global.requestIdleCallback === "function";
+    const cancelIdleCallbackPresent =
+        _global.cancelIdleCallback &&
+        typeof _global.cancelIdleCallback === "function";
+    const setImmediatePresent =
+        _global.setImmediate && typeof _global.setImmediate === "function";
+
+    // Make properties writable in IE, as per
+    // https://www.adequatelygood.com/Replacing-setTimeout-Globally.html
+    /* eslint-disable no-self-assign */
+    if (isRunningInIE) {
+        _global.setTimeout = _global.setTimeout;
+        _global.clearTimeout = _global.clearTimeout;
+        _global.setInterval = _global.setInterval;
+        _global.clearInterval = _global.clearInterval;
+        _global.Date = _global.Date;
+    }
+
+    // setImmediate is not a standard function
+    // avoid adding the prop to the window object if not present
+    if (setImmediatePresent) {
+        _global.setImmediate = _global.setImmediate;
+        _global.clearImmediate = _global.clearImmediate;
+    }
+    /* eslint-enable no-self-assign */
+
+    _global.clearTimeout(timeoutResult);
+
+    const NativeDate = _global.Date;
+    let uniqueTimerId = idCounterStart;
+
+    /**
+     * @param {number} num
+     * @returns {boolean}
+     */
+    function isNumberFinite(num) {
+        if (Number.isFinite) {
+            return Number.isFinite(num);
+        }
+
+        return isFinite(num);
+    }
+
+    let isNearInfiniteLimit = false;
+
+    /**
+     * @param {Clock} clock
+     * @param {number} i
+     */
+    function checkIsNearInfiniteLimit(clock, i) {
+        if (clock.loopLimit && i === clock.loopLimit - 1) {
+            isNearInfiniteLimit = true;
+        }
+    }
+
+    /**
+     *
+     */
+    function resetIsNearInfiniteLimit() {
+        isNearInfiniteLimit = false;
+    }
+
+    /**
+     * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into
+     * number of milliseconds. This is used to support human-readable strings passed
+     * to clock.tick()
+     *
+     * @param {string} str
+     * @returns {number}
+     */
+    function parseTime(str) {
+        if (!str) {
+            return 0;
+        }
+
+        const strings = str.split(":");
+        const l = strings.length;
+        let i = l;
+        let ms = 0;
+        let parsed;
+
+        if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+            throw new Error(
+                "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
+            );
+        }
+
+        while (i--) {
+            parsed = parseInt(strings[i], 10);
+
+            if (parsed >= 60) {
+                throw new Error(`Invalid time ${str}`);
+            }
+
+            ms += parsed * Math.pow(60, l - i - 1);
+        }
+
+        return ms * 1000;
+    }
+
+    /**
+     * Get the decimal part of the millisecond value as nanoseconds
+     *
+     * @param {number} msFloat the number of milliseconds
+     * @returns {number} an integer number of nanoseconds in the range [0,1e6)
+     *
+     * Example: nanoRemainer(123.456789) -> 456789
+     */
+    function nanoRemainder(msFloat) {
+        const modulo = 1e6;
+        const remainder = (msFloat * 1e6) % modulo;
+        const positiveRemainder =
+            remainder < 0 ? remainder + modulo : remainder;
+
+        return Math.floor(positiveRemainder);
+    }
+
+    /**
+     * Used to grok the `now` parameter to createClock.
+     *
+     * @param {Date|number} epoch the system time
+     * @returns {number}
+     */
+    function getEpoch(epoch) {
+        if (!epoch) {
+            return 0;
+        }
+        if (typeof epoch.getTime === "function") {
+            return epoch.getTime();
+        }
+        if (typeof epoch === "number") {
+            return epoch;
+        }
+        throw new TypeError("now should be milliseconds since UNIX epoch");
+    }
+
+    /**
+     * @param {number} from
+     * @param {number} to
+     * @param {Timer} timer
+     * @returns {boolean}
+     */
+    function inRange(from, to, timer) {
+        return timer && timer.callAt >= from && timer.callAt <= to;
+    }
+
+    /**
+     * @param {Clock} clock
+     * @param {Timer} job
+     */
+    function getInfiniteLoopError(clock, job) {
+        const infiniteLoopError = new Error(
+            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`
+        );
+
+        if (!job.error) {
+            return infiniteLoopError;
+        }
+
+        // pattern never matched in Node
+        const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
+        let clockMethodPattern = new RegExp(
+            String(Object.keys(clock).join("|"))
+        );
+
+        if (addTimerReturnsObject) {
+            // node.js environment
+            clockMethodPattern = new RegExp(
+                `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`
+            );
+        }
+
+        let matchedLineIndex = -1;
+        job.error.stack.split("\n").some(function (line, i) {
+            // If we've matched a computed target line (e.g. setTimeout) then we
+            // don't need to look any further. Return true to stop iterating.
+            const matchedComputedTarget = line.match(computedTargetPattern);
+            /* istanbul ignore if */
+            if (matchedComputedTarget) {
+                matchedLineIndex = i;
+                return true;
+            }
+
+            // If we've matched a clock method line, then there may still be
+            // others further down the trace. Return false to keep iterating.
+            const matchedClockMethod = line.match(clockMethodPattern);
+            if (matchedClockMethod) {
+                matchedLineIndex = i;
+                return false;
+            }
+
+            // If we haven't matched anything on this line, but we matched
+            // previously and set the matched line index, then we can stop.
+            // If we haven't matched previously, then we should keep iterating.
+            return matchedLineIndex >= 0;
+        });
+
+        const stack = `${infiniteLoopError}\n${job.type || "Microtask"} - ${
+            job.func.name || "anonymous"
+        }\n${job.error.stack
+            .split("\n")
+            .slice(matchedLineIndex + 1)
+            .join("\n")}`;
+
+        try {
+            Object.defineProperty(infiniteLoopError, "stack", {
+                value: stack,
+            });
+        } catch (e) {
+            // noop
+        }
+
+        return infiniteLoopError;
+    }
+
+    /**
+     * @param {Date} target
+     * @param {Date} source
+     * @returns {Date} the target after modifications
+     */
+    function mirrorDateProperties(target, source) {
+        let prop;
+        for (prop in source) {
+            if (source.hasOwnProperty(prop)) {
+                target[prop] = source[prop];
+            }
+        }
+
+        // set special now implementation
+        if (source.now) {
+            target.now = function now() {
+                return target.clock.now;
+            };
+        } else {
+            delete target.now;
+        }
+
+        // set special toSource implementation
+        if (source.toSource) {
+            target.toSource = function toSource() {
+                return source.toSource();
+            };
+        } else {
+            delete target.toSource;
+        }
+
+        // set special toString implementation
+        target.toString = function toString() {
+            return source.toString();
+        };
+
+        target.prototype = source.prototype;
+        target.parse = source.parse;
+        target.UTC = source.UTC;
+        target.prototype.toUTCString = source.prototype.toUTCString;
+        target.isFake = true;
+
+        return target;
+    }
+
+    //eslint-disable-next-line jsdoc/require-jsdoc
+    function createDate() {
+        /**
+         * @param {number} year
+         * @param {number} month
+         * @param {number} date
+         * @param {number} hour
+         * @param {number} minute
+         * @param {number} second
+         * @param {number} ms
+         * @returns {Date}
+         */
+        function ClockDate(year, month, date, hour, minute, second, ms) {
+            // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.
+            // This remains so in the 10th edition of 2019 as well.
+            if (!(this instanceof ClockDate)) {
+                return new NativeDate(ClockDate.clock.now).toString();
+            }
+
+            // if Date is called as a constructor with 'new' keyword
+            // Defensive and verbose to avoid potential harm in passing
+            // explicit undefined when user does not pass argument
+            switch (arguments.length) {
+                case 0:
+                    return new NativeDate(ClockDate.clock.now);
+                case 1:
+                    return new NativeDate(year);
+                case 2:
+                    return new NativeDate(year, month);
+                case 3:
+                    return new NativeDate(year, month, date);
+                case 4:
+                    return new NativeDate(year, month, date, hour);
+                case 5:
+                    return new NativeDate(year, month, date, hour, minute);
+                case 6:
+                    return new NativeDate(
+                        year,
+                        month,
+                        date,
+                        hour,
+                        minute,
+                        second
+                    );
+                default:
+                    return new NativeDate(
+                        year,
+                        month,
+                        date,
+                        hour,
+                        minute,
+                        second,
+                        ms
+                    );
+            }
+        }
+
+        return mirrorDateProperties(ClockDate, NativeDate);
+    }
+
+    //eslint-disable-next-line jsdoc/require-jsdoc
+    function enqueueJob(clock, job) {
+        // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob
+        if (!clock.jobs) {
+            clock.jobs = [];
+        }
+        clock.jobs.push(job);
+    }
+
+    //eslint-disable-next-line jsdoc/require-jsdoc
+    function runJobs(clock) {
+        // runs all microtick-deferred tasks - ecma262/#sec-runjobs
+        if (!clock.jobs) {
+            return;
+        }
+        for (let i = 0; i < clock.jobs.length; i++) {
+            const job = clock.jobs[i];
+            job.func.apply(null, job.args);
+
+            checkIsNearInfiniteLimit(clock, i);
+            if (clock.loopLimit && i > clock.loopLimit) {
+                throw getInfiniteLoopError(clock, job);
+            }
+        }
+        resetIsNearInfiniteLimit();
+        clock.jobs = [];
+    }
+
+    /**
+     * @param {Clock} clock
+     * @param {Timer} timer
+     * @returns {number} id of the created timer
+     */
+    function addTimer(clock, timer) {
+        if (timer.func === undefined) {
+            throw new Error("Callback must be provided to timer calls");
+        }
+
+        if (addTimerReturnsObject) {
+            // Node.js environment
+            if (typeof timer.func !== "function") {
+                throw new TypeError(
+                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${
+                        timer.func
+                    } of type ${typeof timer.func}`
+                );
+            }
+        }
+
+        if (isNearInfiniteLimit) {
+            timer.error = new Error();
+        }
+
+        timer.type = timer.immediate ? "Immediate" : "Timeout";
+
+        if (timer.hasOwnProperty("delay")) {
+            if (typeof timer.delay !== "number") {
+                timer.delay = parseInt(timer.delay, 10);
+            }
+
+            if (!isNumberFinite(timer.delay)) {
+                timer.delay = 0;
+            }
+            timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
+            timer.delay = Math.max(0, timer.delay);
+        }
+
+        if (timer.hasOwnProperty("interval")) {
+            timer.type = "Interval";
+            timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
+        }
+
+        if (timer.hasOwnProperty("animation")) {
+            timer.type = "AnimationFrame";
+            timer.animation = true;
+        }
+
+        if (timer.hasOwnProperty("idleCallback")) {
+            timer.type = "IdleCallback";
+            timer.idleCallback = true;
+        }
+
+        if (!clock.timers) {
+            clock.timers = {};
+        }
+
+        timer.id = uniqueTimerId++;
+        timer.createdAt = clock.now;
+        timer.callAt =
+            clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+
+        clock.timers[timer.id] = timer;
+
+        if (addTimerReturnsObject) {
+            const res = {
+                refed: true,
+                ref: function () {
+                    this.refed = true;
+                    return res;
+                },
+                unref: function () {
+                    this.refed = false;
+                    return res;
+                },
+                hasRef: function () {
+                    return this.refed;
+                },
+                refresh: function () {
+                    timer.callAt =
+                        clock.now +
+                        (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+
+                    // it _might_ have been removed, but if not the assignment is perfectly fine
+                    clock.timers[timer.id] = timer;
+
+                    return res;
+                },
+                [Symbol.toPrimitive]: function () {
+                    return timer.id;
+                },
+            };
+            return res;
+        }
+
+        return timer.id;
+    }
+
+    /* eslint consistent-return: "off" */
+    /**
+     * Timer comparitor
+     *
+     * @param {Timer} a
+     * @param {Timer} b
+     * @returns {number}
+     */
+    function compareTimers(a, b) {
+        // Sort first by absolute timing
+        if (a.callAt < b.callAt) {
+            return -1;
+        }
+        if (a.callAt > b.callAt) {
+            return 1;
+        }
+
+        // Sort next by immediate, immediate timers take precedence
+        if (a.immediate && !b.immediate) {
+            return -1;
+        }
+        if (!a.immediate && b.immediate) {
+            return 1;
+        }
+
+        // Sort next by creation time, earlier-created timers take precedence
+        if (a.createdAt < b.createdAt) {
+            return -1;
+        }
+        if (a.createdAt > b.createdAt) {
+            return 1;
+        }
+
+        // Sort next by id, lower-id timers take precedence
+        if (a.id < b.id) {
+            return -1;
+        }
+        if (a.id > b.id) {
+            return 1;
+        }
+
+        // As timer ids are unique, no fallback `0` is necessary
+    }
+
+    /**
+     * @param {Clock} clock
+     * @param {number} from
+     * @param {number} to
+     * @returns {Timer}
+     */
+    function firstTimerInRange(clock, from, to) {
+        const timers = clock.timers;
+        let timer = null;
+        let id, isInRange;
+
+        for (id in timers) {
+            if (timers.hasOwnProperty(id)) {
+                isInRange = inRange(from, to, timers[id]);
+
+                if (
+                    isInRange &&
+                    (!timer || compareTimers(timer, timers[id]) === 1)
+                ) {
+                    timer = timers[id];
+                }
+            }
+        }
+
+        return timer;
+    }
+
+    /**
+     * @param {Clock} clock
+     * @returns {Timer}
+     */
+    function firstTimer(clock) {
+        const timers = clock.timers;
+        let timer = null;
+        let id;
+
+        for (id in timers) {
+            if (timers.hasOwnProperty(id)) {
+                if (!timer || compareTimers(timer, timers[id]) === 1) {
+                    timer = timers[id];
+                }
+            }
+        }
+
+        return timer;
+    }
+
+    /**
+     * @param {Clock} clock
+     * @returns {Timer}
+     */
+    function lastTimer(clock) {
+        const timers = clock.timers;
+        let timer = null;
+        let id;
+
+        for (id in timers) {
+            if (timers.hasOwnProperty(id)) {
+                if (!timer || compareTimers(timer, timers[id]) === -1) {
+                    timer = timers[id];
+                }
+            }
+        }
+
+        return timer;
+    }
+
+    /**
+     * @param {Clock} clock
+     * @param {Timer} timer
+     */
+    function callTimer(clock, timer) {
+        if (typeof timer.interval === "number") {
+            clock.timers[timer.id].callAt += timer.interval;
+        } else {
+            delete clock.timers[timer.id];
+        }
+
+        if (typeof timer.func === "function") {
+            timer.func.apply(null, timer.args);
+        } else {
+            /* eslint no-eval: "off" */
+            const eval2 = eval;
+            (function () {
+                eval2(timer.func);
+            })();
+        }
+    }
+
+    /**
+     * Gets clear handler name for a given timer type
+     *
+     * @param {string} ttype
+     */
+    function getClearHandler(ttype) {
+        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
+            return `cancel${ttype}`;
+        }
+        return `clear${ttype}`;
+    }
+
+    /**
+     * Gets schedule handler name for a given timer type
+     *
+     * @param {string} ttype
+     */
+    function getScheduleHandler(ttype) {
+        if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
+            return `request${ttype}`;
+        }
+        return `set${ttype}`;
+    }
+
+    /**
+     * Creates an anonymous function to warn only once
+     */
+    function createWarnOnce() {
+        let calls = 0;
+        return function (msg) {
+            // eslint-disable-next-line
+            !calls++ && console.warn(msg);
+        };
+    }
+    const warnOnce = createWarnOnce();
+
+    /**
+     * @param {Clock} clock
+     * @param {number} timerId
+     * @param {string} ttype
+     */
+    function clearTimer(clock, timerId, ttype) {
+        if (!timerId) {
+            // null appears to be allowed in most browsers, and appears to be
+            // relied upon by some libraries, like Bootstrap carousel
+            return;
+        }
+
+        if (!clock.timers) {
+            clock.timers = {};
+        }
+
+        // in Node, the ID is stored as the primitive value for `Timeout` objects
+        // for `Immediate` objects, no ID exists, so it gets coerced to NaN
+        const id = Number(timerId);
+
+        if (Number.isNaN(id) || id < idCounterStart) {
+            const handlerName = getClearHandler(ttype);
+
+            if (clock.shouldClearNativeTimers === true) {
+                const nativeHandler = clock[`_${handlerName}`];
+                return typeof nativeHandler === "function"
+                    ? nativeHandler(timerId)
+                    : undefined;
+            }
+            warnOnce(
+                `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.` +
+                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`."
+            );
+        }
+
+        if (clock.timers.hasOwnProperty(id)) {
+            // check that the ID matches a timer of the correct type
+            const timer = clock.timers[id];
+            if (
+                timer.type === ttype ||
+                (timer.type === "Timeout" && ttype === "Interval") ||
+                (timer.type === "Interval" && ttype === "Timeout")
+            ) {
+                delete clock.timers[id];
+            } else {
+                const clear = getClearHandler(ttype);
+                const schedule = getScheduleHandler(timer.type);
+                throw new Error(
+                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`
+                );
+            }
+        }
+    }
+
+    /**
+     * @param {Clock} clock
+     * @param {Config} config
+     * @returns {Timer[]}
+     */
+    function uninstall(clock, config) {
+        let method, i, l;
+        const installedHrTime = "_hrtime";
+        const installedNextTick = "_nextTick";
+
+        for (i = 0, l = clock.methods.length; i < l; i++) {
+            method = clock.methods[i];
+            if (method === "hrtime" && _global.process) {
+                _global.process.hrtime = clock[installedHrTime];
+            } else if (method === "nextTick" && _global.process) {
+                _global.process.nextTick = clock[installedNextTick];
+            } else if (method === "performance") {
+                const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
+                    clock,
+                    `_${method}`
+                );
+                if (
+                    originalPerfDescriptor &&
+                    originalPerfDescriptor.get &&
+                    !originalPerfDescriptor.set
+                ) {
+                    Object.defineProperty(
+                        _global,
+                        method,
+                        originalPerfDescriptor
+                    );
+                } else if (originalPerfDescriptor.configurable) {
+                    _global[method] = clock[`_${method}`];
+                }
+            } else {
+                if (_global[method] && _global[method].hadOwnProperty) {
+                    _global[method] = clock[`_${method}`];
+                } else {
+                    try {
+                        delete _global[method];
+                    } catch (ignore) {
+                        /* eslint no-empty: "off" */
+                    }
+                }
+            }
+        }
+
+        if (config.shouldAdvanceTime === true) {
+            _global.clearInterval(clock.attachedInterval);
+        }
+
+        // Prevent multiple executions which will completely remove these props
+        clock.methods = [];
+
+        // return pending timers, to enable checking what timers remained on uninstall
+        if (!clock.timers) {
+            return [];
+        }
+        return Object.keys(clock.timers).map(function mapper(key) {
+            return clock.timers[key];
+        });
+    }
+
+    /**
+     * @param {object} target the target containing the method to replace
+     * @param {string} method the keyname of the method on the target
+     * @param {Clock} clock
+     */
+    function hijackMethod(target, method, clock) {
+        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
+            target,
+            method
+        );
+        clock[`_${method}`] = target[method];
+
+        if (method === "Date") {
+            const date = mirrorDateProperties(clock[method], target[method]);
+            target[method] = date;
+        } else if (method === "performance") {
+            const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
+                target,
+                method
+            );
+            // JSDOM has a read only performance field so we have to save/copy it differently
+            if (
+                originalPerfDescriptor &&
+                originalPerfDescriptor.get &&
+                !originalPerfDescriptor.set
+            ) {
+                Object.defineProperty(
+                    clock,
+                    `_${method}`,
+                    originalPerfDescriptor
+                );
+
+                const perfDescriptor = Object.getOwnPropertyDescriptor(
+                    clock,
+                    method
+                );
+                Object.defineProperty(target, method, perfDescriptor);
+            } else {
+                target[method] = clock[method];
+            }
+        } else {
+            target[method] = function () {
+                return clock[method].apply(clock, arguments);
+            };
+
+            Object.defineProperties(
+                target[method],
+                Object.getOwnPropertyDescriptors(clock[method])
+            );
+        }
+
+        target[method].clock = clock;
+    }
+
+    /**
+     * @param {Clock} clock
+     * @param {number} advanceTimeDelta
+     */
+    function doIntervalTick(clock, advanceTimeDelta) {
+        clock.tick(advanceTimeDelta);
+    }
+
+    /**
+     * @typedef {object} Timers
+     * @property {setTimeout} setTimeout
+     * @property {clearTimeout} clearTimeout
+     * @property {setInterval} setInterval
+     * @property {clearInterval} clearInterval
+     * @property {Date} Date
+     * @property {SetImmediate=} setImmediate
+     * @property {function(NodeImmediate): void=} clearImmediate
+     * @property {function(number[]):number[]=} hrtime
+     * @property {NextTick=} nextTick
+     * @property {Performance=} performance
+     * @property {RequestAnimationFrame=} requestAnimationFrame
+     * @property {boolean=} queueMicrotask
+     * @property {function(number): void=} cancelAnimationFrame
+     * @property {RequestIdleCallback=} requestIdleCallback
+     * @property {function(number): void=} cancelIdleCallback
+     */
+
+    /** @type {Timers} */
+    const timers = {
+        setTimeout: _global.setTimeout,
+        clearTimeout: _global.clearTimeout,
+        setInterval: _global.setInterval,
+        clearInterval: _global.clearInterval,
+        Date: _global.Date,
+    };
+
+    if (setImmediatePresent) {
+        timers.setImmediate = _global.setImmediate;
+        timers.clearImmediate = _global.clearImmediate;
+    }
+
+    if (hrtimePresent) {
+        timers.hrtime = _global.process.hrtime;
+    }
+
+    if (nextTickPresent) {
+        timers.nextTick = _global.process.nextTick;
+    }
+
+    if (performancePresent) {
+        timers.performance = _global.performance;
+    }
+
+    if (requestAnimationFramePresent) {
+        timers.requestAnimationFrame = _global.requestAnimationFrame;
+    }
+
+    if (queueMicrotaskPresent) {
+        timers.queueMicrotask = true;
+    }
+
+    if (cancelAnimationFramePresent) {
+        timers.cancelAnimationFrame = _global.cancelAnimationFrame;
+    }
+
+    if (requestIdleCallbackPresent) {
+        timers.requestIdleCallback = _global.requestIdleCallback;
+    }
+
+    if (cancelIdleCallbackPresent) {
+        timers.cancelIdleCallback = _global.cancelIdleCallback;
+    }
+
+    const originalSetTimeout = _global.setImmediate || _global.setTimeout;
+
+    /**
+     * @param {Date|number} [start] the system time - non-integer values are floored
+     * @param {number} [loopLimit] maximum number of timers that will be run when calling runAll()
+     * @returns {Clock}
+     */
+    function createClock(start, loopLimit) {
+        // eslint-disable-next-line no-param-reassign
+        start = Math.floor(getEpoch(start));
+        // eslint-disable-next-line no-param-reassign
+        loopLimit = loopLimit || 1000;
+        let nanos = 0;
+        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
+
+        if (NativeDate === undefined) {
+            throw new Error(
+                "The global scope doesn't have a `Date` object" +
+                    " (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
+            );
+        }
+
+        const clock = {
+            now: start,
+            Date: createDate(),
+            loopLimit: loopLimit,
+        };
+
+        clock.Date.clock = clock;
+
+        //eslint-disable-next-line jsdoc/require-jsdoc
+        function getTimeToNextFrame() {
+            return 16 - ((clock.now - start) % 16);
+        }
+
+        //eslint-disable-next-line jsdoc/require-jsdoc
+        function hrtime(prev) {
+            const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
+            const secsSinceStart = Math.floor(millisSinceStart / 1000);
+            const remainderInNanos =
+                (millisSinceStart - secsSinceStart * 1e3) * 1e6 +
+                nanos -
+                adjustedSystemTime[1];
+
+            if (Array.isArray(prev)) {
+                if (prev[1] > 1e9) {
+                    throw new TypeError(
+                        "Number of nanoseconds can't exceed a billion"
+                    );
+                }
+
+                const oldSecs = prev[0];
+                let nanoDiff = remainderInNanos - prev[1];
+                let secDiff = secsSinceStart - oldSecs;
+
+                if (nanoDiff < 0) {
+                    nanoDiff += 1e9;
+                    secDiff -= 1;
+                }
+
+                return [secDiff, nanoDiff];
+            }
+            return [secsSinceStart, remainderInNanos];
+        }
+
+        function fakePerformanceNow() {
+            const hrt = hrtime();
+            const millis = hrt[0] * 1000 + hrt[1] / 1e6;
+            return millis;
+        }
+
+        if (hrtimeBigintPresent) {
+            hrtime.bigint = function () {
+                const parts = hrtime();
+                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line
+            };
+        }
+
+        clock.requestIdleCallback = function requestIdleCallback(
+            func,
+            timeout
+        ) {
+            let timeToNextIdlePeriod = 0;
+
+            if (clock.countTimers() > 0) {
+                timeToNextIdlePeriod = 50; // const for now
+            }
+
+            const result = addTimer(clock, {
+                func: func,
+                args: Array.prototype.slice.call(arguments, 2),
+                delay:
+                    typeof timeout === "undefined"
+                        ? timeToNextIdlePeriod
+                        : Math.min(timeout, timeToNextIdlePeriod),
+                idleCallback: true,
+            });
+
+            return Number(result);
+        };
+
+        clock.cancelIdleCallback = function cancelIdleCallback(timerId) {
+            return clearTimer(clock, timerId, "IdleCallback");
+        };
+
+        clock.setTimeout = function setTimeout(func, timeout) {
+            return addTimer(clock, {
+                func: func,
+                args: Array.prototype.slice.call(arguments, 2),
+                delay: timeout,
+            });
+        };
+        if (typeof _global.Promise !== "undefined" && utilPromisify) {
+            clock.setTimeout[utilPromisify.custom] =
+                function promisifiedSetTimeout(timeout, arg) {
+                    return new _global.Promise(function setTimeoutExecutor(
+                        resolve
+                    ) {
+                        addTimer(clock, {
+                            func: resolve,
+                            args: [arg],
+                            delay: timeout,
+                        });
+                    });
+                };
+        }
+
+        clock.clearTimeout = function clearTimeout(timerId) {
+            return clearTimer(clock, timerId, "Timeout");
+        };
+
+        clock.nextTick = function nextTick(func) {
+            return enqueueJob(clock, {
+                func: func,
+                args: Array.prototype.slice.call(arguments, 1),
+                error: isNearInfiniteLimit ? new Error() : null,
+            });
+        };
+
+        clock.queueMicrotask = function queueMicrotask(func) {
+            return clock.nextTick(func); // explicitly drop additional arguments
+        };
+
+        clock.setInterval = function setInterval(func, timeout) {
+            // eslint-disable-next-line no-param-reassign
+            timeout = parseInt(timeout, 10);
+            return addTimer(clock, {
+                func: func,
+                args: Array.prototype.slice.call(arguments, 2),
+                delay: timeout,
+                interval: timeout,
+            });
+        };
+
+        clock.clearInterval = function clearInterval(timerId) {
+            return clearTimer(clock, timerId, "Interval");
+        };
+
+        if (setImmediatePresent) {
+            clock.setImmediate = function setImmediate(func) {
+                return addTimer(clock, {
+                    func: func,
+                    args: Array.prototype.slice.call(arguments, 1),
+                    immediate: true,
+                });
+            };
+
+            if (typeof _global.Promise !== "undefined" && utilPromisify) {
+                clock.setImmediate[utilPromisify.custom] =
+                    function promisifiedSetImmediate(arg) {
+                        return new _global.Promise(
+                            function setImmediateExecutor(resolve) {
+                                addTimer(clock, {
+                                    func: resolve,
+                                    args: [arg],
+                                    immediate: true,
+                                });
+                            }
+                        );
+                    };
+            }
+
+            clock.clearImmediate = function clearImmediate(timerId) {
+                return clearTimer(clock, timerId, "Immediate");
+            };
+        }
+
+        clock.countTimers = function countTimers() {
+            return (
+                Object.keys(clock.timers || {}).length +
+                (clock.jobs || []).length
+            );
+        };
+
+        clock.requestAnimationFrame = function requestAnimationFrame(func) {
+            const result = addTimer(clock, {
+                func: func,
+                delay: getTimeToNextFrame(),
+                get args() {
+                    return [fakePerformanceNow()];
+                },
+                animation: true,
+            });
+
+            return Number(result);
+        };
+
+        clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {
+            return clearTimer(clock, timerId, "AnimationFrame");
+        };
+
+        clock.runMicrotasks = function runMicrotasks() {
+            runJobs(clock);
+        };
+
+        /**
+         * @param {number|string} tickValue milliseconds or a string parseable by parseTime
+         * @param {boolean} isAsync
+         * @param {Function} resolve
+         * @param {Function} reject
+         * @returns {number|undefined} will return the new `now` value or nothing for async
+         */
+        function doTick(tickValue, isAsync, resolve, reject) {
+            const msFloat =
+                typeof tickValue === "number"
+                    ? tickValue
+                    : parseTime(tickValue);
+            const ms = Math.floor(msFloat);
+            const remainder = nanoRemainder(msFloat);
+            let nanosTotal = nanos + remainder;
+            let tickTo = clock.now + ms;
+
+            if (msFloat < 0) {
+                throw new TypeError("Negative ticks are not supported");
+            }
+
+            // adjust for positive overflow
+            if (nanosTotal >= 1e6) {
+                tickTo += 1;
+                nanosTotal -= 1e6;
+            }
+
+            nanos = nanosTotal;
+            let tickFrom = clock.now;
+            let previous = clock.now;
+            // ESLint fails to detect this correctly
+            /* eslint-disable prefer-const */
+            let timer,
+                firstException,
+                oldNow,
+                nextPromiseTick,
+                compensationCheck,
+                postTimerCall;
+            /* eslint-enable prefer-const */
+
+            clock.duringTick = true;
+
+            // perform microtasks
+            oldNow = clock.now;
+            runJobs(clock);
+            if (oldNow !== clock.now) {
+                // compensate for any setSystemTime() call during microtask callback
+                tickFrom += clock.now - oldNow;
+                tickTo += clock.now - oldNow;
+            }
+
+            //eslint-disable-next-line jsdoc/require-jsdoc
+            function doTickInner() {
+                // perform each timer in the requested range
+                timer = firstTimerInRange(clock, tickFrom, tickTo);
+                // eslint-disable-next-line no-unmodified-loop-condition
+                while (timer && tickFrom <= tickTo) {
+                    if (clock.timers[timer.id]) {
+                        tickFrom = timer.callAt;
+                        clock.now = timer.callAt;
+                        oldNow = clock.now;
+                        try {
+                            runJobs(clock);
+                            callTimer(clock, timer);
+                        } catch (e) {
+                            firstException = firstException || e;
+                        }
+
+                        if (isAsync) {
+                            // finish up after native setImmediate callback to allow
+                            // all native es6 promises to process their callbacks after
+                            // each timer fires.
+                            originalSetTimeout(nextPromiseTick);
+                            return;
+                        }
+
+                        compensationCheck();
+                    }
+
+                    postTimerCall();
+                }
+
+                // perform process.nextTick()s again
+                oldNow = clock.now;
+                runJobs(clock);
+                if (oldNow !== clock.now) {
+                    // compensate for any setSystemTime() call during process.nextTick() callback
+                    tickFrom += clock.now - oldNow;
+                    tickTo += clock.now - oldNow;
+                }
+                clock.duringTick = false;
+
+                // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]
+                timer = firstTimerInRange(clock, tickFrom, tickTo);
+                if (timer) {
+                    try {
+                        clock.tick(tickTo - clock.now); // do it all again - for the remainder of the requested range
+                    } catch (e) {
+                        firstException = firstException || e;
+                    }
+                } else {
+                    // no timers remaining in the requested range: move the clock all the way to the end
+                    clock.now = tickTo;
+
+                    // update nanos
+                    nanos = nanosTotal;
+                }
+                if (firstException) {
+                    throw firstException;
+                }
+
+                if (isAsync) {
+                    resolve(clock.now);
+                } else {
+                    return clock.now;
+                }
+            }
+
+            nextPromiseTick =
+                isAsync &&
+                function () {
+                    try {
+                        compensationCheck();
+                        postTimerCall();
+                        doTickInner();
+                    } catch (e) {
+                        reject(e);
+                    }
+                };
+
+            compensationCheck = function () {
+                // compensate for any setSystemTime() call during timer callback
+                if (oldNow !== clock.now) {
+                    tickFrom += clock.now - oldNow;
+                    tickTo += clock.now - oldNow;
+                    previous += clock.now - oldNow;
+                }
+            };
+
+            postTimerCall = function () {
+                timer = firstTimerInRange(clock, previous, tickTo);
+                previous = tickFrom;
+            };
+
+            return doTickInner();
+        }
+
+        /**
+         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+         * @returns {number} will return the new `now` value
+         */
+        clock.tick = function tick(tickValue) {
+            return doTick(tickValue, false);
+        };
+
+        if (typeof _global.Promise !== "undefined") {
+            /**
+             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+             * @returns {Promise}
+             */
+            clock.tickAsync = function tickAsync(tickValue) {
+                return new _global.Promise(function (resolve, reject) {
+                    originalSetTimeout(function () {
+                        try {
+                            doTick(tickValue, true, resolve, reject);
+                        } catch (e) {
+                            reject(e);
+                        }
+                    });
+                });
+            };
+        }
+
+        clock.next = function next() {
+            runJobs(clock);
+            const timer = firstTimer(clock);
+            if (!timer) {
+                return clock.now;
+            }
+
+            clock.duringTick = true;
+            try {
+                clock.now = timer.callAt;
+                callTimer(clock, timer);
+                runJobs(clock);
+                return clock.now;
+            } finally {
+                clock.duringTick = false;
+            }
+        };
+
+        if (typeof _global.Promise !== "undefined") {
+            clock.nextAsync = function nextAsync() {
+                return new _global.Promise(function (resolve, reject) {
+                    originalSetTimeout(function () {
+                        try {
+                            const timer = firstTimer(clock);
+                            if (!timer) {
+                                resolve(clock.now);
+                                return;
+                            }
+
+                            let err;
+                            clock.duringTick = true;
+                            clock.now = timer.callAt;
+                            try {
+                                callTimer(clock, timer);
+                            } catch (e) {
+                                err = e;
+                            }
+                            clock.duringTick = false;
+
+                            originalSetTimeout(function () {
+                                if (err) {
+                                    reject(err);
+                                } else {
+                                    resolve(clock.now);
+                                }
+                            });
+                        } catch (e) {
+                            reject(e);
+                        }
+                    });
+                });
+            };
+        }
+
+        clock.runAll = function runAll() {
+            let numTimers, i;
+            runJobs(clock);
+            for (i = 0; i < clock.loopLimit; i++) {
+                if (!clock.timers) {
+                    resetIsNearInfiniteLimit();
+                    return clock.now;
+                }
+
+                numTimers = Object.keys(clock.timers).length;
+                if (numTimers === 0) {
+                    resetIsNearInfiniteLimit();
+                    return clock.now;
+                }
+
+                clock.next();
+                checkIsNearInfiniteLimit(clock, i);
+            }
+
+            const excessJob = firstTimer(clock);
+            throw getInfiniteLoopError(clock, excessJob);
+        };
+
+        clock.runToFrame = function runToFrame() {
+            return clock.tick(getTimeToNextFrame());
+        };
+
+        if (typeof _global.Promise !== "undefined") {
+            clock.runAllAsync = function runAllAsync() {
+                return new _global.Promise(function (resolve, reject) {
+                    let i = 0;
+                    /**
+                     *
+                     */
+                    function doRun() {
+                        originalSetTimeout(function () {
+                            try {
+                                let numTimers;
+                                if (i < clock.loopLimit) {
+                                    if (!clock.timers) {
+                                        resetIsNearInfiniteLimit();
+                                        resolve(clock.now);
+                                        return;
+                                    }
+
+                                    numTimers = Object.keys(
+                                        clock.timers
+                                    ).length;
+                                    if (numTimers === 0) {
+                                        resetIsNearInfiniteLimit();
+                                        resolve(clock.now);
+                                        return;
+                                    }
+
+                                    clock.next();
+
+                                    i++;
+
+                                    doRun();
+                                    checkIsNearInfiniteLimit(clock, i);
+                                    return;
+                                }
+
+                                const excessJob = firstTimer(clock);
+                                reject(getInfiniteLoopError(clock, excessJob));
+                            } catch (e) {
+                                reject(e);
+                            }
+                        });
+                    }
+                    doRun();
+                });
+            };
+        }
+
+        clock.runToLast = function runToLast() {
+            const timer = lastTimer(clock);
+            if (!timer) {
+                runJobs(clock);
+                return clock.now;
+            }
+
+            return clock.tick(timer.callAt - clock.now);
+        };
+
+        if (typeof _global.Promise !== "undefined") {
+            clock.runToLastAsync = function runToLastAsync() {
+                return new _global.Promise(function (resolve, reject) {
+                    originalSetTimeout(function () {
+                        try {
+                            const timer = lastTimer(clock);
+                            if (!timer) {
+                                resolve(clock.now);
+                            }
+
+                            resolve(clock.tickAsync(timer.callAt - clock.now));
+                        } catch (e) {
+                            reject(e);
+                        }
+                    });
+                });
+            };
+        }
+
+        clock.reset = function reset() {
+            nanos = 0;
+            clock.timers = {};
+            clock.jobs = [];
+            clock.now = start;
+        };
+
+        clock.setSystemTime = function setSystemTime(systemTime) {
+            // determine time difference
+            const newNow = getEpoch(systemTime);
+            const difference = newNow - clock.now;
+            let id, timer;
+
+            adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
+            adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
+            // update 'system clock'
+            clock.now = newNow;
+            nanos = 0;
+
+            // update timers and intervals to keep them stable
+            for (id in clock.timers) {
+                if (clock.timers.hasOwnProperty(id)) {
+                    timer = clock.timers[id];
+                    timer.createdAt += difference;
+                    timer.callAt += difference;
+                }
+            }
+        };
+
+        /**
+         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+         * @returns {number} will return the new `now` value
+         */
+        clock.jump = function jump(tickValue) {
+            const msFloat =
+                typeof tickValue === "number"
+                    ? tickValue
+                    : parseTime(tickValue);
+            const ms = Math.floor(msFloat);
+
+            for (const timer of Object.values(clock.timers)) {
+                if (clock.now + ms > timer.callAt) {
+                    timer.callAt = clock.now + ms;
+                }
+            }
+            clock.tick(ms);
+        };
+
+        if (performancePresent) {
+            clock.performance = Object.create(null);
+            clock.performance.now = fakePerformanceNow;
+        }
+
+        if (hrtimePresent) {
+            clock.hrtime = hrtime;
+        }
+
+        return clock;
+    }
+
+    /* eslint-disable complexity */
+
+    /**
+     * @param {Config=} [config] Optional config
+     * @returns {Clock}
+     */
+    function install(config) {
+        if (
+            arguments.length > 1 ||
+            config instanceof Date ||
+            Array.isArray(config) ||
+            typeof config === "number"
+        ) {
+            throw new TypeError(
+                `FakeTimers.install called with ${String(
+                    config
+                )} install requires an object parameter`
+            );
+        }
+
+        if (_global.Date.isFake === true) {
+            // Timers are already faked; this is a problem.
+            // Make the user reset timers before continuing.
+            throw new TypeError(
+                "Can't install fake timers twice on the same global object."
+            );
+        }
+
+        // eslint-disable-next-line no-param-reassign
+        config = typeof config !== "undefined" ? config : {};
+        config.shouldAdvanceTime = config.shouldAdvanceTime || false;
+        config.advanceTimeDelta = config.advanceTimeDelta || 20;
+        config.shouldClearNativeTimers =
+            config.shouldClearNativeTimers || false;
+
+        if (config.target) {
+            throw new TypeError(
+                "config.target is no longer supported. Use `withGlobal(target)` instead."
+            );
+        }
+
+        let i, l;
+        const clock = createClock(config.now, config.loopLimit);
+        clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
+
+        clock.uninstall = function () {
+            return uninstall(clock, config);
+        };
+
+        clock.methods = config.toFake || [];
+
+        if (clock.methods.length === 0) {
+            // do not fake nextTick by default - GitHub#126
+            clock.methods = Object.keys(timers).filter(function (key) {
+                return key !== "nextTick" && key !== "queueMicrotask";
+            });
+        }
+
+        if (config.shouldAdvanceTime === true) {
+            const intervalTick = doIntervalTick.bind(
+                null,
+                clock,
+                config.advanceTimeDelta
+            );
+            const intervalId = _global.setInterval(
+                intervalTick,
+                config.advanceTimeDelta
+            );
+            clock.attachedInterval = intervalId;
+        }
+
+        if (clock.methods.includes("performance")) {
+            const proto = (() => {
+                if (hasPerformancePrototype) {
+                    return _global.Performance.prototype;
+                }
+                if (hasPerformanceConstructorPrototype) {
+                    return _global.performance.constructor.prototype;
+                }
+            })();
+            if (proto) {
+                Object.getOwnPropertyNames(proto).forEach(function (name) {
+                    if (name !== "now") {
+                        clock.performance[name] =
+                            name.indexOf("getEntries") === 0
+                                ? NOOP_ARRAY
+                                : NOOP;
+                    }
+                });
+            } else if ((config.toFake || []).includes("performance")) {
+                // user explicitly tried to fake performance when not present
+                throw new ReferenceError(
+                    "non-existent performance object cannot be faked"
+                );
+            }
+        }
+
+        for (i = 0, l = clock.methods.length; i < l; i++) {
+            const nameOfMethodToReplace = clock.methods[i];
+            if (nameOfMethodToReplace === "hrtime") {
+                if (
+                    _global.process &&
+                    typeof _global.process.hrtime === "function"
+                ) {
+                    hijackMethod(_global.process, nameOfMethodToReplace, clock);
+                }
+            } else if (nameOfMethodToReplace === "nextTick") {
+                if (
+                    _global.process &&
+                    typeof _global.process.nextTick === "function"
+                ) {
+                    hijackMethod(_global.process, nameOfMethodToReplace, clock);
+                }
+            } else {
+                hijackMethod(_global, nameOfMethodToReplace, clock);
+            }
+        }
+
+        return clock;
+    }
+
+    /* eslint-enable complexity */
+
+    return {
+        timers: timers,
+        createClock: createClock,
+        install: install,
+        withGlobal: withGlobal,
+    };
+}
+
+/**
+ * @typedef {object} FakeTimers
+ * @property {Timers} timers
+ * @property {createClock} createClock
+ * @property {Function} install
+ * @property {withGlobal} withGlobal
+ */
+
+/* eslint-enable complexity */
+
+/** @type {FakeTimers} */
+const defaultImplementation = withGlobal(globalObject);
+
+exports.timers = defaultImplementation.timers;
+exports.createClock = defaultImplementation.createClock;
+exports.install = defaultImplementation.install;
+exports.withGlobal = withGlobal;