@accelint/design-system 1.1.4 → 1.1.6

package/dist/test/setup.js

@@ -12,16 +12,18 @@ import 'react-dom';
 import 'react-dom/client';
 import * as prettyFormat from 'pretty-format.js';
 import lzString from 'lz-string.js';
-import { JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, equals, iterableEquality, subsetEquality } from '@vitest/expect.js';
+import { chai, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers, equals, iterableEquality, subsetEquality } from '@vitest/expect.js';
 import { afterEach as afterEach$1, getCurrentTest } from '@vitest/runner.js';
+import { getSafeTimers, delay } from '@vitest/utils/timers.js';
 import { getNames } from '@vitest/runner/utils.js';
-import * as chai$1 from 'chai.js';
-import { assertTypes, getSafeTimers, createSimpleStackTrace } from '@vitest/utils.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot.js';
 import '@vitest/utils/error.js';
-import { parseSingleStack } from '@vitest/utils/source-map.js';
-import { fn, spyOn, mocks, isMockFunction } from '@vitest/spy.js';
+import '@vitest/utils/helpers.js';
+import '@vitest/spy.js';
+import '@vitest/utils/offset.js';
+import '@vitest/utils/source-map.js';
 import 'expect-type.js';
+import 'pathe.js';
 
 // ../node_modules/.pnpm/@testing-library+jest-dom@6.6.3/node_modules/@testing-library/jest-dom/dist/matchers.mjs
 var matchers_exports = {};
@@ -3877,7 +3879,7 @@ typeof document !== "undefined" && document.body ? getQueriesForElement(document
   return helpers;
 }, initialValue);
 
-// ../node_modules/.pnpm/@testing-library+react@16.3.0_@testing-library+dom@10.4.0_@types+react-dom@19.2.3_@type_4f36caec69ec7efad7b676e805da57e4/node_modules/@testing-library/react/dist/@testing-library/react.esm.js
+// ../node_modules/.pnpm/@testing-library+react@16.3.0_@testing-library+dom@10.4.0_@types+react-dom@19.0.0_@type_c73dee9f0e611c0cf8e2f38a680966d7/node_modules/@testing-library/react/dist/@testing-library/react.esm.js
 var reactAct = typeof React.act === "function" ? React.act : DeprecatedReactTestUtils.act;
 function getGlobalThis() {
   if (typeof globalThis !== "undefined") {
@@ -4025,82 +4027,22 @@ if (typeof process === "undefined" || !process.env?.RTL_SKIP_AUTO_CLEANUP) {
 var NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
   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);
-  }
+  if (!workerState) throw new Error('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- "vitest" is imported inside Vite / Vitest config file\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n');
   return workerState;
 }
-function getCurrentEnvironment() {
-  const state = getWorkerState();
-  return state?.environment.name;
-}
-function isChildProcess() {
-  return typeof process !== "undefined" && !!process.send;
-}
-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: setTimeout2 } = getSafeTimers();
-  return new Promise((resolve) => setTimeout2(resolve, 0));
-}
-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++;
-    }
-  }
-  if (!promises.length && !resolvingCount) {
-    return;
-  }
-  await Promise.allSettled(promises);
-  await waitForImportsToResolve();
-}
 
-// ../node_modules/.pnpm/vitest@2.1.9_@types+node@24.10.1_jsdom@25.0.1_msw@2.12.1_@types+node@24.10.1_typescript@5.9.3_/node_modules/vitest/dist/chunks/_commonjsHelpers.BFTU3MAI.js
+// ../node_modules/.pnpm/vitest@4.0.16_@types+node@25.0.3_jiti@2.6.1_jsdom@25.0.1_msw@2.12.7_@types+node@25.0.3_typescript@5.9.3__tsx@4.21.0/node_modules/vitest/dist/chunks/_commonjsHelpers.D26ty3Ew.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@2.1.9_@types+node@24.10.1_jsdom@25.0.1_msw@2.12.1_@types+node@24.10.1_typescript@5.9.3_/node_modules/vitest/dist/chunks/date.W2xKR2qe.js
+// ../node_modules/.pnpm/vitest@4.0.16_@types+node@25.0.3_jiti@2.6.1_jsdom@25.0.1_msw@2.12.7_@types+node@25.0.3_typescript@5.9.3__tsx@4.21.0/node_modules/vitest/dist/chunks/date.Bq6ZW5rf.js
 var RealDate = Date;
