@assistant-ui/react 0.8.16 → 0.8.18

package/dist/tests/setup.mjs

@@ -1,19 +1,14 @@
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/index.js
-import { afterAll as afterAll2, afterEach as afterEach2, beforeAll as beforeAll2, beforeEach as beforeEach2, describe as describe2, it as it2, onTestFailed as onTestFailed2, onTestFinished as onTestFinished2, suite as suite2, test as test2 } from "@vitest/runner.mjs";
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/benchmark.yGkUTKnC.js
-import { getCurrentSuite } from "@vitest/runner.mjs";
-import { createChainable } from "@vitest/runner/utils.mjs";
-import { noop } from "@vitest/utils.mjs";
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/index.SMVOaj7F.js
-import { relative } from "pathe.mjs";
-import "@vitest/runner/utils.mjs";
-import "@vitest/utils.mjs";
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
+import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from "@vitest/expect.mjs";
+import { getCurrentTest } from "@vitest/runner.mjs";
+import { getNames, getTestName } from "@vitest/runner/utils.mjs";
+import * as chai$1 from "chai.mjs";
 
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/global.CkGT_TMy.js
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/utils.CtocqOoE.js
+import { getSafeTimers } from "@vitest/utils.mjs";
+var NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
-  const workerState = globalThis.__vitest_worker__;
+  const workerState = globalThis[NAME_WORKER_STATE];
   if (!workerState) {
     const errorMsg = 'Vitest failed to access its internal state.\n\nOne of the following is possible:\n- "vitest" is imported directly without running "vitest" command\n- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
     throw new Error(errorMsg);
@@ -22,103 +17,66 @@ function getWorkerState() {
 }
 function getCurrentEnvironment() {
   const state = getWorkerState();
-  return state == null ? void 0 : state.environment.name;
-}
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/index.SMVOaj7F.js
-function getRunMode() {
-  return getWorkerState().config.mode;
+  return state?.environment.name;
 }
-function isRunningInBenchmark() {
-  return getRunMode() === "benchmark";
+function isChildProcess() {
+  return typeof process !== "undefined" && !!process.send;
 }
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/benchmark.yGkUTKnC.js
-var benchFns = /* @__PURE__ */ new WeakMap();
-var benchOptsMap = /* @__PURE__ */ new WeakMap();
-var bench = createBenchmark(
-  function(name, fn2 = noop, options = {}) {
-    if (!isRunningInBenchmark())
-      throw new Error("`bench()` is only available in benchmark mode.");
-    const task = getCurrentSuite().task(formatName(name), {
-      ...this,
-      meta: {
-        benchmark: true
-      }
-    });
-    benchFns.set(task, fn2);
-    benchOptsMap.set(task, options);
-  }
-);
-function createBenchmark(fn2) {
-  const benchmark = createChainable(
-    ["skip", "only", "todo"],
-    fn2
-  );
-  benchmark.skipIf = (condition) => condition ? benchmark.skip : benchmark;
-  benchmark.runIf = (condition) => condition ? benchmark : benchmark.skip;
-  return benchmark;
+function resetModules(modules, resetMocks = false) {
+  const skipPaths = [
+    /\/vitest\/dist\//,
+    /\/vite-node\/dist\//,
+    /vitest-virtual-\w+\/dist/,
+    /@vitest\/dist/,
+    ...!resetMocks ? [/^mock:/] : []
+  ];
+  modules.forEach((mod, path) => {
+    if (skipPaths.some((re) => re.test(path))) {
+      return;
+    }
+    modules.invalidateModule(mod);
+  });
 }
-function formatName(name) {
-  return typeof name === "string" ? name : name instanceof Function ? name.name || "<anonymous>" : String(name);
+function waitNextTick() {
+  const { setTimeout } = getSafeTimers();
+  return new Promise((resolve) => setTimeout(resolve, 0));
 }
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/run-once.Olz_Zkd8.js
-var filesCount = /* @__PURE__ */ new Map();
-var cache = /* @__PURE__ */ new Map();
-function runOnce(fn2, key) {
-  const filepath = getWorkerState().filepath || "__unknown_files__";
-  if (!key) {
-    filesCount.set(filepath, (filesCount.get(filepath) || 0) + 1);
-    key = String(filesCount.get(filepath));
+async function waitForImportsToResolve() {
+  await waitNextTick();
+  const state = getWorkerState();
+  const promises = [];
+  let resolvingCount = 0;
+  for (const mod of state.moduleCache.values()) {
+    if (mod.promise && !mod.evaluated) {
+      promises.push(mod.promise);
+    }
+    if (mod.resolving) {
+      resolvingCount++;
+    }
   }
-  const id = `${filepath}:${key}`;
-  if (!cache.has(id))
-    cache.set(id, fn2());
-  return cache.get(id);
-}
-function isFirstRun() {
-  let firstRun = false;
-  runOnce(() => {
-    firstRun = true;
-  }, "__vitest_first_run__");
-  return firstRun;
+  if (!promises.length && !resolvingCount) {
+    return;
+  }
+  await Promise.allSettled(promises);
+  await waitForImportsToResolve();
 }
 
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/vi.YFlodzP_.js
-import * as chai$1 from "chai.mjs";
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
+import { getSafeTimers as getSafeTimers2, assertTypes, createSimpleStackTrace } from "@vitest/utils.mjs";
 
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/_commonjsHelpers.jjO7Zipk.js
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
 
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/vi.YFlodzP_.js
-import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT as GLOBAL_EXPECT$1, ASYMMETRIC_MATCHERS_OBJECT as ASYMMETRIC_MATCHERS_OBJECT$1, getState, setState, addCustomEqualityTesters } from "@vitest/expect.mjs";
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from "@vitest/snapshot.mjs";
-import { getNames as getNames2 } from "@vitest/runner/utils.mjs";
 import "@vitest/utils/error.mjs";
-import { getCurrentTest } from "@vitest/runner.mjs";
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/tasks.IknbGB2n.js
-import { getNames, getTests } from "@vitest/runner/utils.mjs";
-import "@vitest/utils.mjs";
-function getFullName(task, separator = " > ") {
-  return getNames(task).join(separator);
-}
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/vi.YFlodzP_.js
-import { getSafeTimers, assertTypes, createSimpleStackTrace } from "@vitest/utils.mjs";
+import { fn, spyOn, mocks, isMockFunction } from "@vitest/spy.mjs";
 import { parseSingleStack } from "@vitest/utils/source-map.mjs";
 
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/base.5NT-gWu5.js
-import "@vitest/utils.mjs";
-function isChildProcess() {
-  return typeof process !== "undefined" && !!process.send;
-}
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/date.Ns1pGd_X.js
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/date.CDOsz-HY.js
 var RealDate = Date;
 var now = null;
 var MockDate = class _MockDate extends RealDate {
@@ -127,10 +85,11 @@ var MockDate = class _MockDate extends RealDate {
     let date;
     switch (arguments.length) {
       case 0:
-        if (now !== null)
+        if (now !== null) {
           date = new RealDate(now.valueOf());
-        else
+        } else {
           date = new RealDate();
+        }
         break;
       case 1:
         date = new RealDate(y);
@@ -160,8 +119,9 @@ MockDate.toString = function() {
 };
 function mockDate(date) {
   const dateObj = new RealDate(date.valueOf());
-  if (Number.isNaN(dateObj.getTime()))
+  if (Number.isNaN(dateObj.getTime())) {
     throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+  }
   globalThis.Date = MockDate;
   now = dateObj.valueOf();
 }
@@ -169,177 +129,265 @@ function resetDate() {
   globalThis.Date = RealDate;
 }
 
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/vi.YFlodzP_.js
-import { spyOn, fn, isMockFunction, mocks } from "@vitest/spy.mjs";
-function resetModules(modules, resetMocks = false) {
-  const skipPaths = [
-    // Vitest
-    /\/vitest\/dist\//,
-    /\/vite-node\/dist\//,
-    // yarn's .store folder
-    /vitest-virtual-\w+\/dist/,
-    // cnpm
-    /@vitest\/dist/,
-    // don't clear mocks
-    ...!resetMocks ? [/^mock:/] : []
-  ];
-  modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path)))
-      return;
-    modules.invalidateModule(mod);
-  });
-}
-function waitNextTick() {
-  const { setTimeout } = getSafeTimers();
-  return new Promise((resolve) => setTimeout(resolve, 0));
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/chunks/vi.B-PuvDzu.js
+var unsupported = [
+  "matchSnapshot",
+  "toMatchSnapshot",
+  "toMatchInlineSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "toThrowErrorMatchingInlineSnapshot",
+  "throws",
+  "Throw",
+  "throw",
+  "toThrow",
+  "toThrowError"
+];
+function createExpectPoll(expect2) {
+  return function poll(fn2, options = {}) {
+    const state = getWorkerState();
+    const defaults = state.config.expect?.poll ?? {};
+    const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+    const assertion = expect2(null, message).withContext({ poll: true });
+    fn2 = fn2.bind(assertion);
+    const test2 = chai$1.util.flag(assertion, "vitest-test");
+    if (!test2) {
+      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 } = getSafeTimers2();
+          const check = async () => {
+            try {
+              chai$1.util.flag(assertion, "_name", key);
+              const obj = await fn2();
+              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;
+        test2.onFinished ??= [];
+        test2.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;
+  };
 }
-async function waitForImportsToResolve() {
-  await waitNextTick();
-  const state = getWorkerState();
-  const promises = [];
-  let resolvingCount = 0;
-  for (const mod of state.moduleCache.values()) {
-    if (mod.promise && !mod.evaluated)
-      promises.push(mod.promise);
-    if (mod.resolving)
-      resolvingCount++;
+function copyStackTrace$1(target, source) {
+  if (source.stack !== void 0) {
+    target.stack = source.stack.replace(source.message, target.message);
   }
-  if (!promises.length && !resolvingCount)
-    return;
-  await Promise.allSettled(promises);
-  await waitForImportsToResolve();
+  return target;
 }
 function commonjsRequire(path) {
   throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
-var chaiSubset = { exports: {} };
-(function(module, exports) {
-  (function() {
-    (function(chaiSubset2) {
-      if (typeof commonjsRequire === "function" && true && true) {
-        return module.exports = chaiSubset2;
-      } else {
-        return chai.use(chaiSubset2);
-      }
-    })(function(chai4, utils) {
-      var Assertion = chai4.Assertion;
-      var assertionPrototype = Assertion.prototype;
-      Assertion.addMethod("containSubset", function(expected) {
-        var actual = utils.flag(this, "object");
-        var showDiff = chai4.config.showDiff;
-        assertionPrototype.assert.call(
-          this,
-          compare(expected, actual),
-          "expected #{act} to contain subset #{exp}",
-          "expected #{act} to not contain subset #{exp}",
-          expected,
-          actual,
-          showDiff
-        );
-      });
-      chai4.assert.containSubset = function(val, exp, msg) {
-        new chai4.Assertion(val, msg).to.be.containSubset(exp);
-      };
-      function compare(expected, actual) {
-        if (expected === actual) {
-          return true;
-        }
-        if (typeof actual !== typeof expected) {
-          return false;
-        }
-        if (typeof expected !== "object" || expected === null) {
-          return expected === actual;
-        }
-        if (!!expected && !actual) {
-          return false;
+var chaiSubset$1 = { exports: {} };
+var chaiSubset = chaiSubset$1.exports;
+var hasRequiredChaiSubset;
+function requireChaiSubset() {
+  if (hasRequiredChaiSubset) return chaiSubset$1.exports;
+  hasRequiredChaiSubset = 1;
+  (function(module, exports) {
+    (function() {
+      (function(chaiSubset2) {
+        if (typeof commonjsRequire === "function" && true && true) {
+          return module.exports = chaiSubset2;
+        } else {
+          return chai.use(chaiSubset2);
         }
-        if (Array.isArray(expected)) {
-          if (typeof actual.length !== "number") {
+      })(function(chai3, utils) {
+        var Assertion2 = chai3.Assertion;
+        var assertionPrototype = Assertion2.prototype;
+        Assertion2.addMethod("containSubset", function(expected) {
+          var actual = utils.flag(this, "object");
+          var showDiff = chai3.config.showDiff;
+          assertionPrototype.assert.call(
+            this,
+            compare(expected, actual),
+            "expected #{act} to contain subset #{exp}",
+            "expected #{act} to not contain subset #{exp}",
+            expected,
+            actual,
+            showDiff
+          );
+        });
+        chai3.assert.containSubset = function(val, exp, msg) {
+          new chai3.Assertion(val, msg).to.be.containSubset(exp);
+        };
+        function compare(expected, actual) {
+          if (expected === actual) {
+            return true;
+          }
+          if (typeof actual !== typeof expected) {
             return false;
           }
-          var aa = Array.prototype.slice.call(actual);
-          return expected.every(function(exp) {
-            return aa.some(function(act) {
-              return compare(exp, act);
-            });
-          });
-        }
-        if (expected instanceof Date) {
-          if (actual instanceof Date) {
-            return expected.getTime() === actual.getTime();
-          } else {
+          if (typeof expected !== "object" || expected === null) {
+            return expected === actual;
+          }
+          if (!!expected && !actual) {
             return false;
           }
-        }
-        return Object.keys(expected).every(function(key) {
-          var eo = expected[key];
-          var ao = actual[key];
-          if (typeof eo === "object" && eo !== null && ao !== null) {
-            return compare(eo, ao);
+          if (Array.isArray(expected)) {
+            if (typeof actual.length !== "number") {
+              return false;
+            }
+            var aa = Array.prototype.slice.call(actual);
+            return expected.every(function(exp) {
+              return aa.some(function(act) {
+                return compare(exp, act);
+              });
+            });
           }
-          if (typeof eo === "function") {
-            return eo(ao);
+          if (expected instanceof Date) {
+            if (actual instanceof Date) {
+              return expected.getTime() === actual.getTime();
+            } else {
+              return false;
+            }
           }
-          return ao === eo;
-        });
-      }
-    });
-  }).call(commonjsGlobal);
-})(chaiSubset);
-var chaiSubsetExports = chaiSubset.exports;
+          return Object.keys(expected).every(function(key) {
+            var eo = expected[key];
+            var ao = actual[key];
+            if (typeof eo === "object" && eo !== null && ao !== null) {
+              return compare(eo, ao);
+            }
+            if (typeof eo === "function") {
+              return eo(ao);
+            }
+            return ao === eo;
+          });
+        }
+      });
+    }).call(chaiSubset);
+  })(chaiSubset$1);
+  return chaiSubset$1.exports;
+}
+var chaiSubsetExports = requireChaiSubset();
 var Subset = /* @__PURE__ */ getDefaultExportFromCjs(chaiSubsetExports);
-var MATCHERS_OBJECT = Symbol.for("matchers-object");
-var JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
-var GLOBAL_EXPECT = Symbol.for("expect-global");
-var ASYMMETRIC_MATCHERS_OBJECT = Symbol.for("asymmetric-matchers-object");
-if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
-  const globalState = /* @__PURE__ */ new WeakMap();
-  const matchers = /* @__PURE__ */ Object.create(null);
-  const customEqualityTesters = [];
-  const assymetricMatchers = /* @__PURE__ */ Object.create(null);
-  Object.defineProperty(globalThis, MATCHERS_OBJECT, {
-    get: () => globalState
-  });
-  Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, {
-    configurable: true,
-    get: () => ({
-      state: globalState.get(globalThis[GLOBAL_EXPECT]),
-      matchers,
-      customEqualityTesters
-    })
-  });
-  Object.defineProperty(globalThis, ASYMMETRIC_MATCHERS_OBJECT, {
-    get: () => assymetricMatchers
-  });
+function createAssertionMessage(util2, assertion, hasArgs) {
+  const not = util2.flag(assertion, "negate") ? "not." : "";
+  const name = `${util2.flag(assertion, "_name")}(${"expected"})`;
+  const promiseName = util2.flag(assertion, "promise");
+  const promise = promiseName ? `.${promiseName}` : "";
+  return `expect(actual)${promise}.${not}${name}`;
 }
-function recordAsyncExpect(test3, promise) {
-  if (test3 && promise instanceof Promise) {
+function recordAsyncExpect(_test, promise, assertion, error) {
+  const test2 = _test;
+  if (test2 && promise instanceof Promise) {
     promise = promise.finally(() => {
-      const index = test3.promises.indexOf(promise);
-      if (index !== -1)
-        test3.promises.splice(index, 1);
+      if (!test2.promises) {
+        return;
+      }
+      const index = test2.promises.indexOf(promise);
+      if (index !== -1) {
+        test2.promises.splice(index, 1);
+      }
+    });
+    if (!test2.promises) {
+      test2.promises = [];
+    }
+    test2.promises.push(promise);
+    let resolved = false;
+    test2.onFinished ??= [];
+    test2.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(""));
+      }
     });
-    if (!test3.promises)
-      test3.promises = [];
-    test3.promises.push(promise);
+    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;
 }
 var _client;
 function getSnapshotClient() {
   if (!_client) {
-    _client = new SnapshotClient({
-      isEqual: (received, expected) => {
-        return equals(received, expected, [iterableEquality, subsetEquality]);
-      }
-    });
+    _client = new SnapshotClient({ isEqual: (received, expected) => {
+      return equals(received, expected, [iterableEquality, subsetEquality]);
+    } });
   }
   return _client;
 }
 function getError(expected, promise) {
   if (typeof expected !== "function") {
-    if (!promise)
+    if (!promise) {
       throw new Error(`expected must be a function, received ${typeof expected}`);
+    }
     return expected;
   }
   try {
@@ -349,177 +397,167 @@ function getError(expected, promise) {
   }
   throw new Error("snapshot function didn't throw");
 }
-var SnapshotPlugin = (chai4, utils) => {
-  const getTestNames = (test3) => {
-    var _a;
-    if (!test3)
-      return {};
-    return {
-      filepath: (_a = test3.file) == null ? void 0 : _a.filepath,
-      name: getNames2(test3).slice(1).join(" > ")
-    };
+function getTestNames(test2) {
+  return {
+    filepath: test2.file.filepath,
+    name: getNames(test2).slice(1).join(" > "),
+    testId: test2.id
   };
-  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
-    utils.addMethod(
-      chai4.Assertion.prototype,
-      key,
-      function(properties, message) {
-        const isNot = utils.flag(this, "negate");
-        if (isNot)
-          throw new Error(`${key} cannot be used with "not"`);
-        const expected = utils.flag(this, "object");
-        const test3 = 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(test3)
-        });
-      }
-    );
+}
+var SnapshotPlugin = (chai3, utils) => {
+  function getTest(assertionName, obj) {
+    const test2 = utils.flag(obj, "vitest-test");
+    if (!test2) {
+      throw new Error(`'${assertionName}' cannot be used without test context`);
+    }
+    return test2;
   }
-  utils.addMethod(
-    chai4.Assertion.prototype,
-    "toMatchFileSnapshot",
-    function(file, message) {
-      const isNot = utils.flag(this, "negate");
-      if (isNot)
-        throw new Error('toMatchFileSnapshot cannot be used with "not"');
-      const expected = utils.flag(this, "object");
-      const test3 = utils.flag(this, "vitest-test");
-      const errorMessage = utils.flag(this, "message");
-      const promise = getSnapshotClient().assertRaw({
-        received: expected,
-        message,
-        isInline: false,
-        rawSnapshot: {
-          file
-        },
-        errorMessage,
-        ...getTestNames(test3)
-      });
-      return recordAsyncExpect(test3, promise);
-    }
-  );
-  utils.addMethod(
-    chai4.Assertion.prototype,
-    "toMatchInlineSnapshot",
-    function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-      var _a;
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
+    utils.addMethod(chai3.Assertion.prototype, key, function(properties, message) {
+      utils.flag(this, "_name", key);
       const isNot = utils.flag(this, "negate");
-      if (isNot)
-        throw new Error('toMatchInlineSnapshot cannot be used with "not"');
-      const test3 = utils.flag(this, "vitest-test");
-      const isInsideEach = test3 && (test3.each || ((_a = test3.suite) == null ? void 0 : _a.each));
-      if (isInsideEach)
-        throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+      if (isNot) {
+        throw new Error(`${key} cannot be used with "not"`);
+      }
       const expected = utils.flag(this, "object");
-      const error = utils.flag(this, "error");
-      if (typeof properties === "string") {
-        message = inlineSnapshot;
-        inlineSnapshot = properties;
+      const test2 = getTest(key, this);
+      if (typeof properties === "string" && typeof message === "undefined") {
+        message = properties;
         properties = void 0;
       }
-      if (inlineSnapshot)
-        inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
       const errorMessage = utils.flag(this, "message");
       getSnapshotClient().assert({
         received: expected,
         message,
-        isInline: true,
+        isInline: false,
         properties,
-        inlineSnapshot,
-        error,
-        errorMessage,
-        ...getTestNames(test3)
-      });
-    }
-  );
-  utils.addMethod(
-    chai4.Assertion.prototype,
-    "toThrowErrorMatchingSnapshot",
-    function(message) {
-      const isNot = utils.flag(this, "negate");
-      if (isNot)
-        throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
-      const expected = utils.flag(this, "object");
-      const test3 = 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(test3)
+        ...getTestNames(test2)
       });
-    }
-  );
-  utils.addMethod(
-    chai4.Assertion.prototype,
-    "toThrowErrorMatchingInlineSnapshot",
-    function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
-      var _a;
-      const isNot = utils.flag(this, "negate");
-      if (isNot)
-        throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
-      const test3 = utils.flag(this, "vitest-test");
-      const isInsideEach = test3 && (test3.each || ((_a = test3.suite) == null ? void 0 : _a.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(test3)
-      });
-    }
-  );
-  utils.addMethod(
-    chai4.expect,
-    "addSnapshotSerializer",
-    addSerializer
-  );
+    });
+  }
+  utils.addMethod(chai3.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 test2 = getTest("toMatchFileSnapshot", this);
+    const errorMessage = utils.flag(this, "message");
+    const promise = getSnapshotClient().assertRaw({
+      received: expected,
+      message,
+      isInline: false,
+      rawSnapshot: { file },
+      errorMessage,
+      ...getTestNames(test2)
+    });
+    return recordAsyncExpect(test2, promise, createAssertionMessage(utils, this), error);
+  });
+  utils.addMethod(chai3.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 test2 = getTest("toMatchInlineSnapshot", this);
+    const isInsideEach = test2.each || test2.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(test2)
+    });
+  });
+  utils.addMethod(chai3.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 test2 = getTest("toThrowErrorMatchingSnapshot", this);
+    const promise = utils.flag(this, "promise");
+    const errorMessage = utils.flag(this, "message");
+    getSnapshotClient().assert({
+      received: getError(expected, promise),
+      message,
+      errorMessage,
+      ...getTestNames(test2)
+    });
+  });
+  utils.addMethod(chai3.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 test2 = getTest("toThrowErrorMatchingInlineSnapshot", this);
+    const isInsideEach = test2.each || test2.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(test2)
+    });
+  });
+  utils.addMethod(chai3.expect, "addSnapshotSerializer", addSerializer);
 };
 chai$1.use(JestExtend);
 chai$1.use(JestChaiExpect);
 chai$1.use(Subset);
 chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
-function createExpect(test3) {
-  var _a;
+function createExpect(test2) {
   const expect2 = (value, message) => {
     const { assertionCalls } = getState(expect2);
-    setState({ assertionCalls: assertionCalls + 1, soft: false }, expect2);
-    const assert22 = chai$1.expect(value, message);
-    const _test = test3 || getCurrentTest();
-    if (_test)
-      return assert22.withTest(_test);
-    else
-      return assert22;
+    setState({ assertionCalls: assertionCalls + 1 }, expect2);
+    const assert3 = chai$1.expect(value, message);
+    const _test = test2 || getCurrentTest();
+    if (_test) {
+      return assert3.withTest(_test);
+    } else {
+      return assert3;
+    }
   };
   Object.assign(expect2, chai$1.expect);
-  Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT$1]);
+  Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
   expect2.getState = () => getState(expect2);
   expect2.setState = (state) => setState(state, expect2);
-  const globalState = getState(globalThis[GLOBAL_EXPECT$1]) || {};
+  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
   setState({
-    // this should also add "snapshotState" that is added conditionally
     ...globalState,
     assertionCalls: 0,
     isExpectingAssertions: false,
@@ -527,25 +565,25 @@ function createExpect(test3) {
     expectedAssertionsNumber: null,
     expectedAssertionsNumberErrorGen: null,
     environment: getCurrentEnvironment(),
-    testPath: test3 ? (_a = test3.suite.file) == null ? void 0 : _a.filepath : globalState.testPath,
-    currentTestName: test3 ? getFullName(test3) : globalState.currentTestName
+    get testPath() {
+      return getWorkerState().filepath;
+    },
+    currentTestName: test2 ? getTestName(test2) : globalState.currentTestName
   }, expect2);
   expect2.extend = (matchers) => chai$1.expect.extend(expect2, matchers);
   expect2.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
   expect2.soft = (...args) => {
-    const assert22 = expect2(...args);
-    expect2.setState({
-      soft: true
-    });
-    return assert22;
+    return expect2(...args).withContext({ soft: true });
   };
+  expect2.poll = createExpectPoll(expect2);
   expect2.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 ${expect2.getState().assertionCalls}`);
-    if (Error.captureStackTrace)
+    if (Error.captureStackTrace) {
       Error.captureStackTrace(errorGen(), assertions);
+    }
     expect2.setState({
       expectedAssertionsNumber: expected,
       expectedAssertionsNumberErrorGen: errorGen
@@ -553,8 +591,9 @@ function createExpect(test3) {
   }
   function hasAssertions() {
     const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace)
+    if (Error.captureStackTrace) {
       Error.captureStackTrace(error, hasAssertions);
+    }
     expect2.setState({
       isExpectingAssertions: true,
       isExpectingAssertionsError: error
@@ -562,1461 +601,1833 @@ function createExpect(test3) {
   }
   chai$1.util.addMethod(expect2, "assertions", assertions);
   chai$1.util.addMethod(expect2, "hasAssertions", hasAssertions);
+  expect2.extend(customMatchers);
   return expect2;
 }
 var globalExpect = createExpect();
-Object.defineProperty(globalThis, GLOBAL_EXPECT$1, {
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
   value: globalExpect,
   writable: true,
   configurable: true
 });
-var globalObject$1;
-if (typeof commonjsGlobal !== "undefined") {
-  globalObject$1 = commonjsGlobal;
-} else if (typeof window !== "undefined") {
-  globalObject$1 = window;
-} else {
-  globalObject$1 = self;
+var fakeTimersSrc = {};
+var global2;
+var hasRequiredGlobal;
+function requireGlobal() {
+  if (hasRequiredGlobal) return global2;
+  hasRequiredGlobal = 1;
+  var globalObject;
+  if (typeof commonjsGlobal !== "undefined") {
+    globalObject = commonjsGlobal;
+  } else if (typeof window !== "undefined") {
+    globalObject = window;
+  } else {
+    globalObject = self;
+  }
+  global2 = globalObject;
+  return global2;
 }
-var global2 = globalObject$1;
-var throwsOnProto$1;
-try {
-  const object2 = {};
-  object2.__proto__;
-  throwsOnProto$1 = false;
-} catch (_) {
-  throwsOnProto$1 = true;
-}
-var throwsOnProto_1 = throwsOnProto$1;
-var call = Function.call;
-var throwsOnProto = throwsOnProto_1;
-var disallowedProperties = [
-  // ignore size because it throws from Map
-  "size",
-  "caller",
-  "callee",
-  "arguments"
-];
-if (throwsOnProto) {
-  disallowedProperties.push("__proto__");
+var throwsOnProto_1;
+var hasRequiredThrowsOnProto;
+function requireThrowsOnProto() {
+  if (hasRequiredThrowsOnProto) return throwsOnProto_1;
+  hasRequiredThrowsOnProto = 1;
+  let throwsOnProto;
+  try {
+    const object2 = {};
+    object2.__proto__;
+    throwsOnProto = false;
+  } catch (_) {
+    throwsOnProto = true;
+  }
+  throwsOnProto_1 = throwsOnProto;
+  return throwsOnProto_1;
 }
-var copyPrototypeMethods = function copyPrototypeMethods2(prototype) {
-  return Object.getOwnPropertyNames(prototype).reduce(
-    function(result, name) {
-      if (disallowedProperties.includes(name)) {
-        return result;
-      }
-      if (typeof prototype[name] !== "function") {
+var copyPrototypeMethods;
+var hasRequiredCopyPrototypeMethods;
+function requireCopyPrototypeMethods() {
+  if (hasRequiredCopyPrototypeMethods) return copyPrototypeMethods;
+  hasRequiredCopyPrototypeMethods = 1;
+  var call = Function.call;
+  var throwsOnProto = requireThrowsOnProto();
+  var disallowedProperties = [
+    // ignore size because it throws from Map
+    "size",
+    "caller",
+    "callee",
+    "arguments"
+  ];
+  if (throwsOnProto) {
+    disallowedProperties.push("__proto__");
+  }
+  copyPrototypeMethods = function copyPrototypeMethods2(prototype) {
+    return Object.getOwnPropertyNames(prototype).reduce(
+      function(result, name) {
+        if (disallowedProperties.includes(name)) {
+          return result;
+        }
+        if (typeof prototype[name] !== "function") {
+          return result;
+        }
+        result[name] = call.bind(prototype[name]);
         return result;
-      }
-      result[name] = call.bind(prototype[name]);
-      return result;
-    },
-    /* @__PURE__ */ Object.create(null)
-  );
-};
-var copyPrototype$5 = copyPrototypeMethods;
-var array = copyPrototype$5(Array.prototype);
-var every$1 = array.every;
-function hasCallsLeft(callMap, spy) {
-  if (callMap[spy.id] === void 0) {
-    callMap[spy.id] = 0;
-  }
-  return callMap[spy.id] < spy.callCount;
-}
-function checkAdjacentCalls(callMap, spy, index, spies) {
-  var calledBeforeNext = true;
-  if (index !== spies.length - 1) {
-    calledBeforeNext = spy.calledBefore(spies[index + 1]);
-  }
-  if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
-    callMap[spy.id] += 1;
-    return true;
-  }
-  return false;
+      },
+      /* @__PURE__ */ Object.create(null)
+    );
+  };
+  return copyPrototypeMethods;
 }
-function calledInOrder(spies) {
-  var callMap = {};
-  var _spies = arguments.length > 1 ? arguments : spies;
-  return every$1(_spies, checkAdjacentCalls.bind(null, callMap));
+var array;
+var hasRequiredArray;
+function requireArray() {
+  if (hasRequiredArray) return array;
+  hasRequiredArray = 1;
+  var copyPrototype = requireCopyPrototypeMethods();
+  array = copyPrototype(Array.prototype);
+  return array;
 }
-var calledInOrder_1 = calledInOrder;
-var functionName$1 = function functionName(func) {
-  if (!func) {
-    return "";
+var calledInOrder_1;
+var hasRequiredCalledInOrder;
+function requireCalledInOrder() {
+  if (hasRequiredCalledInOrder) return calledInOrder_1;
+  hasRequiredCalledInOrder = 1;
+  var every2 = requireArray().every;
+  function hasCallsLeft(callMap, spy) {
+    if (callMap[spy.id] === void 0) {
+      callMap[spy.id] = 0;
+    }
+    return callMap[spy.id] < spy.callCount;
+  }
+  function checkAdjacentCalls(callMap, spy, index, spies) {
+    var calledBeforeNext = true;
+    if (index !== spies.length - 1) {
+      calledBeforeNext = spy.calledBefore(spies[index + 1]);
+    }
+    if (hasCallsLeft(callMap, spy) && calledBeforeNext) {
+      callMap[spy.id] += 1;
+      return true;
+    }
+    return false;
   }
-  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) {
-    return "";
+  function calledInOrder(spies) {
+    var callMap = {};
+    var _spies = arguments.length > 1 ? arguments : spies;
+    return every2(_spies, checkAdjacentCalls.bind(null, callMap));
   }
-};
-var functionName2 = functionName$1;
-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 */
-  functionName2(value.constructor) || null;
+  calledInOrder_1 = calledInOrder;
+  return calledInOrder_1;
+}
+var className_1;
+var hasRequiredClassName;
+function requireClassName() {
+  if (hasRequiredClassName) return className_1;
+  hasRequiredClassName = 1;
+  function className(value) {
+    const name = value.constructor && value.constructor.name;
+    return name || null;
+  }
+  className_1 = className;
+  return className_1;
 }
-var className_1 = className;
 var deprecated = {};
-(function(exports) {
-  exports.wrap = function(func, msg) {
-    var wrapped = function() {
-      exports.printWarning(msg);
-      return func.apply(this, arguments);
+var hasRequiredDeprecated;
+function requireDeprecated() {
+  if (hasRequiredDeprecated) return deprecated;
+  hasRequiredDeprecated = 1;
+  (function(exports) {
+    exports.wrap = function(func, msg) {
+      var wrapped = function() {
+        exports.printWarning(msg);
+        return func.apply(this, arguments);
+      };
+      if (func.prototype) {
+        wrapped.prototype = func.prototype;
+      }
+      return wrapped;
+    };
+    exports.defaultMsg = function(packageName, funcName) {
+      return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
     };
-    if (func.prototype) {
-      wrapped.prototype = func.prototype;
+    exports.printWarning = function(msg) {
+      if (typeof process === "object" && process.emitWarning) {
+        process.emitWarning(msg);
+      } else if (console.info) {
+        console.info(msg);
+      } else {
+        console.log(msg);
+      }
+    };
+  })(deprecated);
+  return deprecated;
+}
+var every;
+var hasRequiredEvery;
+function requireEvery() {
+  if (hasRequiredEvery) return every;
+  hasRequiredEvery = 1;
+  every = function every2(obj, fn2) {
+    var pass = true;
+    try {
+      obj.forEach(function() {
+        if (!fn2.apply(this, arguments)) {
+          throw new Error();
+        }
+      });
+    } catch (e) {
+      pass = false;
     }
-    return wrapped;
+    return pass;
   };
-  exports.defaultMsg = function(packageName, funcName) {
-    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
-  };
-  exports.printWarning = function(msg) {
-    if (typeof process === "object" && process.emitWarning) {
-      process.emitWarning(msg);
-    } else if (console.info) {
-      console.info(msg);
-    } else {
-      console.log(msg);
+  return every;
+}
+var functionName;
+var hasRequiredFunctionName;
+function requireFunctionName() {
+  if (hasRequiredFunctionName) return functionName;
+  hasRequiredFunctionName = 1;
+  functionName = function functionName2(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) {
+      return "";
     }
   };
-})(deprecated);
-var every = function every2(obj, fn2) {
-  var pass = true;
-  try {
-    obj.forEach(function() {
-      if (!fn2.apply(this, arguments)) {
-        throw new Error();
-      }
-    });
-  } catch (e) {
-    pass = false;
-  }
-  return pass;
-};
-var sort = array.sort;
-var slice = array.slice;
-function comparator(a, b) {
-  var aCall = a.getCall(0);
-  var bCall = b.getCall(0);
-  var aId = aCall && aCall.callId || -1;
-  var bId = bCall && bCall.callId || -1;
-  return aId < bId ? -1 : 1;
+  return functionName;
 }
-function orderByFirstCall(spies) {
-  return sort(slice(spies), comparator);
+var orderByFirstCall_1;
+var hasRequiredOrderByFirstCall;
+function requireOrderByFirstCall() {
+  if (hasRequiredOrderByFirstCall) return orderByFirstCall_1;
+  hasRequiredOrderByFirstCall = 1;
+  var sort = requireArray().sort;
+  var slice = requireArray().slice;
+  function comparator(a, b) {
+    var aCall = a.getCall(0);
+    var bCall = b.getCall(0);
+    var aId = aCall && aCall.callId || -1;
+    var bId = bCall && bCall.callId || -1;
+    return aId < bId ? -1 : 1;
+  }
+  function orderByFirstCall(spies) {
+    return sort(slice(spies), comparator);
+  }
+  orderByFirstCall_1 = orderByFirstCall;
+  return orderByFirstCall_1;
 }
-var orderByFirstCall_1 = orderByFirstCall;
-var copyPrototype$4 = copyPrototypeMethods;
-var _function = copyPrototype$4(Function.prototype);
-var copyPrototype$3 = copyPrototypeMethods;
-var map = copyPrototype$3(Map.prototype);
-var copyPrototype$2 = copyPrototypeMethods;
-var object = copyPrototype$2(Object.prototype);
-var copyPrototype$1 = copyPrototypeMethods;
-var set = copyPrototype$1(Set.prototype);
-var copyPrototype = copyPrototypeMethods;
-var string = copyPrototype(String.prototype);
-var prototypes = {
-  array,
-  function: _function,
-  map,
-  object,
-  set,
-  string
-};
-var typeDetect = { exports: {} };
-(function(module, exports) {
-  (function(global3, factory) {
-    module.exports = factory();
-  })(commonjsGlobal, function() {
-    var promiseExists = typeof Promise === "function";
-    var globalObject2 = typeof self === "object" ? self : commonjsGlobal;
-    var symbolExists = typeof Symbol !== "undefined";
-    var mapExists = typeof Map !== "undefined";
-    var setExists = typeof Set !== "undefined";
-    var weakMapExists = typeof WeakMap !== "undefined";
-    var weakSetExists = typeof WeakSet !== "undefined";
-    var dataViewExists = typeof DataView !== "undefined";
-    var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== "undefined";
-    var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== "undefined";
-    var setEntriesExists = setExists && typeof Set.prototype.entries === "function";
-    var mapEntriesExists = mapExists && typeof Map.prototype.entries === "function";
-    var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Set()).entries());
-    var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Map()).entries());
-    var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === "function";
-    var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
-    var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === "function";
-    var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]());
-    var toStringLeftSliceLength = 8;
-    var toStringRightSliceLength = -1;
-    function typeDetect2(obj) {
-      var typeofObj = typeof obj;
-      if (typeofObj !== "object") {
-        return typeofObj;
-      }
-      if (obj === null) {
-        return "null";
-      }
-      if (obj === globalObject2) {
-        return "global";
-      }
-      if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) {
-        return "Array";
-      }
-      if (typeof window === "object" && window !== null) {
-        if (typeof window.location === "object" && obj === window.location) {
-          return "Location";
-        }
-        if (typeof window.document === "object" && obj === window.document) {
-          return "Document";
-        }
-        if (typeof window.navigator === "object") {
-          if (typeof window.navigator.mimeTypes === "object" && obj === window.navigator.mimeTypes) {
-            return "MimeTypeArray";
-          }
-          if (typeof window.navigator.plugins === "object" && obj === window.navigator.plugins) {
-            return "PluginArray";
-          }
-        }
-        if ((typeof window.HTMLElement === "function" || typeof window.HTMLElement === "object") && obj instanceof window.HTMLElement) {
-          if (obj.tagName === "BLOCKQUOTE") {
-            return "HTMLQuoteElement";
-          }
-          if (obj.tagName === "TD") {
-            return "HTMLTableDataCellElement";
-          }
-          if (obj.tagName === "TH") {
-            return "HTMLTableHeaderCellElement";
-          }
-        }
-      }
-      var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
-      if (typeof stringTag === "string") {
-        return stringTag;
-      }
-      var objPrototype = Object.getPrototypeOf(obj);
-      if (objPrototype === RegExp.prototype) {
-        return "RegExp";
-      }
-      if (objPrototype === Date.prototype) {
-        return "Date";
-      }
-      if (promiseExists && objPrototype === Promise.prototype) {
-        return "Promise";
-      }
-      if (setExists && objPrototype === Set.prototype) {
-        return "Set";
-      }
-      if (mapExists && objPrototype === Map.prototype) {
-        return "Map";
-      }
-      if (weakSetExists && objPrototype === WeakSet.prototype) {
-        return "WeakSet";
-      }
-      if (weakMapExists && objPrototype === WeakMap.prototype) {
-        return "WeakMap";
-      }
-      if (dataViewExists && objPrototype === DataView.prototype) {
-        return "DataView";
-      }
-      if (mapExists && objPrototype === mapIteratorPrototype) {
-        return "Map Iterator";
-      }
-      if (setExists && objPrototype === setIteratorPrototype) {
-        return "Set Iterator";
-      }
-      if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {
-        return "Array Iterator";
-      }
-      if (stringIteratorExists && objPrototype === stringIteratorPrototype) {
-        return "String Iterator";
-      }
-      if (objPrototype === null) {
-        return "Object";
-      }
-      return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
-    }
-    return typeDetect2;
-  });
-})(typeDetect);
-var typeDetectExports = typeDetect.exports;
-var type = typeDetectExports;
-var typeOf = function typeOf2(value) {
-  return type(value).toLowerCase();
-};
-function valueToString(value) {
-  if (value && value.toString) {
-    return value.toString();
-  }
-  return String(value);
+var _function;
+var hasRequired_function;
+function require_function() {
+  if (hasRequired_function) return _function;
+  hasRequired_function = 1;
+  var copyPrototype = requireCopyPrototypeMethods();
+  _function = copyPrototype(Function.prototype);
+  return _function;
 }
-var valueToString_1 = valueToString;
-var lib = {
-  global: global2,
-  calledInOrder: calledInOrder_1,
-  className: className_1,
-  deprecated,
-  every,
-  functionName: functionName$1,
-  orderByFirstCall: orderByFirstCall_1,
-  prototypes,
-  typeOf,
-  valueToString: valueToString_1
-};
-var globalObject = lib.global;
-var timersModule;
-if (typeof __vitest_required__ !== "undefined") {
-  try {
-    timersModule = __vitest_required__.timers;
-  } catch (e) {
-  }
+var map;
+var hasRequiredMap;
+function requireMap() {
+  if (hasRequiredMap) return map;
+  hasRequiredMap = 1;
+  var copyPrototype = requireCopyPrototypeMethods();
+  map = copyPrototype(Map.prototype);
+  return map;
+}
+var object;
+var hasRequiredObject;
+function requireObject() {
+  if (hasRequiredObject) return object;
+  hasRequiredObject = 1;
+  var copyPrototype = requireCopyPrototypeMethods();
+  object = copyPrototype(Object.prototype);
+  return object;
+}
+var set;
+var hasRequiredSet;
+function requireSet() {
+  if (hasRequiredSet) return set;
+  hasRequiredSet = 1;
+  var copyPrototype = requireCopyPrototypeMethods();
+  set = copyPrototype(Set.prototype);
+  return set;
+}
+var string;
+var hasRequiredString;
+function requireString() {
+  if (hasRequiredString) return string;
+  hasRequiredString = 1;
+  var copyPrototype = requireCopyPrototypeMethods();
+  string = copyPrototype(String.prototype);
+  return string;
+}
+var prototypes;
+var hasRequiredPrototypes;
+function requirePrototypes() {
+  if (hasRequiredPrototypes) return prototypes;
+  hasRequiredPrototypes = 1;
+  prototypes = {
+    array: requireArray(),
+    function: require_function(),
+    map: requireMap(),
+    object: requireObject(),
+    set: requireSet(),
+    string: requireString()
+  };
+  return prototypes;
+}
+var typeDetect$1 = { exports: {} };
+var typeDetect = typeDetect$1.exports;
+var hasRequiredTypeDetect;
+function requireTypeDetect() {
+  if (hasRequiredTypeDetect) return typeDetect$1.exports;
+  hasRequiredTypeDetect = 1;
+  (function(module, exports) {
+    (function(global3, factory) {
+      module.exports = factory();
+    })(typeDetect, function() {
+      var promiseExists = typeof Promise === "function";
+      var globalObject = typeof self === "object" ? self : commonjsGlobal;
+      var symbolExists = typeof Symbol !== "undefined";
+      var mapExists = typeof Map !== "undefined";
+      var setExists = typeof Set !== "undefined";
+      var weakMapExists = typeof WeakMap !== "undefined";
+      var weakSetExists = typeof WeakSet !== "undefined";
+      var dataViewExists = typeof DataView !== "undefined";
+      var symbolIteratorExists = symbolExists && typeof Symbol.iterator !== "undefined";
+      var symbolToStringTagExists = symbolExists && typeof Symbol.toStringTag !== "undefined";
+      var setEntriesExists = setExists && typeof Set.prototype.entries === "function";
+      var mapEntriesExists = mapExists && typeof Map.prototype.entries === "function";
+      var setIteratorPrototype = setEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Set()).entries());
+      var mapIteratorPrototype = mapEntriesExists && Object.getPrototypeOf((/* @__PURE__ */ new Map()).entries());
+      var arrayIteratorExists = symbolIteratorExists && typeof Array.prototype[Symbol.iterator] === "function";
+      var arrayIteratorPrototype = arrayIteratorExists && Object.getPrototypeOf([][Symbol.iterator]());
+      var stringIteratorExists = symbolIteratorExists && typeof String.prototype[Symbol.iterator] === "function";
+      var stringIteratorPrototype = stringIteratorExists && Object.getPrototypeOf(""[Symbol.iterator]());
+      var toStringLeftSliceLength = 8;
+      var toStringRightSliceLength = -1;
+      function typeDetect2(obj) {
+        var typeofObj = typeof obj;
+        if (typeofObj !== "object") {
+          return typeofObj;
+        }
+        if (obj === null) {
+          return "null";
+        }
+        if (obj === globalObject) {
+          return "global";
+        }
+        if (Array.isArray(obj) && (symbolToStringTagExists === false || !(Symbol.toStringTag in obj))) {
+          return "Array";
+        }
+        if (typeof window === "object" && window !== null) {
+          if (typeof window.location === "object" && obj === window.location) {
+            return "Location";
+          }
+          if (typeof window.document === "object" && obj === window.document) {
+            return "Document";
+          }
+          if (typeof window.navigator === "object") {
+            if (typeof window.navigator.mimeTypes === "object" && obj === window.navigator.mimeTypes) {
+              return "MimeTypeArray";
+            }
+            if (typeof window.navigator.plugins === "object" && obj === window.navigator.plugins) {
+              return "PluginArray";
+            }
+          }
+          if ((typeof window.HTMLElement === "function" || typeof window.HTMLElement === "object") && obj instanceof window.HTMLElement) {
+            if (obj.tagName === "BLOCKQUOTE") {
+              return "HTMLQuoteElement";
+            }
+            if (obj.tagName === "TD") {
+              return "HTMLTableDataCellElement";
+            }
+            if (obj.tagName === "TH") {
+              return "HTMLTableHeaderCellElement";
+            }
+          }
+        }
+        var stringTag = symbolToStringTagExists && obj[Symbol.toStringTag];
+        if (typeof stringTag === "string") {
+          return stringTag;
+        }
+        var objPrototype = Object.getPrototypeOf(obj);
+        if (objPrototype === RegExp.prototype) {
+          return "RegExp";
+        }
+        if (objPrototype === Date.prototype) {
+          return "Date";
+        }
+        if (promiseExists && objPrototype === Promise.prototype) {
+          return "Promise";
+        }
+        if (setExists && objPrototype === Set.prototype) {
+          return "Set";
+        }
+        if (mapExists && objPrototype === Map.prototype) {
+          return "Map";
+        }
+        if (weakSetExists && objPrototype === WeakSet.prototype) {
+          return "WeakSet";
+        }
+        if (weakMapExists && objPrototype === WeakMap.prototype) {
+          return "WeakMap";
+        }
+        if (dataViewExists && objPrototype === DataView.prototype) {
+          return "DataView";
+        }
+        if (mapExists && objPrototype === mapIteratorPrototype) {
+          return "Map Iterator";
+        }
+        if (setExists && objPrototype === setIteratorPrototype) {
+          return "Set Iterator";
+        }
+        if (arrayIteratorExists && objPrototype === arrayIteratorPrototype) {
+          return "Array Iterator";
+        }
+        if (stringIteratorExists && objPrototype === stringIteratorPrototype) {
+          return "String Iterator";
+        }
+        if (objPrototype === null) {
+          return "Object";
+        }
+        return Object.prototype.toString.call(obj).slice(toStringLeftSliceLength, toStringRightSliceLength);
+      }
+      return typeDetect2;
+    });
+  })(typeDetect$1);
+  return typeDetect$1.exports;
 }
-function withGlobal(_global) {
-  const maxTimeout = Math.pow(2, 31) - 1;
-  const idCounterStart = 1e12;
-  const NOOP = function() {
-    return void 0;
+var typeOf;
+var hasRequiredTypeOf;
+function requireTypeOf() {
+  if (hasRequiredTypeOf) return typeOf;
+  hasRequiredTypeOf = 1;
+  var type = requireTypeDetect();
+  typeOf = function typeOf2(value) {
+    return type(value).toLowerCase();
   };
-  const NOOP_ARRAY = function() {
-    return [];
+  return typeOf;
+}
+var valueToString_1;
+var hasRequiredValueToString;
+function requireValueToString() {
+  if (hasRequiredValueToString) return valueToString_1;
+  hasRequiredValueToString = 1;
+  function valueToString(value) {
+    if (value && value.toString) {
+      return value.toString();
+    }
+    return String(value);
+  }
+  valueToString_1 = valueToString;
+  return valueToString_1;
+}
+var lib;
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib;
+  hasRequiredLib = 1;
+  lib = {
+    global: requireGlobal(),
+    calledInOrder: requireCalledInOrder(),
+    className: requireClassName(),
+    deprecated: requireDeprecated(),
+    every: requireEvery(),
+    functionName: requireFunctionName(),
+    orderByFirstCall: requireOrderByFirstCall(),
+    prototypes: requirePrototypes(),
+    typeOf: requireTypeOf(),
+    valueToString: requireValueToString()
   };
-  const timeoutResult = _global.setTimeout(NOOP, 0);
-  const addTimerReturnsObject = typeof timeoutResult === "object";
-  const hrtimePresent = _global.process && typeof _global.process.hrtime === "function";
-  const hrtimeBigintPresent = hrtimePresent && typeof _global.process.hrtime.bigint === "function";
-  const nextTickPresent = _global.process && typeof _global.process.nextTick === "function";
-  const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
-  const performancePresent = _global.performance && typeof _global.performance.now === "function";
-  const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
-  const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
-  const queueMicrotaskPresent = _global.hasOwnProperty("queueMicrotask");
-  const requestAnimationFramePresent = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
-  const cancelAnimationFramePresent = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
-  const requestIdleCallbackPresent = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
-  const cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
-  const setImmediatePresent = _global.setImmediate && typeof _global.setImmediate === "function";
-  const intlPresent = _global.Intl && typeof _global.Intl === "object";
-  _global.clearTimeout(timeoutResult);
-  const NativeDate = _global.Date;
-  const NativeIntl = _global.Intl;
-  let uniqueTimerId = idCounterStart;
-  function isNumberFinite(num) {
-    if (Number.isFinite) {
-      return Number.isFinite(num);
-    }
-    return isFinite(num);
-  }
-  let isNearInfiniteLimit = false;
-  function checkIsNearInfiniteLimit(clock, i) {
-    if (clock.loopLimit && i === clock.loopLimit - 1) {
-      isNearInfiniteLimit = true;
+  return lib;
+}
+var hasRequiredFakeTimersSrc;
+function requireFakeTimersSrc() {
+  if (hasRequiredFakeTimersSrc) return fakeTimersSrc;
+  hasRequiredFakeTimersSrc = 1;
+  const globalObject = requireLib().global;
+  let timersModule, timersPromisesModule;
+  if (typeof __vitest_required__ !== "undefined") {
+    try {
+      timersModule = __vitest_required__.timers;
+    } catch (e) {
+    }
+    try {
+      timersPromisesModule = __vitest_required__.timersPromises;
+    } catch (e) {
     }
   }
-  function resetIsNearInfiniteLimit() {
-    isNearInfiniteLimit = false;
-  }
-  function parseTime(str) {
-    if (!str) {
-      return 0;
-    }
-    const strings = str.split(":");
-    const l = strings.length;
-    let i = l;
-    let ms = 0;
-    let parsed;
-    if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+  function withGlobal(_global) {
+    const maxTimeout = Math.pow(2, 31) - 1;
+    const idCounterStart = 1e12;
+    const NOOP = function() {
+      return void 0;
+    };
+    const NOOP_ARRAY = function() {
+      return [];
+    };
+    const isPresent = {};
+    let timeoutResult, addTimerReturnsObject = false;
+    if (_global.setTimeout) {
+      isPresent.setTimeout = true;
+      timeoutResult = _global.setTimeout(NOOP, 0);
+      addTimerReturnsObject = typeof timeoutResult === "object";
+    }
+    isPresent.clearTimeout = Boolean(_global.clearTimeout);
+    isPresent.setInterval = Boolean(_global.setInterval);
+    isPresent.clearInterval = Boolean(_global.clearInterval);
+    isPresent.hrtime = _global.process && typeof _global.process.hrtime === "function";
+    isPresent.hrtimeBigint = isPresent.hrtime && typeof _global.process.hrtime.bigint === "function";
+    isPresent.nextTick = _global.process && typeof _global.process.nextTick === "function";
+    const utilPromisify = _global.process && _global.__vitest_required__ && _global.__vitest_required__.util.promisify;
+    isPresent.performance = _global.performance && typeof _global.performance.now === "function";
+    const hasPerformancePrototype = _global.Performance && (typeof _global.Performance).match(/^(function|object)$/);
+    const hasPerformanceConstructorPrototype = _global.performance && _global.performance.constructor && _global.performance.constructor.prototype;
+    isPresent.queueMicrotask = _global.hasOwnProperty("queueMicrotask");
+    isPresent.requestAnimationFrame = _global.requestAnimationFrame && typeof _global.requestAnimationFrame === "function";
+    isPresent.cancelAnimationFrame = _global.cancelAnimationFrame && typeof _global.cancelAnimationFrame === "function";
+    isPresent.requestIdleCallback = _global.requestIdleCallback && typeof _global.requestIdleCallback === "function";
+    isPresent.cancelIdleCallbackPresent = _global.cancelIdleCallback && typeof _global.cancelIdleCallback === "function";
+    isPresent.setImmediate = _global.setImmediate && typeof _global.setImmediate === "function";
+    isPresent.clearImmediate = _global.clearImmediate && typeof _global.clearImmediate === "function";
+    isPresent.Intl = _global.Intl && typeof _global.Intl === "object";
+    if (_global.clearTimeout) {
+      _global.clearTimeout(timeoutResult);
+    }
+    const NativeDate = _global.Date;
+    const NativeIntl = isPresent.Intl ? Object.defineProperties(
+      /* @__PURE__ */ Object.create(null),
+      Object.getOwnPropertyDescriptors(_global.Intl)
+    ) : void 0;
+    let uniqueTimerId = idCounterStart;
+    if (NativeDate === void 0) {
       throw new Error(
-        "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
+        "The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
       );
     }
-    while (i--) {
-      parsed = parseInt(strings[i], 10);
-      if (parsed >= 60) {
-        throw new Error(`Invalid time ${str}`);
+    isPresent.Date = true;
+    class FakePerformanceEntry {
+      constructor(name, entryType, startTime, duration) {
+        this.name = name;
+        this.entryType = entryType;
+        this.startTime = startTime;
+        this.duration = duration;
+      }
+      toJSON() {
+        return JSON.stringify({ ...this });
       }
-      ms += parsed * Math.pow(60, l - i - 1);
     }
-    return ms * 1e3;
-  }
-  function nanoRemainder(msFloat) {
-    const modulo = 1e6;
-    const remainder = msFloat * 1e6 % modulo;
-    const positiveRemainder = remainder < 0 ? remainder + modulo : remainder;
-    return Math.floor(positiveRemainder);
-  }
-  function getEpoch(epoch) {
-    if (!epoch) {
-      return 0;
+    function isNumberFinite(num) {
+      if (Number.isFinite) {
+        return Number.isFinite(num);
+      }
+      return isFinite(num);
     }
-    if (typeof epoch.getTime === "function") {
-      return epoch.getTime();
+    let isNearInfiniteLimit = false;
+    function checkIsNearInfiniteLimit(clock, i) {
+      if (clock.loopLimit && i === clock.loopLimit - 1) {
+        isNearInfiniteLimit = true;
+      }
     }
-    if (typeof epoch === "number") {
-      return epoch;
+    function resetIsNearInfiniteLimit() {
+      isNearInfiniteLimit = false;
     }
-    throw new TypeError("now should be milliseconds since UNIX epoch");
-  }
-  function inRange(from, to, timer) {
-    return timer && timer.callAt >= from && timer.callAt <= to;
-  }
-  function getInfiniteLoopError(clock, job) {
-    const infiniteLoopError = new Error(
-      `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`
-    );
-    if (!job.error) {
-      return infiniteLoopError;
+    function parseTime(str) {
+      if (!str) {
+        return 0;
+      }
+      const strings = str.split(":");
+      const l = strings.length;
+      let i = l;
+      let ms = 0;
+      let parsed;
+      if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+        throw new Error(
+          "tick only understands numbers, 'm:s' and 'h:m:s'. Each part must be two digits"
+        );
+      }
+      while (i--) {
+        parsed = parseInt(strings[i], 10);
+        if (parsed >= 60) {
+          throw new Error(`Invalid time ${str}`);
+        }
+        ms += parsed * Math.pow(60, l - i - 1);
+      }
+      return ms * 1e3;
     }
-    const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
-    let clockMethodPattern = new RegExp(
-      String(Object.keys(clock).join("|"))
-    );
-    if (addTimerReturnsObject) {
-      clockMethodPattern = new RegExp(
-        `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`
-      );
+    function nanoRemainder(msFloat) {
+      const modulo = 1e6;
+      const remainder = msFloat * 1e6 % modulo;
+      const positiveRemainder = remainder < 0 ? remainder + modulo : remainder;
+      return Math.floor(positiveRemainder);
     }
-    let matchedLineIndex = -1;
-    job.error.stack.split("\n").some(function(line, i) {
-      const matchedComputedTarget = line.match(computedTargetPattern);
-      if (matchedComputedTarget) {
-        matchedLineIndex = i;
-        return true;
+    function getEpoch(epoch) {
+      if (!epoch) {
+        return 0;
       }
-      const matchedClockMethod = line.match(clockMethodPattern);
-      if (matchedClockMethod) {
-        matchedLineIndex = i;
-        return false;
+      if (typeof epoch.getTime === "function") {
+        return epoch.getTime();
       }
-      return matchedLineIndex >= 0;
-    });
-    const stack = `${infiniteLoopError}
+      if (typeof epoch === "number") {
+        return epoch;
+      }
+      throw new TypeError("now should be milliseconds since UNIX epoch");
+    }
+    function inRange(from, to, timer) {
+      return timer && timer.callAt >= from && timer.callAt <= to;
+    }
+    function getInfiniteLoopError(clock, job) {
+      const infiniteLoopError = new Error(
+        `Aborting after running ${clock.loopLimit} timers, assuming an infinite loop!`
+      );
+      if (!job.error) {
+        return infiniteLoopError;
+      }
+      const computedTargetPattern = /target\.*[<|(|[].*?[>|\]|)]\s*/;
+      let clockMethodPattern = new RegExp(
+        String(Object.keys(clock).join("|"))
+      );
+      if (addTimerReturnsObject) {
+        clockMethodPattern = new RegExp(
+          `\\s+at (Object\\.)?(?:${Object.keys(clock).join("|")})\\s+`
+        );
+      }
+      let matchedLineIndex = -1;
+      job.error.stack.split("\n").some(function(line, i) {
+        const matchedComputedTarget = line.match(computedTargetPattern);
+        if (matchedComputedTarget) {
+          matchedLineIndex = i;
+          return true;
+        }
+        const matchedClockMethod = line.match(clockMethodPattern);
+        if (matchedClockMethod) {
+          matchedLineIndex = i;
+          return false;
+        }
+        return matchedLineIndex >= 0;
+      });
+      const stack = `${infiniteLoopError}
 ${job.type || "Microtask"} - ${job.func.name || "anonymous"}
 ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
-    try {
-      Object.defineProperty(infiniteLoopError, "stack", {
-        value: stack
-      });
-    } catch (e) {
-    }
-    return infiniteLoopError;
-  }
-  function mirrorDateProperties(target, source) {
-    let prop;
-    for (prop in source) {
-      if (source.hasOwnProperty(prop)) {
-        target[prop] = source[prop];
+      try {
+        Object.defineProperty(infiniteLoopError, "stack", {
+          value: stack
+        });
+      } catch (e) {
       }
+      return infiniteLoopError;
     }
-    if (source.now) {
-      target.now = function now2() {
-        return target.clock.now;
+    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) {
+          if (arguments.length === 0) {
+            super(ClockDate.clock.now);
+          } else {
+            super(...arguments);
+          }
+          Object.defineProperty(this, "constructor", {
+            value: NativeDate,
+            enumerable: false
+          });
+        }
+        static [Symbol.hasInstance](instance) {
+          return instance instanceof NativeDate;
+        }
+      }
+      ClockDate.isFake = true;
+      if (NativeDate.now) {
+        ClockDate.now = function now2() {
+          return ClockDate.clock.now;
+        };
+      }
+      if (NativeDate.toSource) {
+        ClockDate.toSource = function toSource() {
+          return NativeDate.toSource();
+        };
+      }
+      ClockDate.toString = function toString() {
+        return NativeDate.toString();
       };
-    } else {
-      delete target.now;
+      const ClockDateProxy = new Proxy(ClockDate, {
+        // handler for [[Call]] invocations (i.e. not using `new`)
+        apply() {
+          if (this instanceof ClockDate) {
+            throw new TypeError(
+              "A Proxy should only capture `new` calls with the `construct` handler. This is not supposed to be possible, so check the logic."
+            );
+          }
+          return new NativeDate(ClockDate.clock.now).toString();
+        }
+      });
+      return ClockDateProxy;
     }
-    if (source.toSource) {
-      target.toSource = function toSource() {
-        return source.toSource();
+    function createIntl() {
+      const ClockIntl = {};
+      Object.getOwnPropertyNames(NativeIntl).forEach(
+        (property) => ClockIntl[property] = NativeIntl[property]
+      );
+      ClockIntl.DateTimeFormat = function(...args) {
+        const realFormatter = new NativeIntl.DateTimeFormat(...args);
+        const formatter = {};
+        ["formatRange", "formatRangeToParts", "resolvedOptions"].forEach(
+          (method) => {
+            formatter[method] = realFormatter[method].bind(realFormatter);
+          }
+        );
+        ["format", "formatToParts"].forEach((method) => {
+          formatter[method] = function(date) {
+            return realFormatter[method](date || ClockIntl.clock.now);
+          };
+        });
+        return formatter;
       };
-    } else {
-      delete target.toSource;
+      ClockIntl.DateTimeFormat.prototype = Object.create(
+        NativeIntl.DateTimeFormat.prototype
+      );
+      ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf;
+      return ClockIntl;
     }
-    target.toString = function toString() {
-      return source.toString();
-    };
-    target.prototype = source.prototype;
-    target.parse = source.parse;
-    target.UTC = source.UTC;
-    target.prototype.toUTCString = source.prototype.toUTCString;
-    target.isFake = true;
-    return target;
-  }
-  function createDate() {
-    function ClockDate(year, month, date, hour, minute, second, ms) {
-      if (!(this instanceof ClockDate)) {
-        return new NativeDate(ClockDate.clock.now).toString();
-      }
-      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
-          );
+    function enqueueJob(clock, job) {
+      if (!clock.jobs) {
+        clock.jobs = [];
       }
+      clock.jobs.push(job);
     }
-    return mirrorDateProperties(ClockDate, NativeDate);
-  }
-  function createIntl() {
-    const ClockIntl = { ...NativeIntl };
-    ClockIntl.DateTimeFormat = function(...args) {
-      const realFormatter = new NativeIntl.DateTimeFormat(...args);
-      const formatter = {};
-      ["formatRange", "formatRangeToParts", "resolvedOptions"].forEach(
-        (method) => {
-          formatter[method] = realFormatter[method].bind(realFormatter);
+    function runJobs(clock) {
+      if (!clock.jobs) {
+        return;
+      }
+      for (let i = 0; i < clock.jobs.length; i++) {
+        const job = clock.jobs[i];
+        job.func.apply(null, job.args);
+        checkIsNearInfiniteLimit(clock, i);
+        if (clock.loopLimit && i > clock.loopLimit) {
+          throw getInfiniteLoopError(clock, job);
         }
-      );
-      ["format", "formatToParts"].forEach((method) => {
-        formatter[method] = function(date) {
-          return realFormatter[method](date || ClockIntl.clock.now);
-        };
-      });
-      return formatter;
-    };
-    ClockIntl.DateTimeFormat.prototype = Object.create(
-      NativeIntl.DateTimeFormat.prototype
-    );
-    ClockIntl.DateTimeFormat.supportedLocalesOf = NativeIntl.DateTimeFormat.supportedLocalesOf;
-    return ClockIntl;
-  }
-  function enqueueJob(clock, job) {
-    if (!clock.jobs) {
+      }
+      resetIsNearInfiniteLimit();
       clock.jobs = [];
     }
-    clock.jobs.push(job);
-  }
-  function runJobs(clock) {
-    if (!clock.jobs) {
-      return;
-    }
-    for (let i = 0; i < clock.jobs.length; i++) {
-      const job = clock.jobs[i];
-      job.func.apply(null, job.args);
-      checkIsNearInfiniteLimit(clock, i);
-      if (clock.loopLimit && i > clock.loopLimit) {
-        throw getInfiniteLoopError(clock, job);
+    function addTimer(clock, timer) {
+      if (timer.func === void 0) {
+        throw new Error("Callback must be provided to timer calls");
       }
-    }
-    resetIsNearInfiniteLimit();
-    clock.jobs = [];
-  }
-  function addTimer(clock, timer) {
-    if (timer.func === void 0) {
-      throw new Error("Callback must be provided to timer calls");
-    }
-    if (addTimerReturnsObject) {
-      if (typeof timer.func !== "function") {
-        throw new TypeError(
-          `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`
-        );
+      if (addTimerReturnsObject) {
+        if (typeof timer.func !== "function") {
+          throw new TypeError(
+            `[ERR_INVALID_CALLBACK]: Callback must be a function. Received ${timer.func} of type ${typeof timer.func}`
+          );
+        }
       }
-    }
-    if (isNearInfiniteLimit) {
-      timer.error = new Error();
-    }
-    timer.type = timer.immediate ? "Immediate" : "Timeout";
-    if (timer.hasOwnProperty("delay")) {
-      if (typeof timer.delay !== "number") {
-        timer.delay = parseInt(timer.delay, 10);
-      }
-      if (!isNumberFinite(timer.delay)) {
-        timer.delay = 0;
-      }
-      timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
-      timer.delay = Math.max(0, timer.delay);
-    }
-    if (timer.hasOwnProperty("interval")) {
-      timer.type = "Interval";
-      timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
-    }
-    if (timer.hasOwnProperty("animation")) {
-      timer.type = "AnimationFrame";
-      timer.animation = true;
-    }
-    if (timer.hasOwnProperty("idleCallback")) {
-      timer.type = "IdleCallback";
-      timer.idleCallback = true;
-    }
-    if (!clock.timers) {
-      clock.timers = {};
-    }
-    timer.id = uniqueTimerId++;
-    timer.createdAt = clock.now;
-    timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
-    clock.timers[timer.id] = timer;
-    if (addTimerReturnsObject) {
-      const res = {
-        refed: true,
-        ref: function() {
-          this.refed = true;
-          return res;
-        },
-        unref: function() {
-          this.refed = false;
-          return res;
-        },
-        hasRef: function() {
-          return this.refed;
-        },
-        refresh: function() {
-          timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
-          clock.timers[timer.id] = timer;
-          return res;
-        },
-        [Symbol.toPrimitive]: function() {
-          return timer.id;
+      if (isNearInfiniteLimit) {
+        timer.error = new Error();
+      }
+      timer.type = timer.immediate ? "Immediate" : "Timeout";
+      if (timer.hasOwnProperty("delay")) {
+        if (typeof timer.delay !== "number") {
+          timer.delay = parseInt(timer.delay, 10);
         }
-      };
-      return res;
-    }
-    return timer.id;
-  }
-  function compareTimers(a, b) {
-    if (a.callAt < b.callAt) {
-      return -1;
-    }
-    if (a.callAt > b.callAt) {
-      return 1;
-    }
-    if (a.immediate && !b.immediate) {
-      return -1;
-    }
-    if (!a.immediate && b.immediate) {
-      return 1;
-    }
-    if (a.createdAt < b.createdAt) {
-      return -1;
-    }
-    if (a.createdAt > b.createdAt) {
-      return 1;
-    }
-    if (a.id < b.id) {
-      return -1;
+        if (!isNumberFinite(timer.delay)) {
+          timer.delay = 0;
+        }
+        timer.delay = timer.delay > maxTimeout ? 1 : timer.delay;
+        timer.delay = Math.max(0, timer.delay);
+      }
+      if (timer.hasOwnProperty("interval")) {
+        timer.type = "Interval";
+        timer.interval = timer.interval > maxTimeout ? 1 : timer.interval;
+      }
+      if (timer.hasOwnProperty("animation")) {
+        timer.type = "AnimationFrame";
+        timer.animation = true;
+      }
+      if (timer.hasOwnProperty("idleCallback")) {
+        timer.type = "IdleCallback";
+        timer.idleCallback = true;
+      }
+      if (!clock.timers) {
+        clock.timers = {};
+      }
+      timer.id = uniqueTimerId++;
+      timer.createdAt = clock.now;
+      timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+      clock.timers[timer.id] = timer;
+      if (addTimerReturnsObject) {
+        const res = {
+          refed: true,
+          ref: function() {
+            this.refed = true;
+            return res;
+          },
+          unref: function() {
+            this.refed = false;
+            return res;
+          },
+          hasRef: function() {
+            return this.refed;
+          },
+          refresh: function() {
+            timer.callAt = clock.now + (parseInt(timer.delay) || (clock.duringTick ? 1 : 0));
+            clock.timers[timer.id] = timer;
+            return res;
+          },
+          [Symbol.toPrimitive]: function() {
+            return timer.id;
+          }
+        };
+        return res;
+      }
+      return timer.id;
     }
-    if (a.id > b.id) {
-      return 1;
+    function compareTimers(a, b) {
+      if (a.callAt < b.callAt) {
+        return -1;
+      }
+      if (a.callAt > b.callAt) {
+        return 1;
+      }
+      if (a.immediate && !b.immediate) {
+        return -1;
+      }
+      if (!a.immediate && b.immediate) {
+        return 1;
+      }
+      if (a.createdAt < b.createdAt) {
+        return -1;
+      }
+      if (a.createdAt > b.createdAt) {
+        return 1;
+      }
+      if (a.id < b.id) {
+        return -1;
+      }
+      if (a.id > b.id) {
+        return 1;
+      }
     }
-  }
-  function firstTimerInRange(clock, from, to) {
-    const timers2 = clock.timers;
-    let timer = null;
-    let id, isInRange;
-    for (id in timers2) {
-      if (timers2.hasOwnProperty(id)) {
-        isInRange = inRange(from, to, timers2[id]);
-        if (isInRange && (!timer || compareTimers(timer, timers2[id]) === 1)) {
-          timer = timers2[id];
+    function firstTimerInRange(clock, from, to) {
+      const timers2 = clock.timers;
+      let timer = null;
+      let id, isInRange;
+      for (id in timers2) {
+        if (timers2.hasOwnProperty(id)) {
+          isInRange = inRange(from, to, timers2[id]);
+          if (isInRange && (!timer || compareTimers(timer, timers2[id]) === 1)) {
+            timer = timers2[id];
+          }
         }
       }
+      return timer;
     }
-    return timer;
-  }
-  function firstTimer(clock) {
-    const timers2 = clock.timers;
-    let timer = null;
-    let id;
-    for (id in timers2) {
-      if (timers2.hasOwnProperty(id)) {
-        if (!timer || compareTimers(timer, timers2[id]) === 1) {
-          timer = timers2[id];
+    function firstTimer(clock) {
+      const timers2 = clock.timers;
+      let timer = null;
+      let id;
+      for (id in timers2) {
+        if (timers2.hasOwnProperty(id)) {
+          if (!timer || compareTimers(timer, timers2[id]) === 1) {
+            timer = timers2[id];
+          }
         }
       }
+      return timer;
     }
-    return timer;
-  }
-  function lastTimer(clock) {
-    const timers2 = clock.timers;
-    let timer = null;
-    let id;
-    for (id in timers2) {
-      if (timers2.hasOwnProperty(id)) {
-        if (!timer || compareTimers(timer, timers2[id]) === -1) {
-          timer = timers2[id];
+    function lastTimer(clock) {
+      const timers2 = clock.timers;
+      let timer = null;
+      let id;
+      for (id in timers2) {
+        if (timers2.hasOwnProperty(id)) {
+          if (!timer || compareTimers(timer, timers2[id]) === -1) {
+            timer = timers2[id];
+          }
         }
       }
+      return timer;
     }
-    return timer;
-  }
-  function callTimer(clock, timer) {
-    if (typeof timer.interval === "number") {
-      clock.timers[timer.id].callAt += timer.interval;
-    } else {
-      delete clock.timers[timer.id];
-    }
-    if (typeof timer.func === "function") {
-      timer.func.apply(null, timer.args);
-    } else {
-      const eval2 = eval;
-      (function() {
-        eval2(timer.func);
-      })();
-    }
-  }
-  function getClearHandler(ttype) {
-    if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
-      return `cancel${ttype}`;
+    function callTimer(clock, timer) {
+      if (typeof timer.interval === "number") {
+        clock.timers[timer.id].callAt += timer.interval;
+      } else {
+        delete clock.timers[timer.id];
+      }
+      if (typeof timer.func === "function") {
+        timer.func.apply(null, timer.args);
+      } else {
+        const eval2 = eval;
+        (function() {
+          eval2(timer.func);
+        })();
+      }
     }
-    return `clear${ttype}`;
-  }
-  function getScheduleHandler(ttype) {
-    if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
-      return `request${ttype}`;
+    function getClearHandler(ttype) {
+      if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
+        return `cancel${ttype}`;
+      }
+      return `clear${ttype}`;
     }
-    return `set${ttype}`;
-  }
-  function createWarnOnce() {
-    let calls = 0;
-    return function(msg) {
-      !calls++ && console.warn(msg);
-    };
-  }
-  const warnOnce = createWarnOnce();
-  function clearTimer(clock, timerId, ttype) {
-    if (!timerId) {
-      return;
+    function getScheduleHandler(ttype) {
+      if (ttype === "IdleCallback" || ttype === "AnimationFrame") {
+        return `request${ttype}`;
+      }
+      return `set${ttype}`;
     }
-    if (!clock.timers) {
-      clock.timers = {};
+    function createWarnOnce() {
+      let calls = 0;
+      return function(msg) {
+        !calls++ && console.warn(msg);
+      };
     }
-    const id = Number(timerId);
-    if (Number.isNaN(id) || id < idCounterStart) {
-      const handlerName = getClearHandler(ttype);
-      if (clock.shouldClearNativeTimers === true) {
-        const nativeHandler = clock[`_${handlerName}`];
-        return typeof nativeHandler === "function" ? nativeHandler(timerId) : void 0;
+    const warnOnce = createWarnOnce();
+    function clearTimer(clock, timerId, ttype) {
+      if (!timerId) {
+        return;
+      }
+      if (!clock.timers) {
+        clock.timers = {};
       }
-      warnOnce(
-        `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.
+      const id = Number(timerId);
+      if (Number.isNaN(id) || id < idCounterStart) {
+        const handlerName = getClearHandler(ttype);
+        if (clock.shouldClearNativeTimers === true) {
+          const nativeHandler = clock[`_${handlerName}`];
+          return typeof nativeHandler === "function" ? nativeHandler(timerId) : void 0;
+        }
+        warnOnce(
+          `FakeTimers: ${handlerName} was invoked to clear a native timer instead of one created by this library.
 To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
-      );
-    }
-    if (clock.timers.hasOwnProperty(id)) {
-      const timer = clock.timers[id];
-      if (timer.type === ttype || timer.type === "Timeout" && ttype === "Interval" || timer.type === "Interval" && ttype === "Timeout") {
-        delete clock.timers[id];
-      } else {
-        const clear = getClearHandler(ttype);
-        const schedule = getScheduleHandler(timer.type);
-        throw new Error(
-          `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`
         );
       }
-    }
-  }
-  function uninstall(clock, config) {
-    let method, i, l;
-    const installedHrTime = "_hrtime";
-    const installedNextTick = "_nextTick";
-    for (i = 0, l = clock.methods.length; i < l; i++) {
-      method = clock.methods[i];
-      if (method === "hrtime" && _global.process) {
-        _global.process.hrtime = clock[installedHrTime];
-      } else if (method === "nextTick" && _global.process) {
-        _global.process.nextTick = clock[installedNextTick];
-      } else if (method === "performance") {
-        const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
-          clock,
-          `_${method}`
-        );
-        if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
-          Object.defineProperty(
-            _global,
-            method,
-            originalPerfDescriptor
+      if (clock.timers.hasOwnProperty(id)) {
+        const timer = clock.timers[id];
+        if (timer.type === ttype || timer.type === "Timeout" && ttype === "Interval" || timer.type === "Interval" && ttype === "Timeout") {
+          delete clock.timers[id];
+        } else {
+          const clear = getClearHandler(ttype);
+          const schedule = getScheduleHandler(timer.type);
+          throw new Error(
+            `Cannot clear timer: timer created with ${schedule}() but cleared with ${clear}()`
           );
-        } else if (originalPerfDescriptor.configurable) {
-          _global[method] = clock[`_${method}`];
         }
-      } else {
-        if (_global[method] && _global[method].hadOwnProperty) {
-          _global[method] = clock[`_${method}`];
+      }
+    }
+    function uninstall(clock, config) {
+      let method, i, l;
+      const installedHrTime = "_hrtime";
+      const installedNextTick = "_nextTick";
+      for (i = 0, l = clock.methods.length; i < l; i++) {
+        method = clock.methods[i];
+        if (method === "hrtime" && _global.process) {
+          _global.process.hrtime = clock[installedHrTime];
+        } else if (method === "nextTick" && _global.process) {
+          _global.process.nextTick = clock[installedNextTick];
+        } else if (method === "performance") {
+          const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
+            clock,
+            `_${method}`
+          );
+          if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
+            Object.defineProperty(
+              _global,
+              method,
+              originalPerfDescriptor
+            );
+          } else if (originalPerfDescriptor.configurable) {
+            _global[method] = clock[`_${method}`];
+          }
         } else {
-          try {
-            delete _global[method];
-          } catch (ignore) {
+          if (_global[method] && _global[method].hadOwnProperty) {
+            _global[method] = clock[`_${method}`];
+          } else {
+            try {
+              delete _global[method];
+            } catch (ignore) {
+            }
           }
         }
-      }
-      if (clock.timersModuleMethods !== void 0) {
-        for (let j = 0; j < clock.timersModuleMethods.length; j++) {
-          const entry = clock.timersModuleMethods[j];
-          timersModule[entry.methodName] = entry.original;
+        if (clock.timersModuleMethods !== void 0) {
+          for (let j = 0; j < clock.timersModuleMethods.length; j++) {
+            const entry = clock.timersModuleMethods[j];
+            timersModule[entry.methodName] = entry.original;
+          }
+        }
+        if (clock.timersPromisesModuleMethods !== void 0) {
+          for (let j = 0; j < clock.timersPromisesModuleMethods.length; j++) {
+            const entry = clock.timersPromisesModuleMethods[j];
+            timersPromisesModule[entry.methodName] = entry.original;
+          }
         }
       }
+      if (config.shouldAdvanceTime === true) {
+        _global.clearInterval(clock.attachedInterval);
+      }
+      clock.methods = [];
+      for (const [listener, signal] of clock.abortListenerMap.entries()) {
+        signal.removeEventListener("abort", listener);
+        clock.abortListenerMap.delete(listener);
+      }
+      if (!clock.timers) {
+        return [];
+      }
+      return Object.keys(clock.timers).map(function mapper(key) {
+        return clock.timers[key];
+      });
     }
-    if (config.shouldAdvanceTime === true) {
-      _global.clearInterval(clock.attachedInterval);
-    }
-    clock.methods = [];
-    if (!clock.timers) {
-      return [];
-    }
-    return Object.keys(clock.timers).map(function mapper(key) {
-      return clock.timers[key];
-    });
-  }
-  function hijackMethod(target, method, clock) {
-    clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
-      target,
-      method
-    );
-    clock[`_${method}`] = target[method];
-    if (method === "Date") {
-      const date = mirrorDateProperties(clock[method], target[method]);
-      target[method] = date;
-    } else if (method === "Intl") {
-      target[method] = clock[method];
-    } else if (method === "performance") {
-      const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
+    function hijackMethod(target, method, clock) {
+      clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(
         target,
         method
       );
-      if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
-        Object.defineProperty(
-          clock,
-          `_${method}`,
-          originalPerfDescriptor
-        );
-        const perfDescriptor = Object.getOwnPropertyDescriptor(
-          clock,
+      clock[`_${method}`] = target[method];
+      if (method === "Date") {
+        target[method] = clock[method];
+      } else if (method === "Intl") {
+        target[method] = clock[method];
+      } else if (method === "performance") {
+        const originalPerfDescriptor = Object.getOwnPropertyDescriptor(
+          target,
           method
         );
-        Object.defineProperty(target, method, perfDescriptor);
+        if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
+          Object.defineProperty(
+            clock,
+            `_${method}`,
+            originalPerfDescriptor
+          );
+          const perfDescriptor = Object.getOwnPropertyDescriptor(
+            clock,
+            method
+          );
+          Object.defineProperty(target, method, perfDescriptor);
+        } else {
+          target[method] = clock[method];
+        }
       } else {
-        target[method] = clock[method];
+        target[method] = function() {
+          return clock[method].apply(clock, arguments);
+        };
+        Object.defineProperties(
+          target[method],
+          Object.getOwnPropertyDescriptors(clock[method])
+        );
       }
-    } else {
-      target[method] = function() {
-        return clock[method].apply(clock, arguments);
-      };
-      Object.defineProperties(
-        target[method],
-        Object.getOwnPropertyDescriptors(clock[method])
-      );
+      target[method].clock = clock;
     }
-    target[method].clock = clock;
-  }
-  function doIntervalTick(clock, advanceTimeDelta) {
-    clock.tick(advanceTimeDelta);
-  }
-  const timers = {
-    setTimeout: _global.setTimeout,
-    clearTimeout: _global.clearTimeout,
-    setInterval: _global.setInterval,
-    clearInterval: _global.clearInterval,
-    Date: _global.Date
-  };
-  if (setImmediatePresent) {
-    timers.setImmediate = _global.setImmediate;
-    timers.clearImmediate = _global.clearImmediate;
-  }
-  if (hrtimePresent) {
-    timers.hrtime = _global.process.hrtime;
-  }
-  if (nextTickPresent) {
-    timers.nextTick = _global.process.nextTick;
-  }
-  if (performancePresent) {
-    timers.performance = _global.performance;
-  }
-  if (requestAnimationFramePresent) {
-    timers.requestAnimationFrame = _global.requestAnimationFrame;
-  }
-  if (queueMicrotaskPresent) {
-    timers.queueMicrotask = true;
-  }
-  if (cancelAnimationFramePresent) {
-    timers.cancelAnimationFrame = _global.cancelAnimationFrame;
-  }
-  if (requestIdleCallbackPresent) {
-    timers.requestIdleCallback = _global.requestIdleCallback;
-  }
-  if (cancelIdleCallbackPresent) {
-    timers.cancelIdleCallback = _global.cancelIdleCallback;
-  }
-  if (intlPresent) {
-    timers.Intl = _global.Intl;
-  }
-  const originalSetTimeout = _global.setImmediate || _global.setTimeout;
-  function createClock(start, loopLimit) {
-    start = Math.floor(getEpoch(start));
-    loopLimit = loopLimit || 1e3;
-    let nanos = 0;
-    const adjustedSystemTime = [0, 0];
-    if (NativeDate === void 0) {
-      throw new Error(
-        "The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
-      );
+    function doIntervalTick(clock, advanceTimeDelta) {
+      clock.tick(advanceTimeDelta);
     }
-    const clock = {
-      now: start,
-      Date: createDate(),
-      loopLimit
+    const timers = {
+      setTimeout: _global.setTimeout,
+      clearTimeout: _global.clearTimeout,
+      setInterval: _global.setInterval,
+      clearInterval: _global.clearInterval,
+      Date: _global.Date
     };
-    clock.Date.clock = clock;
-    function getTimeToNextFrame() {
-      return 16 - (clock.now - start) % 16;
-    }
-    function hrtime(prev) {
-      const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
-      const secsSinceStart = Math.floor(millisSinceStart / 1e3);
-      const remainderInNanos = (millisSinceStart - secsSinceStart * 1e3) * 1e6 + nanos - adjustedSystemTime[1];
-      if (Array.isArray(prev)) {
-        if (prev[1] > 1e9) {
-          throw new TypeError(
-            "Number of nanoseconds can't exceed a billion"
-          );
-        }
-        const oldSecs = prev[0];
-        let nanoDiff = remainderInNanos - prev[1];
-        let secDiff = secsSinceStart - oldSecs;
-        if (nanoDiff < 0) {
-          nanoDiff += 1e9;
-          secDiff -= 1;
-        }
-        return [secDiff, nanoDiff];
-      }
-      return [secsSinceStart, remainderInNanos];
+    if (isPresent.setImmediate) {
+      timers.setImmediate = _global.setImmediate;
     }
-    function fakePerformanceNow() {
-      const hrt = hrtime();
-      const millis = hrt[0] * 1e3 + hrt[1] / 1e6;
-      return millis;
+    if (isPresent.clearImmediate) {
+      timers.clearImmediate = _global.clearImmediate;
     }
-    if (hrtimeBigintPresent) {
-      hrtime.bigint = function() {
-        const parts = hrtime();
-        return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
-      };
+    if (isPresent.hrtime) {
+      timers.hrtime = _global.process.hrtime;
+    }
+    if (isPresent.nextTick) {
+      timers.nextTick = _global.process.nextTick;
+    }
+    if (isPresent.performance) {
+      timers.performance = _global.performance;
     }
-    if (intlPresent) {
-      clock.Intl = createIntl();
-      clock.Intl.clock = clock;
+    if (isPresent.requestAnimationFrame) {
+      timers.requestAnimationFrame = _global.requestAnimationFrame;
     }
-    clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
-      let timeToNextIdlePeriod = 0;
-      if (clock.countTimers() > 0) {
-        timeToNextIdlePeriod = 50;
+    if (isPresent.queueMicrotask) {
+      timers.queueMicrotask = _global.queueMicrotask;
+    }
+    if (isPresent.cancelAnimationFrame) {
+      timers.cancelAnimationFrame = _global.cancelAnimationFrame;
+    }
+    if (isPresent.requestIdleCallback) {
+      timers.requestIdleCallback = _global.requestIdleCallback;
+    }
+    if (isPresent.cancelIdleCallback) {
+      timers.cancelIdleCallback = _global.cancelIdleCallback;
+    }
+    if (isPresent.Intl) {
+      timers.Intl = NativeIntl;
+    }
+    const originalSetTimeout = _global.setImmediate || _global.setTimeout;
+    function createClock(start, loopLimit) {
+      start = Math.floor(getEpoch(start));
+      loopLimit = loopLimit || 1e3;
+      let nanos = 0;
+      const adjustedSystemTime = [0, 0];
+      const clock = {
+        now: start,
+        Date: createDate(),
+        loopLimit
+      };
+      clock.Date.clock = clock;
+      function getTimeToNextFrame() {
+        return 16 - (clock.now - start) % 16;
+      }
+      function hrtime(prev) {
+        const millisSinceStart = clock.now - adjustedSystemTime[0] - start;
+        const secsSinceStart = Math.floor(millisSinceStart / 1e3);
+        const remainderInNanos = (millisSinceStart - secsSinceStart * 1e3) * 1e6 + nanos - adjustedSystemTime[1];
+        if (Array.isArray(prev)) {
+          if (prev[1] > 1e9) {
+            throw new TypeError(
+              "Number of nanoseconds can't exceed a billion"
+            );
+          }
+          const oldSecs = prev[0];
+          let nanoDiff = remainderInNanos - prev[1];
+          let secDiff = secsSinceStart - oldSecs;
+          if (nanoDiff < 0) {
+            nanoDiff += 1e9;
+            secDiff -= 1;
+          }
+          return [secDiff, nanoDiff];
+        }
+        return [secsSinceStart, remainderInNanos];
       }
-      const result = addTimer(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 2),
-        delay: typeof timeout === "undefined" ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod),
-        idleCallback: true
-      });
-      return Number(result);
-    };
-    clock.cancelIdleCallback = function cancelIdleCallback(timerId) {
-      return clearTimer(clock, timerId, "IdleCallback");
-    };
-    clock.setTimeout = function setTimeout(func, timeout) {
-      return addTimer(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 2),
-        delay: timeout
-      });
-    };
-    if (typeof _global.Promise !== "undefined" && utilPromisify) {
-      clock.setTimeout[utilPromisify.custom] = function promisifiedSetTimeout(timeout, arg) {
-        return new _global.Promise(function setTimeoutExecutor(resolve) {
-          addTimer(clock, {
-            func: resolve,
-            args: [arg],
-            delay: timeout
-          });
+      function fakePerformanceNow() {
+        const hrt = hrtime();
+        const millis = hrt[0] * 1e3 + hrt[1] / 1e6;
+        return millis;
+      }
+      if (isPresent.hrtimeBigint) {
+        hrtime.bigint = function() {
+          const parts = hrtime();
+          return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
+        };
+      }
+      if (isPresent.Intl) {
+        clock.Intl = createIntl();
+        clock.Intl.clock = clock;
+      }
+      clock.requestIdleCallback = function requestIdleCallback(func, timeout) {
+        let timeToNextIdlePeriod = 0;
+        if (clock.countTimers() > 0) {
+          timeToNextIdlePeriod = 50;
+        }
+        const result = addTimer(clock, {
+          func,
+          args: Array.prototype.slice.call(arguments, 2),
+          delay: typeof timeout === "undefined" ? timeToNextIdlePeriod : Math.min(timeout, timeToNextIdlePeriod),
+          idleCallback: true
         });
+        return Number(result);
       };
-    }
-    clock.clearTimeout = function clearTimeout(timerId) {
-      return clearTimer(clock, timerId, "Timeout");
-    };
-    clock.nextTick = function nextTick(func) {
-      return enqueueJob(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 1),
-        error: isNearInfiniteLimit ? new Error() : null
-      });
-    };
-    clock.queueMicrotask = function queueMicrotask(func) {
-      return clock.nextTick(func);
-    };
-    clock.setInterval = function setInterval(func, timeout) {
-      timeout = parseInt(timeout, 10);
-      return addTimer(clock, {
-        func,
-        args: Array.prototype.slice.call(arguments, 2),
-        delay: timeout,
-        interval: timeout
-      });
-    };
-    clock.clearInterval = function clearInterval(timerId) {
-      return clearTimer(clock, timerId, "Interval");
-    };
-    if (setImmediatePresent) {
-      clock.setImmediate = function setImmediate(func) {
+      clock.cancelIdleCallback = function cancelIdleCallback(timerId) {
+        return clearTimer(clock, timerId, "IdleCallback");
+      };
+      clock.setTimeout = function setTimeout(func, timeout) {
         return addTimer(clock, {
           func,
-          args: Array.prototype.slice.call(arguments, 1),
-          immediate: true
+          args: Array.prototype.slice.call(arguments, 2),
+          delay: timeout
         });
       };
       if (typeof _global.Promise !== "undefined" && utilPromisify) {
-        clock.setImmediate[utilPromisify.custom] = function promisifiedSetImmediate(arg) {
-          return new _global.Promise(
-            function setImmediateExecutor(resolve) {
-              addTimer(clock, {
-                func: resolve,
-                args: [arg],
-                immediate: true
-              });
-            }
-          );
+        clock.setTimeout[utilPromisify.custom] = function promisifiedSetTimeout(timeout, arg) {
+          return new _global.Promise(function setTimeoutExecutor(resolve) {
+            addTimer(clock, {
+              func: resolve,
+              args: [arg],
+              delay: timeout
+            });
+          });
         };
       }
-      clock.clearImmediate = function clearImmediate(timerId) {
-        return clearTimer(clock, timerId, "Immediate");
+      clock.clearTimeout = function clearTimeout(timerId) {
+        return clearTimer(clock, timerId, "Timeout");
       };
-    }
-    clock.countTimers = function countTimers() {
-      return Object.keys(clock.timers || {}).length + (clock.jobs || []).length;
-    };
-    clock.requestAnimationFrame = function requestAnimationFrame(func) {
-      const result = addTimer(clock, {
-        func,
-        delay: getTimeToNextFrame(),
-        get args() {
-          return [fakePerformanceNow()];
-        },
-        animation: true
-      });
-      return Number(result);
-    };
-    clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {
-      return clearTimer(clock, timerId, "AnimationFrame");
-    };
-    clock.runMicrotasks = function runMicrotasks() {
-      runJobs(clock);
-    };
-    function doTick(tickValue, isAsync, resolve, reject) {
-      const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue);
-      const ms = Math.floor(msFloat);
-      const remainder = nanoRemainder(msFloat);
-      let nanosTotal = nanos + remainder;
-      let tickTo = clock.now + ms;
-      if (msFloat < 0) {
-        throw new TypeError("Negative ticks are not supported");
-      }
-      if (nanosTotal >= 1e6) {
-        tickTo += 1;
-        nanosTotal -= 1e6;
-      }
-      nanos = nanosTotal;
-      let tickFrom = clock.now;
-      let previous = clock.now;
-      let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall;
-      clock.duringTick = true;
-      oldNow = clock.now;
-      runJobs(clock);
-      if (oldNow !== clock.now) {
-        tickFrom += clock.now - oldNow;
-        tickTo += clock.now - oldNow;
-      }
-      function doTickInner() {
-        timer = firstTimerInRange(clock, tickFrom, tickTo);
-        while (timer && tickFrom <= tickTo) {
-          if (clock.timers[timer.id]) {
-            tickFrom = timer.callAt;
-            clock.now = timer.callAt;
-            oldNow = clock.now;
-            try {
-              runJobs(clock);
-              callTimer(clock, timer);
-            } catch (e) {
-              firstException = firstException || e;
-            }
-            if (isAsync) {
-              originalSetTimeout(nextPromiseTick);
-              return;
-            }
-            compensationCheck();
-          }
-          postTimerCall();
+      clock.nextTick = function nextTick(func) {
+        return enqueueJob(clock, {
+          func,
+          args: Array.prototype.slice.call(arguments, 1),
+          error: isNearInfiniteLimit ? new Error() : null
+        });
+      };
+      clock.queueMicrotask = function queueMicrotask(func) {
+        return clock.nextTick(func);
+      };
+      clock.setInterval = function setInterval(func, timeout) {
+        timeout = parseInt(timeout, 10);
+        return addTimer(clock, {
+          func,
+          args: Array.prototype.slice.call(arguments, 2),
+          delay: timeout,
+          interval: timeout
+        });
+      };
+      clock.clearInterval = function clearInterval(timerId) {
+        return clearTimer(clock, timerId, "Interval");
+      };
+      if (isPresent.setImmediate) {
+        clock.setImmediate = function setImmediate(func) {
+          return addTimer(clock, {
+            func,
+            args: Array.prototype.slice.call(arguments, 1),
+            immediate: true
+          });
+        };
+        if (typeof _global.Promise !== "undefined" && utilPromisify) {
+          clock.setImmediate[utilPromisify.custom] = function promisifiedSetImmediate(arg) {
+            return new _global.Promise(
+              function setImmediateExecutor(resolve) {
+                addTimer(clock, {
+                  func: resolve,
+                  args: [arg],
+                  immediate: true
+                });
+              }
+            );
+          };
         }
-        oldNow = clock.now;
+        clock.clearImmediate = function clearImmediate(timerId) {
+          return clearTimer(clock, timerId, "Immediate");
+        };
+      }
+      clock.countTimers = function countTimers() {
+        return Object.keys(clock.timers || {}).length + (clock.jobs || []).length;
+      };
+      clock.requestAnimationFrame = function requestAnimationFrame(func) {
+        const result = addTimer(clock, {
+          func,
+          delay: getTimeToNextFrame(),
+          get args() {
+            return [fakePerformanceNow()];
+          },
+          animation: true
+        });
+        return Number(result);
+      };
+      clock.cancelAnimationFrame = function cancelAnimationFrame(timerId) {
+        return clearTimer(clock, timerId, "AnimationFrame");
+      };
+      clock.runMicrotasks = function runMicrotasks() {
         runJobs(clock);
-        if (oldNow !== clock.now) {
-          tickFrom += clock.now - oldNow;
-          tickTo += clock.now - oldNow;
-        }
-        clock.duringTick = false;
-        timer = firstTimerInRange(clock, tickFrom, tickTo);
-        if (timer) {
-          try {
-            clock.tick(tickTo - clock.now);
-          } catch (e) {
-            firstException = firstException || e;
-          }
-        } else {
-          clock.now = tickTo;
-          nanos = nanosTotal;
-        }
-        if (firstException) {
-          throw firstException;
+      };
+      function doTick(tickValue, isAsync, resolve, reject) {
+        const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue);
+        const ms = Math.floor(msFloat);
+        const remainder = nanoRemainder(msFloat);
+        let nanosTotal = nanos + remainder;
+        let tickTo = clock.now + ms;
+        if (msFloat < 0) {
+          throw new TypeError("Negative ticks are not supported");
         }
-        if (isAsync) {
-          resolve(clock.now);
-        } else {
-          return clock.now;
+        if (nanosTotal >= 1e6) {
+          tickTo += 1;
+          nanosTotal -= 1e6;
         }
-      }
-      nextPromiseTick = isAsync && function() {
-        try {
-          compensationCheck();
-          postTimerCall();
-          doTickInner();
-        } catch (e) {
-          reject(e);
-        }
-      };
-      compensationCheck = function() {
+        nanos = nanosTotal;
+        let tickFrom = clock.now;
+        let previous = clock.now;
+        let timer, firstException, oldNow, nextPromiseTick, compensationCheck, postTimerCall;
+        clock.duringTick = true;
+        oldNow = clock.now;
+        runJobs(clock);
         if (oldNow !== clock.now) {
           tickFrom += clock.now - oldNow;
           tickTo += clock.now - oldNow;
-          previous += clock.now - oldNow;
         }
-      };
-      postTimerCall = function() {
-        timer = firstTimerInRange(clock, previous, tickTo);
-        previous = tickFrom;
-      };
-      return doTickInner();
-    }
-    clock.tick = function tick(tickValue) {
-      return doTick(tickValue, false);
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.tickAsync = function tickAsync(tickValue) {
-        return new _global.Promise(function(resolve, reject) {
-          originalSetTimeout(function() {
+        function doTickInner() {
+          timer = firstTimerInRange(clock, tickFrom, tickTo);
+          while (timer && tickFrom <= tickTo) {
+            if (clock.timers[timer.id]) {
+              tickFrom = timer.callAt;
+              clock.now = timer.callAt;
+              oldNow = clock.now;
+              try {
+                runJobs(clock);
+                callTimer(clock, timer);
+              } catch (e) {
+                firstException = firstException || e;
+              }
+              if (isAsync) {
+                originalSetTimeout(nextPromiseTick);
+                return;
+              }
+              compensationCheck();
+            }
+            postTimerCall();
+          }
+          oldNow = clock.now;
+          runJobs(clock);
+          if (oldNow !== clock.now) {
+            tickFrom += clock.now - oldNow;
+            tickTo += clock.now - oldNow;
+          }
+          clock.duringTick = false;
+          timer = firstTimerInRange(clock, tickFrom, tickTo);
+          if (timer) {
             try {
-              doTick(tickValue, true, resolve, reject);
+              clock.tick(tickTo - clock.now);
             } catch (e) {
-              reject(e);
+              firstException = firstException || e;
             }
-          });
-        });
-      };
-    }
-    clock.next = function next() {
-      runJobs(clock);
-      const timer = firstTimer(clock);
-      if (!timer) {
-        return clock.now;
-      }
-      clock.duringTick = true;
-      try {
-        clock.now = timer.callAt;
-        callTimer(clock, timer);
-        runJobs(clock);
-        return clock.now;
-      } finally {
-        clock.duringTick = false;
+          } else {
+            clock.now = tickTo;
+            nanos = nanosTotal;
+          }
+          if (firstException) {
+            throw firstException;
+          }
+          if (isAsync) {
+            resolve(clock.now);
+          } else {
+            return clock.now;
+          }
+        }
+        nextPromiseTick = isAsync && function() {
+          try {
+            compensationCheck();
+            postTimerCall();
+            doTickInner();
+          } catch (e) {
+            reject(e);
+          }
+        };
+        compensationCheck = function() {
+          if (oldNow !== clock.now) {
+            tickFrom += clock.now - oldNow;
+            tickTo += clock.now - oldNow;
+            previous += clock.now - oldNow;
+          }
+        };
+        postTimerCall = function() {
+          timer = firstTimerInRange(clock, previous, tickTo);
+          previous = tickFrom;
+        };
+        return doTickInner();
       }
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.nextAsync = function nextAsync() {
-        return new _global.Promise(function(resolve, reject) {
-          originalSetTimeout(function() {
-            try {
-              const timer = firstTimer(clock);
-              if (!timer) {
-                resolve(clock.now);
-                return;
-              }
-              let err;
-              clock.duringTick = true;
-              clock.now = timer.callAt;
+      clock.tick = function tick(tickValue) {
+        return doTick(tickValue, false);
+      };
+      if (typeof _global.Promise !== "undefined") {
+        clock.tickAsync = function tickAsync(tickValue) {
+          return new _global.Promise(function(resolve, reject) {
+            originalSetTimeout(function() {
               try {
-                callTimer(clock, timer);
+                doTick(tickValue, true, resolve, reject);
               } catch (e) {
-                err = e;
+                reject(e);
               }
-              clock.duringTick = false;
-              originalSetTimeout(function() {
-                if (err) {
-                  reject(err);
-                } else {
-                  resolve(clock.now);
-                }
-              });
-            } catch (e) {
-              reject(e);
-            }
+            });
           });
-        });
-      };
-    }
-    clock.runAll = function runAll() {
-      let numTimers, i;
-      runJobs(clock);
-      for (i = 0; i < clock.loopLimit; i++) {
-        if (!clock.timers) {
-          resetIsNearInfiniteLimit();
+        };
+      }
+      clock.next = function next() {
+        runJobs(clock);
+        const timer = firstTimer(clock);
+        if (!timer) {
           return clock.now;
         }
-        numTimers = Object.keys(clock.timers).length;
-        if (numTimers === 0) {
-          resetIsNearInfiniteLimit();
+        clock.duringTick = true;
+        try {
+          clock.now = timer.callAt;
+          callTimer(clock, timer);
+          runJobs(clock);
           return clock.now;
+        } finally {
+          clock.duringTick = false;
         }
-        clock.next();
-        checkIsNearInfiniteLimit(clock, i);
-      }
-      const excessJob = firstTimer(clock);
-      throw getInfiniteLoopError(clock, excessJob);
-    };
-    clock.runToFrame = function runToFrame() {
-      return clock.tick(getTimeToNextFrame());
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.runAllAsync = function runAllAsync() {
-        return new _global.Promise(function(resolve, reject) {
-          let i = 0;
-          function doRun() {
+      };
+      if (typeof _global.Promise !== "undefined") {
+        clock.nextAsync = function nextAsync() {
+          return new _global.Promise(function(resolve, reject) {
             originalSetTimeout(function() {
               try {
-                let numTimers;
-                if (i < clock.loopLimit) {
-                  if (!clock.timers) {
-                    resetIsNearInfiniteLimit();
-                    resolve(clock.now);
-                    return;
-                  }
-                  numTimers = Object.keys(
-                    clock.timers
-                  ).length;
-                  if (numTimers === 0) {
-                    resetIsNearInfiniteLimit();
-                    resolve(clock.now);
-                    return;
-                  }
-                  clock.next();
-                  i++;
-                  doRun();
-                  checkIsNearInfiniteLimit(clock, i);
+                const timer = firstTimer(clock);
+                if (!timer) {
+                  resolve(clock.now);
                   return;
                 }
-                const excessJob = firstTimer(clock);
-                reject(getInfiniteLoopError(clock, excessJob));
+                let err;
+                clock.duringTick = true;
+                clock.now = timer.callAt;
+                try {
+                  callTimer(clock, timer);
+                } catch (e) {
+                  err = e;
+                }
+                clock.duringTick = false;
+                originalSetTimeout(function() {
+                  if (err) {
+                    reject(err);
+                  } else {
+                    resolve(clock.now);
+                  }
+                });
               } catch (e) {
                 reject(e);
               }
             });
+          });
+        };
+      }
+      clock.runAll = function runAll() {
+        let numTimers, i;
+        runJobs(clock);
+        for (i = 0; i < clock.loopLimit; i++) {
+          if (!clock.timers) {
+            resetIsNearInfiniteLimit();
+            return clock.now;
           }
-          doRun();
-        });
+          numTimers = Object.keys(clock.timers).length;
+          if (numTimers === 0) {
+            resetIsNearInfiniteLimit();
+            return clock.now;
+          }
+          clock.next();
+          checkIsNearInfiniteLimit(clock, i);
+        }
+        const excessJob = firstTimer(clock);
+        throw getInfiniteLoopError(clock, excessJob);
       };
-    }
-    clock.runToLast = function runToLast() {
-      const timer = lastTimer(clock);
-      if (!timer) {
-        runJobs(clock);
-        return clock.now;
+      clock.runToFrame = function runToFrame() {
+        return clock.tick(getTimeToNextFrame());
+      };
+      if (typeof _global.Promise !== "undefined") {
+        clock.runAllAsync = function runAllAsync() {
+          return new _global.Promise(function(resolve, reject) {
+            let i = 0;
+            function doRun() {
+              originalSetTimeout(function() {
+                try {
+                  runJobs(clock);
+                  let numTimers;
+                  if (i < clock.loopLimit) {
+                    if (!clock.timers) {
+                      resetIsNearInfiniteLimit();
+                      resolve(clock.now);
+                      return;
+                    }
+                    numTimers = Object.keys(
+                      clock.timers
+                    ).length;
+                    if (numTimers === 0) {
+                      resetIsNearInfiniteLimit();
+                      resolve(clock.now);
+                      return;
+                    }
+                    clock.next();
+                    i++;
+                    doRun();
+                    checkIsNearInfiniteLimit(clock, i);
+                    return;
+                  }
+                  const excessJob = firstTimer(clock);
+                  reject(getInfiniteLoopError(clock, excessJob));
+                } catch (e) {
+                  reject(e);
+                }
+              });
+            }
+            doRun();
+          });
+        };
       }
-      return clock.tick(timer.callAt - clock.now);
-    };
-    if (typeof _global.Promise !== "undefined") {
-      clock.runToLastAsync = function runToLastAsync() {
-        return new _global.Promise(function(resolve, reject) {
-          originalSetTimeout(function() {
-            try {
-              const timer = lastTimer(clock);
-              if (!timer) {
-                resolve(clock.now);
+      clock.runToLast = function runToLast() {
+        const timer = lastTimer(clock);
+        if (!timer) {
+          runJobs(clock);
+          return clock.now;
+        }
+        return clock.tick(timer.callAt - clock.now);
+      };
+      if (typeof _global.Promise !== "undefined") {
+        clock.runToLastAsync = function runToLastAsync() {
+          return new _global.Promise(function(resolve, reject) {
+            originalSetTimeout(function() {
+              try {
+                const timer = lastTimer(clock);
+                if (!timer) {
+                  runJobs(clock);
+                  resolve(clock.now);
+                }
+                resolve(clock.tickAsync(timer.callAt - clock.now));
+              } catch (e) {
+                reject(e);
               }
-              resolve(clock.tickAsync(timer.callAt - clock.now));
-            } catch (e) {
-              reject(e);
-            }
+            });
           });
-        });
+        };
+      }
+      clock.reset = function reset() {
+        nanos = 0;
+        clock.timers = {};
+        clock.jobs = [];
+        clock.now = start;
       };
-    }
-    clock.reset = function reset() {
-      nanos = 0;
-      clock.timers = {};
-      clock.jobs = [];
-      clock.now = start;
-    };
-    clock.setSystemTime = function setSystemTime(systemTime) {
-      const newNow = getEpoch(systemTime);
-      const difference = newNow - clock.now;
-      let id, timer;
-      adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
-      adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
-      clock.now = newNow;
-      nanos = 0;
-      for (id in clock.timers) {
-        if (clock.timers.hasOwnProperty(id)) {
-          timer = clock.timers[id];
-          timer.createdAt += difference;
-          timer.callAt += difference;
+      clock.setSystemTime = function setSystemTime(systemTime) {
+        const newNow = getEpoch(systemTime);
+        const difference = newNow - clock.now;
+        let id, timer;
+        adjustedSystemTime[0] = adjustedSystemTime[0] + difference;
+        adjustedSystemTime[1] = adjustedSystemTime[1] + nanos;
+        clock.now = newNow;
+        nanos = 0;
+        for (id in clock.timers) {
+          if (clock.timers.hasOwnProperty(id)) {
+            timer = clock.timers[id];
+            timer.createdAt += difference;
+            timer.callAt += difference;
+          }
         }
-      }
-    };
-    clock.jump = function jump(tickValue) {
-      const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue);
-      const ms = Math.floor(msFloat);
-      for (const timer of Object.values(clock.timers)) {
-        if (clock.now + ms > timer.callAt) {
-          timer.callAt = clock.now + ms;
+      };
+      clock.jump = function jump(tickValue) {
+        const msFloat = typeof tickValue === "number" ? tickValue : parseTime(tickValue);
+        const ms = Math.floor(msFloat);
+        for (const timer of Object.values(clock.timers)) {
+          if (clock.now + ms > timer.callAt) {
+            timer.callAt = clock.now + ms;
+          }
         }
+        clock.tick(ms);
+      };
+      if (isPresent.performance) {
+        clock.performance = /* @__PURE__ */ Object.create(null);
+        clock.performance.now = fakePerformanceNow;
       }
-      clock.tick(ms);
-    };
-    if (performancePresent) {
-      clock.performance = /* @__PURE__ */ Object.create(null);
-      clock.performance.now = fakePerformanceNow;
-    }
-    if (hrtimePresent) {
-      clock.hrtime = hrtime;
-    }
-    return clock;
-  }
-  function install(config) {
-    if (arguments.length > 1 || config instanceof Date || Array.isArray(config) || typeof config === "number") {
-      throw new TypeError(
-        `FakeTimers.install called with ${String(
-          config
-        )} install requires an object parameter`
-      );
-    }
-    if (_global.Date.isFake === true) {
-      throw new TypeError(
-        "Can't install fake timers twice on the same global object."
-      );
-    }
-    config = typeof config !== "undefined" ? config : {};
-    config.shouldAdvanceTime = config.shouldAdvanceTime || false;
-    config.advanceTimeDelta = config.advanceTimeDelta || 20;
-    config.shouldClearNativeTimers = config.shouldClearNativeTimers || false;
-    if (config.target) {
-      throw new TypeError(
-        "config.target is no longer supported. Use `withGlobal(target)` instead."
-      );
-    }
-    let i, l;
-    const clock = createClock(config.now, config.loopLimit);
-    clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
-    clock.uninstall = function() {
-      return uninstall(clock, config);
-    };
-    clock.methods = config.toFake || [];
-    if (clock.methods.length === 0) {
-      clock.methods = Object.keys(timers).filter(function(key) {
-        return key !== "nextTick" && key !== "queueMicrotask";
-      });
-    }
-    if (config.shouldAdvanceTime === true) {
-      const intervalTick = doIntervalTick.bind(
-        null,
-        clock,
-        config.advanceTimeDelta
-      );
-      const intervalId = _global.setInterval(
-        intervalTick,
-        config.advanceTimeDelta
-      );
-      clock.attachedInterval = intervalId;
+      if (isPresent.hrtime) {
+        clock.hrtime = hrtime;
+      }
+      return clock;
     }
-    if (clock.methods.includes("performance")) {
-      const proto = (() => {
-        if (hasPerformanceConstructorPrototype) {
-          return _global.performance.constructor.prototype;
-        }
-        if (hasPerformancePrototype) {
-          return _global.Performance.prototype;
+    function install(config) {
+      if (arguments.length > 1 || config instanceof Date || Array.isArray(config) || typeof config === "number") {
+        throw new TypeError(
+          `FakeTimers.install called with ${String(
+            config
+          )} install requires an object parameter`
+        );
+      }
+      if (_global.Date.isFake === true) {
+        throw new TypeError(
+          "Can't install fake timers twice on the same global object."
+        );
+      }
+      config = typeof config !== "undefined" ? config : {};
+      config.shouldAdvanceTime = config.shouldAdvanceTime || false;
+      config.advanceTimeDelta = config.advanceTimeDelta || 20;
+      config.shouldClearNativeTimers = config.shouldClearNativeTimers || false;
+      if (config.target) {
+        throw new TypeError(
+          "config.target is no longer supported. Use `withGlobal(target)` instead."
+        );
+      }
+      function handleMissingTimer(timer) {
+        if (config.ignoreMissingTimers) {
+          return;
         }
-      })();
-      if (proto) {
-        Object.getOwnPropertyNames(proto).forEach(function(name) {
-          if (name !== "now") {
-            clock.performance[name] = name.indexOf("getEntries") === 0 ? NOOP_ARRAY : NOOP;
-          }
-        });
-      } else if ((config.toFake || []).includes("performance")) {
         throw new ReferenceError(
-          "non-existent performance object cannot be faked"
+          `non-existent timers and/or objects cannot be faked: '${timer}'`
         );
       }
-    }
-    if (_global === globalObject && timersModule) {
-      clock.timersModuleMethods = [];
-    }
-    for (i = 0, l = clock.methods.length; i < l; i++) {
-      const nameOfMethodToReplace = clock.methods[i];
-      if (nameOfMethodToReplace === "hrtime") {
-        if (_global.process && typeof _global.process.hrtime === "function") {
-          hijackMethod(_global.process, nameOfMethodToReplace, clock);
-        }
-      } else if (nameOfMethodToReplace === "nextTick") {
-        if (_global.process && typeof _global.process.nextTick === "function") {
-          hijackMethod(_global.process, nameOfMethodToReplace, clock);
+      let i, l;
+      const clock = createClock(config.now, config.loopLimit);
+      clock.shouldClearNativeTimers = config.shouldClearNativeTimers;
+      clock.uninstall = function() {
+        return uninstall(clock, config);
+      };
+      clock.abortListenerMap = /* @__PURE__ */ new Map();
+      clock.methods = config.toFake || [];
+      if (clock.methods.length === 0) {
+        clock.methods = Object.keys(timers);
+      }
+      if (config.shouldAdvanceTime === true) {
+        const intervalTick = doIntervalTick.bind(
+          null,
+          clock,
+          config.advanceTimeDelta
+        );
+        const intervalId = _global.setInterval(
+          intervalTick,
+          config.advanceTimeDelta
+        );
+        clock.attachedInterval = intervalId;
+      }
+      if (clock.methods.includes("performance")) {
+        const proto = (() => {
+          if (hasPerformanceConstructorPrototype) {
+            return _global.performance.constructor.prototype;
+          }
+          if (hasPerformancePrototype) {
+            return _global.Performance.prototype;
+          }
+        })();
+        if (proto) {
+          Object.getOwnPropertyNames(proto).forEach(function(name) {
+            if (name !== "now") {
+              clock.performance[name] = name.indexOf("getEntries") === 0 ? NOOP_ARRAY : NOOP;
+            }
+          });
+          clock.performance.mark = (name) => new FakePerformanceEntry(name, "mark", 0, 0);
+          clock.performance.measure = (name) => new FakePerformanceEntry(name, "measure", 0, 100);
+          clock.performance.timeOrigin = getEpoch(config.now);
+        } else if ((config.toFake || []).includes("performance")) {
+          return handleMissingTimer("performance");
         }
-      } else {
-        hijackMethod(_global, nameOfMethodToReplace, clock);
       }
-      if (clock.timersModuleMethods !== void 0 && timersModule[nameOfMethodToReplace]) {
-        const original = timersModule[nameOfMethodToReplace];
-        clock.timersModuleMethods.push({
-          methodName: nameOfMethodToReplace,
-          original
-        });
-        timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
+      if (_global === globalObject && timersModule) {
+        clock.timersModuleMethods = [];
+      }
+      if (_global === globalObject && timersPromisesModule) {
+        clock.timersPromisesModuleMethods = [];
+      }
+      for (i = 0, l = clock.methods.length; i < l; i++) {
+        const nameOfMethodToReplace = clock.methods[i];
+        if (!isPresent[nameOfMethodToReplace]) {
+          handleMissingTimer(nameOfMethodToReplace);
+          continue;
+        }
+        if (nameOfMethodToReplace === "hrtime") {
+          if (_global.process && typeof _global.process.hrtime === "function") {
+            hijackMethod(_global.process, nameOfMethodToReplace, clock);
+          }
+        } else if (nameOfMethodToReplace === "nextTick") {
+          if (_global.process && typeof _global.process.nextTick === "function") {
+            hijackMethod(_global.process, nameOfMethodToReplace, clock);
+          }
+        } else {
+          hijackMethod(_global, nameOfMethodToReplace, clock);
+        }
+        if (clock.timersModuleMethods !== void 0 && timersModule[nameOfMethodToReplace]) {
+          const original = timersModule[nameOfMethodToReplace];
+          clock.timersModuleMethods.push({
+            methodName: nameOfMethodToReplace,
+            original
+          });
+          timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
+        }
+        if (clock.timersPromisesModuleMethods !== void 0) {
+          if (nameOfMethodToReplace === "setTimeout") {
+            clock.timersPromisesModuleMethods.push({
+              methodName: "setTimeout",
+              original: timersPromisesModule.setTimeout
+            });
+            timersPromisesModule.setTimeout = (delay, value, options = {}) => new Promise((resolve, reject) => {
+              const abort = () => {
+                options.signal.removeEventListener(
+                  "abort",
+                  abort
+                );
+                clock.abortListenerMap.delete(abort);
+                clock.clearTimeout(handle);
+                reject(options.signal.reason);
+              };
+              const handle = clock.setTimeout(() => {
+                if (options.signal) {
+                  options.signal.removeEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.delete(abort);
+                }
+                resolve(value);
+              }, delay);
+              if (options.signal) {
+                if (options.signal.aborted) {
+                  abort();
+                } else {
+                  options.signal.addEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.set(
+                    abort,
+                    options.signal
+                  );
+                }
+              }
+            });
+          } else if (nameOfMethodToReplace === "setImmediate") {
+            clock.timersPromisesModuleMethods.push({
+              methodName: "setImmediate",
+              original: timersPromisesModule.setImmediate
+            });
+            timersPromisesModule.setImmediate = (value, options = {}) => new Promise((resolve, reject) => {
+              const abort = () => {
+                options.signal.removeEventListener(
+                  "abort",
+                  abort
+                );
+                clock.abortListenerMap.delete(abort);
+                clock.clearImmediate(handle);
+                reject(options.signal.reason);
+              };
+              const handle = clock.setImmediate(() => {
+                if (options.signal) {
+                  options.signal.removeEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.delete(abort);
+                }
+                resolve(value);
+              });
+              if (options.signal) {
+                if (options.signal.aborted) {
+                  abort();
+                } else {
+                  options.signal.addEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.set(
+                    abort,
+                    options.signal
+                  );
+                }
+              }
+            });
+          } else if (nameOfMethodToReplace === "setInterval") {
+            clock.timersPromisesModuleMethods.push({
+              methodName: "setInterval",
+              original: timersPromisesModule.setInterval
+            });
+            timersPromisesModule.setInterval = (delay, value, options = {}) => ({
+              [Symbol.asyncIterator]: () => {
+                const createResolvable = () => {
+                  let resolve, reject;
+                  const promise = new Promise((res, rej) => {
+                    resolve = res;
+                    reject = rej;
+                  });
+                  promise.resolve = resolve;
+                  promise.reject = reject;
+                  return promise;
+                };
+                let done = false;
+                let hasThrown = false;
+                let returnCall;
+                let nextAvailable = 0;
+                const nextQueue = [];
+                const handle = clock.setInterval(() => {
+                  if (nextQueue.length > 0) {
+                    nextQueue.shift().resolve();
+                  } else {
+                    nextAvailable++;
+                  }
+                }, delay);
+                const abort = () => {
+                  options.signal.removeEventListener(
+                    "abort",
+                    abort
+                  );
+                  clock.abortListenerMap.delete(abort);
+                  clock.clearInterval(handle);
+                  done = true;
+                  for (const resolvable of nextQueue) {
+                    resolvable.resolve();
+                  }
+                };
+                if (options.signal) {
+                  if (options.signal.aborted) {
+                    done = true;
+                  } else {
+                    options.signal.addEventListener(
+                      "abort",
+                      abort
+                    );
+                    clock.abortListenerMap.set(
+                      abort,
+                      options.signal
+                    );
+                  }
+                }
+                return {
+                  next: async () => {
+                    if (options.signal?.aborted && !hasThrown) {
+                      hasThrown = true;
+                      throw options.signal.reason;
+                    }
+                    if (done) {
+                      return { done: true, value: void 0 };
+                    }
+                    if (nextAvailable > 0) {
+                      nextAvailable--;
+                      return { done: false, value };
+                    }
+                    const resolvable = createResolvable();
+                    nextQueue.push(resolvable);
+                    await resolvable;
+                    if (returnCall && nextQueue.length === 0) {
+                      returnCall.resolve();
+                    }
+                    if (options.signal?.aborted && !hasThrown) {
+                      hasThrown = true;
+                      throw options.signal.reason;
+                    }
+                    if (done) {
+                      return { done: true, value: void 0 };
+                    }
+                    return { done: false, value };
+                  },
+                  return: async () => {
+                    if (done) {
+                      return { done: true, value: void 0 };
+                    }
+                    if (nextQueue.length > 0) {
+                      returnCall = createResolvable();
+                      await returnCall;
+                    }
+                    clock.clearInterval(handle);
+                    done = true;
+                    if (options.signal) {
+                      options.signal.removeEventListener(
+                        "abort",
+                        abort
+                      );
+                      clock.abortListenerMap.delete(abort);
+                    }
+                    return { done: true, value: void 0 };
+                  }
+                };
+              }
+            });
+          }
+        }
       }
+      return clock;
     }
-    return clock;
+    return {
+      timers,
+      createClock,
+      install,
+      withGlobal
+    };
   }
-  return {
-    timers,
-    createClock,
-    install,
-    withGlobal
-  };
+  const defaultImplementation = withGlobal(globalObject);
+  fakeTimersSrc.timers = defaultImplementation.timers;
+  fakeTimersSrc.createClock = defaultImplementation.createClock;
+  fakeTimersSrc.install = defaultImplementation.install;
+  fakeTimersSrc.withGlobal = withGlobal;
+  return fakeTimersSrc;
 }
-var defaultImplementation = withGlobal(globalObject);
-defaultImplementation.timers;
-defaultImplementation.createClock;
-defaultImplementation.install;
-var withGlobal_1 = withGlobal;
+var fakeTimersSrcExports = requireFakeTimersSrc();
 var FakeTimers = class {
   _global;
   _clock;
@@ -2025,46 +2436,49 @@ var FakeTimers = class {
   _fakeTimers;
   _userConfig;
   _now = RealDate.now;
-  constructor({
-    global: global3,
-    config
-  }) {
+  constructor({ global: global3, config }) {
     this._userConfig = config;
-    this._fakingDate = false;
+    this._fakingDate = null;
     this._fakingTime = false;
-    this._fakeTimers = withGlobal_1(global3);
+    this._fakeTimers = fakeTimersSrcExports.withGlobal(global3);
     this._global = global3;
   }
   clearAllTimers() {
-    if (this._fakingTime)
+    if (this._fakingTime) {
       this._clock.reset();
+    }
   }
   dispose() {
     this.useRealTimers();
   }
   runAllTimers() {
-    if (this._checkFakeTimers())
+    if (this._checkFakeTimers()) {
       this._clock.runAll();
+    }
   }
   async runAllTimersAsync() {
-    if (this._checkFakeTimers())
+    if (this._checkFakeTimers()) {
       await this._clock.runAllAsync();
+    }
   }
   runOnlyPendingTimers() {
-    if (this._checkFakeTimers())
+    if (this._checkFakeTimers()) {
       this._clock.runToLast();
+    }
   }
   async runOnlyPendingTimersAsync() {
-    if (this._checkFakeTimers())
+    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)
+        if (this._clock.countTimers() === 0) {
           break;
+        }
       }
     }
   }
@@ -2073,18 +2487,26 @@ var FakeTimers = class {
       for (let i = steps; i > 0; i--) {
         await this._clock.nextAsync();
         this._clock.tick(0);
-        if (this._clock.countTimers() === 0)
+        if (this._clock.countTimers() === 0) {
           break;
+        }
       }
     }
   }
   advanceTimersByTime(msToRun) {
-    if (this._checkFakeTimers())
+    if (this._checkFakeTimers()) {
       this._clock.tick(msToRun);
+    }
   }
   async advanceTimersByTimeAsync(msToRun) {
-    if (this._checkFakeTimers())
+    if (this._checkFakeTimers()) {
       await this._clock.tickAsync(msToRun);
+    }
+  }
+  advanceTimersToNextFrame() {
+    if (this._checkFakeTimers()) {
+      this._clock.runToFrame();
+    }
   }
   runAllTicks() {
     if (this._checkFakeTimers()) {
@@ -2094,7 +2516,7 @@ var FakeTimers = class {
   useRealTimers() {
     if (this._fakingDate) {
       resetDate();
-      this._fakingDate = false;
+      this._fakingDate = null;
     }
     if (this._fakingTime) {
       this._clock.uninstall();
@@ -2102,29 +2524,19 @@ var FakeTimers = class {
     }
   }
   useFakeTimers() {
-    var _a, _b, _c;
     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.'
-      );
+      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 (((_b = (_a = this._userConfig) == null ? void 0 : _a.toFake) == null ? void 0 : _b.includes("nextTick")) && isChildProcess())
+      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");
-      const existingFakedMethods = (((_c = this._userConfig) == null ? void 0 : _c.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
+        toFake: this._userConfig?.toFake || toFake,
+        ignoreMissingTimers: true
       });
       this._fakingTime = true;
     }
@@ -2137,19 +2549,24 @@ var FakeTimers = class {
     }
   }
   setSystemTime(now2) {
+    const date = typeof now2 === "undefined" || now2 instanceof Date ? now2 : new Date(now2);
     if (this._fakingTime) {
-      this._clock.setSystemTime(now2);
+      this._clock.setSystemTime(date);
     } else {
-      mockDate(now2 ?? this.getRealSystemTime());
-      this._fakingDate = true;
+      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())
+    if (this._checkFakeTimers()) {
       return this._clock.countTimers();
+    }
     return 0;
   }
   configure(config) {
@@ -2160,20 +2577,19 @@ var FakeTimers = class {
   }
   _checkFakeTimers() {
     if (!this._fakingTime) {
-      throw new Error(
-        'Timers are not mocked. Try calling "vi.useFakeTimers()" first.'
-      );
+      throw new Error('Timers are not mocked. Try calling "vi.useFakeTimers()" first.');
     }
     return this._fakingTime;
   }
 };
 function copyStackTrace(target, source) {
-  if (source.stack !== void 0)
+  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 { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers2();
   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) => {
@@ -2182,38 +2598,43 @@ function waitFor(callback, options = {}) {
     let timeoutId;
     let intervalId;
     const onResolve = (result) => {
-      if (timeoutId)
+      if (timeoutId) {
         clearTimeout(timeoutId);
-      if (intervalId)
+      }
+      if (intervalId) {
         clearInterval(intervalId);
+      }
       resolve(result);
     };
     const handleTimeout = () => {
+      if (intervalId) {
+        clearInterval(intervalId);
+      }
       let error = lastError;
-      if (!error)
+      if (!error) {
         error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+      }
       reject(error);
     };
     const checkCallback = () => {
-      if (vi.isFakeTimers())
+      if (vi.isFakeTimers()) {
         vi.advanceTimersByTime(interval);
-      if (promiseStatus === "pending")
+      }
+      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;
-            }
-          );
+          thenable.then((resolvedValue) => {
+            promiseStatus = "resolved";
+            onResolve(resolvedValue);
+          }, (rejectedValue) => {
+            promiseStatus = "rejected";
+            lastError = rejectedValue;
+          });
         } else {
           onResolve(result);
           return true;
@@ -2222,14 +2643,15 @@ function waitFor(callback, options = {}) {
         lastError = error;
       }
     };
-    if (checkCallback() === true)
+    if (checkCallback() === true) {
       return;
+    }
     timeoutId = setTimeout(handleTimeout, timeout);
     intervalId = setInterval(checkCallback, interval);
   });
 }
 function waitUntil(callback, options = {}) {
-  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+  const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers2();
   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) => {
@@ -2237,40 +2659,46 @@ function waitUntil(callback, options = {}) {
     let timeoutId;
     let intervalId;
     const onReject = (error) => {
-      if (!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)
+      if (!result) {
         return;
-      if (timeoutId)
+      }
+      if (timeoutId) {
         clearTimeout(timeoutId);
-      if (intervalId)
+      }
+      if (intervalId) {
         clearInterval(intervalId);
+      }
       resolve(result);
       return true;
     };
     const checkCallback = () => {
-      if (vi.isFakeTimers())
+      if (vi.isFakeTimers()) {
         vi.advanceTimersByTime(interval);
-      if (promiseStatus === "pending")
+      }
+      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);
-            }
-          );
+          thenable.then((resolvedValue) => {
+            promiseStatus = "resolved";
+            onResolve(resolvedValue);
+          }, (rejectedValue) => {
+            promiseStatus = "rejected";
+            onReject(rejectedValue);
+          });
         } else {
           return onResolve(result);
         }
@@ -2278,51 +2706,43 @@ function waitUntil(callback, options = {}) {
         onReject(error);
       }
     };
-    if (checkCallback() === true)
+    if (checkCallback() === true) {
       return;
+    }
     timeoutId = setTimeout(onReject, timeout);
     intervalId = setInterval(checkCallback, interval);
   });
 }
 function createVitest() {
-  const _mocker = 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.`
-      );
-    }
-  });
-  let _mockedDate = null;
   let _config = null;
   const workerState = getWorkerState();
   let _timers;
