vitest 2.0.0-beta.9 → 2.0.1

package/dist/vendor/{constants.TCjCaw2D.js → constants.CsnA4eRy.js}

@@ -1,9 +1,7 @@
 const defaultPort = 51204;
 const defaultBrowserPort = 63315;
 const defaultInspectPort = 9229;
-const EXIT_CODE_RESTART = 43;
 const API_PATH = "/__vitest_api__";
-const BROWSER_API_PATH = "/__vitest_browser_api__";
 const extraInlineDeps = [
   /^(?!.*node_modules).*\.mjs$/,
   /^(?!.*node_modules).*\.cjs\.js$/,
@@ -12,29 +10,13 @@ const extraInlineDeps = [
   // Nuxt
   "@nuxt/test-utils"
 ];
-const CONFIG_NAMES = [
-  "vitest.config",
-  "vite.config"
-];
-const WORKSPACES_NAMES = [
-  "vitest.workspace",
-  "vitest.projects"
-];
-const CONFIG_EXTENSIONS = [
-  ".ts",
-  ".mts",
-  ".cts",
-  ".js",
-  ".mjs",
-  ".cjs"
-];
+const CONFIG_NAMES = ["vitest.config", "vite.config"];
+const WORKSPACES_NAMES = ["vitest.workspace", "vitest.projects"];
+const CONFIG_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
 const configFiles = CONFIG_NAMES.flatMap(
   (name) => CONFIG_EXTENSIONS.map((ext) => name + ext)
 );
-const WORKSPACES_EXTENSIONS = [
-  ...CONFIG_EXTENSIONS,
-  ".json"
-];
+const WORKSPACES_EXTENSIONS = [...CONFIG_EXTENSIONS, ".json"];
 const workspacesFiles = WORKSPACES_NAMES.flatMap(
   (name) => WORKSPACES_EXTENSIONS.map((ext) => name + ext)
 );
@@ -63,4 +45,4 @@ const globalApis = [
   "onTestFailed"
 ];
 
-export { API_PATH as A, BROWSER_API_PATH as B, CONFIG_NAMES as C, EXIT_CODE_RESTART as E, defaultBrowserPort as a, defaultInspectPort as b, configFiles as c, defaultPort as d, extraInlineDeps as e, globalApis as g, workspacesFiles as w };
+export { API_PATH as A, CONFIG_NAMES as C, defaultBrowserPort as a, defaultInspectPort as b, configFiles as c, defaultPort as d, extraInlineDeps as e, globalApis as g, workspacesFiles as w };

package/dist/vendor/{coverage.ChSqD-qS.js → coverage.BhYSDdTT.js}

@@ -3,50 +3,66 @@ const CoverageProviderMap = {
   istanbul: "@vitest/coverage-istanbul"
 };
 async function resolveCoverageProviderModule(options, loader) {
-  if (!(options == null ? void 0 : options.enabled) || !options.provider)
+  if (!(options == null ? void 0 : options.enabled) || !options.provider) {
     return null;
+  }
   const provider = options.provider;
   if (provider === "v8" || provider === "istanbul") {
-    const { default: coverageModule } = await loader.executeId(CoverageProviderMap[provider]);
-    if (!coverageModule)
-      throw new Error(`Failed to load ${CoverageProviderMap[provider]}. Default export is missing.`);
+    const { default: coverageModule } = await loader.executeId(
+      CoverageProviderMap[provider]
+    );
+    if (!coverageModule) {
+      throw new Error(
+        `Failed to load ${CoverageProviderMap[provider]}. Default export is missing.`
+      );
+    }
     return coverageModule;
   }
   let customProviderModule;
   try {
     customProviderModule = await loader.executeId(options.customProviderModule);
   } catch (error) {
-    throw new Error(`Failed to load custom CoverageProviderModule from ${options.customProviderModule}`, { cause: error });
+    throw new Error(
+      `Failed to load custom CoverageProviderModule from ${options.customProviderModule}`,
+      { cause: error }
+    );
+  }
+  if (customProviderModule.default == null) {
+    throw new Error(
+      `Custom CoverageProviderModule loaded from ${options.customProviderModule} was not the default export`
+    );
   }
-  if (customProviderModule.default == null)
-    throw new Error(`Custom CoverageProviderModule loaded from ${options.customProviderModule} was not the default export`);
   return customProviderModule.default;
 }
 async function getCoverageProvider(options, loader) {
   const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule)
+  if (coverageModule) {
     return coverageModule.getProvider();
+  }
   return null;
 }
 async function startCoverageInsideWorker(options, loader) {
   var _a;
   const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule)
