vitest 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/vendor/{vi.ClD3hi7L.js → vi.BPjl8cAZ.js}

@@ -1,16 +1,18 @@
 import * as chai$1 from 'chai';
 import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.BFTU3MAI.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';
+import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters } from '@vitest/expect';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import { getNames } from '@vitest/runner/utils';
 import '@vitest/utils/error';
 import { getCurrentTest } from '@vitest/runner';
-import { g as getTestName } from './tasks.WC7M-K-v.js';
+import { g as getTestName } from './tasks.DhVtQBtW.js';
 import { g as getWorkerState, a as getCurrentEnvironment } from './global.7bFbnyXl.js';
 import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
+import 'pathe';
+import './env.bmJgw1qP.js';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { i as isChildProcess } from './base._gnK9Slw.js';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.BKM1wewY.js';
+import { i as isChildProcess } from './base.CTYV4Gnz.js';
+import { R as RealDate, r as resetDate, m as mockDate } from './date.W2xKR2qe.js';
 import { spyOn, fn, isMockFunction, mocks } from '@vitest/spy';
 
 function resetModules(modules, resetMocks = false) {
@@ -26,8 +28,9 @@ function resetModules(modules, resetMocks = false) {
     ...!resetMocks ? [/^mock:/] : []
   ];
   modules.forEach((mod, path) => {
-    if (skipPaths.some((re) => re.test(path)))
+    if (skipPaths.some((re) => re.test(path))) {
       return;
+    }
     modules.invalidateModule(mod);
   });
 }
@@ -41,13 +44,16 @@ async function waitForImportsToResolve() {
   const promises = [];
   let resolvingCount = 0;
   for (const mod of state.moduleCache.values()) {
-    if (mod.promise && !mod.evaluated)
+    if (mod.promise && !mod.evaluated) {
       promises.push(mod.promise);
-    if (mod.resolving)
+    }
+    if (mod.resolving) {
       resolvingCount++;
+    }
   }
-  if (!promises.length && !resolvingCount)
+  if (!promises.length && !resolvingCount) {
     return;
+  }
   await Promise.allSettled(promises);
   await waitForImportsToResolve();
 }
@@ -142,41 +148,17 @@ var chaiSubset = {exports: {}};
 var chaiSubsetExports = chaiSubset.exports;
 var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
 
