@manifest-network/manifest-mcp-core 0.1.0

package/dist/node_modules/vitest/dist/chunks/test.CTcmp4Su.js

@@ -0,0 +1,2791 @@
+import { assertTypes, createSimpleStackTrace } from "../../../@vitest/utils/dist/helpers.js";
+import { processError } from "../../../@vitest/utils/dist/error.js";
+import { delay, getSafeTimers } from "../../../@vitest/utils/dist/timers.js";
+import { parseSingleStack } from "../../../@vitest/utils/dist/source-map.js";
+import { normalize } from "../../../pathe/dist/shared/pathe.M-eThtNZ.js";
+import { createChainable, getNames, getTestName, getTests } from "../../../@vitest/runner/dist/chunk-tasks.js";
+import { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks } from "../../../@vitest/runner/dist/index.js";
+import "../../../@vitest/runner/dist/utils.js";
+import { getWorkerState, isChildProcess, resetModules, waitForImportsToResolve } from "./utils.BX5Fg8C4.js";
+import { getBenchFn, getBenchOptions } from "./benchmark.D0SlKNbZ.js";
+import { clearAllMocks, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn } from "../../../@vitest/spy/dist/index.js";
+import { Assertion, assert as assert$1, expect, use, utils_exports } from "../../../chai/index.js";
+import { ASYMMETRIC_MATCHERS_OBJECT, ChaiStyleAssertions, GLOBAL_EXPECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, addCustomEqualityTesters, createAssertionMessage, customMatchers, equals, getState, iterableEquality, recordAsyncExpect, setState, subsetEquality, wrapAssertion } from "../../../@vitest/expect/dist/index.js";
+import { SnapshotClient, addSerializer, stripSnapshotIndentation } from "../../../@vitest/snapshot/dist/index.js";
+import { commonjsGlobal } from "./_commonjsHelpers.D26ty3Ew.js";
+import { RealDate, mockDate, resetDate, rpc } from "./rpc.MzXet3jl.js";
+//#region ../../node_modules/vitest/dist/chunks/test.CTcmp4Su.js
+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$1(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);
+		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(...args) {
+				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+				const promise = async () => {
+					const { setTimeout, clearTimeout } = getSafeTimers();
+					let executionPhase = "fn";
+					let hasTimedOut = false;
+					const timerId = setTimeout(() => {
+						hasTimedOut = true;
+					}, timeout);
+					utils_exports.flag(assertion, "_name", key);
+					const onSettled = utils_exports.flag(assertion, "_poll.onSettled");
+					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);
+							}
+						}
+					} finally {
+						clearTimeout(timerId);
+					}
+				};
+				let awaited = false;
+				test.onFinished ?? (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$1(/* @__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 || (resultPromise = promise())).then(onFulfilled, onRejected);
+					},
+					catch(onRejected) {
+						awaited = true;
+						return (resultPromise || (resultPromise = promise())).catch(onRejected);
+					},
+					finally(onFinally) {
+						awaited = true;
+						return (resultPromise || (resultPromise = promise())).finally(onFinally);
+					},
+					[Symbol.toStringTag]: "Promise"
+				};
+			};
+		} });
+		return proxy;
+	};
+}
+function copyStackTrace$1(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
+	};
+}
+const SnapshotPlugin = (chai, utils) => {
+	function getTest(assertionName, obj) {
+		const test = utils.flag(obj, "vitest-test");
+		if (!test) throw new Error(`'${assertionName}' cannot be used without test context`);
+		return test;
+	}
+	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(properties, message) {
+		utils.flag(this, "_name", key);
+		if (utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
+		const expected = utils.flag(this, "object");
+		const test = getTest(key, this);
+		if (typeof properties === "string" && typeof message === "undefined") {
+			message = properties;
+			properties = void 0;
+		}
+		const errorMessage = utils.flag(this, "message");
+		getSnapshotClient().assert({
+			received: expected,
+			message,
+			isInline: false,
+			properties,
+			errorMessage,
+			...getTestNames(test)
+		});
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
+		utils.flag(this, "_name", "toMatchFileSnapshot");
+		if (utils.flag(this, "negate")) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
+		const error = /* @__PURE__ */ new Error("resolves");
+		const expected = utils.flag(this, "object");
+		const test = getTest("toMatchFileSnapshot", this);
+		const errorMessage = utils.flag(this, "message");
+		return recordAsyncExpect(test, getSnapshotClient().assertRaw({
+			received: expected,
+			message,
+			isInline: false,
+			rawSnapshot: { file },
+			errorMessage,
+			...getTestNames(test)
+		}), createAssertionMessage(utils, this, true), error, utils.flag(this, "soft"));
+	});
+	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(properties, inlineSnapshot, message) {
+		utils.flag(this, "_name", "toMatchInlineSnapshot");
+		if (utils.flag(this, "negate")) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
+		const test = getTest("toMatchInlineSnapshot", this);
+		const expected = utils.flag(this, "object");
+		const error = utils.flag(this, "error");
+		if (typeof properties === "string") {
+			message = inlineSnapshot;
+			inlineSnapshot = properties;
+			properties = void 0;
+		}
+		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+		const errorMessage = utils.flag(this, "message");
+		getSnapshotClient().assert({
+			received: expected,
+			message,
+			isInline: true,
+			properties,
+			inlineSnapshot,
+			error,
+			errorMessage,
+			...getTestNames(test)
+		});
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(properties, message) {
+		utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
+		if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
+		const expected = utils.flag(this, "object");
+		const test = getTest("toThrowErrorMatchingSnapshot", this);
+		const promise = utils.flag(this, "promise");
+		const errorMessage = utils.flag(this, "message");
+		getSnapshotClient().assert({
+			received: getError(expected, promise),
+			message,
+			errorMessage,
+			...getTestNames(test)
+		});
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshot, message) {
+		if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
+		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
+		const expected = utils.flag(this, "object");
+		const error = utils.flag(this, "error");
+		const promise = utils.flag(this, "promise");
+		const errorMessage = utils.flag(this, "message");
+		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+		getSnapshotClient().assert({
+			received: getError(expected, promise),
+			message,
+			inlineSnapshot,
+			isInline: true,
+			error,
+			errorMessage,
+			...getTestNames(test)
+		});
+	}));
+	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+};
+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
+});
+/**
+* Gives access to injected context provided from the main thread.
+* This usually returns a value provided by `globalSetup` or an external library.
+*/
+function inject(key) {
+	return getWorkerState().providedContext[key];
+}
+var fakeTimersSrc = {};
+var global;
+var hasRequiredGlobal;
+function requireGlobal() {
+	if (hasRequiredGlobal) return global;
+	hasRequiredGlobal = 1;
+	/**
+	* A reference to the global object
+	* @type {object} globalObject
+	*/
+	var globalObject;
+	/* istanbul ignore else */
+	if (typeof commonjsGlobal !== "undefined") globalObject = commonjsGlobal;
+	else if (typeof window !== "undefined") globalObject = window;
+	else globalObject = self;
+	global = globalObject;
+	return global;
+}
+var throwsOnProto_1;
+var hasRequiredThrowsOnProto;
+function requireThrowsOnProto() {
+	if (hasRequiredThrowsOnProto) return throwsOnProto_1;
+	hasRequiredThrowsOnProto = 1;
+	/**
+	* Is true when the environment causes an error to be thrown for accessing the
+	* __proto__ property.
+	* This is necessary in order to support `node --disable-proto=throw`.
+	*
+	* See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
+	* @type {boolean}
+	*/
+	let throwsOnProto;
+	try {
+		({}).__proto__;
+		throwsOnProto = false;
+	} catch (_) {
+		/* istanbul ignore next */
+		throwsOnProto = true;
+	}
+	throwsOnProto_1 = throwsOnProto;
+	return throwsOnProto_1;
+}
+var copyPrototypeMethods;
+var hasRequiredCopyPrototypeMethods;
+function requireCopyPrototypeMethods() {
+	if (hasRequiredCopyPrototypeMethods) return copyPrototypeMethods;
+	hasRequiredCopyPrototypeMethods = 1;
+	var call = Function.call;
+	var throwsOnProto = requireThrowsOnProto();
+	var disallowedProperties = [
+		"size",
+		"caller",
+		"callee",
+		"arguments"
+	];
+	/* istanbul ignore next */
+	if (throwsOnProto) disallowedProperties.push("__proto__");
+	copyPrototypeMethods = function copyPrototypeMethods(prototype) {
+		return Object.getOwnPropertyNames(prototype).reduce(function(result, name) {
+			if (disallowedProperties.includes(name)) return result;
+			if (typeof prototype[name] !== "function") return result;
+			result[name] = call.bind(prototype[name]);
+			return result;
+		}, Object.create(null));
+	};
+	return copyPrototypeMethods;
+}
+var array;
+var hasRequiredArray;
+function requireArray() {
+	if (hasRequiredArray) return array;
+	hasRequiredArray = 1;
+	array = requireCopyPrototypeMethods()(Array.prototype);
+	return array;
+}
+var calledInOrder_1;
+var hasRequiredCalledInOrder;
+function requireCalledInOrder() {
+	if (hasRequiredCalledInOrder) return calledInOrder_1;
+	hasRequiredCalledInOrder = 1;
+	var every = requireArray().every;
+	/**
+	* @private
+	*/
+	function hasCallsLeft(callMap, spy) {
+		if (callMap[spy.id] === void 0) callMap[spy.id] = 0;
+		return callMap[spy.id] < spy.callCount;
+	}
+	/**
+	* @private
+	*/
+	function checkAdjacentCalls(callMap, spy, index, spies) {
+		var calledBeforeNext = true;
+		if (index !== spies.length - 1) calledBeforeNext = spy.calledBefore(spies[index + 1]);
+		if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
+			callMap[spy.id] += 1;
+			return true;
+		}
+		return false;
+	}
+	/**
+	* A Sinon proxy object (fake, spy, stub)
+	* @typedef {object} SinonProxy
+	* @property {Function} calledBefore - A method that determines if this proxy was called before another one
+	* @property {string} id - Some id
+	* @property {number} callCount - Number of times this proxy has been called
+	*/
+	/**
+	* Returns true when the spies have been called in the order they were supplied in
+	* @param  {SinonProxy[] | SinonProxy} spies An array of proxies, or several proxies as arguments
+	* @returns {boolean} true when spies are called in order, false otherwise
+	*/
+	function calledInOrder(spies) {
+		return every(arguments.length > 1 ? arguments : spies, checkAdjacentCalls.bind(null, {}));
+	}
+	calledInOrder_1 = calledInOrder;
+	return calledInOrder_1;
+}
+var className_1;
+var hasRequiredClassName;
+function requireClassName() {
+	if (hasRequiredClassName) return className_1;
+	hasRequiredClassName = 1;
+	/**
+	* Returns a display name for a value from a constructor
+	* @param  {object} value A value to examine
+	* @returns {(string|null)} A string or null
+	*/
+	function className(value) {
+		return value.constructor && value.constructor.name || null;
+	}
+	className_1 = className;
+	return className_1;
+}
+var deprecated = {};
+var hasRequiredDeprecated;
+function requireDeprecated() {
+	if (hasRequiredDeprecated) return deprecated;
+	hasRequiredDeprecated = 1;
+	(function(exports$1) {
+		/**
+		* Returns a function that will invoke the supplied function and print a
+		* deprecation warning to the console each time it is called.
+		* @param  {Function} func
+		* @param  {string} msg
+		* @returns {Function}
+		*/
+		exports$1.wrap = function(func, msg) {
+			var wrapped = function() {
+				exports$1.printWarning(msg);
+				return func.apply(this, arguments);
+			};
+			if (func.prototype) wrapped.prototype = func.prototype;
+			return wrapped;
+		};
+		/**
+		* Returns a string which can be supplied to `wrap()` to notify the user that a
+		* particular part of the sinon API has been deprecated.
+		* @param  {string} packageName
+		* @param  {string} funcName
+		* @returns {string}
+		*/
+		exports$1.defaultMsg = function(packageName, funcName) {
+			return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
+		};
+		/**
+		* Prints a warning on the console, when it exists
+		* @param  {string} msg
+		* @returns {undefined}
+		*/
+		exports$1.printWarning = function(msg) {
+			/* istanbul ignore next */
+			if (typeof process === "object" && process.emitWarning) process.emitWarning(msg);
+			else if (console.info) console.info(msg);
+			else console.log(msg);
+		};
+	})(deprecated);
+	return deprecated;
+}
+var every;
+var hasRequiredEvery;
+function requireEvery() {
+	if (hasRequiredEvery) return every;
+	hasRequiredEvery = 1;
+	/**
+	* Returns true when fn returns true for all members of obj.
+	* This is an every implementation that works for all iterables
+	* @param  {object}   obj
+	* @param  {Function} fn
+	* @returns {boolean}
+	*/
+	every = function every(obj, fn) {
+		var pass = true;
+		try {
+			obj.forEach(function() {
+				if (!fn.apply(this, arguments)) throw new Error();
+			});
+		} catch (e) {
+			pass = false;
+		}
+		return pass;
+	};
+	return every;
+}
+var functionName;
+var hasRequiredFunctionName;
+function requireFunctionName() {
+	if (hasRequiredFunctionName) return functionName;
+	hasRequiredFunctionName = 1;
+	/**
+	* Returns a display name for a function
+	* @param  {Function} func
+	* @returns {string}
+	*/
+	functionName = function functionName(func) {
+		if (!func) return "";
+		try {
+			return func.displayName || func.name || (String(func).match(/function ([^\s(]+)/) || [])[1];
+		} catch (e) {
+			return "";
+		}
+	};
+	return functionName;
+}
+var orderByFirstCall_1;
+var hasRequiredOrderByFirstCall;
+function requireOrderByFirstCall() {
+	if (hasRequiredOrderByFirstCall) return orderByFirstCall_1;
+	hasRequiredOrderByFirstCall = 1;
+	var sort = requireArray().sort;
+	var slice = requireArray().slice;
+	/**
+	* @private
+	*/
+	function comparator(a, b) {
+		var aCall = a.getCall(0);
+		var bCall = b.getCall(0);
+		return (aCall && aCall.callId || -1) < (bCall && bCall.callId || -1) ? -1 : 1;
+	}
+	/**
+	* A Sinon proxy object (fake, spy, stub)
+	* @typedef {object} SinonProxy
+	* @property {Function} getCall - A method that can return the first call
+	*/
+	/**
+	* Sorts an array of SinonProxy instances (fake, spy, stub) by their first call
+	* @param  {SinonProxy[] | SinonProxy} spies
+	* @returns {SinonProxy[]}
+	*/
+	function orderByFirstCall(spies) {
+		return sort(slice(spies), comparator);
+	}
+	orderByFirstCall_1 = orderByFirstCall;
+	return orderByFirstCall_1;
+}
+var _function;
+var hasRequired_function;
+function require_function() {
+	if (hasRequired_function) return _function;
+	hasRequired_function = 1;
+	_function = requireCopyPrototypeMethods()(Function.prototype);
+	return _function;
+}
+var map;
+var hasRequiredMap;
+function requireMap() {
+	if (hasRequiredMap) return map;
+	hasRequiredMap = 1;
+	map = requireCopyPrototypeMethods()(Map.prototype);
+	return map;
+}
+var object;
+var hasRequiredObject;
+function requireObject() {
+	if (hasRequiredObject) return object;
+	hasRequiredObject = 1;
+	object = requireCopyPrototypeMethods()(Object.prototype);
+	return object;
+}
+var set;
+var hasRequiredSet;
+function requireSet() {
+	if (hasRequiredSet) return set;
+	hasRequiredSet = 1;
+	set = requireCopyPrototypeMethods()(Set.prototype);
+	return set;
+}
+var string;
+var hasRequiredString;
+function requireString() {
+	if (hasRequiredString) return string;
+	hasRequiredString = 1;
+	string = requireCopyPrototypeMethods()(String.prototype);
+	return string;
+}
+var prototypes;
+var hasRequiredPrototypes;
+function requirePrototypes() {
+	if (hasRequiredPrototypes) return prototypes;
+	hasRequiredPrototypes = 1;
+	prototypes = {
+		array: requireArray(),
+		function: require_function(),
+		map: requireMap(),
+		object: requireObject(),
+		set: requireSet(),
+		string: requireString()
+	};
+	return prototypes;
+}
+var typeDetect$1 = { exports: {} };
+var typeDetect = typeDetect$1.exports;
+var hasRequiredTypeDetect;
+function requireTypeDetect() {
+	if (hasRequiredTypeDetect) return typeDetect$1.exports;
+	hasRequiredTypeDetect = 1;
+	(function(module, exports$1) {
+		(function(global, factory) {
+			module.exports = factory();
+		})(typeDetect, (function() {
+			var promiseExists = typeof Promise === "function";
+			var globalObject = typeof self === "object" ? self : commonjsGlobal;
+			var symbolExists = typeof Symbol !== "undefined";
+			var mapExists = typeof Map !== "undefined";
+			var setExists = typeof Set !== "undefined";
+			var weakMapExists = typeof WeakMap !== "undefined";
+			var weakSetExists = typeof WeakSet !== "undefined";
+			var dataViewExists = typeof DataView !== "undefined";
+			var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== "undefined";
+			var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== "undefined";
+			var setEntriesExists = setExists && typeof Set.prototype.entries === "function";
+			var mapEntriesExists = mapExists && typeof Map.prototype.entries === "function";
+			var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Set()).entries());
+			var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Map()).entries());
+			var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === "function";
+			var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
+			var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === "function";
+			var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]());
+			var toStringLeftSliceLength = 8;
+			var toStringRightSliceLength = -1;
+			/**
+			* ### typeOf (obj)
+			*
+			* Uses `Object.prototype.toString` to determine the type of an object,
+			* normalising behaviour across engine versions & well optimised.
+			*
+			* @param {Mixed} object
+			* @return {String} object type
+			* @api public
+			*/
+			function typeDetect(obj) {
+				var typeofObj = typeof obj;
+				if (typeofObj !== "object") return typeofObj;
+				if (obj === null) return "null";
+				if (obj === globalObject) return "global";
+				if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) return "Array";
+				if (typeof window === "object" && window !== null) {
+					if (typeof window.location === "object" && obj === window.location) return "Location";
+					if (typeof window.document === "object" && obj === window.document) return "Document";
+					if (typeof window.navigator === "object") {
+						if (typeof window.navigator.mimeTypes === "object" && obj === window.navigator.mimeTypes) return "MimeTypeArray";
+						if (typeof window.navigator.plugins === "object" && obj === window.navigator.plugins) return "PluginArray";
+					}
+					if ((typeof window.HTMLElement === "function" || typeof window.HTMLElement === "object") && obj instanceof window.HTMLElement) {
+						if (obj.tagName === "BLOCKQUOTE") return "HTMLQuoteElement";
+						if (obj.tagName === "TD") return "HTMLTableDataCellElement";
+						if (obj.tagName === "TH") return "HTMLTableHeaderCellElement";
+					}
+				}
+				var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
+				if (typeof stringTag === "string") return stringTag;
+				var objPrototype = Object.getPrototypeOf(obj);
+				if (objPrototype === RegExp.prototype) return "RegExp";
+				if (objPrototype === Date.prototype) return "Date";
+				if (promiseExists && objPrototype === Promise.prototype) return "Promise";
+				if (setExists && objPrototype === Set.prototype) return "Set";
+				if (mapExists && objPrototype === Map.prototype) return "Map";
+				if (weakSetExists && objPrototype === WeakSet.prototype) return "WeakSet";
+				if (weakMapExists && objPrototype === WeakMap.prototype) return "WeakMap";
+				if (dataViewExists && objPrototype === DataView.prototype) return "DataView";
+				if (mapExists && objPrototype === mapIteratorPrototype) return "Map Iterator";
+				if (setExists && objPrototype === setIteratorPrototype) return "Set Iterator";
+				if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) return "Array Iterator";
+				if (stringIteratorExists && objPrototype === stringIteratorPrototype) return "String Iterator";
+				if (objPrototype === null) return "Object";
+				return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
+			}
+			return typeDetect;
+		}));
+	})(typeDetect$1);
+	return typeDetect$1.exports;
+}
+var typeOf;
+var hasRequiredTypeOf;
+function requireTypeOf() {
+	if (hasRequiredTypeOf) return typeOf;
+	hasRequiredTypeOf = 1;
+	var type = requireTypeDetect();
+	/**
+	* Returns the lower-case result of running type from type-detect on the value
+	* @param  {*} value
+	* @returns {string}
+	*/
+	typeOf = function typeOf(value) {
+		return type(value).toLowerCase();
+	};
+	return typeOf;
+}
+var valueToString_1;
+var hasRequiredValueToString;
+function requireValueToString() {
+	if (hasRequiredValueToString) return valueToString_1;
+	hasRequiredValueToString = 1;
+	/**
+	* Returns a string representation of the value
+	* @param  {*} value
+	* @returns {string}
+	*/
+	function valueToString(value) {
+		if (value && value.toString) return value.toString();
+		return String(value);
+	}
+	valueToString_1 = valueToString;
+	return valueToString_1;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	lib = {
+		global: requireGlobal(),
+		calledInOrder: requireCalledInOrder(),
+		className: requireClassName(),
+		deprecated: requireDeprecated(),
+		every: requireEvery(),
+		functionName: requireFunctionName(),
+		orderByFirstCall: requireOrderByFirstCall(),
+		prototypes: requirePrototypes(),
+		typeOf: requireTypeOf(),
+		valueToString: requireValueToString()
+	};
+	return lib;
+}
+var hasRequiredFakeTimersSrc;
+function requireFakeTimersSrc() {
+	if (hasRequiredFakeTimersSrc) return fakeTimersSrc;
+	hasRequiredFakeTimersSrc = 1;
+	const globalObject = requireLib().global;
+	let timersModule, timersPromisesModule;
+	if (typeof __vitest_required__ !== "undefined") {
+		try {
+			timersModule = __vitest_required__.timers;
+		} catch (e) {}
+		try {
+			timersPromisesModule = __vitest_required__.timersPromises;
+		} catch (e) {}
+	}
+	/**
+	* @typedef {"nextAsync" | "manual" | "interval"} TickMode
+	*/
+	/**
+	* @typedef {object} NextAsyncTickMode
+	* @property {"nextAsync"} mode
+	*/
+	/**
+	* @typedef {object} ManualTickMode
+	* @property {"manual"} mode
+	*/
+	/**
+	* @typedef {object} IntervalTickMode
+	* @property {"interval"} mode
+	* @property {number} [delta]
+	*/
+	/**
+	* @typedef {IntervalTickMode | NextAsyncTickMode | ManualTickMode} TimerTickMode
+	*/
+	/**
+	* @typedef {object} IdleDeadline
+	* @property {boolean} didTimeout - whether or not the callback was called before reaching the optional timeout
+	* @property {function():number} timeRemaining - a floating-point value providing an estimate of the number of milliseconds remaining in the current idle period
+	*/
+	/**
+	* Queues a function to be called during a browser's idle periods
+	* @callback RequestIdleCallback
+	* @param {function(IdleDeadline)} callback
+	* @param {{timeout: number}} options - an options object
+	* @returns {number} the id
+	*/
+	/**
+	* @callback NextTick
+	* @param {VoidVarArgsFunc} callback - the callback to run
+	* @param {...*} args - optional arguments to call the callback with
+	* @returns {void}
+	*/
+	/**
+	* @callback SetImmediate
+	* @param {VoidVarArgsFunc} callback - the callback to run
+	* @param {...*} args - optional arguments to call the callback with
+	* @returns {NodeImmediate}
+	*/
+	/**
+	* @callback VoidVarArgsFunc
+	* @param {...*} callback - the callback to run
+	* @returns {void}
+	*/
+	/**
+	* @typedef RequestAnimationFrame
+	* @property {function(number):void} requestAnimationFrame
+	* @returns {number} - the id
+	*/
+	/**
+	* @typedef Performance
+	* @property {function(): number} now
+	*/
+	/**
+	* @typedef {object} Clock
+	* @property {number} now - the current time
+	* @property {Date} Date - the Date constructor
+	* @property {number} loopLimit - the maximum number of timers before assuming an infinite loop
+	* @property {RequestIdleCallback} requestIdleCallback
+	* @property {function(number):void} cancelIdleCallback
+	* @property {setTimeout} setTimeout
+	* @property {clearTimeout} clearTimeout
+	* @property {NextTick} nextTick
+	* @property {queueMicrotask} queueMicrotask
+	* @property {setInterval} setInterval
+	* @property {clearInterval} clearInterval
+	* @property {SetImmediate} setImmediate
+	* @property {function(NodeImmediate):void} clearImmediate
+	* @property {function():number} countTimers
+	* @property {RequestAnimationFrame} requestAnimationFrame
+	* @property {function(number):void} cancelAnimationFrame
+	* @property {function():void} runMicrotasks
+	* @property {function(string | number): number} tick
+	* @property {function(string | number): Promise<number>} tickAsync
+	* @property {function(): number} next
+	* @property {function(): Promise<number>} nextAsync
+	* @property {function(): number} runAll
+	* @property {function(): number} runToFrame
+	* @property {function(): Promise<number>} runAllAsync
+	* @property {function(): number} runToLast
+	* @property {function(): Promise<number>} runToLastAsync
+	* @property {function(): void} reset
+	* @property {function(number | Date): void} setSystemTime
+	* @property {function(number): void} jump
+	* @property {Performance} performance
+	* @property {function(number[]): number[]} hrtime - process.hrtime (legacy)
+	* @property {function(): void} uninstall Uninstall the clock.
+	* @property {Function[]} methods - the methods that are faked
+	* @property {boolean} [shouldClearNativeTimers] inherited from config
+	* @property {{methodName:string, original:any}[] | undefined} timersModuleMethods
+	* @property {{methodName:string, original:any}[] | undefined} timersPromisesModuleMethods
+	* @property {Map<function(): void, AbortSignal>} abortListenerMap
+	* @property {function(TimerTickMode): void} setTickMode
+	*/
+	/**
+	* Configuration object for the `install` method.
+	* @typedef {object} Config
+	* @property {number|Date} [now] a number (in milliseconds) or a Date object (default epoch)
+	* @property {string[]} [toFake] names of the methods that should be faked.
+	* @property {number} [loopLimit] the maximum number of timers that will be run when calling runAll()
+	* @property {boolean} [shouldAdvanceTime] tells FakeTimers to increment mocked time automatically (default false)
+	* @property {number} [advanceTimeDelta] increment mocked time every <<advanceTimeDelta>> ms (default: 20ms)
+	* @property {boolean} [shouldClearNativeTimers] forwards clear timer calls to native functions if they are not fakes (default: false)
+	* @property {boolean} [ignoreMissingTimers] default is false, meaning asking to fake timers that are not present will throw an error
+	*/
+	/**
+	* The internal structure to describe a scheduled fake timer
+	* @typedef {object} Timer
+	* @property {Function} func
+	* @property {*[]} args
+	* @property {number} delay
+	* @property {number} callAt
+	* @property {number} createdAt
+	* @property {boolean} immediate
+	* @property {number} id
+	* @property {Error} [error]
+	*/
+	/**
+	* A Node timer
+	* @typedef {object} NodeImmediate
+	* @property {function(): boolean} hasRef
+	* @property {function(): NodeImmediate} ref
+	* @property {function(): NodeImmediate} unref
+	*/
+	/**
+	* Mocks available features in the specified global namespace.
+	* @param {*} _global Namespace to mock (e.g. `window`)
+	* @returns {FakeTimers}
+	*/
+	function withGlobal(_global) {
+		const maxTimeout = Math.pow(2, 31) - 1;
+		const idCounterStart = 0xe8d4a51000;
+		const NOOP = function() {};
+		const NOOP_ARRAY = function() {
+			return [];
+		};
+		const isPresent = {};
+		let timeoutResult, addTimerReturnsObject = false;
+		if (_global.setTimeout) {
+			isPresent.setTimeout = true;
+			timeoutResult = _global.setTimeout(NOOP, 0);
+			addTimerReturnsObject = typeof timeoutResult === "object";
+		}
+		isPresent.clearTimeout = Boolean(_global.clearTimeout);
+		isPresent.setInterval = Boolean(_global.setInterval);
+		isPresent.clearInterval = Boolean(_global.clearInterval);
+		isPresent.hrtime = _global.process && typeof _global.process.hrtime === "function";
+		isPresent.hrtimeBigint = isPresent.hrtime && typeof _global.process.hrtime.bigint === "function";
+		isPresent.nextTick = _global.process && typeof _global.process.nextTick === "function";
+		const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
+		isPresent.performance = _global.performance && typeof _global.performance.now === "function";
+		const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
+		const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
+		isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+		isPresent.requestAnimationFrame = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
+		isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
+		isPresent.requestIdleCallback = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
+		isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
+		isPresent.setImmediate = _global.setImmediate && typeof _global.setImmediate === "function";
+		isPresent.clearImmediate = _global.clearImmediate && typeof _global.clearImmediate === "function";
+		isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
+		if (_global.clearTimeout) _global.clearTimeout(timeoutResult);
+		const NativeDate = _global.Date;
+		const NativeIntl = isPresent.Intl ? Object.defineProperties(Object.create(null), Object.getOwnPropertyDescriptors(_global.Intl)) : void 0;
+		let uniqueTimerId = idCounterStart;
+		if (NativeDate === void 0) throw new Error("The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)");
+		isPresent.Date = true;
+		/**
+		* The PerformanceEntry object encapsulates a single performance metric
+		* that is part of the browser's performance timeline.
+		*
+		* This is an object returned by the `mark` and `measure` methods on the Performance prototype
+		*/
+		class FakePerformanceEntry {
+			constructor(name, entryType, startTime, duration) {
+				this.name = name;
+				this.entryType = entryType;
+				this.startTime = startTime;
+				this.duration = duration;
+			}
+			toJSON() {
+				return JSON.stringify({ ...this });
+			}
+		}
+		/**
+		* @param {number} num
+		* @returns {boolean}
+		*/
+		function isNumberFinite(num) {
+			if (Number.isFinite) return Number.isFinite(num);
+			return isFinite(num);
+		}
+		let isNearInfiniteLimit = false;
+		/**
+		* @param {Clock} clock
+		* @param {number} i
+		*/
+		function checkIsNearInfiniteLimit(clock, i) {
+			if (clock.loopLimit && i === clock.loopLimit - 1) isNearInfiniteLimit = true;
+		}
+		/**
+		*
+		*/
+		function resetIsNearInfiniteLimit() {
+			isNearInfiniteLimit = false;
+		}
+		/**
+		* Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into
+		* number of milliseconds. This is used to support human-readable strings passed
+		* to clock.tick()
+		* @param {string} str
+		* @returns {number}
+		*/
+		function parseTime(str) {
+			if (!str) return 0;
+			const strings = str.split(":");
+			const l = strings.length;
+			let i = l;
+			let ms = 0;
+			let parsed;
+			if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) throw new Error("tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits");
+			while (i--) {
+				parsed = parseInt(strings[i], 10);
+				if (parsed >= 60) throw new Error(`Invalid time ${str}`);
+				ms += parsed * Math.pow(60, l - i - 1);
+			}
+			return ms * 1e3;
+		}
+		/**
+		* Get the decimal part of the millisecond value as nanoseconds
+		* @param {number} msFloat the number of milliseconds
+		* @returns {number} an integer number of nanoseconds in the range [0,1e6)
+		*
+		* Example: nanoRemainer(123.456789) -> 456789
+		*/
+		function nanoRemainder(msFloat) {
+			const modulo = 1e6;
+			const remainder = msFloat * 1e6 % modulo;
+			const positiveRemainder = remainder < 0 ? remainder + modulo : remainder;
+			return Math.floor(positiveRemainder);
+		}
+		/**
+		* Used to grok the `now` parameter to createClock.
+		* @param {Date|number} epoch the system time
+		* @returns {number}
+		*/
+		function getEpoch(epoch) {
+			if (!epoch) return 0;
+			if (typeof epoch.getTime === "function") return epoch.getTime();
+			if (typeof epoch === "number") return epoch;
+			throw new TypeError("now should be milliseconds since UNIX epoch");
+		}
+		/**
+		* @param {number} from
+		* @param {number} to
+		* @param {Timer} timer
+		* @returns {boolean}
+		*/
+		function inRange(from, to, timer) {
+			return timer && timer.callAt >= from && timer.callAt <= to;
+		}
+		/**
+		* @param {Clock} clock
+		* @param {Timer} job
+		*/
+		function getInfiniteLoopError(clock, job) {
+			const infiniteLoopError = /* @__PURE__ */ new Error(`Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`);
+			if (!job.error) return infiniteLoopError;
+			const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
+			let clockMethodPattern = new RegExp(String(Object.keys(clock).join("|")));
+			if (addTimerReturnsObject) clockMethodPattern = new RegExp(`\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`);
+			let matchedLineIndex = -1;
+			job.error.stack.split("\n").some(function(line, i) {
+				/* istanbul ignore if */
+				if (line.match(computedTargetPattern)) {
+					matchedLineIndex = i;
+					return true;
+				}
+				if (line.match(clockMethodPattern)) {
+					matchedLineIndex = i;
+					return false;
+				}
+				return matchedLineIndex >= 0;
+			});
+			const stack = `${infiniteLoopError}\n${job.type || "Microtask"} - ${job.func.name || "anonymous"}\n${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
+			try {
+				Object.defineProperty(infiniteLoopError, "stack", { value: stack });
+			} catch (e) {}
+			return infiniteLoopError;
+		}
+		function createDate() {
+			class ClockDate extends NativeDate {
+				/**
+				* @param {number} year
+				* @param {number} month
+				* @param {number} date
+				* @param {number} hour
+				* @param {number} minute
+				* @param {number} second
+				* @param {number} ms
+				* @returns void
+				*/
+				constructor(year, month, date, hour, minute, second, ms) {
+					if (arguments.length === 0) super(ClockDate.clock.now);
+					else super(...arguments);
+					Object.defineProperty(this, "constructor", {
+						value: NativeDate,
+						enumerable: false
+					});
+				}
+				static [Symbol.hasInstance](instance) {
+					return instance instanceof NativeDate;
+				}
+			}
+			ClockDate.isFake = true;
+			if (NativeDate.now) ClockDate.now = function now() {
+				return ClockDate.clock.now;
+			};
+			if (NativeDate.toSource) ClockDate.toSource = function toSource() {
+				return NativeDate.toSource();
+			};
+			ClockDate.toString = function toString() {
+				return NativeDate.toString();
+			};
+			return new Proxy(ClockDate, { apply() {
+				if (this instanceof ClockDate) throw new TypeError("A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic.");
+				return new NativeDate(ClockDate.clock.now).toString();
+			} });
+		}
+		/**
+		* Mirror Intl by default on our fake implementation
+		*
+		* Most of the properties are the original native ones,
+		* but we need to take control of those that have a
+		* dependency on the current clock.
+		* @returns {object} the partly fake Intl implementation
+		*/
+		function createIntl() {
+			const ClockIntl = {};
+			Object.getOwnPropertyNames(NativeIntl).forEach((property) => ClockIntl[property] = NativeIntl[property]);
+			ClockIntl.DateTimeFormat = function(...args) {
+				const realFormatter = new NativeIntl.DateTimeFormat(...args);
+				const formatter = {};
+				[
+					"formatRange",
+					"formatRangeToParts",
+					"resolvedOptions"
+				].forEach((method) => {
+					formatter[method] = realFormatter[method].bind(realFormatter);
+				});
+				["format", "formatToParts"].forEach((method) => {
+					formatter[method] = function(date) {
+						return realFormatter[method](date || ClockIntl.clock.now);
+					};
+				});
+				return formatter;
+			};
+			ClockIntl.DateTimeFormat.prototype = Object.create(NativeIntl.DateTimeFormat.prototype);
+			ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf;
+			return ClockIntl;
+		}
+		function enqueueJob(clock, job) {
+			if (!clock.jobs) clock.jobs = [];
+			clock.jobs.push(job);
+		}
+		function runJobs(clock) {
+			if (!clock.jobs) return;
+			for (let i = 0; i < clock.jobs.length; i++) {
+				const job = clock.jobs[i];
+				job.func.apply(null, job.args);
+				checkIsNearInfiniteLimit(clock, i);
+				if (clock.loopLimit && i > clock.loopLimit) throw getInfiniteLoopError(clock, job);
+			}
+			resetIsNearInfiniteLimit();
+			clock.jobs = [];
+		}
+		/**
+		* @param {Clock} clock
+		* @param {Timer} timer
+		* @returns {number} id of the created timer
+		*/
+		function addTimer(clock, timer) {
+			if (timer.func === void 0) throw new Error("Callback must be provided to timer calls");
+			if (addTimerReturnsObject) {
+				if (typeof timer.func !== "function") throw new TypeError(`[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`);
+			}
+			if (isNearInfiniteLimit) timer.error = /* @__PURE__ */ new Error();
+			timer.type = timer.immediate ? "Immediate" : "Timeout";
+			if (timer.hasOwnProperty("delay")) {
+				if (typeof timer.delay !== "number") timer.delay = parseInt(timer.delay, 10);
+				if (!isNumberFinite(timer.delay)) timer.delay = 0;
+				timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
+				timer.delay = Math.max(0, timer.delay);
+			}
+			if (timer.hasOwnProperty("interval")) {
+				timer.type = "Interval";
+				timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
+			}
+			if (timer.hasOwnProperty("animation")) {
+				timer.type = "AnimationFrame";
+				timer.animation = true;
+			}
+			if (timer.hasOwnProperty("idleCallback")) {
+				timer.type = "IdleCallback";
+				timer.idleCallback = true;
+			}
+			if (!clock.timers) clock.timers = {};
+			timer.id = uniqueTimerId++;
+			timer.createdAt = clock.now;
+			timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+			clock.timers[timer.id] = timer;
+			if (addTimerReturnsObject) {
+				const res = {
+					refed: true,
+					ref: function() {
+						this.refed = true;
+						return res;
+					},
+					unref: function() {
+						this.refed = false;
+						return res;
+					},
+					hasRef: function() {
+						return this.refed;
+					},
+					refresh: function() {
+						timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+						clock.timers[timer.id] = timer;
+						return res;
+					},
+					[Symbol.toPrimitive]: function() {
+						return timer.id;
+					}
+				};
+				return res;
+			}
+			return timer.id;
+		}
+		/**
+		* Timer comparitor
+		* @param {Timer} a
+		* @param {Timer} b
+		* @returns {number}
+		*/
+		function compareTimers(a, b) {
+			if (a.callAt < b.callAt) return -1;
+			if (a.callAt > b.callAt) return 1;
+			if (a.immediate && !b.immediate) return -1;
+			if (!a.immediate && b.immediate) return 1;
+			if (a.createdAt < b.createdAt) return -1;
+			if (a.createdAt > b.createdAt) return 1;
+			if (a.id < b.id) return -1;
+			if (a.id > b.id) return 1;
+		}
+		/**
+		* @param {Clock} clock
+		* @param {number} from
+		* @param {number} to
+		* @returns {Timer}
+		*/
+		function firstTimerInRange(clock, from, to) {
+			const timers = clock.timers;
+			let timer = null;
+			let id, isInRange;
+			for (id in timers) if (timers.hasOwnProperty(id)) {
+				isInRange = inRange(from, to, timers[id]);
+				if (isInRange && (!timer || compareTimers(timer, timers[id]) === 1)) timer = timers[id];
+			}
+			return timer;
+		}
+		/**
+		* @param {Clock} clock
+		* @returns {Timer}
+		*/
+		function firstTimer(clock) {
+			const timers = clock.timers;
+			let timer = null;
+			let id;
+			for (id in timers) if (timers.hasOwnProperty(id)) {
+				if (!timer || compareTimers(timer, timers[id]) === 1) timer = timers[id];
+			}
+			return timer;
+		}
+		/**
+		* @param {Clock} clock
+		* @returns {Timer}
+		*/
+		function lastTimer(clock) {
+			const timers = clock.timers;
+			let timer = null;
+			let id;
+			for (id in timers) if (timers.hasOwnProperty(id)) {
+				if (!timer || compareTimers(timer, timers[id]) === -1) timer = timers[id];
+			}
+			return timer;
+		}
+		/**
+		* @param {Clock} clock
+		* @param {Timer} timer
+		*/
+		function callTimer(clock, timer) {
+			if (typeof timer.interval === "number") clock.timers[timer.id].callAt += timer.interval;
+			else delete clock.timers[timer.id];
+			if (typeof timer.func === "function") timer.func.apply(null, timer.args);
+			else {
+				const eval2 = eval;
+				(function() {
+					eval2(timer.func);
+				})();
+			}
+		}
+		/**
+		* Gets clear handler name for a given timer type
+		* @param {string} ttype
+		*/
+		function getClearHandler(ttype) {
+			if (ttype === "IdleCallback" || ttype === "AnimationFrame") return `cancel${ttype}`;
+			return `clear${ttype}`;
+		}
+		/**
+		* Gets schedule handler name for a given timer type
+		* @param {string} ttype
+		*/
+		function getScheduleHandler(ttype) {
+			if (ttype === "IdleCallback" || ttype === "AnimationFrame") return `request${ttype}`;
+			return `set${ttype}`;
+		}
+		/**
+		* Creates an anonymous function to warn only once
+		*/
+		function createWarnOnce() {
+			let calls = 0;
+			return function(msg) {
+				!calls++ && console.warn(msg);
+			};
+		}
+		const warnOnce = createWarnOnce();
+		/**
+		* @param {Clock} clock
+		* @param {number} timerId
+		* @param {string} ttype
+		*/
+		function clearTimer(clock, timerId, ttype) {
+			if (!timerId) return;
+			if (!clock.timers) clock.timers = {};
+			const id = Number(timerId);
+			if (Number.isNaN(id) || id < idCounterStart) {
+				const handlerName = getClearHandler(ttype);
+				if (clock.shouldClearNativeTimers === true) {
+					const nativeHandler = clock[`_${handlerName}`];
+					return typeof nativeHandler === "function" ? nativeHandler(timerId) : void 0;
+				}
+				warnOnce(`FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.
+To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`);
+			}
+			if (clock.timers.hasOwnProperty(id)) {
+				const timer = clock.timers[id];
+				if (timer.type === ttype || timer.type === "Timeout" && ttype === "Interval" || timer.type === "Interval" && ttype === "Timeout") delete clock.timers[id];
+				else {
+					const clear = getClearHandler(ttype);
+					const schedule = getScheduleHandler(timer.type);
+					throw new Error(`Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`);
+				}
+			}
+		}
+		/**
+		* @param {Clock} clock
+		* @returns {Timer[]}
+		*/
+		function uninstall(clock) {
+			let method, i, l;
+			const installedHrTime = "_hrtime";
+			const installedNextTick = "_nextTick";
+			for (i = 0, l = clock.methods.length; i < l; i++) {
+				method = clock.methods[i];
+				if (method === "hrtime" && _global.process) _global.process.hrtime = clock[installedHrTime];
+				else if (method === "nextTick" && _global.process) _global.process.nextTick = clock[installedNextTick];
+				else if (method === "performance") {
+					const originalPerfDescriptor = Object.getOwnPropertyDescriptor(clock, `_${method}`);
+					if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) Object.defineProperty(_global, method, originalPerfDescriptor);
+					else if (originalPerfDescriptor.configurable) _global[method] = clock[`_${method}`];
+				} else if (_global[method] && _global[method].hadOwnProperty) _global[method] = clock[`_${method}`];
+				else try {
+					delete _global[method];
+				} catch (ignore) {}
+				if (clock.timersModuleMethods !== void 0) for (let j = 0; j < clock.timersModuleMethods.length; j++) {
+					const entry = clock.timersModuleMethods[j];
+					timersModule[entry.methodName] = entry.original;
+				}
+				if (clock.timersPromisesModuleMethods !== void 0) for (let j = 0; j < clock.timersPromisesModuleMethods.length; j++) {
+					const entry = clock.timersPromisesModuleMethods[j];
+					timersPromisesModule[entry.methodName] = entry.original;
+				}
+			}
+			clock.setTickMode("manual");
+			clock.methods = [];
+			for (const [listener, signal] of clock.abortListenerMap.entries()) {
+				signal.removeEventListener("abort", listener);
+				clock.abortListenerMap.delete(listener);
+			}
+			if (!clock.timers) return [];
+			return Object.keys(clock.timers).map(function mapper(key) {
+				return clock.timers[key];
+			});
+		}
+		/**
+		* @param {object} target the target containing the method to replace
+		* @param {string} method the keyname of the method on the target
+		* @param {Clock} clock
+		*/
+		function hijackMethod(target, method, clock) {
+			clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
+			clock[`_${method}`] = target[method];
+			if (method === "Date") target[method] = clock[method];
+			else if (method === "Intl") target[method] = clock[method];
+			else if (method === "performance") {
+				const originalPerfDescriptor = Object.getOwnPropertyDescriptor(target, method);
+				if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
+					Object.defineProperty(clock, `_${method}`, originalPerfDescriptor);
+					const perfDescriptor = Object.getOwnPropertyDescriptor(clock, method);
+					Object.defineProperty(target, method, perfDescriptor);
+				} else target[method] = clock[method];
+			} else {
+				target[method] = function() {
+					return clock[method].apply(clock, arguments);
+				};
+				Object.defineProperties(target[method], Object.getOwnPropertyDescriptors(clock[method]));
+			}
+			target[method].clock = clock;
+		}
+		/**
+		* @param {Clock} clock
+		* @param {number} advanceTimeDelta
+		*/
+		function doIntervalTick(clock, advanceTimeDelta) {
+			clock.tick(advanceTimeDelta);
+		}
+		/**
+		* @typedef {object} Timers
+		* @property {setTimeout} setTimeout
+		* @property {clearTimeout} clearTimeout
+		* @property {setInterval} setInterval
+		* @property {clearInterval} clearInterval
+		* @property {Date} Date
+		* @property {Intl} Intl
+		* @property {SetImmediate=} setImmediate
+		* @property {function(NodeImmediate): void=} clearImmediate
+		* @property {function(number[]):number[]=} hrtime
+		* @property {NextTick=} nextTick
+		* @property {Performance=} performance
+		* @property {RequestAnimationFrame=} requestAnimationFrame
+		* @property {boolean=} queueMicrotask
+		* @property {function(number): void=} cancelAnimationFrame
+		* @property {RequestIdleCallback=} requestIdleCallback
+		* @property {function(number): void=} cancelIdleCallback
+		*/
+		/** @type {Timers} */
+		const timers = {
+			setTimeout: _global.setTimeout,
+			clearTimeout: _global.clearTimeout,
+			setInterval: _global.setInterval,
+			clearInterval: _global.clearInterval,
+			Date: _global.Date
+		};
+		if (isPresent.setImmediate) timers.setImmediate = _global.setImmediate;
+		if (isPresent.clearImmediate) timers.clearImmediate = _global.clearImmediate;
+		if (isPresent.hrtime) timers.hrtime = _global.process.hrtime;
+		if (isPresent.nextTick) timers.nextTick = _global.process.nextTick;
+		if (isPresent.performance) timers.performance = _global.performance;
+		if (isPresent.requestAnimationFrame) timers.requestAnimationFrame = _global.requestAnimationFrame;
+		if (isPresent.queueMicrotask) timers.queueMicrotask = _global.queueMicrotask;
+		if (isPresent.cancelAnimationFrame) timers.cancelAnimationFrame = _global.cancelAnimationFrame;
+		if (isPresent.requestIdleCallback) timers.requestIdleCallback = _global.requestIdleCallback;
+		if (isPresent.cancelIdleCallback) timers.cancelIdleCallback = _global.cancelIdleCallback;
+		if (isPresent.Intl) timers.Intl = NativeIntl;
+		const originalSetTimeout = _global.setImmediate || _global.setTimeout;
+		const originalClearInterval = _global.clearInterval;
+		const originalSetInterval = _global.setInterval;
+		/**
+		* @param {Date|number} [start] the system time - non-integer values are floored
+		* @param {number} [loopLimit] maximum number of timers that will be run when calling runAll()
+		* @returns {Clock}
+		*/
+		function createClock(start, loopLimit) {
+			start = Math.floor(getEpoch(start));
+			loopLimit = loopLimit || 1e3;
+			let nanos = 0;
+			const adjustedSystemTime = [0, 0];
+			const clock = {
+				now: start,
+				Date: createDate(),
+				loopLimit,
+				tickMode: {
+					mode: "manual",
+					counter: 0,
+					delta: void 0
+				}
+			};
+			clock.Date.clock = clock;
+			function getTimeToNextFrame() {
+				return 16 - (clock.now - start) % 16;
+			}
+			function hrtime(prev) {
+				const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
+				const secsSinceStart = Math.floor(millisSinceStart / 1e3);
+				const remainderInNanos = (millisSinceStart - secsSinceStart * 1e3) * 1e6 + nanos - adjustedSystemTime[1];
+				if (Array.isArray(prev)) {
+					if (prev[1] > 1e9) throw new TypeError("Number of nanoseconds can't exceed a billion");
+					const oldSecs = prev[0];
+					let nanoDiff = remainderInNanos - prev[1];
+					let secDiff = secsSinceStart - oldSecs;
+					if (nanoDiff < 0) {
+						nanoDiff += 1e9;
+						secDiff -= 1;
+					}
+					return [secDiff, nanoDiff];
+				}
+				return [secsSinceStart, remainderInNanos];
+			}
+			/**
+			* A high resolution timestamp in milliseconds.
+			* @typedef {number} DOMHighResTimeStamp
+			*/
+			/**
+			* performance.now()
+			* @returns {DOMHighResTimeStamp}
+			*/
+			function fakePerformanceNow() {
+				const hrt = hrtime();
+				return hrt[0] * 1e3 + hrt[1] / 1e6;
+			}
+			if (isPresent.hrtimeBigint) hrtime.bigint = function() {
+				const parts = hrtime();
+				return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
+			};
+			if (isPresent.Intl) {
+				clock.Intl = createIntl();
+				clock.Intl.clock = clock;
+			}
+			/**
+			* @param {TimerTickMode} tickModeConfig - The new configuration for how the clock should tick.
+			*/
+			clock.setTickMode = function(tickModeConfig) {
+				const { mode: newMode, delta: newDelta } = tickModeConfig;
+				const { mode: oldMode, delta: oldDelta } = clock.tickMode;
+				if (newMode === oldMode && newDelta === oldDelta) return;
+				if (oldMode === "interval") originalClearInterval(clock.attachedInterval);
+				clock.tickMode = {
+					counter: clock.tickMode.counter + 1,
+					mode: newMode,
+					delta: newDelta
+				};
+				if (newMode === "nextAsync") advanceUntilModeChanges();
+				else if (newMode === "interval") createIntervalTick(clock, newDelta || 20);
+			};
+			async function advanceUntilModeChanges() {
+				async function newMacrotask() {
+					const channel = new MessageChannel();
+					await new Promise((resolve) => {
+						channel.port1.onmessage = () => {
+							resolve();
+							channel.port1.close();
+						};
+						channel.port2.postMessage(void 0);
+					});
+					channel.port1.close();
+					channel.port2.close();
+					await new Promise((resolve) => {
+						originalSetTimeout(resolve);
+					});
+				}
+				const { counter } = clock.tickMode;
+				while (clock.tickMode.counter === counter) {
+					await newMacrotask();
+					if (clock.tickMode.counter !== counter) return;
+					clock.next();
+				}
+			}
+			function pauseAutoTickUntilFinished(promise) {
+				if (clock.tickMode.mode !== "nextAsync") return promise;
+				clock.setTickMode({ mode: "manual" });
+				return promise.finally(() => {
+					clock.setTickMode({ mode: "nextAsync" });
+				});
+			}
+			clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
+				let timeToNextIdlePeriod = 0;
+				if (clock.countTimers() > 0) timeToNextIdlePeriod = 50;
+				const result = addTimer(clock, {
+					func,
+					args: Array.prototype.slice.call(arguments, 2),
+					delay: typeof timeout === "undefined" ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod),
+					idleCallback: true
+				});
+				return Number(result);
+			};
+			clock.cancelIdleCallback = function cancelIdleCallback(timerId) {
+				return clearTimer(clock, timerId, "IdleCallback");
+			};
+			clock.setTimeout = function setTimeout(func, timeout) {
+				return addTimer(clock, {
+					func,
+					args: Array.prototype.slice.call(arguments, 2),
+					delay: timeout
+				});
+			};
+			if (typeof _global.Promise !== "undefined" && utilPromisify) clock.setTimeout[utilPromisify.custom] = function promisifiedSetTimeout(timeout, arg) {
+				return new _global.Promise(function setTimeoutExecutor(resolve) {
+					addTimer(clock, {
+						func: resolve,
+						args: [arg],
+						delay: timeout
+					});
+				});
+			};
+			clock.clearTimeout = function clearTimeout(timerId) {
+				return clearTimer(clock, timerId, "Timeout");
+			};
+			clock.nextTick = function nextTick(func) {
+				return enqueueJob(clock, {
+					func,
+					args: Array.prototype.slice.call(arguments, 1),
+					error: isNearInfiniteLimit ? /* @__PURE__ */ new Error() : null
+				});
+			};
+			clock.queueMicrotask = function queueMicrotask(func) {
+				return clock.nextTick(func);
+			};
+			clock.setInterval = function setInterval(func, timeout) {
+				timeout = parseInt(timeout, 10);
+				return addTimer(clock, {
+					func,
+					args: Array.prototype.slice.call(arguments, 2),
+					delay: timeout,
+					interval: timeout
+				});
+			};
+			clock.clearInterval = function clearInterval(timerId) {
+				return clearTimer(clock, timerId, "Interval");
+			};
+			if (isPresent.setImmediate) {
+				clock.setImmediate = function setImmediate(func) {
+					return addTimer(clock, {
+						func,
+						args: Array.prototype.slice.call(arguments, 1),
+						immediate: true
+					});
+				};
+				if (typeof _global.Promise !== "undefined" && utilPromisify) clock.setImmediate[utilPromisify.custom] = function promisifiedSetImmediate(arg) {
+					return new _global.Promise(function setImmediateExecutor(resolve) {
+						addTimer(clock, {
+							func: resolve,
+							args: [arg],
+							immediate: true
+						});
+					});
+				};
+				clock.clearImmediate = function clearImmediate(timerId) {
+					return clearTimer(clock, timerId, "Immediate");
+				};
+			}
+			clock.countTimers = function countTimers() {
+				return Object.keys(clock.timers || {}).length + (clock.jobs || []).length;
+			};
+			clock.requestAnimationFrame = function requestAnimationFrame(func) {
+				const result = addTimer(clock, {
+					func,
+					delay: getTimeToNextFrame(),
+					get args() {
+						return [fakePerformanceNow()];
+					},
+					animation: true
+				});
+				return Number(result);
+			};
+			clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {
+				return clearTimer(clock, timerId, "AnimationFrame");
+			};
+			clock.runMicrotasks = function runMicrotasks() {
+				runJobs(clock);
+			};
+			/**
+			* @param {number|string} tickValue milliseconds or a string parseable by parseTime
+			* @param {boolean} isAsync
+			* @param {Function} resolve
+			* @param {Function} reject
+			* @returns {number|undefined} will return the new `now` value or nothing for async
+			*/
+			function doTick(tickValue, isAsync, resolve, reject) {
+				const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue);
+				const ms = Math.floor(msFloat);
+				const remainder = nanoRemainder(msFloat);
+				let nanosTotal = nanos + remainder;
+				let tickTo = clock.now + ms;
+				if (msFloat < 0) throw new TypeError("Negative ticks are not supported");
+				if (nanosTotal >= 1e6) {
+					tickTo += 1;
+					nanosTotal -= 1e6;
+				}
+				nanos = nanosTotal;
+				let tickFrom = clock.now;
+				let previous = clock.now;
+				let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall;
+				clock.duringTick = true;
+				oldNow = clock.now;
+				runJobs(clock);
+				if (oldNow !== clock.now) {
+					tickFrom += clock.now - oldNow;
+					tickTo += clock.now - oldNow;
+				}
+				function doTickInner() {
+					timer = firstTimerInRange(clock, tickFrom, tickTo);
+					while (timer && tickFrom <= tickTo) {
+						if (clock.timers[timer.id]) {
+							tickFrom = timer.callAt;
+							clock.now = timer.callAt;
+							oldNow = clock.now;
+							try {
+								runJobs(clock);
+								callTimer(clock, timer);
+							} catch (e) {
+								firstException = firstException || e;
+							}
+							if (isAsync) {
+								originalSetTimeout(nextPromiseTick);
+								return;
+							}
+							compensationCheck();
+						}
+						postTimerCall();
+					}
+					oldNow = clock.now;
+					runJobs(clock);
+					if (oldNow !== clock.now) {
+						tickFrom += clock.now - oldNow;
+						tickTo += clock.now - oldNow;
+					}
+					clock.duringTick = false;
+					timer = firstTimerInRange(clock, tickFrom, tickTo);
+					if (timer) try {
+						clock.tick(tickTo - clock.now);
+					} catch (e) {
+						firstException = firstException || e;
+					}
+					else {
+						clock.now = tickTo;
+						nanos = nanosTotal;
+					}
+					if (firstException) throw firstException;
+					if (isAsync) resolve(clock.now);
+					else return clock.now;
+				}
+				nextPromiseTick = isAsync && function() {
+					try {
+						compensationCheck();
+						postTimerCall();
+						doTickInner();
+					} catch (e) {
+						reject(e);
+					}
+				};
+				compensationCheck = function() {
+					if (oldNow !== clock.now) {
+						tickFrom += clock.now - oldNow;
+						tickTo += clock.now - oldNow;
+						previous += clock.now - oldNow;
+					}
+				};
+				postTimerCall = function() {
+					timer = firstTimerInRange(clock, previous, tickTo);
+					previous = tickFrom;
+				};
+				return doTickInner();
+			}
+			/**
+			* @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+			* @returns {number} will return the new `now` value
+			*/
+			clock.tick = function tick(tickValue) {
+				return doTick(tickValue, false);
+			};
+			if (typeof _global.Promise !== "undefined")
+ /**
+			* @param {string|number} tickValue number of milliseconds or a human-readable value like "01:11:15"
+			* @returns {Promise}
+			*/
+			clock.tickAsync = function tickAsync(tickValue) {
+				return pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
+					originalSetTimeout(function() {
+						try {
+							doTick(tickValue, true, resolve, reject);
+						} catch (e) {
+							reject(e);
+						}
+					});
+				}));
+			};
+			clock.next = function next() {
+				runJobs(clock);
+				const timer = firstTimer(clock);
+				if (!timer) return clock.now;
+				clock.duringTick = true;
+				try {
+					clock.now = timer.callAt;
+					callTimer(clock, timer);
+					runJobs(clock);
+					return clock.now;
+				} finally {
+					clock.duringTick = false;
+				}
+			};
+			if (typeof _global.Promise !== "undefined") clock.nextAsync = function nextAsync() {
+				return pauseAutoTickUntilFinished(new _global.Promise(function(resolve, reject) {
+					originalSetTimeout(function() {
+						try {
+							const timer = firstTimer(clock);
+							if (!timer) {
+								resolve(clock.now);
+								return;
+							}
+							let err;
+							clock.duringTick = true;
+							clock.now = timer.callAt;
+							try {
+								callTimer(clock, timer);
+							} catch (e) {
+								err = e;
+							}
+							clock.duringTick = false;
+							originalSetTimeout(function() {
+								if (err) reject(err);
+								else resolve(clock.now);
+							});
+						} catch (e) {
+							reject(e);
+						}
+					});
+				}));
+			};
+			clock.runAll = function runAll() {
+				let numTimers, i;
+				runJobs(clock);
+				for (i = 0; i < clock.loopLimit; i++) {
+					if (!clock.timers) {
+						resetIsNearInfiniteLimit();
+						return clock.now;
+					}
+					numTimers = Object.keys(clock.timers).length;
+					if (numTimers === 0) {
+						resetIsNearInfiniteLimit();
+						return clock.now;
+					}
+					clock.next();
+					checkIsNearInfiniteLimit(clock, i);
+				}
+				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 {
+	constructor({ global, config }) {
+		this._now = RealDate.now;
+		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(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(/* @__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(/* @__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 || (_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(...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 vi = createVitest();
+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 || "";
+}
+var TestRunner = class {
+	constructor(config) {
+		this.snapshotClient = getSnapshotClient();
+		this.workerState = getWorkerState();
+		this.cancelRun = false;
+		this.assertionsErrors = /* @__PURE__ */ new WeakMap();
+		this.pool = this.workerState.ctx.pool;
+		this.trace = (name, attributes, cb) => {
+			const options = typeof attributes === "object" ? { attributes } : {};
+			return this._otel.$(`vitest.test.runner.${name}`, options, cb || attributes);
+		};
+		this.config = config;
+		const environment = this.workerState.environment;
+		this.viteEnvironment = environment.viteEnvironment || environment.name;
+		this.viteModuleRunner = config.experimental.viteModuleRunner;
+	}
+	importFile(filepath, source) {
+		if (source === "setup") {
+			const moduleNode = this.workerState.evaluatedModules.getModuleById(filepath);
+			if (moduleNode) this.workerState.evaluatedModules.invalidateModule(moduleNode);
+		}
+		return this._otel.$(`vitest.module.import_${source === "setup" ? "setup" : "spec"}`, { attributes: { "code.file.path": filepath } }, () => {
+			if (!this.viteModuleRunner) filepath = `${filepath}?vitest=${Date.now()}`;
+			return this.moduleRunner.import(filepath);
+		});
+	}
+	onCollectStart(file) {
+		this.workerState.current = file;
+	}
+	onCleanupWorkerContext(listener) {
+		this.workerState.onCleanup(listener);
+	}
+	onAfterRunFiles() {
+		this.snapshotClient.clear();
+		this.workerState.current = void 0;
+	}
+	async onAfterRunSuite(suite) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") suite.result.heap = process.memoryUsage().heapUsed;
+		if (suite.mode !== "skip" && "filepath" in suite) {
+			for (const test of getTests(suite)) if (test.mode === "skip") {
+				const name = getNames(test).slice(1).join(" > ");
+				this.snapshotClient.skipTest(suite.file.filepath, name);
+			}
+			const result = await this.snapshotClient.finish(suite.file.filepath);
+			if (this.workerState.config.snapshotOptions.updateSnapshot === "none" && result.unchecked) {
+				var _suite$result;
+				let message = `Obsolete snapshots found when no snapshot update is expected.\n`;
+				for (const key of result.uncheckedKeys) message += `· ${key}\n`;
+				(_suite$result = suite.result).errors ?? (_suite$result.errors = []);
+				suite.result.errors.push(processError(new Error(message)));
+				suite.result.state = "fail";
+			}
+			await rpc().snapshotSaved(result);
+		}
+		this.workerState.current = suite.suite || suite.file;
+	}
+	onAfterRunTask(test) {
+		if (this.config.logHeapUsage && typeof process !== "undefined") test.result.heap = process.memoryUsage().heapUsed;
+		this.workerState.current = test.suite || test.file;
+	}
+	cancel(_reason) {
+		this.cancelRun = true;
+	}
+	injectValue(key) {
+		return inject(key);
+	}
+	async onBeforeRunTask(test) {
+		if (this.cancelRun) test.mode = "skip";
+		if (test.mode !== "run" && test.mode !== "queued") return;
+		this.workerState.current = test;
+	}
+	async onBeforeRunSuite(suite) {
+		if (this.cancelRun) suite.mode = "skip";
+		if (suite.mode !== "skip" && "filepath" in suite) await this.snapshotClient.setup(suite.file.filepath, this.workerState.config.snapshotOptions);
+		this.workerState.current = suite;
+	}
+	onBeforeTryTask(test) {
+		clearModuleMocks(this.config);
+		this.snapshotClient.clearTest(test.file.filepath, test.id);
+		setState({
+			assertionCalls: 0,
+			isExpectingAssertions: false,
+			isExpectingAssertionsError: null,
+			expectedAssertionsNumber: null,
+			expectedAssertionsNumberErrorGen: null,
+			currentTestName: getTestName(test),
+			snapshotState: this.snapshotClient.getSnapshotState(test.file.filepath)
+		}, globalThis[GLOBAL_EXPECT]);
+	}
+	onAfterTryTask(test) {
+		const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberErrorGen, isExpectingAssertions, isExpectingAssertionsError } = test.context._local ? test.context.expect.getState() : getState(globalThis[GLOBAL_EXPECT]);
+		if (expectedAssertionsNumber !== null && assertionCalls !== expectedAssertionsNumber) throw expectedAssertionsNumberErrorGen();
+		if (isExpectingAssertions === true && assertionCalls === 0) throw isExpectingAssertionsError;
+		if (this.config.expect.requireAssertions && assertionCalls === 0) throw this.assertionsErrors.get(test);
+	}
+	extendTaskContext(context) {
+		if (this.config.expect.requireAssertions) this.assertionsErrors.set(context.task, /* @__PURE__ */ new Error("expected any number of assertion, but got none"));
+		let _expect;
+		Object.defineProperty(context, "expect", { get() {
+			if (!_expect) _expect = createExpect(context.task);
+			return _expect;
+		} });
+		Object.defineProperty(context, "_local", { get() {
+			return _expect != null;
+		} });
+		return context;
+	}
+	getImportDurations() {
+		const { limit } = this.config.experimental.importDurations;
+		if (limit === 0) return {};
+		const sortedEntries = [...this.workerState.moduleExecutionInfo?.entries() || []].sort(([, a], [, b]) => b.duration - a.duration).slice(0, limit);
+		const importDurations = {};
+		for (const [filepath, { duration, selfTime, external, importer }] of sortedEntries) importDurations[normalize(filepath)] = {
+			selfTime,
+			totalTime: duration,
+			external,
+			importer
+		};
+		return importDurations;
+	}
+	__setTraces(traces) {
+		this._otel = traces;
+	}
+};
+TestRunner.createTaskCollector = createTaskCollector;
+TestRunner.getCurrentSuite = getCurrentSuite;
+TestRunner.getCurrentTest = getCurrentTest;
+TestRunner.createChainable = createChainable;
+TestRunner.getSuiteHooks = getHooks;
+TestRunner.getTestFn = getFn;
+TestRunner.setSuiteHooks = getHooks;
+TestRunner.setTestFn = getFn;
+TestRunner.getBenchFn = getBenchFn;
+TestRunner.getBenchOptions = getBenchOptions;
+function clearModuleMocks(config) {
+	const { clearMocks, mockReset, restoreMocks, unstubEnvs, unstubGlobals } = config;
+	if (restoreMocks) vi.restoreAllMocks();
+	if (mockReset) vi.resetAllMocks();
+	if (clearMocks) vi.clearAllMocks();
+	if (unstubEnvs) vi.unstubAllEnvs();
+	if (unstubGlobals) vi.unstubAllGlobals();
+}
+//#endregion
+export { vi };
+
+//# sourceMappingURL=test.CTcmp4Su.js.map