vitest 2.0.0-beta.9 → 2.0.1

package/dist/vendor/{vi.C6AfDXK6.js → vi.DXACdGTu.js}

@@ -5,14 +5,14 @@ import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest
 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 './env.2ltrQNq0.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) {
@@ -28,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);
   });
 }
@@ -43,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();
 }
@@ -148,11 +152,13 @@ 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;
@@ -171,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 {
@@ -184,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(" > ")
@@ -197,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") {
@@ -222,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");
@@ -246,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") {
@@ -259,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,
@@ -279,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");
@@ -299,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,
@@ -322,11 +349,7 @@ const SnapshotPlugin = (chai, utils) => {
       });
     }
   );
-  utils.addMethod(
-    chai.expect,
-    "addSnapshotSerializer",
-    addSerializer
-  );
+  utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 
 chai$1.use(JestExtend);
@@ -365,16 +388,23 @@ function createExpectPoll(expect) {
       timeout = defaults.timeout ?? 1e3,
       message
     } = options;
-    const assertion = expect(null, message).withContext({ poll: true });
+    const assertion = expect(null, message).withContext({
+      poll: true
+    });
     const proxy = new Proxy(assertion, {
       get(target, key, receiver) {
-        const result = Reflect.get(target, key, receiver);
-        if (typeof result !== "function")
-          return result instanceof chai$1.Assertion ? proxy : result;
-        if (key === "assert")
-          return result;
-        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.`);
+        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) => {
@@ -383,12 +413,20 @@ function createExpectPoll(expect) {
             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));
+              reject(
+                copyStackTrace$1(
+                  new Error(`Matcher did not succeed in ${timeout}ms`, {
+                    cause: lastError
+                  }),
+                  STACK_TRACE_ERROR
+                )
+              );
             }, timeout);
             const check = async () => {
               try {
-                chai$1.util.flag(this, "object", await fn());
-                resolve(await result.call(this, ...args));
+                const obj = await fn();
+                chai$1.util.flag(assertion, "object", obj);
+                resolve(await assertionFunction.call(assertion, ...args));
                 clearTimeout(intervalId);
                 clearTimeout(timeoutId);
               } catch (err) {
@@ -405,8 +443,9 @@ function createExpectPoll(expect) {
   };
 }
 function copyStackTrace$1(target, source) {
-  if (source.stack !== void 0)
+  if (source.stack !== void 0) {
     target.stack = source.stack.replace(source.message, target.message);
+  }
   return target;
 }
 
@@ -416,10 +455,11 @@ function createExpect(test) {
     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]);
@@ -427,18 +467,21 @@ function createExpect(test) {
   expect.setState = (state) => setState(state, expect);
   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) => {
@@ -446,12 +489,17 @@ function createExpect(test) {
   };
   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
@@ -459,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
@@ -471,8 +520,9 @@ function createExpect(test) {
   return expect;
 }
 function getTestFile(test) {
-  if (test)
+  if (test) {
     return test.file.filepath;
+  }
   const state = getWorkerState();
   return state.filepath;
 }
@@ -3122,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;
+        }
       }
     }
   }
@@ -3159,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()) {
@@ -3195,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,
@@ -3234,8 +3300,9 @@ class FakeTimers {
     return this._now();
   }
   getTimerCount() {
-    if (this._checkFakeTimers())
+    if (this._checkFakeTimers()) {
       return this._clock.countTimers();
+    }
     return 0;
   }
   configure(config) {
@@ -3255,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 = {}) {
@@ -3269,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") {
@@ -3309,8 +3388,9 @@ function waitFor(callback, options = {}) {
         lastError = error;
       }
     };
-    if (checkCallback() === true)
+    if (checkCallback() === true) {
       return;
+    }
     timeoutId = setTimeout(handleTimeout, timeout);
     intervalId = setInterval(checkCallback, interval);
   });
@@ -3324,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") {
@@ -3365,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({
@@ -3410,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;
     },
@@ -3490,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}`);
+      if (typeof path !== "string") {
+        throw new TypeError(
+          `vi.mock() expects a string path, but received a ${typeof path}`
+        );
+      }
       const importer = getImporter("mock");
-      _mocker.queueMock(
+      _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("unmock"));
+      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}`);
+      if (typeof path !== "string") {
+        throw new TypeError(
+          `vi.doMock() expects a string path, but received a ${typeof path}`
+        );
+      }
       const importer = getImporter("doMock");
-      _mocker.queueMock(
+      _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("doUnmock"));
+      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("importActual"),
-        _mocker.getMockContext().callstack
+        _mocker().getMockContext().callstack
       );
     },
     async importMock(path) {
-      return _mocker.importMock(path, getImporter("importMock"));
+      return _mocker().importMock(path, getImporter("importMock"));
     },
     // this is typed in the interface so it's not necessary to type it here
     mocked(item, _options = {}) {
@@ -3551,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,
@@ -3562,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;
@@ -3598,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;