-const MATCHERS_OBJECT = Symbol.for("matchers-object");
-const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
-const GLOBAL_EXPECT = Symbol.for("expect-global");
-const 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 recordAsyncExpect(test, promise) {
   if (test && promise instanceof Promise) {
     promise = promise.finally(() => {
       const index = test.promises.indexOf(promise);
-      if (index !== -1)
+      if (index !== -1) {
         test.promises.splice(index, 1);
+      }
     });
-    if (!test.promises)
+    if (!test.promises) {
       test.promises = [];
+    }
     test.promises.push(promise);
   }
   return promise;
@@ -195,8 +177,11 @@ function getSnapshotClient() {
 }
 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 {
@@ -208,8 +193,9 @@ function getError(expected, promise) {
 }
 const SnapshotPlugin = (chai, utils) => {
   const getTestNames = (test) => {
-    if (!test)
+    if (!test) {
       return {};
+    }
     return {
       filepath: test.file.filepath,
       name: getNames(test).slice(1).join(" > ")
@@ -221,8 +207,9 @@ const SnapshotPlugin = (chai, utils) => {
       key,
       function(properties, message) {
         const isNot = utils.flag(this, "negate");
-        if (isNot)
+        if (isNot) {
           throw new Error(`${key} cannot be used with "not"`);
+        }
         const expected = utils.flag(this, "object");
         const test = utils.flag(this, "vitest-test");
         if (typeof properties === "string" && typeof message === "undefined") {
@@ -246,8 +233,9 @@ const SnapshotPlugin = (chai, utils) => {
     "toMatchFileSnapshot",
     function(file, message) {
       const isNot = utils.flag(this, "negate");
-      if (isNot)
+      if (isNot) {
         throw new Error('toMatchFileSnapshot cannot be used with "not"');
+      }
       const expected = utils.flag(this, "object");
       const test = utils.flag(this, "vitest-test");
       const errorMessage = utils.flag(this, "message");
@@ -270,12 +258,16 @@ const SnapshotPlugin = (chai, utils) => {
     function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
       var _a;
       const isNot = utils.flag(this, "negate");
-      if (isNot)
+      if (isNot) {
         throw new Error('toMatchInlineSnapshot cannot be used with "not"');
+      }
       const test = utils.flag(this, "vitest-test");
       const isInsideEach = test && (test.each || ((_a = test.suite) == null ? void 0 : _a.each));
-      if (isInsideEach)
-        throw new Error("InlineSnapshot cannot be used inside of test.each or describe.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") {
@@ -283,8 +275,9 @@ const SnapshotPlugin = (chai, utils) => {
         inlineSnapshot = properties;
         properties = void 0;
       }
-      if (inlineSnapshot)
+      if (inlineSnapshot) {
         inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+      }
       const errorMessage = utils.flag(this, "message");
       getSnapshotClient().assert({
         received: expected,
@@ -303,8 +296,11 @@ const SnapshotPlugin = (chai, utils) => {
     "toThrowErrorMatchingSnapshot",
     function(message) {
       const isNot = utils.flag(this, "negate");
-      if (isNot)
-        throw new Error('toThrowErrorMatchingSnapshot cannot be used with "not"');
+      if (isNot) {
+        throw new Error(
+          'toThrowErrorMatchingSnapshot cannot be used with "not"'
+        );
+      }
       const expected = utils.flag(this, "object");
       const test = utils.flag(this, "vitest-test");
       const promise = utils.flag(this, "promise");
@@ -323,18 +319,25 @@ const SnapshotPlugin = (chai, utils) => {
     function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
       var _a;
       const isNot = utils.flag(this, "negate");
-      if (isNot)
-        throw new Error('toThrowErrorMatchingInlineSnapshot cannot be used with "not"');
+      if (isNot) {
+        throw new Error(
+          'toThrowErrorMatchingInlineSnapshot cannot be used with "not"'
+        );
+      }
       const test = utils.flag(this, "vitest-test");
       const isInsideEach = test && (test.each || ((_a = test.suite) == null ? void 0 : _a.each));
-      if (isInsideEach)
-        throw new Error("InlineSnapshot cannot be used inside of test.each or describe.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)
+      if (inlineSnapshot) {
         inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+      }
       getSnapshotClient().assert({
         received: getError(expected, promise),
         message,
@@ -346,11 +349,7 @@ const SnapshotPlugin = (chai, utils) => {
       });
     }
   );
-  utils.addMethod(
-    chai.expect,
-    "addSnapshotSerializer",
-    addSerializer
-  );
+  utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 
 chai$1.use(JestExtend);
@@ -359,51 +358,148 @@ chai$1.use(Subset);
 chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
 
+const unsupported = [
+  // .poll is meant to retry matchers until they succeed, and
+  // snapshots will always succeed as long as the poll method doesn't thow an error
+  // in this case using the `vi.waitFor` method is more appropriate
+  "matchSnapshot",
+  "toMatchSnapshot",
+  "toMatchInlineSnapshot",
+  "toThrowErrorMatchingSnapshot",
+  "toThrowErrorMatchingInlineSnapshot",
+  // toThrow will never succeed because we call the poll callback until it doesn't throw
+  "throws",
+  "Throw",
+  "throw",
+  "toThrow",
+  "toThrowError"
+  // these are not supported because you can call them without `.poll`,
+  // we throw an error inside the rejects/resolves methods to prevent this
+  // rejects,
+  // resolves
+];
+function createExpectPoll(expect) {
+  return function poll(fn, options = {}) {
+    var _a;
+    const state = getWorkerState();
+    const defaults = ((_a = state.config.expect) == null ? void 0 : _a.poll) ?? {};
+    const {
+      interval = defaults.interval ?? 50,
+      timeout = defaults.timeout ?? 1e3,
+      message
+    } = options;
+    const assertion = expect(null, message).withContext({
+      poll: true
+    });
+    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");
+          return new Promise((resolve, reject) => {
+            let intervalId;
+            let lastError;
+            const { setTimeout, clearTimeout } = getSafeTimers();
+            const timeoutId = setTimeout(() => {
+              clearTimeout(intervalId);
+              reject(
+                copyStackTrace$1(
+                  new Error(`Matcher did not succeed in ${timeout}ms`, {
+                    cause: lastError
+                  }),
+                  STACK_TRACE_ERROR
+                )
+              );
+            }, timeout);
+            const check = async () => {
+              try {
+                const obj = await fn();
+                chai$1.util.flag(assertion, "object", obj);
+                resolve(await assertionFunction.call(assertion, ...args));
+                clearTimeout(intervalId);
+                clearTimeout(timeoutId);
+              } catch (err) {
+                lastError = err;
+                intervalId = setTimeout(check, interval);
+              }
+            };
+            check();
+          });
+        };
+      }
+    });
+    return proxy;
+  };
+}
+function copyStackTrace$1(target, source) {
+  if (source.stack !== void 0) {
+    target.stack = source.stack.replace(source.message, target.message);
+  }
+  return target;
+}
+
 function createExpect(test) {
   const expect = (value, message) => {
     const { assertionCalls } = getState(expect);
-    setState({ assertionCalls: assertionCalls + 1, soft: false }, expect);
+    setState({ assertionCalls: assertionCalls + 1 }, expect);
     const assert2 = chai$1.expect(value, message);
     const _test = test || getCurrentTest();
-    if (_test)
+    if (_test) {
       return assert2.withTest(_test);
-    else
+    } else {
       return assert2;
+    }
   };
   Object.assign(expect, chai$1.expect);
-  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT$1]);
+  Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
   expect.getState = () => getState(expect);
   expect.setState = (state) => setState(state, expect);
-  const globalState = getState(globalThis[GLOBAL_EXPECT$1]) || {};
+  const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
   const testPath = getTestFile(test);
-  setState({
-    // this should also add "snapshotState" that is added conditionally
-    ...globalState,
-    assertionCalls: 0,
-    isExpectingAssertions: false,
-    isExpectingAssertionsError: null,
-    expectedAssertionsNumber: null,
-    expectedAssertionsNumberErrorGen: null,
-    environment: getCurrentEnvironment(),
-    testPath,
-    currentTestName: test ? getTestName(test) : globalState.currentTestName
-  }, expect);
+  setState(
+    {
+      // this should also add "snapshotState" that is added conditionally
+      ...globalState,
+      assertionCalls: 0,
+      isExpectingAssertions: false,
+      isExpectingAssertionsError: null,
+      expectedAssertionsNumber: null,
+      expectedAssertionsNumberErrorGen: null,
+      environment: getCurrentEnvironment(),
+      testPath,
+      currentTestName: test ? getTestName(test) : globalState.currentTestName
+    },
+    expect
+  );
   expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
   expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
   expect.soft = (...args) => {
-    const assert2 = expect(...args);
-    expect.setState({
-      soft: true
-    });
-    return assert2;
+    return expect(...args).withContext({ soft: true });
   };
+  expect.poll = createExpectPoll(expect);
   expect.unreachable = (message) => {
-    chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+    chai$1.assert.fail(
+      `expected${message ? ` "${message}" ` : " "}not to be reached`
+    );
   };
   function assertions(expected) {
-    const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
-    if (Error.captureStackTrace)
+    const errorGen = () => new Error(
+      `expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`
+    );
+    if (Error.captureStackTrace) {
       Error.captureStackTrace(errorGen(), assertions);
+    }
     expect.setState({
       expectedAssertionsNumber: expected,
       expectedAssertionsNumberErrorGen: errorGen
@@ -411,8 +507,9 @@ function createExpect(test) {
   }
   function hasAssertions() {
     const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace)
+    if (Error.captureStackTrace) {
       Error.captureStackTrace(error, hasAssertions);
+    }
     expect.setState({
       isExpectingAssertions: true,
       isExpectingAssertionsError: error
@@ -423,13 +520,14 @@ function createExpect(test) {
   return expect;
 }
 function getTestFile(test) {
-  if (test)
+  if (test) {
     return test.file.filepath;
+  }
   const state = getWorkerState();
   return state.filepath;
 }
 const globalExpect = createExpect();
-Object.defineProperty(globalThis, GLOBAL_EXPECT$1, {
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
   value: globalExpect,
   writable: true,
   configurable: true
@@ -3074,35 +3172,41 @@ class FakeTimers {
     this._global = global;
   }
   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;
+        }
       }
     }
   }
@@ -3111,18 +3215,21 @@ class FakeTimers {
       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);
+    }
   }
   runAllTicks() {
     if (this._checkFakeTimers()) {
@@ -3147,18 +3254,25 @@ class FakeTimers {
       );
     }
     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())
-        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;
+      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()) {
+        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,
@@ -3186,8 +3300,9 @@ class FakeTimers {
     return this._now();
   }
   getTimerCount() {
-    if (this._checkFakeTimers())
+    if (this._checkFakeTimers()) {
       return this._clock.countTimers();
+    }
     return 0;
   }
   configure(config) {
@@ -3207,8 +3322,9 @@ class FakeTimers {
 }
 
 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 = {}) {
@@ -3221,23 +3337,34 @@ 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)
-        error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_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") {
@@ -3261,8 +3388,9 @@ function waitFor(callback, options = {}) {
         lastError = error;
       }
     };
-    if (checkCallback() === true)
+    if (checkCallback() === true) {
       return;
+    }
     timeoutId = setTimeout(handleTimeout, timeout);
     intervalId = setInterval(checkCallback, interval);
   });
@@ -3276,25 +3404,37 @@ function waitUntil(callback, options = {}) {
     let timeoutId;
     let intervalId;
     const onReject = (error) => {
-      if (!error)
-        error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_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") {
@@ -3317,23 +3457,29 @@ 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;
+  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.`
+          );
+        }
+      }
+    );
+  }
   const workerState = getWorkerState();
   let _timers;
   const timers = () => _timers || (_timers = new FakeTimers({
@@ -3343,10 +3489,13 @@ function createVitest() {
   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);
+  const 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 == null ? void 0 : stack.file) || "";
   };
   const utils = {
@@ -3359,10 +3508,11 @@ function createVitest() {
           );
         }
       }
-      if (config)
+      if (config) {
         timers().configure({ ...workerState.config.fakeTimers, ...config });
-      else
+      } else {
         timers().configure(workerState.config.fakeTimers);
+      }
       timers().useFakeTimers();
       return utils;
     },
@@ -3439,46 +3589,70 @@ function createVitest() {
       return factory();
     },
     mock(path, factory) {
-      if (typeof path !== "string")
-        throw new Error(`vi.mock() expects a string path, but received a ${typeof path}`);
-      const importer = getImporter();
-      _mocker.queueMock(
+      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,
-        factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0,
+        factory ? () => factory(
+          () => _mocker().importActual(
+            path,
+            importer,
+            _mocker().getMockContext().callstack
+          )
+        ) : void 0,
         true
       );
     },
     unmock(path) {
-      if (typeof path !== "string")
-        throw new Error(`vi.unmock() expects a string path, but received a ${typeof 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) {
-      if (typeof path !== "string")
-        throw new Error(`vi.doMock() expects a string path, but received a ${typeof path}`);
-      const importer = getImporter();
-      _mocker.queueMock(
+      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,
-        factory ? () => factory(() => _mocker.importActual(path, importer, _mocker.getMockContext().callstack)) : void 0,
+        factory ? () => factory(
+          () => _mocker().importActual(
+            path,
+            importer,
+            _mocker().getMockContext().callstack
+          )
+        ) : void 0,
         false
       );
     },
     doUnmock(path) {
-      if (typeof path !== "string")
-        throw new Error(`vi.doUnmock() expects a string path, but received a ${typeof 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(
+      return _mocker().importActual(
         path,
-        getImporter(),
-        _mocker.getMockContext().callstack
+        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 = {}) {
@@ -3500,8 +3674,12 @@ function createVitest() {
       return utils;
     },
     stubGlobal(name, value) {
-      if (!_stubsGlobal.has(name))
-        _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
+      if (!_stubsGlobal.has(name)) {
+        _stubsGlobal.set(
+          name,
+          Object.getOwnPropertyDescriptor(globalThis, name)
+        );
+      }
       Object.defineProperty(globalThis, name, {
         value,
         writable: true,
@@ -3511,30 +3689,34 @@ 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 {
         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;
@@ -3547,13 +3729,15 @@ 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;