@powerlines/plugin-react 0.1.636 → 0.1.638

package/dist/node_modules/.pnpm/vitest@4.1.7_@opentelemetry_api@1.9.1_@types_node@25.9.1_@vitest_coverage-v8@4.1.7_vite_34dd47607c0af5e5ae7f1b2f95fc48c3/node_modules/vitest/dist/chunks/test.DNmyFkvJ.mjs

@@ -1,2697 +0,0 @@
-import { assertTypes, createSimpleStackTrace } from "../../../../../@vitest_utils@4.1.7/node_modules/@vitest/utils/dist/helpers.mjs";
-import { delay, getSafeTimers } from "../../../../../@vitest_utils@4.1.7/node_modules/@vitest/utils/dist/timers.mjs";
-import { parseSingleStack } from "../../../../../@vitest_utils@4.1.7/node_modules/@vitest/utils/dist/source-map.mjs";
-import { getCurrentTest, getNames } from "../../../../../@vitest_runner@4.1.7/node_modules/@vitest/runner/dist/chunk-artifact.mjs";
-import "../../../../../@vitest_runner@4.1.7/node_modules/@vitest/runner/dist/index.mjs";
-import "../../../../../@vitest_runner@4.1.7/node_modules/@vitest/runner/dist/utils.mjs";
-import { getWorkerState, isChildProcess, resetModules, waitForImportsToResolve } from "./utils.BX5Fg8C4.mjs";
-import { clearAllMocks, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn } from "../../../../../@vitest_spy@4.1.7/node_modules/@vitest/spy/dist/index.mjs";
-import { Assertion, assert as assert$1, expect, should as should$1, use, utils_exports } from "../../../../../chai@6.2.2/node_modules/chai/index.mjs";
-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.7/node_modules/@vitest/expect/dist/index.mjs";
-import { commonjsGlobal } from "./_commonjsHelpers.D26ty3Ew.mjs";
-import { RealDate, mockDate, resetDate } from "./rpc.MzXet3jl.mjs";
-import { SnapshotClient, addSerializer, stripSnapshotIndentation } from "../../../../../@vitest_snapshot@4.1.7/node_modules/@vitest/snapshot/dist/index.mjs";
-
-//#region ../../../node_modules/.pnpm/vitest@4.1.7_@opentelemetry+api@1.9.1_@types+node@25.9.1_@vitest+coverage-v8@4.1.7_vite_34dd47607c0af5e5ae7f1b2f95fc48c3/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);
-					Object.defineProperty(target, method, Object.getOwnPropertyDescriptor(clock, method));
-				} 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);
-				}
-				throw getInfiniteLoopError(clock, firstTimer(clock));
-			};
-			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;
-								}
-								reject(getInfiniteLoopError(clock, firstTimer(clock)));
-							} 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) {
-			clock.attachedInterval = originalSetInterval(doIntervalTick.bind(null, clock, delta), 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 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 }
-		});
-	}
-}
-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;
-
-//#endregion
-export { globalExpect };
-//# sourceMappingURL=test.DNmyFkvJ.mjs.map