@apple-pie/slice 0.1.59 → 0.2.0

package/dist/cjs/providers/themeServer.test.js

@@ -1579,12 +1579,12 @@ function requireBuild() {
         }
     };
     /**
-	 * Copyright (c) Meta Platforms, Inc. and affiliates.
-	 *
-	 * This source code is licensed under the MIT license found in the
-	 * LICENSE file in the root directory of this source tree.
-	 *
-	 */
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *
+   */
     const pkg = "diff-sequences", NOT_YET_SET = 0, countCommonItemsF = (aIndex, aEnd, bIndex, bEnd, isCommon) => {
         let nCommon = 0;
         for (;aIndex < aEnd && bIndex < bEnd && isCommon(aIndex, bIndex); ) aIndex += 1, 
@@ -3625,9 +3625,9 @@ function createTest(fn) {
     return function(fn) {
         const taskFn = fn;
         /**
-	* Parse builder pattern arguments into a fixtures object.
-	* Handles both builder pattern (name, options?, value) and object syntax.
-	*/
+  * Parse builder pattern arguments into a fixtures object.
+  * Handles both builder pattern (name, options?, value) and object syntax.
+  */
         function parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {
             if ("string" != typeof fixturesOrName) return fixturesOrName;
             const fixtureName = fixturesOrName;
@@ -4254,8 +4254,8 @@ function test$1(obj, args) {
 function type(obj) {
     if (void 0 === obj) return "undefined";
     if (null === obj) return "null";
-    const stringTag = 
-    /** @type {Record<PropertyKey, unknown>} */ obj[Symbol.toStringTag];
+    const stringTag = /** @type {Record<PropertyKey, unknown>} */
+    obj[Symbol.toStringTag];
     if ("string" == typeof stringTag) return stringTag;
     return Object.prototype.toString.call(obj).slice(8, -1);
 }
@@ -4298,8 +4298,8 @@ __name(_AssertionError, "AssertionError");
 var AssertionError = _AssertionError;
 
 function expectTypes(obj, types) {
-    let flagMsg = flag(obj, "message"), ssfi = 
-    /** @type {Function} */ flag(obj, "ssfi");
+    let flagMsg = flag(obj, "message"), ssfi = /** @type {Function} */
+    flag(obj, "ssfi");
     flagMsg = flagMsg ? flagMsg + ": " : "", obj = /** @type {object} */
     flag(obj, "object"), (types = types.map(function(t) {
         return t.toLowerCase();
@@ -4808,17 +4808,17 @@ function objDisplay(obj) {
     let str = inspect2(obj), type3 = Object.prototype.toString.call(obj);
     if (config.truncateThreshold && str.length >= config.truncateThreshold) {
         if ("[object Function]" === type3) {
-            const objAsFunction = 
-            /** @type {Function} */ obj;
+            const objAsFunction = /** @type {Function} */
+            obj;
             return objAsFunction.name && "" !== objAsFunction.name ? "[Function: " + objAsFunction.name + "]" : "[Function]";
         }
         if ("[object Array]" === type3) {
-            return "[ Array(" + 
-            /** @type {unknown[]} */ obj.length + ") ]";
+            return "[ Array(" + /** @type {unknown[]} */
+            obj.length + ") ]";
         }
         if ("[object Object]" === type3) {
-            const objAsObject = 
-            /** @type {Record<PropertyKey, unknown>} */ obj;
+            const objAsObject = /** @type {Record<PropertyKey, unknown>} */
+            obj;
             let keys = Object.keys(objAsObject);
             return "{ Object (" + (keys.length > 2 ? keys.splice(0, 2).join(", ") + ", ..." : keys.join(", ")) + ") }";
         }
@@ -4830,17 +4830,17 @@ function objDisplay(obj) {
 function getMessage2(obj, args) {
     let negate = flag(obj, "negate"), val = flag(obj, "object"), expected = args[3], actual = getActual(obj, args), rawMsg = negate ? args[2] : args[1], flagMsg = flag(obj, "message");
     "function" == typeof rawMsg && (rawMsg = rawMsg());
-    const msg = (
-    /** @type {string} */ rawMsg || "").replace(/#\{(this|act|exp)\}/g, function(_, tag) {
+    const msg = (/** @type {string} */
+    rawMsg || "").replace(/#\{(this|act|exp)\}/g, function(_, tag) {
         return objDisplay("this" === tag ? val : "act" === tag ? actual : expected);
     });
     return flagMsg ? flagMsg + ": " + msg : msg;
 }
 
 function transferFlags(source, object, includeAll) {
-    const sourceWithFlags = 
-    /** @type {{__flags?: Record<PropertyKey, unknown>}} */ source, objWithFlags = 
-    /** @type {{__flags?: Record<PropertyKey, unknown>}} */ object;
+    const sourceWithFlags = /** @type {{__flags?: Record<PropertyKey, unknown>}} */
+    source, objWithFlags = /** @type {{__flags?: Record<PropertyKey, unknown>}} */
+    object;
     let flags = sourceWithFlags.__flags || (sourceWithFlags.__flags = Object.create(null));
     const objFlags = objWithFlags.__flags || (objWithFlags.__flags = Object.create(null));
     includeAll = 3 !== arguments.length || includeAll;
@@ -5395,8 +5395,8 @@ function overwriteProperty(ctx, name, getter) {
 }
 
 function overwriteMethod(ctx, name, method) {
-    let _method = 
-    /** @type {Record<PropertyKey, unknown>} */ ctx[name], _super = __name(function() {
+    let _method = /** @type {Record<PropertyKey, unknown>} */
+    ctx[name], _super = __name(function() {
         throw new Error(String(name) + " is not a function");
     }, "_super");
     function overwritingMethodWrapper() {
@@ -5436,8 +5436,8 @@ __name(_PluginAddChainableMethodEvent, "PluginAddChainableMethodEvent");
 var PluginAddChainableMethodEvent = _PluginAddChainableMethodEvent;
 
 function addChainableMethod(ctx, name, method, chainingBehavior) {
-    const ctxChainable = 
-    /** @type {T & {__methods: Record<PropertyKey, ChainableBehavior>}} */ ctx;
+    const ctxChainable = /** @type {T & {__methods: Record<PropertyKey, ChainableBehavior>}} */
+    ctx;
     "function" != typeof chainingBehavior && (chainingBehavior = __name(function() {}, "chainingBehavior"));
     let chainableBehavior = {
         method: method,
@@ -5448,8 +5448,8 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
         get: __name(function() {
             function chainableMethodWrapper(...args) {
                 flag(this, "lockSsfi") || flag(this, "ssfi", chainableMethodWrapper);
-                let result = 
-                /** @type {(...args: unknown[]) => unknown} */ chainableBehavior.method.apply(this, args);
+                let result = /** @type {(...args: unknown[]) => unknown} */
+                chainableBehavior.method.apply(this, args);
                 if (void 0 !== result) return result;
                 let newAssertion = new Assertion;
                 return transferFlags(this, newAssertion), newAssertion;
@@ -5472,12 +5472,13 @@ function addChainableMethod(ctx, name, method, chainingBehavior) {
 }
 
 function overwriteChainableMethod(ctx, name, method, chainingBehavior) {
-    let chainableBehavior = 
-    /** @type {{__methods: Record<PropertyKey, ChainableBehavior>}} */ ctx.__methods[name], _chainingBehavior = chainableBehavior.chainingBehavior;
+    let chainableBehavior = /** @type {{__methods: Record<PropertyKey, ChainableBehavior>}} */
+    ctx.__methods[name], _chainingBehavior = chainableBehavior.chainingBehavior;
     chainableBehavior.chainingBehavior = 
     /**
-   * @this {T}
-   */ __name(function() {
+  * @this {T}
+  */
+    __name(function() {
         let result = chainingBehavior(_chainingBehavior).call(this);
         if (void 0 !== result) return result;
         let newAssertion = new Assertion;
@@ -5929,17 +5930,15 @@ function oneOf(list, msg) {
 
 function assertChanges(subject, prop, msg) {
     msg && flag2(this, "message", msg);
-    const fn = 
-    /** @type {() => void} */ flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+    const fn = /** @type {() => void} */
+    flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
     let initial;
     new Assertion(fn, flagMsg, ssfi, !0).is.a("function"), null == prop ? (new Assertion(subject, flagMsg, ssfi, !0).is.a("function"), 
     initial = /** @type {() => unknown} */
     subject()) : (new Assertion(subject, flagMsg, ssfi, !0).to.have.property(prop), 
     initial = /** @type {Record<PropertyKey, unknown>} */
     subject[prop]), fn();
-    let final = null == prop ? 
-    /** @type {() => unknown} */ subject() : 
-    /** @type {Record<PropertyKey, unknown>} */ subject[prop], msgObj = null == prop ? initial : "." + prop;
+    let final = null == prop ? /** @type {() => unknown} */ subject() : /** @type {Record<PropertyKey, unknown>} */ subject[prop], msgObj = null == prop ? initial : "." + prop;
     flag2(this, "deltaMsgObj", msgObj), flag2(this, "initialDeltaValue", initial), flag2(this, "finalDeltaValue", final), 
     flag2(this, "deltaBehavior", "change"), flag2(this, "realDelta", final !== initial), 
     this.assert(initial !== final, "expected " + msgObj + " to change", "expected " + msgObj + " to not change");
@@ -5947,17 +5946,15 @@ function assertChanges(subject, prop, msg) {
 
 function assertIncreases(subject, prop, msg) {
     msg && flag2(this, "message", msg);
-    const fn = 
-    /** @type {() => void} */ flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+    const fn = /** @type {() => void} */
+    flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
     let initial;
     new Assertion(fn, flagMsg, ssfi, !0).is.a("function"), null == prop ? (new Assertion(subject, flagMsg, ssfi, !0).is.a("function"), 
     initial = /** @type {() => number} */
     subject()) : (new Assertion(subject, flagMsg, ssfi, !0).to.have.property(prop), 
     initial = /** @type {Record<PropertyKey, number>} */
     subject[prop]), new Assertion(initial, flagMsg, ssfi, !0).is.a("number"), fn();
-    let final = null == prop ? 
-    /** @type {() => number} */ subject() : 
-    /** @type {Record<PropertyKey, number>} */ subject[prop], msgObj = null == prop ? initial : "." + prop;
+    let final = null == prop ? /** @type {() => number} */ subject() : /** @type {Record<PropertyKey, number>} */ subject[prop], msgObj = null == prop ? initial : "." + prop;
     flag2(this, "deltaMsgObj", msgObj), flag2(this, "initialDeltaValue", initial), flag2(this, "finalDeltaValue", final), 
     flag2(this, "deltaBehavior", "increase"), flag2(this, "realDelta", final - initial), 
     this.assert(final - initial > 0, "expected " + msgObj + " to increase", "expected " + msgObj + " to not increase");
@@ -5965,17 +5962,15 @@ function assertIncreases(subject, prop, msg) {
 
 function assertDecreases(subject, prop, msg) {
     msg && flag2(this, "message", msg);
-    const fn = 
-    /** @type {() => void} */ flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
+    const fn = /** @type {() => void} */
+    flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
     let initial;
     new Assertion(fn, flagMsg, ssfi, !0).is.a("function"), null == prop ? (new Assertion(subject, flagMsg, ssfi, !0).is.a("function"), 
     initial = /** @type {() => number} */
     subject()) : (new Assertion(subject, flagMsg, ssfi, !0).to.have.property(prop), 
     initial = /** @type {Record<PropertyKey, number>} */
     subject[prop]), new Assertion(initial, flagMsg, ssfi, !0).is.a("number"), fn();
-    let final = null == prop ? 
-    /** @type {() => number} */ subject() : 
-    /** @type {Record<PropertyKey, number>} */ subject[prop], msgObj = null == prop ? initial : "." + prop;
+    let final = null == prop ? /** @type {() => number} */ subject() : /** @type {Record<PropertyKey, number>} */ subject[prop], msgObj = null == prop ? initial : "." + prop;
     flag2(this, "deltaMsgObj", msgObj), flag2(this, "initialDeltaValue", initial), flag2(this, "finalDeltaValue", final), 
     flag2(this, "deltaBehavior", "decrease"), flag2(this, "realDelta", initial - final), 
     this.assert(final - initial < 0, "expected " + msgObj + " to decrease", "expected " + msgObj + " to not decrease");
@@ -7816,7 +7811,7 @@ class SnapshotState {
         }(this._environment, this._snapshotData, this.snapshotPath), this._fileExists = !0), 
         hasInlineSnapshots && await async function(environment, snapshots) {
             const MagicString = (await Promise.resolve().then(function() {
-                return require("../chunks/magic-string.es-DRDyITUv.js");
+                return require("../chunks/magic-string.es-DsAR0Q7u.js");
             })).default, files = new Set(snapshots.map(i => i.file));
             await Promise.all(Array.from(files).map(async file => {
                 const snaps = snapshots.filter(i => i.file === file), code = await environment.readSnapshotFile(file);
@@ -8158,13 +8153,13 @@ function requireCopyPrototypeMethods() {
     var call = Function.call, throwsOnProto = function() {
         if (hasRequiredThrowsOnProto) return throwsOnProto_1;
         /**
-	 * 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}
-	 */
+   * 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;
         hasRequiredThrowsOnProto = 1;
         try {
@@ -8194,11 +8189,11 @@ function requireCalledInOrder() {
     hasRequiredCalledInOrder = 1;
     var every = requireArray().every;
     /**
-	 * @private
-	 */    
+   * @private
+   */    
     /**
-	 * @private
-	 */
+   * @private
+   */
     function checkAdjacentCalls(callMap, spy, index, spies) {
         var calledBeforeNext = !0;
         return index !== spies.length - 1 && (calledBeforeNext = spy.calledBefore(spies[index + 1])), 
@@ -8207,17 +8202,17 @@ function requireCalledInOrder() {
         }(callMap, spy) || !calledBeforeNext) && (callMap[spy.id] += 1, !0);
     }
     /**
-	 * 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
-	 */
+   * 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
-	 */    return calledInOrder_1 = function(spies) {
+   * 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
+   */    return calledInOrder_1 = function(spies) {
         return every(arguments.length > 1 ? arguments : spies, checkAdjacentCalls.bind(null, {}));
     }, calledInOrder_1;
 }
@@ -8226,10 +8221,10 @@ function requireClassName() {
     if (hasRequiredClassName) return className_1;
     return hasRequiredClassName = 1, className_1 = 
     /**
-	 * Returns a display name for a value from a constructor
-	 * @param  {object} value A value to examine
-	 * @returns {(string|null)} A string or null
-	 */
+   * 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(value) {
         return value.constructor && value.constructor.name || null;
     };
@@ -8242,22 +8237,22 @@ function requireOrderByFirstCall() {
     hasRequiredOrderByFirstCall = 1;
     var sort = requireArray().sort, slice = requireArray().slice;
     /**
-	 * @private
-	 */
+   * @private
+   */
     function comparator(a, b) {
         var aCall = a.getCall(0), bCall = b.getCall(0);
         return (aCall && aCall.callId || -1) < (bCall && bCall.callId || -1) ? -1 : 1;
     }
     /**
-	 * A Sinon proxy object (fake, spy, stub)
-	 * @typedef {object} SinonProxy
-	 * @property {Function} getCall - A method that can return the first call
-	 */
+   * 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[]}
-	 */    return orderByFirstCall_1 = function(spies) {
+   * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
+   * @param  {SinonProxy[] | SinonProxy} spies
+   * @returns {SinonProxy[]}
+   */    return orderByFirstCall_1 = function(spies) {
         return sort(slice(spies), comparator);
     };
 }
@@ -8305,15 +8300,15 @@ function requireTypeDetect() {
     return hasRequiredTypeDetect || (hasRequiredTypeDetect = 1, typeDetect$1.exports = function() {
         var promiseExists = "function" == typeof Promise, globalObject = "object" == typeof self ? self : commonjsGlobal, symbolExists = "undefined" != typeof Symbol, mapExists = "undefined" != typeof Map, setExists = "undefined" != typeof Set, weakMapExists = "undefined" != typeof WeakMap, weakSetExists = "undefined" != typeof WeakSet, dataViewExists = "undefined" != typeof DataView, symbolIteratorExists = symbolExists && void 0 !== Symbol.iterator, symbolToStringTagExists = symbolExists && void 0 !== Symbol.toStringTag, setEntriesExists = setExists && "function" == typeof Set.prototype.entries, mapEntriesExists = mapExists && "function" == typeof Map.prototype.entries, setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((new Set).entries()), mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((new Map).entries()), arrayIteratorExists = symbolIteratorExists && "function" == typeof Array.prototype[Symbol.iterator], arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]()), stringIteratorExists = symbolIteratorExists && "function" == typeof String.prototype[Symbol.iterator], stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]()), toStringLeftSliceLength = 8, toStringRightSliceLength = -1;
         /**
-		 * ### typeOf (obj)
-		 *
-		 * Uses `Object.prototype.toString` to determine the type of an object,
-		 * normalising behaviour across engine versions & well optimised.
-		 *
-		 * @param {Mixed} object
-		 * @return {String} object type
-		 * @api public
-		 */
+       * ### typeOf (obj)
+       *
+       * Uses `Object.prototype.toString` to determine the type of an object,
+       * normalising behaviour across engine versions & well optimised.
+       *
+       * @param {Mixed} object
+       * @return {String} object type
+       * @api public
+       */
         function typeDetect(obj) {
             var typeofObj = typeof obj;
             if ("object" !== typeofObj) return typeofObj;
@@ -8347,10 +8342,10 @@ function requireTypeOf() {
     hasRequiredTypeOf = 1;
     var type = requireTypeDetect();
     /**
-	 * Returns the lower-case result of running type from type-detect on the value
-	 * @param  {*} value
-	 * @returns {string}
-	 */    return typeOf = function(value) {
+   * Returns the lower-case result of running type from type-detect on the value
+   * @param  {*} value
+   * @returns {string}
+   */    return typeOf = function(value) {
         return type(value).toLowerCase();
     };
 }
@@ -8359,10 +8354,10 @@ function requireValueToString() {
     if (hasRequiredValueToString) return valueToString_1;
     return hasRequiredValueToString = 1, valueToString_1 = 
     /**
-	 * Returns a string representation of the value
-	 * @param  {*} value
-	 * @returns {string}
-	 */
+   * Returns a string representation of the value
+   * @param  {*} value
+   * @returns {string}
+   */
     function(value) {
         return value && value.toString ? value.toString() : String(value);
     };
@@ -8379,12 +8374,12 @@ var fakeTimersSrcExports = function() {
             className: requireClassName(),
             deprecated: (hasRequiredDeprecated || (hasRequiredDeprecated = 1, 
             /**
-		 * 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}
-		 */
+     * 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$1 = deprecated).wrap = function(func, msg) {
                 var wrapped = function() {
                     return exports$1.printWarning(msg), func.apply(this, arguments);
@@ -8392,31 +8387,31 @@ var fakeTimersSrcExports = function() {
                 return func.prototype && (wrapped.prototype = func.prototype), 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}
-		 */
+     * 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$1.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}
-		 */
+     * Prints a warning on the console, when it exists
+     * @param  {string} msg
+     * @returns {undefined}
+     */
             exports$1.printWarning = function(msg) {
                 "object" == typeof process && process.emitWarning ? process.emitWarning(msg) : console.info && console.info(msg);
             }), deprecated),
             every: (hasRequiredEvery || (hasRequiredEvery = 1, 
             /**
-	 * 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}
-	 */
+   * 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}
+   */
             every = function(obj, fn) {
                 var pass = !0;
                 try {
@@ -8430,10 +8425,10 @@ var fakeTimersSrcExports = function() {
             }), every),
             functionName: hasRequiredFunctionName ? functionName : (hasRequiredFunctionName = 1, 
             /**
-	 * Returns a display name for a function
-	 * @param  {Function} func
-	 * @returns {string}
-	 */
+   * Returns a display name for a function
+   * @param  {Function} func
+   * @returns {string}
+   */
             functionName = function(func) {
                 if (!func) return "";
                 try {
@@ -8466,138 +8461,138 @@ var fakeTimersSrcExports = function() {
         } catch (e) {}
     }
     /**
-	 * @typedef {"nextAsync" | "manual" | "interval"} TickMode
-	 */
+   * @typedef {"nextAsync" | "manual" | "interval"} TickMode
+   */
     /**
-	 * @typedef {object} NextAsyncTickMode
-	 * @property {"nextAsync"} mode
-	 */
+   * @typedef {object} NextAsyncTickMode
+   * @property {"nextAsync"} mode
+   */
     /**
-	 * @typedef {object} ManualTickMode
-	 * @property {"manual"} mode
-	 */
+   * @typedef {object} ManualTickMode
+   * @property {"manual"} mode
+   */
     /**
-	 * @typedef {object} IntervalTickMode
-	 * @property {"interval"} mode
-	 * @property {number} [delta]
-	 */
+   * @typedef {object} IntervalTickMode
+   * @property {"interval"} mode
+   * @property {number} [delta]
+   */
     /**
-	 * @typedef {IntervalTickMode | NextAsyncTickMode | ManualTickMode} TimerTickMode
-	 */
+   * @typedef {IntervalTickMode | NextAsyncTickMode | ManualTickMode} TimerTickMode
+   */
     /**
-	 * @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
-	 */
+   * @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
-	 */
+   * 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 {...*} args - optional arguments to call the callback with
-	 * @returns {void}
-	 */
+   * @callback NextTick
+   * @param {VoidVarArgsFunc} callback - the callback to run
+   * @param {...*} args - optional arguments to call the callback with
+   * @returns {void}
+   */
     /**
-	 * @callback SetImmediate
-	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} args - optional arguments to call the callback with
-	 * @returns {NodeImmediate}
-	 */
+   * @callback SetImmediate
+   * @param {VoidVarArgsFunc} callback - the callback to run
+   * @param {...*} args - optional arguments to call the callback with
+   * @returns {NodeImmediate}
+   */
     /**
-	 * @callback VoidVarArgsFunc
-	 * @param {...*} callback - the callback to run
-	 * @returns {void}
-	 */
+   * @callback VoidVarArgsFunc
+   * @param {...*} callback - the callback to run
+   * @returns {void}
+   */
     /**
-	 * @typedef RequestAnimationFrame
-	 * @property {function(number):void} requestAnimationFrame
-	 * @returns {number} - the id
-	 */
+   * @typedef RequestAnimationFrame
+   * @property {function(number):void} requestAnimationFrame
+   * @returns {number} - the id
+   */
     /**
-	 * @typedef Performance
-	 * @property {function(): number} now
-	 */
+   * @typedef Performance
+   * @property {function(): number} now
+   */
     /**
-	 * @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
-	 * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
-	 * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
-	 * @property {Map<function(): void, AbortSignal>} abortListenerMap
-	 * @property {function(TimerTickMode): void} setTickMode
-	 */
+   * @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
+   * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
+   * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
+   * @property {Map<function(): void, AbortSignal>} abortListenerMap
+   * @property {function(TimerTickMode): void} setTickMode
+   */
     /**
-	 * 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)
-	 * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error
-	 */
+   * 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)
+   * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error
+   */
     /**
-	 * 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]
-	 */
+   * 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
-	 */
+   * A Node timer
+   * @typedef {object} NodeImmediate
+   * @property {function(): boolean} hasRef
+   * @property {function(): NodeImmediate} ref
+   * @property {function(): NodeImmediate} unref
+   */
     /**
-	 * Mocks available features in the specified global namespace.
-	 * @param {*} _global Namespace to mock (e.g. `window`)
-	 * @returns {FakeTimers}
-	 */    function withGlobal(_global) {
+   * Mocks available features in the specified global namespace.
+   * @param {*} _global Namespace to mock (e.g. `window`)
+   * @returns {FakeTimers}
+   */    function withGlobal(_global) {
         const maxTimeout = Math.pow(2, 31) - 1, NOOP = function() {}, NOOP_ARRAY = function() {
             return [];
         }, isPresent = {};
@@ -8623,11 +8618,11 @@ var fakeTimersSrcExports = function() {
         if (void 0 === NativeDate) throw new Error("The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)");
         isPresent.Date = !0;
         /**
-	     * The PerformanceEntry object encapsulates a single performance metric
-	     * that is part of the browser's performance timeline.
-	     *
-	     * This is an object returned by the `mark` and `measure` methods on the Performance prototype
-	     */
+     * The PerformanceEntry object encapsulates a single performance metric
+     * that is part of the browser's performance timeline.
+     *
+     * This is an object returned by the `mark` and `measure` methods on the Performance prototype
+     */
         class FakePerformanceEntry {
             constructor(name, entryType, startTime, duration) {
                 this.name = name, this.entryType = entryType, this.startTime = startTime, this.duration = duration;
@@ -8639,27 +8634,27 @@ var fakeTimersSrcExports = function() {
             }
         }
         /**
-	     * @param {number} num
-	     * @returns {boolean}
-	     */        let isNearInfiniteLimit = !1;
+     * @param {number} num
+     * @returns {boolean}
+     */        let isNearInfiniteLimit = !1;
         /**
-	     * @param {Clock} clock
-	     * @param {number} i
-	     */        function checkIsNearInfiniteLimit(clock, i) {
+     * @param {Clock} clock
+     * @param {number} i
+     */        function checkIsNearInfiniteLimit(clock, i) {
             clock.loopLimit && i === clock.loopLimit - 1 && (isNearInfiniteLimit = !0);
         }
         /**
-	     *
-	     */        function resetIsNearInfiniteLimit() {
+     *
+     */        function resetIsNearInfiniteLimit() {
             isNearInfiniteLimit = !1;
         }
         /**
-	     * 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) {
+     * 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(":"), l = strings.length;
             let parsed, i = l, ms = 0;
@@ -8671,17 +8666,17 @@ var fakeTimersSrcExports = function() {
             return 1e3 * ms;
         }
         /**
-	     * 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
-	     */        
+     * 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
+     */        
         /**
-	     * Used to grok the `now` parameter to createClock.
-	     * @param {Date|number} epoch the system time
-	     * @returns {number}
-	     */
+     * 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 ("function" == typeof epoch.getTime) return epoch.getTime();
@@ -8689,17 +8684,17 @@ var fakeTimersSrcExports = function() {
             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) {
+     * @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) {
+     * @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;
             const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
@@ -8721,15 +8716,15 @@ var fakeTimersSrcExports = function() {
         function createDate() {
             class ClockDate extends NativeDate {
                 /**
-	             * @param {number} year
-	             * @param {number} month
-	             * @param {number} date
-	             * @param {number} hour
-	             * @param {number} minute
-	             * @param {number} second
-	             * @param {number} ms
-	             * @returns void
-	             */
+         * @param {number} year
+         * @param {number} month
+         * @param {number} date
+         * @param {number} hour
+         * @param {number} minute
+         * @param {number} second
+         * @param {number} ms
+         * @returns void
+         */
                 constructor(year, month, date, hour, minute, second, ms) {
                     0 === arguments.length ? super(ClockDate.clock.now) : super(...arguments), Object.defineProperty(this, "constructor", {
                         value: NativeDate,
@@ -8755,13 +8750,13 @@ var fakeTimersSrcExports = function() {
             });
         }
         /**
-	     * Mirror Intl by default on our fake implementation
-	     *
-	     * Most of the properties are the original native ones,
-	     * but we need to take control of those that have a
-	     * dependency on the current clock.
-	     * @returns {object} the partly fake Intl implementation
-	     */        function runJobs(clock) {
+     * Mirror Intl by default on our fake implementation
+     *
+     * Most of the properties are the original native ones,
+     * but we need to take control of those that have a
+     * dependency on the current clock.
+     * @returns {object} the partly fake Intl implementation
+     */        function runJobs(clock) {
             if (clock.jobs) {
                 for (let i = 0; i < clock.jobs.length; i++) {
                     const job = clock.jobs[i];
@@ -8771,10 +8766,10 @@ var fakeTimersSrcExports = function() {
             }
         }
         /**
-	     * @param {Clock} clock
-	     * @param {Timer} timer
-	     * @returns {number} id of the created timer
-	     */        function addTimer(clock, timer) {
+     * @param {Clock} clock
+     * @param {Timer} timer
+     * @returns {number} id of the created timer
+     */        function addTimer(clock, timer) {
             if (void 0 === timer.func) throw new Error("Callback must be provided to timer calls");
             if (addTimerReturnsObject && "function" != typeof timer.func) throw new TypeError(`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`);
             var num;
@@ -8812,19 +8807,19 @@ var fakeTimersSrcExports = function() {
             return timer.id;
         }
         /**
-	     * Timer comparitor
-	     * @param {Timer} a
-	     * @param {Timer} b
-	     * @returns {number}
-	     */        function compareTimers(a, b) {
+     * Timer comparitor
+     * @param {Timer} a
+     * @param {Timer} b
+     * @returns {number}
+     */        function compareTimers(a, b) {
             return a.callAt < b.callAt ? -1 : a.callAt > b.callAt ? 1 : a.immediate && !b.immediate ? -1 : !a.immediate && b.immediate ? 1 : a.createdAt < b.createdAt ? -1 : a.createdAt > b.createdAt ? 1 : a.id < b.id ? -1 : a.id > b.id ? 1 : void 0;
         }
         /**
-	     * @param {Clock} clock
-	     * @param {number} from
-	     * @param {number} to
-	     * @returns {Timer}
-	     */        function firstTimerInRange(clock, from, to) {
+     * @param {Clock} clock
+     * @param {number} from
+     * @param {number} to
+     * @returns {Timer}
+     */        function firstTimerInRange(clock, from, to) {
             const timers = clock.timers;
             let id, isInRange, timer = null;
             for (id in timers) timers.hasOwnProperty(id) && (isInRange = inRange(from, to, timers[id]), 
@@ -8832,45 +8827,45 @@ var fakeTimersSrcExports = function() {
             return timer;
         }
         /**
-	     * @param {Clock} clock
-	     * @returns {Timer}
-	     */        function firstTimer(clock) {
+     * @param {Clock} clock
+     * @returns {Timer}
+     */        function firstTimer(clock) {
             const timers = clock.timers;
             let id, timer = null;
             for (id in timers) timers.hasOwnProperty(id) && (timer && 1 !== compareTimers(timer, timers[id]) || (timer = timers[id]));
             return timer;
         }
         /**
-	     * @param {Clock} clock
-	     * @returns {Timer}
-	     */        function lastTimer(clock) {
+     * @param {Clock} clock
+     * @returns {Timer}
+     */        function lastTimer(clock) {
             const timers = clock.timers;
             let id, timer = null;
             for (id in timers) timers.hasOwnProperty(id) && (timer && -1 !== compareTimers(timer, timers[id]) || (timer = timers[id]));
             return timer;
         }
         /**
-	     * @param {Clock} clock
-	     * @param {Timer} timer
-	     */        function callTimer(clock, timer) {
+     * @param {Clock} clock
+     * @param {Timer} timer
+     */        function callTimer(clock, timer) {
             if ("number" == typeof timer.interval ? clock.timers[timer.id].callAt += timer.interval : delete clock.timers[timer.id], 
             "function" == typeof timer.func) timer.func.apply(null, timer.args); else {
                 (0, eval)(timer.func);
             }
         }
         /**
-	     * Gets clear handler name for a given timer type
-	     * @param {string} ttype
-	     */        function getClearHandler(ttype) {
+     * Gets clear handler name for a given timer type
+     * @param {string} ttype
+     */        function getClearHandler(ttype) {
             return "IdleCallback" === ttype || "AnimationFrame" === ttype ? `cancel${ttype}` : `clear${ttype}`;
         }
         /**
-	     * Gets schedule handler name for a given timer type
-	     * @param {string} ttype
-	     */        const warnOnce = 
+     * Gets schedule handler name for a given timer type
+     * @param {string} ttype
+     */        const warnOnce = 
         /**
-	     * Creates an anonymous function to warn only once
-	     */
+     * Creates an anonymous function to warn only once
+     */
         function() {
             let calls = 0;
             return function(msg) {
@@ -8878,10 +8873,10 @@ var fakeTimersSrcExports = function() {
             };
         }();
         /**
-	     * @param {Clock} clock
-	     * @param {number} timerId
-	     * @param {string} ttype
-	     */        function clearTimer(clock, timerId, ttype) {
+     * @param {Clock} clock
+     * @param {number} timerId
+     * @param {string} ttype
+     */        function clearTimer(clock, timerId, ttype) {
             if (!timerId) return;
             clock.timers || (clock.timers = {});
             const id = Number(timerId);
@@ -8905,14 +8900,14 @@ var fakeTimersSrcExports = function() {
             }
         }
         /**
-	     * @param {Clock} clock
-	     * @returns {Timer[]}
-	     */        
+     * @param {Clock} clock
+     * @returns {Timer[]}
+     */        
         /**
-	     * @param {object} target the target containing the method to replace
-	     * @param {string} method the keyname of the method on the target
-	     * @param {Clock} clock
-	     */
+     * @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) {
             if (clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method), 
             clock[`_${method}`] = target[method], "Date" === method) target[method] = clock[method]; else if ("Intl" === method) target[method] = clock[method]; else if ("performance" === method) {
@@ -8928,30 +8923,30 @@ var fakeTimersSrcExports = function() {
             target[method].clock = clock;
         }
         /**
-	     * @param {Clock} clock
-	     * @param {number} advanceTimeDelta
-	     */        function doIntervalTick(clock, advanceTimeDelta) {
+     * @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 {Intl} Intl
-	     * @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
-	     */
+     * @typedef {object} Timers
+     * @property {setTimeout} setTimeout
+     * @property {clearTimeout} clearTimeout
+     * @property {setInterval} setInterval
+     * @property {clearInterval} clearInterval
+     * @property {Date} Date
+     * @property {Intl} Intl
+     * @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,
@@ -8968,10 +8963,10 @@ var fakeTimersSrcExports = function() {
         isPresent.Intl && (timers.Intl = NativeIntl);
         const originalSetTimeout = _global.setImmediate || _global.setTimeout, originalClearInterval = _global.clearInterval, originalSetInterval = _global.setInterval;
         /**
-	     * @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}
-	     */
+     * @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) {
             start = Math.floor(getEpoch(start)), loopLimit = loopLimit || 1e3;
             let nanos = 0;
@@ -8999,13 +8994,13 @@ var fakeTimersSrcExports = function() {
                 return [ secsSinceStart, remainderInNanos ];
             }
             /**
-	         * A high resolution timestamp in milliseconds.
-	         * @typedef {number} DOMHighResTimeStamp
-	         */
+       * A high resolution timestamp in milliseconds.
+       * @typedef {number} DOMHighResTimeStamp
+       */
             /**
-	         * performance.now()
-	         * @returns {DOMHighResTimeStamp}
-	         */            function fakePerformanceNow() {
+       * performance.now()
+       * @returns {DOMHighResTimeStamp}
+       */            function fakePerformanceNow() {
                 const hrt = hrtime();
                 return 1e3 * hrt[0] + hrt[1] / 1e6;
             }
@@ -9019,12 +9014,12 @@ var fakeTimersSrcExports = function() {
                 }));
             }
             /**
-	         * @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
-	         */
+       * @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 = "number" == typeof tickValue ? tickValue : parseTime(tickValue), ms = Math.floor(msFloat), remainder = function(msFloat) {
                     const remainder = 1e6 * msFloat % 1e6, positiveRemainder = remainder < 0 ? remainder + 1e6 : remainder;
@@ -9074,9 +9069,9 @@ var fakeTimersSrcExports = function() {
                 }, 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
-	         */            return clock.Date.clock = clock, isPresent.hrtimeBigint && (hrtime.bigint = function() {
+       * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+       * @returns {number} will return the new `now` value
+       */            return clock.Date.clock = clock, isPresent.hrtimeBigint && (hrtime.bigint = function() {
                 const parts = hrtime();
                 return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
             }), isPresent.Intl && (clock.Intl = function() {
@@ -9096,8 +9091,8 @@ var fakeTimersSrcExports = function() {
                 ClockIntl;
             }(), clock.Intl.clock = clock)
             /**
-	         * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
-	         */ , clock.setTickMode = function(tickModeConfig) {
+       * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
+       */ , clock.setTickMode = function(tickModeConfig) {
                 const {mode: newMode, delta: newDelta} = tickModeConfig, {mode: oldMode, delta: oldDelta} = clock.tickMode;
                 newMode === oldMode && newDelta === oldDelta || ("interval" === oldMode && originalClearInterval(clock.attachedInterval), 
                 clock.tickMode = {
@@ -9125,9 +9120,9 @@ var fakeTimersSrcExports = function() {
                     clock.attachedInterval = intervalId;
                 }
                 /**
-	     * @param {Config=} [config] Optional config
-	     * @returns {Clock}
-	     */ (clock, newDelta || 20));
+     * @param {Config=} [config] Optional config
+     * @returns {Clock}
+     */ (clock, newDelta || 20));
             }, clock.requestIdleCallback = function(func, timeout) {
                 let timeToNextIdlePeriod = 0;
                 clock.countTimers() > 0 && (timeToNextIdlePeriod = 50);
@@ -9211,9 +9206,9 @@ var fakeTimersSrcExports = function() {
                 return doTick(tickValue, !1);
             }, void 0 !== _global.Promise && (
             /**
-	             * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
-	             * @returns {Promise}
-	             */
+         * @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+         * @returns {Promise}
+         */
             clock.tickAsync = function(tickValue) {
                 return pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
                     originalSetTimeout(function() {
@@ -9271,8 +9266,8 @@ var fakeTimersSrcExports = function() {
                 return pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
                     let i = 0;
                     /**
-	                         *
-	                         */                    !function doRun() {
+             *
+             */                    !function doRun() {
                         originalSetTimeout(function() {
                             try {
                                 let numTimers;
@@ -9312,9 +9307,9 @@ var fakeTimersSrcExports = function() {
                 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
-	         */
+       * @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(tickValue) {
                 const msFloat = "number" == typeof tickValue ? tickValue : parseTime(tickValue), ms = Math.floor(msFloat);
                 for (const timer of Object.values(clock.timers)) clock.now + ms > timer.callAt && (timer.callAt = clock.now + ms);
@@ -9332,9 +9327,9 @@ var fakeTimersSrcExports = function() {
                 config.advanceTimeDelta = config.advanceTimeDelta || 20, config.shouldClearNativeTimers = config.shouldClearNativeTimers || !1, 
                 config.target) throw new TypeError("config.target is no longer supported. Use `withGlobal(target)` instead.");
                 /**
-	         * @param {string} timer/object the name of the thing that is not present
-	         * @param timer
-	         */                function handleMissingTimer(timer) {
+       * @param {string} timer/object the name of the thing that is not present
+       * @param timer
+       */                function handleMissingTimer(timer) {
                     if (!config.ignoreMissingTimers) throw new ReferenceError(`non-existent timers and/or objects cannot be faked: '${timer}'`);
                 }
                 let i, l;
@@ -9476,12 +9471,12 @@ var fakeTimersSrcExports = function() {
         };
     }
     /**
-	 * @typedef {object} FakeTimers
-	 * @property {Timers} timers
-	 * @property {createClock} createClock
-	 * @property {Function} install
-	 * @property {withGlobal} withGlobal
-	 */
+   * @typedef {object} FakeTimers
+   * @property {Timers} timers
+   * @property {createClock} createClock
+   * @property {Function} install
+   * @property {withGlobal} withGlobal
+   */
     /** @type {FakeTimers} */    const defaultImplementation = withGlobal(globalObject);
     return fakeTimersSrc.timers = defaultImplementation.timers, fakeTimersSrc.createClock = defaultImplementation.createClock, 
     fakeTimersSrc.install = defaultImplementation.install, fakeTimersSrc.withGlobal = withGlobal, 
@@ -9955,8 +9950,8 @@ use((chai, utils) => {
         return a.length === b.length && a.every((aItem, i) => equals(aItem, b[i], [ ...customTesters, iterableEquality ]));
     }
     /**
-	* Used for `toHaveBeenCalledBefore` and `toHaveBeenCalledAfter` to determine if the expected spy was called before the result spy.
-	*/
+  * Used for `toHaveBeenCalledBefore` and `toHaveBeenCalledAfter` to determine if the expected spy was called before the result spy.
+  */
     function isSpyCalledBeforeAnotherSpy(beforeSpy, afterSpy, failIfNoFirstInvocation) {
         const beforeInvocationCallOrder = beforeSpy.mock.invocationCallOrder, afterInvocationCallOrder = afterSpy.mock.invocationCallOrder;
         return 0 === beforeInvocationCallOrder.length ? !failIfNoFirstInvocation : 0 !== afterInvocationCallOrder.length && beforeInvocationCallOrder[0] < afterInvocationCallOrder[0];