@venos-inc/venos 0.1.5 → 0.1.6

package/etc/mcp-server/node_modules/vitest/dist/chunks/{vi.DgezovHB.js → vi.bdSIJ99Y.js}

@@ -1,140 +1,109 @@
-import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters } from '@vitest/expect';
+import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
 import { getCurrentTest } from '@vitest/runner';
 import { getNames, getTestName } from '@vitest/runner/utils';
 import * as chai$1 from 'chai';
-import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, r as resetModules, w as waitForImportsToResolve } from './utils.C8RiOc4B.js';
+import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.XdZDrNZV.js';
 import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import '@vitest/utils/error';
+import { fn, spyOn, mocks, isMockFunction } from '@vitest/spy';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.W2xKR2qe.js';
-import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy';
+import { R as RealDate, r as resetDate, m as mockDate } from './date.Bq6ZW5rf.js';
 
+// these matchers are not supported because they don't make sense with poll
 const unsupported = [
-  // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't thow an error
-  // in this case using the `vi.waitFor` method is more appropriate
-  "matchSnapshot",
-  "toMatchSnapshot",
-  "toMatchInlineSnapshot",
-  "toThrowErrorMatchingSnapshot",
-  "toThrowErrorMatchingInlineSnapshot",
-  // toThrow will never succeed because we call the poll callback until it doesn't throw
-  "throws",
-  "Throw",
-  "throw",
-  "toThrow",
-  "toThrowError"
-  // these are not supported because you can call them without `.poll`,
-  // we throw an error inside the rejects/resolves methods to prevent this
-  // rejects,
-  // resolves
+	"matchSnapshot",
+	"toMatchSnapshot",
+	"toMatchInlineSnapshot",
+	"toThrowErrorMatchingSnapshot",
+	"toThrowErrorMatchingInlineSnapshot",
+	"throws",
+	"Throw",
+	"throw",
+	"toThrow",
+	"toThrowError"
 ];
 function createExpectPoll(expect) {
-  return function poll(fn, options = {}) {
-    const state = getWorkerState();
-    const defaults = state.config.expect?.poll ?? {};
-    const {
-      interval = defaults.interval ?? 50,
-      timeout = defaults.timeout ?? 1e3,
-      message
-    } = options;
-    const assertion = expect(null, message).withContext({
-      poll: true
-    });
-    fn = fn.bind(assertion);
-    const test = chai$1.util.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 chai$1.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 = new Error("STACK_TRACE_ERROR");
-          const promise = () => new Promise((resolve, reject) => {
-            let intervalId;
-            let lastError;
-            const { setTimeout, clearTimeout } = getSafeTimers();
-            const timeoutId = setTimeout(() => {
-              clearTimeout(intervalId);
-              reject(
-                copyStackTrace$1(
-                  new Error(`Matcher did not succeed in ${timeout}ms`, {
-                    cause: lastError
-                  }),
-                  STACK_TRACE_ERROR
-                )
-              );
-            }, timeout);
-            const check = async () => {
-              try {
-                chai$1.util.flag(assertion, "_name", key);
-                const obj = await fn();
-                chai$1.util.flag(assertion, "object", obj);
-                resolve(await assertionFunction.call(assertion, ...args));
-                clearTimeout(intervalId);
-                clearTimeout(timeoutId);
-              } catch (err) {
-                lastError = err;
-                intervalId = setTimeout(check, interval);
-              }
-            };
-            check();
-          });
-          let awaited = false;
-          test.onFinished ??= [];
-          test.onFinished.push(() => {
-            if (!awaited) {
-              const negated = chai$1.util.flag(assertion, "negate") ? "not." : "";
-              const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
-              const assertionString = `expect.${name}.${negated}${String(key)}()`;
-              const error = new Error(
-                `${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
-
-await ${assertionString}
-`
-              );
-              throw copyStackTrace$1(error, 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;
-  };
+	return function poll(fn, options = {}) {
+		const state = getWorkerState();
+		const defaults = state.config.expect?.poll ?? {};
+		const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+		// @ts-expect-error private poll access
+		const assertion = expect(null, message).withContext({ poll: true });
+		fn = fn.bind(assertion);
+		const test = chai$1.util.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 chai$1.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 = 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 {
+							chai$1.util.flag(assertion, "_name", key);
+							const obj = await fn();
+							chai$1.util.flag(assertion, "object", obj);
+							resolve(await assertionFunction.call(assertion, ...args));
+							clearTimeout(intervalId);
+							clearTimeout(timeoutId);
+						} catch (err) {
+							lastError = err;
+							if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
+						}
+					};
+					timeoutId = setTimeout(() => {
+						clearTimeout(intervalId);
+						chai$1.util.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 = chai$1.util.flag(assertion, "negate") ? "not." : "";
+						const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
+						const assertionString = `expect.${name}.${negated}${String(key)}()`;
+						const error = 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`);
+						throw copyStackTrace$1(error, STACK_TRACE_ERROR);
+					}
+				});
+				let resultPromise;
+				// only .then is enough to check awaited, but we type this as `Promise<void>` in global types
+				// so let's follow it
+				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;
+	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
+	return target;
 }
 
 function commonjsRequire(path) {
@@ -237,253 +206,191 @@ var chaiSubsetExports = requireChaiSubset();
 var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
 
 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");
-  const promise = promiseName ? `.${promiseName}` : "";
-  return `expect(actual)${promise}.${not}${name}`;
+	const not = util.flag(assertion, "negate") ? "not." : "";
+	const name = `${util.flag(assertion, "_name")}(${"expected" })`;
+	const promiseName = util.flag(assertion, "promise");
+	const promise = promiseName ? `.${promiseName}` : "";
+	return `expect(actual)${promise}.${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 processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
-        const stack = processor(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(onFullfilled, onRejected) {
-        resolved = true;
-        return promise.then(onFullfilled, onRejected);
-      },
-      catch(onRejected) {
-        return promise.catch(onRejected);
-      },
-      finally(onFinally) {
-        return promise.finally(onFinally);
-      },
-      [Symbol.toStringTag]: "Promise"
-    };
-  }
-  return promise;
+	const test = _test;
+	// record promise for test, that resolves before test ends
+	if (test && promise instanceof Promise) {
+		// if promise is explicitly awaited, remove it from the list
+		promise = promise.finally(() => {
+			if (!test.promises) return;
+			const index = test.promises.indexOf(promise);
+			if (index !== -1) test.promises.splice(index, 1);
+		});
+		// record promise
+		if (!test.promises) test.promises = [];
+		test.promises.push(promise);
+		let resolved = false;
+		test.onFinished ??= [];
+		test.onFinished.push(() => {
+			if (!resolved) {
+				const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
+				const stack = processor(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;
+	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");
+	if (typeof expected !== "function") {
+		if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
+		// when "promised", it receives thrown error
+		return expected;
+	}
+	try {
+		expected();
+	} catch (e) {
+		return e;
+	}
+	throw new Error("snapshot function didn't throw");
 }
 function getTestNames(test) {
-  if (!test) {
-    return {};
-  }
-  return {
-    filepath: test.file.filepath,
-    name: getNames(test).slice(1).join(" > ")
-  };
+	return {
+		filepath: test.file.filepath,
+		name: getNames(test).slice(1).join(" > "),
+		testId: test.id
+	};
 }
 const SnapshotPlugin = (chai, utils) => {
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-    utils.addMethod(
-      chai.Assertion.prototype,
-      key,
-      function(properties, message) {
-        utils.flag(this, "_name", key);
-        const isNot = utils.flag(this, "negate");
-        if (isNot) {
-          throw new Error(`${key} cannot be used with "not"`);
-        }
-        const expected = utils.flag(this, "object");
-        const test = utils.flag(this, "vitest-test");
-        if (typeof properties === "string" && typeof message === "undefined") {
-          message = properties;
-          properties = void 0;
-        }
-        const errorMessage = utils.flag(this, "message");
-        getSnapshotClient().assert({
-          received: expected,
-          message,
-          isInline: false,
-          properties,
-          errorMessage,
-          ...getTestNames(test)
-        });
-      }
-    );
-  }
-  utils.addMethod(
-    chai.Assertion.prototype,
-    "toMatchFileSnapshot",
-    function(file, message) {
-      utils.flag(this, "_name", "toMatchFileSnapshot");
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error('toMatchFileSnapshot cannot be used with "not"');
-      }
-      const error = new Error("resolves");
-      const expected = utils.flag(this, "object");
-      const test = utils.flag(this, "vitest-test");
-      const errorMessage = utils.flag(this, "message");
-      const promise = getSnapshotClient().assertRaw({
-        received: expected,
-        message,
-        isInline: false,
-        rawSnapshot: {
-          file
-        },
-        errorMessage,
-        ...getTestNames(test)
-      });
-      return recordAsyncExpect(
-        test,
-        promise,
-        createAssertionMessage(utils, this),
-        error
-      );
-    }
-  );
-  utils.addMethod(
-    chai.Assertion.prototype,
-    "toMatchInlineSnapshot",
-    function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-      utils.flag(this, "_name", "toMatchInlineSnapshot");
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error('toMatchInlineSnapshot cannot be used with "not"');
-      }
-      const test = utils.flag(this, "vitest-test");
-      const isInsideEach = test && (test.each || test.suite?.each);
-      if (isInsideEach) {
-        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.Assertion.prototype,
-    "toThrowErrorMatchingSnapshot",
-    function(message) {
-      utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error(
-          'toThrowErrorMatchingSnapshot cannot be used with "not"'
-        );
-      }
-      const expected = utils.flag(this, "object");
-      const test = utils.flag(this, "vitest-test");
-      const promise = utils.flag(this, "promise");
-      const errorMessage = utils.flag(this, "message");
-      getSnapshotClient().assert({
-        received: getError(expected, promise),
-        message,
-        errorMessage,
-        ...getTestNames(test)
-      });
-    }
-  );
-  utils.addMethod(
-    chai.Assertion.prototype,
-    "toThrowErrorMatchingInlineSnapshot",
-    function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
-      const isNot = utils.flag(this, "negate");
-      if (isNot) {
-        throw new Error(
-          'toThrowErrorMatchingInlineSnapshot cannot be used with "not"'
-        );
-      }
-      const test = utils.flag(this, "vitest-test");
-      const isInsideEach = test && (test.each || test.suite?.each);
-      if (isInsideEach) {
-        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.expect, "addSnapshotSerializer", addSerializer);
+	function getTest(assertionName, obj) {
+		const test = utils.flag(obj, "vitest-test");
+		if (!test) throw new Error(`'${assertionName}' cannot be used without test context`);
+		return test;
+	}
+	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
+		utils.flag(this, "_name", key);
+		const isNot = utils.flag(this, "negate");
+		if (isNot) throw new Error(`${key} cannot be used with "not"`);
+		const expected = utils.flag(this, "object");
+		const test = getTest(key, this);
+		if (typeof properties === "string" && typeof message === "undefined") {
+			message = properties;
+			properties = void 0;
+		}
+		const errorMessage = utils.flag(this, "message");
+		getSnapshotClient().assert({
+			received: expected,
+			message,
+			isInline: false,
+			properties,
+			errorMessage,
+			...getTestNames(test)
+		});
+	});
+	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
+		utils.flag(this, "_name", "toMatchFileSnapshot");
+		const isNot = utils.flag(this, "negate");
+		if (isNot) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
+		const error = new Error("resolves");
+		const expected = utils.flag(this, "object");
+		const test = getTest("toMatchFileSnapshot", this);
+		const errorMessage = utils.flag(this, "message");
+		const promise = getSnapshotClient().assertRaw({
+			received: expected,
+			message,
+			isInline: false,
+			rawSnapshot: { file },
+			errorMessage,
+			...getTestNames(test)
+		});
+		return recordAsyncExpect(test, promise, createAssertionMessage(utils, this), error);
+	});
+	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+		utils.flag(this, "_name", "toMatchInlineSnapshot");
+		const isNot = utils.flag(this, "negate");
+		if (isNot) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
+		const test = getTest("toMatchInlineSnapshot", this);
+		const isInsideEach = test.each || test.suite?.each;
+		if (isInsideEach) 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.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
+		utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
+		const isNot = utils.flag(this, "negate");
+		if (isNot) throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
+		const expected = utils.flag(this, "object");
+		const test = getTest("toThrowErrorMatchingSnapshot", this);
+		const promise = utils.flag(this, "promise");
+		const errorMessage = utils.flag(this, "message");
+		getSnapshotClient().assert({
+			received: getError(expected, promise),
+			message,
+			errorMessage,
+			...getTestNames(test)
+		});
+	});
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+		const isNot = utils.flag(this, "negate");
+		if (isNot) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
+		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
+		const isInsideEach = test.each || test.suite?.each;
+		if (isInsideEach) 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.expect, "addSnapshotSerializer", addSerializer);
 };
 
 chai$1.use(JestExtend);
@@ -493,83 +400,83 @@ chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
 
 function createExpect(test) {
-  const expect = (value, message) => {
-    const { assertionCalls } = getState(expect);
-    setState({ assertionCalls: assertionCalls + 1 }, expect);
-    const assert2 = chai$1.expect(value, message);
-    const _test = test || getCurrentTest();
-    if (_test) {
-      return assert2.withTest(_test);
-    } else {
-      return assert2;
-    }
-  };
-  Object.assign(expect, chai$1.expect);
-  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
-  expect.getState = () => getState(expect);
-  expect.setState = (state) => setState(state, expect);
-  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
-  setState(
-    {
-      // this should also add "snapshotState" that is added conditionally
-      ...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
-  );
-  expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
-  expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
-  expect.soft = (...args) => {
-    return expect(...args).withContext({ soft: true });
-  };
-  expect.poll = createExpectPoll(expect);
-  expect.unreachable = (message) => {
-    chai$1.assert.fail(
-      `expected${message ? ` "${message}" ` : " "}not to be reached`
-    );
-  };
-  function assertions(expected) {
-    const errorGen = () => new Error(
-      `expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`
-    );
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(errorGen(), assertions);
-    }
-    expect.setState({
-      expectedAssertionsNumber: expected,
-      expectedAssertionsNumberErrorGen: errorGen
-    });
-  }
-  function hasAssertions() {
-    const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(error, hasAssertions);
-    }
-    expect.setState({
-      isExpectingAssertions: true,
-      isExpectingAssertionsError: error
-    });
-  }
-  chai$1.util.addMethod(expect, "assertions", assertions);
-  chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
-  return expect;
+	const expect = (value, message) => {
+		const { assertionCalls } = getState(expect);
+		setState({ assertionCalls: assertionCalls + 1 }, expect);
+		const assert = chai$1.expect(value, message);
+		const _test = test || getCurrentTest();
+		if (_test)
+ // @ts-expect-error internal
+		return assert.withTest(_test);
+		else return assert;
+	};
+	Object.assign(expect, chai$1.expect);
+	Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+	expect.getState = () => getState(expect);
+	expect.setState = (state) => setState(state, expect);
+	// @ts-expect-error global is not typed
+	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);
+	// @ts-expect-error untyped
+	expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
+	expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+	expect.soft = (...args) => {
+		// @ts-expect-error private soft access
+		return expect(...args).withContext({ soft: true });
+	};
+	expect.poll = createExpectPoll(expect);
+	expect.unreachable = (message) => {
+		chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+	};
+	function assertions(expected) {
+		const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
+		if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
+		expect.setState({
+			expectedAssertionsNumber: expected,
+			expectedAssertionsNumberErrorGen: errorGen
+		});
+	}
+	function hasAssertions() {
+		const error = new Error("expected any number of assertion, but got none");
+		if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
+		expect.setState({
+			isExpectingAssertions: true,
+			isExpectingAssertionsError: error
+		});
+	}
+	chai$1.util.addMethod(expect, "assertions", assertions);
+	chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
+	expect.extend(customMatchers);
+	return expect;
 }
 const globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT, {
-  value: globalExpect,
-  writable: true,
-  configurable: true
+	value: globalExpect,
+	writable: true,
+	configurable: true
 });
 
