vitest 3.1.0-beta.1 → 3.1.0-beta.2

package/dist/chunks/execute.DZKwfrTs.js

@@ -0,0 +1,791 @@
+import fs from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import vm from 'node:vm';
+import { processError } from '@vitest/utils/error';
+import { normalize as normalize$1 } from 'pathe';
+import { ViteNodeRunner, DEFAULT_REQUEST_STUBS } from 'vite-node/client';
+import { isInternalRequest, isNodeBuiltin as isNodeBuiltin$1, isPrimitive, toFilePath } from 'vite-node/utils';
+import { distDir } from '../path.js';
+import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
+import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
+import { builtinModules } from 'node:module';
+import { highlight } from '@vitest/utils';
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) {
+		return input;
+	}
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const normalize = function(path) {
+	if (path.length === 0) {
+		return ".";
+	}
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) {
+			return "/";
+		}
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) {
+		path += "/";
+	}
+	if (_DRIVE_LETTER_RE.test(path)) {
+		path += "/";
+	}
+	if (isUNCPath) {
+		if (!isPathAbsolute) {
+			return `//./${path}`;
+		}
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) {
+			continue;
+		}
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			const both = pathTrailing && segLeading;
+			if (both) {
+				path += seg.slice(1);
+			} else {
+				path += pathTrailing || segLeading ? seg : `/${seg}`;
+			}
+		} else {
+			path += seg;
+		}
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") {
+		return process.cwd().replace(/\\/g, "/");
+	}
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) {
+			continue;
+		}
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+		return `/${resolvedPath}`;
+	}
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) {
+			char = path[index];
+		} else if (char === "/") {
+			break;
+		} else {
+			char = "/";
+		}
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) {
+					res += `/${path.slice(lastSlash + 1, index)}`;
+				} else {
+					res = path.slice(lastSlash + 1, index);
+				}
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) {
+			++dots;
+		} else {
+			dots = -1;
+		}
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+		segments[0] += "/";
+	}
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+
+const { existsSync, readdirSync, statSync } = fs;
+function findMockRedirect(root, mockPath, external) {
+	const path = external || mockPath;
+	if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+		const mockDirname = dirname(path);
+		const mockFolder = join(root, "__mocks__", mockDirname);
+		if (!existsSync(mockFolder)) {
+			return null;
+		}
+		const baseOriginal = basename(path);
+		function findFile(mockFolder, baseOriginal) {
+			const files = readdirSync(mockFolder);
+			for (const file of files) {
+				const baseFile = basename(file, extname(file));
+				if (baseFile === baseOriginal) {
+					const path = resolve(mockFolder, file);
+					if (statSync(path).isFile()) {
+						return path;
+					} else {
+						const indexFile = findFile(path, "index");
+						if (indexFile) {
+							return indexFile;
+						}
+					}
+				}
+			}
+			return null;
+		}
+		return findFile(mockFolder, baseOriginal);
+	}
+	const dir = dirname(path);
+	const baseId = basename(path);
+	const fullPath = resolve(dir, "__mocks__", baseId);
+	return existsSync(fullPath) ? fullPath : null;
+}
+const builtins = new Set([
+	...builtinModules,
+	"assert/strict",
+	"diagnostics_channel",
+	"dns/promises",
+	"fs/promises",
+	"path/posix",
+	"path/win32",
+	"readline/promises",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"timers/promises",
+	"util/types",
+	"wasi"
+]);
+const prefixedBuiltins = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]);
+const NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+	if (prefixedBuiltins.has(id)) {
+		return true;
+	}
+	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(NODE_BUILTIN_NAMESPACE.length) : id);
+}
+
+const spyModulePath = resolve$1(distDir, "spy.js");
+class VitestMocker {
+	static pendingIds = [];
+	spyModule;
+	primitives;
+	filterPublicKeys;
+	registries = new Map();
+	mockContext = { callstack: null };
+	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
+			};
+		}
+		const Symbol = this.primitives.Symbol;
+		this.filterPublicKeys = [
+			"__esModule",
+			Symbol.asyncIterator,
+			Symbol.hasInstance,
+			Symbol.isConcatSpreadable,
+			Symbol.iterator,
+			Symbol.match,
+			Symbol.matchAll,
+			Symbol.replace,
+			Symbol.search,
+			Symbol.split,
+			Symbol.species,
+			Symbol.toPrimitive,
+			Symbol.toStringTag,
+			Symbol.unscopables
+		];
+	}
+	get root() {
+		return this.executor.options.root;
+	}
+	get moduleCache() {
+		return this.executor.moduleCache;
+	}
+	get moduleDirectories() {
+		return this.executor.options.moduleDirectories || [];
+	}
+	async initializeSpyModule() {
+		this.spyModule = await this.executor.executeId(spyModulePath);
+	}
+	getMockerRegistry() {
+		const suite = this.getSuiteFilepath();
+		if (!this.registries.has(suite)) {
+			this.registries.set(suite, new MockerRegistry());
+		}
+		return this.registries.get(suite);
+	}
+	reset() {
+		this.registries.clear();
+	}
+	deleteCachedItem(id) {
+		const mockId = this.getMockPath(id);
+		if (this.moduleCache.has(mockId)) {
+			this.moduleCache.delete(mockId);
+		}
+	}
+	isModuleDirectory(path) {
+		return this.moduleDirectories.some((dir) => path.includes(dir));
+	}
+	getSuiteFilepath() {
+		return this.executor.state.filepath || "global";
+	}
+	createError(message, codeFrame) {
+		const Error = this.primitives.Error;
+		const error = new Error(message);
+		Object.assign(error, { codeFrame });
+		return error;
+	}
+	async resolvePath(rawId, importer) {
+		let id;
+		let fsPath;
+		try {
+			[id, fsPath] = await this.executor.originalResolveUrl(rawId, importer);
+		} catch (error) {
+			if (error.code === "ERR_MODULE_NOT_FOUND") {
+				const { id: unresolvedId } = error[Symbol.for("vitest.error.not_found.data")];
+				id = unresolvedId;
+				fsPath = unresolvedId;
+			} else {
+				throw error;
+			}
+		}
+		const external = !isAbsolute$1(fsPath) || this.isModuleDirectory(fsPath) ? rawId : null;
+		return {
+			id,
+			fsPath,
+			external: external ? this.normalizePath(external) : external
+		};
+	}
+	async resolveMocks() {
+		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.action === "unmock") {
+				this.unmockPath(fsPath);
+			}
+			if (mock.action === "mock") {
+				this.mockPath(mock.id, fsPath, external, mock.type, mock.factory);
+			}
+		}));
+		VitestMocker.pendingIds = [];
+	}
+	async callFunctionMock(dep, mock) {
+		const cached = this.moduleCache.get(dep)?.exports;
+		if (cached) {
+			return cached;
+		}
+		const exports = await mock.resolve();
+		const moduleExports = new Proxy(exports, { get: (target, prop) => {
+			const val = target[prop];
+			if (prop === "then") {
+				if (target instanceof Promise) {
+					return target.then.bind(target);
+				}
+			} else if (!(prop in target)) {
+				if (this.filterPublicKeys.includes(prop)) {
+					return undefined;
+				}
+				throw this.createError(`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. ` + "Did you forget to return it from \"vi.mock\"?" + "\nIf you need to partially mock a module, you can use \"importOriginal\" helper inside:\n", highlight(`vi.mock(import("${mock.raw}"), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    // your mocked methods
+  }
+})`));
+			}
+			return val;
+		} });
+		this.moduleCache.set(dep, { exports: moduleExports });
+		return moduleExports;
+	}
+	getMockContext() {
+		return this.mockContext;
+	}
+	getMockPath(dep) {
+		return `mock:${dep}`;
+	}
+	getDependencyMock(id) {
+		const registry = this.getMockerRegistry();
+		return registry.get(id);
+	}
+	normalizePath(path) {
+		return this.moduleCache.normalizePath(path);
+	}
+	resolveMockPath(mockPath, external) {
+		return findMockRedirect(this.root, mockPath, external);
+	}
+	mockObject(object, mockExports = {}, behavior = "automock") {
+		const spyOn = this.spyModule?.spyOn;
+		if (!spyOn) {
+			throw this.createError("[vitest] `spyModule` is not defined. This is a Vitest error. Please open a new issue with reproduction.");
+		}
+		return mockObject({
+			globalConstructors: this.primitives,
+			spyOn,
+			type: behavior
+		}, object, mockExports);
+	}
+	unmockPath(path) {
+		const registry = this.getMockerRegistry();
+		const id = this.normalizePath(path);
+		registry.delete(id);
+		this.deleteCachedItem(id);
+	}
+	mockPath(originalId, path, external, mockType, factory) {
+		const registry = this.getMockerRegistry();
+		const id = this.normalizePath(path);
+		if (mockType === "manual") {
+			registry.register("manual", originalId, id, factory);
+		} else if (mockType === "autospy") {
+			registry.register("autospy", originalId, id);
+		} else {
+			const redirect = this.resolveMockPath(id, external);
+			if (redirect) {
+				registry.register("redirect", originalId, id, redirect);
+			} else {
+				registry.register("automock", originalId, id);
+			}
+		}
+		this.deleteCachedItem(id);
+	}
+	async importActual(rawId, importer, callstack) {
+		const { id, fsPath } = await this.resolvePath(rawId, 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) {
+			const redirect = this.resolveMockPath(normalizedId, external);
+			if (redirect) {
+				mock = new RedirectedModule(rawId, normalizedId, redirect);
+			} else {
+				mock = new AutomockedModule(rawId, normalizedId);
+			}
+		}
+		if (mock.type === "automock" || mock.type === "autospy") {
+			const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
+			return this.mockObject(mod, {}, mock.type);
+		}
+		if (mock.type === "manual") {
+			return this.callFunctionMock(fsPath, mock);
+		}
+		return this.executor.dependencyRequest(mock.redirect, mock.redirect, [importee]);
+	}
+	async requestWithMock(url, callstack) {
+		const id = this.normalizePath(url);
+		const mock = this.getDependencyMock(id);
+		if (!mock) {
+			return;
+		}
+		const mockPath = this.getMockPath(id);
+		if (mock.type === "automock" || mock.type === "autospy") {
+			const cache = this.moduleCache.get(mockPath);
+			if (cache.exports) {
+				return cache.exports;
+			}
+			const exports = {};
+			this.moduleCache.set(mockPath, { exports });
+			const mod = await this.executor.directRequest(url, url, callstack);
+			this.mockObject(mod, exports, mock.type);
+			return exports;
+		}
+		if (mock.type === "manual" && !callstack.includes(mockPath) && !callstack.includes(url)) {
+			try {
+				callstack.push(mockPath);
+				this.mockContext.callstack = callstack;
+				return await this.callFunctionMock(mockPath, mock);
+			} finally {
+				this.mockContext.callstack = null;
+				const indexMock = callstack.indexOf(mockPath);
+				callstack.splice(indexMock, 1);
+			}
+		} else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) {
+			return mock.redirect;
+		}
+	}
+	queueMock(id, importer, factoryOrOptions) {
+		const mockType = getMockType(factoryOrOptions);
+		VitestMocker.pendingIds.push({
+			action: "mock",
+			id,
+			importer,
+			factory: typeof factoryOrOptions === "function" ? factoryOrOptions : undefined,
+			type: mockType
+		});
+	}
+	queueUnmock(id, importer) {
+		VitestMocker.pendingIds.push({
+			action: "unmock",
+			id,
+			importer
+		});
+	}
+}
+function getMockType(factoryOrOptions) {
+	if (!factoryOrOptions) {
+		return "automock";
+	}
+	if (typeof factoryOrOptions === "function") {
+		return "manual";
+	}
+	return factoryOrOptions.spy ? "autospy" : "automock";
+}
+
+const normalizedDistDir = normalize$1(distDir);
+const { readFileSync } = fs;
+async function createVitestExecutor(options) {
+	const runner = new VitestExecutor(options);
+	await runner.executeId("/@vite/env");
+	await runner.mocker.initializeSpyModule();
+	return runner;
+}
+const externalizeMap = new Map();
+const bareVitestRegexp = /^@?vitest(?:\/|$)/;
+const dispose = [];
+function listenForErrors(state) {
+	dispose.forEach((fn) => fn());
+	dispose.length = 0;
+	function catchError(err, type, event) {
+		const worker = state();
+		if (worker.current?.type === "test") {
+			const listeners = process.listeners(event);
+			if (listeners.length > 1) {
+				return;
+			}
+		}
+		const error = processError(err);
+		if (!isPrimitive(error)) {
+			error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : undefined;
+			if (worker.filepath) {
+				error.VITEST_TEST_PATH = worker.filepath;
+			}
+			error.VITEST_AFTER_ENV_TEARDOWN = worker.environmentTeardownRun;
+		}
+		state().rpc.onUnhandledError(error, type);
+	}
+	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(() => {
+		process.off("uncaughtException", uncaughtException);
+		process.off("unhandledRejection", unhandledRejection);
+	});
+}
+async function startVitestExecutor(options) {
+	const state = () => globalThis.__vitest_worker__ || options.state;
+	const rpc = () => state().rpc;
+	process.exit = (code = process.exitCode || 0) => {
+		throw new Error(`process.exit unexpectedly called with "${code}"`);
+	};
+	listenForErrors(state);
+	const getTransformMode = () => {
+		return state().environment.transformMode ?? "ssr";
+	};
+	return await createVitestExecutor({
+		async fetchModule(id) {
+			if (externalizeMap.has(id)) {
+				return { externalize: externalizeMap.get(id) };
+			}
+			if (id.includes(distDir) || id.includes(normalizedDistDir)) {
+				const { path } = toFilePath(id, state().config.root);
+				const externalize = pathToFileURL(path).toString();
+				externalizeMap.set(id, externalize);
+				return { externalize };
+			}
+			if (bareVitestRegexp.test(id)) {
+				externalizeMap.set(id, id);
+				return { externalize: id };
+			}
+			const result = await rpc().fetch(id, getTransformMode());
+			if (result.id && !result.externalize) {
+				const code = readFileSync(result.id, "utf-8");
+				return { code };
+			}
+			return result;
+		},
+		resolveId(id, importer) {
+			return rpc().resolveId(id, importer, getTransformMode());
+		},
+		get moduleCache() {
+			return state().moduleCache;
+		},
+		get moduleExecutionInfo() {
+			return state().moduleExecutionInfo;
+		},
+		get interopDefault() {
+			return state().config.deps.interopDefault;
+		},
+		get moduleDirectories() {
+			return state().config.deps.moduleDirectories;
+		},
+		get root() {
+			return state().config.root;
+		},
+		get base() {
+			return state().config.base;
+		},
+		...options
+	});
+}
+function updateStyle(id, css) {
+	if (typeof document === "undefined") {
+		return;
+	}
+	const element = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (element) {
+		element.textContent = css;
+		return;
+	}
+	const head = document.querySelector("head");
+	const style = document.createElement("style");
+	style.setAttribute("type", "text/css");
+	style.setAttribute("data-vite-dev-id", id);
+	style.textContent = css;
+	head?.appendChild(style);
+}
+function removeStyle(id) {
+	if (typeof document === "undefined") {
+		return;
+	}
+	const sheet = document.querySelector(`[data-vite-dev-id="${id}"]`);
+	if (sheet) {
+		document.head.removeChild(sheet);
+	}
+}
+function getDefaultRequestStubs(context) {
+	if (!context) {
+		const clientStub = {
+			...DEFAULT_REQUEST_STUBS["@vite/client"],
+			updateStyle,
+			removeStyle
+		};
+		return {
+			"/@vite/client": clientStub,
+			"@vite/client": clientStub
+		};
+	}
+	const clientStub = vm.runInContext(`(defaultClient) => ({ ...defaultClient, updateStyle: ${updateStyle.toString()}, removeStyle: ${removeStyle.toString()} })`, context)(DEFAULT_REQUEST_STUBS["@vite/client"]);
+	return {
+		"/@vite/client": clientStub,
+		"@vite/client": clientStub
+	};
+}
+class VitestExecutor extends ViteNodeRunner {
+	mocker;
+	externalModules;
+	primitives;
+	constructor(options) {
+		super({
+			...options,
+			interopDefault: options.context ? false : options.interopDefault
+		});
+		this.options = options;
+		this.mocker = new VitestMocker(this);
+		if (!options.context) {
+			Object.defineProperty(globalThis, "__vitest_mocker__", {
+				value: this.mocker,
+				writable: true,
+				configurable: true
+			});
+			this.primitives = {
+				Object,
+				Reflect,
+				Symbol
+			};
+		} else if (options.externalModulesExecutor) {
+			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.");
+		}
+	}
+	getContextPrimitives() {
+		return this.primitives;
+	}
+	get state() {
+		return globalThis.__vitest_worker__ || this.options.state;
+	}
+	get moduleExecutionInfo() {
+		return this.options.moduleExecutionInfo;
+	}
+	shouldResolveId(id, _importee) {
+		if (isInternalRequest(id) || id.startsWith("data:")) {
+			return false;
+		}
+		const transformMode = this.state.environment?.transformMode ?? "ssr";
+		return transformMode === "ssr" ? !isNodeBuiltin$1(id) : !id.startsWith("node:");
+	}
+	async originalResolveUrl(id, importer) {
+		return super.resolveUrl(id, importer);
+	}
+	async resolveUrl(id, importer) {
+		if (VitestMocker.pendingIds.length) {
+			await this.mocker.resolveMocks();
+		}
+		if (importer && importer.startsWith("mock:")) {
+			importer = importer.slice(5);
+		}
+		try {
+			return await super.resolveUrl(id, importer);
+		} catch (error) {
+			if (error.code === "ERR_MODULE_NOT_FOUND") {
+				const { id } = error[Symbol.for("vitest.error.not_found.data")];
+				const path = this.mocker.normalizePath(id);
+				const mock = this.mocker.getDependencyMock(path);
+				if (mock !== undefined) {
+					return [id, id];
+				}
+			}
+			throw error;
+		}
+	}
+	async runModule(context, transformed) {
+		const vmContext = this.options.context;
+		if (!vmContext || !this.externalModules) {
+			return super.runModule(context, transformed);
+		}
+		const codeDefinition = `'use strict';async (${Object.keys(context).join(",")})=>{{`;
+		const code = `${codeDefinition}${transformed}\n}}`;
+		const options = {
+			filename: context.__filename,
+			lineOffset: 0,
+			columnOffset: -codeDefinition.length
+		};
+		this.options.moduleExecutionInfo?.set(options.filename, { startOffset: codeDefinition.length });
+		const fn = vm.runInContext(code, vmContext, {
+			...options,
+			importModuleDynamically: this.externalModules.importModuleDynamically
+		});
+		await fn(...Object.values(context));
+	}
+	async importExternalModule(path) {
+		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") {
+			return super.dependencyRequest(mocked, mocked, callstack);
+		}
+		if (mocked && typeof mocked === "object") {
+			return mocked;
+		}
+		return super.dependencyRequest(id, fsPath, callstack);
+	}
+	prepareContext(context) {
+		if (this.state.filepath && normalize$1(this.state.filepath) === normalize$1(context.__filename)) {
+			const globalNamespace = this.options.context || globalThis;
+			Object.defineProperty(context.__vite_ssr_import_meta__, "vitest", { get: () => globalNamespace.__vitest_index__ });
+		}
+		if (this.options.context && this.externalModules) {
+			context.require = this.externalModules.createRequire(context.__filename);
+		}
+		return context;
+	}
+}
+
+export { VitestExecutor as V, getDefaultRequestStubs as g, startVitestExecutor as s };