-  const timers = () => _timers || (_timers = new FakeTimers({
+  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 getImporter = () => {
-    const stackTrace = createSimpleStackTrace({ stackTraceLimit: 4 });
-    const importerStack = stackTrace.split("\n")[4];
-    const stack = parseSingleStack(importerStack);
-    return (stack == null ? void 0 : stack.file) || "";
-  };
+  const _envBooleans = [
+    "PROD",
+    "DEV",
+    "SSR"
+  ];
   const utils = {
     useFakeTimers(config) {
-      var _a, _b, _c, _d;
       if (isChildProcess()) {
-        if (((_a = config == null ? void 0 : config.toFake) == null ? void 0 : _a.includes("nextTick")) || ((_d = (_c = (_b = workerState.config) == null ? void 0 : _b.fakeTimers) == null ? void 0 : _c.toFake) == null ? void 0 : _d.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?.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
+      if (config) {
+        timers().configure({
+          ...workerState.config.fakeTimers,
+          ...config
+        });
+      } else {
         timers().configure(workerState.config.fakeTimers);
+      }
       timers().useFakeTimers();
       return utils;
     },
@@ -2331,7 +2751,6 @@ function createVitest() {
     },
     useRealTimers() {
       timers().useRealTimers();
-      _mockedDate = null;
       return utils;
     },
     runOnlyPendingTimers() {
@@ -2370,17 +2789,19 @@ function createVitest() {
       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);
+      timers().setSystemTime(time);
       return utils;
     },
     getMockedSystemTime() {
-      return _mockedDate;
+      return timers().getMockedSystemTime();
     },
     getRealSystemTime() {
       return timers().getRealSystemTime();
@@ -2389,7 +2810,6 @@ function createVitest() {
       timers().clearAllTimers();
       return utils;
     },
-    // mocks
     spyOn,
     fn,
     waitFor,
@@ -2399,40 +2819,37 @@ function createVitest() {
       return factory();
     },
     mock(path, factory) {
-      const importer = getImporter();
-      _mocker.queueMock(
-        path,
-        importer,
-        factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0,
-        true
-      );
+      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) {
-      _mocker.queueUnmock(path, getImporter());
+      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) {
-      const importer = getImporter();
-      _mocker.queueMock(
-        path,
-        importer,
-        factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0,
-        false
-      );
+      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) {
-      _mocker.queueUnmock(path, getImporter());
+      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(),
-        _mocker.getMockContext().callstack
-      );
+      return _mocker().importActual(path, getImporter("importActual"), _mocker().getMockContext().callstack);
     },
     async importMock(path) {
-      return _mocker.importMock(path, getImporter());
+      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;
     },
@@ -2440,20 +2857,21 @@ function createVitest() {
       return isMockFunction(fn2);
     },
     clearAllMocks() {
-      mocks.forEach((spy) => spy.mockClear());
+      [...mocks].reverse().forEach((spy) => spy.mockClear());
       return utils;
     },
     resetAllMocks() {
-      mocks.forEach((spy) => spy.mockReset());
+      [...mocks].reverse().forEach((spy) => spy.mockReset());
       return utils;
     },
     restoreAllMocks() {
-      mocks.forEach((spy) => spy.mockRestore());
+      [...mocks].reverse().forEach((spy) => spy.mockRestore());
       return utils;
     },
     stubGlobal(name, value) {
-      if (!_stubsGlobal.has(name))
+      if (!_stubsGlobal.has(name)) {
         _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
+      }
       Object.defineProperty(globalThis, name, {
         value,
         writable: true,
@@ -2463,30 +2881,36 @@ function createVitest() {
       return utils;
     },
     stubEnv(name, value) {
-      if (!_stubsEnv.has(name))
+      if (!_stubsEnv.has(name)) {
         _stubsEnv.set(name, process.env[name]);
-      if (_envBooleans.includes(name))
+      }
+      if (_envBooleans.includes(name)) {
         process.env[name] = value ? "1" : "";
-      else
+      } else if (value === void 0) {
+        delete process.env[name];
+      } else {
         process.env[name] = String(value);
+      }
       return utils;
     },
     unstubAllGlobals() {
       _stubsGlobal.forEach((original, name) => {
-        if (!original)
+        if (!original) {
           Reflect.deleteProperty(globalThis, name);
-        else
+        } else {
           Object.defineProperty(globalThis, name, original);
+        }
       });
       _stubsGlobal.clear();
       return utils;
     },
     unstubAllEnvs() {
       _stubsEnv.forEach((original, name) => {
-        if (original === void 0)
+        if (original === void 0) {
           delete process.env[name];
-        else
+        } else {
           process.env[name] = original;
+        }
       });
       _stubsEnv.clear();
       return utils;
@@ -2499,130 +2923,48 @@ function createVitest() {
       return waitForImportsToResolve();
     },
     setConfig(config) {
-      if (!_config)
+      if (!_config) {
         _config = { ...workerState.config };
+      }
       Object.assign(workerState.config, config);
     },
     resetConfig() {
-      if (_config)
+      if (_config) {
         Object.assign(workerState.config, _config);
+      }
     }
   };
   return utils;
 }
 var vitest = createVitest();
 var vi = vitest;
+function _mocker() {
+  return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {
+    throw new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);
+  } });
+}
+function getImporter(name) {
+  const 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 || "";
+}
 
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/vendor/index.dI9lHwVn.js
+// ../../node_modules/.pnpm/vitest@3.1.1_@types+debug@4.1.12_@types+node@22.14.0_jiti@2.4.2_lightningcss@1.29.2_terser@5.39.0_tsx@4.19.3_yaml@2.7.1/node_modules/vitest/dist/index.js
+import { expectTypeOf } from "expect-type.mjs";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from "@vitest/runner.mjs";
 import * as chai2 from "chai.mjs";
 import { assert as assert2, should } from "chai.mjs";
-function getRunningMode() {
-  return process.env.VITEST_MODE === "WATCH" ? "watch" : "run";
-}
-function isWatchMode() {
-  return getRunningMode() === "watch";
-}
-function inject(key) {
-  const workerState = getWorkerState();
-  return workerState.providedContext[key];
-}
-var dist = {};
-(function(exports) {
-  Object.defineProperty(exports, "__esModule", { value: true });
-  exports.expectTypeOf = void 0;
-  const fn2 = () => true;
-  const expectTypeOf2 = (_actual) => {
-    const nonFunctionProperties = [
-      "parameters",
-      "returns",
-      "resolves",
-      "not",
-      "items",
-      "constructorParameters",
-      "thisParameter",
-      "instance",
-      "guards",
-      "asserts",
-      "branded"
-    ];
-    const obj = {
-      /* eslint-disable mmkal/@typescript-eslint/no-unsafe-assignment */
-      toBeAny: fn2,
-      toBeUnknown: fn2,
-      toBeNever: fn2,
-      toBeFunction: fn2,
-      toBeObject: fn2,
-      toBeArray: fn2,
-      toBeString: fn2,
-      toBeNumber: fn2,
-      toBeBoolean: fn2,
-      toBeVoid: fn2,
-      toBeSymbol: fn2,
-      toBeNull: fn2,
-      toBeUndefined: fn2,
-      toBeNullable: fn2,
-      toMatchTypeOf: fn2,
-      toEqualTypeOf: fn2,
-      toBeCallableWith: fn2,
-      toBeConstructibleWith: fn2,
-      /* eslint-enable mmkal/@typescript-eslint/no-unsafe-assignment */
-      extract: exports.expectTypeOf,
-      exclude: exports.expectTypeOf,
-      toHaveProperty: exports.expectTypeOf,
-      parameter: exports.expectTypeOf
-    };
-    const getterProperties = nonFunctionProperties;
-    getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) }));
-    return obj;
-  };
-  exports.expectTypeOf = expectTypeOf2;
-})(dist);
-function noop2() {
-}
-var assertType = noop2;
-var VitestIndex = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  afterAll,
-  afterEach,
-  assert: assert2,
-  assertType,
-  beforeAll,
-  beforeEach,
-  bench,
-  chai: chai2,
-  createExpect,
-  describe,
-  expect: globalExpect,
-  expectTypeOf: dist.expectTypeOf,
-  getRunningMode,
-  inject,
-  isFirstRun,
-  isWatchMode,
-  it,
-  onTestFailed,
-  onTestFinished,
-  runOnce,
-  should,
-  suite,
-  test,
-  vi,
-  vitest
-});
-
-// ../../node_modules/.pnpm/vitest@1.6.1_@types+node@22.13.1_lightningcss@1.29.1_terser@5.38.1/node_modules/vitest/dist/index.js
-import * as chai3 from "chai.mjs";
-import { assert as assert3, should as should2 } from "chai.mjs";
+import "@vitest/expect.mjs";
 import "@vitest/runner/utils.mjs";
 import "@vitest/utils.mjs";
-import "pathe.mjs";
-import "std-env.mjs";
-import "@vitest/expect.mjs";
 import "@vitest/snapshot.mjs";
 import "@vitest/utils/error.mjs";
-import "@vitest/utils/source-map.mjs";
 import "@vitest/spy.mjs";
-var expectTypeOf = dist.expectTypeOf;
+import "@vitest/utils/source-map.mjs";
 
 // src/tests/setup.ts
 var OriginalDate = global.Date;