-var now = null;
 var MockDate = class _MockDate extends RealDate {
   constructor(y, m, d, h, M, s, ms) {
     super();
     let date;
     switch (arguments.length) {
       case 0:
-        if (now !== null) {
-          date = new RealDate(now.valueOf());
-        } else {
-          date = new RealDate();
-        }
+        date = new RealDate();
         break;
       case 1:
         date = new RealDate(y);
@@ -4128,257 +4070,122 @@ MockDate.parse = function(dateString) {
 MockDate.toString = function() {
   return RealDate.toString();
 };
-function mockDate(date) {
-  const dateObj = new RealDate(date.valueOf());
-  if (Number.isNaN(dateObj.getTime())) {
-    throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
-  }
-  globalThis.Date = MockDate;
-  now = dateObj.valueOf();
-}
-function resetDate() {
-  globalThis.Date = RealDate;
-}
+
+// ../node_modules/.pnpm/vitest@4.0.16_@types+node@25.0.3_jiti@2.6.1_jsdom@25.0.1_msw@2.12.7_@types+node@25.0.3_typescript@5.9.3__tsx@4.21.0/node_modules/vitest/dist/chunks/vi.2VT5v0um.js
 var unsupported = [
-  // .poll is meant to retry matchers until they succeed, and
-  // snapshots will always succeed as long as the poll method doesn't thow an error
-  // in this case using the `vi.waitFor` method is more appropriate
   "matchSnapshot",
   "toMatchSnapshot",
   "toMatchInlineSnapshot",
   "toThrowErrorMatchingSnapshot",
   "toThrowErrorMatchingInlineSnapshot",
-  // toThrow will never succeed because we call the poll callback until it doesn't throw
   "throws",
   "Throw",
   "throw",
   "toThrow",
   "toThrowError"
-  // these are not supported because you can call them without `.poll`,
-  // we throw an error inside the rejects/resolves methods to prevent this
-  // rejects,
-  // resolves
 ];
-function createExpectPoll(expect2) {
+function throwWithCause(error, source) {
+  if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
+  throw copyStackTrace$1(error, source);
+}
+function createExpectPoll(expect) {
   return function poll(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
-    });
+    const defaults = getWorkerState().config.expect?.poll ?? {};
+    const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+    const assertion = expect(null, message).withContext({ poll: true });
     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 lastError;
-            const { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = getSafeTimers();
-            const timeoutId = setTimeout2(() => {
-              clearTimeout2(intervalId);
-              reject(
-                copyStackTrace$1(
-                  new Error(`Matcher did not succeed in ${timeout}ms`, {
-                    cause: lastError
-                  }),
-                  STACK_TRACE_ERROR
-                )
-              );
-            }, timeout);
-            const check = async () => {
+    const test2 = chai.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.Assertion ? proxy : assertionFunction;
+      if (key === "assert") return assertionFunction;
+      if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
+      return function(...args) {
+        const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+        const promise = async () => {
+          const { setTimeout: setTimeout2, clearTimeout: clearTimeout2 } = getSafeTimers();
+          let executionPhase = "fn";
+          let hasTimedOut = false;
+          const timerId = setTimeout2(() => {
+            hasTimedOut = true;
+          }, timeout);
+          chai.util.flag(assertion, "_name", key);
+          try {
+            while (true) {
+              const isLastAttempt = hasTimedOut;
+              if (isLastAttempt) chai.util.flag(assertion, "_isLastPollAttempt", true);
               try {
-                chai$1.util.flag(assertion, "_name", key);
+                executionPhase = "fn";
                 const obj = await fn2();
-                chai$1.util.flag(assertion, "object", obj);
-                resolve(await assertionFunction.call(assertion, ...args));
-                clearTimeout2(intervalId);
-                clearTimeout2(timeoutId);
+                chai.util.flag(assertion, "object", obj);
+                executionPhase = "assertion";
+                return await assertionFunction.call(assertion, ...args);
               } catch (err) {
-                lastError = err;
-                intervalId = setTimeout2(check, interval);
+                if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) throwWithCause(err, STACK_TRACE_ERROR);
+                await delay(interval, setTimeout2);
               }
-            };
-            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:
+            }
+          } finally {
+            clearTimeout2(timerId);
+          }
+        };
+        let awaited = false;
+        test2.onFinished ??= [];
+        test2.onFinished.push(() => {
+          if (!awaited) {
+            const negated = chai.util.flag(assertion, "negate") ? "not." : "";
+            const assertionString = `expect.${chai.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
+            throw copyStackTrace$1(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:
 
 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"
-          };
+`), STACK_TRACE_ERROR);
+          }
+        });
+        let resultPromise;
+        return {
+          then(onFulfilled, onRejected) {
+            awaited = true;
+            return (resultPromise ||= promise()).then(onFulfilled, onRejected);
+          },
+          catch(onRejected) {
+            return (resultPromise ||= promise()).catch(onRejected);
+          },
+          finally(onFinally) {
+            return (resultPromise ||= promise()).finally(onFinally);
+          },
+          [Symbol.toStringTag]: "Promise"
         };
-      }
-    });
+      };
+    } });
     return proxy;
   };
 }
 function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
+  if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
   return target;
 }
