import { assertTypes, createSimpleStackTrace } from "../../../../../@vitest_utils@3.2.4/node_modules/@vitest/utils/dist/helpers.js";
import { getSafeTimers } from "../../../../../@vitest_utils@3.2.4/node_modules/@vitest/utils/dist/index.js";
import { fn, isMockFunction, mocks, spyOn } from "../../../../../@vitest_spy@3.2.4/node_modules/@vitest/spy/dist/index.js";
import { Assertion, assert, expect, use, utils_exports } from "../../../../../chai@5.3.3/node_modules/chai/index.js";
import { ASYMMETRIC_MATCHERS_OBJECT, GLOBAL_EXPECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, addCustomEqualityTesters, customMatchers, equals, getState, iterableEquality, setState, subsetEquality } from "../../../../../@vitest_expect@3.2.4/node_modules/@vitest/expect/dist/index.js";
import { parseSingleStack } from "../../../../../@vitest_utils@3.2.4/node_modules/@vitest/utils/dist/source-map.js";
import { getCurrentTest, getNames, getTestName } from "../../../../../@vitest_runner@3.2.4/node_modules/@vitest/runner/dist/chunk-hooks.js";
import "../../../../../@vitest_runner@3.2.4/node_modules/@vitest/runner/dist/index.js";
import "../../../../../@vitest_runner@3.2.4/node_modules/@vitest/runner/dist/utils.js";
import { getCurrentEnvironment, getWorkerState, isChildProcess, resetModules, waitForImportsToResolve } from "./utils.XdZDrNZV.js";
import { commonjsGlobal, getDefaultExportFromCjs } from "./_commonjsHelpers.BFTU3MAI.js";
import { SnapshotClient, addSerializer, stripSnapshotIndentation } from "../../../../../@vitest_snapshot@3.2.4/node_modules/@vitest/snapshot/dist/index.js";
import { RealDate, mockDate, resetDate } from "./date.Bq6ZW5rf.js";

