vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/chunks/startModuleRunner.oAuCu1yL.js

@@ -0,0 +1,682 @@
+import fs from 'node:fs';
+import nodeModule, { isBuiltin } from 'node:module';
+import { isBareImport } from '@vitest/utils/helpers';
+import { pathToFileURL } from 'node:url';
+import { normalize as normalize$1, join as join$1 } from 'pathe';
+import { distDir } from '../path.js';
+import { serializeValue } from '@vitest/utils/serialize';
+import { VitestModuleEvaluator, unwrapId } from '../module-evaluator.js';
+import { resolve as resolve$1, isAbsolute as isAbsolute$1 } from 'node:path';
+import vm from 'node:vm';
+import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '@vitest/mocker';
+import * as viteModuleRunner from 'vite/module-runner';
+
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	return input && input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/, _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/, _DRIVE_LETTER_RE = /^[A-Za-z]:$/, _EXTNAME_RE = /.(\.[^./]+|\.)$/, normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX), isPathAbsolute = isAbsolute(path), trailingSeparator = path[path.length - 1] === "/";
+	if (path = normalizeString(path, !isPathAbsolute), path.length === 0) return isPathAbsolute ? "/" : trailingSeparator ? "./" : ".";
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	return isUNCPath ? isPathAbsolute ? `//${path}` : `//./${path}` : isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+}, join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/", segLeading = seg[0] === "/", both = pathTrailing && segLeading;
+			if (both) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd$1() {
+	return typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd().replace(/\\/g, "/") : "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "", resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd$1();
+		!path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path));
+	}
+	return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, 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);
+}, extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+}, 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) ? "/" : ".");
+}, 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;
+	// it's a node_module alias
+	// all mocks should be inside <root>/__mocks__
+	if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
+		const mockDirname = dirname(path), 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 the same name, return the file
+					if (statSync(path).isFile()) return path;
+					{
+						// find folder/index.{js,ts}
+						const indexFile = findFile(path, "index");
+						if (indexFile) return indexFile;
+					}
+				}
+			}
+			return null;
+		}
+		return findFile(mockFolder, baseOriginal);
+	}
+	const dir = dirname(path), baseId = basename(path), fullPath = resolve(dir, "__mocks__", baseId);
+	return existsSync(fullPath) ? fullPath : null;
+}
+const builtins = new Set([
+	...nodeModule.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"
+]), prefixedBuiltins$1 = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]), NODE_BUILTIN_NAMESPACE = "node:";
+function isNodeBuiltin(id) {
+	return nodeModule.isBuiltin ? nodeModule.isBuiltin(id) : prefixedBuiltins$1.has(id) ? true : builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
+}
+
+const spyModulePath = resolve$1(distDir, "spy.js");
+class VitestMocker {
+	static pendingIds = [];
+	spyModule;
+	primitives;
+	filterPublicKeys;
+	registries = /* @__PURE__ */ new Map();
+	mockContext = { callstack: null };
+	constructor(moduleRunner, options) {
+		this.moduleRunner = moduleRunner, this.options = options;
+		const context = this.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 (options.spyModule) this.spyModule = options.spyModule;
+		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.options.root;
+	}
+	get evaluatedModules() {
+		return this.moduleRunner.evaluatedModules;
+	}
+	get moduleDirectories() {
+		return this.options.moduleDirectories || [];
+	}
+	async initializeSpyModule() {
+		this.spyModule ||= await this.moduleRunner.import(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();
+	}
+	invalidateModuleById(id) {
+		const mockId = this.getMockPath(id), node = this.evaluatedModules.getModuleById(mockId);
+		if (node) this.evaluatedModules.invalidateModule(node), node.mockedExports = void 0;
+	}
+	isModuleDirectory(path) {
+		return this.moduleDirectories.some((dir) => path.includes(dir));
+	}
+	getSuiteFilepath() {
+		return this.options.getCurrentTestFilepath() || "global";
+	}
+	createError(message, codeFrame) {
+		const Error = this.primitives.Error, error = new Error(message);
+		return Object.assign(error, { codeFrame }), error;
+	}
+	async resolveId(rawId, importer) {
+		const result = await this.options.resolveId(rawId, importer);
+		if (!result) {
+			const id = normalizeModuleId(rawId);
+			return {
+				id,
+				url: rawId,
+				external: id
+			};
+		}
+		// external is node_module or unresolved module
+		// for example, some people mock "vscode" and don't have it installed
+		const external = !isAbsolute$1(result.file) || this.isModuleDirectory(result.file) ? normalizeModuleId(rawId) : null;
+		return {
+			...result,
+			id: normalizeModuleId(result.id),
+			external
+		};
+	}
+	async resolveMocks() {
+		VitestMocker.pendingIds.length && (await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
+			const { id, url, external } = await this.resolveId(mock.id, mock.importer);
+			if (mock.action === "unmock") this.unmockPath(id);
+			if (mock.action === "mock") this.mockPath(mock.id, id, url, external, mock.type, mock.factory);
+		})), VitestMocker.pendingIds = []);
+	}
+	ensureModule(id, url) {
+		const node = this.evaluatedModules.ensureModule(id, url);
+		return node.meta = {
+			id,
+			url,
+			code: "",
+			file: null,
+			invalidate: false
+		}, node;
+	}
+	async callFunctionMock(id, url, mock) {
+		const node = this.ensureModule(id, url);
+		if (node.exports) return node.exports;
+		const exports = await mock.resolve(), moduleExports = new Proxy(exports, { get: (target, prop) => {
+			const val = target[prop];
+			// 'then' can exist on non-Promise objects, need nested instanceof check for logic to work
+			if (prop === "then") {
+				if (target instanceof Promise) return target.then.bind(target);
+			} else if (!(prop in target)) {
+				if (this.filterPublicKeys.includes(prop)) return void 0;
+				throw this.createError(`[vitest] No "${String(prop)}" export is defined on the "${mock.raw}" mock. Did you forget to return it from "vi.mock"?
+If you need to partially mock a module, you can use "importOriginal" helper inside:
+`, `vi.mock(import("${mock.raw}"), async (importOriginal) => {
+  const actual = await importOriginal()
+  return {
+    ...actual,
+    // your mocked methods
+  }
+})`);
+			}
+			return val;
+		} });
+		return node.exports = moduleExports, moduleExports;
+	}
+	// public method to avoid circular dependency
+	getMockContext() {
+		return this.mockContext;
+	}
+	// path used to store mocked dependencies
+	getMockPath(dep) {
+		return `mock:${dep}`;
+	}
+	getDependencyMock(id) {
+		const registry = this.getMockerRegistry();
+		return registry.getById(fixLeadingSlashes(id));
+	}
+	findMockRedirect(mockPath, external) {
+		return findMockRedirect(this.root, mockPath, external);
+	}
+	mockObject(object, mockExports = {}, behavior = "automock") {
+		const createMockInstance = this.spyModule?.createMockInstance;
+		if (!createMockInstance) 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,
+			createMockInstance,
+			type: behavior
+		}, object, mockExports);
+	}
+	unmockPath(id) {
+		const registry = this.getMockerRegistry();
+		registry.deleteById(id), this.invalidateModuleById(id);
+	}
+	mockPath(originalId, id, url, external, mockType, factory) {
+		const registry = this.getMockerRegistry();
+		if (mockType === "manual") registry.register("manual", originalId, id, url, factory);
+		else if (mockType === "autospy") registry.register("autospy", originalId, id, url);
+		else {
+			const redirect = this.findMockRedirect(id, external);
+			if (redirect) registry.register("redirect", originalId, id, url, redirect);
+			else registry.register("automock", originalId, id, url);
+		}
+		// every time the mock is registered, we remove the previous one from the cache
+		this.invalidateModuleById(id);
+	}
+	async importActual(rawId, importer, callstack) {
+		const { url } = await this.resolveId(rawId, importer), node = await this.moduleRunner.fetchModule(url, importer), result = await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
+		return result;
+	}
+	async importMock(rawId, importer) {
+		const { id, url, external } = await this.resolveId(rawId, importer);
+		let mock = this.getDependencyMock(id);
+		if (!mock) {
+			const redirect = this.findMockRedirect(id, external);
+			if (redirect) mock = new RedirectedModule(rawId, id, rawId, redirect);
+			else mock = new AutomockedModule(rawId, id, rawId);
+		}
+		if (mock.type === "automock" || mock.type === "autospy") {
+			const node = await this.moduleRunner.fetchModule(url, importer), mod = await this.moduleRunner.cachedRequest(url, node, [importer], void 0, true), Object = this.primitives.Object;
+			return this.mockObject(mod, Object.create(Object.prototype), mock.type);
+		}
+		if (mock.type === "manual") return this.callFunctionMock(id, url, mock);
+		const node = await this.moduleRunner.fetchModule(mock.redirect);
+		return this.moduleRunner.cachedRequest(mock.redirect, node, [importer], void 0, true);
+	}
+	async requestWithMockedModule(url, evaluatedNode, callstack, mock) {
+		const mockId = this.getMockPath(evaluatedNode.id);
+		if (mock.type === "automock" || mock.type === "autospy") {
+			const cache = this.evaluatedModules.getModuleById(mockId);
+			if (cache && cache.mockedExports) return cache.mockedExports;
+			const Object = this.primitives.Object, exports = Object.create(null);
+			Object.defineProperty(exports, Symbol.toStringTag, {
+				value: "Module",
+				configurable: true,
+				writable: true
+			});
+			const node = this.ensureModule(mockId, this.getMockPath(evaluatedNode.url));
+			node.meta = evaluatedNode.meta, node.file = evaluatedNode.file, node.mockedExports = exports;
+			const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
+			return this.mockObject(mod, exports, mock.type), exports;
+		}
+		if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url)) try {
+			return callstack.push(mockId), this.mockContext.callstack = callstack, await this.callFunctionMock(mockId, this.getMockPath(url), mock);
+		} finally {
+			this.mockContext.callstack = null;
+			const indexMock = callstack.indexOf(mockId);
+			callstack.splice(indexMock, 1);
+		}
+		else if (mock.type === "redirect" && !callstack.includes(mock.redirect)) return mock.redirect;
+	}
+	async mockedRequest(url, evaluatedNode, callstack) {
+		const mock = this.getDependencyMock(evaluatedNode.id);
+		if (mock) return this.requestWithMockedModule(url, evaluatedNode, callstack, mock);
+	}
+	queueMock(id, importer, factoryOrOptions) {
+		const mockType = getMockType(factoryOrOptions);
+		VitestMocker.pendingIds.push({
+			action: "mock",
+			id,
+			importer,
+			factory: typeof factoryOrOptions === "function" ? factoryOrOptions : void 0,
+			type: mockType
+		});
+	}
+	queueUnmock(id, importer) {
+		VitestMocker.pendingIds.push({
+			action: "unmock",
+			id,
+			importer
+		});
+	}
+}
+function getMockType(factoryOrOptions) {
+	return factoryOrOptions ? typeof factoryOrOptions === "function" ? "manual" : factoryOrOptions.spy ? "autospy" : "automock" : "automock";
+}
+// unique id that is not available as "$bare_import" like "test"
+// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
+const prefixedBuiltins = new Set([
+	"node:sea",
+	"node:sqlite",
+	"node:test",
+	"node:test/reporters"
+]), isWindows$1 = process.platform === "win32";
+// transform file url to id
+// virtual:custom -> virtual:custom
+// \0custom -> \0custom
+// /root/id -> /id
+// /root/id.js -> /id.js
+// C:/root/id.js -> /id.js
+// C:\root\id.js -> /id.js
+// TODO: expose this in vite/module-runner
+function normalizeModuleId(file) {
+	if (prefixedBuiltins.has(file)) return file;
+	// unix style, but Windows path still starts with the drive letter to check the root
+	const unixFile = slash(file).replace(/^\/@fs\//, isWindows$1 ? "" : "/").replace(/^node:/, "").replace(/^\/+/, "/");
+	// if it's not in the root, keep it as a path, not a URL
+	return unixFile.replace(/^file:\//, "/");
+}
+const windowsSlashRE = /\\/g;
+function slash(p) {
+	return p.replace(windowsSlashRE, "/");
+}
+const multipleSlashRe = /^\/+/;
+// module-runner incorrectly replaces file:///path with `///path`
+function fixLeadingSlashes(id) {
+	return id.startsWith("//") ? id.replace(multipleSlashRe, "/") : id;
+}
+
+class VitestTransport {
+	constructor(options) {
+		this.options = options;
+	}
+	async invoke(event) {
+		if (event.type !== "custom") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support Vite HMR events.`) };
+		if (event.event !== "vite:invoke") return { error: /* @__PURE__ */ new Error(`Vitest Module Runner doesn't support ${event.event} event.`) };
+		const { name, data } = event.data;
+		if (name !== "fetchModule") return { error: /* @__PURE__ */ new Error(`Unknown method: ${name}. Expected "fetchModule".`) };
+		try {
+			const result = await this.options.fetchModule(...data);
+			return { result };
+		} catch (error) {
+			return { error };
+		}
+	}
+}
+
+// eslint-disable-next-line ts/ban-ts-comment
+// @ts-ignore
+const createNodeImportMeta = viteModuleRunner.createNodeImportMeta;
+// @ts-expect-error overriding private method
+class VitestModuleRunner extends viteModuleRunner.ModuleRunner {
+	mocker;
+	moduleExecutionInfo;
+	constructor(vitestOptions) {
+		const options = vitestOptions, transport = new VitestTransport(options.transport), evaluatedModules = options.evaluatedModules;
+		if (super({
+			transport,
+			hmr: false,
+			evaluatedModules,
+			sourcemapInterceptor: "prepareStackTrace",
+			createImportMeta: vitestOptions.createImportMeta
+		}, options.evaluator), this.vitestOptions = vitestOptions, this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo, this.mocker = options.mocker || new VitestMocker(this, {
+			spyModule: options.spyModule,
+			context: options.vm?.context,
+			resolveId: options.transport.resolveId,
+			get root() {
+				return options.getWorkerState().config.root;
+			},
+			get moduleDirectories() {
+				return options.getWorkerState().config.deps.moduleDirectories || [];
+			},
+			getCurrentTestFilepath() {
+				return options.getWorkerState().filepath;
+			}
+		}), options.vm) options.vm.context.__vitest_mocker__ = this.mocker;
+		else Object.defineProperty(globalThis, "__vitest_mocker__", {
+			configurable: true,
+			writable: true,
+			value: this.mocker
+		});
+	}
+	async import(rawId) {
+		const resolved = await this.vitestOptions.transport.resolveId(rawId);
+		return resolved ? super.import(resolved.url) : super.import(rawId);
+	}
+	async fetchModule(url, importer) {
+		const module = await this.cachedModule(url, importer);
+		return module;
+	}
+	_cachedRequest(url, module, callstack = [], metadata) {
+		// @ts-expect-error "cachedRequest" is private
+		return super.cachedRequest(url, module, callstack, metadata);
+	}
+	/**
+	* @internal
+	*/
+	async cachedRequest(url, mod, callstack = [], metadata, ignoreMock = false) {
+		if (ignoreMock) return this._cachedRequest(url, mod, callstack, metadata);
+		let mocked;
+		if (mod.meta && "mockedModule" in mod.meta) mocked = await this.mocker.requestWithMockedModule(url, mod, callstack, mod.meta.mockedModule);
+		else mocked = await this.mocker.mockedRequest(url, mod, callstack);
+		if (typeof mocked === "string") {
+			const node = await this.fetchModule(mocked);
+			return this._cachedRequest(mocked, node, callstack, metadata);
+		}
+		return mocked != null && typeof mocked === "object" ? mocked : this._cachedRequest(url, mod, callstack, metadata);
+	}
+	/** @internal */
+	_invalidateSubTreeById(ids, invalidated = /* @__PURE__ */ new Set()) {
+		for (const id of ids) {
+			if (invalidated.has(id)) continue;
+			const node = this.evaluatedModules.getModuleById(id);
+			if (!node) continue;
+			invalidated.add(id);
+			const subIds = Array.from(this.evaluatedModules.idToModuleMap).filter(([, mod]) => mod.importers.has(id)).map(([key]) => key);
+			if (subIds.length) this._invalidateSubTreeById(subIds, invalidated);
+			this.evaluatedModules.invalidateModule(node);
+		}
+	}
+}
+
+const bareVitestRegexp = /^@?vitest(?:\/|$)/, normalizedDistDir = normalize$1(distDir), relativeIds = {}, externalizeMap = /* @__PURE__ */ new Map();
+// all Vitest imports always need to be externalized
+function getCachedVitestImport(id, state) {
+	if (id.startsWith("/@fs/") || id.startsWith("\\@fs\\")) id = id.slice(process.platform === "win32" ? 5 : 4);
+	if (externalizeMap.has(id)) return {
+		externalize: externalizeMap.get(id),
+		type: "module"
+	};
+	// always externalize Vitest because we import from there before running tests
+	// so we already have it cached by Node.js
+	const root = state().config.root, relativeRoot = relativeIds[root] ?? (relativeIds[root] = normalizedDistDir.slice(root.length));
+	if (id.includes(distDir) || id.includes(normalizedDistDir)) {
+		const externalize = id.startsWith("file://") ? id : pathToFileURL(id).toString();
+		return externalizeMap.set(id, externalize), {
+			externalize,
+			type: "module"
+		};
+	}
+	if (relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
+		const path = join$1(root, id), externalize = pathToFileURL(path).toString();
+		return externalizeMap.set(id, externalize), {
+			externalize,
+			type: "module"
+		};
+	}
+	return bareVitestRegexp.test(id) ? (externalizeMap.set(id, id), {
+		externalize: id,
+		type: "module"
+	}) : null;
+}
+
+const dispose = [];
+function listenForErrors(state) {
+	dispose.forEach((fn) => fn()), dispose.length = 0;
+	function catchError(err, type, event) {
+		const worker = state(), listeners = process.listeners(event);
+		// if there is another listener, assume that it's handled by user code
+		// one is Vitest's own listener
+		if (listeners.length > 1) return;
+		const error = serializeValue(err);
+		if (typeof error === "object" && error != null) {
+			if (error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0, 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"), 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);
+	});
+}
+
+const { readFileSync } = fs, browserExternalId = "__vite-browser-external", browserExternalLength = 24;
+const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
+const cwd = process.cwd(), isWindows = process.platform === "win32";
+function startVitestModuleRunner(options) {
+	const state = () => globalThis.__vitest_worker__ || options.state, rpc = () => state().rpc;
+	process.exit = (code = process.exitCode || 0) => {
+		throw new Error(`process.exit unexpectedly called with "${code}"`);
+	}, listenForErrors(state);
+	const environment = () => {
+		const environment = state().environment;
+		return environment.viteEnvironment || environment.name;
+	}, vm = options.context && options.externalModulesExecutor ? {
+		context: options.context,
+		externalModulesExecutor: options.externalModulesExecutor
+	} : void 0, evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
+		get moduleExecutionInfo() {
+			return state().moduleExecutionInfo;
+		},
+		get interopDefault() {
+			return state().config.deps.interopDefault;
+		},
+		getCurrentTestFilepath: () => state().filepath
+	}), moduleRunner = new VitestModuleRunner({
+		spyModule: options.spyModule,
+		evaluatedModules: options.evaluatedModules,
+		evaluator,
+		mocker: options.mocker,
+		transport: {
+			async fetchModule(id, importer, options) {
+				const resolvingModules = state().resolvingModules;
+				if (isWindows) {
+					if (id[1] === ":") {
+						// The drive letter is different for whatever reason, we need to normalize it to CWD
+						if (id[0] !== cwd[0] && id[0].toUpperCase() === cwd[0].toUpperCase()) {
+							const isUpperCase = cwd[0].toUpperCase() === cwd[0];
+							id = (isUpperCase ? id[0].toUpperCase() : id[0].toLowerCase()) + id.slice(1);
+						}
+						// always mark absolute windows paths, otherwise Vite will externalize it
+						id = `/@id/${id}`;
+					}
+				}
+				const vitest = getCachedVitestImport(id, state);
+				if (vitest) return vitest;
+				const rawId = unwrapId(id);
+				resolvingModules.add(rawId);
+				try {
+					if (VitestMocker.pendingIds.length) await moduleRunner.mocker.resolveMocks();
+					const resolvedMock = moduleRunner.mocker.getDependencyMock(rawId);
+					if (resolvedMock?.type === "manual" || resolvedMock?.type === "redirect") return {
+						code: "",
+						file: null,
+						id,
+						url: id,
+						invalidate: false,
+						mockedModule: resolvedMock
+					};
+					if (isBuiltin(rawId) || rawId.startsWith(browserExternalId)) return {
+						externalize: toBuiltin(rawId),
+						type: "builtin"
+					};
+					const result = await rpc().fetch(id, importer, environment(), options);
+					if ("cached" in result) {
+						const code = readFileSync(result.tmp, "utf-8");
+						return {
+							code,
+							...result
+						};
+					}
+					return result;
+				} catch (cause) {
+					// rethrow vite error if it cannot load the module because it's not resolved
+					if (typeof cause === "object" && cause != null && cause.code === "ERR_LOAD_URL" || typeof cause?.message === "string" && cause.message.includes("Failed to load url") || typeof cause?.message === "string" && cause.message.startsWith("Cannot find module '")) {
+						const error = new Error(`Cannot find ${isBareImport(id) ? "package" : "module"} '${id}'${importer ? ` imported from '${importer}'` : ""}`, { cause });
+						throw error.code = "ERR_MODULE_NOT_FOUND", error;
+					}
+					throw cause;
+				} finally {
+					resolvingModules.delete(rawId);
+				}
+			},
+			resolveId(id, importer) {
+				return rpc().resolve(id, importer, environment());
+			}
+		},
+		getWorkerState: state,
+		vm,
+		createImportMeta: options.createImportMeta
+	});
+	// await moduleRunner.import('/@vite/env')
+	// await moduleRunner.mocker.initializeSpyModule()
+	return moduleRunner;
+}
+function toBuiltin(id) {
+	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
+	if (!id.startsWith("node:")) id = `node:${id}`;
+	return id;
+}
+
+export { VitestModuleRunner as V, VITEST_VM_CONTEXT_SYMBOL as a, VitestTransport as b, createNodeImportMeta as c, startVitestModuleRunner as s };

package/dist/chunks/{suite.d.FvehnV49.d.ts → suite.d.BJWk38HB.d.ts}

@@ -1,5 +1,5 @@
 import { Test } from '@vitest/runner';
-import { c as BenchmarkAPI, a as BenchFunction } from './benchmark.d.BwvBVTda.js';
+import { c as BenchmarkAPI, a as BenchFunction } from './benchmark.d.DAaHLpsq.js';
 import { Options } from 'tinybench';
 import '@vitest/runner/utils';