vitest 0.34.0 → 0.34.2

package/dist/{vendor-execute.9ab1c1a7.js → vendor-execute.4fc8203a.js}

@@ -1,12 +1,12 @@
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import vm from 'node:vm';
 import { ModuleCacheMap, ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
-import { isNodeBuiltin, getCachedData, setCacheData, isInternalRequest, isPrimitive } from 'vite-node/utils';
+import { isNodeBuiltin, isPrimitive, toArray, getCachedData, setCacheData, isInternalRequest } from 'vite-node/utils';
 import { resolve, isAbsolute, dirname, join, basename, extname, normalize, relative } from 'pathe';
 import { processError } from '@vitest/utils/error';
 import { d as distDir } from './vendor-paths.84fc7a99.js';
 import { g as getWorkerState } from './vendor-global.97e4527c.js';
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
 import { getColors, getType } from '@vitest/utils';
 import { b as getAllMockableProperties } from './vendor-base.9c08bbd0.js';
 import { dirname as dirname$1 } from 'node:path';
@@ -334,17 +334,20 @@ ${c.green(`vi.mock("${mockpath}", async () => {
   }
 }
 
-const SyntheticModule = vm.SyntheticModule;
-const SourceTextModule = vm.SourceTextModule;
 const _require = createRequire(import.meta.url);
-const nativeResolve = import.meta.resolve;
-const dataURIRegex = /^data:(?<mime>text\/javascript|application\/json|application\/wasm)(?:;(?<encoding>charset=utf-8|base64))?,(?<code>.*)$/;
-class ExternalModulesExecutor {
+class CommonjsExecutor {
+  context;
+  requireCache = /* @__PURE__ */ new Map();
+  publicRequireCache = this.createProxyCache();
+  moduleCache = /* @__PURE__ */ new Map();
+  builtinCache = /* @__PURE__ */ Object.create(null);
+  extensions = /* @__PURE__ */ Object.create(null);
+  fs;
+  Module;
   constructor(options) {
-    this.options = options;
     this.context = options.context;
+    this.fs = options.fileMap;
     const primitives = vm.runInContext("({ Object, Array, Error })", this.context);
-    this.primitives = primitives;
     const executor = this;
     this.Module = class Module$1 {
       exports;
@@ -360,7 +363,7 @@ class ExternalModulesExecutor {
       constructor(id, parent) {
         this.exports = primitives.Object.create(Object.prototype);
         this.require = Module$1.createRequire(id);
-        this.path = dirname$1(id);
+        this.path = dirname(id);
         this.id = id;
         this.filename = id;
         this.loaded = false;
@@ -370,12 +373,12 @@ class ExternalModulesExecutor {
         const cjsModule = Module$1.wrap(code);
         const script = new vm.Script(cjsModule, {
           filename,
-          importModuleDynamically: executor.importModuleDynamically
+          importModuleDynamically: options.importModuleDynamically
         });
         script.identifier = filename;
         const fn = script.runInContext(executor.context);
-        const __dirname = dirname$1(filename);
-        executor.requireCache[filename] = this;
+        const __dirname = dirname(filename);
+        executor.requireCache.set(filename, this);
         try {
           fn(this.exports, this.require, this, filename, __dirname);
           return this.exports;
@@ -427,121 +430,14 @@ class ExternalModulesExecutor {
     this.extensions[".js"] = this.requireJs;
     this.extensions[".json"] = this.requireJson;
   }
-  requireCache = /* @__PURE__ */ Object.create(null);
-  builtinCache = /* @__PURE__ */ Object.create(null);
-  moduleCache = /* @__PURE__ */ new Map();
-  extensions = /* @__PURE__ */ Object.create(null);
-  esmLinkMap = /* @__PURE__ */ new WeakMap();
-  context;
-  fsCache = /* @__PURE__ */ new Map();
-  fsBufferCache = /* @__PURE__ */ new Map();
-  Module;
-  primitives;
   requireJs = (m, filename) => {
-    const content = this.readFile(filename);
+    const content = this.fs.readFile(filename);
     m._compile(content, filename);
   };
   requireJson = (m, filename) => {
-    const code = this.readFile(filename);
+    const code = this.fs.readFile(filename);
     m.exports = JSON.parse(code);
   };
-  importModuleDynamically = async (specifier, referencer) => {
-    const module = await this.resolveModule(specifier, referencer.identifier);
-    return this.evaluateModule(module);
-  };
-  resolveModule = async (specifier, referencer) => {
-    const identifier = await this.resolveAsync(specifier, referencer);
-    return await this.createModule(identifier);
-  };
-  async resolveAsync(specifier, parent) {
-    return nativeResolve(specifier, parent);
-  }
-  readFile(path) {
-    const cached = this.fsCache.get(path);
-    if (cached)
-      return cached;
-    const source = readFileSync(path, "utf-8");
-    this.fsCache.set(path, source);
-    return source;
-  }
-  readBuffer(path) {
-    const cached = this.fsBufferCache.get(path);
-    if (cached)
-      return cached;
-    const buffer = readFileSync(path);
-    this.fsBufferCache.set(path, buffer);
-    return buffer;
-  }
-  findNearestPackageData(basedir) {
-    var _a;
-    const originalBasedir = basedir;
-    const packageCache = this.options.packageCache;
-    while (basedir) {
-      const cached = getCachedData(packageCache, basedir, originalBasedir);
-      if (cached)
-        return cached;
-      const pkgPath = join(basedir, "package.json");
-      try {
-        if ((_a = statSync(pkgPath, { throwIfNoEntry: false })) == null ? void 0 : _a.isFile()) {
-          const pkgData = JSON.parse(this.readFile(pkgPath));
-          if (packageCache)
-            setCacheData(packageCache, pkgData, basedir, originalBasedir);
-          return pkgData;
-        }
-      } catch {
-      }
-      const nextBasedir = dirname$1(basedir);
-      if (nextBasedir === basedir)
-        break;
-      basedir = nextBasedir;
-    }
-    return null;
-  }
-  wrapSynteticModule(identifier, exports) {
-    const moduleKeys = Object.keys(exports).filter((key) => key !== "default");
-    const m = new SyntheticModule(
-      [...moduleKeys, "default"],
-      () => {
-        for (const key of moduleKeys)
-          m.setExport(key, exports[key]);
-        m.setExport("default", exports);
-      },
-      {
-        context: this.context,
-        identifier
-      }
-    );
-    return m;
-  }
-  async evaluateModule(m) {
-    if (m.status === "unlinked") {
-      this.esmLinkMap.set(
-        m,
-        m.link(
-          (identifier, referencer) => this.resolveModule(identifier, referencer.identifier)
-        )
-      );
-    }
-    await this.esmLinkMap.get(m);
-    if (m.status === "linked")
-      await m.evaluate();
-    return m;
-  }
-  findLongestRegisteredExtension(filename) {
-    const name = basename(filename);
-    let currentExtension;
-    let index;
-    let startIndex = 0;
-    while ((index = name.indexOf(".", startIndex)) !== -1) {
-      startIndex = index + 1;
-      if (index === 0)
-        continue;
-      currentExtension = name.slice(index);
-      if (this.extensions[currentExtension])
-        return currentExtension;
-    }
-    return ".js";
-  }
   createRequire = (filename) => {
     const _require2 = createRequire(filename);
     const require = (id) => {
@@ -549,7 +445,7 @@ class ExternalModulesExecutor {
       const ext = extname(resolved);
       if (ext === ".node" || isNodeBuiltin(resolved))
         return this.requireCoreModule(resolved);
-      const module = this.createCommonJSNodeModule(resolved);
+      const module = new this.Module(resolved);
       return this.loadCommonJSModule(module, resolved);
     };
     require.resolve = _require2.resolve;
@@ -559,16 +455,29 @@ class ExternalModulesExecutor {
       },
       configurable: true
     });
-    require.main = _require2.main;
-    require.cache = this.requireCache;
+    require.main = void 0;
+    require.cache = this.publicRequireCache;
     return require;
   };
-  createCommonJSNodeModule(filename) {
-    return new this.Module(filename);
+  createProxyCache() {
+    return new Proxy(/* @__PURE__ */ Object.create(null), {
+      defineProperty: () => true,
+      deleteProperty: () => true,
+      set: () => true,
+      get: (_, key) => this.requireCache.get(key),
+      has: (_, key) => this.requireCache.has(key),
+      ownKeys: () => Array.from(this.requireCache.keys()),
+      getOwnPropertyDescriptor() {
+        return {
+          configurable: true,
+          enumerable: true
+        };
+      }
+    });
   }
   // very naive implementation for Node.js require
   loadCommonJSModule(module, filename) {
-    const cached = this.requireCache[filename];
+    const cached = this.requireCache.get(filename);
     if (cached)
       return cached.exports;
     const extension = this.findLongestRegisteredExtension(filename);
@@ -576,44 +485,106 @@ class ExternalModulesExecutor {
     loader(module, filename);
     return module.exports;
   }
-  async createEsmModule(fileUrl, code) {
-    const cached = this.moduleCache.get(fileUrl);
-    if (cached)
-      return cached;
-    const [urlPath] = fileUrl.split("?");
-    if (CSS_LANGS_RE.test(urlPath) || KNOWN_ASSET_RE.test(urlPath)) {
-      const path = normalize(urlPath);
-      let name = path.split("/node_modules/").pop() || "";
-      if (name == null ? void 0 : name.startsWith("@"))
-        name = name.split("/").slice(0, 2).join("/");
-      else
-        name = name.split("/")[0];
-      const ext = extname(path);
-      let error = `[vitest] Cannot import ${fileUrl}. At the moment, importing ${ext} files inside external dependencies is not allowed. `;
-      if (name) {
-        const c = getColors();
-        error += `As a temporary workaround you can try to inline the package by updating your config:
+  findLongestRegisteredExtension(filename) {
+    const name = basename(filename);
+    let currentExtension;
+    let index;
+    let startIndex = 0;
+    while ((index = name.indexOf(".", startIndex)) !== -1) {
+      startIndex = index + 1;
+      if (index === 0)
+        continue;
+      currentExtension = name.slice(index);
+      if (this.extensions[currentExtension])
+        return currentExtension;
+    }
+    return ".js";
+  }
+  require(identifier) {
+    const ext = extname(identifier);
+    if (ext === ".node" || isNodeBuiltin(identifier))
+      return this.requireCoreModule(identifier);
+    const module = new this.Module(identifier);
+    return this.loadCommonJSModule(module, identifier);
+  }
+  requireCoreModule(identifier) {
+    const normalized = identifier.replace(/^node:/, "");
+    if (this.builtinCache[normalized])
+      return this.builtinCache[normalized].exports;
+    const moduleExports = _require(identifier);
+    if (identifier === "node:module" || identifier === "module") {
+      const module = new this.Module("/module.js");
+      module.exports = this.Module;
+      this.builtinCache[normalized] = module;
+      return module.exports;
+    }
+    this.builtinCache[normalized] = _require.cache[normalized];
+    return moduleExports;
+  }
+}
 
-${c.gray(c.dim("// vitest.config.js"))}
-${c.green(`export default {
-  test: {
-    deps: {
-      optimizer: {
-        web: {
-          include: [
-            ${c.yellow(c.bold(`"${name}"`))}
-          ]
+function interopCommonJsModule(interopDefault, mod) {
+  if (isPrimitive(mod) || Array.isArray(mod) || mod instanceof Promise) {
+    return {
+      keys: [],
+      moduleExports: {},
+      defaultExport: mod
+    };
+  }
+  if (interopDefault !== false && "__esModule" in mod && !isPrimitive(mod.default)) {
+    const defaultKets = Object.keys(mod.default);
+    const moduleKeys = Object.keys(mod);
+    const allKeys = /* @__PURE__ */ new Set([...defaultKets, ...moduleKeys]);
+    allKeys.delete("default");
+    return {
+      keys: Array.from(allKeys),
+      moduleExports: new Proxy(mod, {
+        get(mod2, prop) {
+          var _a;
+          return mod2[prop] ?? ((_a = mod2.default) == null ? void 0 : _a[prop]);
         }
-      }
-    }
+      }),
+      defaultExport: mod
+    };
   }
+  return {
+    keys: Object.keys(mod).filter((key) => key !== "default"),
+    moduleExports: mod,
+    defaultExport: mod
+  };
 }
-`)}`;
-      }
-      throw new this.primitives.Error(error);
+const SyntheticModule$1 = vm.SyntheticModule;
+const SourceTextModule = vm.SourceTextModule;
+
+const dataURIRegex = /^data:(?<mime>text\/javascript|application\/json|application\/wasm)(?:;(?<encoding>charset=utf-8|base64))?,(?<code>.*)$/;
+class EsmExecutor {
+  constructor(executor, options) {
+    this.executor = executor;
+    this.context = options.context;
+  }
+  moduleCache = /* @__PURE__ */ new Map();
+  esmLinkMap = /* @__PURE__ */ new WeakMap();
+  context;
+  async evaluateModule(m) {
+    if (m.status === "unlinked") {
+      this.esmLinkMap.set(
+        m,
+        m.link(
+          (identifier, referencer) => this.executor.resolveModule(identifier, referencer.identifier)
+        )
+      );
     }
+    await this.esmLinkMap.get(m);
+    if (m.status === "linked")
+      await m.evaluate();
+    return m;
+  }
+  async createEsModule(fileUrl, code) {
+    const cached = this.moduleCache.get(fileUrl);
+    if (cached)
+      return cached;
     if (fileUrl.endsWith(".json")) {
-      const m2 = new SyntheticModule(
+      const m2 = new SyntheticModule$1(
         ["default"],
         () => {
           const result = JSON.parse(code);
@@ -628,11 +599,11 @@ ${c.green(`export default {
       {
         identifier: fileUrl,
         context: this.context,
-        importModuleDynamically: this.importModuleDynamically,
+        importModuleDynamically: this.executor.importModuleDynamically,
         initializeImportMeta: (meta, mod) => {
           meta.url = mod.identifier;
           meta.resolve = (specifier, importer) => {
-            return nativeResolve(specifier, importer ?? mod.identifier);
+            return this.executor.resolve(specifier, importer ?? mod.identifier);
           };
         }
       }
@@ -640,20 +611,6 @@ ${c.green(`export default {
     this.moduleCache.set(fileUrl, m);
     return m;
   }
-  requireCoreModule(identifier) {
-    const normalized = identifier.replace(/^node:/, "");
-    if (this.builtinCache[normalized])
-      return this.builtinCache[normalized].exports;
-    const moduleExports = _require(identifier);
-    if (identifier === "node:module" || identifier === "module") {
-      const module = new this.Module("/module.js");
-      module.exports = this.Module;
-      this.builtinCache[normalized] = module;
-      return module.exports;
-    }
-    this.builtinCache[normalized] = _require.cache[normalized];
-    return moduleExports;
-  }
   async loadWebAssemblyModule(source, identifier) {
     const cached = this.moduleCache.get(identifier);
     if (cached)
@@ -664,14 +621,14 @@ ${c.green(`export default {
     const moduleLookup = {};
     for (const { module } of imports) {
       if (moduleLookup[module] === void 0) {
-        const resolvedModule = await this.resolveModule(
+        const resolvedModule = await this.executor.resolveModule(
           module,
           identifier
         );
         moduleLookup[module] = await this.evaluateModule(resolvedModule);
       }
     }
-    const syntheticModule = new SyntheticModule(
+    const syntheticModule = new SyntheticModule$1(
       exports.map(({ name }) => name),
       () => {
         const importsObject = {};
@@ -691,11 +648,16 @@ ${c.green(`export default {
     );
     return syntheticModule;
   }
+  cacheModule(identifier, module) {
+    this.moduleCache.set(identifier, module);
+  }
+  resolveCachedModule(identifier) {
+    return this.moduleCache.get(identifier);
+  }
   async createDataModule(identifier) {
     const cached = this.moduleCache.get(identifier);
     if (cached)
       return cached;
-    const Error = this.primitives.Error;
     const match = identifier.match(dataURIRegex);
     if (!match || !match.groups)
       throw new Error("Invalid data URI");
@@ -721,7 +683,7 @@ ${c.green(`export default {
     else
       throw new Error(`Invalid data URI encoding: ${encoding}`);
     if (mime === "application/json") {
-      const module = new SyntheticModule(
+      const module = new SyntheticModule$1(
         ["default"],
         () => {
           const obj = JSON.parse(code);
@@ -732,38 +694,269 @@ ${c.green(`export default {
       this.moduleCache.set(identifier, module);
       return module;
     }
-    return this.createEsmModule(identifier, code);
+    return this.createEsModule(identifier, code);
   }
-  async createModule(identifier) {
+}
+
+const CLIENT_ID = "/@vite/client";
+const CLIENT_FILE = pathToFileURL(CLIENT_ID).href;
+class ViteExecutor {
+  constructor(options) {
+    this.options = options;
+    this.esm = options.esmExecutor;
+  }
+  esm;
+  resolve = (identifier, parent) => {
+    if (identifier === CLIENT_ID) {
+      if (this.workerState.environment.transformMode === "web")
+        return identifier;
+      const packageName = this.getPackageName(parent);
+      throw new Error(
+        `[vitest] Vitest cannot handle ${CLIENT_ID} imported in ${parent} when running in SSR environment. Add "${packageName}" to "ssr.noExternal" if you are using Vite SSR, or to "server.deps.inline" if you are using Vite Node.`
+      );
+    }
+  };
+  get workerState() {
+    return this.options.context.__vitest_worker__;
+  }
+  getPackageName(modulePath) {
+    const path = normalize(modulePath);
+    let name = path.split("/node_modules/").pop() || "";
+    if (name == null ? void 0 : name.startsWith("@"))
+      name = name.split("/").slice(0, 2).join("/");
+    else
+      name = name.split("/")[0];
+    return name;
+  }
+  async createViteModule(fileUrl) {
+    if (fileUrl === CLIENT_FILE)
+      return this.createViteClientModule();
+    const cached = this.esm.resolveCachedModule(fileUrl);
+    if (cached)
+      return cached;
+    const result = await this.options.transform(fileUrl, "web");
+    if (!result.code)
+      throw new Error(`[vitest] Failed to transform ${fileUrl}. Does the file exists?`);
+    return this.esm.createEsModule(fileUrl, result.code);
+  }
+  createViteClientModule() {
+    const identifier = CLIENT_ID;
+    const cached = this.esm.resolveCachedModule(identifier);
+    if (cached)
+      return cached;
+    const stub = this.options.viteClientModule;
+    const moduleKeys = Object.keys(stub);
+    const module = new SyntheticModule$1(
+      moduleKeys,
+      () => {
+        moduleKeys.forEach((key) => {
+          module.setExport(key, stub[key]);
+        });
+      },
+      { context: this.options.context, identifier }
+    );
+    this.esm.cacheModule(identifier, module);
+    return module;
+  }
+  canResolve = (fileUrl) => {
+    var _a;
+    const transformMode = this.workerState.environment.transformMode;
+    if (transformMode !== "web")
+      return false;
+    if (fileUrl === CLIENT_FILE)
+      return true;
+    const config = ((_a = this.workerState.config.deps) == null ? void 0 : _a.web) || {};
+    const [modulePath] = fileUrl.split("?");
+    if (config.transformCss && CSS_LANGS_RE.test(modulePath))
+      return true;
+    if (config.transformAssets && KNOWN_ASSET_RE.test(modulePath))
+      return true;
+    if (toArray(config.transformGlobPattern).some((pattern) => pattern.test(modulePath)))
+      return true;
+    return false;
+  };
+}
+
+const SyntheticModule = vm.SyntheticModule;
+const nativeResolve = import.meta.resolve;
+class ExternalModulesExecutor {
+  constructor(options) {
+    this.options = options;
+    this.context = options.context;
+    this.fs = options.fileMap;
+    this.esm = new EsmExecutor(this, {
+      context: this.context
+    });
+    this.cjs = new CommonjsExecutor({
+      context: this.context,
+      importModuleDynamically: this.importModuleDynamically,
+      fileMap: options.fileMap
+    });
+    this.vite = new ViteExecutor({
+      esmExecutor: this.esm,
+      context: this.context,
+      transform: options.transform,
+      viteClientModule: options.requestStubs["/@vite/client"]
+    });
+    this.resolvers = [this.vite.resolve];
+  }
+  cjs;
+  esm;
+  vite;
+  context;
+  fs;
+  resolvers = [];
+  // dynamic import can be used in both ESM and CJS, so we have it in the executor
+  importModuleDynamically = async (specifier, referencer) => {
+    const module = await this.resolveModule(specifier, referencer.identifier);
+    return this.esm.evaluateModule(module);
+  };
+  resolveModule = async (specifier, referencer) => {
+    const identifier = await this.resolve(specifier, referencer);
+    return await this.createModule(identifier);
+  };
+  async resolve(specifier, parent) {
+    for (const resolver of this.resolvers) {
+      const id = resolver(specifier, parent);
+      if (id)
+        return id;
+    }
+    return nativeResolve(specifier, parent);
+  }
+  findNearestPackageData(basedir) {
+    var _a;
+    const originalBasedir = basedir;
+    const packageCache = this.options.packageCache;
+    while (basedir) {
+      const cached = getCachedData(packageCache, basedir, originalBasedir);
+      if (cached)
+        return cached;
+      const pkgPath = join(basedir, "package.json");
+      try {
+        if ((_a = statSync(pkgPath, { throwIfNoEntry: false })) == null ? void 0 : _a.isFile()) {
+          const pkgData = JSON.parse(this.fs.readFile(pkgPath));
+          if (packageCache)
+            setCacheData(packageCache, pkgData, basedir, originalBasedir);
+          return pkgData;
+        }
+      } catch {
+      }
+      const nextBasedir = dirname$1(basedir);
+      if (nextBasedir === basedir)
+        break;
+      basedir = nextBasedir;
+    }
+    return {};
+  }
+  wrapCoreSynteticModule(identifier, exports) {
+    const moduleKeys = Object.keys(exports);
+    const m = new SyntheticModule(
+      [...moduleKeys, "default"],
+      () => {
+        for (const key of moduleKeys)
+          m.setExport(key, exports[key]);
+        m.setExport("default", exports);
+      },
+      {
+        context: this.context,
+        identifier
+      }
+    );
+    return m;
+  }
+  wrapCommonJsSynteticModule(identifier, exports) {
+    const { keys, moduleExports, defaultExport } = interopCommonJsModule(this.options.interopDefault, exports);
+    const m = new SyntheticModule(
+      [...keys, "default"],
+      () => {
+        for (const key of keys)
+          m.setExport(key, moduleExports[key]);
+        m.setExport("default", defaultExport);
+      },
+      {
+        context: this.context,
+        identifier
+      }
+    );
+    return m;
+  }
+  getModuleInformation(identifier) {
     if (identifier.startsWith("data:"))
-      return this.createDataModule(identifier);
+      return { type: "data", url: identifier, path: identifier };
     const extension = extname(identifier);
-    if (extension === ".node" || isNodeBuiltin(identifier)) {
-      const exports2 = this.requireCoreModule(identifier);
-      return this.wrapSynteticModule(identifier, exports2);
-    }
+    if (extension === ".node" || isNodeBuiltin(identifier))
+      return { type: "builtin", url: identifier, path: identifier };
     const isFileUrl = identifier.startsWith("file://");
-    const fileUrl = isFileUrl ? identifier : pathToFileURL(identifier).toString();
     const pathUrl = isFileUrl ? fileURLToPath(identifier.split("?")[0]) : identifier;
-    if (extension === ".cjs") {
-      const module2 = this.createCommonJSNodeModule(pathUrl);
-      const exports2 = this.loadCommonJSModule(module2, pathUrl);
-      return this.wrapSynteticModule(fileUrl, exports2);
+    const fileUrl = isFileUrl ? identifier : pathToFileURL(pathUrl).toString();
+    let type;
+    if (this.vite.canResolve(fileUrl)) {
+      type = "vite";
+    } else if (extension === ".mjs") {
+      type = "module";
+    } else if (extension === ".cjs") {
+      type = "commonjs";
+    } else {
+      const pkgData = this.findNearestPackageData(normalize(pathUrl));
+      type = pkgData.type === "module" ? "module" : "commonjs";
+    }
+    return { type, path: pathUrl, url: fileUrl };
+  }
+  async createModule(identifier) {
+    const { type, url, path } = this.getModuleInformation(identifier);
+    switch (type) {
+      case "data":
+        return this.esm.createDataModule(identifier);
+      case "builtin": {
+        const exports = this.require(identifier);
+        return this.wrapCoreSynteticModule(identifier, exports);
+      }
+      case "vite":
+        return await this.vite.createViteModule(url);
+      case "module":
+        return await this.esm.createEsModule(url, this.fs.readFile(path));
+      case "commonjs": {
+        const exports = this.require(path);
+        return this.wrapCommonJsSynteticModule(identifier, exports);
+      }
+      default: {
+        const _deadend = type;
+        return _deadend;
+      }
     }
-    if (extension === ".mjs")
-      return await this.createEsmModule(fileUrl, this.readFile(pathUrl));
-    const pkgData = this.findNearestPackageData(normalize(pathUrl));
-    if (pkgData.type === "module")
-      return await this.createEsmModule(fileUrl, this.readFile(pathUrl));
-    const module = this.createCommonJSNodeModule(pathUrl);
-    const exports = this.loadCommonJSModule(module, pathUrl);
-    return this.wrapSynteticModule(fileUrl, exports);
   }
   async import(identifier) {
     const module = await this.createModule(identifier);
-    await this.evaluateModule(module);
+    await this.esm.evaluateModule(module);
     return module.namespace;
   }
+  require(identifier) {
+    return this.cjs.require(identifier);
+  }
+  createRequire(identifier) {
+    return this.cjs.createRequire(identifier);
+  }
+}
+
+class FileMap {
+  fsCache = /* @__PURE__ */ new Map();
+  fsBufferCache = /* @__PURE__ */ new Map();
+  readFile(path) {
+    const cached = this.fsCache.get(path);
+    if (cached)
+      return cached;
+    const source = readFileSync(path, "utf-8");
+    this.fsCache.set(path, source);
+    return source;
+  }
+  readBuffer(path) {
+    const cached = this.fsBufferCache.get(path);
+    if (cached)
+      return cached;
+    const buffer = readFileSync(path);
+    this.fsBufferCache.set(path, buffer);
+    return buffer;
+  }
 }
 
 const entryUrl = pathToFileURL(resolve(distDir, "entry.js")).href;
@@ -777,6 +970,7 @@ let _viteNode;
 const packageCache = /* @__PURE__ */ new Map();
 const moduleCache = new ModuleCacheMap();
 const mockMap = /* @__PURE__ */ new Map();
+const fileMap = new FileMap();
 async function startViteNode(options) {
   if (_viteNode)
     return _viteNode;
@@ -818,6 +1012,9 @@ async function startVitestExecutor(options) {
     resolveId(id, importer) {
       return rpc().resolveId(id, importer, getTransformMode());
     },
+    transform(id) {
+      return rpc().transform(id, "web");
+    },
     packageCache,
     moduleCache,
     mockMap,
@@ -860,7 +1057,11 @@ function removeStyle(id) {
 }
 class VitestExecutor extends ViteNodeRunner {
   constructor(options) {
-    super(options);
+    super({
+      ...options,
+      // interop is done inside the external executor instead
+      interopDefault: options.context ? false : options.interopDefault
+    });
     this.options = options;
     this.mocker = new VitestMocker(this);
     if (!options.context) {
@@ -880,10 +1081,6 @@ class VitestExecutor extends ViteNodeRunner {
         Symbol
       };
     } else {
-      this.externalModules = new ExternalModulesExecutor({
-        context: options.context,
-        packageCache: options.packageCache
-      });
       const clientStub = vm.runInContext(
         `(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`,
         options.context
@@ -893,6 +1090,12 @@ class VitestExecutor extends ViteNodeRunner {
         "@vite/client": clientStub
       };
       this.primitives = vm.runInContext("({ Object, Reflect, Symbol })", options.context);
+      this.externalModules = new ExternalModulesExecutor({
+        ...options,
+        fileMap,
+        context: options.context,
+        packageCache: options.packageCache
+      });
     }
   }
   mocker;