//#region ../../node_modules/.pnpm/vitest@3.2.4_@edge-runtime+vm@3.2.0_@types+debug@4.1.12_@types+node@20.19.27_jiti@2.6.1_fc26da61d3f761277fbc021fa297f7ea/node_modules/vitest/dist/chunks/vi.bdSIJ99Y.js
const unsupported = [
	"matchSnapshot",
	"toMatchSnapshot",
	"toMatchInlineSnapshot",
	"toThrowErrorMatchingSnapshot",
	"toThrowErrorMatchingInlineSnapshot",
	"throws",
	"Throw",
	"throw",
	"toThrow",
	"toThrowError"
];
function createExpectPoll(expect$1) {
	return function poll(fn$1, options = {}) {
		const defaults = getWorkerState().config.expect?.poll ?? {};
		const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
		const assertion = expect$1(null, message).withContext({ poll: true });
		fn$1 = fn$1.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 = () => new Promise((resolve, reject) => {
					let intervalId;
					let timeoutId;
					let lastError;
					const { setTimeout, clearTimeout } = getSafeTimers();
					const check = async () => {
						try {
							utils_exports.flag(assertion, "_name", key);
							const obj = await fn$1();
							utils_exports.flag(assertion, "object", obj);
							resolve(await assertionFunction.call(assertion, ...args));
							clearTimeout(intervalId);
							clearTimeout(timeoutId);
						} catch (err) {
							lastError = err;
							if (!utils_exports.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
						}
					};
					timeoutId = setTimeout(() => {
						clearTimeout(intervalId);
						utils_exports.flag(assertion, "_isLastPollAttempt", true);
						const rejectWithCause = (cause) => {
							reject(copyStackTrace$1(new Error("Matcher did not succeed in time.", { cause }), STACK_TRACE_ERROR));
						};
						check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
					}, timeout);
					check();
				});
				let awaited = false;
				test.onFinished ??= [];
				test.onFinished.push(() => {
					if (!awaited) {
						const negated = utils_exports.flag(assertion, "negate") ? "not." : "";
						const assertionString = `expect.${utils_exports.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
						throw copyStackTrace$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 ||= promise()).then(onFulfilled, onRejected);
					},
					catch(onRejected) {
						return (resultPromise ||= promise()).catch(onRejected);
					},
					finally(onFinally) {
						return (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;
}
function commonjsRequire(path) {
	throw new Error("Could not dynamically require \"" + path + "\". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.");
}
var chaiSubset$1 = { exports: {} };
var chaiSubset = chaiSubset$1.exports;
var hasRequiredChaiSubset;
function requireChaiSubset() {
	if (hasRequiredChaiSubset) return chaiSubset$1.exports;
	hasRequiredChaiSubset = 1;
	(function(module, exports) {
		(function() {
			(function(chaiSubset$2) {
				if (typeof commonjsRequire === "function" && true) return module.exports = chaiSubset$2;
				else return chai.use(chaiSubset$2);
			})(function(chai$1, utils) {
				var Assertion$1 = chai$1.Assertion;
				var assertionPrototype = Assertion$1.prototype;
				Assertion$1.addMethod("containSubset", function(expected) {
					var actual = utils.flag(this, "object");
					var showDiff = chai$1.config.showDiff;
					assertionPrototype.assert.call(this, compare(expected, actual), "expected #{act} to contain subset #{exp}", "expected #{act} to not contain subset #{exp}", expected, actual, showDiff);
				});
				chai$1.assert.containSubset = function(val, exp, msg) {
					new chai$1.Assertion(val, msg).to.be.containSubset(exp);
				};
				function compare(expected, actual) {
					if (expected === actual) return true;
					if (typeof actual !== typeof expected) return false;
					if (typeof expected !== "object" || expected === null) return expected === actual;
					if (!!expected && !actual) return false;
					if (Array.isArray(expected)) {
						if (typeof actual.length !== "number") return false;
						var aa = Array.prototype.slice.call(actual);
						return expected.every(function(exp) {
							return aa.some(function(act) {
								return compare(exp, act);
							});
						});
					}
					if (expected instanceof Date) if (actual instanceof Date) return expected.getTime() === actual.getTime();
					else return false;
					return Object.keys(expected).every(function(key) {
						var eo = expected[key];
						var ao = actual[key];
						if (typeof eo === "object" && eo !== null && ao !== null) return compare(eo, ao);
						if (typeof eo === "function") return eo(ao);
						return ao === eo;
					});
				}
			});
		}).call(chaiSubset);
	})(chaiSubset$1);
	return chaiSubset$1.exports;
}
var Subset = /* @__PURE__ */ getDefaultExportFromCjs(requireChaiSubset());
function createAssertionMessage(util, assertion, hasArgs) {
	const not = util.flag(assertion, "negate") ? "not." : "";
	const name = `${util.flag(assertion, "_name")}(expected)`;
	const promiseName = util.flag(assertion, "promise");
	return `expect(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
}
function recordAsyncExpect(_test, promise, assertion, error) {
	const test = _test;
	if (test && promise instanceof Promise) {
		promise = promise.finally(() => {
			if (!test.promises) return;
			const index = test.promises.indexOf(promise);
			if (index !== -1) test.promises.splice(index, 1);
		});
		if (!test.promises) test.promises = [];
		test.promises.push(promise);
		let resolved = false;
		test.onFinished ??= [];
		test.onFinished.push(() => {
			if (!resolved) {
				const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(error.stack);
				console.warn([
					`Promise returned by \`${assertion}\` was not awaited. `,
					"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
					"Please remember to await the assertion.\n",
					stack
				].join(""));
			}
		});
		return {
			then(onFulfilled, onRejected) {
				resolved = true;
				return promise.then(onFulfilled, onRejected);
			},
			catch(onRejected) {
				return promise.catch(onRejected);
			},
			finally(onFinally) {
				return promise.finally(onFinally);
			},
			[Symbol.toStringTag]: "Promise"
		};
	}
	return promise;
}
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$1, 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$1.Assertion.prototype, 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$1.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), error);
	});
	utils.addMethod(chai$1.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(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);
		if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
		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$1.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(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$1.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
		if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
		if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
		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$1.expect, "addSnapshotSerializer", addSerializer);
};
use(JestExtend);
use(JestChaiExpect);
use(Subset);
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$1 = expect(value, message);
		const _test = test || getCurrentTest();
		if (_test) return assert$1.withTest(_test);
		else return assert$1;
	};
	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,
		environment: getCurrentEnvironment(),
		get testPath() {
			return getWorkerState().filepath;
		},
		currentTestName: test ? getTestName(test) : globalState.currentTestName
	}, expect$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.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
});
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$1(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$1 = 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$1(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) {
		/**
		* Returns a function that will invoke the supplied function and print a
		* deprecation warning to the console each time it is called.
		* @param  {Function} func
		* @param  {string} msg
		* @returns {Function}
		*/
		exports.wrap = function(func, msg) {
			var wrapped = function() {
				exports.printWarning(msg);
				return func.apply(this, arguments);
			};
			if (func.prototype) wrapped.prototype = func.prototype;
			return wrapped;
		};
		/**
		* Returns a string which can be supplied to `wrap()` to notify the user that a
		* particular part of the sinon API has been deprecated.
		* @param  {string} packageName
		* @param  {string} funcName
		* @returns {string}
		*/
		exports.defaultMsg = function(packageName, funcName) {
			return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
		};
		/**
		* Prints a warning on the console, when it exists
		* @param  {string} msg
		* @returns {undefined}
		*/
		exports.printWarning = function(msg) {
			/* istanbul ignore next */
			if (typeof process === "object" && process.emitWarning) 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$1(obj, fn$1) {
		var pass = true;
		try {
			obj.forEach(function() {
				if (!fn$1.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$1(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) {
		(function(global$1, 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$2(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$2;
		}));
	})(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$1(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 {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
	*/
	/**
	* 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 = /* @__PURE__ */ 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$1 = clock.timers;
			let timer = null;
			let id, isInRange;
			for (id in timers$1) if (timers$1.hasOwnProperty(id)) {
				isInRange = inRange(from, to, timers$1[id]);
				if (isInRange && (!timer || compareTimers(timer, timers$1[id]) === 1)) timer = timers$1[id];
			}
			return timer;
		}
		/**
		* @param {Clock} clock
		* @returns {Timer}
		*/
		function firstTimer(clock) {
			const timers$1 = clock.timers;
			let timer = null;
			let id;
			for (id in timers$1) if (timers$1.hasOwnProperty(id)) {
				if (!timer || compareTimers(timer, timers$1[id]) === 1) timer = timers$1[id];
			}
			return timer;
		}
		/**
		* @param {Clock} clock
		* @returns {Timer}
		*/
		function lastTimer(clock) {
			const timers$1 = clock.timers;
			let timer = null;
			let id;
			for (id in timers$1) if (timers$1.hasOwnProperty(id)) {
				if (!timer || compareTimers(timer, timers$1[id]) === -1) timer = timers$1[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
		* @param {Config} config
		* @returns {Timer[]}
		*/
		function uninstall(clock, config) {
			let method, i, l;
			const installedHrTime = "_hrtime";
			const installedNextTick = "_nextTick";
			for (i = 0, l = clock.methods.length; i < l; i++) {
				method = clock.methods[i];
				if (method === "hrtime" && _global.process) _global.process.hrtime = clock[installedHrTime];
				else if (method === "nextTick" && _global.process) _global.process.nextTick = clock[installedNextTick];
				else if (method === "performance") {
					const originalPerfDescriptor = Object.getOwnPropertyDescriptor(clock, `_${method}`);
					if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) Object.defineProperty(_global, method, originalPerfDescriptor);
					else if (originalPerfDescriptor.configurable) _global[method] = clock[`_${method}`];
				} else if (_global[method] && _global[method].hadOwnProperty) _global[method] = clock[`_${method}`];
				else try {
					delete _global[method];
				} catch (ignore) {}
				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;
				}
			}
			if (config.shouldAdvanceTime === true) _global.clearInterval(clock.attachedInterval);
			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;
		/**
		* @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
			};
			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;
			}
			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 new _global.Promise(function(resolve, reject) {
					originalSetTimeout(function() {
						try {
							doTick(tickValue, true, resolve, reject);
						} catch (e) {
							reject(e);
						}
					});
				});
			};
			clock.next = function next() {
				runJobs(clock);
				const timer = firstTimer(clock);
				if (!timer) return clock.now;
				clock.duringTick = true;
				try {
					clock.now = timer.callAt;
					callTimer(clock, timer);
					runJobs(clock);
					return clock.now;
				} finally {
					clock.duringTick = false;
				}
			};
			if (typeof _global.Promise !== "undefined") clock.nextAsync = function nextAsync() {
				return new _global.Promise(function(resolve, reject) {
					originalSetTimeout(function() {
						try {
							const timer = firstTimer(clock);
							if (!timer) {
								resolve(clock.now);
								return;
							}
							let err;
							clock.duringTick = true;
							clock.now = timer.callAt;
							try {
								callTimer(clock, timer);
							} catch (e) {
								err = e;
							}
							clock.duringTick = false;
							originalSetTimeout(function() {
								if (err) reject(err);
								else resolve(clock.now);
							});
						} catch (e) {
							reject(e);
						}
					});
				});
			};
			clock.runAll = function runAll() {
				let numTimers, i;
				runJobs(clock);
				for (i = 0; i < clock.loopLimit; i++) {
					if (!clock.timers) {
						resetIsNearInfiniteLimit();
						return clock.now;
					}
					numTimers = Object.keys(clock.timers).length;
					if (numTimers === 0) {
						resetIsNearInfiniteLimit();
						return clock.now;
					}
					clock.next();
					checkIsNearInfiniteLimit(clock, i);
				}
				throw getInfiniteLoopError(clock, firstTimer(clock));
			};
			clock.runToFrame = function runToFrame() {
				return clock.tick(getTimeToNextFrame());
			};
			if (typeof _global.Promise !== "undefined") clock.runAllAsync = function runAllAsync() {
				return new _global.Promise(function(resolve, reject) {
					let i = 0;
					/**
					*
					*/
					function doRun() {
						originalSetTimeout(function() {
							try {
								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 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;
		}
		/**
		* @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, config);
			};
			clock.abortListenerMap = /* @__PURE__ */ new Map();
			clock.methods = config.toFake || [];
			if (clock.methods.length === 0) clock.methods = Object.keys(timers);
			if (config.shouldAdvanceTime === true) {
				const intervalTick = doIntervalTick.bind(null, clock, config.advanceTimeDelta);
				clock.attachedInterval = _global.setInterval(intervalTick, config.advanceTimeDelta);
			}
			if (clock.methods.includes("performance")) {
				const proto = (() => {
					if (hasPerformanceConstructorPrototype) return _global.performance.constructor.prototype;
					if (hasPerformancePrototype) return _global.Performance.prototype;
				})();
				if (proto) {
					Object.getOwnPropertyNames(proto).forEach(function(name) {
						if (name !== "now") clock.performance[name] = name.indexOf("getEntries") === 0 ? NOOP_ARRAY : NOOP;
					});
					clock.performance.mark = (name) => new FakePerformanceEntry(name, "mark", 0, 0);
					clock.performance.measure = (name) => new FakePerformanceEntry(name, "measure", 0, 100);
					clock.performance.timeOrigin = getEpoch(config.now);
				} else if ((config.toFake || []).includes("performance")) return handleMissingTimer("performance");
			}
			if (_global === globalObject && timersModule) clock.timersModuleMethods = [];
			if (_global === globalObject && timersPromisesModule) clock.timersPromisesModuleMethods = [];
			for (i = 0, l = clock.methods.length; i < l; i++) {
				const nameOfMethodToReplace = clock.methods[i];
				if (!isPresent[nameOfMethodToReplace]) {
					handleMissingTimer(nameOfMethodToReplace);
					continue;
				}
				if (nameOfMethodToReplace === "hrtime") {
					if (_global.process && typeof _global.process.hrtime === "function") hijackMethod(_global.process, nameOfMethodToReplace, clock);
				} else if (nameOfMethodToReplace === "nextTick") {
					if (_global.process && typeof _global.process.nextTick === "function") hijackMethod(_global.process, nameOfMethodToReplace, clock);
				} else hijackMethod(_global, nameOfMethodToReplace, clock);
				if (clock.timersModuleMethods !== void 0 && timersModule[nameOfMethodToReplace]) {
					const original = timersModule[nameOfMethodToReplace];
					clock.timersModuleMethods.push({
						methodName: nameOfMethodToReplace,
						original
					});
					timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
				}
				if (clock.timersPromisesModuleMethods !== void 0) {
					if (nameOfMethodToReplace === "setTimeout") {
						clock.timersPromisesModuleMethods.push({
							methodName: "setTimeout",
							original: timersPromisesModule.setTimeout
						});
						timersPromisesModule.setTimeout = (delay, value, options = {}) => new Promise((resolve, reject) => {
							const abort = () => {
								options.signal.removeEventListener("abort", abort);
								clock.abortListenerMap.delete(abort);
								clock.clearTimeout(handle);
								reject(options.signal.reason);
							};
							const handle = clock.setTimeout(() => {
								if (options.signal) {
									options.signal.removeEventListener("abort", abort);
									clock.abortListenerMap.delete(abort);
								}
								resolve(value);
							}, delay);
							if (options.signal) if (options.signal.aborted) abort();
							else {
								options.signal.addEventListener("abort", abort);
								clock.abortListenerMap.set(abort, options.signal);
							}
						});
					} else if (nameOfMethodToReplace === "setImmediate") {
						clock.timersPromisesModuleMethods.push({
							methodName: "setImmediate",
							original: timersPromisesModule.setImmediate
						});
						timersPromisesModule.setImmediate = (value, options = {}) => new Promise((resolve, reject) => {
							const abort = () => {
								options.signal.removeEventListener("abort", abort);
								clock.abortListenerMap.delete(abort);
								clock.clearImmediate(handle);
								reject(options.signal.reason);
							};
							const handle = clock.setImmediate(() => {
								if (options.signal) {
									options.signal.removeEventListener("abort", abort);
									clock.abortListenerMap.delete(abort);
								}
								resolve(value);
							});
							if (options.signal) if (options.signal.aborted) abort();
							else {
								options.signal.addEventListener("abort", abort);
								clock.abortListenerMap.set(abort, options.signal);
							}
						});
					} else if (nameOfMethodToReplace === "setInterval") {
						clock.timersPromisesModuleMethods.push({
							methodName: "setInterval",
							original: timersPromisesModule.setInterval
						});
						timersPromisesModule.setInterval = (delay, value, options = {}) => ({ [Symbol.asyncIterator]: () => {
							const createResolvable = () => {
								let resolve, reject;
								const promise = new Promise((res, rej) => {
									resolve = res;
									reject = rej;
								});
								promise.resolve = resolve;
								promise.reject = reject;
								return promise;
							};
							let done = false;
							let hasThrown = false;
							let returnCall;
							let nextAvailable = 0;
							const nextQueue = [];
							const handle = clock.setInterval(() => {
								if (nextQueue.length > 0) nextQueue.shift().resolve();
								else nextAvailable++;
							}, delay);
							const abort = () => {
								options.signal.removeEventListener("abort", abort);
								clock.abortListenerMap.delete(abort);
								clock.clearInterval(handle);
								done = true;
								for (const resolvable of nextQueue) resolvable.resolve();
							};
							if (options.signal) if (options.signal.aborted) done = true;
							else {
								options.signal.addEventListener("abort", abort);
								clock.abortListenerMap.set(abort, options.signal);
							}
							return {
								next: async () => {
									if (options.signal?.aborted && !hasThrown) {
										hasThrown = true;
										throw options.signal.reason;
									}
									if (done) return {
										done: true,
										value: void 0
									};
									if (nextAvailable > 0) {
										nextAvailable--;
										return {
											done: false,
											value
										};
									}
									const resolvable = createResolvable();
									nextQueue.push(resolvable);
									await resolvable;
									if (returnCall && nextQueue.length === 0) returnCall.resolve();
									if (options.signal?.aborted && !hasThrown) {
										hasThrown = true;
										throw options.signal.reason;
									}
									if (done) return {
										done: true,
										value: void 0
									};
									return {
										done: false,
										value
									};
								},
								return: async () => {
									if (done) return {
										done: true,
										value: void 0
									};
									if (nextQueue.length > 0) {
										returnCall = createResolvable();
										await returnCall;
									}
									clock.clearInterval(handle);
									done = true;
									if (options.signal) {
										options.signal.removeEventListener("abort", abort);
										clock.abortListenerMap.delete(abort);
									}
									return {
										done: true,
										value: void 0
									};
								}
							};
						} });
					}
				}
			}
			return clock;
		}
		return {
			timers,
			createClock,
			install,
			withGlobal
		};
	}
	/**
	* @typedef {object} FakeTimers
	* @property {Timers} timers
	* @property {createClock} createClock
	* @property {Function} install
	* @property {withGlobal} withGlobal
	*/
	/** @type {FakeTimers} */
	const defaultImplementation = withGlobal(globalObject);
	fakeTimersSrc.timers = defaultImplementation.timers;
	fakeTimersSrc.createClock = defaultImplementation.createClock;
	fakeTimersSrc.install = defaultImplementation.install;
	fakeTimersSrc.withGlobal = withGlobal;
	return fakeTimersSrc;
}
var fakeTimersSrcExports = requireFakeTimersSrc();
var FakeTimers = class {
	_global;
	_clock;
	_fakingTime;
	_fakingDate;
	_fakeTimers;
	_userConfig;
	_now = RealDate.now;
	constructor({ global: global$1, config }) {
		this._userConfig = config;
		this._fakingDate = null;
		this._fakingTime = false;
		this._fakeTimers = fakeTimersSrcExports.withGlobal(global$1);
		this._global = global$1;
	}
	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() {
		if (this._fakingDate) throw new Error("\"setSystemTime\" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.");
		if (!this._fakingTime) {
			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: Date.now(),
				...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;
	}
	configure(config) {
		this._userConfig = config;
	}
	isFakeTimers() {
		return this._fakingTime;
	}
	_checkFakeTimers() {
		if (!this._fakingTime) throw new Error("Timers are not mocked. Try calling \"vi.useFakeTimers()\" 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 workerState = getWorkerState();
	let _timers;
	const timers = () => _timers ||= new FakeTimers({
		global: globalThis,
		config: workerState.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") || workerState.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({
				...workerState.config.fakeTimers,
				...config
			});
			else timers().configure(workerState.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;
		},
		spyOn,
		fn,
		waitFor,
		waitUntil,
		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);
		},
		doUnmock(path) {
			if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
			_mocker().queueUnmock(path, getImporter("doUnmock"));
		},
		async importActual(path) {
			return _mocker().importActual(path, getImporter("importActual"), _mocker().getMockContext().callstack);
		},
		async importMock(path) {
			return _mocker().importMock(path, getImporter("importMock"));
		},
		mockObject(value) {
			return _mocker().mockObject({ value }).value;
		},
		mocked(item, _options = {}) {
			return item;
		},
		isMockFunction(fn$1) {
			return isMockFunction(fn$1);
		},
		clearAllMocks() {
			[...mocks].reverse().forEach((spy) => spy.mockClear());
			return utils;
		},
		resetAllMocks() {
			[...mocks].reverse().forEach((spy) => spy.mockReset());
			return utils;
		},
		restoreAllMocks() {
			[...mocks].reverse().forEach((spy) => spy.mockRestore());
			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) {
			if (!_stubsEnv.has(name)) _stubsEnv.set(name, process.env[name]);
			if (_envBooleans.includes(name)) process.env[name] = value ? "1" : "";
			else if (value === void 0) delete process.env[name];
			else process.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() {
			_stubsEnv.forEach((original, name) => {
				if (original === void 0) delete process.env[name];
				else process.env[name] = original;
			});
			_stubsEnv.clear();
			return utils;
		},
		resetModules() {
			resetModules(workerState.moduleCache);
			return utils;
		},
		async dynamicImportSettled() {
			return waitForImportsToResolve();
		},
		setConfig(config) {
			if (!_config) _config = { ...workerState.config };
			Object.assign(workerState.config, config);
		},
		resetConfig() {
			if (_config) Object.assign(workerState.config, _config);
		}
	};
	return utils;
}
const vitest = createVitest();
const vi = vitest;
function _mocker() {
	return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {
		throw new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);
	} });
}
function getImporter(name) {
	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n");
	return parseSingleStack(stackArray[stackArray.findIndex((stack) => {
		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
	}) + 1])?.file || "";
}

//#endregion
export { vi };