+/**
+* Gives access to injected context provided from the main thread.
+* This usually returns a value provided by `globalSetup` or an external library.
+*/
+function inject(key) {
+	const workerState = getWorkerState();
+	return workerState.providedContext[key];
+}
+
 var fakeTimersSrc = {};
 
 var global;
@@ -581,7 +488,6 @@ function requireGlobal () {
 
 	/**
 	 * A reference to the global object
-	 *
 	 * @type {object} globalObject
 	 */
 	var globalObject;
@@ -612,11 +518,9 @@ function requireThrowsOnProto () {
 	/**
 	 * 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;
@@ -737,7 +641,6 @@ function requireCalledInOrder () {
 
 	/**
 	 * 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
@@ -746,7 +649,6 @@ function requireCalledInOrder () {
 
 	/**
 	 * 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
 	 */
@@ -762,43 +664,6 @@ function requireCalledInOrder () {
 	return calledInOrder_1;
 }
 
-var functionName;
-var hasRequiredFunctionName;
-
-function requireFunctionName () {
-	if (hasRequiredFunctionName) return functionName;
-	hasRequiredFunctionName = 1;
-
-	/**
-	 * Returns a display name for a function
-	 *
-	 * @param  {Function} func
-	 * @returns {string}
-	 */
-	functionName = function functionName(func) {
-	    if (!func) {
-	        return "";
-	    }
-
-	    try {
-	        return (
-	            func.displayName ||
-	            func.name ||
-	            // Use function decomposition as a last resort to get function
-	            // name. Does not rely on function decomposition to work - if it
-	            // doesn't debugging will be slightly less informative
-	            // (i.e. toString will say 'spy' rather than 'myFunc').
-	            (String(func).match(/function ([^\s(]+)/) || [])[1]
-	        );
-	    } catch (e) {
-	        // Stringify may fail and we might get an exception, as a last-last
-	        // resort fall back to empty string.
-	        return "";
-	    }
-	};
-	return functionName;
-}
-
 var className_1;
 var hasRequiredClassName;
 
@@ -806,28 +671,14 @@ function requireClassName () {
 	if (hasRequiredClassName) return className_1;
 	hasRequiredClassName = 1;
 
-	var functionName = requireFunctionName();
-
 	/**
 	 * 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) ||
-	        // The next branch is for IE11 support only:
-	        // Because the name property is not set on the prototype
-	        // of the Function object, we finally try to grab the
-	        // name from its definition. This will never be reached
-	        // in node, so we are not able to test this properly.
-	        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
-	        (typeof value.constructor === "function" &&
-	            /* istanbul ignore next */
-	            functionName(value.constructor)) ||
-	        null
-	    );
+	    const name = value.constructor && value.constructor.name;
+	    return name || null;
 	}
 
 	className_1 = className;
@@ -848,7 +699,6 @@ function requireDeprecated () {
 		/**
 		 * 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}
@@ -867,7 +717,6 @@ function requireDeprecated () {
 		/**
 		 * 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}
@@ -878,7 +727,6 @@ function requireDeprecated () {
 
 		/**
 		 * Prints a warning on the console, when it exists
-		 *
 		 * @param  {string} msg
 		 * @returns {undefined}
 		 */
@@ -907,7 +755,6 @@ function requireEvery () {
 	/**
 	 * 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}
@@ -932,6 +779,42 @@ function requireEvery () {
 	return every;
 }
 
+var functionName;
+var hasRequiredFunctionName;
+
+function requireFunctionName () {
+	if (hasRequiredFunctionName) return functionName;
+	hasRequiredFunctionName = 1;
+
+	/**
+	 * Returns a display name for a function
+	 * @param  {Function} func
+	 * @returns {string}
+	 */
+	functionName = function functionName(func) {
+	    if (!func) {
+	        return "";
+	    }
+
+	    try {
+	        return (
+	            func.displayName ||
+	            func.name ||
+	            // Use function decomposition as a last resort to get function
+	            // name. Does not rely on function decomposition to work - if it
+	            // doesn't debugging will be slightly less informative
+	            // (i.e. toString will say 'spy' rather than 'myFunc').
+	            (String(func).match(/function ([^\s(]+)/) || [])[1]
+	        );
+	    } catch (e) {
+	        // Stringify may fail and we might get an exception, as a last-last
+	        // resort fall back to empty string.
+	        return "";
+	    }
+	};
+	return functionName;
+}
+
 var orderByFirstCall_1;
 var hasRequiredOrderByFirstCall;
 
@@ -957,14 +840,12 @@ function requireOrderByFirstCall () {
 
 	/**
 	 * 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[]}
 	 */
@@ -1469,7 +1350,6 @@ function requireTypeOf () {
 
 	/**
 	 * Returns the lower-case result of running type from type-detect on the value
-	 *
 	 * @param  {*} value
 	 * @returns {string}
 	 */
@@ -1488,7 +1368,6 @@ function requireValueToString () {
 
 	/**
 	 * Returns a string representation of the value
-	 *
 	 * @param  {*} value
 	 * @returns {string}
 	 */
@@ -1533,13 +1412,18 @@ function requireFakeTimersSrc () {
 	hasRequiredFakeTimersSrc = 1;
 
 	const globalObject = requireLib().global;
-	let timersModule;
+	let timersModule, timersPromisesModule;
 	if (typeof __vitest_required__ !== 'undefined') {
 	    try {
 	        timersModule = __vitest_required__.timers;
 	    } catch (e) {
 	        // ignored
 	    }
+	    try {
+	        timersPromisesModule = __vitest_required__.timersPromises;
+	    } catch (e) {
+	        // ignored
+	    }
 	}
 
 	/**
@@ -1550,7 +1434,6 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * 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
@@ -1560,14 +1443,14 @@ function requireFakeTimersSrc () {
 	/**
 	 * @callback NextTick
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} arguments - optional arguments to call the callback with
+	 * @param {...*} args - optional arguments to call the callback with
 	 * @returns {void}
 	 */
 
 	/**
 	 * @callback SetImmediate
 	 * @param {VoidVarArgsFunc} callback - the callback to run
-	 * @param {...*} arguments - optional arguments to call the callback with
+	 * @param {...*} args - optional arguments to call the callback with
 	 * @returns {NodeImmediate}
 	 */
 
@@ -1626,12 +1509,13 @@ function requireFakeTimersSrc () {
 	 * @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
 	 */
 	/* eslint-enable jsdoc/require-property-description */
 
 	/**
 	 * 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.
@@ -1639,12 +1523,12 @@ function requireFakeTimersSrc () {
 	 * @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
 	 */
 
 	/* eslint-disable jsdoc/require-property-description */
 	/**
 	 * The internal structure to describe a scheduled fake timer
-	 *
 	 * @typedef {object} Timer
 	 * @property {Function} func
 	 * @property {*[]} args
@@ -1658,7 +1542,6 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * A Node timer
-	 *
 	 * @typedef {object} NodeImmediate
 	 * @property {function(): boolean} hasRef
 	 * @property {function(): NodeImmediate} ref
@@ -1670,7 +1553,6 @@ function requireFakeTimersSrc () {
 
 	/**
 	 * Mocks available features in the specified global namespace.
-	 *
 	 * @param {*} _global Namespace to mock (e.g. `window`)
 	 * @returns {FakeTimers}
 	 */
@@ -1683,16 +1565,26 @@ function requireFakeTimersSrc () {
 	    const NOOP_ARRAY = function () {
 	        return [];
 	    };
-	    const timeoutResult = _global.setTimeout(NOOP, 0);
-	    const addTimerReturnsObject = typeof timeoutResult === "object";
-	    const hrtimePresent =
+	    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";
-	    const hrtimeBigintPresent =
-	        hrtimePresent && typeof _global.process.hrtime.bigint === "function";
-	    const nextTickPresent =
+	    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;
-	    const performancePresent =
+	    isPresent.performance =
 	        _global.performance && typeof _global.performance.now === "function";
 	    const hasPerformancePrototype =
 	        _global.Performance &&
@@ -1701,29 +1593,65 @@ function requireFakeTimersSrc () {
 	        _global.performance &&
 	        _global.performance.constructor &&
 	        _global.performance.constructor.prototype;
-	    const queueMicrotaskPresent = _global.hasOwnProperty("queueMicrotask");
-	    const requestAnimationFramePresent =
+	    isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+	    isPresent.requestAnimationFrame =
 	        _global.requestAnimationFrame &&
 	        typeof _global.requestAnimationFrame === "function";
-	    const cancelAnimationFramePresent =
+	    isPresent.cancelAnimationFrame =
 	        _global.cancelAnimationFrame &&
 	        typeof _global.cancelAnimationFrame === "function";
-	    const requestIdleCallbackPresent =
+	    isPresent.requestIdleCallback =
 	        _global.requestIdleCallback &&
 	        typeof _global.requestIdleCallback === "function";
-	    const cancelIdleCallbackPresent =
+	    isPresent.cancelIdleCallbackPresent =
 	        _global.cancelIdleCallback &&
 	        typeof _global.cancelIdleCallback === "function";
-	    const setImmediatePresent =
+	    isPresent.setImmediate =
 	        _global.setImmediate && typeof _global.setImmediate === "function";
-	    const intlPresent = _global.Intl && typeof _global.Intl === "object";
+	    isPresent.clearImmediate =
+	        _global.clearImmediate && typeof _global.clearImmediate === "function";
+	    isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
 
-	    _global.clearTimeout(timeoutResult);
+	    if (_global.clearTimeout) {
+	        _global.clearTimeout(timeoutResult);
+	    }
 
 	    const NativeDate = _global.Date;
-	    const NativeIntl = _global.Intl;
+	    const NativeIntl = isPresent.Intl
+	        ? Object.defineProperties(
+	              Object.create(null),
+	              Object.getOwnPropertyDescriptors(_global.Intl),
+	          )
+	        : undefined;
 	    let uniqueTimerId = idCounterStart;
 
+	    if (NativeDate === undefined) {
+	        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}
@@ -1759,7 +1687,6 @@ function requireFakeTimersSrc () {
 	     * 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}
 	     */
@@ -1776,7 +1703,7 @@ function requireFakeTimersSrc () {
 
 	        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"
+	                "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits",
 	            );
 	        }
 
@@ -1795,7 +1722,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * 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)
 	     *
@@ -1812,7 +1738,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Used to grok the `now` parameter to createClock.
-	     *
 	     * @param {Date|number} epoch the system time
 	     * @returns {number}
 	     */
@@ -1845,7 +1770,7 @@ function requireFakeTimersSrc () {
 	     */
 	    function getInfiniteLoopError(clock, job) {
 	        const infiniteLoopError = new Error(
-	            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`
+	            `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`,
 	        );
 
 	        if (!job.error) {
@@ -1855,13 +1780,13 @@ function requireFakeTimersSrc () {
 	        // pattern never matched in Node
 	        const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
 	        let clockMethodPattern = new RegExp(
-	            String(Object.keys(clock).join("|"))
+	            String(Object.keys(clock).join("|")),
 	        );
 
 	        if (addTimerReturnsObject) {
 	            // node.js environment
 	            clockMethodPattern = new RegExp(
-	                `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`
+	                `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`,
 	            );
 	        }
 
@@ -1908,114 +1833,101 @@ function requireFakeTimersSrc () {
 	        return infiniteLoopError;
 	    }
 
-	    /**
-	     * @param {Date} target
-	     * @param {Date} source
-	     * @returns {Date} the target after modifications
-	     */
-	    function mirrorDateProperties(target, source) {
-	        let prop;
-	        for (prop in source) {
-	            if (source.hasOwnProperty(prop)) {
-	                target[prop] = source[prop];
+	    //eslint-disable-next-line jsdoc/require-jsdoc
+	    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
+	             */
+	            // eslint-disable-next-line no-unused-vars
+	            constructor(year, month, date, hour, minute, second, ms) {
+	                // Defensive and verbose to avoid potential harm in passing
+	                // explicit undefined when user does not pass argument
+	                if (arguments.length === 0) {
+	                    super(ClockDate.clock.now);
+	                } else {
+	                    super(...arguments);
+	                }
+
+	                // ensures identity checks using the constructor prop still works
+	                // this should have no other functional effect
+	                Object.defineProperty(this, "constructor", {
+	                    value: NativeDate,
+	                    enumerable: false,
+	                });
+	            }
+
+	            static [Symbol.hasInstance](instance) {
+	                return instance instanceof NativeDate;
 	            }
 	        }
 
-	        // set special now implementation
-	        if (source.now) {
-	            target.now = function now() {
-	                return target.clock.now;
+	        ClockDate.isFake = true;
+
+	        if (NativeDate.now) {
+	            ClockDate.now = function now() {
+	                return ClockDate.clock.now;
 	            };
-	        } else {
-	            delete target.now;
 	        }
 
-	        // set special toSource implementation
-	        if (source.toSource) {
-	            target.toSource = function toSource() {
-	                return source.toSource();
+	        if (NativeDate.toSource) {
+	            ClockDate.toSource = function toSource() {
+	                return NativeDate.toSource();
 	            };
-	        } else {
-	            delete target.toSource;
 	        }
 
-	        // set special toString implementation
-	        target.toString = function toString() {
-	            return source.toString();
+	        ClockDate.toString = function toString() {
+	            return NativeDate.toString();
 	        };
 
-	        target.prototype = source.prototype;
-	        target.parse = source.parse;
-	        target.UTC = source.UTC;
-	        target.prototype.toUTCString = source.prototype.toUTCString;
-	        target.isFake = true;
-
-	        return target;
-	    }
-
-	    //eslint-disable-next-line jsdoc/require-jsdoc
-	    function createDate() {
+	        // noinspection UnnecessaryLocalVariableJS
 	        /**
-	         * @param {number} year
-	         * @param {number} month
-	         * @param {number} date
-	         * @param {number} hour
-	         * @param {number} minute
-	         * @param {number} second
-	         * @param {number} ms
-	         * @returns {Date}
+	         * A normal Class constructor cannot be called without `new`, but Date can, so we need
+	         * to wrap it in a Proxy in order to ensure this functionality of Date is kept intact
+	         * @type {ClockDate}
 	         */
-	        function ClockDate(year, month, date, hour, minute, second, ms) {
-	            // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.
-	            // This remains so in the 10th edition of 2019 as well.
-	            if (!(this instanceof ClockDate)) {
-	                return new NativeDate(ClockDate.clock.now).toString();
-	            }
-
-	            // if Date is called as a constructor with 'new' keyword
-	            // Defensive and verbose to avoid potential harm in passing
-	            // explicit undefined when user does not pass argument
-	            switch (arguments.length) {
-	                case 0:
-	                    return new NativeDate(ClockDate.clock.now);
-	                case 1:
-	                    return new NativeDate(year);
-	                case 2:
-	                    return new NativeDate(year, month);
-	                case 3:
-	                    return new NativeDate(year, month, date);
-	                case 4:
-	                    return new NativeDate(year, month, date, hour);
-	                case 5:
-	                    return new NativeDate(year, month, date, hour, minute);
-	                case 6:
-	                    return new NativeDate(
-	                        year,
-	                        month,
-	                        date,
-	                        hour,
-	                        minute,
-	                        second
-	                    );
-	                default:
-	                    return new NativeDate(
-	                        year,
-	                        month,
-	                        date,
-	                        hour,
-	                        minute,
-	                        second,
-	                        ms
+	        const ClockDateProxy = new Proxy(ClockDate, {
+	            // handler for [[Call]] invocations (i.e. not using `new`)
+	            apply() {
+	                // the Date constructor called as a function, ref Ecma-262 Edition 5.1, section 15.9.2.
+	                // This remains so in the 10th edition of 2019 as well.
+	                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 mirrorDateProperties(ClockDate, NativeDate);
+	                return new NativeDate(ClockDate.clock.now).toString();
+	            },
+	        });
+
+	        return ClockDateProxy;
 	    }
 
-	    //eslint-disable-next-line jsdoc/require-jsdoc
+	    /**
+	     * 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 = { ...NativeIntl };
+	        const ClockIntl = {};
+	        /*
+	         * All properties of Intl are non-enumerable, so we need
+	         * to do a bit of work to get them out.
+	         */
+	        Object.getOwnPropertyNames(NativeIntl).forEach(
+	            (property) => (ClockIntl[property] = NativeIntl[property]),
+	        );
 
 	        ClockIntl.DateTimeFormat = function (...args) {
 	            const realFormatter = new NativeIntl.DateTimeFormat(...args);
@@ -2025,7 +1937,7 @@ function requireFakeTimersSrc () {
 	                (method) => {
 	                    formatter[method] =
 	                        realFormatter[method].bind(realFormatter);
-	                }
+	                },
 	            );
 
 	            ["format", "formatToParts"].forEach((method) => {
@@ -2038,7 +1950,7 @@ function requireFakeTimersSrc () {
 	        };
 
 	        ClockIntl.DateTimeFormat.prototype = Object.create(
-	            NativeIntl.DateTimeFormat.prototype
+	            NativeIntl.DateTimeFormat.prototype,
 	        );
 
 	        ClockIntl.DateTimeFormat.supportedLocalesOf =
@@ -2091,7 +2003,7 @@ function requireFakeTimersSrc () {
 	                throw new TypeError(
 	                    `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${
 	                        timer.func
-	                    } of type ${typeof timer.func}`
+	                    } of type ${typeof timer.func}`,
 	                );
 	            }
 	        }
@@ -2177,7 +2089,6 @@ function requireFakeTimersSrc () {
 	    /* eslint consistent-return: "off" */
 	    /**
 	     * Timer comparitor
-	     *
 	     * @param {Timer} a
 	     * @param {Timer} b
 	     * @returns {number}
@@ -2309,7 +2220,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Gets clear handler name for a given timer type
-	     *
 	     * @param {string} ttype
 	     */
 	    function getClearHandler(ttype) {
@@ -2321,7 +2231,6 @@ function requireFakeTimersSrc () {
 
 	    /**
 	     * Gets schedule handler name for a given timer type
-	     *
 	     * @param {string} ttype
 	     */
 	    function getScheduleHandler(ttype) {
@@ -2374,7 +2283,7 @@ function requireFakeTimersSrc () {
 	            }
 	            warnOnce(
 	                `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.` +
-	                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`."
+	                    "\nTo automatically clean-up native timers, use `shouldClearNativeTimers`.",
 	            );
 	        }
 
@@ -2391,7 +2300,7 @@ function requireFakeTimersSrc () {
 	                const clear = getClearHandler(ttype);
 	                const schedule = getScheduleHandler(timer.type);
 	                throw new Error(
-	                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`
+	                    `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`,
 	                );
 	            }
 	        }
@@ -2416,7 +2325,7 @@ function requireFakeTimersSrc () {
 	            } else if (method === "performance") {
 	                const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
 	                    clock,
-	                    `_${method}`
+	                    `_${method}`,
 	                );
 	                if (
 	                    originalPerfDescriptor &&
@@ -2426,7 +2335,7 @@ function requireFakeTimersSrc () {
 	                    Object.defineProperty(
 	                        _global,
 	                        method,
-	                        originalPerfDescriptor
+	                        originalPerfDescriptor,
 	                    );
 	                } else if (originalPerfDescriptor.configurable) {
 	                    _global[method] = clock[`_${method}`];
@@ -2448,6 +2357,16 @@ function requireFakeTimersSrc () {
 	                    timersModule[entry.methodName] = entry.original;
 	                }
 	            }
+	            if (clock.timersPromisesModuleMethods !== undefined) {
+	                for (
+	                    let j = 0;
+	                    j < clock.timersPromisesModuleMethods.length;
+	                    j++
+	                ) {
+	                    const entry = clock.timersPromisesModuleMethods[j];
+	                    timersPromisesModule[entry.methodName] = entry.original;
+	                }
+	            }
 	        }
 
 	        if (config.shouldAdvanceTime === true) {
@@ -2457,6 +2376,11 @@ function requireFakeTimersSrc () {
 	        // Prevent multiple executions which will completely remove these props
 	        clock.methods = [];
 
+	        for (const [listener, signal] of clock.abortListenerMap.entries()) {
+	            signal.removeEventListener("abort", listener);
+	            clock.abortListenerMap.delete(listener);
+	        }
+
 	        // return pending timers, to enable checking what timers remained on uninstall
 	        if (!clock.timers) {
 	            return [];
@@ -2474,19 +2398,18 @@ function requireFakeTimersSrc () {
 	    function hijackMethod(target, method, clock) {
 	        clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
 	            target,
-	            method
+	            method,
 	        );
 	        clock[`_${method}`] = target[method];
 
 	        if (method === "Date") {
-	            const date = mirrorDateProperties(clock[method], target[method]);
-	            target[method] = date;
+	            target[method] = clock[method];
 	        } else if (method === "Intl") {
 	            target[method] = clock[method];
 	        } else if (method === "performance") {
 	            const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
 	                target,
-	                method
+	                method,
 	            );
 	            // JSDOM has a read only performance field so we have to save/copy it differently
 	            if (
@@ -2497,12 +2420,12 @@ function requireFakeTimersSrc () {
 	                Object.defineProperty(
 	                    clock,
 	                    `_${method}`,
-	                    originalPerfDescriptor
+	                    originalPerfDescriptor,
 	                );
 
 	                const perfDescriptor = Object.getOwnPropertyDescriptor(
 	                    clock,
-	                    method
+	                    method,
 	                );
 	                Object.defineProperty(target, method, perfDescriptor);
 	            } else {
@@ -2515,7 +2438,7 @@ function requireFakeTimersSrc () {
 
 	            Object.defineProperties(
 	                target[method],
-	                Object.getOwnPropertyDescriptors(clock[method])
+	                Object.getOwnPropertyDescriptors(clock[method]),
 	            );
 	        }
 
@@ -2559,45 +2482,48 @@ function requireFakeTimersSrc () {
 	        Date: _global.Date,
 	    };
 
-	    if (setImmediatePresent) {
+	    if (isPresent.setImmediate) {
 	        timers.setImmediate = _global.setImmediate;
+	    }
+
+	    if (isPresent.clearImmediate) {
 	        timers.clearImmediate = _global.clearImmediate;
 	    }
 
-	    if (hrtimePresent) {
+	    if (isPresent.hrtime) {
 	        timers.hrtime = _global.process.hrtime;
 	    }
 
-	    if (nextTickPresent) {
+	    if (isPresent.nextTick) {
 	        timers.nextTick = _global.process.nextTick;
 	    }
 
-	    if (performancePresent) {
+	    if (isPresent.performance) {
 	        timers.performance = _global.performance;
 	    }
 
-	    if (requestAnimationFramePresent) {
+	    if (isPresent.requestAnimationFrame) {
 	        timers.requestAnimationFrame = _global.requestAnimationFrame;
 	    }
 
-	    if (queueMicrotaskPresent) {
-	        timers.queueMicrotask = true;
+	    if (isPresent.queueMicrotask) {
+	        timers.queueMicrotask = _global.queueMicrotask;
 	    }
 
-	    if (cancelAnimationFramePresent) {
+	    if (isPresent.cancelAnimationFrame) {
 	        timers.cancelAnimationFrame = _global.cancelAnimationFrame;
 	    }
 
-	    if (requestIdleCallbackPresent) {
+	    if (isPresent.requestIdleCallback) {
 	        timers.requestIdleCallback = _global.requestIdleCallback;
 	    }
 
-	    if (cancelIdleCallbackPresent) {
+	    if (isPresent.cancelIdleCallback) {
 	        timers.cancelIdleCallback = _global.cancelIdleCallback;
 	    }
 
-	    if (intlPresent) {
-	        timers.Intl = _global.Intl;
+	    if (isPresent.Intl) {
+	        timers.Intl = NativeIntl;
 	    }
 
 	    const originalSetTimeout = _global.setImmediate || _global.setTimeout;
@@ -2615,13 +2541,6 @@ function requireFakeTimersSrc () {
 	        let nanos = 0;
 	        const adjustedSystemTime = [0, 0]; // [millis, nanoremainder]
 
-	        if (NativeDate === undefined) {
-	            throw new Error(
-	                "The global scope doesn't have a `Date` object" +
-	                    " (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
-	            );
-	        }
-
 	        const clock = {
 	            now: start,
 	            Date: createDate(),
@@ -2647,7 +2566,7 @@ function requireFakeTimersSrc () {
 	            if (Array.isArray(prev)) {
 	                if (prev[1] > 1e9) {
 	                    throw new TypeError(
-	                        "Number of nanoseconds can't exceed a billion"
+	                        "Number of nanoseconds can't exceed a billion",
 	                    );
 	                }
 
@@ -2665,27 +2584,36 @@ function requireFakeTimersSrc () {
 	            return [secsSinceStart, remainderInNanos];
 	        }
 
+	        /**
+	         * A high resolution timestamp in milliseconds.
+	         * @typedef {number} DOMHighResTimeStamp
+	         */
+
+	        /**
+	         * performance.now()
+	         * @returns {DOMHighResTimeStamp}
+	         */
 	        function fakePerformanceNow() {
 	            const hrt = hrtime();
 	            const millis = hrt[0] * 1000 + hrt[1] / 1e6;
 	            return millis;
 	        }
 
-	        if (hrtimeBigintPresent) {
+	        if (isPresent.hrtimeBigint) {
 	            hrtime.bigint = function () {
 	                const parts = hrtime();
 	                return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]); // eslint-disable-line
 	            };
 	        }
 
-	        if (intlPresent) {
+	        if (isPresent.Intl) {
 	            clock.Intl = createIntl();
 	            clock.Intl.clock = clock;
 	        }
 
 	        clock.requestIdleCallback = function requestIdleCallback(
 	            func,
-	            timeout
+	            timeout,
 	        ) {
 	            let timeToNextIdlePeriod = 0;
 
@@ -2721,7 +2649,7 @@ function requireFakeTimersSrc () {
 	            clock.setTimeout[utilPromisify.custom] =
 	                function promisifiedSetTimeout(timeout, arg) {
 	                    return new _global.Promise(function setTimeoutExecutor(
-	                        resolve
+	                        resolve,
 	                    ) {
 	                        addTimer(clock, {
 	                            func: resolve,
@@ -2763,7 +2691,7 @@ function requireFakeTimersSrc () {
 	            return clearTimer(clock, timerId, "Interval");
 	        };
 
-	        if (setImmediatePresent) {
+	        if (isPresent.setImmediate) {
 	            clock.setImmediate = function setImmediate(func) {
 	                return addTimer(clock, {
 	                    func: func,
@@ -2782,7 +2710,7 @@ function requireFakeTimersSrc () {
 	                                    args: [arg],
 	                                    immediate: true,
 	                                });
-	                            }
+	                            },
 	                        );
 	                    };
 	            }
@@ -3084,6 +3012,8 @@ function requireFakeTimersSrc () {
 	                    function doRun() {
 	                        originalSetTimeout(function () {
 	                            try {
+	                                runJobs(clock);
+
 	                                let numTimers;
 	                                if (i < clock.loopLimit) {
 	                                    if (!clock.timers) {
@@ -3093,7 +3023,7 @@ function requireFakeTimersSrc () {
 	                                    }
 
 	                                    numTimers = Object.keys(
-	                                        clock.timers
+	                                        clock.timers,
 	                                    ).length;
 	                                    if (numTimers === 0) {
 	                                        resetIsNearInfiniteLimit();
@@ -3139,6 +3069,7 @@ function requireFakeTimersSrc () {
 	                        try {
 	                            const timer = lastTimer(clock);
 	                            if (!timer) {
+	                                runJobs(clock);
 	                                resolve(clock.now);
 	                            }
 
@@ -3199,12 +3130,12 @@ function requireFakeTimersSrc () {
 	            clock.tick(ms);
 	        };
 
-	        if (performancePresent) {
+	        if (isPresent.performance) {
 	            clock.performance = Object.create(null);
 	            clock.performance.now = fakePerformanceNow;
 	        }
 
-	        if (hrtimePresent) {
+	        if (isPresent.hrtime) {
 	            clock.hrtime = hrtime;
 	        }
 
@@ -3226,8 +3157,8 @@ function requireFakeTimersSrc () {
 	        ) {
 	            throw new TypeError(
 	                `FakeTimers.install called with ${String(
-	                    config
-	                )} install requires an object parameter`
+	                    config,
+	                )} install requires an object parameter`,
 	            );
 	        }
 
@@ -3235,7 +3166,7 @@ function requireFakeTimersSrc () {
 	            // Timers are already faked; this is a problem.
 	            // Make the user reset timers before continuing.
 	            throw new TypeError(
-	                "Can't install fake timers twice on the same global object."
+	                "Can't install fake timers twice on the same global object.",
 	            );
 	        }
 
@@ -3248,7 +3179,21 @@ function requireFakeTimersSrc () {
 
 	        if (config.target) {
 	            throw new TypeError(
-	                "config.target is no longer supported. Use `withGlobal(target)` instead."
+	                "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}'`,
 	            );
 	        }
 
@@ -3260,24 +3205,23 @@ function requireFakeTimersSrc () {
 	            return uninstall(clock, config);
 	        };
 
+	        clock.abortListenerMap = new Map();
+
 	        clock.methods = config.toFake || [];
 
 	        if (clock.methods.length === 0) {
-	            // do not fake nextTick by default - GitHub#126
-	            clock.methods = Object.keys(timers).filter(function (key) {
-	                return key !== "nextTick" && key !== "queueMicrotask";
-	            });
+	            clock.methods = Object.keys(timers);
 	        }
 
 	        if (config.shouldAdvanceTime === true) {
 	            const intervalTick = doIntervalTick.bind(
 	                null,
 	                clock,
-	                config.advanceTimeDelta
+	                config.advanceTimeDelta,
 	            );
 	            const intervalId = _global.setInterval(
 	                intervalTick,
-	                config.advanceTimeDelta
+	                config.advanceTimeDelta,
 	            );
 	            clock.attachedInterval = intervalId;
 	        }
@@ -3300,18 +3244,33 @@ function requireFakeTimersSrc () {
 	                                : NOOP;
 	                    }
 	                });
+	                // ensure `mark` returns a value that is valid
+	                clock.performance.mark = (name) =>
+	                    new FakePerformanceEntry(name, "mark", 0, 0);
+	                clock.performance.measure = (name) =>
+	                    new FakePerformanceEntry(name, "measure", 0, 100);
+	                // `timeOrigin` should return the time of when the Window session started
+	                // (or the Worker was installed)
+	                clock.performance.timeOrigin = getEpoch(config.now);
 	            } else if ((config.toFake || []).includes("performance")) {
-	                // user explicitly tried to fake performance when not present
-	                throw new ReferenceError(
-	                    "non-existent performance object cannot be faked"
-	                );
+	                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);
+	                // eslint-disable-next-line
+	                continue;
+	            }
+
 	            if (nameOfMethodToReplace === "hrtime") {
 	                if (
 	                    _global.process &&
@@ -3341,6 +3300,239 @@ function requireFakeTimersSrc () {
 	                timersModule[nameOfMethodToReplace] =
 	                    _global[nameOfMethodToReplace];
 	            }
+	            if (clock.timersPromisesModuleMethods !== undefined) {
+	                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);
+
+	                                // This is safe, there is no code path that leads to this function
+	                                // being invoked before handle has been assigned.
+	                                // eslint-disable-next-line no-use-before-define
+	                                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);
+
+	                                // This is safe, there is no code path that leads to this function
+	                                // being invoked before handle has been assigned.
+	                                // eslint-disable-next-line no-use-before-define
+	                                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: undefined };
+	                                    }
+
+	                                    if (nextAvailable > 0) {
+	                                        nextAvailable--;
+	                                        return { done: false, value: 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: undefined };
+	                                    }
+
+	                                    return { done: false, value: value };
+	                                },
+	                                return: async () => {
+	                                    if (done) {
+	                                        return { done: true, value: undefined };
+	                                    }
+
+	                                    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: undefined };
+	                                },
+	                            };
+	                        },
+	                    });
+	                }
+	            }
 	        }
 
 	        return clock;
@@ -3379,602 +3571,445 @@ function requireFakeTimersSrc () {
 var fakeTimersSrcExports = requireFakeTimersSrc();
 
 class FakeTimers {
-  _global;
-  _clock;
-  _fakingTime;
-  _fakingDate;
-  _fakeTimers;
-  _userConfig;
-  _now = RealDate.now;
-  constructor({
-    global,
-    config
-  }) {
-    this._userConfig = config;
-    this._fakingDate = false;
-    this._fakingTime = false;
-    this._fakeTimers = fakeTimersSrcExports.withGlobal(global);
-    this._global = global;
-  }
-  clearAllTimers() {
-    if (this._fakingTime) {
-      this._clock.reset();
-    }
-  }
-  dispose() {
-    this.useRealTimers();
-  }
-  runAllTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runAll();
-    }
-  }
-  async runAllTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runAllAsync();
-    }
-  }
-  runOnlyPendingTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToLast();
-    }
-  }
-  async runOnlyPendingTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runToLastAsync();
-    }
-  }
-  advanceTimersToNextTimer(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        this._clock.next();
-        this._clock.tick(0);
-        if (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
-    }
-  }
-  async advanceTimersToNextTimerAsync(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        await this._clock.nextAsync();
-        this._clock.tick(0);
-        if (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
-    }
-  }
-  advanceTimersByTime(msToRun) {
-    if (this._checkFakeTimers()) {
-      this._clock.tick(msToRun);
-    }
-  }
-  async advanceTimersByTimeAsync(msToRun) {
-    if (this._checkFakeTimers()) {
-      await this._clock.tickAsync(msToRun);
-    }
-  }
-  advanceTimersToNextFrame() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToFrame();
-    }
-  }
-  runAllTicks() {
-    if (this._checkFakeTimers()) {
-      this._clock.runMicrotasks();
-    }
-  }
-  useRealTimers() {
-    if (this._fakingDate) {
-      resetDate();
-      this._fakingDate = false;
-    }
-    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"
-      );
-      if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) {
-        throw new Error(
-          "process.nextTick cannot be mocked inside child_process"
-        );
-      }
-      const existingFakedMethods = (this._userConfig?.toFake || toFake).filter(
-        (method) => {
-          switch (method) {
-            case "setImmediate":
-            case "clearImmediate":
-              return method in this._global && this._global[method];
-            default:
-              return true;
-          }
-        }
-      );
-      this._clock = this._fakeTimers.install({
-        now: Date.now(),
-        ...this._userConfig,
-        toFake: existingFakedMethods
-      });
-      this._fakingTime = true;
-    }
-  }
-  reset() {
-    if (this._checkFakeTimers()) {
-      const { now } = this._clock;
-      this._clock.reset();
-      this._clock.setSystemTime(now);
-    }
-  }
-  setSystemTime(now) {
-    if (this._fakingTime) {
-      this._clock.setSystemTime(now);
-    } else {
-      mockDate(now ?? this.getRealSystemTime());
-      this._fakingDate = true;
-    }
-  }
-  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;
-  }
+	_global;
+	_clock;
+	// | _fakingTime | _fakingDate |
+	// +-------------+-------------+
+	// | false       | falsy       | initial
+	// | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
+	// | true        | falsy       | vi.useFakeTimers called first
+	// | true        | truthy     | unreachable
+	_fakingTime;
+	_fakingDate;
+	_fakeTimers;
+	_userConfig;
+	_now = RealDate.now;
+	constructor({ global, config }) {
+		this._userConfig = config;
+		this._fakingDate = null;
+		this._fakingTime = false;
+		this._fakeTimers = fakeTimersSrcExports.withGlobal(global);
+		this._global = global;
+	}
+	clearAllTimers() {
+		if (this._fakingTime) this._clock.reset();
+	}
+	dispose() {
+		this.useRealTimers();
+	}
+	runAllTimers() {
+		if (this._checkFakeTimers()) this._clock.runAll();
+	}
+	async runAllTimersAsync() {
+		if (this._checkFakeTimers()) await this._clock.runAllAsync();
+	}
+	runOnlyPendingTimers() {
+		if (this._checkFakeTimers()) this._clock.runToLast();
+	}
+	async runOnlyPendingTimersAsync() {
+		if (this._checkFakeTimers()) await this._clock.runToLastAsync();
+	}
+	advanceTimersToNextTimer(steps = 1) {
+		if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+			this._clock.next();
+			// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250
+			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();
+			// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250
+			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())
+ // @ts-expect-error method not exposed
+		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;
+	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 = 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(
-          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);
-  });
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = 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(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 = 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(
-          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);
-  });
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = 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(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 _mockedDate = null;
-  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();
-      _mockedDate = null;
-      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) {
-      const date = time instanceof Date ? time : new Date(time);
-      _mockedDate = date;
-      timers().setSystemTime(date);
-      return utils;
-    },
-    getMockedSystemTime() {
-      return _mockedDate;
-    },
-    getRealSystemTime() {
-      return timers().getRealSystemTime();
-    },
-    clearAllTimers() {
-      timers().clearAllTimers();
-      return utils;
-    },
-    // mocks
-    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"));
-    },
-    // this is typed in the interface so it's not necessary to type it here
-    mocked(item, _options = {}) {
-      return item;
-    },
-    isMockFunction(fn2) {
-      return isMockFunction(fn2);
-    },
-    clearAllMocks() {
-      mocks.forEach((spy) => spy.mockClear());
-      return utils;
-    },
-    resetAllMocks() {
-      mocks.forEach((spy) => spy.mockReset());
-      return utils;
-    },
-    restoreAllMocks() {
-      mocks.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;
+	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) {
+			return isMockFunction(fn);
+		},
+		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.`
-        );
-      }
-    }
-  );
+	// @ts-expect-error injected by vite-nide
+	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 stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
-  const stackArray = stackTrace.split("\n");
-  const importerStackIndex = stackArray.findIndex((stack2) => {
-    return stack2.includes(` at Object.${name}`) || stack2.includes(`${name}@`);
-  });
-  const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
-  return stack?.file || "";
+	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
+	const stackArray = stackTrace.split("\n");
+	// if there is no message in a stack trace, use the item - 1
+	const importerStackIndex = stackArray.findIndex((stack) => {
+		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
+	});
+	const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
+	return stack?.file || "";
 }
 
-export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, vi as v };
+export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, inject as i, vi as v };