@cartanova/qgrid-cli 2.4.8 → 2.5.0

package/bundle/dist/node_modules/.pnpm/vitest@4.1.10_@opentelemetry_api@1.9.0_@types_node@25.0.7_@vitest_coverage-v8@4.1.10_ms_f9cfcfeddd63e656d4010c98521af26c/node_modules/vitest/dist/chunks/test.DNmyFkvJ.js

@@ -0,0 +1,3044 @@
+import { assertTypes, createDefer, createSimpleStackTrace } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js";
+import { processError } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/error.js";
+import { delay, getSafeTimers } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/timers.js";
+import { parseSingleStack } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/source-map.js";
+import { n as normalize } from "../../../../../pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.js";
+import "../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+import { G as getNames, J as getTestName, K as getTests, Q as matchesTags, g as createTaskCollector, i as getCurrentSuite, j as getCurrentTest, k as getFn, l as getHooks, w as updateTask, y as createChainable } from "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/chunk-artifact.js";
+import "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/index.js";
+import "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/utils.js";
+import { g as getWorkerState, i as isChildProcess, r as resetModules, w as waitForImportsToResolve } from "./utils.BX5Fg8C4.js";
+import { a as getBenchOptions, g as getBenchFn } from "./benchmark.CX_oY03V.js";
+import { clearAllMocks, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn } from "../../../../../@vitest_spy@4.1.10/node_modules/@vitest/spy/dist/index.js";
+import { Assertion, assert as assert$1, expect, should as should$1, use, util as utils_exports } from "../../../../../chai@6.2.2/node_modules/chai/index.js";
+import { ASYMMETRIC_MATCHERS_OBJECT, ChaiStyleAssertions, GLOBAL_EXPECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, addCustomEqualityTesters, createAssertionMessage, customMatchers, equals, getState, iterableEquality, recordAsyncExpect, setState, subsetEquality, wrapAssertion } from "../../../../../@vitest_expect@4.1.10/node_modules/@vitest/expect/dist/index.js";
+import "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/offset.js";
+import { c as commonjsGlobal } from "./_commonjsHelpers.D26ty3Ew.js";
+import { R as RealDate, b as resetDate, m as mockDate, r as rpc } from "./rpc.MzXet3jl.js";
+import { SnapshotClient, addSerializer, stripSnapshotIndentation } from "../../../../../@vitest_snapshot@4.1.10/node_modules/@vitest/snapshot/dist/index.js";
+//#region ../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_ms_f9cfcfeddd63e656d4010c98521af26c/node_modules/vitest/dist/chunks/test.DNmyFkvJ.js
+var fakeTimersSrc = {};
+var global;
+var hasRequiredGlobal;
+function requireGlobal() {
+	if (hasRequiredGlobal) return global;
+	hasRequiredGlobal = 1;
+	/**
+	* A reference to the global object
+	* @type {object} globalObject
+	*/
+	var globalObject;
+	/* istanbul ignore else */
+	if (typeof commonjsGlobal !== "undefined") globalObject = commonjsGlobal;
+	else if (typeof window !== "undefined") globalObject = window;
+	else globalObject = self;
+	global = globalObject;
+	return global;
+}
+var throwsOnProto_1;
+var hasRequiredThrowsOnProto;
+function requireThrowsOnProto() {
+	if (hasRequiredThrowsOnProto) return throwsOnProto_1;
+	hasRequiredThrowsOnProto = 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}
+	*/
+	let throwsOnProto;
+	try {
+		({}).__proto__;
+		throwsOnProto = false;
+	} catch (_) {
+		/* istanbul ignore next */
+		throwsOnProto = true;
+	}
+	throwsOnProto_1 = throwsOnProto;
+	return throwsOnProto_1;
+}
+var copyPrototypeMethods;
+var hasRequiredCopyPrototypeMethods;
+function requireCopyPrototypeMethods() {
+	if (hasRequiredCopyPrototypeMethods) return copyPrototypeMethods;
+	hasRequiredCopyPrototypeMethods = 1;
+	var call = Function.call;
+	var throwsOnProto = requireThrowsOnProto();
+	var disallowedProperties = [
+		"size",
+		"caller",
+		"callee",
+		"arguments"
+	];
+	/* istanbul ignore next */
+	if (throwsOnProto) disallowedProperties.push("__proto__");
+	copyPrototypeMethods = function copyPrototypeMethods(prototype) {
+		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));
+	};
+	return copyPrototypeMethods;
+}
+var array;
+var hasRequiredArray;
+function requireArray() {
+	if (hasRequiredArray) return array;
+	hasRequiredArray = 1;
+	array = requireCopyPrototypeMethods()(Array.prototype);
+	return array;
+}
+var calledInOrder_1;
+var hasRequiredCalledInOrder;
+function requireCalledInOrder() {
+	if (hasRequiredCalledInOrder) return calledInOrder_1;
+	hasRequiredCalledInOrder = 1;
+	var every = requireArray().every;
+	/**
+	* @private
+	*/
+	function hasCallsLeft(callMap, spy) {
+		if (callMap[spy.id] === void 0) 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) {
+		return every(arguments.length > 1 ? arguments : spies, checkAdjacentCalls.bind(null, {}));
+	}
+	calledInOrder_1 = calledInOrder;
+	return calledInOrder_1;
+}
+var className_1;
+var hasRequiredClassName;
+function requireClassName() {
+	if (hasRequiredClassName) return className_1;
+	hasRequiredClassName = 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
+	*/
+	function className(value) {
+		return value.constructor && value.constructor.name || null;
+	}
+	className_1 = className;
+	return className_1;
+}
+var deprecated = {};
+var hasRequiredDeprecated;
+function requireDeprecated() {
+	if (hasRequiredDeprecated) return deprecated;
+	hasRequiredDeprecated = 1;
+	(function(exports$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}
+		*/
+		exports$1.wrap = function(func, msg) {
+			var wrapped = function() {
+				exports$1.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$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}
+		*/
+		exports$1.printWarning = function(msg) {
+			/* istanbul ignore next */
+			if (typeof process === "object" && process.emitWarning) process.emitWarning(msg);
+			else if (console.info) console.info(msg);
+			else console.log(msg);
+		};
+	})(deprecated);
+	return deprecated;
+}
+var every;
+var hasRequiredEvery;
+function requireEvery() {
+	if (hasRequiredEvery) return every;
+	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}
+	*/
+	every = function every(obj, fn) {
+		var pass = true;
+		try {
+			obj.forEach(function() {
+				if (!fn.apply(this, arguments)) throw new Error();
+			});
+		} catch (e) {
+			pass = false;
+		}
+		return pass;
+	};
+	return every;
+}
+var functionName;
+var hasRequiredFunctionName;
+function requireFunctionName() {
+	if (hasRequiredFunctionName) return functionName;
+	hasRequiredFunctionName = 1;
+	/**
+	* Returns a display name for a function
+	* @param  {Function} func
+	* @returns {string}
+	*/
+	functionName = function functionName(func) {
+		if (!func) return "";
+		try {
+			return func.displayName || func.name || (String(func).match(/function ([^\s(]+)/) || [])[1];
+		} catch (e) {
+			return "";
+		}
+	};
+	return functionName;
+}
+var orderByFirstCall_1;
+var hasRequiredOrderByFirstCall;
+function requireOrderByFirstCall() {
+	if (hasRequiredOrderByFirstCall) return orderByFirstCall_1;
+	hasRequiredOrderByFirstCall = 1;
+	var sort = requireArray().sort;
+	var slice = requireArray().slice;
+	/**
+	* @private
+	*/
+	function comparator(a, b) {
+		var aCall = a.getCall(0);
+		var 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
+	*/
+	/**
+	* 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);
+	}
+	orderByFirstCall_1 = orderByFirstCall;
+	return orderByFirstCall_1;
+}
+var _function;
+var hasRequired_function;
+function require_function() {
+	if (hasRequired_function) return _function;
+	hasRequired_function = 1;
+	_function = requireCopyPrototypeMethods()(Function.prototype);
+	return _function;
+}
+var map;
+var hasRequiredMap;
+function requireMap() {
+	if (hasRequiredMap) return map;
+	hasRequiredMap = 1;
+	map = requireCopyPrototypeMethods()(Map.prototype);
+	return map;
+}
+var object;
+var hasRequiredObject;
+function requireObject() {
+	if (hasRequiredObject) return object;
+	hasRequiredObject = 1;
+	object = requireCopyPrototypeMethods()(Object.prototype);
+	return object;
+}
+var set;
+var hasRequiredSet;
+function requireSet() {
+	if (hasRequiredSet) return set;
+	hasRequiredSet = 1;
+	set = requireCopyPrototypeMethods()(Set.prototype);
+	return set;
+}
+var string;
+var hasRequiredString;
+function requireString() {
+	if (hasRequiredString) return string;
+	hasRequiredString = 1;
+	string = requireCopyPrototypeMethods()(String.prototype);
+	return string;
+}
+var prototypes;
+var hasRequiredPrototypes;
+function requirePrototypes() {
+	if (hasRequiredPrototypes) return prototypes;
+	hasRequiredPrototypes = 1;
+	prototypes = {
+		array: requireArray(),
+		function: require_function(),
+		map: requireMap(),
+		object: requireObject(),
+		set: requireSet(),
+		string: requireString()
+	};
+	return prototypes;
+}
+var typeDetect$1 = { exports: {} };
+var typeDetect = typeDetect$1.exports;
+var hasRequiredTypeDetect;
+function requireTypeDetect() {
+	if (hasRequiredTypeDetect) return typeDetect$1.exports;
+	hasRequiredTypeDetect = 1;
+	(function(module, exports$1) {
+		(function(global, factory) {
+			module.exports = factory();
+		})(typeDetect, (function() {
+			var promiseExists = typeof Promise === "function";
+			var globalObject = typeof self === "object" ? self : commonjsGlobal;
+			var symbolExists = typeof Symbol !== "undefined";
+			var mapExists = typeof Map !== "undefined";
+			var setExists = typeof Set !== "undefined";
+			var weakMapExists = typeof WeakMap !== "undefined";
+			var weakSetExists = typeof WeakSet !== "undefined";
+			var dataViewExists = typeof DataView !== "undefined";
+			var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== "undefined";
+			var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== "undefined";
+			var setEntriesExists = setExists && typeof Set.prototype.entries === "function";
+			var mapEntriesExists = mapExists && typeof Map.prototype.entries === "function";
+			var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Set()).entries());
+			var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Map()).entries());
+			var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === "function";
+			var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
+			var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === "function";
+			var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]());
+			var toStringLeftSliceLength = 8;
+			var 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
+			*/
+			function typeDetect(obj) {
+				var typeofObj = typeof obj;
+				if (typeofObj !== "object") return typeofObj;
+				if (obj === null) return "null";
+				if (obj === globalObject) return "global";
+				if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) return "Array";
+				if (typeof window === "object" && window !== null) {
+					if (typeof window.location === "object" && obj === window.location) return "Location";
+					if (typeof window.document === "object" && obj === window.document) return "Document";
+					if (typeof window.navigator === "object") {
+						if (typeof window.navigator.mimeTypes === "object" && obj === window.navigator.mimeTypes) return "MimeTypeArray";
+						if (typeof window.navigator.plugins === "object" && obj === window.navigator.plugins) return "PluginArray";
+					}
+					if ((typeof window.HTMLElement === "function" || typeof window.HTMLElement === "object") && obj instanceof window.HTMLElement) {
+						if (obj.tagName === "BLOCKQUOTE") return "HTMLQuoteElement";
+						if (obj.tagName === "TD") return "HTMLTableDataCellElement";
+						if (obj.tagName === "TH") return "HTMLTableHeaderCellElement";
+					}
+				}
+				var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
+				if (typeof stringTag === "string") return stringTag;
+				var objPrototype = Object.getPrototypeOf(obj);
+				if (objPrototype === RegExp.prototype) return "RegExp";
+				if (objPrototype === Date.prototype) return "Date";
+				if (promiseExists && objPrototype === Promise.prototype) return "Promise";
+				if (setExists && objPrototype === Set.prototype) return "Set";
+				if (mapExists && objPrototype === Map.prototype) return "Map";
+				if (weakSetExists && objPrototype === WeakSet.prototype) return "WeakSet";
+				if (weakMapExists && objPrototype === WeakMap.prototype) return "WeakMap";
+				if (dataViewExists && objPrototype === DataView.prototype) return "DataView";
+				if (mapExists && objPrototype === mapIteratorPrototype) return "Map Iterator";
+				if (setExists && objPrototype === setIteratorPrototype) return "Set Iterator";
+				if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) return "Array Iterator";
+				if (stringIteratorExists && objPrototype === stringIteratorPrototype) return "String Iterator";
+				if (objPrototype === null) return "Object";
+				return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
+			}
+			return typeDetect;
+		}));
+	})(typeDetect$1);
+	return typeDetect$1.exports;
+}
+var typeOf;
+var hasRequiredTypeOf;
+function requireTypeOf() {
+	if (hasRequiredTypeOf) return typeOf;
+	hasRequiredTypeOf = 1;
+	var type = requireTypeDetect();
+	/**
+	* Returns the lower-case result of running type from type-detect on the value
+	* @param  {*} value
+	* @returns {string}
+	*/
+	typeOf = function typeOf(value) {
+		return type(value).toLowerCase();
+	};
+	return typeOf;
+}
+var valueToString_1;
+var hasRequiredValueToString;
+function requireValueToString() {
+	if (hasRequiredValueToString) return valueToString_1;
+	hasRequiredValueToString = 1;
+	/**
+	* Returns a string representation of the value
+	* @param  {*} value
+	* @returns {string}
+	*/
+	function valueToString(value) {
+		if (value && value.toString) return value.toString();
+		return String(value);
+	}
+	valueToString_1 = valueToString;
+	return valueToString_1;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	lib = {
+		global: requireGlobal(),
+		calledInOrder: requireCalledInOrder(),
+		className: requireClassName(),
+		deprecated: requireDeprecated(),
+		every: requireEvery(),
+		functionName: requireFunctionName(),
+		orderByFirstCall: requireOrderByFirstCall(),
+		prototypes: requirePrototypes(),
+		typeOf: requireTypeOf(),
+		valueToString: requireValueToString()
+	};
+	return lib;
+}
+var hasRequiredFakeTimersSrc;
+function requireFakeTimersSrc() {
+	if (hasRequiredFakeTimersSrc) return fakeTimersSrc;
+	hasRequiredFakeTimersSrc = 1;
+	const globalObject = requireLib().global;
+	let timersModule, timersPromisesModule;
+	if (typeof __vitest_required__ !== "undefined") {
+		try {
+			timersModule = __vitest_required__.timers;
+		} catch (e) {}
+		try {
+			timersPromisesModule = __vitest_required__.timersPromises;
+		} catch (e) {}
+	}
+	/**
+	* @typedef {"nextAsync" | "manual" | "interval"} TickMode
+	*/
+	/**
+	* @typedef {object} NextAsyncTickMode
+	* @property {"nextAsync"} mode
+	*/
+	/**
+	* @typedef {object} ManualTickMode
+	* @property {"manual"} mode
+	*/
+	/**
+	* @typedef {object} IntervalTickMode
+	* @property {"interval"} mode
+	* @property {number} [delta]
+	*/
+	/**
+	* @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
+	*/
+	/**
+	* 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 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}
+	*/
+	/**
+	* @typedef RequestAnimationFrame
+	* @property {function(number):void} requestAnimationFrame
+	* @returns {number} - the id
+	*/
+	/**
+	* @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
+	*/
+	/**
+	* 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]
+	*/
+	/**
+	* 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) {
+		const maxTimeout = Math.pow(2, 31) - 1;
+		const idCounterStart = 0xe8d4a51000;
+		const NOOP = function() {};
+		const NOOP_ARRAY = function() {
+			return [];
+		};
+		const isPresent = {};
+		let timeoutResult, addTimerReturnsObject = false;
+		if (_global.setTimeout) {
+			isPresent.setTimeout = true;
+			timeoutResult = _global.setTimeout(NOOP, 0);
+			addTimerReturnsObject = typeof timeoutResult === "object";
+		}
+		isPresent.clearTimeout = Boolean(_global.clearTimeout);
+		isPresent.setInterval = Boolean(_global.setInterval);
+		isPresent.clearInterval = Boolean(_global.clearInterval);
+		isPresent.hrtime = _global.process && typeof _global.process.hrtime === "function";
+		isPresent.hrtimeBigint = isPresent.hrtime && typeof _global.process.hrtime.bigint === "function";
+		isPresent.nextTick = _global.process && typeof _global.process.nextTick === "function";
+		const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
+		isPresent.performance = _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;
+		isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+		isPresent.requestAnimationFrame = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
+		isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
+		isPresent.requestIdleCallback = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
+		isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
+		isPresent.setImmediate = _global.setImmediate && typeof _global.setImmediate === "function";
+		isPresent.clearImmediate = _global.clearImmediate && typeof _global.clearImmediate === "function";
+		isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
+		if (_global.clearTimeout) _global.clearTimeout(timeoutResult);
+		const NativeDate = _global.Date;
+		const NativeIntl = isPresent.Intl ? Object.defineProperties(Object.create(null), Object.getOwnPropertyDescriptors(_global.Intl)) : void 0;
+		let uniqueTimerId = idCounterStart;
+		if (NativeDate === void 0) throw new Error("The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)");
+		isPresent.Date = true;
+		/**
+		* 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;
+			}
+			toJSON() {
+				return JSON.stringify({ ...this });
+			}
+		}
+		/**
+		* @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 * 1e3;
+		}
+		/**
+		* 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 = /* @__PURE__ */ new Error(`Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`);
+			if (!job.error) return infiniteLoopError;
+			const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
+			let clockMethodPattern = new RegExp(String(Object.keys(clock).join("|")));
+			if (addTimerReturnsObject) clockMethodPattern = new RegExp(`\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`);
+			let matchedLineIndex = -1;
+			job.error.stack.split("\n").some(function(line, i) {
+				/* istanbul ignore if */
+				if (line.match(computedTargetPattern)) {
+					matchedLineIndex = i;
+					return true;
+				}
+				if (line.match(clockMethodPattern)) {
+					matchedLineIndex = i;
+					return false;
+				}
+				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) {}
+			return infiniteLoopError;
+		}
+		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
+				*/
+				constructor(year, month, date, hour, minute, second, ms) {
+					if (arguments.length === 0) super(ClockDate.clock.now);
+					else super(...arguments);
+					Object.defineProperty(this, "constructor", {
+						value: NativeDate,
+						enumerable: false
+					});
+				}
+				static [Symbol.hasInstance](instance) {
+					return instance instanceof NativeDate;
+				}
+			}
+			ClockDate.isFake = true;
+			if (NativeDate.now) ClockDate.now = function now() {
+				return ClockDate.clock.now;
+			};
+			if (NativeDate.toSource) ClockDate.toSource = function toSource() {
+				return NativeDate.toSource();
+			};
+			ClockDate.toString = function toString() {
+				return NativeDate.toString();
+			};
+			return new Proxy(ClockDate, { apply() {
+				if (this instanceof ClockDate) throw new TypeError("A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic.");
+				return new NativeDate(ClockDate.clock.now).toString();
+			} });
+		}
+		/**
+		* 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 createIntl() {
+			const ClockIntl = {};
+			Object.getOwnPropertyNames(NativeIntl).forEach((property) => ClockIntl[property] = NativeIntl[property]);
+			ClockIntl.DateTimeFormat = function(...args) {
+				const realFormatter = new NativeIntl.DateTimeFormat(...args);
+				const formatter = {};
+				[
+					"formatRange",
+					"formatRangeToParts",
+					"resolvedOptions"
+				].forEach((method) => {
+					formatter[method] = realFormatter[method].bind(realFormatter);
+				});
+				["format", "formatToParts"].forEach((method) => {
+					formatter[method] = function(date) {
+						return realFormatter[method](date || ClockIntl.clock.now);
+					};
+				});
+				return formatter;
+			};
+			ClockIntl.DateTimeFormat.prototype = Object.create(NativeIntl.DateTimeFormat.prototype);
+			ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf;
+			return ClockIntl;
+		}
+		function enqueueJob(clock, job) {
+			if (!clock.jobs) clock.jobs = [];
+			clock.jobs.push(job);
+		}
+		function runJobs(clock) {
+			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 === void 0) throw new Error("Callback must be provided to timer calls");
+			if (addTimerReturnsObject) {
+				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 = /* @__PURE__ */ 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));
+						clock.timers[timer.id] = timer;
+						return res;
+					},
+					[Symbol.toPrimitive]: function() {
+						return timer.id;
+					}
+				};
+				return res;
+			}
+			return timer.id;
+		}
+		/**
+		* Timer comparitor
+		* @param {Timer} a
+		* @param {Timer} b
+		* @returns {number}
+		*/
+		function compareTimers(a, b) {
+			if (a.callAt < b.callAt) return -1;
+			if (a.callAt > b.callAt) return 1;
+			if (a.immediate && !b.immediate) return -1;
+			if (!a.immediate && b.immediate) return 1;
+			if (a.createdAt < b.createdAt) return -1;
+			if (a.createdAt > b.createdAt) return 1;
+			if (a.id < b.id) return -1;
+			if (a.id > b.id) return 1;
+		}
+		/**
+		* @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 {
+				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) {
+				!calls++ && console.warn(msg);
+			};
+		}
+		const warnOnce = createWarnOnce();
+		/**
+		* @param {Clock} clock
+		* @param {number} timerId
+		* @param {string} ttype
+		*/
+		function clearTimer(clock, timerId, ttype) {
+			if (!timerId) return;
+			if (!clock.timers) clock.timers = {};
+			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) : void 0;
+				}
+				warnOnce(`FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.
+To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`);
+			}
+			if (clock.timers.hasOwnProperty(id)) {
+				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
+		* @returns {Timer[]}
+		*/
+		function uninstall(clock) {
+			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) {}
+				if (clock.timersModuleMethods !== void 0) for (let j = 0; j < clock.timersModuleMethods.length; j++) {
+					const entry = clock.timersModuleMethods[j];
+					timersModule[entry.methodName] = entry.original;
+				}
+				if (clock.timersPromisesModuleMethods !== void 0) for (let j = 0; j < clock.timersPromisesModuleMethods.length; j++) {
+					const entry = clock.timersPromisesModuleMethods[j];
+					timersPromisesModule[entry.methodName] = entry.original;
+				}
+			}
+			clock.setTickMode("manual");
+			clock.methods = [];
+			for (const [listener, signal] of clock.abortListenerMap.entries()) {
+				signal.removeEventListener("abort", listener);
+				clock.abortListenerMap.delete(listener);
+			}
+			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") target[method] = clock[method];
+			else if (method === "Intl") target[method] = clock[method];
+			else if (method === "performance") {
+				const originalPerfDescriptor = Object.getOwnPropertyDescriptor(target, method);
+				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 {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,
+			setInterval: _global.setInterval,
+			clearInterval: _global.clearInterval,
+			Date: _global.Date
+		};
+		if (isPresent.setImmediate) timers.setImmediate = _global.setImmediate;
+		if (isPresent.clearImmediate) timers.clearImmediate = _global.clearImmediate;
+		if (isPresent.hrtime) timers.hrtime = _global.process.hrtime;
+		if (isPresent.nextTick) timers.nextTick = _global.process.nextTick;
+		if (isPresent.performance) timers.performance = _global.performance;
+		if (isPresent.requestAnimationFrame) timers.requestAnimationFrame = _global.requestAnimationFrame;
+		if (isPresent.queueMicrotask) timers.queueMicrotask = _global.queueMicrotask;
+		if (isPresent.cancelAnimationFrame) timers.cancelAnimationFrame = _global.cancelAnimationFrame;
+		if (isPresent.requestIdleCallback) timers.requestIdleCallback = _global.requestIdleCallback;
+		if (isPresent.cancelIdleCallback) timers.cancelIdleCallback = _global.cancelIdleCallback;
+		if (isPresent.Intl) timers.Intl = NativeIntl;
+		const originalSetTimeout = _global.setImmediate || _global.setTimeout;
+		const originalClearInterval = _global.clearInterval;
+		const 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}
+		*/
+		function createClock(start, loopLimit) {
+			start = Math.floor(getEpoch(start));
+			loopLimit = loopLimit || 1e3;
+			let nanos = 0;
+			const adjustedSystemTime = [0, 0];
+			const clock = {
+				now: start,
+				Date: createDate(),
+				loopLimit,
+				tickMode: {
+					mode: "manual",
+					counter: 0,
+					delta: void 0
+				}
+			};
+			clock.Date.clock = clock;
+			function getTimeToNextFrame() {
+				return 16 - (clock.now - start) % 16;
+			}
+			function hrtime(prev) {
+				const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
+				const secsSinceStart = Math.floor(millisSinceStart / 1e3);
+				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];
+			}
+			/**
+			* A high resolution timestamp in milliseconds.
+			* @typedef {number} DOMHighResTimeStamp
+			*/
+			/**
+			* performance.now()
+			* @returns {DOMHighResTimeStamp}
+			*/
+			function fakePerformanceNow() {
+				const hrt = hrtime();
+				return hrt[0] * 1e3 + hrt[1] / 1e6;
+			}
+			if (isPresent.hrtimeBigint) hrtime.bigint = function() {
+				const parts = hrtime();
+				return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
+			};
+			if (isPresent.Intl) {
+				clock.Intl = createIntl();
+				clock.Intl.clock = clock;
+			}
+			/**
+			* @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
+			*/
+			clock.setTickMode = function(tickModeConfig) {
+				const { mode: newMode, delta: newDelta } = tickModeConfig;
+				const { mode: oldMode, delta: oldDelta } = clock.tickMode;
+				if (newMode === oldMode && newDelta === oldDelta) return;
+				if (oldMode === "interval") originalClearInterval(clock.attachedInterval);
+				clock.tickMode = {
+					counter: clock.tickMode.counter + 1,
+					mode: newMode,
+					delta: newDelta
+				};
+				if (newMode === "nextAsync") advanceUntilModeChanges();
+				else if (newMode === "interval") createIntervalTick(clock, newDelta || 20);
+			};
+			async function advanceUntilModeChanges() {
+				async function newMacrotask() {
+					const channel = new MessageChannel();
+					await new Promise((resolve) => {
+						channel.port1.onmessage = () => {
+							resolve();
+							channel.port1.close();
+						};
+						channel.port2.postMessage(void 0);
+					});
+					channel.port1.close();
+					channel.port2.close();
+					await new Promise((resolve) => {
+						originalSetTimeout(resolve);
+					});
+				}
+				const { counter } = clock.tickMode;
+				while (clock.tickMode.counter === counter) {
+					await newMacrotask();
+					if (clock.tickMode.counter !== counter) return;
+					clock.next();
+				}
+			}
+			function pauseAutoTickUntilFinished(promise) {
+				if (clock.tickMode.mode !== "nextAsync") return promise;
+				clock.setTickMode({ mode: "manual" });
+				return promise.finally(() => {
+					clock.setTickMode({ mode: "nextAsync" });
+				});
+			}
+			clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
+				let timeToNextIdlePeriod = 0;
+				if (clock.countTimers() > 0) timeToNextIdlePeriod = 50;
+				const result = addTimer(clock, {
+					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,
+					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,
+					args: Array.prototype.slice.call(arguments, 1),
+					error: isNearInfiniteLimit ? /* @__PURE__ */ new Error() : null
+				});
+			};
+			clock.queueMicrotask = function queueMicrotask(func) {
+				return clock.nextTick(func);
+			};
+			clock.setInterval = function setInterval(func, timeout) {
+				timeout = parseInt(timeout, 10);
+				return addTimer(clock, {
+					func,
+					args: Array.prototype.slice.call(arguments, 2),
+					delay: timeout,
+					interval: timeout
+				});
+			};
+			clock.clearInterval = function clearInterval(timerId) {
+				return clearTimer(clock, timerId, "Interval");
+			};
+			if (isPresent.setImmediate) {
+				clock.setImmediate = function setImmediate(func) {
+					return addTimer(clock, {
+						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,
+					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");
+				if (nanosTotal >= 1e6) {
+					tickTo += 1;
+					nanosTotal -= 1e6;
+				}
+				nanos = nanosTotal;
+				let tickFrom = clock.now;
+				let previous = clock.now;
+				let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall;
+				clock.duringTick = true;
+				oldNow = clock.now;
+				runJobs(clock);
+				if (oldNow !== clock.now) {
+					tickFrom += clock.now - oldNow;
+					tickTo += clock.now - oldNow;
+				}
+				function doTickInner() {
+					timer = firstTimerInRange(clock, tickFrom, tickTo);
+					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) {
+								originalSetTimeout(nextPromiseTick);
+								return;
+							}
+							compensationCheck();
+						}
+						postTimerCall();
+					}
+					oldNow = clock.now;
+					runJobs(clock);
+					if (oldNow !== clock.now) {
+						tickFrom += clock.now - oldNow;
+						tickTo += clock.now - oldNow;
+					}
+					clock.duringTick = false;
+					timer = firstTimerInRange(clock, tickFrom, tickTo);
+					if (timer) try {
+						clock.tick(tickTo - clock.now);
+					} catch (e) {
+						firstException = firstException || e;
+					}
+					else {
+						clock.now = tickTo;
+						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() {
+					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 pauseAutoTickUntilFinished(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 pauseAutoTickUntilFinished(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 pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
+					let i = 0;
+					/**
+					*
+					*/
+					function doRun() {
+						originalSetTimeout(function() {
+							try {
+								runJobs(clock);
+								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 pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
+					originalSetTimeout(function() {
+						try {
+							const timer = lastTimer(clock);
+							if (!timer) {
+								runJobs(clock);
+								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) {
+				const newNow = getEpoch(systemTime);
+				const difference = newNow - clock.now;
+				let id, timer;
+				adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
+				adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
+				clock.now = newNow;
+				nanos = 0;
+				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 (isPresent.performance) {
+				clock.performance = Object.create(null);
+				clock.performance.now = fakePerformanceNow;
+			}
+			if (isPresent.hrtime) clock.hrtime = hrtime;
+			return clock;
+		}
+		function createIntervalTick(clock, delta) {
+			const intervalTick = doIntervalTick.bind(null, clock, delta);
+			clock.attachedInterval = originalSetInterval(intervalTick, delta);
+		}
+		/**
+		* @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) throw new TypeError("Can't install fake timers twice on the same global object.");
+			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.");
+			/**
+			* @param {string} timer/object the name of the thing that is not present
+			* @param timer
+			*/
+			function handleMissingTimer(timer) {
+				if (config.ignoreMissingTimers) return;
+				throw new ReferenceError(`non-existent timers and/or objects cannot be faked: '${timer}'`);
+			}
+			let i, l;
+			const clock = createClock(config.now, config.loopLimit);
+			clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
+			clock.uninstall = function() {
+				return uninstall(clock);
+			};
+			clock.abortListenerMap = /* @__PURE__ */ new Map();
+			clock.methods = config.toFake || [];
+			if (clock.methods.length === 0) clock.methods = Object.keys(timers);
+			if (config.shouldAdvanceTime === true) clock.setTickMode({
+				mode: "interval",
+				delta: config.advanceTimeDelta
+			});
+			if (clock.methods.includes("performance")) {
+				const proto = (() => {
+					if (hasPerformanceConstructorPrototype) return _global.performance.constructor.prototype;
+					if (hasPerformancePrototype) return _global.Performance.prototype;
+				})();
+				if (proto) {
+					Object.getOwnPropertyNames(proto).forEach(function(name) {
+						if (name !== "now") clock.performance[name] = name.indexOf("getEntries") === 0 ? NOOP_ARRAY : NOOP;
+					});
+					clock.performance.mark = (name) => new FakePerformanceEntry(name, "mark", 0, 0);
+					clock.performance.measure = (name) => new FakePerformanceEntry(name, "measure", 0, 100);
+					clock.performance.timeOrigin = getEpoch(config.now);
+				} else if ((config.toFake || []).includes("performance")) return handleMissingTimer("performance");
+			}
+			if (_global === globalObject && timersModule) clock.timersModuleMethods = [];
+			if (_global === globalObject && timersPromisesModule) clock.timersPromisesModuleMethods = [];
+			for (i = 0, l = clock.methods.length; i < l; i++) {
+				const nameOfMethodToReplace = clock.methods[i];
+				if (!isPresent[nameOfMethodToReplace]) {
+					handleMissingTimer(nameOfMethodToReplace);
+					continue;
+				}
+				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);
+				if (clock.timersModuleMethods !== void 0 && timersModule[nameOfMethodToReplace]) {
+					const original = timersModule[nameOfMethodToReplace];
+					clock.timersModuleMethods.push({
+						methodName: nameOfMethodToReplace,
+						original
+					});
+					timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
+				}
+				if (clock.timersPromisesModuleMethods !== void 0) {
+					if (nameOfMethodToReplace === "setTimeout") {
+						clock.timersPromisesModuleMethods.push({
+							methodName: "setTimeout",
+							original: timersPromisesModule.setTimeout
+						});
+						timersPromisesModule.setTimeout = (delay, value, options = {}) => new Promise((resolve, reject) => {
+							const abort = () => {
+								options.signal.removeEventListener("abort", abort);
+								clock.abortListenerMap.delete(abort);
+								clock.clearTimeout(handle);
+								reject(options.signal.reason);
+							};
+							const handle = clock.setTimeout(() => {
+								if (options.signal) {
+									options.signal.removeEventListener("abort", abort);
+									clock.abortListenerMap.delete(abort);
+								}
+								resolve(value);
+							}, delay);
+							if (options.signal) if (options.signal.aborted) abort();
+							else {
+								options.signal.addEventListener("abort", abort);
+								clock.abortListenerMap.set(abort, options.signal);
+							}
+						});
+					} else if (nameOfMethodToReplace === "setImmediate") {
+						clock.timersPromisesModuleMethods.push({
+							methodName: "setImmediate",
+							original: timersPromisesModule.setImmediate
+						});
+						timersPromisesModule.setImmediate = (value, options = {}) => new Promise((resolve, reject) => {
+							const abort = () => {
+								options.signal.removeEventListener("abort", abort);
+								clock.abortListenerMap.delete(abort);
+								clock.clearImmediate(handle);
+								reject(options.signal.reason);
+							};
+							const handle = clock.setImmediate(() => {
+								if (options.signal) {
+									options.signal.removeEventListener("abort", abort);
+									clock.abortListenerMap.delete(abort);
+								}
+								resolve(value);
+							});
+							if (options.signal) if (options.signal.aborted) abort();
+							else {
+								options.signal.addEventListener("abort", abort);
+								clock.abortListenerMap.set(abort, options.signal);
+							}
+						});
+					} else if (nameOfMethodToReplace === "setInterval") {
+						clock.timersPromisesModuleMethods.push({
+							methodName: "setInterval",
+							original: timersPromisesModule.setInterval
+						});
+						timersPromisesModule.setInterval = (delay, value, options = {}) => ({ [Symbol.asyncIterator]: () => {
+							const createResolvable = () => {
+								let resolve, reject;
+								const promise = new Promise((res, rej) => {
+									resolve = res;
+									reject = rej;
+								});
+								promise.resolve = resolve;
+								promise.reject = reject;
+								return promise;
+							};
+							let done = false;
+							let hasThrown = false;
+							let returnCall;
+							let nextAvailable = 0;
+							const nextQueue = [];
+							const handle = clock.setInterval(() => {
+								if (nextQueue.length > 0) nextQueue.shift().resolve();
+								else nextAvailable++;
+							}, delay);
+							const abort = () => {
+								options.signal.removeEventListener("abort", abort);
+								clock.abortListenerMap.delete(abort);
+								clock.clearInterval(handle);
+								done = true;
+								for (const resolvable of nextQueue) resolvable.resolve();
+							};
+							if (options.signal) if (options.signal.aborted) done = true;
+							else {
+								options.signal.addEventListener("abort", abort);
+								clock.abortListenerMap.set(abort, options.signal);
+							}
+							return {
+								next: async () => {
+									if (options.signal?.aborted && !hasThrown) {
+										hasThrown = true;
+										throw options.signal.reason;
+									}
+									if (done) return {
+										done: true,
+										value: void 0
+									};
+									if (nextAvailable > 0) {
+										nextAvailable--;
+										return {
+											done: false,
+											value
+										};
+									}
+									const resolvable = createResolvable();
+									nextQueue.push(resolvable);
+									await resolvable;
+									if (returnCall && nextQueue.length === 0) returnCall.resolve();
+									if (options.signal?.aborted && !hasThrown) {
+										hasThrown = true;
+										throw options.signal.reason;
+									}
+									if (done) return {
+										done: true,
+										value: void 0
+									};
+									return {
+										done: false,
+										value
+									};
+								},
+								return: async () => {
+									if (done) return {
+										done: true,
+										value: void 0
+									};
+									if (nextQueue.length > 0) {
+										returnCall = createResolvable();
+										await returnCall;
+									}
+									clock.clearInterval(handle);
+									done = true;
+									if (options.signal) {
+										options.signal.removeEventListener("abort", abort);
+										clock.abortListenerMap.delete(abort);
+									}
+									return {
+										done: true,
+										value: void 0
+									};
+								}
+							};
+						} });
+					}
+				}
+			}
+			return clock;
+		}
+		return {
+			timers,
+			createClock,
+			install,
+			withGlobal
+		};
+	}
+	/**
+	* @typedef {object} FakeTimers
+	* @property {Timers} timers
+	* @property {createClock} createClock
+	* @property {Function} install
+	* @property {withGlobal} withGlobal
+	*/
+	/** @type {FakeTimers} */
+	const defaultImplementation = withGlobal(globalObject);
+	fakeTimersSrc.timers = defaultImplementation.timers;
+	fakeTimersSrc.createClock = defaultImplementation.createClock;
+	fakeTimersSrc.install = defaultImplementation.install;
+	fakeTimersSrc.withGlobal = withGlobal;
+	return fakeTimersSrc;
+}
+var fakeTimersSrcExports = requireFakeTimersSrc();
+var FakeTimers = class {
+	_global;
+	_clock;
+	_fakingTime;
+	_fakingDate;
+	_fakeTimers;
+	_userConfig;
+	_now = RealDate.now;
+	constructor({ global, config }) {
+		this._userConfig = config;
+		this._fakingDate = null;
+		this._fakingTime = false;
+		this._fakeTimers = fakeTimersSrcExports.withGlobal(global);
+		this._global = global;
+	}
+	clearAllTimers() {
+		if (this._fakingTime) this._clock.reset();
+	}
+	dispose() {
+		this.useRealTimers();
+	}
+	runAllTimers() {
+		if (this._checkFakeTimers()) this._clock.runAll();
+	}
+	async runAllTimersAsync() {
+		if (this._checkFakeTimers()) await this._clock.runAllAsync();
+	}
+	runOnlyPendingTimers() {
+		if (this._checkFakeTimers()) this._clock.runToLast();
+	}
+	async runOnlyPendingTimersAsync() {
+		if (this._checkFakeTimers()) await this._clock.runToLastAsync();
+	}
+	advanceTimersToNextTimer(steps = 1) {
+		if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+			this._clock.next();
+			this._clock.tick(0);
+			if (this._clock.countTimers() === 0) break;
+		}
+	}
+	async advanceTimersToNextTimerAsync(steps = 1) {
+		if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+			await this._clock.nextAsync();
+			this._clock.tick(0);
+			if (this._clock.countTimers() === 0) break;
+		}
+	}
+	advanceTimersByTime(msToRun) {
+		if (this._checkFakeTimers()) this._clock.tick(msToRun);
+	}
+	async advanceTimersByTimeAsync(msToRun) {
+		if (this._checkFakeTimers()) await this._clock.tickAsync(msToRun);
+	}
+	advanceTimersToNextFrame() {
+		if (this._checkFakeTimers()) this._clock.runToFrame();
+	}
+	runAllTicks() {
+		if (this._checkFakeTimers()) this._clock.runMicrotasks();
+	}
+	useRealTimers() {
+		if (this._fakingDate) {
+			resetDate();
+			this._fakingDate = null;
+		}
+		if (this._fakingTime) {
+			this._clock.uninstall();
+			this._fakingTime = false;
+		}
+	}
+	useFakeTimers() {
+		const fakeDate = this._fakingDate || Date.now();
+		if (this._fakingDate) {
+			resetDate();
+			this._fakingDate = null;
+		}
+		if (this._fakingTime) this._clock.uninstall();
+		const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
+		if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
+		this._clock = this._fakeTimers.install({
+			now: fakeDate,
+			...this._userConfig,
+			toFake: this._userConfig?.toFake || toFake,
+			ignoreMissingTimers: true
+		});
+		this._fakingTime = true;
+	}
+	reset() {
+		if (this._checkFakeTimers()) {
+			const { now } = this._clock;
+			this._clock.reset();
+			this._clock.setSystemTime(now);
+		}
+	}
+	setSystemTime(now) {
+		const date = typeof now === "undefined" || now instanceof Date ? now : new Date(now);
+		if (this._fakingTime) this._clock.setSystemTime(date);
+		else {
+			this._fakingDate = date ?? new Date(this.getRealSystemTime());
+			mockDate(this._fakingDate);
+		}
+	}
+	getMockedSystemTime() {
+		return this._fakingTime ? new Date(this._clock.now) : this._fakingDate;
+	}
+	getRealSystemTime() {
+		return this._now();
+	}
+	getTimerCount() {
+		if (this._checkFakeTimers()) return this._clock.countTimers();
+		return 0;
+	}
+	setTimerTickMode(mode, interval) {
+		if (this._checkFakeTimers()) if (mode === "manual") this._clock.setTickMode({ mode: "manual" });
+		else if (mode === "nextTimerAsync") this._clock.setTickMode({ mode: "nextAsync" });
+		else if (mode === "interval") this._clock.setTickMode({
+			mode: "interval",
+			delta: interval
+		});
+		else throw new Error(`Invalid tick mode: ${mode}`);
+	}
+	configure(config) {
+		this._userConfig = config;
+	}
+	isFakeTimers() {
+		return this._fakingTime;
+	}
+	_checkFakeTimers() {
+		if (!this._fakingTime) throw new Error("A function to advance timers was called but the timers APIs are not mocked. Call `vi.useFakeTimers()` in the test file first.");
+		return this._fakingTime;
+	}
+};
+function copyStackTrace$1(target, source) {
+	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
+	return target;
+}
+function waitFor(callback, options = {}) {
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	return new Promise((resolve, reject) => {
+		let lastError;
+		let promiseStatus = "idle";
+		let timeoutId;
+		let intervalId;
+		const onResolve = (result) => {
+			if (timeoutId) clearTimeout(timeoutId);
+			if (intervalId) clearInterval(intervalId);
+			resolve(result);
+		};
+		const handleTimeout = () => {
+			if (intervalId) clearInterval(intervalId);
+			let error = lastError;
+			if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+			reject(error);
+		};
+		const checkCallback = () => {
+			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+			if (promiseStatus === "pending") return;
+			try {
+				const result = callback();
+				if (result !== null && typeof result === "object" && typeof result.then === "function") {
+					const thenable = result;
+					promiseStatus = "pending";
+					thenable.then((resolvedValue) => {
+						promiseStatus = "resolved";
+						onResolve(resolvedValue);
+					}, (rejectedValue) => {
+						promiseStatus = "rejected";
+						lastError = rejectedValue;
+					});
+				} else {
+					onResolve(result);
+					return true;
+				}
+			} catch (error) {
+				lastError = error;
+			}
+		};
+		if (checkCallback() === true) return;
+		timeoutId = setTimeout(handleTimeout, timeout);
+		intervalId = setInterval(checkCallback, interval);
+	});
+}
+function waitUntil(callback, options = {}) {
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	return new Promise((resolve, reject) => {
+		let promiseStatus = "idle";
+		let timeoutId;
+		let intervalId;
+		const onReject = (error) => {
+			if (intervalId) clearInterval(intervalId);
+			if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
+			reject(error);
+		};
+		const onResolve = (result) => {
+			if (!result) return;
+			if (timeoutId) clearTimeout(timeoutId);
+			if (intervalId) clearInterval(intervalId);
+			resolve(result);
+			return true;
+		};
+		const checkCallback = () => {
+			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+			if (promiseStatus === "pending") return;
+			try {
+				const result = callback();
+				if (result !== null && typeof result === "object" && typeof result.then === "function") {
+					const thenable = result;
+					promiseStatus = "pending";
+					thenable.then((resolvedValue) => {
+						promiseStatus = "resolved";
+						onResolve(resolvedValue);
+					}, (rejectedValue) => {
+						promiseStatus = "rejected";
+						onReject(rejectedValue);
+					});
+				} else return onResolve(result);
+			} catch (error) {
+				onReject(error);
+			}
+		};
+		if (checkCallback() === true) return;
+		timeoutId = setTimeout(onReject, timeout);
+		intervalId = setInterval(checkCallback, interval);
+	});
+}
+function createVitest() {
+	let _config = null;
+	const state = () => getWorkerState();
+	let _timers;
+	const timers = () => _timers ||= new FakeTimers({
+		global: globalThis,
+		config: state().config.fakeTimers
+	});
+	const _stubsGlobal = /* @__PURE__ */ new Map();
+	const _stubsEnv = /* @__PURE__ */ new Map();
+	const _envBooleans = [
+		"PROD",
+		"DEV",
+		"SSR"
+	];
+	const utils = {
+		useFakeTimers(config) {
+			if (isChildProcess()) {
+				if (config?.toFake?.includes("nextTick") || state().config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error("vi.useFakeTimers({ toFake: [\"nextTick\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.");
+			}
+			if (config) timers().configure({
+				...state().config.fakeTimers,
+				...config
+			});
+			else timers().configure(state().config.fakeTimers);
+			timers().useFakeTimers();
+			return utils;
+		},
+		isFakeTimers() {
+			return timers().isFakeTimers();
+		},
+		useRealTimers() {
+			timers().useRealTimers();
+			return utils;
+		},
+		runOnlyPendingTimers() {
+			timers().runOnlyPendingTimers();
+			return utils;
+		},
+		async runOnlyPendingTimersAsync() {
+			await timers().runOnlyPendingTimersAsync();
+			return utils;
+		},
+		runAllTimers() {
+			timers().runAllTimers();
+			return utils;
+		},
+		async runAllTimersAsync() {
+			await timers().runAllTimersAsync();
+			return utils;
+		},
+		runAllTicks() {
+			timers().runAllTicks();
+			return utils;
+		},
+		advanceTimersByTime(ms) {
+			timers().advanceTimersByTime(ms);
+			return utils;
+		},
+		async advanceTimersByTimeAsync(ms) {
+			await timers().advanceTimersByTimeAsync(ms);
+			return utils;
+		},
+		advanceTimersToNextTimer() {
+			timers().advanceTimersToNextTimer();
+			return utils;
+		},
+		async advanceTimersToNextTimerAsync() {
+			await timers().advanceTimersToNextTimerAsync();
+			return utils;
+		},
+		advanceTimersToNextFrame() {
+			timers().advanceTimersToNextFrame();
+			return utils;
+		},
+		getTimerCount() {
+			return timers().getTimerCount();
+		},
+		setSystemTime(time) {
+			timers().setSystemTime(time);
+			return utils;
+		},
+		getMockedSystemTime() {
+			return timers().getMockedSystemTime();
+		},
+		getRealSystemTime() {
+			return timers().getRealSystemTime();
+		},
+		clearAllTimers() {
+			timers().clearAllTimers();
+			return utils;
+		},
+		setTimerTickMode(mode, interval) {
+			timers().setTimerTickMode(mode, interval);
+			return utils;
+		},
+		spyOn,
+		fn,
+		waitFor,
+		waitUntil,
+		defineHelper: (fn) => {
+			return function __VITEST_HELPER__(...args) {
+				const result = fn.apply(this, args);
+				if (result && typeof result === "object" && typeof result.then === "function") return (async function __VITEST_HELPER__() {
+					return await result;
+				})();
+				return result;
+			};
+		},
+		hoisted(factory) {
+			assertTypes(factory, "\"vi.hoisted\" factory", ["function"]);
+			return factory();
+		},
+		mock(path, factory) {
+			if (typeof path !== "string") throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
+			const importer = getImporter("mock");
+			_mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
+		},
+		unmock(path) {
+			if (typeof path !== "string") throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);
+			_mocker().queueUnmock(path, getImporter("unmock"));
+		},
+		doMock(path, factory) {
+			if (typeof path !== "string") throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
+			const importer = getImporter("doMock");
+			_mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
+			const rv = {};
+			if (Symbol.dispose) rv[Symbol.dispose] = () => {
+				_mocker().queueUnmock(path, importer);
+			};
+			return rv;
+		},
+		doUnmock(path) {
+			if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
+			const importer = getImporter("doUnmock");
+			_mocker().queueUnmock(path, importer);
+		},
+		async importActual(path) {
+			const importer = getImporter("importActual");
+			return _mocker().importActual(path, importer, _mocker().getMockContext().callstack);
+		},
+		async importMock(path) {
+			const importer = getImporter("importMock");
+			return _mocker().importMock(path, importer);
+		},
+		mockObject(value, options) {
+			return _mocker().mockObject({ value }, void 0, options?.spy ? "autospy" : "automock").value;
+		},
+		mocked(item, _options = {}) {
+			return item;
+		},
+		isMockFunction(fn) {
+			return isMockFunction(fn);
+		},
+		clearAllMocks() {
+			clearAllMocks();
+			return utils;
+		},
+		resetAllMocks() {
+			resetAllMocks();
+			return utils;
+		},
+		restoreAllMocks() {
+			restoreAllMocks();
+			return utils;
+		},
+		stubGlobal(name, value) {
+			if (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
+			Object.defineProperty(globalThis, name, {
+				value,
+				writable: true,
+				configurable: true,
+				enumerable: true
+			});
+			return utils;
+		},
+		stubEnv(name, value) {
+			const env = state().metaEnv;
+			if (!_stubsEnv.has(name)) _stubsEnv.set(name, env[name]);
+			if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
+			else if (value === void 0) delete env[name];
+			else env[name] = String(value);
+			return utils;
+		},
+		unstubAllGlobals() {
+			_stubsGlobal.forEach((original, name) => {
+				if (!original) Reflect.deleteProperty(globalThis, name);
+				else Object.defineProperty(globalThis, name, original);
+			});
+			_stubsGlobal.clear();
+			return utils;
+		},
+		unstubAllEnvs() {
+			const env = state().metaEnv;
+			_stubsEnv.forEach((original, name) => {
+				if (original === void 0) delete env[name];
+				else env[name] = original;
+			});
+			_stubsEnv.clear();
+			return utils;
+		},
+		resetModules() {
+			resetModules(state().evaluatedModules);
+			return utils;
+		},
+		async dynamicImportSettled() {
+			return waitForImportsToResolve();
+		},
+		setConfig(config) {
+			if (!_config) _config = { ...state().config };
+			Object.assign(state().config, config);
+		},
+		resetConfig() {
+			if (_config) Object.assign(state().config, _config);
+		}
+	};
+	return utils;
+}
+const vitest = createVitest();
+const vi = vitest;
+function _mocker() {
+	return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {
+		throw new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);
+	} });
+}
+function getImporter(name) {
+	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n");
+	return parseSingleStack(stackArray[stackArray.findLastIndex((stack) => {
+		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`) || stack.includes(` at ${name} (`);
+	}) + 1])?.file || "";
+}
+const unsupported = [
+	"matchSnapshot",
+	"toMatchSnapshot",
+	"toMatchInlineSnapshot",
+	"toThrowErrorMatchingSnapshot",
+	"toThrowErrorMatchingInlineSnapshot",
+	"throws",
+	"Throw",
+	"throw",
+	"toThrow",
+	"toThrowError"
+];
+/**
+* Attaches a `cause` property to the error if missing, copies the stack trace from the source, and throws.
+*
+* @param error - The error to throw
+* @param source - Error to copy the stack trace from
+*
+* @throws Always throws the provided error with an amended stack trace
+*/
+function throwWithCause(error, source) {
+	if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
+	throw copyStackTrace(error, source);
+}
+function createExpectPoll(expect) {
+	return function poll(fn, options = {}) {
+		const defaults = getWorkerState().config.expect?.poll ?? {};
+		const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+		const assertion = expect(null, message).withContext({ poll: true });
+		fn = fn.bind(assertion);
+		utils_exports.flag(assertion, "_poll.fn", fn);
+		utils_exports.flag(assertion, "_poll.timeout", timeout);
+		utils_exports.flag(assertion, "_poll.interval", interval);
+		const test = utils_exports.flag(assertion, "vitest-test");
+		if (!test) throw new Error("expect.poll() must be called inside a test");
+		const proxy = new Proxy(assertion, { get(target, key, receiver) {
+			const assertionFunction = Reflect.get(target, key, receiver);
+			if (typeof assertionFunction !== "function") return assertionFunction instanceof Assertion ? proxy : assertionFunction;
+			if (key === "assert") return assertionFunction;
+			if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
+			return function __VITEST_POLL_CHAIN__(...args) {
+				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+				const promise = async () => {
+					utils_exports.flag(assertion, "_name", key);
+					utils_exports.flag(assertion, "error", STACK_TRACE_ERROR);
+					const onSettled = utils_exports.flag(assertion, "_poll.onSettled");
+					if (Object.getOwnPropertyDescriptor(assertionFunction, "__vitest_poll_takeover__")?.value) try {
+						const output = await assertionFunction.call(assertion, ...args);
+						await onSettled?.({
+							assertion,
+							status: "pass"
+						});
+						return output;
+					} catch (err) {
+						await onSettled?.({
+							assertion,
+							status: "fail"
+						});
+						throwWithCause(err, STACK_TRACE_ERROR);
+					}
+					const { setTimeout, clearTimeout } = getSafeTimers();
+					let executionPhase = "fn";
+					let hasTimedOut = false;
+					const timerId = setTimeout(() => {
+						hasTimedOut = true;
+					}, timeout);
+					try {
+						while (true) {
+							const isLastAttempt = hasTimedOut;
+							if (isLastAttempt) utils_exports.flag(assertion, "_isLastPollAttempt", true);
+							try {
+								executionPhase = "fn";
+								const obj = await fn();
+								utils_exports.flag(assertion, "object", obj);
+								executionPhase = "assertion";
+								const output = await assertionFunction.call(assertion, ...args);
+								await onSettled?.({
+									assertion,
+									status: "pass"
+								});
+								return output;
+							} catch (err) {
+								if (isLastAttempt || executionPhase === "assertion" && utils_exports.flag(assertion, "_poll.assert_once")) {
+									await onSettled?.({
+										assertion,
+										status: "fail"
+									});
+									throwWithCause(err, STACK_TRACE_ERROR);
+								}
+								await delay(interval, setTimeout);
+								if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+							}
+						}
+					} finally {
+						clearTimeout(timerId);
+					}
+				};
+				let awaited = false;
+				test.onFinished ??= [];
+				test.onFinished.push(() => {
+					if (!awaited) {
+						const negated = utils_exports.flag(assertion, "negate") ? "not." : "";
+						const assertionString = `expect.${utils_exports.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
+						throw copyStackTrace(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\n\nawait ${assertionString}\n`), STACK_TRACE_ERROR);
+					}
+				});
+				let resultPromise;
+				return {
+					then(onFulfilled, onRejected) {
+						awaited = true;
+						return (resultPromise ||= promise()).then(onFulfilled, onRejected);
+					},
+					catch(onRejected) {
+						awaited = true;
+						return (resultPromise ||= promise()).catch(onRejected);
+					},
+					finally(onFinally) {
+						awaited = true;
+						return (resultPromise ||= promise()).finally(onFinally);
+					},
+					[Symbol.toStringTag]: "Promise"
+				};
+			};
+		} });
+		return proxy;
+	};
+}
+function copyStackTrace(target, source) {
+	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
+	return target;
+}
+let _client;
+function getSnapshotClient() {
+	if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
+		return equals(received, expected, [iterableEquality, subsetEquality]);
+	} });
+	return _client;
+}
+function getError(expected, promise) {
+	if (typeof expected !== "function") {
+		if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
+		return expected;
+	}
+	try {
+		expected();
+	} catch (e) {
+		return e;
+	}
+	throw new Error("snapshot function didn't throw");
+}
+function getTestNames(test) {
+	return {
+		filepath: test.file.filepath,
+		name: getNames(test).slice(1).join(" > "),
+		testId: test.id
+	};
+}
+function getAssertionName(assertion) {
+	const name = utils_exports.flag(assertion, "_name");
+	if (!name) throw new Error("Assertion name is not set. This is a bug in Vitest. Please, open a new issue with reproduction.");
+	return name;
+}
+function getTest(obj) {
+	const test = utils_exports.flag(obj, "vitest-test");
+	if (!test) throw new Error(`'${getAssertionName(obj)}' cannot be used without test context`);
+	return test;
+}
+function validateAssertion(assertion) {
+	if (utils_exports.flag(assertion, "negate")) throw new Error(`${getAssertionName(assertion)} cannot be used with "not"`);
+}
+const SnapshotPlugin = (chai, utils) => {
+	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(propertiesOrHint, hint) {
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: utils.flag(this, "object"),
+			...normalizeArguments(propertiesOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(filepath, hint) {
+		utils.flag(this, "_name", "toMatchFileSnapshot");
+		validateAssertion(this);
+		const assertPromise = toMatchFileSnapshotImpl({
+			assertion: this,
+			received: utils.flag(this, "object"),
+			filepath,
+			hint
+		}).then((result) => assertMatchResult(result, chai.util.flag(this, "message")));
+		return recordAsyncExpect(getTest(this), assertPromise, createAssertionMessage(utils, this, true), /* @__PURE__ */ new Error("resolves"), utils.flag(this, "soft"));
+	});
+	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: utils.flag(this, "object"),
+			isInline: true,
+			...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(propertiesOrHint, hint) {
+		validateAssertion(this);
+		const received = utils.flag(this, "object");
+		const promise = utils.flag(this, "promise");
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: getError(received, promise),
+			...normalizeArguments(propertiesOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshotOrHint, hint) {
+		validateAssertion(this);
+		const received = utils.flag(this, "object");
+		const promise = utils.flag(this, "promise");
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: getError(received, promise),
+			isInline: true,
+			...normalizeInlineArguments(void 0, inlineSnapshotOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+};
+function toMatchDomainSnapshotImpl(opts) {
+	const { assertion } = opts;
+	validateAssertion(assertion);
+	const assertionName = getAssertionName(assertion);
+	const test = getTest(assertion);
+	let { inlineSnapshot } = opts;
+	if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+	const pollFn = utils_exports.flag(assertion, "_poll.fn");
+	if (pollFn) return getSnapshotClient().pollMatchDomain({
+		poll: pollFn,
+		adapter: opts.adapter,
+		message: opts.hint,
+		isInline: opts.isInline,
+		errorMessage: utils_exports.flag(assertion, "message"),
+		timeout: utils_exports.flag(assertion, "_poll.timeout"),
+		interval: utils_exports.flag(assertion, "_poll.interval"),
+		assertionName,
+		inlineSnapshot,
+		error: utils_exports.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+	return getSnapshotClient().matchDomain({
+		received: opts.received,
+		adapter: opts.adapter,
+		message: opts.hint,
+		isInline: opts.isInline,
+		errorMessage: utils_exports.flag(assertion, "message"),
+		assertionName,
+		inlineSnapshot,
+		error: utils_exports.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+}
+function normalizeArguments(propertiesOrHint, hint) {
+	if (typeof propertiesOrHint === "string") return { hint: propertiesOrHint };
+	return {
+		properties: propertiesOrHint,
+		hint
+	};
+}
+function normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+	let inlineSnapshot;
+	if (typeof propertiesOrInlineSnapshot === "string") {
+		inlineSnapshot = stripSnapshotIndentation(propertiesOrInlineSnapshot);
+		return {
+			inlineSnapshot,
+			hint: inlineSnapshotOrHint
+		};
+	}
+	if (inlineSnapshotOrHint) inlineSnapshot = stripSnapshotIndentation(inlineSnapshotOrHint);
+	return {
+		properties: propertiesOrInlineSnapshot,
+		inlineSnapshot,
+		hint
+	};
+}
+function toMatchSnapshotImpl(options) {
+	const { assertion } = options;
+	validateAssertion(assertion);
+	const assertionName = getAssertionName(assertion);
+	const test = getTest(assertion);
+	return getSnapshotClient().match({
+		received: options.received,
+		properties: options.properties,
+		message: options.hint,
+		isInline: options.isInline,
+		inlineSnapshot: options.inlineSnapshot,
+		assertionName,
+		error: utils_exports.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+}
+async function toMatchFileSnapshotImpl(options) {
+	const { assertion } = options;
+	validateAssertion(assertion);
+	const testNames = getTestNames(getTest(assertion));
+	const snapshotState = getSnapshotClient().getSnapshotState(testNames.filepath);
+	const rawSnapshotFile = await snapshotState.environment.resolveRawPath(testNames.filepath, options.filepath);
+	const rawSnapshotContent = await snapshotState.environment.readSnapshotFile(rawSnapshotFile);
+	return getSnapshotClient().match({
+		received: options.received,
+		message: options.hint,
+		rawSnapshot: {
+			file: rawSnapshotFile,
+			content: rawSnapshotContent ?? void 0
+		},
+		...testNames
+	});
+}
+function assertMatchResult(result, customMessage) {
+	if (!result.pass) {
+		const errorMessage = (customMessage ? `${customMessage}: ` : "") + result.message();
+		throw Object.assign(new Error(errorMessage), {
+			actual: result.actual,
+			expected: result.expected,
+			diffOptions: { expand: getWorkerState().config.snapshotOptions.expand }
+		});
+	}
+}
+/**
+* Composable snapshot matcher helpers for building custom snapshot matchers
+* with `expect.extend`.
+*
+* @experimental
+* @see https://vitest.dev/guide/snapshot.html#custom-snapshot-matchers
+*/
+const Snapshots = {
+	toMatchSnapshot(received, propertiesOrHint, hint) {
+		return toMatchSnapshotImpl({
+			assertion: this.assertion,
+			received,
+			...normalizeArguments(propertiesOrHint, hint)
+		});
+	},
+	toMatchInlineSnapshot(received, propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+		return toMatchSnapshotImpl({
+			assertion: this.assertion,
+			received,
+			isInline: true,
+			...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)
+		});
+	},
+	toMatchFileSnapshot(received, filepath, hint) {
+		return toMatchFileSnapshotImpl({
+			assertion: this.assertion,
+			received,
+			filepath,
+			hint
+		});
+	},
+	toMatchDomainSnapshot(domain, received) {
+		return toMatchDomainSnapshotImpl({
+			assertion: this.assertion,
+			adapter: domain,
+			received
+		});
+	},
+	toMatchDomainInlineSnapshot(domain, received, inlineSnapshot) {
+		return toMatchDomainSnapshotImpl({
+			assertion: this.assertion,
+			adapter: domain,
+			received,
+			isInline: true,
+			inlineSnapshot
+		});
+	}
+};
+use(JestExtend);
+use(JestChaiExpect);
+use(ChaiStyleAssertions);
+use(SnapshotPlugin);
+use(JestAsymmetricMatchers);
+function createExpect(test) {
+	const expect$1 = ((value, message) => {
+		const { assertionCalls } = getState(expect$1);
+		setState({ assertionCalls: assertionCalls + 1 }, expect$1);
+		const assert = expect(value, message);
+		const _test = test || getCurrentTest();
+		if (_test) return assert.withTest(_test);
+		else return assert;
+	});
+	Object.assign(expect$1, expect);
+	Object.assign(expect$1, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+	expect$1.getState = () => getState(expect$1);
+	expect$1.setState = (state) => setState(state, expect$1);
+	const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
+	setState({
+		...globalState,
+		assertionCalls: 0,
+		isExpectingAssertions: false,
+		isExpectingAssertionsError: null,
+		expectedAssertionsNumber: null,
+		expectedAssertionsNumberErrorGen: null,
+		get testPath() {
+			return getWorkerState().filepath;
+		},
+		currentTestName: test ? test.fullTestName ?? "" : globalState.currentTestName
+	}, expect$1);
+	expect$1.assert = assert$1;
+	expect$1.extend = (matchers) => expect.extend(expect$1, matchers);
+	expect$1.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+	expect$1.soft = (...args) => {
+		return expect$1(...args).withContext({ soft: true });
+	};
+	expect$1.poll = createExpectPoll(expect$1);
+	expect$1.unreachable = (message) => {
+		assert$1.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+	};
+	function assertions(expected) {
+		const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect$1.getState().assertionCalls}`);
+		if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
+		expect$1.setState({
+			expectedAssertionsNumber: expected,
+			expectedAssertionsNumberErrorGen: errorGen
+		});
+	}
+	function hasAssertions() {
+		const error = /* @__PURE__ */ new Error("expected any number of assertion, but got none");
+		if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
+		expect$1.setState({
+			isExpectingAssertions: true,
+			isExpectingAssertionsError: error
+		});
+	}
+	utils_exports.addMethod(expect$1, "assertions", assertions);
+	utils_exports.addMethod(expect$1, "hasAssertions", hasAssertions);
+	expect$1.extend(customMatchers);
+	return expect$1;
+}
+const globalExpect = createExpect();
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
+	value: globalExpect,
+	writable: true,
+	configurable: true
+});
+const assert = assert$1;
+const should = should$1;
+/**
+* Gives access to injected context provided from the main thread.
+* This usually returns a value provided by `globalSetup` or an external library.
+*/
+function inject(key) {
+	return getWorkerState().providedContext[key];
+}
+function createBenchmarkResult(name) {
+	return {
+		name,
+		rank: 0,
+		rme: 0,
+		samples: []
+	};
+}
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
+async function runBenchmarkSuite(suite, runner) {
+	const { Task, Bench } = await runner.importTinybench();
+	const start = performance.now();
+	const benchmarkGroup = [];
+	const benchmarkSuiteGroup = [];
+	for (const task of suite.tasks) {
+		if (task.mode !== "run" && task.mode !== "queued") continue;
+		if (task.meta?.benchmark) benchmarkGroup.push(task);
+		else if (task.type === "suite") benchmarkSuiteGroup.push(task);
+	}
+	for (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);
+	if (benchmarkGroup.length) {
+		const defer = createDefer();
+		suite.result = {
+			state: "run",
+			startTime: start,
+			benchmark: createBenchmarkResult(suite.name)
+		};
+		updateTask$1("suite-prepare", suite);
+		const addBenchTaskListener = (task, benchmark) => {
+			task.addEventListener("complete", (e) => {
+				const taskRes = e.task.result;
+				const result = benchmark.result.benchmark;
+				benchmark.result.state = "pass";
+				Object.assign(result, taskRes);
+				const samples = result.samples;
+				result.sampleCount = samples.length;
+				result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
+				if (!runner.config.benchmark?.includeSamples) result.samples.length = 0;
+				updateTask$1("test-finished", benchmark);
+			}, { once: true });
+			task.addEventListener("error", (e) => {
+				const task = e.task;
+				defer.reject(benchmark ? task.result.error : e);
+			}, { once: true });
+		};
+		benchmarkGroup.forEach((benchmark) => {
+			const benchmarkInstance = new Bench(getBenchOptions(benchmark));
+			const benchmarkFn = getBenchFn(benchmark);
+			benchmark.result = {
+				state: "run",
+				startTime: start,
+				benchmark: createBenchmarkResult(benchmark.name)
+			};
+			const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+			benchmarkTasks.set(benchmark, task);
+			addBenchTaskListener(task, benchmark);
+		});
+		const { setTimeout } = getSafeTimers();
+		const tasks = [];
+		for (const benchmark of benchmarkGroup) {
+			const task = benchmarkTasks.get(benchmark);
+			updateTask$1("test-prepare", benchmark);
+			await task.warmup();
+			tasks.push([await new Promise((resolve) => setTimeout(async () => {
+				resolve(await task.run());
+			})), benchmark]);
+		}
+		suite.result.duration = performance.now() - start;
+		suite.result.state = "pass";
+		updateTask$1("suite-finished", suite);
+		defer.resolve(null);
+		await defer;
+	}
+	function updateTask$1(event, task) {
+		updateTask(event, task, runner);
+	}
+}
+var NodeBenchmarkRunner = class {
+	moduleRunner;
+	constructor(config) {
+		this.config = config;
+	}
+	async importTinybench() {
+		return await import("../../../../../tinybench@2.9.0/node_modules/tinybench/dist/index.js");
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);
+			if (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this.moduleRunner.import(filepath);
+	}
+	async runSuite(suite) {
+		await runBenchmarkSuite(suite, this);
+	}
+	async runTask() {
+		throw new Error("`test()` and `it()` is only available in test mode.");
+	}
+};
+var TestRunner = class {
+	snapshotClient = getSnapshotClient();
+	workerState = getWorkerState();
+	moduleRunner;
+	cancelRun = false;
+	assertionsErrors = /* @__PURE__ */ new WeakMap();
+	pool = this.workerState.ctx.pool;
+	_otel;
+	viteEnvironment;
+	viteModuleRunner;
+	constructor(config) {
+		this.config = config;
+		const environment = this.workerState.environment;
+		this.viteEnvironment = environment.viteEnvironment || environment.name;
+		this.viteModuleRunner = config.experimental.viteModuleRunner;
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
+			if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this._otel.$(`vitest.module.import_${source === "setup" ? "setup" : "spec"}`, { attributes: { "code.file.path": filepath } }, () => {
+			if (!this.viteModuleRunner) filepath = `${filepath}?vitest=${Date.now()}`;
+			return this.moduleRunner.import(filepath);
+		});
+	}
+	onCollectStart(file) {
+		this.workerState.current = file;
+	}
+	onCleanupWorkerContext(listener) {
+		this.workerState.onCleanup(listener);
+	}
+	onAfterRunFiles() {
+		this.snapshotClient.clear();
+		this.workerState.current = void 0;
+	}
+	async onAfterRunSuite(suite) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
+		if (suite.mode !== "skip" && "filepath" in suite) {
+			for (const test of getTests(suite)) if (test.mode === "skip") {
+				const name = getNames(test).slice(1).join(" > ");
+				this.snapshotClient.skipTest(suite.file.filepath, name);
+			}
+			const result = await this.snapshotClient.finish(suite.file.filepath);
+			if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
+				let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
+				for (const key of result.uncheckedKeys) message += `· ${key}\n`;
+				suite.result.errors ??= [];
+				suite.result.errors.push(processError(new Error(message)));
+				suite.result.state = "fail";
+			}
+			await rpc().snapshotSaved(result);
+		}
+		this.workerState.current = suite.suite || suite.file;
+	}
+	onAfterRunTask(test) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
+		this.workerState.current = test.suite || test.file;
+	}
+	cancel(_reason) {
+		this.cancelRun = true;
+	}
+	injectValue(key) {
+		return inject(key);
+	}
+	async onBeforeRunTask(test) {
+		if (this.cancelRun) test.mode = "skip";
+		if (test.mode !== "run" && test.mode !== "queued") return;
+		this.workerState.current = test;
+	}
+	async onBeforeRunSuite(suite) {
+		if (this.cancelRun) suite.mode = "skip";
+		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
+		this.workerState.current = suite;
+	}
+	onBeforeTryTask(test) {
+		clearModuleMocks(this.config);
+		this.snapshotClient.clearTest(test.file.filepath, test.id);
+		setState({
+			assertionCalls: 0,
+			isExpectingAssertions: false,
+			isExpectingAssertionsError: null,
+			expectedAssertionsNumber: null,
+			expectedAssertionsNumberErrorGen: null,
+			currentTestName: getTestName(test),
+			snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+		}, globalThis[GLOBAL_EXPECT]);
+	}
+	onAfterTryTask(test) {
+		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+		if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
+	}
+	extendTaskContext(context) {
+		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
+		let _expect;
+		Object.defineProperty(context, "expect", { get() {
+			if (!_expect) _expect = createExpect(context.task);
+			return _expect;
+		} });
+		Object.defineProperty(context, "_local", { get() {
+			return _expect != null;
+		} });
+		return context;
+	}
+	getImportDurations() {
+		const { limit } = this.config.experimental.importDurations;
+		if (limit === 0) return {};
+		const sortedEntries = [...this.workerState.moduleExecutionInfo?.entries() || []].sort(([, a], [, b]) => b.duration - a.duration).slice(0, limit);
+		const importDurations = {};
+		for (const [filepath, { duration, selfTime, external, importer }] of sortedEntries) importDurations[normalize(filepath)] = {
+			selfTime,
+			totalTime: duration,
+			external,
+			importer
+		};
+		return importDurations;
+	}
+	trace = (name, attributes, cb) => {
+		const options = typeof attributes === "object" ? { attributes } : {};
+		return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+	};
+	__setTraces(traces) {
+		this._otel = traces;
+	}
+	static createTaskCollector = createTaskCollector;
+	static getCurrentSuite = getCurrentSuite;
+	static getCurrentTest = getCurrentTest;
+	static createChainable = createChainable;
+	static getSuiteHooks = getHooks;
+	static getTestFn = getFn;
+	static setSuiteHooks = getHooks;
+	static setTestFn = getFn;
+	static matchesTags = matchesTags;
+	/**
+	* @deprecated
+	*/
+	static getBenchFn = getBenchFn;
+	/**
+	* @deprecated
+	*/
+	static getBenchOptions = getBenchOptions;
+};
+function clearModuleMocks(config) {
+	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+	if (restoreMocks) vi.restoreAllMocks();
+	if (mockReset) vi.resetAllMocks();
+	if (clearMocks) vi.clearAllMocks();
+	if (unstubEnvs) vi.unstubAllEnvs();
+	if (unstubGlobals) vi.unstubAllGlobals();
+}
+//#endregion
+export { NodeBenchmarkRunner as N, Snapshots as S, TestRunner as T, assert as a, vitest as b, createExpect as c, globalExpect as g, inject as i, should as s, vi as v };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"test.DNmyFkvJ.js","names":["chai.Assertion","chai.use","expect","chai.expect","chai.assert","chai.should"],"sources":["../../../../../../../../../../node_modules/.pnpm/vitest@4.1.10_@opentelemetry+api@1.9.0_@types+node@25.0.7_@vitest+coverage-v8@4.1.10_ms_f9cfcfeddd63e656d4010c98521af26c/node_modules/vitest/dist/chunks/test.DNmyFkvJ.js"],"sourcesContent":["import { getCurrentTest, updateTask, createTaskCollector, getCurrentSuite, getHooks, getFn } from '@vitest/runner';\nimport { assertTypes, createSimpleStackTrace, createDefer } from '@vitest/utils/helpers';\nimport { getSafeTimers, delay } from '@vitest/utils/timers';\nimport { a as getBenchOptions, g as getBenchFn } from './benchmark.CX_oY03V.js';\nimport { i as isChildProcess, w as waitForImportsToResolve, r as resetModules, g as getWorkerState } from './utils.BX5Fg8C4.js';\nimport { chai, wrapAssertion, recordAsyncExpect, createAssertionMessage, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, ChaiStyleAssertions, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';\nimport { getNames, getTests, getTestName, createChainable, matchesTags } from '@vitest/runner/utils';\nimport { processError } from '@vitest/utils/error';\nimport { normalize } from 'pathe';\nimport { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '@vitest/spy';\nimport '@vitest/utils/offset';\nimport { parseSingleStack } from '@vitest/utils/source-map';\nimport { c as commonjsGlobal } from './_commonjsHelpers.D26ty3Ew.js';\nimport { R as RealDate, b as resetDate, m as mockDate, r as rpc } from './rpc.MzXet3jl.js';\nimport { addSerializer, stripSnapshotIndentation, SnapshotClient } from '@vitest/snapshot';\n\nvar fakeTimersSrc = {};\n\nvar global;\nvar hasRequiredGlobal;\n\nfunction requireGlobal () {\n\tif (hasRequiredGlobal) return global;\n\thasRequiredGlobal = 1;\n\n\t/**\n\t * A reference to the global object\n\t * @type {object} globalObject\n\t */\n\tvar globalObject;\n\n\t/* istanbul ignore else */\n\tif (typeof commonjsGlobal !== \"undefined\") {\n\t    // Node\n\t    globalObject = commonjsGlobal;\n\t} else if (typeof window !== \"undefined\") {\n\t    // Browser\n\t    globalObject = window;\n\t} else {\n\t    // WebWorker\n\t    globalObject = self;\n\t}\n\n\tglobal = globalObject;\n\treturn global;\n}\n\nvar throwsOnProto_1;\nvar hasRequiredThrowsOnProto;\n\nfunction requireThrowsOnProto () {\n\tif (hasRequiredThrowsOnProto) return throwsOnProto_1;\n\thasRequiredThrowsOnProto = 1;\n\n\t/**\n\t * Is true when the environment causes an error to be thrown for accessing the\n\t * __proto__ property.\n\t * This is necessary in order to support `node --disable-proto=throw`.\n\t *\n\t * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto\n\t * @type {boolean}\n\t */\n\tlet throwsOnProto;\n\ttry {\n\t    const object = {};\n\t    // eslint-disable-next-line no-proto, no-unused-expressions\n\t    object.__proto__;\n\t    throwsOnProto = false;\n\t} catch (_) {\n\t    // This branch is covered when tests are run with `--disable-proto=throw`,\n\t    // however we can test both branches at the same time, so this is ignored\n\t    /* istanbul ignore next */\n\t    throwsOnProto = true;\n\t}\n\n\tthrowsOnProto_1 = throwsOnProto;\n\treturn throwsOnProto_1;\n}\n\nvar copyPrototypeMethods;\nvar hasRequiredCopyPrototypeMethods;\n\nfunction requireCopyPrototypeMethods () {\n\tif (hasRequiredCopyPrototypeMethods) return copyPrototypeMethods;\n\thasRequiredCopyPrototypeMethods = 1;\n\n\tvar call = Function.call;\n\tvar throwsOnProto = requireThrowsOnProto();\n\n\tvar disallowedProperties = [\n\t    // ignore size because it throws from Map\n\t    \"size\",\n\t    \"caller\",\n\t    \"callee\",\n\t    \"arguments\",\n\t];\n\n\t// This branch is covered when tests are run with `--disable-proto=throw`,\n\t// however we can test both branches at the same time, so this is ignored\n\t/* istanbul ignore next */\n\tif (throwsOnProto) {\n\t    disallowedProperties.push(\"__proto__\");\n\t}\n\n\tcopyPrototypeMethods = function copyPrototypeMethods(prototype) {\n\t    // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n\t    return Object.getOwnPropertyNames(prototype).reduce(function (\n\t        result,\n\t        name\n\t    ) {\n\t        if (disallowedProperties.includes(name)) {\n\t            return result;\n\t        }\n\n\t        if (typeof prototype[name] !== \"function\") {\n\t            return result;\n\t        }\n\n\t        result[name] = call.bind(prototype[name]);\n\n\t        return result;\n\t    },\n\t    Object.create(null));\n\t};\n\treturn copyPrototypeMethods;\n}\n\nvar array;\nvar hasRequiredArray;\n\nfunction requireArray () {\n\tif (hasRequiredArray) return array;\n\thasRequiredArray = 1;\n\n\tvar copyPrototype = requireCopyPrototypeMethods();\n\n\tarray = copyPrototype(Array.prototype);\n\treturn array;\n}\n\nvar calledInOrder_1;\nvar hasRequiredCalledInOrder;\n\nfunction requireCalledInOrder () {\n\tif (hasRequiredCalledInOrder) return calledInOrder_1;\n\thasRequiredCalledInOrder = 1;\n\n\tvar every = requireArray().every;\n\n\t/**\n\t * @private\n\t */\n\tfunction hasCallsLeft(callMap, spy) {\n\t    if (callMap[spy.id] === undefined) {\n\t        callMap[spy.id] = 0;\n\t    }\n\n\t    return callMap[spy.id] < spy.callCount;\n\t}\n\n\t/**\n\t * @private\n\t */\n\tfunction checkAdjacentCalls(callMap, spy, index, spies) {\n\t    var calledBeforeNext = true;\n\n\t    if (index !== spies.length - 1) {\n\t        calledBeforeNext = spy.calledBefore(spies[index + 1]);\n\t    }\n\n\t    if (hasCallsLeft(callMap, spy) && calledBeforeNext) {\n\t        callMap[spy.id] += 1;\n\t        return true;\n\t    }\n\n\t    return false;\n\t}\n\n\t/**\n\t * A Sinon proxy object (fake, spy, stub)\n\t * @typedef {object} SinonProxy\n\t * @property {Function} calledBefore - A method that determines if this proxy was called before another one\n\t * @property {string} id - Some id\n\t * @property {number} callCount - Number of times this proxy has been called\n\t */\n\n\t/**\n\t * Returns true when the spies have been called in the order they were supplied in\n\t * @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments\n\t * @returns {boolean} true when spies are called in order, false otherwise\n\t */\n\tfunction calledInOrder(spies) {\n\t    var callMap = {};\n\t    // eslint-disable-next-line no-underscore-dangle\n\t    var _spies = arguments.length > 1 ? arguments : spies;\n\n\t    return every(_spies, checkAdjacentCalls.bind(null, callMap));\n\t}\n\n\tcalledInOrder_1 = calledInOrder;\n\treturn calledInOrder_1;\n}\n\nvar className_1;\nvar hasRequiredClassName;\n\nfunction requireClassName () {\n\tif (hasRequiredClassName) return className_1;\n\thasRequiredClassName = 1;\n\n\t/**\n\t * Returns a display name for a value from a constructor\n\t * @param  {object} value A value to examine\n\t * @returns {(string|null)} A string or null\n\t */\n\tfunction className(value) {\n\t    const name = value.constructor && value.constructor.name;\n\t    return name || null;\n\t}\n\n\tclassName_1 = className;\n\treturn className_1;\n}\n\nvar deprecated = {};\n\n/* eslint-disable no-console */\n\nvar hasRequiredDeprecated;\n\nfunction requireDeprecated () {\n\tif (hasRequiredDeprecated) return deprecated;\n\thasRequiredDeprecated = 1;\n\t(function (exports$1) {\n\n\t\t/**\n\t\t * Returns a function that will invoke the supplied function and print a\n\t\t * deprecation warning to the console each time it is called.\n\t\t * @param  {Function} func\n\t\t * @param  {string} msg\n\t\t * @returns {Function}\n\t\t */\n\t\texports$1.wrap = function (func, msg) {\n\t\t    var wrapped = function () {\n\t\t        exports$1.printWarning(msg);\n\t\t        return func.apply(this, arguments);\n\t\t    };\n\t\t    if (func.prototype) {\n\t\t        wrapped.prototype = func.prototype;\n\t\t    }\n\t\t    return wrapped;\n\t\t};\n\n\t\t/**\n\t\t * Returns a string which can be supplied to `wrap()` to notify the user that a\n\t\t * particular part of the sinon API has been deprecated.\n\t\t * @param  {string} packageName\n\t\t * @param  {string} funcName\n\t\t * @returns {string}\n\t\t */\n\t\texports$1.defaultMsg = function (packageName, funcName) {\n\t\t    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;\n\t\t};\n\n\t\t/**\n\t\t * Prints a warning on the console, when it exists\n\t\t * @param  {string} msg\n\t\t * @returns {undefined}\n\t\t */\n\t\texports$1.printWarning = function (msg) {\n\t\t    /* istanbul ignore next */\n\t\t    if (typeof process === \"object\" && process.emitWarning) {\n\t\t        // Emit Warnings in Node\n\t\t        process.emitWarning(msg);\n\t\t    } else if (console.info) {\n\t\t        console.info(msg);\n\t\t    } else {\n\t\t        console.log(msg);\n\t\t    }\n\t\t}; \n\t} (deprecated));\n\treturn deprecated;\n}\n\nvar every;\nvar hasRequiredEvery;\n\nfunction requireEvery () {\n\tif (hasRequiredEvery) return every;\n\thasRequiredEvery = 1;\n\n\t/**\n\t * Returns true when fn returns true for all members of obj.\n\t * This is an every implementation that works for all iterables\n\t * @param  {object}   obj\n\t * @param  {Function} fn\n\t * @returns {boolean}\n\t */\n\tevery = function every(obj, fn) {\n\t    var pass = true;\n\n\t    try {\n\t        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n\t        obj.forEach(function () {\n\t            if (!fn.apply(this, arguments)) {\n\t                // Throwing an error is the only way to break `forEach`\n\t                throw new Error();\n\t            }\n\t        });\n\t    } catch (e) {\n\t        pass = false;\n\t    }\n\n\t    return pass;\n\t};\n\treturn every;\n}\n\nvar functionName;\nvar hasRequiredFunctionName;\n\nfunction requireFunctionName () {\n\tif (hasRequiredFunctionName) return functionName;\n\thasRequiredFunctionName = 1;\n\n\t/**\n\t * Returns a display name for a function\n\t * @param  {Function} func\n\t * @returns {string}\n\t */\n\tfunctionName = function functionName(func) {\n\t    if (!func) {\n\t        return \"\";\n\t    }\n\n\t    try {\n\t        return (\n\t            func.displayName ||\n\t            func.name ||\n\t            // Use function decomposition as a last resort to get function\n\t            // name. Does not rely on function decomposition to work - if it\n\t            // doesn't debugging will be slightly less informative\n\t            // (i.e. toString will say 'spy' rather than 'myFunc').\n\t            (String(func).match(/function ([^\\s(]+)/) || [])[1]\n\t        );\n\t    } catch (e) {\n\t        // Stringify may fail and we might get an exception, as a last-last\n\t        // resort fall back to empty string.\n\t        return \"\";\n\t    }\n\t};\n\treturn functionName;\n}\n\nvar orderByFirstCall_1;\nvar hasRequiredOrderByFirstCall;\n\nfunction requireOrderByFirstCall () {\n\tif (hasRequiredOrderByFirstCall) return orderByFirstCall_1;\n\thasRequiredOrderByFirstCall = 1;\n\n\tvar sort = requireArray().sort;\n\tvar slice = requireArray().slice;\n\n\t/**\n\t * @private\n\t */\n\tfunction comparator(a, b) {\n\t    // uuid, won't ever be equal\n\t    var aCall = a.getCall(0);\n\t    var bCall = b.getCall(0);\n\t    var aId = (aCall && aCall.callId) || -1;\n\t    var bId = (bCall && bCall.callId) || -1;\n\n\t    return aId < bId ? -1 : 1;\n\t}\n\n\t/**\n\t * A Sinon proxy object (fake, spy, stub)\n\t * @typedef {object} SinonProxy\n\t * @property {Function} getCall - A method that can return the first call\n\t */\n\n\t/**\n\t * Sorts an array of SinonProxy instances (fake, spy, stub) by their first call\n\t * @param  {SinonProxy[] | SinonProxy} spies\n\t * @returns {SinonProxy[]}\n\t */\n\tfunction orderByFirstCall(spies) {\n\t    return sort(slice(spies), comparator);\n\t}\n\n\torderByFirstCall_1 = orderByFirstCall;\n\treturn orderByFirstCall_1;\n}\n\nvar _function;\nvar hasRequired_function;\n\nfunction require_function () {\n\tif (hasRequired_function) return _function;\n\thasRequired_function = 1;\n\n\tvar copyPrototype = requireCopyPrototypeMethods();\n\n\t_function = copyPrototype(Function.prototype);\n\treturn _function;\n}\n\nvar map;\nvar hasRequiredMap;\n\nfunction requireMap () {\n\tif (hasRequiredMap) return map;\n\thasRequiredMap = 1;\n\n\tvar copyPrototype = requireCopyPrototypeMethods();\n\n\tmap = copyPrototype(Map.prototype);\n\treturn map;\n}\n\nvar object;\nvar hasRequiredObject;\n\nfunction requireObject () {\n\tif (hasRequiredObject) return object;\n\thasRequiredObject = 1;\n\n\tvar copyPrototype = requireCopyPrototypeMethods();\n\n\tobject = copyPrototype(Object.prototype);\n\treturn object;\n}\n\nvar set;\nvar hasRequiredSet;\n\nfunction requireSet () {\n\tif (hasRequiredSet) return set;\n\thasRequiredSet = 1;\n\n\tvar copyPrototype = requireCopyPrototypeMethods();\n\n\tset = copyPrototype(Set.prototype);\n\treturn set;\n}\n\nvar string;\nvar hasRequiredString;\n\nfunction requireString () {\n\tif (hasRequiredString) return string;\n\thasRequiredString = 1;\n\n\tvar copyPrototype = requireCopyPrototypeMethods();\n\n\tstring = copyPrototype(String.prototype);\n\treturn string;\n}\n\nvar prototypes;\nvar hasRequiredPrototypes;\n\nfunction requirePrototypes () {\n\tif (hasRequiredPrototypes) return prototypes;\n\thasRequiredPrototypes = 1;\n\n\tprototypes = {\n\t    array: requireArray(),\n\t    function: require_function(),\n\t    map: requireMap(),\n\t    object: requireObject(),\n\t    set: requireSet(),\n\t    string: requireString(),\n\t};\n\treturn prototypes;\n}\n\nvar typeDetect$1 = {exports: {}};\n\nvar typeDetect = typeDetect$1.exports;\n\nvar hasRequiredTypeDetect;\n\nfunction requireTypeDetect () {\n\tif (hasRequiredTypeDetect) return typeDetect$1.exports;\n\thasRequiredTypeDetect = 1;\n\t(function (module, exports$1) {\n\t\t(function (global, factory) {\n\t\t\tmodule.exports = factory() ;\n\t\t}(typeDetect, (function () {\n\t\t/* !\n\t\t * type-detect\n\t\t * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>\n\t\t * MIT Licensed\n\t\t */\n\t\tvar promiseExists = typeof Promise === 'function';\n\n\t\t/* eslint-disable no-undef */\n\t\tvar globalObject = typeof self === 'object' ? self : commonjsGlobal; // eslint-disable-line id-blacklist\n\n\t\tvar symbolExists = typeof Symbol !== 'undefined';\n\t\tvar mapExists = typeof Map !== 'undefined';\n\t\tvar setExists = typeof Set !== 'undefined';\n\t\tvar weakMapExists = typeof WeakMap !== 'undefined';\n\t\tvar weakSetExists = typeof WeakSet !== 'undefined';\n\t\tvar dataViewExists = typeof DataView !== 'undefined';\n\t\tvar symbolIteratorExists = symbolExists && typeof Symbol.iterator !== 'undefined';\n\t\tvar symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== 'undefined';\n\t\tvar setEntriesExists = setExists && typeof Set.prototype.entries === 'function';\n\t\tvar mapEntriesExists = mapExists && typeof Map.prototype.entries === 'function';\n\t\tvar setIteratorPrototype = setEntriesExists && Object.getPrototypeOf(new Set().entries());\n\t\tvar mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf(new Map().entries());\n\t\tvar arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === 'function';\n\t\tvar arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());\n\t\tvar stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === 'function';\n\t\tvar stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(''[Symbol.iterator]());\n\t\tvar toStringLeftSliceLength = 8;\n\t\tvar toStringRightSliceLength = -1;\n\t\t/**\n\t\t * ### typeOf (obj)\n\t\t *\n\t\t * Uses `Object.prototype.toString` to determine the type of an object,\n\t\t * normalising behaviour across engine versions & well optimised.\n\t\t *\n\t\t * @param {Mixed} object\n\t\t * @return {String} object type\n\t\t * @api public\n\t\t */\n\t\tfunction typeDetect(obj) {\n\t\t  /* ! Speed optimisation\n\t\t   * Pre:\n\t\t   *   string literal     x 3,039,035 ops/sec ±1.62% (78 runs sampled)\n\t\t   *   boolean literal    x 1,424,138 ops/sec ±4.54% (75 runs sampled)\n\t\t   *   number literal     x 1,653,153 ops/sec ±1.91% (82 runs sampled)\n\t\t   *   undefined          x 9,978,660 ops/sec ±1.92% (75 runs sampled)\n\t\t   *   function           x 2,556,769 ops/sec ±1.73% (77 runs sampled)\n\t\t   * Post:\n\t\t   *   string literal     x 38,564,796 ops/sec ±1.15% (79 runs sampled)\n\t\t   *   boolean literal    x 31,148,940 ops/sec ±1.10% (79 runs sampled)\n\t\t   *   number literal     x 32,679,330 ops/sec ±1.90% (78 runs sampled)\n\t\t   *   undefined          x 32,363,368 ops/sec ±1.07% (82 runs sampled)\n\t\t   *   function           x 31,296,870 ops/sec ±0.96% (83 runs sampled)\n\t\t   */\n\t\t  var typeofObj = typeof obj;\n\t\t  if (typeofObj !== 'object') {\n\t\t    return typeofObj;\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t   * Pre:\n\t\t   *   null               x 28,645,765 ops/sec ±1.17% (82 runs sampled)\n\t\t   * Post:\n\t\t   *   null               x 36,428,962 ops/sec ±1.37% (84 runs sampled)\n\t\t   */\n\t\t  if (obj === null) {\n\t\t    return 'null';\n\t\t  }\n\n\t\t  /* ! Spec Conformance\n\t\t   * Test: `Object.prototype.toString.call(window)``\n\t\t   *  - Node === \"[object global]\"\n\t\t   *  - Chrome === \"[object global]\"\n\t\t   *  - Firefox === \"[object Window]\"\n\t\t   *  - PhantomJS === \"[object Window]\"\n\t\t   *  - Safari === \"[object Window]\"\n\t\t   *  - IE 11 === \"[object Window]\"\n\t\t   *  - IE Edge === \"[object Window]\"\n\t\t   * Test: `Object.prototype.toString.call(this)``\n\t\t   *  - Chrome Worker === \"[object global]\"\n\t\t   *  - Firefox Worker === \"[object DedicatedWorkerGlobalScope]\"\n\t\t   *  - Safari Worker === \"[object DedicatedWorkerGlobalScope]\"\n\t\t   *  - IE 11 Worker === \"[object WorkerGlobalScope]\"\n\t\t   *  - IE Edge Worker === \"[object WorkerGlobalScope]\"\n\t\t   */\n\t\t  if (obj === globalObject) {\n\t\t    return 'global';\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t   * Pre:\n\t\t   *   array literal      x 2,888,352 ops/sec ±0.67% (82 runs sampled)\n\t\t   * Post:\n\t\t   *   array literal      x 22,479,650 ops/sec ±0.96% (81 runs sampled)\n\t\t   */\n\t\t  if (\n\t\t    Array.isArray(obj) &&\n\t\t    (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))\n\t\t  ) {\n\t\t    return 'Array';\n\t\t  }\n\n\t\t  // Not caching existence of `window` and related properties due to potential\n\t\t  // for `window` to be unset before tests in quasi-browser environments.\n\t\t  if (typeof window === 'object' && window !== null) {\n\t\t    /* ! Spec Conformance\n\t\t     * (https://html.spec.whatwg.org/multipage/browsers.html#location)\n\t\t     * WhatWG HTML$7.7.3 - The `Location` interface\n\t\t     * Test: `Object.prototype.toString.call(window.location)``\n\t\t     *  - IE <=11 === \"[object Object]\"\n\t\t     *  - IE Edge <=13 === \"[object Object]\"\n\t\t     */\n\t\t    if (typeof window.location === 'object' && obj === window.location) {\n\t\t      return 'Location';\n\t\t    }\n\n\t\t    /* ! Spec Conformance\n\t\t     * (https://html.spec.whatwg.org/#document)\n\t\t     * WhatWG HTML$3.1.1 - The `Document` object\n\t\t     * Note: Most browsers currently adher to the W3C DOM Level 2 spec\n\t\t     *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-26809268)\n\t\t     *       which suggests that browsers should use HTMLTableCellElement for\n\t\t     *       both TD and TH elements. WhatWG separates these.\n\t\t     *       WhatWG HTML states:\n\t\t     *         > For historical reasons, Window objects must also have a\n\t\t     *         > writable, configurable, non-enumerable property named\n\t\t     *         > HTMLDocument whose value is the Document interface object.\n\t\t     * Test: `Object.prototype.toString.call(document)``\n\t\t     *  - Chrome === \"[object HTMLDocument]\"\n\t\t     *  - Firefox === \"[object HTMLDocument]\"\n\t\t     *  - Safari === \"[object HTMLDocument]\"\n\t\t     *  - IE <=10 === \"[object Document]\"\n\t\t     *  - IE 11 === \"[object HTMLDocument]\"\n\t\t     *  - IE Edge <=13 === \"[object HTMLDocument]\"\n\t\t     */\n\t\t    if (typeof window.document === 'object' && obj === window.document) {\n\t\t      return 'Document';\n\t\t    }\n\n\t\t    if (typeof window.navigator === 'object') {\n\t\t      /* ! Spec Conformance\n\t\t       * (https://html.spec.whatwg.org/multipage/webappapis.html#mimetypearray)\n\t\t       * WhatWG HTML$8.6.1.5 - Plugins - Interface MimeTypeArray\n\t\t       * Test: `Object.prototype.toString.call(navigator.mimeTypes)``\n\t\t       *  - IE <=10 === \"[object MSMimeTypesCollection]\"\n\t\t       */\n\t\t      if (typeof window.navigator.mimeTypes === 'object' &&\n\t\t          obj === window.navigator.mimeTypes) {\n\t\t        return 'MimeTypeArray';\n\t\t      }\n\n\t\t      /* ! Spec Conformance\n\t\t       * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray)\n\t\t       * WhatWG HTML$8.6.1.5 - Plugins - Interface PluginArray\n\t\t       * Test: `Object.prototype.toString.call(navigator.plugins)``\n\t\t       *  - IE <=10 === \"[object MSPluginsCollection]\"\n\t\t       */\n\t\t      if (typeof window.navigator.plugins === 'object' &&\n\t\t          obj === window.navigator.plugins) {\n\t\t        return 'PluginArray';\n\t\t      }\n\t\t    }\n\n\t\t    if ((typeof window.HTMLElement === 'function' ||\n\t\t        typeof window.HTMLElement === 'object') &&\n\t\t        obj instanceof window.HTMLElement) {\n\t\t      /* ! Spec Conformance\n\t\t      * (https://html.spec.whatwg.org/multipage/webappapis.html#pluginarray)\n\t\t      * WhatWG HTML$4.4.4 - The `blockquote` element - Interface `HTMLQuoteElement`\n\t\t      * Test: `Object.prototype.toString.call(document.createElement('blockquote'))``\n\t\t      *  - IE <=10 === \"[object HTMLBlockElement]\"\n\t\t      */\n\t\t      if (obj.tagName === 'BLOCKQUOTE') {\n\t\t        return 'HTMLQuoteElement';\n\t\t      }\n\n\t\t      /* ! Spec Conformance\n\t\t       * (https://html.spec.whatwg.org/#htmltabledatacellelement)\n\t\t       * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableDataCellElement`\n\t\t       * Note: Most browsers currently adher to the W3C DOM Level 2 spec\n\t\t       *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075)\n\t\t       *       which suggests that browsers should use HTMLTableCellElement for\n\t\t       *       both TD and TH elements. WhatWG separates these.\n\t\t       * Test: Object.prototype.toString.call(document.createElement('td'))\n\t\t       *  - Chrome === \"[object HTMLTableCellElement]\"\n\t\t       *  - Firefox === \"[object HTMLTableCellElement]\"\n\t\t       *  - Safari === \"[object HTMLTableCellElement]\"\n\t\t       */\n\t\t      if (obj.tagName === 'TD') {\n\t\t        return 'HTMLTableDataCellElement';\n\t\t      }\n\n\t\t      /* ! Spec Conformance\n\t\t       * (https://html.spec.whatwg.org/#htmltableheadercellelement)\n\t\t       * WhatWG HTML$4.9.9 - The `td` element - Interface `HTMLTableHeaderCellElement`\n\t\t       * Note: Most browsers currently adher to the W3C DOM Level 2 spec\n\t\t       *       (https://www.w3.org/TR/DOM-Level-2-HTML/html.html#ID-82915075)\n\t\t       *       which suggests that browsers should use HTMLTableCellElement for\n\t\t       *       both TD and TH elements. WhatWG separates these.\n\t\t       * Test: Object.prototype.toString.call(document.createElement('th'))\n\t\t       *  - Chrome === \"[object HTMLTableCellElement]\"\n\t\t       *  - Firefox === \"[object HTMLTableCellElement]\"\n\t\t       *  - Safari === \"[object HTMLTableCellElement]\"\n\t\t       */\n\t\t      if (obj.tagName === 'TH') {\n\t\t        return 'HTMLTableHeaderCellElement';\n\t\t      }\n\t\t    }\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   Float64Array       x 625,644 ops/sec ±1.58% (80 runs sampled)\n\t\t  *   Float32Array       x 1,279,852 ops/sec ±2.91% (77 runs sampled)\n\t\t  *   Uint32Array        x 1,178,185 ops/sec ±1.95% (83 runs sampled)\n\t\t  *   Uint16Array        x 1,008,380 ops/sec ±2.25% (80 runs sampled)\n\t\t  *   Uint8Array         x 1,128,040 ops/sec ±2.11% (81 runs sampled)\n\t\t  *   Int32Array         x 1,170,119 ops/sec ±2.88% (80 runs sampled)\n\t\t  *   Int16Array         x 1,176,348 ops/sec ±5.79% (86 runs sampled)\n\t\t  *   Int8Array          x 1,058,707 ops/sec ±4.94% (77 runs sampled)\n\t\t  *   Uint8ClampedArray  x 1,110,633 ops/sec ±4.20% (80 runs sampled)\n\t\t  * Post:\n\t\t  *   Float64Array       x 7,105,671 ops/sec ±13.47% (64 runs sampled)\n\t\t  *   Float32Array       x 5,887,912 ops/sec ±1.46% (82 runs sampled)\n\t\t  *   Uint32Array        x 6,491,661 ops/sec ±1.76% (79 runs sampled)\n\t\t  *   Uint16Array        x 6,559,795 ops/sec ±1.67% (82 runs sampled)\n\t\t  *   Uint8Array         x 6,463,966 ops/sec ±1.43% (85 runs sampled)\n\t\t  *   Int32Array         x 5,641,841 ops/sec ±3.49% (81 runs sampled)\n\t\t  *   Int16Array         x 6,583,511 ops/sec ±1.98% (80 runs sampled)\n\t\t  *   Int8Array          x 6,606,078 ops/sec ±1.74% (81 runs sampled)\n\t\t  *   Uint8ClampedArray  x 6,602,224 ops/sec ±1.77% (83 runs sampled)\n\t\t  */\n\t\t  var stringTag = (symbolToStringTagExists && obj[Symbol.toStringTag]);\n\t\t  if (typeof stringTag === 'string') {\n\t\t    return stringTag;\n\t\t  }\n\n\t\t  var objPrototype = Object.getPrototypeOf(obj);\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   regex literal      x 1,772,385 ops/sec ±1.85% (77 runs sampled)\n\t\t  *   regex constructor  x 2,143,634 ops/sec ±2.46% (78 runs sampled)\n\t\t  * Post:\n\t\t  *   regex literal      x 3,928,009 ops/sec ±0.65% (78 runs sampled)\n\t\t  *   regex constructor  x 3,931,108 ops/sec ±0.58% (84 runs sampled)\n\t\t  */\n\t\t  if (objPrototype === RegExp.prototype) {\n\t\t    return 'RegExp';\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   date               x 2,130,074 ops/sec ±4.42% (68 runs sampled)\n\t\t  * Post:\n\t\t  *   date               x 3,953,779 ops/sec ±1.35% (77 runs sampled)\n\t\t  */\n\t\t  if (objPrototype === Date.prototype) {\n\t\t    return 'Date';\n\t\t  }\n\n\t\t  /* ! Spec Conformance\n\t\t   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-promise.prototype-@@tostringtag)\n\t\t   * ES6$25.4.5.4 - Promise.prototype[@@toStringTag] should be \"Promise\":\n\t\t   * Test: `Object.prototype.toString.call(Promise.resolve())``\n\t\t   *  - Chrome <=47 === \"[object Object]\"\n\t\t   *  - Edge <=20 === \"[object Object]\"\n\t\t   *  - Firefox 29-Latest === \"[object Promise]\"\n\t\t   *  - Safari 7.1-Latest === \"[object Promise]\"\n\t\t   */\n\t\t  if (promiseExists && objPrototype === Promise.prototype) {\n\t\t    return 'Promise';\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   set                x 2,222,186 ops/sec ±1.31% (82 runs sampled)\n\t\t  * Post:\n\t\t  *   set                x 4,545,879 ops/sec ±1.13% (83 runs sampled)\n\t\t  */\n\t\t  if (setExists && objPrototype === Set.prototype) {\n\t\t    return 'Set';\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   map                x 2,396,842 ops/sec ±1.59% (81 runs sampled)\n\t\t  * Post:\n\t\t  *   map                x 4,183,945 ops/sec ±6.59% (82 runs sampled)\n\t\t  */\n\t\t  if (mapExists && objPrototype === Map.prototype) {\n\t\t    return 'Map';\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   weakset            x 1,323,220 ops/sec ±2.17% (76 runs sampled)\n\t\t  * Post:\n\t\t  *   weakset            x 4,237,510 ops/sec ±2.01% (77 runs sampled)\n\t\t  */\n\t\t  if (weakSetExists && objPrototype === WeakSet.prototype) {\n\t\t    return 'WeakSet';\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   weakmap            x 1,500,260 ops/sec ±2.02% (78 runs sampled)\n\t\t  * Post:\n\t\t  *   weakmap            x 3,881,384 ops/sec ±1.45% (82 runs sampled)\n\t\t  */\n\t\t  if (weakMapExists && objPrototype === WeakMap.prototype) {\n\t\t    return 'WeakMap';\n\t\t  }\n\n\t\t  /* ! Spec Conformance\n\t\t   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-dataview.prototype-@@tostringtag)\n\t\t   * ES6$24.2.4.21 - DataView.prototype[@@toStringTag] should be \"DataView\":\n\t\t   * Test: `Object.prototype.toString.call(new DataView(new ArrayBuffer(1)))``\n\t\t   *  - Edge <=13 === \"[object Object]\"\n\t\t   */\n\t\t  if (dataViewExists && objPrototype === DataView.prototype) {\n\t\t    return 'DataView';\n\t\t  }\n\n\t\t  /* ! Spec Conformance\n\t\t   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%mapiteratorprototype%-@@tostringtag)\n\t\t   * ES6$23.1.5.2.2 - %MapIteratorPrototype%[@@toStringTag] should be \"Map Iterator\":\n\t\t   * Test: `Object.prototype.toString.call(new Map().entries())``\n\t\t   *  - Edge <=13 === \"[object Object]\"\n\t\t   */\n\t\t  if (mapExists && objPrototype === mapIteratorPrototype) {\n\t\t    return 'Map Iterator';\n\t\t  }\n\n\t\t  /* ! Spec Conformance\n\t\t   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%setiteratorprototype%-@@tostringtag)\n\t\t   * ES6$23.2.5.2.2 - %SetIteratorPrototype%[@@toStringTag] should be \"Set Iterator\":\n\t\t   * Test: `Object.prototype.toString.call(new Set().entries())``\n\t\t   *  - Edge <=13 === \"[object Object]\"\n\t\t   */\n\t\t  if (setExists && objPrototype === setIteratorPrototype) {\n\t\t    return 'Set Iterator';\n\t\t  }\n\n\t\t  /* ! Spec Conformance\n\t\t   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%arrayiteratorprototype%-@@tostringtag)\n\t\t   * ES6$22.1.5.2.2 - %ArrayIteratorPrototype%[@@toStringTag] should be \"Array Iterator\":\n\t\t   * Test: `Object.prototype.toString.call([][Symbol.iterator]())``\n\t\t   *  - Edge <=13 === \"[object Object]\"\n\t\t   */\n\t\t  if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {\n\t\t    return 'Array Iterator';\n\t\t  }\n\n\t\t  /* ! Spec Conformance\n\t\t   * (http://www.ecma-international.org/ecma-262/6.0/index.html#sec-%stringiteratorprototype%-@@tostringtag)\n\t\t   * ES6$21.1.5.2.2 - %StringIteratorPrototype%[@@toStringTag] should be \"String Iterator\":\n\t\t   * Test: `Object.prototype.toString.call(''[Symbol.iterator]())``\n\t\t   *  - Edge <=13 === \"[object Object]\"\n\t\t   */\n\t\t  if (stringIteratorExists && objPrototype === stringIteratorPrototype) {\n\t\t    return 'String Iterator';\n\t\t  }\n\n\t\t  /* ! Speed optimisation\n\t\t  * Pre:\n\t\t  *   object from null   x 2,424,320 ops/sec ±1.67% (76 runs sampled)\n\t\t  * Post:\n\t\t  *   object from null   x 5,838,000 ops/sec ±0.99% (84 runs sampled)\n\t\t  */\n\t\t  if (objPrototype === null) {\n\t\t    return 'Object';\n\t\t  }\n\n\t\t  return Object\n\t\t    .prototype\n\t\t    .toString\n\t\t    .call(obj)\n\t\t    .slice(toStringLeftSliceLength, toStringRightSliceLength);\n\t\t}\n\n\t\treturn typeDetect;\n\n\t\t}))); \n\t} (typeDetect$1));\n\treturn typeDetect$1.exports;\n}\n\nvar typeOf;\nvar hasRequiredTypeOf;\n\nfunction requireTypeOf () {\n\tif (hasRequiredTypeOf) return typeOf;\n\thasRequiredTypeOf = 1;\n\n\tvar type = requireTypeDetect();\n\n\t/**\n\t * Returns the lower-case result of running type from type-detect on the value\n\t * @param  {*} value\n\t * @returns {string}\n\t */\n\ttypeOf = function typeOf(value) {\n\t    return type(value).toLowerCase();\n\t};\n\treturn typeOf;\n}\n\nvar valueToString_1;\nvar hasRequiredValueToString;\n\nfunction requireValueToString () {\n\tif (hasRequiredValueToString) return valueToString_1;\n\thasRequiredValueToString = 1;\n\n\t/**\n\t * Returns a string representation of the value\n\t * @param  {*} value\n\t * @returns {string}\n\t */\n\tfunction valueToString(value) {\n\t    if (value && value.toString) {\n\t        // eslint-disable-next-line @sinonjs/no-prototype-methods/no-prototype-methods\n\t        return value.toString();\n\t    }\n\t    return String(value);\n\t}\n\n\tvalueToString_1 = valueToString;\n\treturn valueToString_1;\n}\n\nvar lib;\nvar hasRequiredLib;\n\nfunction requireLib () {\n\tif (hasRequiredLib) return lib;\n\thasRequiredLib = 1;\n\n\tlib = {\n\t    global: requireGlobal(),\n\t    calledInOrder: requireCalledInOrder(),\n\t    className: requireClassName(),\n\t    deprecated: requireDeprecated(),\n\t    every: requireEvery(),\n\t    functionName: requireFunctionName(),\n\t    orderByFirstCall: requireOrderByFirstCall(),\n\t    prototypes: requirePrototypes(),\n\t    typeOf: requireTypeOf(),\n\t    valueToString: requireValueToString(),\n\t};\n\treturn lib;\n}\n\nvar hasRequiredFakeTimersSrc;\n\nfunction requireFakeTimersSrc () {\n\tif (hasRequiredFakeTimersSrc) return fakeTimersSrc;\n\thasRequiredFakeTimersSrc = 1;\n\n\tconst globalObject = requireLib().global;\n\tlet timersModule, timersPromisesModule;\n\tif (typeof __vitest_required__ !== 'undefined') {\n\t    try {\n\t        timersModule = __vitest_required__.timers;\n\t    } catch (e) {\n\t        // ignored\n\t    }\n\t    try {\n\t        timersPromisesModule = __vitest_required__.timersPromises;\n\t    } catch (e) {\n\t        // ignored\n\t    }\n\t}\n\n\t/**\n\t * @typedef {\"nextAsync\" | \"manual\" | \"interval\"} TickMode\n\t */\n\n\t/**\n\t * @typedef {object} NextAsyncTickMode\n\t * @property {\"nextAsync\"} mode\n\t */\n\n\t/**\n\t * @typedef {object} ManualTickMode\n\t * @property {\"manual\"} mode\n\t */\n\n\t/**\n\t * @typedef {object} IntervalTickMode\n\t * @property {\"interval\"} mode\n\t * @property {number} [delta]\n\t */\n\n\t/**\n\t * @typedef {IntervalTickMode | NextAsyncTickMode | ManualTickMode} TimerTickMode\n\t */\n\n\t/**\n\t * @typedef {object} IdleDeadline\n\t * @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout\n\t * @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period\n\t */\n\n\t/**\n\t * Queues a function to be called during a browser's idle periods\n\t * @callback RequestIdleCallback\n\t * @param {function(IdleDeadline)} callback\n\t * @param {{timeout: number}} options - an options object\n\t * @returns {number} the id\n\t */\n\n\t/**\n\t * @callback NextTick\n\t * @param {VoidVarArgsFunc} callback - the callback to run\n\t * @param {...*} args - optional arguments to call the callback with\n\t * @returns {void}\n\t */\n\n\t/**\n\t * @callback SetImmediate\n\t * @param {VoidVarArgsFunc} callback - the callback to run\n\t * @param {...*} args - optional arguments to call the callback with\n\t * @returns {NodeImmediate}\n\t */\n\n\t/**\n\t * @callback VoidVarArgsFunc\n\t * @param {...*} callback - the callback to run\n\t * @returns {void}\n\t */\n\n\t/**\n\t * @typedef RequestAnimationFrame\n\t * @property {function(number):void} requestAnimationFrame\n\t * @returns {number} - the id\n\t */\n\n\t/**\n\t * @typedef Performance\n\t * @property {function(): number} now\n\t */\n\n\t/* eslint-disable jsdoc/require-property-description */\n\t/**\n\t * @typedef {object} Clock\n\t * @property {number} now - the current time\n\t * @property {Date} Date - the Date constructor\n\t * @property {number} loopLimit - the maximum number of timers before assuming an infinite loop\n\t * @property {RequestIdleCallback} requestIdleCallback\n\t * @property {function(number):void} cancelIdleCallback\n\t * @property {setTimeout} setTimeout\n\t * @property {clearTimeout} clearTimeout\n\t * @property {NextTick} nextTick\n\t * @property {queueMicrotask} queueMicrotask\n\t * @property {setInterval} setInterval\n\t * @property {clearInterval} clearInterval\n\t * @property {SetImmediate} setImmediate\n\t * @property {function(NodeImmediate):void} clearImmediate\n\t * @property {function():number} countTimers\n\t * @property {RequestAnimationFrame} requestAnimationFrame\n\t * @property {function(number):void} cancelAnimationFrame\n\t * @property {function():void} runMicrotasks\n\t * @property {function(string | number): number} tick\n\t * @property {function(string | number): Promise<number>} tickAsync\n\t * @property {function(): number} next\n\t * @property {function(): Promise<number>} nextAsync\n\t * @property {function(): number} runAll\n\t * @property {function(): number} runToFrame\n\t * @property {function(): Promise<number>} runAllAsync\n\t * @property {function(): number} runToLast\n\t * @property {function(): Promise<number>} runToLastAsync\n\t * @property {function(): void} reset\n\t * @property {function(number | Date): void} setSystemTime\n\t * @property {function(number): void} jump\n\t * @property {Performance} performance\n\t * @property {function(number[]): number[]} hrtime - process.hrtime (legacy)\n\t * @property {function(): void} uninstall Uninstall the clock.\n\t * @property {Function[]} methods - the methods that are faked\n\t * @property {boolean} [shouldClearNativeTimers] inherited from config\n\t * @property {{methodName:string, original:any}[] | undefined} timersModuleMethods\n\t * @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods\n\t * @property {Map<function(): void, AbortSignal>} abortListenerMap\n\t * @property {function(TimerTickMode): void} setTickMode\n\t */\n\t/* eslint-enable jsdoc/require-property-description */\n\n\t/**\n\t * Configuration object for the `install` method.\n\t * @typedef {object} Config\n\t * @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)\n\t * @property {string[]} [toFake] names of the methods that should be faked.\n\t * @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll()\n\t * @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)\n\t * @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)\n\t * @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)\n\t * @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error\n\t */\n\n\t/* eslint-disable jsdoc/require-property-description */\n\t/**\n\t * The internal structure to describe a scheduled fake timer\n\t * @typedef {object} Timer\n\t * @property {Function} func\n\t * @property {*[]} args\n\t * @property {number} delay\n\t * @property {number} callAt\n\t * @property {number} createdAt\n\t * @property {boolean} immediate\n\t * @property {number} id\n\t * @property {Error} [error]\n\t */\n\n\t/**\n\t * A Node timer\n\t * @typedef {object} NodeImmediate\n\t * @property {function(): boolean} hasRef\n\t * @property {function(): NodeImmediate} ref\n\t * @property {function(): NodeImmediate} unref\n\t */\n\t/* eslint-enable jsdoc/require-property-description */\n\n\t/* eslint-disable complexity */\n\n\t/**\n\t * Mocks available features in the specified global namespace.\n\t * @param {*} _global Namespace to mock (e.g. `window`)\n\t * @returns {FakeTimers}\n\t */\n\tfunction withGlobal(_global) {\n\t    const maxTimeout = Math.pow(2, 31) - 1; //see https://heycam.github.io/webidl/#abstract-opdef-converttoint\n\t    const idCounterStart = 1e12; // arbitrarily large number to avoid collisions with native timer IDs\n\t    const NOOP = function () {\n\t        return undefined;\n\t    };\n\t    const NOOP_ARRAY = function () {\n\t        return [];\n\t    };\n\t    const isPresent = {};\n\t    let timeoutResult,\n\t        addTimerReturnsObject = false;\n\n\t    if (_global.setTimeout) {\n\t        isPresent.setTimeout = true;\n\t        timeoutResult = _global.setTimeout(NOOP, 0);\n\t        addTimerReturnsObject = typeof timeoutResult === \"object\";\n\t    }\n\t    isPresent.clearTimeout = Boolean(_global.clearTimeout);\n\t    isPresent.setInterval = Boolean(_global.setInterval);\n\t    isPresent.clearInterval = Boolean(_global.clearInterval);\n\t    isPresent.hrtime =\n\t        _global.process && typeof _global.process.hrtime === \"function\";\n\t    isPresent.hrtimeBigint =\n\t        isPresent.hrtime && typeof _global.process.hrtime.bigint === \"function\";\n\t    isPresent.nextTick =\n\t        _global.process && typeof _global.process.nextTick === \"function\";\n\t    const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;\n\t    isPresent.performance =\n\t        _global.performance && typeof _global.performance.now === \"function\";\n\t    const hasPerformancePrototype =\n\t        _global.Performance &&\n\t        (typeof _global.Performance).match(/^(function|object)$/);\n\t    const hasPerformanceConstructorPrototype =\n\t        _global.performance &&\n\t        _global.performance.constructor &&\n\t        _global.performance.constructor.prototype;\n\t    isPresent.queueMicrotask = _global.hasOwnProperty(\"queueMicrotask\");\n\t    isPresent.requestAnimationFrame =\n\t        _global.requestAnimationFrame &&\n\t        typeof _global.requestAnimationFrame === \"function\";\n\t    isPresent.cancelAnimationFrame =\n\t        _global.cancelAnimationFrame &&\n\t        typeof _global.cancelAnimationFrame === \"function\";\n\t    isPresent.requestIdleCallback =\n\t        _global.requestIdleCallback &&\n\t        typeof _global.requestIdleCallback === \"function\";\n\t    isPresent.cancelIdleCallbackPresent =\n\t        _global.cancelIdleCallback &&\n\t        typeof _global.cancelIdleCallback === \"function\";\n\t    isPresent.setImmediate =\n\t        _global.setImmediate && typeof _global.setImmediate === \"function\";\n\t    isPresent.clearImmediate =\n\t        _global.clearImmediate && typeof _global.clearImmediate === \"function\";\n\t    isPresent.Intl = _global.Intl && typeof _global.Intl === \"object\";\n\n\t    if (_global.clearTimeout) {\n\t        _global.clearTimeout(timeoutResult);\n\t    }\n\n\t    const NativeDate = _global.Date;\n\t    const NativeIntl = isPresent.Intl\n\t        ? Object.defineProperties(\n\t              Object.create(null),\n\t              Object.getOwnPropertyDescriptors(_global.Intl),\n\t          )\n\t        : undefined;\n\t    let uniqueTimerId = idCounterStart;\n\n\t    if (NativeDate === undefined) {\n\t        throw new Error(\n\t            \"The global scope doesn't have a `Date` object\" +\n\t                \" (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)\",\n\t        );\n\t    }\n\t    isPresent.Date = true;\n\n\t    /**\n\t     * The PerformanceEntry object encapsulates a single performance metric\n\t     * that is part of the browser's performance timeline.\n\t     *\n\t     * This is an object returned by the `mark` and `measure` methods on the Performance prototype\n\t     */\n\t    class FakePerformanceEntry {\n\t        constructor(name, entryType, startTime, duration) {\n\t            this.name = name;\n\t            this.entryType = entryType;\n\t            this.startTime = startTime;\n\t            this.duration = duration;\n\t        }\n\n\t        toJSON() {\n\t            return JSON.stringify({ ...this });\n\t        }\n\t    }\n\n\t    /**\n\t     * @param {number} num\n\t     * @returns {boolean}\n\t     */\n\t    function isNumberFinite(num) {\n\t        if (Number.isFinite) {\n\t            return Number.isFinite(num);\n\t        }\n\n\t        return isFinite(num);\n\t    }\n\n\t    let isNearInfiniteLimit = false;\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @param {number} i\n\t     */\n\t    function checkIsNearInfiniteLimit(clock, i) {\n\t        if (clock.loopLimit && i === clock.loopLimit - 1) {\n\t            isNearInfiniteLimit = true;\n\t        }\n\t    }\n\n\t    /**\n\t     *\n\t     */\n\t    function resetIsNearInfiniteLimit() {\n\t        isNearInfiniteLimit = false;\n\t    }\n\n\t    /**\n\t     * Parse strings like \"01:10:00\" (meaning 1 hour, 10 minutes, 0 seconds) into\n\t     * number of milliseconds. This is used to support human-readable strings passed\n\t     * to clock.tick()\n\t     * @param {string} str\n\t     * @returns {number}\n\t     */\n\t    function parseTime(str) {\n\t        if (!str) {\n\t            return 0;\n\t        }\n\n\t        const strings = str.split(\":\");\n\t        const l = strings.length;\n\t        let i = l;\n\t        let ms = 0;\n\t        let parsed;\n\n\t        if (l > 3 || !/^(\\d\\d:){0,2}\\d\\d?$/.test(str)) {\n\t            throw new Error(\n\t                \"tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits\",\n\t            );\n\t        }\n\n\t        while (i--) {\n\t            parsed = parseInt(strings[i], 10);\n\n\t            if (parsed >= 60) {\n\t                throw new Error(`Invalid time ${str}`);\n\t            }\n\n\t            ms += parsed * Math.pow(60, l - i - 1);\n\t        }\n\n\t        return ms * 1000;\n\t    }\n\n\t    /**\n\t     * Get the decimal part of the millisecond value as nanoseconds\n\t     * @param {number} msFloat the number of milliseconds\n\t     * @returns {number} an integer number of nanoseconds in the range [0,1e6)\n\t     *\n\t     * Example: nanoRemainer(123.456789) -> 456789\n\t     */\n\t    function nanoRemainder(msFloat) {\n\t        const modulo = 1e6;\n\t        const remainder = (msFloat * 1e6) % modulo;\n\t        const positiveRemainder =\n\t            remainder < 0 ? remainder + modulo : remainder;\n\n\t        return Math.floor(positiveRemainder);\n\t    }\n\n\t    /**\n\t     * Used to grok the `now` parameter to createClock.\n\t     * @param {Date|number} epoch the system time\n\t     * @returns {number}\n\t     */\n\t    function getEpoch(epoch) {\n\t        if (!epoch) {\n\t            return 0;\n\t        }\n\t        if (typeof epoch.getTime === \"function\") {\n\t            return epoch.getTime();\n\t        }\n\t        if (typeof epoch === \"number\") {\n\t            return epoch;\n\t        }\n\t        throw new TypeError(\"now should be milliseconds since UNIX epoch\");\n\t    }\n\n\t    /**\n\t     * @param {number} from\n\t     * @param {number} to\n\t     * @param {Timer} timer\n\t     * @returns {boolean}\n\t     */\n\t    function inRange(from, to, timer) {\n\t        return timer && timer.callAt >= from && timer.callAt <= to;\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @param {Timer} job\n\t     */\n\t    function getInfiniteLoopError(clock, job) {\n\t        const infiniteLoopError = new Error(\n\t            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`,\n\t        );\n\n\t        if (!job.error) {\n\t            return infiniteLoopError;\n\t        }\n\n\t        // pattern never matched in Node\n\t        const computedTargetPattern = /target\\.*[<|(|[].*?[>|\\]|)]\\s*/;\n\t        let clockMethodPattern = new RegExp(\n\t            String(Object.keys(clock).join(\"|\")),\n\t        );\n\n\t        if (addTimerReturnsObject) {\n\t            // node.js environment\n\t            clockMethodPattern = new RegExp(\n\t                `\\\\s+at (Object\\\\.)?(?:${Object.keys(clock).join(\"|\")})\\\\s+`,\n\t            );\n\t        }\n\n\t        let matchedLineIndex = -1;\n\t        job.error.stack.split(\"\\n\").some(function (line, i) {\n\t            // If we've matched a computed target line (e.g. setTimeout) then we\n\t            // don't need to look any further. Return true to stop iterating.\n\t            const matchedComputedTarget = line.match(computedTargetPattern);\n\t            /* istanbul ignore if */\n\t            if (matchedComputedTarget) {\n\t                matchedLineIndex = i;\n\t                return true;\n\t            }\n\n\t            // If we've matched a clock method line, then there may still be\n\t            // others further down the trace. Return false to keep iterating.\n\t            const matchedClockMethod = line.match(clockMethodPattern);\n\t            if (matchedClockMethod) {\n\t                matchedLineIndex = i;\n\t                return false;\n\t            }\n\n\t            // If we haven't matched anything on this line, but we matched\n\t            // previously and set the matched line index, then we can stop.\n\t            // If we haven't matched previously, then we should keep iterating.\n\t            return matchedLineIndex >= 0;\n\t        });\n\n\t        const stack = `${infiniteLoopError}\\n${job.type || \"Microtask\"} - ${\n\t            job.func.name || \"anonymous\"\n\t        }\\n${job.error.stack\n\t            .split(\"\\n\")\n\t            .slice(matchedLineIndex + 1)\n\t            .join(\"\\n\")}`;\n\n\t        try {\n\t            Object.defineProperty(infiniteLoopError, \"stack\", {\n\t                value: stack,\n\t            });\n\t        } catch (e) {\n\t            // noop\n\t        }\n\n\t        return infiniteLoopError;\n\t    }\n\n\t    //eslint-disable-next-line jsdoc/require-jsdoc\n\t    function createDate() {\n\t        class ClockDate extends NativeDate {\n\t            /**\n\t             * @param {number} year\n\t             * @param {number} month\n\t             * @param {number} date\n\t             * @param {number} hour\n\t             * @param {number} minute\n\t             * @param {number} second\n\t             * @param {number} ms\n\t             * @returns void\n\t             */\n\t            // eslint-disable-next-line no-unused-vars\n\t            constructor(year, month, date, hour, minute, second, ms) {\n\t                // Defensive and verbose to avoid potential harm in passing\n\t                // explicit undefined when user does not pass argument\n\t                if (arguments.length === 0) {\n\t                    super(ClockDate.clock.now);\n\t                } else {\n\t                    super(...arguments);\n\t                }\n\n\t                // ensures identity checks using the constructor prop still works\n\t                // this should have no other functional effect\n\t                Object.defineProperty(this, \"constructor\", {\n\t                    value: NativeDate,\n\t                    enumerable: false,\n\t                });\n\t            }\n\n\t            static [Symbol.hasInstance](instance) {\n\t                return instance instanceof NativeDate;\n\t            }\n\t        }\n\n\t        ClockDate.isFake = true;\n\n\t        if (NativeDate.now) {\n\t            ClockDate.now = function now() {\n\t                return ClockDate.clock.now;\n\t            };\n\t        }\n\n\t        if (NativeDate.toSource) {\n\t            ClockDate.toSource = function toSource() {\n\t                return NativeDate.toSource();\n\t            };\n\t        }\n\n\t        ClockDate.toString = function toString() {\n\t            return NativeDate.toString();\n\t        };\n\n\t        // noinspection UnnecessaryLocalVariableJS\n\t        /**\n\t         * A normal Class constructor cannot be called without `new`, but Date can, so we need\n\t         * to wrap it in a Proxy in order to ensure this functionality of Date is kept intact\n\t         * @type {ClockDate}\n\t         */\n\t        const ClockDateProxy = new Proxy(ClockDate, {\n\t            // handler for [[Call]] invocations (i.e. not using `new`)\n\t            apply() {\n\t                // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.\n\t                // This remains so in the 10th edition of 2019 as well.\n\t                if (this instanceof ClockDate) {\n\t                    throw new TypeError(\n\t                        \"A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic.\",\n\t                    );\n\t                }\n\n\t                return new NativeDate(ClockDate.clock.now).toString();\n\t            },\n\t        });\n\n\t        return ClockDateProxy;\n\t    }\n\n\t    /**\n\t     * Mirror Intl by default on our fake implementation\n\t     *\n\t     * Most of the properties are the original native ones,\n\t     * but we need to take control of those that have a\n\t     * dependency on the current clock.\n\t     * @returns {object} the partly fake Intl implementation\n\t     */\n\t    function createIntl() {\n\t        const ClockIntl = {};\n\t        /*\n\t         * All properties of Intl are non-enumerable, so we need\n\t         * to do a bit of work to get them out.\n\t         */\n\t        Object.getOwnPropertyNames(NativeIntl).forEach(\n\t            (property) => (ClockIntl[property] = NativeIntl[property]),\n\t        );\n\n\t        ClockIntl.DateTimeFormat = function (...args) {\n\t            const realFormatter = new NativeIntl.DateTimeFormat(...args);\n\t            const formatter = {};\n\n\t            [\"formatRange\", \"formatRangeToParts\", \"resolvedOptions\"].forEach(\n\t                (method) => {\n\t                    formatter[method] =\n\t                        realFormatter[method].bind(realFormatter);\n\t                },\n\t            );\n\n\t            [\"format\", \"formatToParts\"].forEach((method) => {\n\t                formatter[method] = function (date) {\n\t                    return realFormatter[method](date || ClockIntl.clock.now);\n\t                };\n\t            });\n\n\t            return formatter;\n\t        };\n\n\t        ClockIntl.DateTimeFormat.prototype = Object.create(\n\t            NativeIntl.DateTimeFormat.prototype,\n\t        );\n\n\t        ClockIntl.DateTimeFormat.supportedLocalesOf =\n\t            NativeIntl.DateTimeFormat.supportedLocalesOf;\n\n\t        return ClockIntl;\n\t    }\n\n\t    //eslint-disable-next-line jsdoc/require-jsdoc\n\t    function enqueueJob(clock, job) {\n\t        // enqueues a microtick-deferred task - ecma262/#sec-enqueuejob\n\t        if (!clock.jobs) {\n\t            clock.jobs = [];\n\t        }\n\t        clock.jobs.push(job);\n\t    }\n\n\t    //eslint-disable-next-line jsdoc/require-jsdoc\n\t    function runJobs(clock) {\n\t        // runs all microtick-deferred tasks - ecma262/#sec-runjobs\n\t        if (!clock.jobs) {\n\t            return;\n\t        }\n\t        for (let i = 0; i < clock.jobs.length; i++) {\n\t            const job = clock.jobs[i];\n\t            job.func.apply(null, job.args);\n\n\t            checkIsNearInfiniteLimit(clock, i);\n\t            if (clock.loopLimit && i > clock.loopLimit) {\n\t                throw getInfiniteLoopError(clock, job);\n\t            }\n\t        }\n\t        resetIsNearInfiniteLimit();\n\t        clock.jobs = [];\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @param {Timer} timer\n\t     * @returns {number} id of the created timer\n\t     */\n\t    function addTimer(clock, timer) {\n\t        if (timer.func === undefined) {\n\t            throw new Error(\"Callback must be provided to timer calls\");\n\t        }\n\n\t        if (addTimerReturnsObject) {\n\t            // Node.js environment\n\t            if (typeof timer.func !== \"function\") {\n\t                throw new TypeError(\n\t                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${\n\t                        timer.func\n\t                    } of type ${typeof timer.func}`,\n\t                );\n\t            }\n\t        }\n\n\t        if (isNearInfiniteLimit) {\n\t            timer.error = new Error();\n\t        }\n\n\t        timer.type = timer.immediate ? \"Immediate\" : \"Timeout\";\n\n\t        if (timer.hasOwnProperty(\"delay\")) {\n\t            if (typeof timer.delay !== \"number\") {\n\t                timer.delay = parseInt(timer.delay, 10);\n\t            }\n\n\t            if (!isNumberFinite(timer.delay)) {\n\t                timer.delay = 0;\n\t            }\n\t            timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;\n\t            timer.delay = Math.max(0, timer.delay);\n\t        }\n\n\t        if (timer.hasOwnProperty(\"interval\")) {\n\t            timer.type = \"Interval\";\n\t            timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;\n\t        }\n\n\t        if (timer.hasOwnProperty(\"animation\")) {\n\t            timer.type = \"AnimationFrame\";\n\t            timer.animation = true;\n\t        }\n\n\t        if (timer.hasOwnProperty(\"idleCallback\")) {\n\t            timer.type = \"IdleCallback\";\n\t            timer.idleCallback = true;\n\t        }\n\n\t        if (!clock.timers) {\n\t            clock.timers = {};\n\t        }\n\n\t        timer.id = uniqueTimerId++;\n\t        timer.createdAt = clock.now;\n\t        timer.callAt =\n\t            clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));\n\n\t        clock.timers[timer.id] = timer;\n\n\t        if (addTimerReturnsObject) {\n\t            const res = {\n\t                refed: true,\n\t                ref: function () {\n\t                    this.refed = true;\n\t                    return res;\n\t                },\n\t                unref: function () {\n\t                    this.refed = false;\n\t                    return res;\n\t                },\n\t                hasRef: function () {\n\t                    return this.refed;\n\t                },\n\t                refresh: function () {\n\t                    timer.callAt =\n\t                        clock.now +\n\t                        (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));\n\n\t                    // it _might_ have been removed, but if not the assignment is perfectly fine\n\t                    clock.timers[timer.id] = timer;\n\n\t                    return res;\n\t                },\n\t                [Symbol.toPrimitive]: function () {\n\t                    return timer.id;\n\t                },\n\t            };\n\t            return res;\n\t        }\n\n\t        return timer.id;\n\t    }\n\n\t    /* eslint consistent-return: \"off\" */\n\t    /**\n\t     * Timer comparitor\n\t     * @param {Timer} a\n\t     * @param {Timer} b\n\t     * @returns {number}\n\t     */\n\t    function compareTimers(a, b) {\n\t        // Sort first by absolute timing\n\t        if (a.callAt < b.callAt) {\n\t            return -1;\n\t        }\n\t        if (a.callAt > b.callAt) {\n\t            return 1;\n\t        }\n\n\t        // Sort next by immediate, immediate timers take precedence\n\t        if (a.immediate && !b.immediate) {\n\t            return -1;\n\t        }\n\t        if (!a.immediate && b.immediate) {\n\t            return 1;\n\t        }\n\n\t        // Sort next by creation time, earlier-created timers take precedence\n\t        if (a.createdAt < b.createdAt) {\n\t            return -1;\n\t        }\n\t        if (a.createdAt > b.createdAt) {\n\t            return 1;\n\t        }\n\n\t        // Sort next by id, lower-id timers take precedence\n\t        if (a.id < b.id) {\n\t            return -1;\n\t        }\n\t        if (a.id > b.id) {\n\t            return 1;\n\t        }\n\n\t        // As timer ids are unique, no fallback `0` is necessary\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @param {number} from\n\t     * @param {number} to\n\t     * @returns {Timer}\n\t     */\n\t    function firstTimerInRange(clock, from, to) {\n\t        const timers = clock.timers;\n\t        let timer = null;\n\t        let id, isInRange;\n\n\t        for (id in timers) {\n\t            if (timers.hasOwnProperty(id)) {\n\t                isInRange = inRange(from, to, timers[id]);\n\n\t                if (\n\t                    isInRange &&\n\t                    (!timer || compareTimers(timer, timers[id]) === 1)\n\t                ) {\n\t                    timer = timers[id];\n\t                }\n\t            }\n\t        }\n\n\t        return timer;\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @returns {Timer}\n\t     */\n\t    function firstTimer(clock) {\n\t        const timers = clock.timers;\n\t        let timer = null;\n\t        let id;\n\n\t        for (id in timers) {\n\t            if (timers.hasOwnProperty(id)) {\n\t                if (!timer || compareTimers(timer, timers[id]) === 1) {\n\t                    timer = timers[id];\n\t                }\n\t            }\n\t        }\n\n\t        return timer;\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @returns {Timer}\n\t     */\n\t    function lastTimer(clock) {\n\t        const timers = clock.timers;\n\t        let timer = null;\n\t        let id;\n\n\t        for (id in timers) {\n\t            if (timers.hasOwnProperty(id)) {\n\t                if (!timer || compareTimers(timer, timers[id]) === -1) {\n\t                    timer = timers[id];\n\t                }\n\t            }\n\t        }\n\n\t        return timer;\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @param {Timer} timer\n\t     */\n\t    function callTimer(clock, timer) {\n\t        if (typeof timer.interval === \"number\") {\n\t            clock.timers[timer.id].callAt += timer.interval;\n\t        } else {\n\t            delete clock.timers[timer.id];\n\t        }\n\n\t        if (typeof timer.func === \"function\") {\n\t            timer.func.apply(null, timer.args);\n\t        } else {\n\t            /* eslint no-eval: \"off\" */\n\t            const eval2 = eval;\n\t            (function () {\n\t                eval2(timer.func);\n\t            })();\n\t        }\n\t    }\n\n\t    /**\n\t     * Gets clear handler name for a given timer type\n\t     * @param {string} ttype\n\t     */\n\t    function getClearHandler(ttype) {\n\t        if (ttype === \"IdleCallback\" || ttype === \"AnimationFrame\") {\n\t            return `cancel${ttype}`;\n\t        }\n\t        return `clear${ttype}`;\n\t    }\n\n\t    /**\n\t     * Gets schedule handler name for a given timer type\n\t     * @param {string} ttype\n\t     */\n\t    function getScheduleHandler(ttype) {\n\t        if (ttype === \"IdleCallback\" || ttype === \"AnimationFrame\") {\n\t            return `request${ttype}`;\n\t        }\n\t        return `set${ttype}`;\n\t    }\n\n\t    /**\n\t     * Creates an anonymous function to warn only once\n\t     */\n\t    function createWarnOnce() {\n\t        let calls = 0;\n\t        return function (msg) {\n\t            // eslint-disable-next-line\n\t            !calls++ && console.warn(msg);\n\t        };\n\t    }\n\t    const warnOnce = createWarnOnce();\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @param {number} timerId\n\t     * @param {string} ttype\n\t     */\n\t    function clearTimer(clock, timerId, ttype) {\n\t        if (!timerId) {\n\t            // null appears to be allowed in most browsers, and appears to be\n\t            // relied upon by some libraries, like Bootstrap carousel\n\t            return;\n\t        }\n\n\t        if (!clock.timers) {\n\t            clock.timers = {};\n\t        }\n\n\t        // in Node, the ID is stored as the primitive value for `Timeout` objects\n\t        // for `Immediate` objects, no ID exists, so it gets coerced to NaN\n\t        const id = Number(timerId);\n\n\t        if (Number.isNaN(id) || id < idCounterStart) {\n\t            const handlerName = getClearHandler(ttype);\n\n\t            if (clock.shouldClearNativeTimers === true) {\n\t                const nativeHandler = clock[`_${handlerName}`];\n\t                return typeof nativeHandler === \"function\"\n\t                    ? nativeHandler(timerId)\n\t                    : undefined;\n\t            }\n\t            warnOnce(\n\t                `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.` +\n\t                    \"\\nTo automatically clean-up native timers, use `shouldClearNativeTimers`.\",\n\t            );\n\t        }\n\n\t        if (clock.timers.hasOwnProperty(id)) {\n\t            // check that the ID matches a timer of the correct type\n\t            const timer = clock.timers[id];\n\t            if (\n\t                timer.type === ttype ||\n\t                (timer.type === \"Timeout\" && ttype === \"Interval\") ||\n\t                (timer.type === \"Interval\" && ttype === \"Timeout\")\n\t            ) {\n\t                delete clock.timers[id];\n\t            } else {\n\t                const clear = getClearHandler(ttype);\n\t                const schedule = getScheduleHandler(timer.type);\n\t                throw new Error(\n\t                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`,\n\t                );\n\t            }\n\t        }\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @returns {Timer[]}\n\t     */\n\t    function uninstall(clock) {\n\t        let method, i, l;\n\t        const installedHrTime = \"_hrtime\";\n\t        const installedNextTick = \"_nextTick\";\n\n\t        for (i = 0, l = clock.methods.length; i < l; i++) {\n\t            method = clock.methods[i];\n\t            if (method === \"hrtime\" && _global.process) {\n\t                _global.process.hrtime = clock[installedHrTime];\n\t            } else if (method === \"nextTick\" && _global.process) {\n\t                _global.process.nextTick = clock[installedNextTick];\n\t            } else if (method === \"performance\") {\n\t                const originalPerfDescriptor = Object.getOwnPropertyDescriptor(\n\t                    clock,\n\t                    `_${method}`,\n\t                );\n\t                if (\n\t                    originalPerfDescriptor &&\n\t                    originalPerfDescriptor.get &&\n\t                    !originalPerfDescriptor.set\n\t                ) {\n\t                    Object.defineProperty(\n\t                        _global,\n\t                        method,\n\t                        originalPerfDescriptor,\n\t                    );\n\t                } else if (originalPerfDescriptor.configurable) {\n\t                    _global[method] = clock[`_${method}`];\n\t                }\n\t            } else {\n\t                if (_global[method] && _global[method].hadOwnProperty) {\n\t                    _global[method] = clock[`_${method}`];\n\t                } else {\n\t                    try {\n\t                        delete _global[method];\n\t                    } catch (ignore) {\n\t                        /* eslint no-empty: \"off\" */\n\t                    }\n\t                }\n\t            }\n\t            if (clock.timersModuleMethods !== undefined) {\n\t                for (let j = 0; j < clock.timersModuleMethods.length; j++) {\n\t                    const entry = clock.timersModuleMethods[j];\n\t                    timersModule[entry.methodName] = entry.original;\n\t                }\n\t            }\n\t            if (clock.timersPromisesModuleMethods !== undefined) {\n\t                for (\n\t                    let j = 0;\n\t                    j < clock.timersPromisesModuleMethods.length;\n\t                    j++\n\t                ) {\n\t                    const entry = clock.timersPromisesModuleMethods[j];\n\t                    timersPromisesModule[entry.methodName] = entry.original;\n\t                }\n\t            }\n\t        }\n\n\t        clock.setTickMode(\"manual\");\n\n\t        // Prevent multiple executions which will completely remove these props\n\t        clock.methods = [];\n\n\t        for (const [listener, signal] of clock.abortListenerMap.entries()) {\n\t            signal.removeEventListener(\"abort\", listener);\n\t            clock.abortListenerMap.delete(listener);\n\t        }\n\n\t        // return pending timers, to enable checking what timers remained on uninstall\n\t        if (!clock.timers) {\n\t            return [];\n\t        }\n\t        return Object.keys(clock.timers).map(function mapper(key) {\n\t            return clock.timers[key];\n\t        });\n\t    }\n\n\t    /**\n\t     * @param {object} target the target containing the method to replace\n\t     * @param {string} method the keyname of the method on the target\n\t     * @param {Clock} clock\n\t     */\n\t    function hijackMethod(target, method, clock) {\n\t        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(\n\t            target,\n\t            method,\n\t        );\n\t        clock[`_${method}`] = target[method];\n\n\t        if (method === \"Date\") {\n\t            target[method] = clock[method];\n\t        } else if (method === \"Intl\") {\n\t            target[method] = clock[method];\n\t        } else if (method === \"performance\") {\n\t            const originalPerfDescriptor = Object.getOwnPropertyDescriptor(\n\t                target,\n\t                method,\n\t            );\n\t            // JSDOM has a read only performance field so we have to save/copy it differently\n\t            if (\n\t                originalPerfDescriptor &&\n\t                originalPerfDescriptor.get &&\n\t                !originalPerfDescriptor.set\n\t            ) {\n\t                Object.defineProperty(\n\t                    clock,\n\t                    `_${method}`,\n\t                    originalPerfDescriptor,\n\t                );\n\n\t                const perfDescriptor = Object.getOwnPropertyDescriptor(\n\t                    clock,\n\t                    method,\n\t                );\n\t                Object.defineProperty(target, method, perfDescriptor);\n\t            } else {\n\t                target[method] = clock[method];\n\t            }\n\t        } else {\n\t            target[method] = function () {\n\t                return clock[method].apply(clock, arguments);\n\t            };\n\n\t            Object.defineProperties(\n\t                target[method],\n\t                Object.getOwnPropertyDescriptors(clock[method]),\n\t            );\n\t        }\n\n\t        target[method].clock = clock;\n\t    }\n\n\t    /**\n\t     * @param {Clock} clock\n\t     * @param {number} advanceTimeDelta\n\t     */\n\t    function doIntervalTick(clock, advanceTimeDelta) {\n\t        clock.tick(advanceTimeDelta);\n\t    }\n\n\t    /**\n\t     * @typedef {object} Timers\n\t     * @property {setTimeout} setTimeout\n\t     * @property {clearTimeout} clearTimeout\n\t     * @property {setInterval} setInterval\n\t     * @property {clearInterval} clearInterval\n\t     * @property {Date} Date\n\t     * @property {Intl} Intl\n\t     * @property {SetImmediate=} setImmediate\n\t     * @property {function(NodeImmediate): void=} clearImmediate\n\t     * @property {function(number[]):number[]=} hrtime\n\t     * @property {NextTick=} nextTick\n\t     * @property {Performance=} performance\n\t     * @property {RequestAnimationFrame=} requestAnimationFrame\n\t     * @property {boolean=} queueMicrotask\n\t     * @property {function(number): void=} cancelAnimationFrame\n\t     * @property {RequestIdleCallback=} requestIdleCallback\n\t     * @property {function(number): void=} cancelIdleCallback\n\t     */\n\n\t    /** @type {Timers} */\n\t    const timers = {\n\t        setTimeout: _global.setTimeout,\n\t        clearTimeout: _global.clearTimeout,\n\t        setInterval: _global.setInterval,\n\t        clearInterval: _global.clearInterval,\n\t        Date: _global.Date,\n\t    };\n\n\t    if (isPresent.setImmediate) {\n\t        timers.setImmediate = _global.setImmediate;\n\t    }\n\n\t    if (isPresent.clearImmediate) {\n\t        timers.clearImmediate = _global.clearImmediate;\n\t    }\n\n\t    if (isPresent.hrtime) {\n\t        timers.hrtime = _global.process.hrtime;\n\t    }\n\n\t    if (isPresent.nextTick) {\n\t        timers.nextTick = _global.process.nextTick;\n\t    }\n\n\t    if (isPresent.performance) {\n\t        timers.performance = _global.performance;\n\t    }\n\n\t    if (isPresent.requestAnimationFrame) {\n\t        timers.requestAnimationFrame = _global.requestAnimationFrame;\n\t    }\n\n\t    if (isPresent.queueMicrotask) {\n\t        timers.queueMicrotask = _global.queueMicrotask;\n\t    }\n\n\t    if (isPresent.cancelAnimationFrame) {\n\t        timers.cancelAnimationFrame = _global.cancelAnimationFrame;\n\t    }\n\n\t    if (isPresent.requestIdleCallback) {\n\t        timers.requestIdleCallback = _global.requestIdleCallback;\n\t    }\n\n\t    if (isPresent.cancelIdleCallback) {\n\t        timers.cancelIdleCallback = _global.cancelIdleCallback;\n\t    }\n\n\t    if (isPresent.Intl) {\n\t        timers.Intl = NativeIntl;\n\t    }\n\n\t    const originalSetTimeout = _global.setImmediate || _global.setTimeout;\n\t    const originalClearInterval = _global.clearInterval;\n\t    const originalSetInterval = _global.setInterval;\n\n\t    /**\n\t     * @param {Date|number} [start] the system time - non-integer values are floored\n\t     * @param {number} [loopLimit] maximum number of timers that will be run when calling runAll()\n\t     * @returns {Clock}\n\t     */\n\t    function createClock(start, loopLimit) {\n\t        // eslint-disable-next-line no-param-reassign\n\t        start = Math.floor(getEpoch(start));\n\t        // eslint-disable-next-line no-param-reassign\n\t        loopLimit = loopLimit || 1000;\n\t        let nanos = 0;\n\t        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]\n\n\t        const clock = {\n\t            now: start,\n\t            Date: createDate(),\n\t            loopLimit: loopLimit,\n\t            tickMode: { mode: \"manual\", counter: 0, delta: undefined },\n\t        };\n\n\t        clock.Date.clock = clock;\n\n\t        //eslint-disable-next-line jsdoc/require-jsdoc\n\t        function getTimeToNextFrame() {\n\t            return 16 - ((clock.now - start) % 16);\n\t        }\n\n\t        //eslint-disable-next-line jsdoc/require-jsdoc\n\t        function hrtime(prev) {\n\t            const millisSinceStart = clock.now - adjustedSystemTime[0] - start;\n\t            const secsSinceStart = Math.floor(millisSinceStart / 1000);\n\t            const remainderInNanos =\n\t                (millisSinceStart - secsSinceStart * 1e3) * 1e6 +\n\t                nanos -\n\t                adjustedSystemTime[1];\n\n\t            if (Array.isArray(prev)) {\n\t                if (prev[1] > 1e9) {\n\t                    throw new TypeError(\n\t                        \"Number of nanoseconds can't exceed a billion\",\n\t                    );\n\t                }\n\n\t                const oldSecs = prev[0];\n\t                let nanoDiff = remainderInNanos - prev[1];\n\t                let secDiff = secsSinceStart - oldSecs;\n\n\t                if (nanoDiff < 0) {\n\t                    nanoDiff += 1e9;\n\t                    secDiff -= 1;\n\t                }\n\n\t                return [secDiff, nanoDiff];\n\t            }\n\t            return [secsSinceStart, remainderInNanos];\n\t        }\n\n\t        /**\n\t         * A high resolution timestamp in milliseconds.\n\t         * @typedef {number} DOMHighResTimeStamp\n\t         */\n\n\t        /**\n\t         * performance.now()\n\t         * @returns {DOMHighResTimeStamp}\n\t         */\n\t        function fakePerformanceNow() {\n\t            const hrt = hrtime();\n\t            const millis = hrt[0] * 1000 + hrt[1] / 1e6;\n\t            return millis;\n\t        }\n\n\t        if (isPresent.hrtimeBigint) {\n\t            hrtime.bigint = function () {\n\t                const parts = hrtime();\n\t                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line\n\t            };\n\t        }\n\n\t        if (isPresent.Intl) {\n\t            clock.Intl = createIntl();\n\t            clock.Intl.clock = clock;\n\t        }\n\n\t        /**\n\t         * @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.\n\t         */\n\t        clock.setTickMode = function (tickModeConfig) {\n\t            const { mode: newMode, delta: newDelta } = tickModeConfig;\n\t            const { mode: oldMode, delta: oldDelta } = clock.tickMode;\n\t            if (newMode === oldMode && newDelta === oldDelta) {\n\t                return;\n\t            }\n\n\t            if (oldMode === \"interval\") {\n\t                originalClearInterval(clock.attachedInterval);\n\t            }\n\n\t            clock.tickMode = {\n\t                counter: clock.tickMode.counter + 1,\n\t                mode: newMode,\n\t                delta: newDelta,\n\t            };\n\n\t            if (newMode === \"nextAsync\") {\n\t                advanceUntilModeChanges();\n\t            } else if (newMode === \"interval\") {\n\t                createIntervalTick(clock, newDelta || 20);\n\t            }\n\t        };\n\n\t        async function advanceUntilModeChanges() {\n\t            async function newMacrotask() {\n\t                // MessageChannel ensures that setTimeout is not throttled to 4ms.\n\t                // https://developer.mozilla.org/en-US/docs/Web/API/setTimeout#reasons_for_delays_longer_than_specified\n\t                // https://stackblitz.com/edit/stackblitz-starters-qtlpcc\n\t                const channel = new MessageChannel();\n\t                await new Promise((resolve) => {\n\t                    channel.port1.onmessage = () => {\n\t                        resolve();\n\t                        channel.port1.close();\n\t                    };\n\t                    channel.port2.postMessage(undefined);\n\t                });\n\t                channel.port1.close();\n\t                channel.port2.close();\n\t                // setTimeout ensures microtask queue is emptied\n\t                await new Promise((resolve) => {\n\t                    originalSetTimeout(resolve);\n\t                });\n\t            }\n\n\t            const { counter } = clock.tickMode;\n\t            while (clock.tickMode.counter === counter) {\n\t                await newMacrotask();\n\t                if (clock.tickMode.counter !== counter) {\n\t                    return;\n\t                }\n\t                clock.next();\n\t            }\n\t        }\n\n\t        function pauseAutoTickUntilFinished(promise) {\n\t            if (clock.tickMode.mode !== \"nextAsync\") {\n\t                return promise;\n\t            }\n\t            clock.setTickMode({ mode: \"manual\" });\n\t            return promise.finally(() => {\n\t                clock.setTickMode({ mode: \"nextAsync\" });\n\t            });\n\t        }\n\n\t        clock.requestIdleCallback = function requestIdleCallback(\n\t            func,\n\t            timeout,\n\t        ) {\n\t            let timeToNextIdlePeriod = 0;\n\n\t            if (clock.countTimers() > 0) {\n\t                timeToNextIdlePeriod = 50; // const for now\n\t            }\n\n\t            const result = addTimer(clock, {\n\t                func: func,\n\t                args: Array.prototype.slice.call(arguments, 2),\n\t                delay:\n\t                    typeof timeout === \"undefined\"\n\t                        ? timeToNextIdlePeriod\n\t                        : Math.min(timeout, timeToNextIdlePeriod),\n\t                idleCallback: true,\n\t            });\n\n\t            return Number(result);\n\t        };\n\n\t        clock.cancelIdleCallback = function cancelIdleCallback(timerId) {\n\t            return clearTimer(clock, timerId, \"IdleCallback\");\n\t        };\n\n\t        clock.setTimeout = function setTimeout(func, timeout) {\n\t            return addTimer(clock, {\n\t                func: func,\n\t                args: Array.prototype.slice.call(arguments, 2),\n\t                delay: timeout,\n\t            });\n\t        };\n\t        if (typeof _global.Promise !== \"undefined\" && utilPromisify) {\n\t            clock.setTimeout[utilPromisify.custom] =\n\t                function promisifiedSetTimeout(timeout, arg) {\n\t                    return new _global.Promise(function setTimeoutExecutor(\n\t                        resolve,\n\t                    ) {\n\t                        addTimer(clock, {\n\t                            func: resolve,\n\t                            args: [arg],\n\t                            delay: timeout,\n\t                        });\n\t                    });\n\t                };\n\t        }\n\n\t        clock.clearTimeout = function clearTimeout(timerId) {\n\t            return clearTimer(clock, timerId, \"Timeout\");\n\t        };\n\n\t        clock.nextTick = function nextTick(func) {\n\t            return enqueueJob(clock, {\n\t                func: func,\n\t                args: Array.prototype.slice.call(arguments, 1),\n\t                error: isNearInfiniteLimit ? new Error() : null,\n\t            });\n\t        };\n\n\t        clock.queueMicrotask = function queueMicrotask(func) {\n\t            return clock.nextTick(func); // explicitly drop additional arguments\n\t        };\n\n\t        clock.setInterval = function setInterval(func, timeout) {\n\t            // eslint-disable-next-line no-param-reassign\n\t            timeout = parseInt(timeout, 10);\n\t            return addTimer(clock, {\n\t                func: func,\n\t                args: Array.prototype.slice.call(arguments, 2),\n\t                delay: timeout,\n\t                interval: timeout,\n\t            });\n\t        };\n\n\t        clock.clearInterval = function clearInterval(timerId) {\n\t            return clearTimer(clock, timerId, \"Interval\");\n\t        };\n\n\t        if (isPresent.setImmediate) {\n\t            clock.setImmediate = function setImmediate(func) {\n\t                return addTimer(clock, {\n\t                    func: func,\n\t                    args: Array.prototype.slice.call(arguments, 1),\n\t                    immediate: true,\n\t                });\n\t            };\n\n\t            if (typeof _global.Promise !== \"undefined\" && utilPromisify) {\n\t                clock.setImmediate[utilPromisify.custom] =\n\t                    function promisifiedSetImmediate(arg) {\n\t                        return new _global.Promise(\n\t                            function setImmediateExecutor(resolve) {\n\t                                addTimer(clock, {\n\t                                    func: resolve,\n\t                                    args: [arg],\n\t                                    immediate: true,\n\t                                });\n\t                            },\n\t                        );\n\t                    };\n\t            }\n\n\t            clock.clearImmediate = function clearImmediate(timerId) {\n\t                return clearTimer(clock, timerId, \"Immediate\");\n\t            };\n\t        }\n\n\t        clock.countTimers = function countTimers() {\n\t            return (\n\t                Object.keys(clock.timers || {}).length +\n\t                (clock.jobs || []).length\n\t            );\n\t        };\n\n\t        clock.requestAnimationFrame = function requestAnimationFrame(func) {\n\t            const result = addTimer(clock, {\n\t                func: func,\n\t                delay: getTimeToNextFrame(),\n\t                get args() {\n\t                    return [fakePerformanceNow()];\n\t                },\n\t                animation: true,\n\t            });\n\n\t            return Number(result);\n\t        };\n\n\t        clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {\n\t            return clearTimer(clock, timerId, \"AnimationFrame\");\n\t        };\n\n\t        clock.runMicrotasks = function runMicrotasks() {\n\t            runJobs(clock);\n\t        };\n\n\t        /**\n\t         * @param {number|string} tickValue milliseconds or a string parseable by parseTime\n\t         * @param {boolean} isAsync\n\t         * @param {Function} resolve\n\t         * @param {Function} reject\n\t         * @returns {number|undefined} will return the new `now` value or nothing for async\n\t         */\n\t        function doTick(tickValue, isAsync, resolve, reject) {\n\t            const msFloat =\n\t                typeof tickValue === \"number\"\n\t                    ? tickValue\n\t                    : parseTime(tickValue);\n\t            const ms = Math.floor(msFloat);\n\t            const remainder = nanoRemainder(msFloat);\n\t            let nanosTotal = nanos + remainder;\n\t            let tickTo = clock.now + ms;\n\n\t            if (msFloat < 0) {\n\t                throw new TypeError(\"Negative ticks are not supported\");\n\t            }\n\n\t            // adjust for positive overflow\n\t            if (nanosTotal >= 1e6) {\n\t                tickTo += 1;\n\t                nanosTotal -= 1e6;\n\t            }\n\n\t            nanos = nanosTotal;\n\t            let tickFrom = clock.now;\n\t            let previous = clock.now;\n\t            // ESLint fails to detect this correctly\n\t            /* eslint-disable prefer-const */\n\t            let timer,\n\t                firstException,\n\t                oldNow,\n\t                nextPromiseTick,\n\t                compensationCheck,\n\t                postTimerCall;\n\t            /* eslint-enable prefer-const */\n\n\t            clock.duringTick = true;\n\n\t            // perform microtasks\n\t            oldNow = clock.now;\n\t            runJobs(clock);\n\t            if (oldNow !== clock.now) {\n\t                // compensate for any setSystemTime() call during microtask callback\n\t                tickFrom += clock.now - oldNow;\n\t                tickTo += clock.now - oldNow;\n\t            }\n\n\t            //eslint-disable-next-line jsdoc/require-jsdoc\n\t            function doTickInner() {\n\t                // perform each timer in the requested range\n\t                timer = firstTimerInRange(clock, tickFrom, tickTo);\n\t                // eslint-disable-next-line no-unmodified-loop-condition\n\t                while (timer && tickFrom <= tickTo) {\n\t                    if (clock.timers[timer.id]) {\n\t                        tickFrom = timer.callAt;\n\t                        clock.now = timer.callAt;\n\t                        oldNow = clock.now;\n\t                        try {\n\t                            runJobs(clock);\n\t                            callTimer(clock, timer);\n\t                        } catch (e) {\n\t                            firstException = firstException || e;\n\t                        }\n\n\t                        if (isAsync) {\n\t                            // finish up after native setImmediate callback to allow\n\t                            // all native es6 promises to process their callbacks after\n\t                            // each timer fires.\n\t                            originalSetTimeout(nextPromiseTick);\n\t                            return;\n\t                        }\n\n\t                        compensationCheck();\n\t                    }\n\n\t                    postTimerCall();\n\t                }\n\n\t                // perform process.nextTick()s again\n\t                oldNow = clock.now;\n\t                runJobs(clock);\n\t                if (oldNow !== clock.now) {\n\t                    // compensate for any setSystemTime() call during process.nextTick() callback\n\t                    tickFrom += clock.now - oldNow;\n\t                    tickTo += clock.now - oldNow;\n\t                }\n\t                clock.duringTick = false;\n\n\t                // corner case: during runJobs new timers were scheduled which could be in the range [clock.now, tickTo]\n\t                timer = firstTimerInRange(clock, tickFrom, tickTo);\n\t                if (timer) {\n\t                    try {\n\t                        clock.tick(tickTo - clock.now); // do it all again - for the remainder of the requested range\n\t                    } catch (e) {\n\t                        firstException = firstException || e;\n\t                    }\n\t                } else {\n\t                    // no timers remaining in the requested range: move the clock all the way to the end\n\t                    clock.now = tickTo;\n\n\t                    // update nanos\n\t                    nanos = nanosTotal;\n\t                }\n\t                if (firstException) {\n\t                    throw firstException;\n\t                }\n\n\t                if (isAsync) {\n\t                    resolve(clock.now);\n\t                } else {\n\t                    return clock.now;\n\t                }\n\t            }\n\n\t            nextPromiseTick =\n\t                isAsync &&\n\t                function () {\n\t                    try {\n\t                        compensationCheck();\n\t                        postTimerCall();\n\t                        doTickInner();\n\t                    } catch (e) {\n\t                        reject(e);\n\t                    }\n\t                };\n\n\t            compensationCheck = function () {\n\t                // compensate for any setSystemTime() call during timer callback\n\t                if (oldNow !== clock.now) {\n\t                    tickFrom += clock.now - oldNow;\n\t                    tickTo += clock.now - oldNow;\n\t                    previous += clock.now - oldNow;\n\t                }\n\t            };\n\n\t            postTimerCall = function () {\n\t                timer = firstTimerInRange(clock, previous, tickTo);\n\t                previous = tickFrom;\n\t            };\n\n\t            return doTickInner();\n\t        }\n\n\t        /**\n\t         * @param {string|number} tickValue number of milliseconds or a human-readable value like \"01:11:15\"\n\t         * @returns {number} will return the new `now` value\n\t         */\n\t        clock.tick = function tick(tickValue) {\n\t            return doTick(tickValue, false);\n\t        };\n\n\t        if (typeof _global.Promise !== \"undefined\") {\n\t            /**\n\t             * @param {string|number} tickValue number of milliseconds or a human-readable value like \"01:11:15\"\n\t             * @returns {Promise}\n\t             */\n\t            clock.tickAsync = function tickAsync(tickValue) {\n\t                return pauseAutoTickUntilFinished(\n\t                    new _global.Promise(function (resolve, reject) {\n\t                        originalSetTimeout(function () {\n\t                            try {\n\t                                doTick(tickValue, true, resolve, reject);\n\t                            } catch (e) {\n\t                                reject(e);\n\t                            }\n\t                        });\n\t                    }),\n\t                );\n\t            };\n\t        }\n\n\t        clock.next = function next() {\n\t            runJobs(clock);\n\t            const timer = firstTimer(clock);\n\t            if (!timer) {\n\t                return clock.now;\n\t            }\n\n\t            clock.duringTick = true;\n\t            try {\n\t                clock.now = timer.callAt;\n\t                callTimer(clock, timer);\n\t                runJobs(clock);\n\t                return clock.now;\n\t            } finally {\n\t                clock.duringTick = false;\n\t            }\n\t        };\n\n\t        if (typeof _global.Promise !== \"undefined\") {\n\t            clock.nextAsync = function nextAsync() {\n\t                return pauseAutoTickUntilFinished(\n\t                    new _global.Promise(function (resolve, reject) {\n\t                        originalSetTimeout(function () {\n\t                            try {\n\t                                const timer = firstTimer(clock);\n\t                                if (!timer) {\n\t                                    resolve(clock.now);\n\t                                    return;\n\t                                }\n\n\t                                let err;\n\t                                clock.duringTick = true;\n\t                                clock.now = timer.callAt;\n\t                                try {\n\t                                    callTimer(clock, timer);\n\t                                } catch (e) {\n\t                                    err = e;\n\t                                }\n\t                                clock.duringTick = false;\n\n\t                                originalSetTimeout(function () {\n\t                                    if (err) {\n\t                                        reject(err);\n\t                                    } else {\n\t                                        resolve(clock.now);\n\t                                    }\n\t                                });\n\t                            } catch (e) {\n\t                                reject(e);\n\t                            }\n\t                        });\n\t                    }),\n\t                );\n\t            };\n\t        }\n\n\t        clock.runAll = function runAll() {\n\t            let numTimers, i;\n\t            runJobs(clock);\n\t            for (i = 0; i < clock.loopLimit; i++) {\n\t                if (!clock.timers) {\n\t                    resetIsNearInfiniteLimit();\n\t                    return clock.now;\n\t                }\n\n\t                numTimers = Object.keys(clock.timers).length;\n\t                if (numTimers === 0) {\n\t                    resetIsNearInfiniteLimit();\n\t                    return clock.now;\n\t                }\n\n\t                clock.next();\n\t                checkIsNearInfiniteLimit(clock, i);\n\t            }\n\n\t            const excessJob = firstTimer(clock);\n\t            throw getInfiniteLoopError(clock, excessJob);\n\t        };\n\n\t        clock.runToFrame = function runToFrame() {\n\t            return clock.tick(getTimeToNextFrame());\n\t        };\n\n\t        if (typeof _global.Promise !== \"undefined\") {\n\t            clock.runAllAsync = function runAllAsync() {\n\t                return pauseAutoTickUntilFinished(\n\t                    new _global.Promise(function (resolve, reject) {\n\t                        let i = 0;\n\t                        /**\n\t                         *\n\t                         */\n\t                        function doRun() {\n\t                            originalSetTimeout(function () {\n\t                                try {\n\t                                    runJobs(clock);\n\n\t                                    let numTimers;\n\t                                    if (i < clock.loopLimit) {\n\t                                        if (!clock.timers) {\n\t                                            resetIsNearInfiniteLimit();\n\t                                            resolve(clock.now);\n\t                                            return;\n\t                                        }\n\n\t                                        numTimers = Object.keys(\n\t                                            clock.timers,\n\t                                        ).length;\n\t                                        if (numTimers === 0) {\n\t                                            resetIsNearInfiniteLimit();\n\t                                            resolve(clock.now);\n\t                                            return;\n\t                                        }\n\n\t                                        clock.next();\n\n\t                                        i++;\n\n\t                                        doRun();\n\t                                        checkIsNearInfiniteLimit(clock, i);\n\t                                        return;\n\t                                    }\n\n\t                                    const excessJob = firstTimer(clock);\n\t                                    reject(\n\t                                        getInfiniteLoopError(clock, excessJob),\n\t                                    );\n\t                                } catch (e) {\n\t                                    reject(e);\n\t                                }\n\t                            });\n\t                        }\n\t                        doRun();\n\t                    }),\n\t                );\n\t            };\n\t        }\n\n\t        clock.runToLast = function runToLast() {\n\t            const timer = lastTimer(clock);\n\t            if (!timer) {\n\t                runJobs(clock);\n\t                return clock.now;\n\t            }\n\n\t            return clock.tick(timer.callAt - clock.now);\n\t        };\n\n\t        if (typeof _global.Promise !== \"undefined\") {\n\t            clock.runToLastAsync = function runToLastAsync() {\n\t                return pauseAutoTickUntilFinished(\n\t                    new _global.Promise(function (resolve, reject) {\n\t                        originalSetTimeout(function () {\n\t                            try {\n\t                                const timer = lastTimer(clock);\n\t                                if (!timer) {\n\t                                    runJobs(clock);\n\t                                    resolve(clock.now);\n\t                                }\n\n\t                                resolve(\n\t                                    clock.tickAsync(timer.callAt - clock.now),\n\t                                );\n\t                            } catch (e) {\n\t                                reject(e);\n\t                            }\n\t                        });\n\t                    }),\n\t                );\n\t            };\n\t        }\n\n\t        clock.reset = function reset() {\n\t            nanos = 0;\n\t            clock.timers = {};\n\t            clock.jobs = [];\n\t            clock.now = start;\n\t        };\n\n\t        clock.setSystemTime = function setSystemTime(systemTime) {\n\t            // determine time difference\n\t            const newNow = getEpoch(systemTime);\n\t            const difference = newNow - clock.now;\n\t            let id, timer;\n\n\t            adjustedSystemTime[0] = adjustedSystemTime[0] + difference;\n\t            adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;\n\t            // update 'system clock'\n\t            clock.now = newNow;\n\t            nanos = 0;\n\n\t            // update timers and intervals to keep them stable\n\t            for (id in clock.timers) {\n\t                if (clock.timers.hasOwnProperty(id)) {\n\t                    timer = clock.timers[id];\n\t                    timer.createdAt += difference;\n\t                    timer.callAt += difference;\n\t                }\n\t            }\n\t        };\n\n\t        /**\n\t         * @param {string|number} tickValue number of milliseconds or a human-readable value like \"01:11:15\"\n\t         * @returns {number} will return the new `now` value\n\t         */\n\t        clock.jump = function jump(tickValue) {\n\t            const msFloat =\n\t                typeof tickValue === \"number\"\n\t                    ? tickValue\n\t                    : parseTime(tickValue);\n\t            const ms = Math.floor(msFloat);\n\n\t            for (const timer of Object.values(clock.timers)) {\n\t                if (clock.now + ms > timer.callAt) {\n\t                    timer.callAt = clock.now + ms;\n\t                }\n\t            }\n\t            clock.tick(ms);\n\t        };\n\n\t        if (isPresent.performance) {\n\t            clock.performance = Object.create(null);\n\t            clock.performance.now = fakePerformanceNow;\n\t        }\n\n\t        if (isPresent.hrtime) {\n\t            clock.hrtime = hrtime;\n\t        }\n\n\t        return clock;\n\t    }\n\n\t    function createIntervalTick(clock, delta) {\n\t        const intervalTick = doIntervalTick.bind(null, clock, delta);\n\t        const intervalId = originalSetInterval(intervalTick, delta);\n\t        clock.attachedInterval = intervalId;\n\t    }\n\n\t    /* eslint-disable complexity */\n\n\t    /**\n\t     * @param {Config=} [config] Optional config\n\t     * @returns {Clock}\n\t     */\n\t    function install(config) {\n\t        if (\n\t            arguments.length > 1 ||\n\t            config instanceof Date ||\n\t            Array.isArray(config) ||\n\t            typeof config === \"number\"\n\t        ) {\n\t            throw new TypeError(\n\t                `FakeTimers.install called with ${String(\n\t                    config,\n\t                )} install requires an object parameter`,\n\t            );\n\t        }\n\n\t        if (_global.Date.isFake === true) {\n\t            // Timers are already faked; this is a problem.\n\t            // Make the user reset timers before continuing.\n\t            throw new TypeError(\n\t                \"Can't install fake timers twice on the same global object.\",\n\t            );\n\t        }\n\n\t        // eslint-disable-next-line no-param-reassign\n\t        config = typeof config !== \"undefined\" ? config : {};\n\t        config.shouldAdvanceTime = config.shouldAdvanceTime || false;\n\t        config.advanceTimeDelta = config.advanceTimeDelta || 20;\n\t        config.shouldClearNativeTimers =\n\t            config.shouldClearNativeTimers || false;\n\n\t        if (config.target) {\n\t            throw new TypeError(\n\t                \"config.target is no longer supported. Use `withGlobal(target)` instead.\",\n\t            );\n\t        }\n\n\t        /**\n\t         * @param {string} timer/object the name of the thing that is not present\n\t         * @param timer\n\t         */\n\t        function handleMissingTimer(timer) {\n\t            if (config.ignoreMissingTimers) {\n\t                return;\n\t            }\n\n\t            throw new ReferenceError(\n\t                `non-existent timers and/or objects cannot be faked: '${timer}'`,\n\t            );\n\t        }\n\n\t        let i, l;\n\t        const clock = createClock(config.now, config.loopLimit);\n\t        clock.shouldClearNativeTimers = config.shouldClearNativeTimers;\n\n\t        clock.uninstall = function () {\n\t            return uninstall(clock);\n\t        };\n\n\t        clock.abortListenerMap = new Map();\n\n\t        clock.methods = config.toFake || [];\n\n\t        if (clock.methods.length === 0) {\n\t            clock.methods = Object.keys(timers);\n\t        }\n\n\t        if (config.shouldAdvanceTime === true) {\n\t            clock.setTickMode({\n\t                mode: \"interval\",\n\t                delta: config.advanceTimeDelta,\n\t            });\n\t        }\n\n\t        if (clock.methods.includes(\"performance\")) {\n\t            const proto = (() => {\n\t                if (hasPerformanceConstructorPrototype) {\n\t                    return _global.performance.constructor.prototype;\n\t                }\n\t                if (hasPerformancePrototype) {\n\t                    return _global.Performance.prototype;\n\t                }\n\t            })();\n\t            if (proto) {\n\t                Object.getOwnPropertyNames(proto).forEach(function (name) {\n\t                    if (name !== \"now\") {\n\t                        clock.performance[name] =\n\t                            name.indexOf(\"getEntries\") === 0\n\t                                ? NOOP_ARRAY\n\t                                : NOOP;\n\t                    }\n\t                });\n\t                // ensure `mark` returns a value that is valid\n\t                clock.performance.mark = (name) =>\n\t                    new FakePerformanceEntry(name, \"mark\", 0, 0);\n\t                clock.performance.measure = (name) =>\n\t                    new FakePerformanceEntry(name, \"measure\", 0, 100);\n\t                // `timeOrigin` should return the time of when the Window session started\n\t                // (or the Worker was installed)\n\t                clock.performance.timeOrigin = getEpoch(config.now);\n\t            } else if ((config.toFake || []).includes(\"performance\")) {\n\t                return handleMissingTimer(\"performance\");\n\t            }\n\t        }\n\t        if (_global === globalObject && timersModule) {\n\t            clock.timersModuleMethods = [];\n\t        }\n\t        if (_global === globalObject && timersPromisesModule) {\n\t            clock.timersPromisesModuleMethods = [];\n\t        }\n\t        for (i = 0, l = clock.methods.length; i < l; i++) {\n\t            const nameOfMethodToReplace = clock.methods[i];\n\n\t            if (!isPresent[nameOfMethodToReplace]) {\n\t                handleMissingTimer(nameOfMethodToReplace);\n\t                // eslint-disable-next-line\n\t                continue;\n\t            }\n\n\t            if (nameOfMethodToReplace === \"hrtime\") {\n\t                if (\n\t                    _global.process &&\n\t                    typeof _global.process.hrtime === \"function\"\n\t                ) {\n\t                    hijackMethod(_global.process, nameOfMethodToReplace, clock);\n\t                }\n\t            } else if (nameOfMethodToReplace === \"nextTick\") {\n\t                if (\n\t                    _global.process &&\n\t                    typeof _global.process.nextTick === \"function\"\n\t                ) {\n\t                    hijackMethod(_global.process, nameOfMethodToReplace, clock);\n\t                }\n\t            } else {\n\t                hijackMethod(_global, nameOfMethodToReplace, clock);\n\t            }\n\t            if (\n\t                clock.timersModuleMethods !== undefined &&\n\t                timersModule[nameOfMethodToReplace]\n\t            ) {\n\t                const original = timersModule[nameOfMethodToReplace];\n\t                clock.timersModuleMethods.push({\n\t                    methodName: nameOfMethodToReplace,\n\t                    original: original,\n\t                });\n\t                timersModule[nameOfMethodToReplace] =\n\t                    _global[nameOfMethodToReplace];\n\t            }\n\t            if (clock.timersPromisesModuleMethods !== undefined) {\n\t                if (nameOfMethodToReplace === \"setTimeout\") {\n\t                    clock.timersPromisesModuleMethods.push({\n\t                        methodName: \"setTimeout\",\n\t                        original: timersPromisesModule.setTimeout,\n\t                    });\n\n\t                    timersPromisesModule.setTimeout = (\n\t                        delay,\n\t                        value,\n\t                        options = {},\n\t                    ) =>\n\t                        new Promise((resolve, reject) => {\n\t                            const abort = () => {\n\t                                options.signal.removeEventListener(\n\t                                    \"abort\",\n\t                                    abort,\n\t                                );\n\t                                clock.abortListenerMap.delete(abort);\n\n\t                                // This is safe, there is no code path that leads to this function\n\t                                // being invoked before handle has been assigned.\n\t                                // eslint-disable-next-line no-use-before-define\n\t                                clock.clearTimeout(handle);\n\t                                reject(options.signal.reason);\n\t                            };\n\n\t                            const handle = clock.setTimeout(() => {\n\t                                if (options.signal) {\n\t                                    options.signal.removeEventListener(\n\t                                        \"abort\",\n\t                                        abort,\n\t                                    );\n\t                                    clock.abortListenerMap.delete(abort);\n\t                                }\n\n\t                                resolve(value);\n\t                            }, delay);\n\n\t                            if (options.signal) {\n\t                                if (options.signal.aborted) {\n\t                                    abort();\n\t                                } else {\n\t                                    options.signal.addEventListener(\n\t                                        \"abort\",\n\t                                        abort,\n\t                                    );\n\t                                    clock.abortListenerMap.set(\n\t                                        abort,\n\t                                        options.signal,\n\t                                    );\n\t                                }\n\t                            }\n\t                        });\n\t                } else if (nameOfMethodToReplace === \"setImmediate\") {\n\t                    clock.timersPromisesModuleMethods.push({\n\t                        methodName: \"setImmediate\",\n\t                        original: timersPromisesModule.setImmediate,\n\t                    });\n\n\t                    timersPromisesModule.setImmediate = (value, options = {}) =>\n\t                        new Promise((resolve, reject) => {\n\t                            const abort = () => {\n\t                                options.signal.removeEventListener(\n\t                                    \"abort\",\n\t                                    abort,\n\t                                );\n\t                                clock.abortListenerMap.delete(abort);\n\n\t                                // This is safe, there is no code path that leads to this function\n\t                                // being invoked before handle has been assigned.\n\t                                // eslint-disable-next-line no-use-before-define\n\t                                clock.clearImmediate(handle);\n\t                                reject(options.signal.reason);\n\t                            };\n\n\t                            const handle = clock.setImmediate(() => {\n\t                                if (options.signal) {\n\t                                    options.signal.removeEventListener(\n\t                                        \"abort\",\n\t                                        abort,\n\t                                    );\n\t                                    clock.abortListenerMap.delete(abort);\n\t                                }\n\n\t                                resolve(value);\n\t                            });\n\n\t                            if (options.signal) {\n\t                                if (options.signal.aborted) {\n\t                                    abort();\n\t                                } else {\n\t                                    options.signal.addEventListener(\n\t                                        \"abort\",\n\t                                        abort,\n\t                                    );\n\t                                    clock.abortListenerMap.set(\n\t                                        abort,\n\t                                        options.signal,\n\t                                    );\n\t                                }\n\t                            }\n\t                        });\n\t                } else if (nameOfMethodToReplace === \"setInterval\") {\n\t                    clock.timersPromisesModuleMethods.push({\n\t                        methodName: \"setInterval\",\n\t                        original: timersPromisesModule.setInterval,\n\t                    });\n\n\t                    timersPromisesModule.setInterval = (\n\t                        delay,\n\t                        value,\n\t                        options = {},\n\t                    ) => ({\n\t                        [Symbol.asyncIterator]: () => {\n\t                            const createResolvable = () => {\n\t                                let resolve, reject;\n\t                                const promise = new Promise((res, rej) => {\n\t                                    resolve = res;\n\t                                    reject = rej;\n\t                                });\n\t                                promise.resolve = resolve;\n\t                                promise.reject = reject;\n\t                                return promise;\n\t                            };\n\n\t                            let done = false;\n\t                            let hasThrown = false;\n\t                            let returnCall;\n\t                            let nextAvailable = 0;\n\t                            const nextQueue = [];\n\n\t                            const handle = clock.setInterval(() => {\n\t                                if (nextQueue.length > 0) {\n\t                                    nextQueue.shift().resolve();\n\t                                } else {\n\t                                    nextAvailable++;\n\t                                }\n\t                            }, delay);\n\n\t                            const abort = () => {\n\t                                options.signal.removeEventListener(\n\t                                    \"abort\",\n\t                                    abort,\n\t                                );\n\t                                clock.abortListenerMap.delete(abort);\n\n\t                                clock.clearInterval(handle);\n\t                                done = true;\n\t                                for (const resolvable of nextQueue) {\n\t                                    resolvable.resolve();\n\t                                }\n\t                            };\n\n\t                            if (options.signal) {\n\t                                if (options.signal.aborted) {\n\t                                    done = true;\n\t                                } else {\n\t                                    options.signal.addEventListener(\n\t                                        \"abort\",\n\t                                        abort,\n\t                                    );\n\t                                    clock.abortListenerMap.set(\n\t                                        abort,\n\t                                        options.signal,\n\t                                    );\n\t                                }\n\t                            }\n\n\t                            return {\n\t                                next: async () => {\n\t                                    if (options.signal?.aborted && !hasThrown) {\n\t                                        hasThrown = true;\n\t                                        throw options.signal.reason;\n\t                                    }\n\n\t                                    if (done) {\n\t                                        return { done: true, value: undefined };\n\t                                    }\n\n\t                                    if (nextAvailable > 0) {\n\t                                        nextAvailable--;\n\t                                        return { done: false, value: value };\n\t                                    }\n\n\t                                    const resolvable = createResolvable();\n\t                                    nextQueue.push(resolvable);\n\n\t                                    await resolvable;\n\n\t                                    if (returnCall && nextQueue.length === 0) {\n\t                                        returnCall.resolve();\n\t                                    }\n\n\t                                    if (options.signal?.aborted && !hasThrown) {\n\t                                        hasThrown = true;\n\t                                        throw options.signal.reason;\n\t                                    }\n\n\t                                    if (done) {\n\t                                        return { done: true, value: undefined };\n\t                                    }\n\n\t                                    return { done: false, value: value };\n\t                                },\n\t                                return: async () => {\n\t                                    if (done) {\n\t                                        return { done: true, value: undefined };\n\t                                    }\n\n\t                                    if (nextQueue.length > 0) {\n\t                                        returnCall = createResolvable();\n\t                                        await returnCall;\n\t                                    }\n\n\t                                    clock.clearInterval(handle);\n\t                                    done = true;\n\n\t                                    if (options.signal) {\n\t                                        options.signal.removeEventListener(\n\t                                            \"abort\",\n\t                                            abort,\n\t                                        );\n\t                                        clock.abortListenerMap.delete(abort);\n\t                                    }\n\n\t                                    return { done: true, value: undefined };\n\t                                },\n\t                            };\n\t                        },\n\t                    });\n\t                }\n\t            }\n\t        }\n\n\t        return clock;\n\t    }\n\n\t    /* eslint-enable complexity */\n\n\t    return {\n\t        timers: timers,\n\t        createClock: createClock,\n\t        install: install,\n\t        withGlobal: withGlobal,\n\t    };\n\t}\n\n\t/**\n\t * @typedef {object} FakeTimers\n\t * @property {Timers} timers\n\t * @property {createClock} createClock\n\t * @property {Function} install\n\t * @property {withGlobal} withGlobal\n\t */\n\n\t/* eslint-enable complexity */\n\n\t/** @type {FakeTimers} */\n\tconst defaultImplementation = withGlobal(globalObject);\n\n\tfakeTimersSrc.timers = defaultImplementation.timers;\n\tfakeTimersSrc.createClock = defaultImplementation.createClock;\n\tfakeTimersSrc.install = defaultImplementation.install;\n\tfakeTimersSrc.withGlobal = withGlobal;\n\treturn fakeTimersSrc;\n}\n\nvar fakeTimersSrcExports = requireFakeTimersSrc();\n\nclass FakeTimers {\n\t_global;\n\t_clock;\n\t// | _fakingTime | _fakingDate |\n\t// +-------------+-------------+\n\t// | false       | falsy       | initial\n\t// | false       | truthy      | vi.setSystemTime called first (for mocking only Date without fake timers)\n\t// | true        | falsy       | vi.useFakeTimers called first\n\t// | true        | truthy      | unreachable\n\t_fakingTime;\n\t_fakingDate;\n\t_fakeTimers;\n\t_userConfig;\n\t_now = RealDate.now;\n\tconstructor({ global, config }) {\n\t\tthis._userConfig = config;\n\t\tthis._fakingDate = null;\n\t\tthis._fakingTime = false;\n\t\tthis._fakeTimers = fakeTimersSrcExports.withGlobal(global);\n\t\tthis._global = global;\n\t}\n\tclearAllTimers() {\n\t\tif (this._fakingTime) this._clock.reset();\n\t}\n\tdispose() {\n\t\tthis.useRealTimers();\n\t}\n\trunAllTimers() {\n\t\tif (this._checkFakeTimers()) this._clock.runAll();\n\t}\n\tasync runAllTimersAsync() {\n\t\tif (this._checkFakeTimers()) await this._clock.runAllAsync();\n\t}\n\trunOnlyPendingTimers() {\n\t\tif (this._checkFakeTimers()) this._clock.runToLast();\n\t}\n\tasync runOnlyPendingTimersAsync() {\n\t\tif (this._checkFakeTimers()) await this._clock.runToLastAsync();\n\t}\n\tadvanceTimersToNextTimer(steps = 1) {\n\t\tif (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {\n\t\t\tthis._clock.next();\n\t\t\t// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250\n\t\t\tthis._clock.tick(0);\n\t\t\tif (this._clock.countTimers() === 0) break;\n\t\t}\n\t}\n\tasync advanceTimersToNextTimerAsync(steps = 1) {\n\t\tif (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {\n\t\t\tawait this._clock.nextAsync();\n\t\t\t// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250\n\t\t\tthis._clock.tick(0);\n\t\t\tif (this._clock.countTimers() === 0) break;\n\t\t}\n\t}\n\tadvanceTimersByTime(msToRun) {\n\t\tif (this._checkFakeTimers()) this._clock.tick(msToRun);\n\t}\n\tasync advanceTimersByTimeAsync(msToRun) {\n\t\tif (this._checkFakeTimers()) await this._clock.tickAsync(msToRun);\n\t}\n\tadvanceTimersToNextFrame() {\n\t\tif (this._checkFakeTimers()) this._clock.runToFrame();\n\t}\n\trunAllTicks() {\n\t\tif (this._checkFakeTimers()) this._clock.runMicrotasks();\n\t}\n\tuseRealTimers() {\n\t\tif (this._fakingDate) {\n\t\t\tresetDate();\n\t\t\tthis._fakingDate = null;\n\t\t}\n\t\tif (this._fakingTime) {\n\t\t\tthis._clock.uninstall();\n\t\t\tthis._fakingTime = false;\n\t\t}\n\t}\n\tuseFakeTimers() {\n\t\tconst fakeDate = this._fakingDate || Date.now();\n\t\tif (this._fakingDate) {\n\t\t\tresetDate();\n\t\t\tthis._fakingDate = null;\n\t\t}\n\t\tif (this._fakingTime) this._clock.uninstall();\n\t\tconst toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== \"nextTick\" && timer !== \"queueMicrotask\");\n\t\tif (this._userConfig?.toFake?.includes(\"nextTick\") && isChildProcess()) throw new Error(\"process.nextTick cannot be mocked inside child_process\");\n\t\tthis._clock = this._fakeTimers.install({\n\t\t\tnow: fakeDate,\n\t\t\t...this._userConfig,\n\t\t\ttoFake: this._userConfig?.toFake || toFake,\n\t\t\tignoreMissingTimers: true\n\t\t});\n\t\tthis._fakingTime = true;\n\t}\n\treset() {\n\t\tif (this._checkFakeTimers()) {\n\t\t\tconst { now } = this._clock;\n\t\t\tthis._clock.reset();\n\t\t\tthis._clock.setSystemTime(now);\n\t\t}\n\t}\n\tsetSystemTime(now) {\n\t\tconst date = typeof now === \"undefined\" || now instanceof Date ? now : new Date(now);\n\t\tif (this._fakingTime) this._clock.setSystemTime(date);\n\t\telse {\n\t\t\tthis._fakingDate = date ?? new Date(this.getRealSystemTime());\n\t\t\tmockDate(this._fakingDate);\n\t\t}\n\t}\n\tgetMockedSystemTime() {\n\t\treturn this._fakingTime ? new Date(this._clock.now) : this._fakingDate;\n\t}\n\tgetRealSystemTime() {\n\t\treturn this._now();\n\t}\n\tgetTimerCount() {\n\t\tif (this._checkFakeTimers()) return this._clock.countTimers();\n\t\treturn 0;\n\t}\n\tsetTimerTickMode(mode, interval) {\n\t\tif (this._checkFakeTimers()) if (mode === \"manual\") this._clock.setTickMode({ mode: \"manual\" });\n\t\telse if (mode === \"nextTimerAsync\") this._clock.setTickMode({ mode: \"nextAsync\" });\n\t\telse if (mode === \"interval\") this._clock.setTickMode({\n\t\t\tmode: \"interval\",\n\t\t\tdelta: interval\n\t\t});\n\t\telse throw new Error(`Invalid tick mode: ${mode}`);\n\t}\n\tconfigure(config) {\n\t\tthis._userConfig = config;\n\t}\n\tisFakeTimers() {\n\t\treturn this._fakingTime;\n\t}\n\t_checkFakeTimers() {\n\t\tif (!this._fakingTime) throw new Error(\"A function to advance timers was called but the timers APIs are not mocked. Call `vi.useFakeTimers()` in the test file first.\");\n\t\treturn this._fakingTime;\n\t}\n}\n\nfunction copyStackTrace$1(target, source) {\n\tif (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);\n\treturn target;\n}\nfunction waitFor(callback, options = {}) {\n\tconst { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();\n\tconst { interval = 50, timeout = 1e3 } = typeof options === \"number\" ? { timeout: options } : options;\n\tconst STACK_TRACE_ERROR = /* @__PURE__ */ new Error(\"STACK_TRACE_ERROR\");\n\treturn new Promise((resolve, reject) => {\n\t\tlet lastError;\n\t\tlet promiseStatus = \"idle\";\n\t\tlet timeoutId;\n\t\tlet intervalId;\n\t\tconst onResolve = (result) => {\n\t\t\tif (timeoutId) clearTimeout(timeoutId);\n\t\t\tif (intervalId) clearInterval(intervalId);\n\t\t\tresolve(result);\n\t\t};\n\t\tconst handleTimeout = () => {\n\t\t\tif (intervalId) clearInterval(intervalId);\n\t\t\tlet error = lastError;\n\t\t\tif (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error(\"Timed out in waitFor!\"), STACK_TRACE_ERROR);\n\t\t\treject(error);\n\t\t};\n\t\tconst checkCallback = () => {\n\t\t\tif (vi.isFakeTimers()) vi.advanceTimersByTime(interval);\n\t\t\tif (promiseStatus === \"pending\") return;\n\t\t\ttry {\n\t\t\t\tconst result = callback();\n\t\t\t\tif (result !== null && typeof result === \"object\" && typeof result.then === \"function\") {\n\t\t\t\t\tconst thenable = result;\n\t\t\t\t\tpromiseStatus = \"pending\";\n\t\t\t\t\tthenable.then((resolvedValue) => {\n\t\t\t\t\t\tpromiseStatus = \"resolved\";\n\t\t\t\t\t\tonResolve(resolvedValue);\n\t\t\t\t\t}, (rejectedValue) => {\n\t\t\t\t\t\tpromiseStatus = \"rejected\";\n\t\t\t\t\t\tlastError = rejectedValue;\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tonResolve(result);\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tlastError = error;\n\t\t\t}\n\t\t};\n\t\tif (checkCallback() === true) return;\n\t\ttimeoutId = setTimeout(handleTimeout, timeout);\n\t\tintervalId = setInterval(checkCallback, interval);\n\t});\n}\nfunction waitUntil(callback, options = {}) {\n\tconst { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();\n\tconst { interval = 50, timeout = 1e3 } = typeof options === \"number\" ? { timeout: options } : options;\n\tconst STACK_TRACE_ERROR = /* @__PURE__ */ new Error(\"STACK_TRACE_ERROR\");\n\treturn new Promise((resolve, reject) => {\n\t\tlet promiseStatus = \"idle\";\n\t\tlet timeoutId;\n\t\tlet intervalId;\n\t\tconst onReject = (error) => {\n\t\t\tif (intervalId) clearInterval(intervalId);\n\t\t\tif (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error(\"Timed out in waitUntil!\"), STACK_TRACE_ERROR);\n\t\t\treject(error);\n\t\t};\n\t\tconst onResolve = (result) => {\n\t\t\tif (!result) return;\n\t\t\tif (timeoutId) clearTimeout(timeoutId);\n\t\t\tif (intervalId) clearInterval(intervalId);\n\t\t\tresolve(result);\n\t\t\treturn true;\n\t\t};\n\t\tconst checkCallback = () => {\n\t\t\tif (vi.isFakeTimers()) vi.advanceTimersByTime(interval);\n\t\t\tif (promiseStatus === \"pending\") return;\n\t\t\ttry {\n\t\t\t\tconst result = callback();\n\t\t\t\tif (result !== null && typeof result === \"object\" && typeof result.then === \"function\") {\n\t\t\t\t\tconst thenable = result;\n\t\t\t\t\tpromiseStatus = \"pending\";\n\t\t\t\t\tthenable.then((resolvedValue) => {\n\t\t\t\t\t\tpromiseStatus = \"resolved\";\n\t\t\t\t\t\tonResolve(resolvedValue);\n\t\t\t\t\t}, (rejectedValue) => {\n\t\t\t\t\t\tpromiseStatus = \"rejected\";\n\t\t\t\t\t\tonReject(rejectedValue);\n\t\t\t\t\t});\n\t\t\t\t} else return onResolve(result);\n\t\t\t} catch (error) {\n\t\t\t\tonReject(error);\n\t\t\t}\n\t\t};\n\t\tif (checkCallback() === true) return;\n\t\ttimeoutId = setTimeout(onReject, timeout);\n\t\tintervalId = setInterval(checkCallback, interval);\n\t});\n}\n\nfunction createVitest() {\n\tlet _config = null;\n\tconst state = () => getWorkerState();\n\tlet _timers;\n\tconst timers = () => _timers ||= new FakeTimers({\n\t\tglobal: globalThis,\n\t\tconfig: state().config.fakeTimers\n\t});\n\tconst _stubsGlobal = /* @__PURE__ */ new Map();\n\tconst _stubsEnv = /* @__PURE__ */ new Map();\n\tconst _envBooleans = [\n\t\t\"PROD\",\n\t\t\"DEV\",\n\t\t\"SSR\"\n\t];\n\tconst utils = {\n\t\tuseFakeTimers(config) {\n\t\t\tif (isChildProcess()) {\n\t\t\t\tif (config?.toFake?.includes(\"nextTick\") || state().config?.fakeTimers?.toFake?.includes(\"nextTick\")) throw new Error(\"vi.useFakeTimers({ toFake: [\\\"nextTick\\\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.\");\n\t\t\t}\n\t\t\tif (config) timers().configure({\n\t\t\t\t...state().config.fakeTimers,\n\t\t\t\t...config\n\t\t\t});\n\t\t\telse timers().configure(state().config.fakeTimers);\n\t\t\ttimers().useFakeTimers();\n\t\t\treturn utils;\n\t\t},\n\t\tisFakeTimers() {\n\t\t\treturn timers().isFakeTimers();\n\t\t},\n\t\tuseRealTimers() {\n\t\t\ttimers().useRealTimers();\n\t\t\treturn utils;\n\t\t},\n\t\trunOnlyPendingTimers() {\n\t\t\ttimers().runOnlyPendingTimers();\n\t\t\treturn utils;\n\t\t},\n\t\tasync runOnlyPendingTimersAsync() {\n\t\t\tawait timers().runOnlyPendingTimersAsync();\n\t\t\treturn utils;\n\t\t},\n\t\trunAllTimers() {\n\t\t\ttimers().runAllTimers();\n\t\t\treturn utils;\n\t\t},\n\t\tasync runAllTimersAsync() {\n\t\t\tawait timers().runAllTimersAsync();\n\t\t\treturn utils;\n\t\t},\n\t\trunAllTicks() {\n\t\t\ttimers().runAllTicks();\n\t\t\treturn utils;\n\t\t},\n\t\tadvanceTimersByTime(ms) {\n\t\t\ttimers().advanceTimersByTime(ms);\n\t\t\treturn utils;\n\t\t},\n\t\tasync advanceTimersByTimeAsync(ms) {\n\t\t\tawait timers().advanceTimersByTimeAsync(ms);\n\t\t\treturn utils;\n\t\t},\n\t\tadvanceTimersToNextTimer() {\n\t\t\ttimers().advanceTimersToNextTimer();\n\t\t\treturn utils;\n\t\t},\n\t\tasync advanceTimersToNextTimerAsync() {\n\t\t\tawait timers().advanceTimersToNextTimerAsync();\n\t\t\treturn utils;\n\t\t},\n\t\tadvanceTimersToNextFrame() {\n\t\t\ttimers().advanceTimersToNextFrame();\n\t\t\treturn utils;\n\t\t},\n\t\tgetTimerCount() {\n\t\t\treturn timers().getTimerCount();\n\t\t},\n\t\tsetSystemTime(time) {\n\t\t\ttimers().setSystemTime(time);\n\t\t\treturn utils;\n\t\t},\n\t\tgetMockedSystemTime() {\n\t\t\treturn timers().getMockedSystemTime();\n\t\t},\n\t\tgetRealSystemTime() {\n\t\t\treturn timers().getRealSystemTime();\n\t\t},\n\t\tclearAllTimers() {\n\t\t\ttimers().clearAllTimers();\n\t\t\treturn utils;\n\t\t},\n\t\tsetTimerTickMode(mode, interval) {\n\t\t\ttimers().setTimerTickMode(mode, interval);\n\t\t\treturn utils;\n\t\t},\n\t\tspyOn,\n\t\tfn,\n\t\twaitFor,\n\t\twaitUntil,\n\t\tdefineHelper: (fn) => {\n\t\t\treturn function __VITEST_HELPER__(...args) {\n\t\t\t\tconst result = fn.apply(this, args);\n\t\t\t\tif (result && typeof result === \"object\" && typeof result.then === \"function\") return (async function __VITEST_HELPER__() {\n\t\t\t\t\treturn await result;\n\t\t\t\t})();\n\t\t\t\treturn result;\n\t\t\t};\n\t\t},\n\t\thoisted(factory) {\n\t\t\tassertTypes(factory, \"\\\"vi.hoisted\\\" factory\", [\"function\"]);\n\t\t\treturn factory();\n\t\t},\n\t\tmock(path, factory) {\n\t\t\tif (typeof path !== \"string\") throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);\n\t\t\tconst importer = getImporter(\"mock\");\n\t\t\t_mocker().queueMock(path, importer, typeof factory === \"function\" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);\n\t\t},\n\t\tunmock(path) {\n\t\t\tif (typeof path !== \"string\") throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);\n\t\t\t_mocker().queueUnmock(path, getImporter(\"unmock\"));\n\t\t},\n\t\tdoMock(path, factory) {\n\t\t\tif (typeof path !== \"string\") throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);\n\t\t\tconst importer = getImporter(\"doMock\");\n\t\t\t_mocker().queueMock(path, importer, typeof factory === \"function\" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);\n\t\t\tconst rv = {};\n\t\t\tif (Symbol.dispose) rv[Symbol.dispose] = () => {\n\t\t\t\t_mocker().queueUnmock(path, importer);\n\t\t\t};\n\t\t\treturn rv;\n\t\t},\n\t\tdoUnmock(path) {\n\t\t\tif (typeof path !== \"string\") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);\n\t\t\tconst importer = getImporter(\"doUnmock\");\n\t\t\t_mocker().queueUnmock(path, importer);\n\t\t},\n\t\tasync importActual(path) {\n\t\t\tconst importer = getImporter(\"importActual\");\n\t\t\treturn _mocker().importActual(path, importer, _mocker().getMockContext().callstack);\n\t\t},\n\t\tasync importMock(path) {\n\t\t\tconst importer = getImporter(\"importMock\");\n\t\t\treturn _mocker().importMock(path, importer);\n\t\t},\n\t\tmockObject(value, options) {\n\t\t\treturn _mocker().mockObject({ value }, void 0, options?.spy ? \"autospy\" : \"automock\").value;\n\t\t},\n\t\tmocked(item, _options = {}) {\n\t\t\treturn item;\n\t\t},\n\t\tisMockFunction(fn) {\n\t\t\treturn isMockFunction(fn);\n\t\t},\n\t\tclearAllMocks() {\n\t\t\tclearAllMocks();\n\t\t\treturn utils;\n\t\t},\n\t\tresetAllMocks() {\n\t\t\tresetAllMocks();\n\t\t\treturn utils;\n\t\t},\n\t\trestoreAllMocks() {\n\t\t\trestoreAllMocks();\n\t\t\treturn utils;\n\t\t},\n\t\tstubGlobal(name, value) {\n\t\t\tif (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));\n\t\t\tObject.defineProperty(globalThis, name, {\n\t\t\t\tvalue,\n\t\t\t\twritable: true,\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: true\n\t\t\t});\n\t\t\treturn utils;\n\t\t},\n\t\tstubEnv(name, value) {\n\t\t\tconst env = state().metaEnv;\n\t\t\tif (!_stubsEnv.has(name)) _stubsEnv.set(name, env[name]);\n\t\t\tif (_envBooleans.includes(name)) env[name] = value ? \"1\" : \"\";\n\t\t\telse if (value === void 0) delete env[name];\n\t\t\telse env[name] = String(value);\n\t\t\treturn utils;\n\t\t},\n\t\tunstubAllGlobals() {\n\t\t\t_stubsGlobal.forEach((original, name) => {\n\t\t\t\tif (!original) Reflect.deleteProperty(globalThis, name);\n\t\t\t\telse Object.defineProperty(globalThis, name, original);\n\t\t\t});\n\t\t\t_stubsGlobal.clear();\n\t\t\treturn utils;\n\t\t},\n\t\tunstubAllEnvs() {\n\t\t\tconst env = state().metaEnv;\n\t\t\t_stubsEnv.forEach((original, name) => {\n\t\t\t\tif (original === void 0) delete env[name];\n\t\t\t\telse env[name] = original;\n\t\t\t});\n\t\t\t_stubsEnv.clear();\n\t\t\treturn utils;\n\t\t},\n\t\tresetModules() {\n\t\t\tresetModules(state().evaluatedModules);\n\t\t\treturn utils;\n\t\t},\n\t\tasync dynamicImportSettled() {\n\t\t\treturn waitForImportsToResolve();\n\t\t},\n\t\tsetConfig(config) {\n\t\t\tif (!_config) _config = { ...state().config };\n\t\t\tObject.assign(state().config, config);\n\t\t},\n\t\tresetConfig() {\n\t\t\tif (_config) Object.assign(state().config, _config);\n\t\t}\n\t};\n\treturn utils;\n}\nconst vitest = createVitest();\nconst vi = vitest;\nfunction _mocker() {\n\t// @ts-expect-error injected by vite-nide\n\treturn typeof __vitest_mocker__ !== \"undefined\" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {\n\t\tthrow new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);\n\t} });\n}\nfunction getImporter(name) {\n\tconst stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split(\"\\n\");\n\treturn parseSingleStack(stackArray[stackArray.findLastIndex((stack) => {\n\t\treturn stack.includes(` at Object.${name}`) || stack.includes(`${name}@`) || stack.includes(` at ${name} (`);\n\t}) + 1])?.file || \"\";\n}\n\n// these matchers are not supported because they don't make sense with poll\nconst unsupported = [\n\t\"matchSnapshot\",\n\t\"toMatchSnapshot\",\n\t\"toMatchInlineSnapshot\",\n\t\"toThrowErrorMatchingSnapshot\",\n\t\"toThrowErrorMatchingInlineSnapshot\",\n\t\"throws\",\n\t\"Throw\",\n\t\"throw\",\n\t\"toThrow\",\n\t\"toThrowError\"\n];\n/**\n* Attaches a `cause` property to the error if missing, copies the stack trace from the source, and throws.\n*\n* @param error - The error to throw\n* @param source - Error to copy the stack trace from\n*\n* @throws Always throws the provided error with an amended stack trace\n*/\nfunction throwWithCause(error, source) {\n\tif (error.cause == null) error.cause = /* @__PURE__ */ new Error(\"Matcher did not succeed in time.\");\n\tthrow copyStackTrace(error, source);\n}\nfunction createExpectPoll(expect) {\n\treturn function poll(fn, options = {}) {\n\t\tconst defaults = getWorkerState().config.expect?.poll ?? {};\n\t\tconst { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;\n\t\t// @ts-expect-error private poll access\n\t\tconst assertion = expect(null, message).withContext({ poll: true });\n\t\tfn = fn.bind(assertion);\n\t\t// injected so that domain snapshot can take over poll implementation.\n\t\tchai.util.flag(assertion, \"_poll.fn\", fn);\n\t\tchai.util.flag(assertion, \"_poll.timeout\", timeout);\n\t\tchai.util.flag(assertion, \"_poll.interval\", interval);\n\t\tconst test = chai.util.flag(assertion, \"vitest-test\");\n\t\tif (!test) throw new Error(\"expect.poll() must be called inside a test\");\n\t\tconst proxy = new Proxy(assertion, { get(target, key, receiver) {\n\t\t\tconst assertionFunction = Reflect.get(target, key, receiver);\n\t\t\tif (typeof assertionFunction !== \"function\") return assertionFunction instanceof chai.Assertion ? proxy : assertionFunction;\n\t\t\tif (key === \"assert\") return assertionFunction;\n\t\t\tif (typeof key === \"string\" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);\n\t\t\t// Core poll stack-trace trick:\n\t\t\t//   1. capture STACK_TRACE_ERROR here before entering the async poll loop\n\t\t\t//   2. when the matcher eventually fails, rethrow via throwWithCause()\n\t\t\t//      so the final error keeps this earlier stack\n\t\t\t//\n\t\t\t// For example, when user writes:\n\t\t\t//    await expect.poll(...).toBeSomething()\n\t\t\t// STACK_TRACE_ERROR.stack would look like\n\t\t\t//   at ...(more internal stacks)...\n\t\t\t//   at __VITEST_POLL_CHAIN__ .../packages/vitest/dist/...\n\t\t\t//   at .../my-file.test.ts:12:3   (this points to `toBeSomething()` callsite in user test file)\n\t\t\t// Vitest later filters out internal stacks from `vitest/dist`, so the reported errors correctly\n\t\t\t// points to the user callsite for poll assertion errors.\n\t\t\t//\n\t\t\t// Inline snapshots piggyback on the same idea. We pass\n\t\t\t// STACK_TRACE_ERROR through `chai.util.flag(assertion, 'error', ...)`.\n\t\t\t// Inline snapshot assertion access the same error stack for\n\t\t\t// extracting inline snapshot location to validate and update new snapshots.\n\t\t\treturn function __VITEST_POLL_CHAIN__(...args) {\n\t\t\t\tconst STACK_TRACE_ERROR = /* @__PURE__ */ new Error(\"STACK_TRACE_ERROR\");\n\t\t\t\tconst promise = async () => {\n\t\t\t\t\tchai.util.flag(assertion, \"_name\", key);\n\t\t\t\t\tchai.util.flag(assertion, \"error\", STACK_TRACE_ERROR);\n\t\t\t\t\tconst onSettled = chai.util.flag(assertion, \"_poll.onSettled\");\n\t\t\t\t\tif (Object.getOwnPropertyDescriptor(assertionFunction, \"__vitest_poll_takeover__\")?.value) try {\n\t\t\t\t\t\tconst output = await assertionFunction.call(assertion, ...args);\n\t\t\t\t\t\tawait onSettled?.({\n\t\t\t\t\t\t\tassertion,\n\t\t\t\t\t\t\tstatus: \"pass\"\n\t\t\t\t\t\t});\n\t\t\t\t\t\treturn output;\n\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\tawait onSettled?.({\n\t\t\t\t\t\t\tassertion,\n\t\t\t\t\t\t\tstatus: \"fail\"\n\t\t\t\t\t\t});\n\t\t\t\t\t\tthrowWithCause(err, STACK_TRACE_ERROR);\n\t\t\t\t\t}\n\t\t\t\t\tconst { setTimeout, clearTimeout } = getSafeTimers();\n\t\t\t\t\tlet executionPhase = \"fn\";\n\t\t\t\t\tlet hasTimedOut = false;\n\t\t\t\t\tconst timerId = setTimeout(() => {\n\t\t\t\t\t\thasTimedOut = true;\n\t\t\t\t\t}, timeout);\n\t\t\t\t\ttry {\n\t\t\t\t\t\twhile (true) {\n\t\t\t\t\t\t\tconst isLastAttempt = hasTimedOut;\n\t\t\t\t\t\t\tif (isLastAttempt) chai.util.flag(assertion, \"_isLastPollAttempt\", true);\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\texecutionPhase = \"fn\";\n\t\t\t\t\t\t\t\tconst obj = await fn();\n\t\t\t\t\t\t\t\tchai.util.flag(assertion, \"object\", obj);\n\t\t\t\t\t\t\t\texecutionPhase = \"assertion\";\n\t\t\t\t\t\t\t\tconst output = await assertionFunction.call(assertion, ...args);\n\t\t\t\t\t\t\t\tawait onSettled?.({\n\t\t\t\t\t\t\t\t\tassertion,\n\t\t\t\t\t\t\t\t\tstatus: \"pass\"\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\treturn output;\n\t\t\t\t\t\t\t} catch (err) {\n\t\t\t\t\t\t\t\tif (isLastAttempt || executionPhase === \"assertion\" && chai.util.flag(assertion, \"_poll.assert_once\")) {\n\t\t\t\t\t\t\t\t\tawait onSettled?.({\n\t\t\t\t\t\t\t\t\t\tassertion,\n\t\t\t\t\t\t\t\t\t\tstatus: \"fail\"\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t\tthrowWithCause(err, STACK_TRACE_ERROR);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tawait delay(interval, setTimeout);\n\t\t\t\t\t\t\t\tif (vi.isFakeTimers()) vi.advanceTimersByTime(interval);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tclearTimeout(timerId);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t\tlet awaited = false;\n\t\t\t\ttest.onFinished ??= [];\n\t\t\t\ttest.onFinished.push(() => {\n\t\t\t\t\tif (!awaited) {\n\t\t\t\t\t\tconst negated = chai.util.flag(assertion, \"negate\") ? \"not.\" : \"\";\n\t\t\t\t\t\tconst assertionString = `expect.${chai.util.flag(assertion, \"_poll.element\") ? \"element(locator)\" : \"poll(assertion)\"}.${negated}${String(key)}()`;\n\t\t\t\t\t\tthrow copyStackTrace(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\\n\\nawait ${assertionString}\\n`), STACK_TRACE_ERROR);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t\tlet resultPromise;\n\t\t\t\t// only .then is enough to check awaited, but we type this as `Promise<void>` in global types\n\t\t\t\t// so let's follow it\n\t\t\t\treturn {\n\t\t\t\t\tthen(onFulfilled, onRejected) {\n\t\t\t\t\t\tawaited = true;\n\t\t\t\t\t\treturn (resultPromise ||= promise()).then(onFulfilled, onRejected);\n\t\t\t\t\t},\n\t\t\t\t\tcatch(onRejected) {\n\t\t\t\t\t\tawaited = true;\n\t\t\t\t\t\treturn (resultPromise ||= promise()).catch(onRejected);\n\t\t\t\t\t},\n\t\t\t\t\tfinally(onFinally) {\n\t\t\t\t\t\tawaited = true;\n\t\t\t\t\t\treturn (resultPromise ||= promise()).finally(onFinally);\n\t\t\t\t\t},\n\t\t\t\t\t[Symbol.toStringTag]: \"Promise\"\n\t\t\t\t};\n\t\t\t};\n\t\t} });\n\t\treturn proxy;\n\t};\n}\nfunction copyStackTrace(target, source) {\n\tif (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);\n\treturn target;\n}\n\nlet _client;\nfunction getSnapshotClient() {\n\tif (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {\n\t\treturn equals(received, expected, [iterableEquality, subsetEquality]);\n\t} });\n\treturn _client;\n}\nfunction getError(expected, promise) {\n\tif (typeof expected !== \"function\") {\n\t\tif (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);\n\t\t// when \"promised\", it receives thrown error\n\t\treturn expected;\n\t}\n\ttry {\n\t\texpected();\n\t} catch (e) {\n\t\treturn e;\n\t}\n\tthrow new Error(\"snapshot function didn't throw\");\n}\nfunction getTestNames(test) {\n\treturn {\n\t\tfilepath: test.file.filepath,\n\t\tname: getNames(test).slice(1).join(\" > \"),\n\t\ttestId: test.id\n\t};\n}\nfunction getAssertionName(assertion) {\n\tconst name = chai.util.flag(assertion, \"_name\");\n\tif (!name) throw new Error(\"Assertion name is not set. This is a bug in Vitest. Please, open a new issue with reproduction.\");\n\treturn name;\n}\nfunction getTest(obj) {\n\tconst test = chai.util.flag(obj, \"vitest-test\");\n\tif (!test) throw new Error(`'${getAssertionName(obj)}' cannot be used without test context`);\n\treturn test;\n}\nfunction validateAssertion(assertion) {\n\tif (chai.util.flag(assertion, \"negate\")) throw new Error(`${getAssertionName(assertion)} cannot be used with \"not\"`);\n}\nconst SnapshotPlugin = (chai, utils) => {\n\tfor (const key of [\"matchSnapshot\", \"toMatchSnapshot\"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(propertiesOrHint, hint) {\n\t\treturn assertMatchResult(toMatchSnapshotImpl({\n\t\t\tassertion: this,\n\t\t\treceived: utils.flag(this, \"object\"),\n\t\t\t...normalizeArguments(propertiesOrHint, hint)\n\t\t}), chai.util.flag(this, \"message\"));\n\t}));\n\tutils.addMethod(chai.Assertion.prototype, \"toMatchFileSnapshot\", function(filepath, hint) {\n\t\t// set name manually since it's not wrapped by wrapAssertion\n\t\tutils.flag(this, \"_name\", \"toMatchFileSnapshot\");\n\t\t// validate early synchronously just not to break some existing tests\n\t\tvalidateAssertion(this);\n\t\tconst assertPromise = toMatchFileSnapshotImpl({\n\t\t\tassertion: this,\n\t\t\treceived: utils.flag(this, \"object\"),\n\t\t\tfilepath,\n\t\t\thint\n\t\t}).then((result) => assertMatchResult(result, chai.util.flag(this, \"message\")));\n\t\treturn recordAsyncExpect(getTest(this), assertPromise, createAssertionMessage(utils, this, true), /* @__PURE__ */ new Error(\"resolves\"), utils.flag(this, \"soft\"));\n\t});\n\tutils.addMethod(chai.Assertion.prototype, \"toMatchInlineSnapshot\", wrapAssertion(utils, \"toMatchInlineSnapshot\", function __INLINE_SNAPSHOT_OFFSET_3__(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {\n\t\treturn assertMatchResult(toMatchSnapshotImpl({\n\t\t\tassertion: this,\n\t\t\treceived: utils.flag(this, \"object\"),\n\t\t\tisInline: true,\n\t\t\t...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)\n\t\t}), chai.util.flag(this, \"message\"));\n\t}));\n\tutils.addMethod(chai.Assertion.prototype, \"toThrowErrorMatchingSnapshot\", wrapAssertion(utils, \"toThrowErrorMatchingSnapshot\", function(propertiesOrHint, hint) {\n\t\tvalidateAssertion(this);\n\t\tconst received = utils.flag(this, \"object\");\n\t\tconst promise = utils.flag(this, \"promise\");\n\t\treturn assertMatchResult(toMatchSnapshotImpl({\n\t\t\tassertion: this,\n\t\t\treceived: getError(received, promise),\n\t\t\t...normalizeArguments(propertiesOrHint, hint)\n\t\t}), chai.util.flag(this, \"message\"));\n\t}));\n\tutils.addMethod(chai.Assertion.prototype, \"toThrowErrorMatchingInlineSnapshot\", wrapAssertion(utils, \"toThrowErrorMatchingInlineSnapshot\", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshotOrHint, hint) {\n\t\tvalidateAssertion(this);\n\t\tconst received = utils.flag(this, \"object\");\n\t\tconst promise = utils.flag(this, \"promise\");\n\t\treturn assertMatchResult(toMatchSnapshotImpl({\n\t\t\tassertion: this,\n\t\t\treceived: getError(received, promise),\n\t\t\tisInline: true,\n\t\t\t...normalizeInlineArguments(void 0, inlineSnapshotOrHint, hint)\n\t\t}), chai.util.flag(this, \"message\"));\n\t}));\n\tutils.addMethod(chai.expect, \"addSnapshotSerializer\", addSerializer);\n};\nfunction toMatchDomainSnapshotImpl(opts) {\n\tconst { assertion } = opts;\n\tvalidateAssertion(assertion);\n\tconst assertionName = getAssertionName(assertion);\n\tconst test = getTest(assertion);\n\tlet { inlineSnapshot } = opts;\n\tif (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);\n\tconst pollFn = chai.util.flag(assertion, \"_poll.fn\");\n\tif (pollFn) return getSnapshotClient().pollMatchDomain({\n\t\tpoll: pollFn,\n\t\tadapter: opts.adapter,\n\t\tmessage: opts.hint,\n\t\tisInline: opts.isInline,\n\t\terrorMessage: chai.util.flag(assertion, \"message\"),\n\t\ttimeout: chai.util.flag(assertion, \"_poll.timeout\"),\n\t\tinterval: chai.util.flag(assertion, \"_poll.interval\"),\n\t\tassertionName,\n\t\tinlineSnapshot,\n\t\terror: chai.util.flag(assertion, \"error\"),\n\t\t...getTestNames(test)\n\t});\n\treturn getSnapshotClient().matchDomain({\n\t\treceived: opts.received,\n\t\tadapter: opts.adapter,\n\t\tmessage: opts.hint,\n\t\tisInline: opts.isInline,\n\t\terrorMessage: chai.util.flag(assertion, \"message\"),\n\t\tassertionName,\n\t\tinlineSnapshot,\n\t\terror: chai.util.flag(assertion, \"error\"),\n\t\t...getTestNames(test)\n\t});\n}\n// toMatchSnapshot(propertiesOrHint?, hint?)\nfunction normalizeArguments(propertiesOrHint, hint) {\n\tif (typeof propertiesOrHint === \"string\") return { hint: propertiesOrHint };\n\treturn {\n\t\tproperties: propertiesOrHint,\n\t\thint\n\t};\n}\n// toMatchInlineSnapshot(propertiesOrInlineSnapshot?, inlineSnapshotOrHint?, hint?)\nfunction normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {\n\tlet inlineSnapshot;\n\tif (typeof propertiesOrInlineSnapshot === \"string\") {\n\t\tinlineSnapshot = stripSnapshotIndentation(propertiesOrInlineSnapshot);\n\t\treturn {\n\t\t\tinlineSnapshot,\n\t\t\thint: inlineSnapshotOrHint\n\t\t};\n\t}\n\tif (inlineSnapshotOrHint) inlineSnapshot = stripSnapshotIndentation(inlineSnapshotOrHint);\n\treturn {\n\t\tproperties: propertiesOrInlineSnapshot,\n\t\tinlineSnapshot,\n\t\thint\n\t};\n}\nfunction toMatchSnapshotImpl(options) {\n\tconst { assertion } = options;\n\tvalidateAssertion(assertion);\n\tconst assertionName = getAssertionName(assertion);\n\tconst test = getTest(assertion);\n\treturn getSnapshotClient().match({\n\t\treceived: options.received,\n\t\tproperties: options.properties,\n\t\tmessage: options.hint,\n\t\tisInline: options.isInline,\n\t\tinlineSnapshot: options.inlineSnapshot,\n\t\tassertionName,\n\t\terror: chai.util.flag(assertion, \"error\"),\n\t\t...getTestNames(test)\n\t});\n}\nasync function toMatchFileSnapshotImpl(options) {\n\tconst { assertion } = options;\n\tvalidateAssertion(assertion);\n\tconst testNames = getTestNames(getTest(assertion));\n\tconst snapshotState = getSnapshotClient().getSnapshotState(testNames.filepath);\n\tconst rawSnapshotFile = await snapshotState.environment.resolveRawPath(testNames.filepath, options.filepath);\n\tconst rawSnapshotContent = await snapshotState.environment.readSnapshotFile(rawSnapshotFile);\n\treturn getSnapshotClient().match({\n\t\treceived: options.received,\n\t\tmessage: options.hint,\n\t\trawSnapshot: {\n\t\t\tfile: rawSnapshotFile,\n\t\t\tcontent: rawSnapshotContent ?? void 0\n\t\t},\n\t\t...testNames\n\t});\n}\nfunction assertMatchResult(result, customMessage) {\n\tif (!result.pass) {\n\t\tconst errorMessage = (customMessage ? `${customMessage}: ` : \"\") + result.message();\n\t\tthrow Object.assign(new Error(errorMessage), {\n\t\t\tactual: result.actual,\n\t\t\texpected: result.expected,\n\t\t\tdiffOptions: { expand: getWorkerState().config.snapshotOptions.expand }\n\t\t});\n\t}\n}\n/**\n* Composable snapshot matcher helpers for building custom snapshot matchers\n* with `expect.extend`.\n*\n* @experimental\n* @see https://vitest.dev/guide/snapshot.html#custom-snapshot-matchers\n*/\nconst Snapshots = {\n\ttoMatchSnapshot(received, propertiesOrHint, hint) {\n\t\treturn toMatchSnapshotImpl({\n\t\t\tassertion: this.assertion,\n\t\t\treceived,\n\t\t\t...normalizeArguments(propertiesOrHint, hint)\n\t\t});\n\t},\n\ttoMatchInlineSnapshot(received, propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {\n\t\treturn toMatchSnapshotImpl({\n\t\t\tassertion: this.assertion,\n\t\t\treceived,\n\t\t\tisInline: true,\n\t\t\t...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)\n\t\t});\n\t},\n\ttoMatchFileSnapshot(received, filepath, hint) {\n\t\treturn toMatchFileSnapshotImpl({\n\t\t\tassertion: this.assertion,\n\t\t\treceived,\n\t\t\tfilepath,\n\t\t\thint\n\t\t});\n\t},\n\ttoMatchDomainSnapshot(domain, received) {\n\t\treturn toMatchDomainSnapshotImpl({\n\t\t\tassertion: this.assertion,\n\t\t\tadapter: domain,\n\t\t\treceived\n\t\t});\n\t},\n\ttoMatchDomainInlineSnapshot(domain, received, inlineSnapshot) {\n\t\treturn toMatchDomainSnapshotImpl({\n\t\t\tassertion: this.assertion,\n\t\t\tadapter: domain,\n\t\t\treceived,\n\t\t\tisInline: true,\n\t\t\tinlineSnapshot\n\t\t});\n\t}\n};\n\nchai.use(JestExtend);\nchai.use(JestChaiExpect);\nchai.use(ChaiStyleAssertions);\nchai.use(SnapshotPlugin);\nchai.use(JestAsymmetricMatchers);\n\nfunction createExpect(test) {\n\tconst expect = ((value, message) => {\n\t\tconst { assertionCalls } = getState(expect);\n\t\tsetState({ assertionCalls: assertionCalls + 1 }, expect);\n\t\tconst assert = chai.expect(value, message);\n\t\tconst _test = test || getCurrentTest();\n\t\tif (_test)\n // @ts-expect-error internal\n\t\treturn assert.withTest(_test);\n\t\telse return assert;\n\t});\n\tObject.assign(expect, chai.expect);\n\tObject.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);\n\texpect.getState = () => getState(expect);\n\texpect.setState = (state) => setState(state, expect);\n\t// @ts-expect-error global is not typed\n\tconst globalState = getState(globalThis[GLOBAL_EXPECT]) || {};\n\tsetState({\n\t\t...globalState,\n\t\tassertionCalls: 0,\n\t\tisExpectingAssertions: false,\n\t\tisExpectingAssertionsError: null,\n\t\texpectedAssertionsNumber: null,\n\t\texpectedAssertionsNumberErrorGen: null,\n\t\tget testPath() {\n\t\t\treturn getWorkerState().filepath;\n\t\t},\n\t\tcurrentTestName: test ? test.fullTestName ?? \"\" : globalState.currentTestName\n\t}, expect);\n\texpect.assert = chai.assert;\n\t// @ts-expect-error untyped\n\texpect.extend = (matchers) => chai.expect.extend(expect, matchers);\n\texpect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);\n\texpect.soft = (...args) => {\n\t\t// @ts-expect-error private soft access\n\t\treturn expect(...args).withContext({ soft: true });\n\t};\n\texpect.poll = createExpectPoll(expect);\n\texpect.unreachable = (message) => {\n\t\tchai.assert.fail(`expected${message ? ` \"${message}\" ` : \" \"}not to be reached`);\n\t};\n\tfunction assertions(expected) {\n\t\tconst errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);\n\t\tif (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);\n\t\texpect.setState({\n\t\t\texpectedAssertionsNumber: expected,\n\t\t\texpectedAssertionsNumberErrorGen: errorGen\n\t\t});\n\t}\n\tfunction hasAssertions() {\n\t\tconst error = /* @__PURE__ */ new Error(\"expected any number of assertion, but got none\");\n\t\tif (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);\n\t\texpect.setState({\n\t\t\tisExpectingAssertions: true,\n\t\t\tisExpectingAssertionsError: error\n\t\t});\n\t}\n\tchai.util.addMethod(expect, \"assertions\", assertions);\n\tchai.util.addMethod(expect, \"hasAssertions\", hasAssertions);\n\texpect.extend(customMatchers);\n\treturn expect;\n}\nconst globalExpect = createExpect();\nObject.defineProperty(globalThis, GLOBAL_EXPECT, {\n\tvalue: globalExpect,\n\twritable: true,\n\tconfigurable: true\n});\nconst assert = chai.assert;\nconst should = chai.should;\n\n/**\n* Gives access to injected context provided from the main thread.\n* This usually returns a value provided by `globalSetup` or an external library.\n*/\nfunction inject(key) {\n\treturn getWorkerState().providedContext[key];\n}\n\nfunction createBenchmarkResult(name) {\n\treturn {\n\t\tname,\n\t\trank: 0,\n\t\trme: 0,\n\t\tsamples: []\n\t};\n}\nconst benchmarkTasks = /* @__PURE__ */ new WeakMap();\nasync function runBenchmarkSuite(suite, runner) {\n\tconst { Task, Bench } = await runner.importTinybench();\n\tconst start = performance.now();\n\tconst benchmarkGroup = [];\n\tconst benchmarkSuiteGroup = [];\n\tfor (const task of suite.tasks) {\n\t\tif (task.mode !== \"run\" && task.mode !== \"queued\") continue;\n\t\tif (task.meta?.benchmark) benchmarkGroup.push(task);\n\t\telse if (task.type === \"suite\") benchmarkSuiteGroup.push(task);\n\t}\n\t// run sub suites sequentially\n\tfor (const subSuite of benchmarkSuiteGroup) await runBenchmarkSuite(subSuite, runner);\n\tif (benchmarkGroup.length) {\n\t\tconst defer = createDefer();\n\t\tsuite.result = {\n\t\t\tstate: \"run\",\n\t\t\tstartTime: start,\n\t\t\tbenchmark: createBenchmarkResult(suite.name)\n\t\t};\n\t\tupdateTask$1(\"suite-prepare\", suite);\n\t\tconst addBenchTaskListener = (task, benchmark) => {\n\t\t\ttask.addEventListener(\"complete\", (e) => {\n\t\t\t\tconst taskRes = e.task.result;\n\t\t\t\tconst result = benchmark.result.benchmark;\n\t\t\t\tbenchmark.result.state = \"pass\";\n\t\t\t\tObject.assign(result, taskRes);\n\t\t\t\t// compute extra stats and free raw samples as early as possible\n\t\t\t\tconst samples = result.samples;\n\t\t\t\tresult.sampleCount = samples.length;\n\t\t\t\tresult.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;\n\t\t\t\tif (!runner.config.benchmark?.includeSamples) result.samples.length = 0;\n\t\t\t\tupdateTask$1(\"test-finished\", benchmark);\n\t\t\t}, { once: true });\n\t\t\ttask.addEventListener(\"error\", (e) => {\n\t\t\t\tconst task = e.task;\n\t\t\t\tdefer.reject(benchmark ? task.result.error : e);\n\t\t\t}, { once: true });\n\t\t};\n\t\tbenchmarkGroup.forEach((benchmark) => {\n\t\t\tconst benchmarkInstance = new Bench(getBenchOptions(benchmark));\n\t\t\tconst benchmarkFn = getBenchFn(benchmark);\n\t\t\tbenchmark.result = {\n\t\t\t\tstate: \"run\",\n\t\t\t\tstartTime: start,\n\t\t\t\tbenchmark: createBenchmarkResult(benchmark.name)\n\t\t\t};\n\t\t\tconst task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);\n\t\t\tbenchmarkTasks.set(benchmark, task);\n\t\t\taddBenchTaskListener(task, benchmark);\n\t\t});\n\t\tconst { setTimeout } = getSafeTimers();\n\t\tconst tasks = [];\n\t\tfor (const benchmark of benchmarkGroup) {\n\t\t\tconst task = benchmarkTasks.get(benchmark);\n\t\t\tupdateTask$1(\"test-prepare\", benchmark);\n\t\t\tawait task.warmup();\n\t\t\ttasks.push([await new Promise((resolve) => setTimeout(async () => {\n\t\t\t\tresolve(await task.run());\n\t\t\t})), benchmark]);\n\t\t}\n\t\tsuite.result.duration = performance.now() - start;\n\t\tsuite.result.state = \"pass\";\n\t\tupdateTask$1(\"suite-finished\", suite);\n\t\tdefer.resolve(null);\n\t\tawait defer;\n\t}\n\tfunction updateTask$1(event, task) {\n\t\tupdateTask(event, task, runner);\n\t}\n}\nclass NodeBenchmarkRunner {\n\tmoduleRunner;\n\tconstructor(config) {\n\t\tthis.config = config;\n\t}\n\tasync importTinybench() {\n\t\treturn await import('tinybench');\n\t}\n\timportFile(filepath, source) {\n\t\tif (source === \"setup\") {\n\t\t\tconst moduleNode = getWorkerState().evaluatedModules.getModuleById(filepath);\n\t\t\tif (moduleNode) getWorkerState().evaluatedModules.invalidateModule(moduleNode);\n\t\t}\n\t\treturn this.moduleRunner.import(filepath);\n\t}\n\tasync runSuite(suite) {\n\t\tawait runBenchmarkSuite(suite, this);\n\t}\n\tasync runTask() {\n\t\tthrow new Error(\"`test()` and `it()` is only available in test mode.\");\n\t}\n}\n\nclass TestRunner {\n\tsnapshotClient = getSnapshotClient();\n\tworkerState = getWorkerState();\n\tmoduleRunner;\n\tcancelRun = false;\n\tassertionsErrors = /* @__PURE__ */ new WeakMap();\n\tpool = this.workerState.ctx.pool;\n\t_otel;\n\tviteEnvironment;\n\tviteModuleRunner;\n\tconstructor(config) {\n\t\tthis.config = config;\n\t\tconst environment = this.workerState.environment;\n\t\tthis.viteEnvironment = environment.viteEnvironment || environment.name;\n\t\tthis.viteModuleRunner = config.experimental.viteModuleRunner;\n\t}\n\timportFile(filepath, source) {\n\t\tif (source === \"setup\") {\n\t\t\tconst moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);\n\t\t\tif (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);\n\t\t}\n\t\treturn this._otel.$(`vitest.module.import_${source === \"setup\" ? \"setup\" : \"spec\"}`, { attributes: { \"code.file.path\": filepath } }, () => {\n\t\t\tif (!this.viteModuleRunner) filepath = `${filepath}?vitest=${Date.now()}`;\n\t\t\treturn this.moduleRunner.import(filepath);\n\t\t});\n\t}\n\tonCollectStart(file) {\n\t\tthis.workerState.current = file;\n\t}\n\tonCleanupWorkerContext(listener) {\n\t\tthis.workerState.onCleanup(listener);\n\t}\n\tonAfterRunFiles() {\n\t\tthis.snapshotClient.clear();\n\t\tthis.workerState.current = void 0;\n\t}\n\tasync onAfterRunSuite(suite) {\n\t\tif (this.config.logHeapUsage && typeof process !== \"undefined\") suite.result.heap = process.memoryUsage().heapUsed;\n\t\tif (suite.mode !== \"skip\" && \"filepath\" in suite) {\n\t\t\t// mark snapshots in skipped tests as not obsolete\n\t\t\tfor (const test of getTests(suite)) if (test.mode === \"skip\") {\n\t\t\t\tconst name = getNames(test).slice(1).join(\" > \");\n\t\t\t\tthis.snapshotClient.skipTest(suite.file.filepath, name);\n\t\t\t}\n\t\t\tconst result = await this.snapshotClient.finish(suite.file.filepath);\n\t\t\tif (this.workerState.config.snapshotOptions.updateSnapshot === \"none\" && result.unchecked) {\n\t\t\t\tlet message = `Obsolete snapshots found when no snapshot update is expected.\\n`;\n\t\t\t\tfor (const key of result.uncheckedKeys) message += `· ${key}\\n`;\n\t\t\t\tsuite.result.errors ??= [];\n\t\t\t\tsuite.result.errors.push(processError(new Error(message)));\n\t\t\t\tsuite.result.state = \"fail\";\n\t\t\t}\n\t\t\tawait rpc().snapshotSaved(result);\n\t\t}\n\t\tthis.workerState.current = suite.suite || suite.file;\n\t}\n\tonAfterRunTask(test) {\n\t\tif (this.config.logHeapUsage && typeof process !== \"undefined\") test.result.heap = process.memoryUsage().heapUsed;\n\t\tthis.workerState.current = test.suite || test.file;\n\t}\n\tcancel(_reason) {\n\t\tthis.cancelRun = true;\n\t}\n\tinjectValue(key) {\n\t\t// inject has a very limiting type controlled by ProvidedContext\n\t\t// some tests override it which causes the build to fail\n\t\treturn inject(key);\n\t}\n\tasync onBeforeRunTask(test) {\n\t\tif (this.cancelRun) test.mode = \"skip\";\n\t\tif (test.mode !== \"run\" && test.mode !== \"queued\") return;\n\t\tthis.workerState.current = test;\n\t}\n\tasync onBeforeRunSuite(suite) {\n\t\tif (this.cancelRun) suite.mode = \"skip\";\n\t\t// initialize snapshot state before running file suite\n\t\tif (suite.mode !== \"skip\" && \"filepath\" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);\n\t\tthis.workerState.current = suite;\n\t}\n\tonBeforeTryTask(test) {\n\t\tclearModuleMocks(this.config);\n\t\tthis.snapshotClient.clearTest(test.file.filepath, test.id);\n\t\tsetState({\n\t\t\tassertionCalls: 0,\n\t\t\tisExpectingAssertions: false,\n\t\t\tisExpectingAssertionsError: null,\n\t\t\texpectedAssertionsNumber: null,\n\t\t\texpectedAssertionsNumberErrorGen: null,\n\t\t\tcurrentTestName: getTestName(test),\n\t\t\tsnapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)\n\t\t}, globalThis[GLOBAL_EXPECT]);\n\t}\n\tonAfterTryTask(test) {\n\t\tconst { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);\n\t\tif (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();\n\t\tif (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;\n\t\tif (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);\n\t}\n\textendTaskContext(context) {\n\t\t// create error during the test initialization so we have a nice stack trace\n\t\tif (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error(\"expected any number of assertion, but got none\"));\n\t\tlet _expect;\n\t\tObject.defineProperty(context, \"expect\", { get() {\n\t\t\tif (!_expect) _expect = createExpect(context.task);\n\t\t\treturn _expect;\n\t\t} });\n\t\tObject.defineProperty(context, \"_local\", { get() {\n\t\t\treturn _expect != null;\n\t\t} });\n\t\treturn context;\n\t}\n\tgetImportDurations() {\n\t\tconst { limit } = this.config.experimental.importDurations;\n\t\t// skip sorting if limit is 0\n\t\tif (limit === 0) return {};\n\t\t// Sort by duration descending and keep top entries\n\t\tconst sortedEntries = [...this.workerState.moduleExecutionInfo?.entries() || []].sort(([, a], [, b]) => b.duration - a.duration).slice(0, limit);\n\t\tconst importDurations = {};\n\t\tfor (const [filepath, { duration, selfTime, external, importer }] of sortedEntries) importDurations[normalize(filepath)] = {\n\t\t\tselfTime,\n\t\t\ttotalTime: duration,\n\t\t\texternal,\n\t\t\timporter\n\t\t};\n\t\treturn importDurations;\n\t}\n\ttrace = (name, attributes, cb) => {\n\t\tconst options = typeof attributes === \"object\" ? { attributes } : {};\n\t\treturn this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);\n\t};\n\t__setTraces(traces) {\n\t\tthis._otel = traces;\n\t}\n\tstatic createTaskCollector = createTaskCollector;\n\tstatic getCurrentSuite = getCurrentSuite;\n\tstatic getCurrentTest = getCurrentTest;\n\tstatic createChainable = createChainable;\n\tstatic getSuiteHooks = getHooks;\n\tstatic getTestFn = getFn;\n\tstatic setSuiteHooks = getHooks;\n\tstatic setTestFn = getFn;\n\tstatic matchesTags = matchesTags;\n\t/**\n\t* @deprecated\n\t*/\n\tstatic getBenchFn = getBenchFn;\n\t/**\n\t* @deprecated\n\t*/\n\tstatic getBenchOptions = getBenchOptions;\n}\nfunction clearModuleMocks(config) {\n\tconst { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;\n\tif (restoreMocks) vi.restoreAllMocks();\n\tif (mockReset) vi.resetAllMocks();\n\tif (clearMocks) vi.clearAllMocks();\n\tif (unstubEnvs) vi.unstubAllEnvs();\n\tif (unstubGlobals) vi.unstubAllGlobals();\n}\n\nexport { NodeBenchmarkRunner as N, Snapshots as S, TestRunner as T, assert as a, vitest as b, createExpect as c, globalExpect as g, inject as i, should as s, vi as v };\n"],"x_google_ignoreList":[0],"mappings":"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"}