-function commonjsRequire(path) {
-  throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-var chaiSubset$1 = { exports: {} };
-var chaiSubset = chaiSubset$1.exports;
-var hasRequiredChaiSubset;
-function requireChaiSubset() {
-  if (hasRequiredChaiSubset) return chaiSubset$1.exports;
-  hasRequiredChaiSubset = 1;
-  (function(module2, exports$1) {
-    (function() {
-      (function(chaiSubset2) {
-        if (typeof commonjsRequire === "function" && true && true) {
-          return module2.exports = chaiSubset2;
-        } else {
-          return chai.use(chaiSubset2);
-        }
-      })(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;
-          }
-          if (typeof expected !== "object" || expected === null) {
-            return expected === actual;
-          }
-          if (!!expected && !actual) {
-            return false;
-          }
-          if (Array.isArray(expected)) {
-            if (typeof actual.length !== "number") {
-              return false;
-            }
-            var aa = Array.prototype.slice.call(actual);
-            return expected.every(function(exp) {
-              return aa.some(function(act4) {
-                return compare(exp, act4);
-              });
-            });
-          }
-          if (expected instanceof Date) {
-            if (actual instanceof Date) {
-              return expected.getTime() === actual.getTime();
-            } else {
-              return false;
-            }
-          }
-          return Object.keys(expected).every(function(key) {
-            var eo = expected[key];
-            var ao = actual[key];
-            if (typeof eo === "object" && eo !== null && ao !== null) {
-              return compare(eo, ao);
-            }
-            if (typeof eo === "function") {
-              return eo(ao);
-            }
-            return ao === eo;
-          });
-        }
-      });
-    }).call(chaiSubset);
-  })(chaiSubset$1);
-  return chaiSubset$1.exports;
-}
-var chaiSubsetExports = requireChaiSubset();
-var Subset = /* @__PURE__ */ getDefaultExportFromCjs(chaiSubsetExports);
-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 createAssertionMessage(util, assertion, hasArgs) {
+  const not = util.flag(assertion, "negate") ? "not." : "";
+  const name = `${util.flag(assertion, "_name")}(${"expected"})`;
+  const promiseName = util.flag(assertion, "promise");
+  return `expect(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
 }
 function recordAsyncExpect(_test, promise, assertion, error) {
   const test2 = _test;
   if (test2 && promise instanceof Promise) {
     promise = promise.finally(() => {
-      if (!test2.promises) {
-        return;
-      }
+      if (!test2.promises) return;
       const index = test2.promises.indexOf(promise);
-      if (index !== -1) {
-        test2.promises.splice(index, 1);
-      }
+      if (index !== -1) test2.promises.splice(index, 1);
     });
-    if (!test2.promises) {
-      test2.promises = [];
-    }
+    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);
+        const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(error.stack);
         console.warn([
           `Promise returned by \`${assertion}\` was not awaited. `,
           "Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
@@ -4388,9 +4195,9 @@ function recordAsyncExpect(_test, promise, assertion, error) {
       }
     });
     return {
-      then(onFullfilled, onRejected) {
+      then(onFulfilled, onRejected) {
         resolved = true;
-        return promise.then(onFullfilled, onRejected);
+        return promise.then(onFulfilled, onRejected);
       },
       catch(onRejected) {
         return promise.catch(onRejected);
@@ -4405,22 +4212,14 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 }
 var _client;
 function getSnapshotClient() {
-  if (!_client) {
-    _client = new SnapshotClient({
-      isEqual: (received, expected) => {
-        return equals(received, expected, [iterableEquality, subsetEquality]);
-      }
-    });
-  }
+  if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
+    return equals(received, expected, [iterableEquality, subsetEquality]);
+  } });
   return _client;
 }
 function getError(expected, promise) {
   if (typeof expected !== "function") {
-    if (!promise) {
-      throw new Error(
-        `expected must be a function, received ${typeof expected}`
-      );
-    }
+    if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
     return expected;
   }
   try {
@@ -4431,248 +4230,174 @@ function getError(expected, promise) {
   throw new Error("snapshot function didn't throw");
 }
 function getTestNames(test2) {
-  if (!test2) {
-    return {};
-  }
   return {
     filepath: test2.file.filepath,
-    name: getNames(test2).slice(1).join(" > ")
+    name: getNames(test2).slice(1).join(" > "),
+    testId: test2.id
   };
 }
 var SnapshotPlugin = (chai3, utils) => {
-  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(`${key} cannot be used with "not"`);
-        }
-        const expected = utils.flag(this, "object");
-        const test2 = 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(test2)
-        });
-      }
-    );
-  }
-  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 = utils.flag(this, "vitest-test");
-      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 = utils.flag(this, "vitest-test");
-      const isInsideEach = test2 && (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 = 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(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 = utils.flag(this, "vitest-test");
-      const isInsideEach = test2 && (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)
-      });
-    }
-  );
+  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;
+  }
+  for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai3.Assertion.prototype, key, function(properties, message) {
+    utils.flag(this, "_name", key);
+    if (utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
+    const expected = utils.flag(this, "object");
+    const test2 = getTest(key, this);
+    if (typeof properties === "string" && typeof message === "undefined") {
+      message = properties;
+      properties = void 0;
+    }
+    const errorMessage = utils.flag(this, "message");
+    getSnapshotClient().assert({
+      received: expected,
+      message,
+      isInline: false,
+      properties,
+      errorMessage,
+      ...getTestNames(test2)
+    });
+  });
+  utils.addMethod(chai3.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
+    utils.flag(this, "_name", "toMatchFileSnapshot");
+    if (utils.flag(this, "negate")) throw new Error('toMatchFileSnapshot cannot be used with "not"');
+    const error = /* @__PURE__ */ new Error("resolves");
+    const expected = utils.flag(this, "object");
+    const test2 = getTest("toMatchFileSnapshot", this);
+    const errorMessage = utils.flag(this, "message");
+    return recordAsyncExpect(test2, getSnapshotClient().assertRaw({
+      received: expected,
+      message,
+      isInline: false,
+      rawSnapshot: { file },
+      errorMessage,
+      ...getTestNames(test2)
+    }), createAssertionMessage(utils, this), error);
+  });
+  utils.addMethod(chai3.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+    utils.flag(this, "_name", "toMatchInlineSnapshot");
+    if (utils.flag(this, "negate")) throw new Error('toMatchInlineSnapshot cannot be used with "not"');
+    const test2 = getTest("toMatchInlineSnapshot", this);
+    if (test2.each || test2.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+    const expected = utils.flag(this, "object");
+    const error = utils.flag(this, "error");
+    if (typeof properties === "string") {
+      message = inlineSnapshot;
+      inlineSnapshot = properties;
+      properties = void 0;
+    }
+    if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+    const errorMessage = utils.flag(this, "message");
+    getSnapshotClient().assert({
+      received: expected,
+      message,
+      isInline: true,
+      properties,
+      inlineSnapshot,
+      error,
+      errorMessage,
+      ...getTestNames(test2)
+    });
+  });
+  utils.addMethod(chai3.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
+    utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
+    if (utils.flag(this, "negate")) throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
+    const expected = utils.flag(this, "object");
+    const 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) {
+    if (utils.flag(this, "negate")) throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
+    const test2 = getTest("toThrowErrorMatchingInlineSnapshot", this);
+    if (test2.each || test2.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+    const expected = utils.flag(this, "object");
+    const error = utils.flag(this, "error");
+    const promise = utils.flag(this, "promise");
+    const errorMessage = utils.flag(this, "message");
+    if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+    getSnapshotClient().assert({
+      received: getError(expected, promise),
+      message,
+      inlineSnapshot,
+      isInline: true,
+      error,
+      errorMessage,
+      ...getTestNames(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);
+chai.use(JestExtend);
+chai.use(JestChaiExpect);
+chai.use(SnapshotPlugin);
+chai.use(JestAsymmetricMatchers);
 function createExpect(test2) {
-  const expect2 = (value, message) => {
-    const { assertionCalls } = getState(expect2);
-    setState({ assertionCalls: assertionCalls + 1 }, expect2);
-    const assert22 = chai$1.expect(value, message);
+  const expect = ((value, message) => {
+    const { assertionCalls } = getState(expect);
+    setState({ assertionCalls: assertionCalls + 1 }, expect);
+    const assert2 = chai.expect(value, message);
     const _test = getCurrentTest();
-    if (_test) {
-      return assert22.withTest(_test);
-    } else {
-      return assert22;
-    }
-  };
-  Object.assign(expect2, chai$1.expect);
-  Object.assign(expect2, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
-  expect2.getState = () => getState(expect2);
-  expect2.setState = (state) => setState(state, expect2);
+    if (_test)
+      return assert2.withTest(_test);
+    else return assert2;
+  });
+  Object.assign(expect, chai.expect);
+  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+  expect.getState = () => getState(expect);
+  expect.setState = (state) => setState(state, expect);
   const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
-  setState(
-    {
-      // this should also add "snapshotState" that is added conditionally
-      ...globalState,
-      assertionCalls: 0,
-      isExpectingAssertions: false,
-      isExpectingAssertionsError: null,
-      expectedAssertionsNumber: null,
-      expectedAssertionsNumberErrorGen: null,
-      environment: getCurrentEnvironment(),
-      get testPath() {
-        return getWorkerState().filepath;
-      },
-      currentTestName: globalState.currentTestName
+  setState({
+    ...globalState,
+    assertionCalls: 0,
+    isExpectingAssertions: false,
+    isExpectingAssertionsError: null,
+    expectedAssertionsNumber: null,
+    expectedAssertionsNumberErrorGen: null,
+    get testPath() {
+      return getWorkerState().filepath;
     },
-    expect2
-  );
-  expect2.extend = (matchers) => chai$1.expect.extend(expect2, matchers);
-  expect2.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
-  expect2.soft = (...args) => {
-    return expect2(...args).withContext({ soft: true });
+    currentTestName: globalState.currentTestName
+  }, expect);
+  expect.assert = chai.assert;
+  expect.extend = (matchers) => chai.expect.extend(expect, matchers);
+  expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+  expect.soft = (...args) => {
+    return expect(...args).withContext({ soft: true });
   };
-  expect2.poll = createExpectPoll(expect2);
-  expect2.unreachable = (message) => {
-    chai$1.assert.fail(
-      `expected${message ? ` "${message}" ` : " "}not to be reached`
-    );
+  expect.poll = createExpectPoll(expect);
+  expect.unreachable = (message) => {
+    chai.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) {
-      Error.captureStackTrace(errorGen(), assertions);
-    }
-    expect2.setState({
+    const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
+    if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
+    expect.setState({
       expectedAssertionsNumber: expected,
       expectedAssertionsNumberErrorGen: errorGen
     });
   }
   function hasAssertions() {
-    const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(error, hasAssertions);
-    }
-    expect2.setState({
+    const error = /* @__PURE__ */ new Error("expected any number of assertion, but got none");
+    if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
+    expect.setState({
       isExpectingAssertions: true,
       isExpectingAssertionsError: error
     });
   }
-  chai$1.util.addMethod(expect2, "assertions", assertions);
-  chai$1.util.addMethod(expect2, "hasAssertions", hasAssertions);
-  return expect2;
+  chai.util.addMethod(expect, "assertions", assertions);
+  chai.util.addMethod(expect, "hasAssertions", hasAssertions);
+  expect.extend(customMatchers);
+  return expect;
 }
 var globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT, {
@@ -4680,6 +4405,8 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
   writable: true,
   configurable: true
 });
+chai.assert;
+chai.should;
 var fakeTimersSrc = {};
 var global2;
 var hasRequiredGlobal;
@@ -4787,42 +4514,14 @@ function requireCalledInOrder() {
   calledInOrder_1 = calledInOrder;
   return calledInOrder_1;
 }
-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 "";
-    }
-  };
-  return functionName;
-}
 var className_1;
 var hasRequiredClassName;
 function requireClassName() {
   if (hasRequiredClassName) return className_1;
   hasRequiredClassName = 1;
-  var functionName2 = requireFunctionName();
   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;
+    const name = value.constructor && value.constructor.name;
+    return name || null;
   }
   className_1 = className;
   return className_1;
@@ -4878,6 +4577,27 @@ function requireEvery() {
   };
   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 "";
+    }
+  };
+  return functionName;
+}
 var orderByFirstCall_1;
 var hasRequiredOrderByFirstCall;
 function requireOrderByFirstCall() {
@@ -5129,12 +4849,16 @@ function requireFakeTimersSrc() {
   if (hasRequiredFakeTimersSrc) return fakeTimersSrc;
   hasRequiredFakeTimersSrc = 1;
   const globalObject = requireLib().global;
-  let timersModule;
+  let timersModule, timersPromisesModule;
   if (typeof __vitest_required__ !== "undefined") {
     try {
       timersModule = __vitest_required__.timers;
     } catch (e) {
     }
+    try {
+      timersPromisesModule = __vitest_required__.timersPromises;
+    } catch (e) {
+    }
   }
   function withGlobal(_global) {
     const maxTimeout = Math.pow(2, 31) - 1;
@@ -5145,26 +4869,57 @@ function requireFakeTimersSrc() {
     const NOOP_ARRAY = function() {
       return [];
     };
-    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 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;
-    const performancePresent = _global.performance && typeof _global.performance.now === "function";
+    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;
-    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);
+    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 = _global.Intl;
+    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(
+        "The global scope doesn't have a `Date` object (see https://github.com/sinonjs/sinon/issues/1852#issuecomment-419622780)"
+      );
+    }
+    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 });
+      }
+    }
     function isNumberFinite(num) {
       if (Number.isFinite) {
         return Number.isFinite(num);
@@ -5265,80 +5020,66 @@ ${job.error.stack.split("\n").slice(matchedLineIndex + 1).join("\n")}`;
       }
       return infiniteLoopError;
     }
-    function mirrorDateProperties(target, source) {
-      let prop;
-      for (prop in source) {
-        if (source.hasOwnProperty(prop)) {
-          target[prop] = source[prop];
+    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;
         }
       }
-      if (source.now) {
-        target.now = function now2() {
-          return target.clock.now;
+      ClockDate.isFake = true;
+      if (NativeDate.now) {
+        ClockDate.now = function now2() {
+          return ClockDate.clock.now;
         };
-      } else {
-        delete target.now;
       }
-      if (source.toSource) {
-        target.toSource = function toSource() {
-          return source.toSource();
+      if (NativeDate.toSource) {
+        ClockDate.toSource = function toSource() {
+          return NativeDate.toSource();
         };
-      } else {
-        delete target.toSource;
       }
-      target.toString = function toString() {
-        return source.toString();
+      ClockDate.toString = function toString() {
+        return NativeDate.toString();
       };
-      target.prototype = source.prototype;
-      target.parse = source.parse;
-      target.UTC = source.UTC;
-      target.prototype.toUTCString = source.prototype.toUTCString;
-      target.isFake = true;
-      return target;
-    }
-    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
+      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 mirrorDateProperties(ClockDate, NativeDate);
+      });
+      return ClockDateProxy;
     }
     function createIntl() {
-      const ClockIntl = { ...NativeIntl };
+      const ClockIntl = {};
+      Object.getOwnPropertyNames(NativeIntl).forEach(
+        (property) => ClockIntl[property] = NativeIntl[property]
+      );
       ClockIntl.DateTimeFormat = function(...args) {
         const realFormatter = new NativeIntl.DateTimeFormat(...args);
         const formatter = {};
@@ -5624,11 +5365,21 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
             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 (config2.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 [];
       }
@@ -5643,8 +5394,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       );
       clock[`_${method}`] = target[method];
       if (method === "Date") {
-        const date = mirrorDateProperties(clock[method], target[method]);
-        target[method] = date;
+        target[method] = clock[method];
       } else if (method === "Intl") {
         target[method] = clock[method];
       } else if (method === "performance") {
@@ -5687,36 +5437,38 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       clearInterval: _global.clearInterval,
       Date: _global.Date
     };
-    if (setImmediatePresent) {
+    if (isPresent.setImmediate) {
       timers.setImmediate = _global.setImmediate;
+    }
+    if (isPresent.clearImmediate) {
       timers.clearImmediate = _global.clearImmediate;
     }
-    if (hrtimePresent) {
+    if (isPresent.hrtime) {
       timers.hrtime = _global.process.hrtime;
     }
-    if (nextTickPresent) {
+    if (isPresent.nextTick) {
       timers.nextTick = _global.process.nextTick;
     }
-    if (performancePresent) {
+    if (isPresent.performance) {
       timers.performance = _global.performance;
     }
-    if (requestAnimationFramePresent) {
+    if (isPresent.requestAnimationFrame) {
       timers.requestAnimationFrame = _global.requestAnimationFrame;
     }
-    if (queueMicrotaskPresent) {
-      timers.queueMicrotask = true;
+    if (isPresent.queueMicrotask) {
+      timers.queueMicrotask = _global.queueMicrotask;
     }
-    if (cancelAnimationFramePresent) {
+    if (isPresent.cancelAnimationFrame) {
       timers.cancelAnimationFrame = _global.cancelAnimationFrame;
     }
-    if (requestIdleCallbackPresent) {
+    if (isPresent.requestIdleCallback) {
       timers.requestIdleCallback = _global.requestIdleCallback;
     }
-    if (cancelIdleCallbackPresent) {
+    if (isPresent.cancelIdleCallback) {
       timers.cancelIdleCallback = _global.cancelIdleCallback;
     }
-    if (intlPresent) {
-      timers.Intl = _global.Intl;
+    if (isPresent.Intl) {
+      timers.Intl = NativeIntl;
     }
     const originalSetTimeout = _global.setImmediate || _global.setTimeout;
     function createClock(start, loopLimit) {
@@ -5724,11 +5476,6 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       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)"
-        );
-      }
       const clock = {
         now: start,
         Date: createDate(),
@@ -5764,13 +5511,13 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
         const millis = hrt[0] * 1e3 + hrt[1] / 1e6;
         return millis;
       }
-      if (hrtimeBigintPresent) {
+      if (isPresent.hrtimeBigint) {
         hrtime.bigint = function() {
           const parts = hrtime();
           return BigInt(parts[0]) * BigInt(1e9) + BigInt(parts[1]);
         };
       }
-      if (intlPresent) {
+      if (isPresent.Intl) {
         clock.Intl = createIntl();
         clock.Intl.clock = clock;
       }
@@ -5833,7 +5580,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
       clock.clearInterval = function clearInterval2(timerId) {
         return clearTimer(clock, timerId, "Interval");
       };
-      if (setImmediatePresent) {
+      if (isPresent.setImmediate) {
         clock.setImmediate = function setImmediate(func) {
           return addTimer(clock, {
             func,
@@ -6066,6 +5813,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
             function doRun() {
               originalSetTimeout(function() {
                 try {
+                  runJobs(clock);
                   let numTimers;
                   if (i < clock.loopLimit) {
                     if (!clock.timers) {
@@ -6113,6 +5861,7 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
               try {
                 const timer = lastTimer(clock);
                 if (!timer) {
+                  runJobs(clock);
                   resolve(clock.now);
                 }
                 resolve(clock.tickAsync(timer.callAt - clock.now));
@@ -6155,11 +5904,11 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
         }
         clock.tick(ms);
       };
-      if (performancePresent) {
+      if (isPresent.performance) {
         clock.performance = /* @__PURE__ */ Object.create(null);
         clock.performance.now = fakePerformanceNow;
       }
-      if (hrtimePresent) {
+      if (isPresent.hrtime) {
         clock.hrtime = hrtime;
       }
       return clock;
@@ -6186,17 +5935,24 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           "config.target is no longer supported. Use `withGlobal(target)` instead."
         );
       }
+      function handleMissingTimer(timer) {
+        if (config2.ignoreMissingTimers) {
+          return;
+        }
+        throw new ReferenceError(
+          `non-existent timers and/or objects cannot be faked: '${timer}'`
+        );
+      }
       let i, l;
       const clock = createClock(config2.now, config2.loopLimit);
       clock.shouldClearNativeTimers = config2.shouldClearNativeTimers;
       clock.uninstall = function() {
         return uninstall(clock, config2);
       };
+      clock.abortListenerMap = /* @__PURE__ */ new Map();
       clock.methods = config2.toFake || [];
       if (clock.methods.length === 0) {
-        clock.methods = Object.keys(timers).filter(function(key) {
-          return key !== "nextTick" && key !== "queueMicrotask";
-        });
+        clock.methods = Object.keys(timers);
       }
       if (config2.shouldAdvanceTime === true) {
         const intervalTick = doIntervalTick.bind(
@@ -6225,17 +5981,25 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
               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(config2.now);
         } else if ((config2.toFake || []).includes("performance")) {
-          throw new ReferenceError(
-            "non-existent performance object cannot be faked"
-          );
+          return handleMissingTimer("performance");
         }
       }
       if (_global === globalObject && timersModule) {
         clock.timersModuleMethods = [];
       }
+      if (_global === globalObject && timersPromisesModule) {
+        clock.timersPromisesModuleMethods = [];
+      }
       for (i = 0, l = clock.methods.length; i < l; i++) {
         const nameOfMethodToReplace = clock.methods[i];
+        if (!isPresent[nameOfMethodToReplace]) {
+          handleMissingTimer(nameOfMethodToReplace);
+          continue;
+        }
         if (nameOfMethodToReplace === "hrtime") {
           if (_global.process && typeof _global.process.hrtime === "function") {
             hijackMethod(_global.process, nameOfMethodToReplace, clock);
@@ -6255,6 +6019,194 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
           });
           timersModule[nameOfMethodToReplace] = _global[nameOfMethodToReplace];
         }
+        if (clock.timersPromisesModuleMethods !== void 0) {
+          if (nameOfMethodToReplace === "setTimeout") {
+            clock.timersPromisesModuleMethods.push({
+              methodName: "setTimeout",
+              original: timersPromisesModule.setTimeout
+            });
+            timersPromisesModule.setTimeout = (delay2, 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);
+              }, delay2);
+              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 = (delay2, 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++;
+                  }
+                }, delay2);
+                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;
     }
@@ -6272,604 +6224,33 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`
   fakeTimersSrc.withGlobal = withGlobal;
   return fakeTimersSrc;
 }
-var fakeTimersSrcExports = requireFakeTimersSrc();
-var FakeTimers = class {
-  _global;
-  _clock;
-  _fakingTime;
-  _fakingDate;
-  _fakeTimers;
-  _userConfig;
-  _now = RealDate.now;
-  constructor({
-    global: global3,
-    config: config2
-  }) {
-    this._userConfig = config2;
-    this._fakingDate = false;
-    this._fakingTime = false;
-    this._fakeTimers = fakeTimersSrcExports.withGlobal(global3);
-    this._global = global3;
-  }
-  clearAllTimers() {
-    if (this._fakingTime) {
-      this._clock.reset();
-    }
-  }
-  dispose() {
-    this.useRealTimers();
-  }
-  runAllTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runAll();
-    }
-  }
-  async runAllTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runAllAsync();
-    }
-  }
-  runOnlyPendingTimers() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToLast();
-    }
-  }
-  async runOnlyPendingTimersAsync() {
-    if (this._checkFakeTimers()) {
-      await this._clock.runToLastAsync();
-    }
-  }
-  advanceTimersToNextTimer(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        this._clock.next();
-        this._clock.tick(0);
-        if (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
-    }
-  }
-  async advanceTimersToNextTimerAsync(steps = 1) {
-    if (this._checkFakeTimers()) {
-      for (let i = steps; i > 0; i--) {
-        await this._clock.nextAsync();
-        this._clock.tick(0);
-        if (this._clock.countTimers() === 0) {
-          break;
-        }
-      }
-    }
-  }
-  advanceTimersByTime(msToRun) {
-    if (this._checkFakeTimers()) {
-      this._clock.tick(msToRun);
-    }
-  }
-  async advanceTimersByTimeAsync(msToRun) {
-    if (this._checkFakeTimers()) {
-      await this._clock.tickAsync(msToRun);
-    }
-  }
-  advanceTimersToNextFrame() {
-    if (this._checkFakeTimers()) {
-      this._clock.runToFrame();
-    }
-  }
-  runAllTicks() {
-    if (this._checkFakeTimers()) {
-      this._clock.runMicrotasks();
-    }
-  }
-  useRealTimers() {
-    if (this._fakingDate) {
-      resetDate();
-      this._fakingDate = false;
-    }
-    if (this._fakingTime) {
-      this._clock.uninstall();
-      this._fakingTime = false;
-    }
-  }
-  useFakeTimers() {
-    if (this._fakingDate) {
-      throw new Error(
-        '"setSystemTime" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.'
-      );
-    }
-    if (!this._fakingTime) {
-      const toFake = Object.keys(this._fakeTimers.timers).filter(
-        (timer) => timer !== "nextTick"
-      );
-      if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) {
-        throw new Error(
-          "process.nextTick cannot be mocked inside child_process"
-        );
-      }
-      const existingFakedMethods = (this._userConfig?.toFake || toFake).filter(
-        (method) => {
-          switch (method) {
-            case "setImmediate":
-            case "clearImmediate":
-              return method in this._global && this._global[method];
-            default:
-              return true;
-          }
-        }
-      );
-      this._clock = this._fakeTimers.install({
-        now: Date.now(),
-        ...this._userConfig,
-        toFake: existingFakedMethods
-      });
-      this._fakingTime = true;
-    }
-  }
-  reset() {
-    if (this._checkFakeTimers()) {
-      const { now: now2 } = this._clock;
-      this._clock.reset();
-      this._clock.setSystemTime(now2);
-    }
-  }
-  setSystemTime(now2) {
-    if (this._fakingTime) {
-      this._clock.setSystemTime(now2);
-    } else {
-      mockDate(now2 ?? this.getRealSystemTime());
-      this._fakingDate = true;
-    }
-  }
-  getRealSystemTime() {
-    return this._now();
-  }
-  getTimerCount() {
-    if (this._checkFakeTimers()) {
-      return this._clock.countTimers();
-    }
-    return 0;
-  }
-  configure(config2) {
-    this._userConfig = config2;
-  }
-  isFakeTimers() {
-    return this._fakingTime;
-  }
-  _checkFakeTimers() {
-    if (!this._fakingTime) {
-      throw new Error(
-        'Timers are not mocked. Try calling "vi.useFakeTimers()" first.'
-      );
-    }
-    return this._fakingTime;
-  }
-};
-function copyStackTrace2(target, source) {
-  if (source.stack !== void 0) {
-    target.stack = source.stack.replace(source.message, target.message);
-  }
-  return target;
-}
-function waitFor2(callback, options = {}) {
-  const { setTimeout: setTimeout2, setInterval: setInterval2, clearTimeout: clearTimeout2, clearInterval: clearInterval2 } = getSafeTimers();
-  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-  return new Promise((resolve, reject) => {
-    let lastError;
-    let promiseStatus = "idle";
-    let timeoutId;
-    let intervalId;
-    const onResolve = (result) => {
-      if (timeoutId) {
-        clearTimeout2(timeoutId);
-      }
-      if (intervalId) {
-        clearInterval2(intervalId);
-      }
-      resolve(result);
-    };
-    const handleTimeout = () => {
-      if (intervalId) {
-        clearInterval2(intervalId);
-      }
-      let error = lastError;
-      if (!error) {
-        error = copyStackTrace2(
-          new Error("Timed out in waitFor!"),
-          STACK_TRACE_ERROR
-        );
-      }
-      reject(error);
-    };
-    const checkCallback = () => {
-      if (vi.isFakeTimers()) {
-        vi.advanceTimersByTime(interval);
-      }
-      if (promiseStatus === "pending") {
-        return;
-      }
-      try {
-        const result = callback();
-        if (result !== null && typeof result === "object" && typeof result.then === "function") {
-          const thenable = result;
-          promiseStatus = "pending";
-          thenable.then(
-            (resolvedValue) => {
-              promiseStatus = "resolved";
-              onResolve(resolvedValue);
-            },
-            (rejectedValue) => {
-              promiseStatus = "rejected";
-              lastError = rejectedValue;
-            }
-          );
-        } else {
-          onResolve(result);
-          return true;
-        }
-      } catch (error) {
-        lastError = error;
-      }
-    };
-    if (checkCallback() === true) {
-      return;
-    }
-    timeoutId = setTimeout2(handleTimeout, timeout);
-    intervalId = setInterval2(checkCallback, interval);
-  });
-}
-function waitUntil(callback, options = {}) {
-  const { setTimeout: setTimeout2, setInterval: setInterval2, clearTimeout: clearTimeout2, clearInterval: clearInterval2 } = getSafeTimers();
-  const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-  const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
-  return new Promise((resolve, reject) => {
-    let promiseStatus = "idle";
-    let timeoutId;
-    let intervalId;
-    const onReject = (error) => {
-      if (intervalId) {
-        clearInterval2(intervalId);
-      }
-      if (!error) {
-        error = copyStackTrace2(
-          new Error("Timed out in waitUntil!"),
-          STACK_TRACE_ERROR
-        );
-      }
-      reject(error);
-    };
-    const onResolve = (result) => {
-      if (!result) {
-        return;
-      }
-      if (timeoutId) {
-        clearTimeout2(timeoutId);
-      }
-      if (intervalId) {
-        clearInterval2(intervalId);
-      }
-      resolve(result);
-      return true;
-    };
-    const checkCallback = () => {
-      if (vi.isFakeTimers()) {
-        vi.advanceTimersByTime(interval);
-      }
-      if (promiseStatus === "pending") {
-        return;
-      }
-      try {
-        const result = callback();
-        if (result !== null && typeof result === "object" && typeof result.then === "function") {
-          const thenable = result;
-          promiseStatus = "pending";
-          thenable.then(
-            (resolvedValue) => {
-              promiseStatus = "resolved";
-              onResolve(resolvedValue);
-            },
-            (rejectedValue) => {
-              promiseStatus = "rejected";
-              onReject(rejectedValue);
-            }
-          );
-        } else {
-          return onResolve(result);
-        }
-      } catch (error) {
-        onReject(error);
-      }
-    };
-    if (checkCallback() === true) {
-      return;
-    }
-    timeoutId = setTimeout2(onReject, timeout);
-    intervalId = setInterval2(checkCallback, interval);
-  });
-}
-function createVitest() {
-  let _mockedDate = null;
-  let _config = null;
-  const workerState = getWorkerState();
-  let _timers;
-  const timers = () => _timers ||= new FakeTimers({
-    global: globalThis,
-    config: workerState.config.fakeTimers
-  });
-  const _stubsGlobal = /* @__PURE__ */ new Map();
-  const _stubsEnv = /* @__PURE__ */ new Map();
-  const _envBooleans = ["PROD", "DEV", "SSR"];
-  const utils = {
-    useFakeTimers(config2) {
-      if (isChildProcess()) {
-        if (config2?.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 (config2) {
-        timers().configure({ ...workerState.config.fakeTimers, ...config2 });
-      } else {
-        timers().configure(workerState.config.fakeTimers);
-      }
-      timers().useFakeTimers();
-      return utils;
-    },
-    isFakeTimers() {
-      return timers().isFakeTimers();
-    },
-    useRealTimers() {
-      timers().useRealTimers();
-      _mockedDate = null;
-      return utils;
-    },
-    runOnlyPendingTimers() {
-      timers().runOnlyPendingTimers();
-      return utils;
-    },
-    async runOnlyPendingTimersAsync() {
-      await timers().runOnlyPendingTimersAsync();
-      return utils;
-    },
-    runAllTimers() {
-      timers().runAllTimers();
-      return utils;
-    },
-    async runAllTimersAsync() {
-      await timers().runAllTimersAsync();
-      return utils;
-    },
-    runAllTicks() {
-      timers().runAllTicks();
-      return utils;
-    },
-    advanceTimersByTime(ms) {
-      timers().advanceTimersByTime(ms);
-      return utils;
-    },
-    async advanceTimersByTimeAsync(ms) {
-      await timers().advanceTimersByTimeAsync(ms);
-      return utils;
-    },
-    advanceTimersToNextTimer() {
-      timers().advanceTimersToNextTimer();
-      return utils;
-    },
-    async advanceTimersToNextTimerAsync() {
-      await timers().advanceTimersToNextTimerAsync();
-      return utils;
-    },
-    advanceTimersToNextFrame() {
-      timers().advanceTimersToNextFrame();
-      return utils;
-    },
-    getTimerCount() {
-      return timers().getTimerCount();
-    },
-    setSystemTime(time) {
-      const date = time instanceof Date ? time : new Date(time);
-      _mockedDate = date;
-      timers().setSystemTime(date);
-      return utils;
-    },
-    getMockedSystemTime() {
-      return _mockedDate;
-    },
-    getRealSystemTime() {
-      return timers().getRealSystemTime();
-    },
-    clearAllTimers() {
-      timers().clearAllTimers();
-      return utils;
-    },
-    // mocks
-    spyOn,
-    fn,
-    waitFor: waitFor2,
-    waitUntil,
-    hoisted(factory) {
-      assertTypes(factory, '"vi.hoisted" factory', ["function"]);
-      return factory();
-    },
-    mock(path, factory) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.mock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      const importer = getImporter("mock");
-      _mocker().queueMock(
-        path,
-        importer,
-        typeof factory === "function" ? () => factory(
-          () => _mocker().importActual(
-            path,
-            importer,
-            _mocker().getMockContext().callstack
-          )
-        ) : factory
-      );
-    },
-    unmock(path) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.unmock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      _mocker().queueUnmock(path, getImporter("unmock"));
-    },
-    doMock(path, factory) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.doMock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      const importer = getImporter("doMock");
-      _mocker().queueMock(
-        path,
-        importer,
-        typeof factory === "function" ? () => factory(
-          () => _mocker().importActual(
-            path,
-            importer,
-            _mocker().getMockContext().callstack
-          )
-        ) : factory
-      );
-    },
-    doUnmock(path) {
-      if (typeof path !== "string") {
-        throw new TypeError(
-          `vi.doUnmock() expects a string path, but received a ${typeof path}`
-        );
-      }
-      _mocker().queueUnmock(path, getImporter("doUnmock"));
-    },
-    async importActual(path) {
-      return _mocker().importActual(
-        path,
-        getImporter("importActual"),
-        _mocker().getMockContext().callstack
-      );
-    },
-    async importMock(path) {
-      return _mocker().importMock(path, getImporter("importMock"));
-    },
-    // this is typed in the interface so it's not necessary to type it here
-    mocked(item, _options = {}) {
-      return item;
-    },
-    isMockFunction(fn2) {
-      return isMockFunction(fn2);
-    },
-    clearAllMocks() {
-      mocks.forEach((spy) => spy.mockClear());
-      return utils;
-    },
-    resetAllMocks() {
-      mocks.forEach((spy) => spy.mockReset());
-      return utils;
-    },
-    restoreAllMocks() {
-      mocks.forEach((spy) => spy.mockRestore());
-      return utils;
-    },
-    stubGlobal(name, value) {
-      if (!_stubsGlobal.has(name)) {
-        _stubsGlobal.set(
-          name,
-          Object.getOwnPropertyDescriptor(globalThis, name)
-        );
-      }
-      Object.defineProperty(globalThis, name, {
-        value,
-        writable: true,
-        configurable: true,
-        enumerable: true
-      });
-      return utils;
-    },
-    stubEnv(name, value) {
-      if (!_stubsEnv.has(name)) {
-        _stubsEnv.set(name, process.env[name]);
-      }
-      if (_envBooleans.includes(name)) {
-        process.env[name] = value ? "1" : "";
-      } else if (value === void 0) {
-        delete process.env[name];
-      } else {
-        process.env[name] = String(value);
-      }
-      return utils;
-    },
-    unstubAllGlobals() {
-      _stubsGlobal.forEach((original, name) => {
-        if (!original) {
-          Reflect.deleteProperty(globalThis, name);
-        } else {
-          Object.defineProperty(globalThis, name, original);
-        }
-      });
-      _stubsGlobal.clear();
-      return utils;
-    },
-    unstubAllEnvs() {
-      _stubsEnv.forEach((original, name) => {
-        if (original === void 0) {
-          delete process.env[name];
-        } else {
-          process.env[name] = original;
-        }
-      });
-      _stubsEnv.clear();
-      return utils;
-    },
-    resetModules() {
-      resetModules(workerState.moduleCache);
-      return utils;
-    },
-    async dynamicImportSettled() {
-      return waitForImportsToResolve();
-    },
-    setConfig(config2) {
-      if (!_config) {
-        _config = { ...workerState.config };
-      }
-      Object.assign(workerState.config, config2);
-    },
-    resetConfig() {
-      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.`
-        );
-      }
-    }
-  );
+requireFakeTimersSrc();
+typeof process < "u" && process.platform === "win32";
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  let c = chars.charCodeAt(i);
+  intToChar[i] = c, charToInt[c] = i;
 }
-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 || "";
+var customizationHookNamespace = "vite-module-runner:import-meta-resolve/v1/";
+`
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier.startsWith(${JSON.stringify(customizationHookNamespace)})) {
+    const data = specifier.slice(${JSON.stringify(customizationHookNamespace)}.length)
+    const [parsedSpecifier, parsedImporter] = JSON.parse(data)
+    specifier = parsedSpecifier
+    context.parentURL = parsedImporter
+  }
+  return nextResolve(specifier, context)
 }
 
+`;
+new Proxy({}, { get(_, p) {
+  throw Error(`[module runner] Dynamic access of "import.meta.env" is not supported. Please, use "import.meta.env.${String(p)}" instead.`);
+} });
+
 // src/test/setup.ts
 globalExpect.extend(matchers_exports);
 afterEach$1(() => {