+  if (coverageModule) {
     return (_a = coverageModule.startCoverage) == null ? void 0 : _a.call(coverageModule);
+  }
   return null;
 }
 async function takeCoverageInsideWorker(options, loader) {
   var _a;
   const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule)
+  if (coverageModule) {
     return (_a = coverageModule.takeCoverage) == null ? void 0 : _a.call(coverageModule);
+  }
   return null;
 }
 async function stopCoverageInsideWorker(options, loader) {
   var _a;
   const coverageModule = await resolveCoverageProviderModule(options, loader);
-  if (coverageModule)
+  if (coverageModule) {
     return (_a = coverageModule.stopCoverage) == null ? void 0 : _a.call(coverageModule);
+  }
   return null;
 }
 

package/dist/vendor/{date.BKM1wewY.js → date.W2xKR2qe.js}

@@ -6,10 +6,11 @@ class MockDate extends RealDate {
     let date;
     switch (arguments.length) {
       case 0:
-        if (now !== null)
+        if (now !== null) {
           date = new RealDate(now.valueOf());
-        else
+        } else {
           date = new RealDate();
+        }
         break;
       case 1:
         date = new RealDate(y);
@@ -39,8 +40,9 @@ MockDate.toString = function() {
 };
 function mockDate(date) {
   const dateObj = new RealDate(date.valueOf());
-  if (Number.isNaN(dateObj.getTime()))
+  if (Number.isNaN(dateObj.getTime())) {
     throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+  }
   globalThis.Date = MockDate;
   now = dateObj.valueOf();
 }

package/dist/vendor/env.2ltrQNq0.js

@@ -0,0 +1,8 @@
+import 'std-env';
+
+var _a, _b;
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && ((_b = process.versions) == null ? void 0 : _b.deno) !== void 0;
+const isWindows = (isNode || isDeno) && process.platform === "win32";
+
+export { isDeno as a, isWindows as b, isNode as i };

package/dist/vendor/{execute.BHj6OMh4.js → execute.Dx503nGn.js}

@@ -1,14 +1,15 @@
 import vm from 'node:vm';
 import { pathToFileURL } from 'node:url';
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import fs from 'node:fs';
 import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
 import { isNodeBuiltin, isInternalRequest, toFilePath, isPrimitive } from 'vite-node/utils';
 import { resolve, isAbsolute, dirname, join, basename, extname, normalize, relative } from 'pathe';
 import { processError } from '@vitest/utils/error';
 import { distDir } from '../path.js';
 import { highlight, getType } from '@vitest/utils';
-import { g as getAllMockableProperties } from './base._gnK9Slw.js';
+import { g as getAllMockableProperties } from './base.CTYV4Gnz.js';
 
+const { existsSync, readdirSync } = fs;
 const spyModulePath = resolve(distDir, "spy.js");
 class RefTracker {
   idMap = /* @__PURE__ */ new Map();
@@ -33,12 +34,39 @@ class VitestMocker {
   constructor(executor) {
     this.executor = executor;
     const context = this.executor.options.context;
-    if (context)
-      this.primitives = vm.runInContext("({ Object, Error, Function, RegExp, Symbol, Array, Map })", context);
-    else
-      this.primitives = { Object, Error, Function, RegExp, Symbol: globalThis.Symbol, Array, Map };
+    if (context) {
+      this.primitives = vm.runInContext(
+        "({ Object, Error, Function, RegExp, Symbol, Array, Map })",
+        context
+      );
+    } else {
+      this.primitives = {
+        Object,
+        Error,
+        Function,
+        RegExp,
+        Symbol: globalThis.Symbol,
+        Array,
+        Map
+      };
+    }
     const Symbol2 = this.primitives.Symbol;
-    this.filterPublicKeys = ["__esModule", Symbol2.asyncIterator, Symbol2.hasInstance, Symbol2.isConcatSpreadable, Symbol2.iterator, Symbol2.match, Symbol2.matchAll, Symbol2.replace, Symbol2.search, Symbol2.split, Symbol2.species, Symbol2.toPrimitive, Symbol2.toStringTag, Symbol2.unscopables];
+    this.filterPublicKeys = [
+      "__esModule",
+      Symbol2.asyncIterator,
+      Symbol2.hasInstance,
+      Symbol2.isConcatSpreadable,
+      Symbol2.iterator,
+      Symbol2.match,
+      Symbol2.matchAll,
+      Symbol2.replace,
+      Symbol2.search,
+      Symbol2.split,
+      Symbol2.species,
+      Symbol2.toPrimitive,
+      Symbol2.toStringTag,
+      Symbol2.unscopables
+    ];
   }
   static pendingIds = [];
   spyModule;
@@ -65,8 +93,9 @@ class VitestMocker {
   }
   deleteCachedItem(id) {
     const mockId = this.getMockPath(id);
-    if (this.moduleCache.has(mockId))
+    if (this.moduleCache.has(mockId)) {
       this.moduleCache.delete(mockId);
+    }
   }
   isModuleDirectory(path) {
     return this.moduleDirectories.some((dir) => path.includes(dir));
@@ -111,22 +140,31 @@ class VitestMocker {
     };
   }
   async resolveMocks() {
-    if (!VitestMocker.pendingIds.length)
+    if (!VitestMocker.pendingIds.length) {
       return;
-    await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
-      const { fsPath, external } = await this.resolvePath(mock.id, mock.importer);
-      if (mock.type === "unmock")
-        this.unmockPath(fsPath);
-      if (mock.type === "mock")
-        this.mockPath(mock.id, fsPath, external, mock.factory);
-    }));
+    }
+    await Promise.all(
+      VitestMocker.pendingIds.map(async (mock) => {
+        const { fsPath, external } = await this.resolvePath(
+          mock.id,
+          mock.importer
+        );
+        if (mock.type === "unmock") {
+          this.unmockPath(fsPath);
+        }
+        if (mock.type === "mock") {
+          this.mockPath(mock.id, fsPath, external, mock.factory);
+        }
+      })
+    );
     VitestMocker.pendingIds = [];
   }
   async callFunctionMock(dep, mock) {
     var _a, _b;
     const cached = (_a = this.moduleCache.get(dep)) == null ? void 0 : _a.exports;
-    if (cached)
+    if (cached) {
       return cached;
+    }
     let exports;
     try {
       exports = await mock();
@@ -139,19 +177,26 @@ class VitestMocker {
     }
     const filepath = dep.slice(5);
     const mockpath = ((_b = this.resolveCache.get(this.getSuiteFilepath())) == null ? void 0 : _b[filepath]) || filepath;
-    if (exports === null || typeof exports !== "object")
-      throw this.createError(`[vitest] vi.mock("${mockpath}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`);
+    if (exports === null || typeof exports !== "object") {
+      throw this.createError(
+        `[vitest] vi.mock("${mockpath}", factory?: () => unknown) is not returning an object. Did you mean to return an object with a "default" key?`
+      );
+    }
     const moduleExports = new Proxy(exports, {
       get: (target, prop) => {
         const val = target[prop];
         if (prop === "then") {
-          if (target instanceof Promise)
+          if (target instanceof Promise) {
             return target.then.bind(target);
+          }
         } else if (!(prop in target)) {
-          if (this.filterPublicKeys.includes(prop))
+          if (this.filterPublicKeys.includes(prop)) {
             return void 0;
+          }
           throw this.createError(
-            `[vitest] No "${String(prop)}" export is defined on the "${mockpath}" mock. Did you forget to return it from "vi.mock"?
+            `[vitest] No "${String(
+              prop
+            )}" export is defined on the "${mockpath}" mock. Did you forget to return it from "vi.mock"?
 If you need to partially mock a module, you can use "importOriginal" helper inside:
 `,
             highlight(`vi.mock("${mockpath}", async (importOriginal) => {
@@ -186,14 +231,16 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
       const mockDirname = dirname(path);
       const mockFolder = join(this.root, "__mocks__", mockDirname);
-      if (!existsSync(mockFolder))
+      if (!existsSync(mockFolder)) {
         return null;
+      }
       const files = readdirSync(mockFolder);
       const baseOriginal = basename(path);
       for (const file of files) {
         const baseFile = basename(file, extname(file));
-        if (baseFile === baseOriginal)
+        if (baseFile === baseOriginal) {
           return resolve(mockFolder, file);
+        }
       }
       return null;
     }
@@ -216,7 +263,11 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     const mockPropertiesOf = (container, newContainer) => {
       const containerType = getType(container);
       const isModule = containerType === "Module" || !!container.__esModule;
-      for (const { key: property, descriptor } of getAllMockableProperties(container, isModule, this.primitives)) {
+      for (const { key: property, descriptor } of getAllMockableProperties(
+        container,
+        isModule,
+        this.primitives
+      )) {
         if (!isModule && descriptor.get) {
           try {
             Object.defineProperty(newContainer, property, descriptor);
@@ -224,12 +275,15 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
           }
           continue;
         }
-        if (isSpecialProp(property, containerType))
+        if (isSpecialProp(property, containerType)) {
           continue;
+        }
         const value = container[property];
         const refId = refs.getId(value);
         if (refId !== void 0) {
-          finalizers.push(() => define(newContainer, property, refs.getMockedValue(refId)));
+          finalizers.push(
+            () => define(newContainer, property, refs.getMockedValue(refId))
+          );
           continue;
         }
         const type = getType(value);
@@ -242,14 +296,20 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
           define(newContainer, property, value);
           continue;
         }
-        if (!define(newContainer, property, isFunction ? value : {}))
+        if (!define(newContainer, property, isFunction ? value : {})) {
           continue;
+        }
         if (isFunction) {
           let mockFunction2 = function() {
             if (this instanceof newContainer[property]) {
-              for (const { key, descriptor: descriptor2 } of getAllMockableProperties(this, false, primitives)) {
-                if (descriptor2.get)
+              for (const { key, descriptor: descriptor2 } of getAllMockableProperties(
+                this,
+                false,
+                primitives
+              )) {
+                if (descriptor2.get) {
                   continue;
+                }
                 const value2 = this[key];
                 const type2 = getType(value2);
                 const isFunction2 = type2.includes("Function") && typeof value2 === "function";
@@ -265,8 +325,11 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
               }
             }
           };
-          if (!this.spyModule)
-            throw this.createError("[vitest] `spyModule` is not defined. This is Vitest error. Please open a new issue with reproduction.");
+          if (!this.spyModule) {
+            throw this.createError(
+              "[vitest] `spyModule` is not defined. This is Vitest error. Please open a new issue with reproduction."
+            );
+          }
           const spyModule = this.spyModule;
           const primitives = this.primitives;
           const mock = spyModule.spyOn(newContainer, property).mockImplementation(mockFunction2);
@@ -283,16 +346,18 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     };
     const mockedObject = mockExports;
     mockPropertiesOf(object, mockedObject);
-    for (const finalizer of finalizers)
+    for (const finalizer of finalizers) {
       finalizer();
+    }
     return mockedObject;
   }
   unmockPath(path) {
     const suitefile = this.getSuiteFilepath();
     const id = this.normalizePath(path);
     const mock = this.mockMap.get(suitefile);
-    if (mock && id in mock)
+    if (mock && id in mock) {
       delete mock[id];
+    }
     this.deleteCachedItem(id);
   }
   mockPath(originalId, path, external, factory) {
@@ -308,21 +373,27 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
   }
   async importActual(rawId, importer, callstack) {
     const { id, fsPath } = await this.resolvePath(rawId, importer);
-    const result = await this.executor.cachedRequest(id, fsPath, callstack || [importer]);
+    const result = await this.executor.cachedRequest(
+      id,
+      fsPath,
+      callstack || [importer]
+    );
     return result;
   }
   async importMock(rawId, importee) {
     const { id, fsPath, external } = await this.resolvePath(rawId, importee);
     const normalizedId = this.normalizePath(fsPath);
     let mock = this.getDependencyMock(normalizedId);
-    if (mock === void 0)
+    if (mock === void 0) {
       mock = this.resolveMockPath(fsPath, external);
+    }
     if (mock === null) {
       const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
       return this.mockObject(mod);
     }
-    if (typeof mock === "function")
+    if (typeof mock === "function") {
       return this.callFunctionMock(fsPath, mock);
+    }
     return this.executor.dependencyRequest(mock, mock, [importee]);
   }
   async requestWithMock(url, callstack) {
@@ -331,8 +402,9 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
     const mockPath = this.getMockPath(id);
     if (mock === null) {
       const cache = this.moduleCache.get(mockPath);
-      if (cache.exports)
+      if (cache.exports) {
         return cache.exports;
+      }
       const exports = {};
       this.moduleCache.set(mockPath, { exports });
       const mod = await this.executor.directRequest(url, url, callstack);
@@ -350,17 +422,30 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
         callstack.splice(indexMock, 1);
       }
     }
-    if (typeof mock === "string" && !callstack.includes(mock))
+    if (typeof mock === "string" && !callstack.includes(mock)) {
       return mock;
+    }
   }
   queueMock(id, importer, factory, throwIfCached = false) {
-    VitestMocker.pendingIds.push({ type: "mock", id, importer, factory, throwIfCached });
+    VitestMocker.pendingIds.push({
+      type: "mock",
+      id,
+      importer,
+      factory,
+      throwIfCached
+    });
   }
   queueUnmock(id, importer, throwIfCached = false) {
-    VitestMocker.pendingIds.push({ type: "unmock", id, importer, throwIfCached });
+    VitestMocker.pendingIds.push({
+      type: "unmock",
+      id,
+      importer,
+      throwIfCached
+    });
   }
 }
 
+const { readFileSync } = fs;
 async function createVitestExecutor(options) {
   const runner = new VitestExecutor(options);
   await runner.executeId("/@vite/env");
@@ -373,20 +458,27 @@ const dispose = [];
 function listenForErrors(state) {
   dispose.forEach((fn) => fn());
   dispose.length = 0;
-  function catchError(err, type) {
+  function catchError(err, type, event) {
     var _a;
     const worker = state();
+    if (worker.current) {
+      const listeners = process.listeners(event);
+      if (listeners.length > 1) {
+        return;
+      }
+    }
     const error = processError(err);
     if (!isPrimitive(error)) {
       error.VITEST_TEST_NAME = (_a = worker.current) == null ? void 0 : _a.name;
-      if (worker.filepath)
+      if (worker.filepath) {
         error.VITEST_TEST_PATH = relative(state().config.root, worker.filepath);
+      }
       error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
     }
     state().rpc.onUnhandledError(error, type);
   }
-  const uncaughtException = (e) => catchError(e, "Uncaught Exception");
-  const unhandledRejection = (e) => catchError(e, "Unhandled Rejection");
+  const uncaughtException = (e) => catchError(e, "Uncaught Exception", "uncaughtException");
+  const unhandledRejection = (e) => catchError(e, "Unhandled Rejection", "unhandledRejection");
   process.on("uncaughtException", uncaughtException);
   process.on("unhandledRejection", unhandledRejection);
   dispose.push(() => {
@@ -395,7 +487,10 @@ function listenForErrors(state) {
   });
 }
 async function startVitestExecutor(options) {
-  const state = () => globalThis.__vitest_worker__ || options.state;
+  const state = () => (
+    // @ts-expect-error injected untyped global
+    globalThis.__vitest_worker__ || options.state
+  );
   const rpc = () => state().rpc;
   process.exit = (code = process.exitCode || 0) => {
     throw new Error(`process.exit unexpectedly called with "${code}"`);
@@ -406,8 +501,9 @@ async function startVitestExecutor(options) {
   };
   return await createVitestExecutor({
     async fetchModule(id) {
-      if (externalizeMap.has(id))
+      if (externalizeMap.has(id)) {
         return { externalize: externalizeMap.get(id) };
+      }
       if (id.includes(distDir)) {
         const { path } = toFilePath(id, state().config.root);
         const externalize = pathToFileURL(path).toString();
@@ -450,8 +546,9 @@ async function startVitestExecutor(options) {
   });
 }
 function updateStyle(id, css) {
-  if (typeof document === "undefined")
+  if (typeof document === "undefined") {
     return;
+  }
   const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
   if (element) {
     element.textContent = css;
@@ -465,15 +562,21 @@ function updateStyle(id, css) {
   head == null ? void 0 : head.appendChild(style);
 }
 function removeStyle(id) {
-  if (typeof document === "undefined")
+  if (typeof document === "undefined") {
     return;
+  }
   const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
-  if (sheet)
+  if (sheet) {
     document.head.removeChild(sheet);
+  }
 }
 function getDefaultRequestStubs(context) {
   if (!context) {
-    const clientStub2 = { ...DEFAULT_REQUEST_STUBS["@vite/client"], updateStyle, removeStyle };
+    const clientStub2 = {
+      ...DEFAULT_REQUEST_STUBS["@vite/client"],
+      updateStyle,
+      removeStyle
+    };
     return {
       "/@vite/client": clientStub2,
       "@vite/client": clientStub2
@@ -505,10 +608,15 @@ class VitestExecutor extends ViteNodeRunner {
       });
       this.primitives = { Object, Reflect, Symbol };
     } else if (options.externalModulesExecutor) {
-      this.primitives = vm.runInContext("({ Object, Reflect, Symbol })", options.context);
+      this.primitives = vm.runInContext(
+        "({ Object, Reflect, Symbol })",
+        options.context
+      );
       this.externalModules = options.externalModulesExecutor;
     } else {
-      throw new Error("When context is provided, externalModulesExecutor must be provided as well.");
+      throw new Error(
+        "When context is provided, externalModulesExecutor must be provided as well."
+      );
     }
   }
   mocker;
@@ -522,8 +630,9 @@ class VitestExecutor extends ViteNodeRunner {
   }
   shouldResolveId(id, _importee) {
     var _a;
-    if (isInternalRequest(id) || id.startsWith("data:"))
+    if (isInternalRequest(id) || id.startsWith("data:")) {
       return false;
+    }
     const transformMode = ((_a = this.state.environment) == null ? void 0 : _a.transformMode) ?? "ssr";
     return transformMode === "ssr" ? !isNodeBuiltin(id) : !id.startsWith("node:");
   }
@@ -531,10 +640,12 @@ class VitestExecutor extends ViteNodeRunner {
     return super.resolveUrl(id, importer);
   }
   async resolveUrl(id, importer) {
-    if (VitestMocker.pendingIds.length)
+    if (VitestMocker.pendingIds.length) {
       await this.mocker.resolveMocks();
-    if (importer && importer.startsWith("mock:"))
+    }
+    if (importer && importer.startsWith("mock:")) {
       importer = importer.slice(5);
+    }
     try {
       return await super.resolveUrl(id, importer);
     } catch (error) {
@@ -542,17 +653,21 @@ class VitestExecutor extends ViteNodeRunner {
         const { id: id2 } = error[Symbol.for("vitest.error.not_found.data")];
         const path = this.mocker.normalizePath(id2);
         const mock = this.mocker.getDependencyMock(path);
-        if (mock !== void 0)
+        if (mock !== void 0) {
           return [id2, id2];
+        }
       }
       throw error;
     }
   }
   async runModule(context, transformed) {
     const vmContext = this.options.context;
-    if (!vmContext || !this.externalModules)
+    if (!vmContext || !this.externalModules) {
       return super.runModule(context, transformed);
-    const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
+    }
+    const codeDefinition = `'use strict';async (${Object.keys(context).join(
+      ","
+    )})=>{{`;
     const code = `${codeDefinition}${transformed}
 }}`;
     const options = {
@@ -568,25 +683,32 @@ class VitestExecutor extends ViteNodeRunner {
     await fn(...Object.values(context));
   }
   async importExternalModule(path) {
-    if (this.externalModules)
+    if (this.externalModules) {
       return this.externalModules.import(path);
+    }
     return super.importExternalModule(path);
   }
   async dependencyRequest(id, fsPath, callstack) {
     const mocked = await this.mocker.requestWithMock(fsPath, callstack);
-    if (typeof mocked === "string")
+    if (typeof mocked === "string") {
       return super.dependencyRequest(mocked, mocked, callstack);
-    if (mocked && typeof mocked === "object")
+    }
+    if (mocked && typeof mocked === "object") {
       return mocked;
+    }
     return super.dependencyRequest(id, fsPath, callstack);
   }
   prepareContext(context) {
     if (this.state.filepath && normalize(this.state.filepath) === normalize(context.__filename)) {
       const globalNamespace = this.options.context || globalThis;
-      Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalNamespace.__vitest_index__ });
+      Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", {
+        // @ts-expect-error injected untyped global
+        get: () => globalNamespace.__vitest_index__
+      });
     }
-    if (this.options.context && this.externalModules)
+    if (this.options.context && this.externalModules) {
       context.require = this.externalModules.createRequire(context.__filename);
+    }
     return context;
   }
 }