vitest 4.0.0-beta.5 → 4.0.0-beta.7

package/dist/chunks/{startModuleRunner.C8FtT_BY.js → startModuleRunner.C8TW8zTN.js}

@@ -12,10 +12,7 @@ import { MockerRegistry, mockObject, RedirectedModule, AutomockedModule } from '
 import { ModuleRunner } from 'vite/module-runner';
 import { V as VitestTransport } from './moduleTransport.I-bgQy0S.js';
 
-const bareVitestRegexp = /^@?vitest(?:\/|$)/;
-const normalizedDistDir = normalize$1(distDir);
-const relativeIds = {};
-const externalizeMap = /* @__PURE__ */ new Map();
+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);
@@ -25,99 +22,66 @@ function getCachedVitestImport(id, state) {
 	};
 	// 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;
-	const relativeRoot = relativeIds[root] ?? (relativeIds[root] = normalizedDistDir.slice(root.length));
+	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();
-		externalizeMap.set(id, externalize);
-		return {
+		return externalizeMap.set(id, externalize), {
 			externalize,
 			type: "module"
 		};
 	}
 	if (relativeRoot && relativeRoot !== "/" && id.startsWith(relativeRoot)) {
-		const path = join$1(root, id);
-		const externalize = pathToFileURL(path).toString();
-		externalizeMap.set(id, externalize);
-		return {
+		const path = join$1(root, id), externalize = pathToFileURL(path).toString();
+		return externalizeMap.set(id, externalize), {
 			externalize,
 			type: "module"
 		};
 	}
-	if (bareVitestRegexp.test(id)) {
-		externalizeMap.set(id, id);
-		return {
-			externalize: id,
-			type: "module"
-		};
-	}
-	return null;
+	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;
+	dispose.forEach((fn) => fn()), dispose.length = 0;
 	function catchError(err, type, event) {
-		const worker = state();
-		const listeners = process.listeners(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 = processError(err);
 		if (typeof error === "object" && error != null) {
-			error.VITEST_TEST_NAME = worker.current?.type === "test" ? worker.current.name : void 0;
-			if (worker.filepath) error.VITEST_TEST_PATH = worker.filepath;
+			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");
-	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);
+	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 _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());
+	return input && 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) {
+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);
-	const isPathAbsolute = isAbsolute(path);
-	const trailingSeparator = path[path.length - 1] === "/";
-	path = normalizeString(path, !isPathAbsolute);
-	if (path.length === 0) {
-		if (isPathAbsolute) return "/";
-		return trailingSeparator ? "./" : ".";
-	}
+	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 += "/";
-	if (isUNCPath) {
-		if (!isPathAbsolute) return `//./${path}`;
-		return `//${path}`;
-	}
-	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-};
-const join = function(...segments) {
+	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] === "/";
-			const segLeading = seg[0] === "/";
-			const both = pathTrailing && segLeading;
+			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;
@@ -125,29 +89,19 @@ const join = function(...segments) {
 	return normalize(path);
 };
 function cwd$1() {
-	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
-	return "/";
+	return typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd().replace(/\\/g, "/") : "/";
 }
 const resolve = function(...arguments_) {
 	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-	let resolvedPath = "";
-	let resolvedAbsolute = false;
+	let resolvedPath = "", resolvedAbsolute = false;
 	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
 		const path = index >= 0 ? arguments_[index] : cwd$1();
-		if (!path || path.length === 0) continue;
-		resolvedPath = `${path}/${resolvedPath}`;
-		resolvedAbsolute = isAbsolute(path);
+		!path || path.length === 0 || (resolvedPath = `${path}/${resolvedPath}`, resolvedAbsolute = isAbsolute(path));
 	}
-	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
-	return resolvedPath.length > 0 ? resolvedPath : ".";
+	return resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute), resolvedAbsolute && !isAbsolute(resolvedPath) ? `/${resolvedPath}` : resolvedPath.length > 0 ? resolvedPath : ".";
 };
 function normalizeString(path, allowAboveRoot) {
-	let res = "";
-	let lastSegmentLength = 0;
-	let lastSlash = -1;
-	let dots = 0;
-	let char = null;
+	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;
@@ -158,35 +112,22 @@ function normalizeString(path, allowAboveRoot) {
 				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;
+						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;
+						res = "", lastSegmentLength = 0, lastSlash = index, dots = 0;
 						continue;
 					}
 				}
-				if (allowAboveRoot) {
-					res += res.length > 0 ? "/.." : "..";
-					lastSegmentLength = 2;
-				}
+				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;
+			lastSlash = index, dots = 0;
 		} else if (char === "." && dots !== -1) ++dots;
 		else dots = -1;
 	}
@@ -194,18 +135,15 @@ function normalizeString(path, allowAboveRoot) {
 }
 const isAbsolute = function(p) {
 	return _IS_ABSOLUTE_RE.test(p);
-};
-const extname = function(p) {
+}, extname = function(p) {
 	if (p === "..") return "";
 	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
 	return match && match[1] || "";
-};
-const dirname = function(p) {
+}, 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) {
+}, basename = function(p, extension) {
 	const segments = normalizeWindowsPath(p).split("/");
 	let lastSegment = "";
 	for (let i = segments.length - 1; i >= 0; i--) {
@@ -224,8 +162,7 @@ function findMockRedirect(root, mockPath, external) {
 	// it's a node_module alias
 	// all mocks should be inside <root>/__mocks__
 	if (external || isNodeBuiltin(mockPath) || !existsSync(mockPath)) {
-		const mockDirname = dirname(path);
-		const mockFolder = join(root, "__mocks__", mockDirname);
+		const mockDirname = dirname(path), mockFolder = join(root, "__mocks__", mockDirname);
 		if (!existsSync(mockFolder)) return null;
 		const baseOriginal = basename(path);
 		function findFile(mockFolder, baseOriginal) {
@@ -236,7 +173,7 @@ function findMockRedirect(root, mockPath, external) {
 					const path = resolve(mockFolder, file);
 					// if the same name, return the file
 					if (statSync(path).isFile()) return path;
-					else {
+					{
 						// find folder/index.{js,ts}
 						const indexFile = findFile(path, "index");
 						if (indexFile) return indexFile;
@@ -247,9 +184,7 @@ function findMockRedirect(root, mockPath, external) {
 		}
 		return findFile(mockFolder, baseOriginal);
 	}
-	const dir = dirname(path);
-	const baseId = basename(path);
-	const fullPath = resolve(dir, "__mocks__", baseId);
+	const dir = dirname(path), baseId = basename(path), fullPath = resolve(dir, "__mocks__", baseId);
 	return existsSync(fullPath) ? fullPath : null;
 }
 const builtins = new Set([
@@ -267,18 +202,14 @@ const builtins = new Set([
 	"timers/promises",
 	"util/types",
 	"wasi"
-]);
-// https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix
-const prefixedBuiltins$1 = new Set([
+]), prefixedBuiltins$1 = new Set([
 	"node:sea",
 	"node:sqlite",
 	"node:test",
 	"node:test/reporters"
-]);
-const NODE_BUILTIN_NAMESPACE = "node:";
+]), NODE_BUILTIN_NAMESPACE = "node:";
 function isNodeBuiltin(id) {
-	if (prefixedBuiltins$1.has(id)) return true;
-	return builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
+	return prefixedBuiltins$1.has(id) ? true : builtins.has(id.startsWith(NODE_BUILTIN_NAMESPACE) ? id.slice(5) : id);
 }
 
 const spyModulePath = resolve$1(distDir, "spy.js");
@@ -290,8 +221,7 @@ class VitestMocker {
 	registries = /* @__PURE__ */ new Map();
 	mockContext = { callstack: null };
 	constructor(moduleRunner, options) {
-		this.moduleRunner = moduleRunner;
-		this.options = 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 = {
@@ -331,8 +261,7 @@ class VitestMocker {
 		return this.options.moduleDirectories || [];
 	}
 	async initializeSpyModule() {
-		if (this.spyModule) return;
-		this.spyModule = await this.moduleRunner.import(spyModulePath);
+		this.spyModule ||= await this.moduleRunner.import(spyModulePath);
 	}
 	getMockerRegistry() {
 		const suite = this.getSuiteFilepath();
@@ -343,12 +272,8 @@ class VitestMocker {
 		this.registries.clear();
 	}
 	invalidateModuleById(id) {
-		const mockId = this.getMockPath(id);
-		const node = this.evaluatedModules.getModuleById(mockId);
-		if (node) {
-			this.evaluatedModules.invalidateModule(node);
-			node.mockedExports = void 0;
-		}
+		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));
@@ -357,10 +282,8 @@ class VitestMocker {
 		return this.options.getCurrentTestFilepath() || "global";
 	}
 	createError(message, codeFrame) {
-		const Error = this.primitives.Error;
-		const error = new Error(message);
-		Object.assign(error, { codeFrame });
-		return error;
+		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);
@@ -382,31 +305,26 @@ class VitestMocker {
 		};
 	}
 	async resolveMocks() {
-		if (!VitestMocker.pendingIds.length) return;
-		await Promise.all(VitestMocker.pendingIds.map(async (mock) => {
+		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 = [];
+		})), VitestMocker.pendingIds = []);
 	}
 	ensureModule(id, url) {
 		const node = this.evaluatedModules.ensureModule(id, url);
-		// TODO
-		node.meta = {
+		return node.meta = {
 			id,
 			url,
 			code: "",
 			file: null,
 			invalidate: false
-		};
-		return node;
+		}, node;
 	}
 	async callFunctionMock(id, url, mock) {
 		const node = this.ensureModule(id, url);
 		if (node.exports) return node.exports;
-		const exports = await mock.resolve();
-		const moduleExports = new Proxy(exports, { get: (target, prop) => {
+		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") {
@@ -425,8 +343,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			}
 			return val;
 		} });
-		node.exports = moduleExports;
-		return moduleExports;
+		return node.exports = moduleExports, moduleExports;
 	}
 	// public method to avoid circular dependency
 	getMockContext() {
@@ -444,18 +361,17 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		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.");
+		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,
-			spyOn,
+			createMockInstance,
 			type: behavior
 		}, object, mockExports);
 	}
 	unmockPath(id) {
 		const registry = this.getMockerRegistry();
-		registry.deleteById(id);
-		this.invalidateModuleById(id);
+		registry.deleteById(id), this.invalidateModuleById(id);
 	}
 	mockPath(originalId, id, url, external, mockType, factory) {
 		const registry = this.getMockerRegistry();
@@ -470,9 +386,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		this.invalidateModuleById(id);
 	}
 	async importActual(rawId, importer, callstack) {
-		const { url } = await this.resolveId(rawId, importer);
-		const node = await this.moduleRunner.fetchModule(url, importer);
-		const result = await this.moduleRunner.cachedRequest(node.url, node, callstack || [importer], void 0, true);
+		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) {
@@ -484,9 +398,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 			else mock = new AutomockedModule(rawId, id, rawId);
 		}
 		if (mock.type === "automock" || mock.type === "autospy") {
-			const node = await this.moduleRunner.fetchModule(url, importer);
-			const mod = await this.moduleRunner.cachedRequest(url, node, [importer], void 0, true);
-			const Object = this.primitives.Object;
+			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);
@@ -498,30 +410,19 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 		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;
-			// we have to define a separate object that will copy all properties into itself
-			// and can't just use the same `exports` define automatically by Vite before the evaluator
-			const exports = Object.create(null);
+			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;
+			node.meta = evaluatedNode.meta, node.file = evaluatedNode.file, node.mockedExports = exports;
 			const mod = await this.moduleRunner.cachedRequest(url, node, callstack, void 0, true);
-			this.mockObject(mod, exports, mock.type);
-			return exports;
+			return this.mockObject(mod, exports, mock.type), exports;
 		}
 		if (mock.type === "manual" && !callstack.includes(mockId) && !callstack.includes(url)) try {
-			callstack.push(mockId);
-			// this will not work if user does Promise.all(import(), import())
-			// we can also use AsyncLocalStorage to store callstack, but this won't work in the browser
-			// maybe we should improve mock API in the future?
-			this.mockContext.callstack = callstack;
-			return await this.callFunctionMock(mockId, this.getMockPath(url), mock);
+			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);
@@ -531,8 +432,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 	}
 	async mockedRequest(url, evaluatedNode, callstack) {
 		const mock = this.getDependencyMock(evaluatedNode.id);
-		if (!mock) return;
-		return this.requestWithMockedModule(url, evaluatedNode, callstack, mock);
+		if (mock) return this.requestWithMockedModule(url, evaluatedNode, callstack, mock);
 	}
 	queueMock(id, importer, factoryOrOptions) {
 		const mockType = getMockType(factoryOrOptions);
@@ -553,9 +453,7 @@ If you need to partially mock a module, you can use "importOriginal" helper insi
 	}
 }
 function getMockType(factoryOrOptions) {
-	if (!factoryOrOptions) return "automock";
-	if (typeof factoryOrOptions === "function") return "manual";
-	return factoryOrOptions.spy ? "autospy" : "automock";
+	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
@@ -564,8 +462,7 @@ const prefixedBuiltins = new Set([
 	"node:sqlite",
 	"node:test",
 	"node:test/reporters"
-]);
-const isWindows$1 = process.platform === "win32";
+]), isWindows$1 = process.platform === "win32";
 // transform file url to id
 // virtual:custom -> virtual:custom
 // \0custom -> \0custom
@@ -588,8 +485,7 @@ function slash(p) {
 const multipleSlashRe = /^\/+/;
 // module-runner incorrectly replaces file:///path with `///path`
 function fixLeadingSlashes(id) {
-	if (id.startsWith("//")) return id.replace(multipleSlashRe, "/");
-	return id;
+	return id.startsWith("//") ? id.replace(multipleSlashRe, "/") : id;
 }
 
 // @ts-expect-error overriding private method
@@ -597,17 +493,13 @@ class VitestModuleRunner extends ModuleRunner {
 	mocker;
 	moduleExecutionInfo;
 	constructor(options) {
-		const transport = new VitestTransport(options.transport);
-		const evaluatedModules = options.evaluatedModules;
-		super({
+		const transport = new VitestTransport(options.transport), evaluatedModules = options.evaluatedModules;
+		if (super({
 			transport,
 			hmr: false,
 			evaluatedModules,
 			sourcemapInterceptor: "prepareStackTrace"
-		}, options.evaluator);
-		this.options = options;
-		this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo;
-		this.mocker = options.mocker || new VitestMocker(this, {
+		}, options.evaluator), this.options = options, this.moduleExecutionInfo = options.getWorkerState().moduleExecutionInfo, this.mocker = options.mocker || new VitestMocker(this, {
 			context: options.vm?.context,
 			resolveId: options.transport.resolveId,
 			get root() {
@@ -619,8 +511,7 @@ class VitestModuleRunner extends ModuleRunner {
 			getCurrentTestFilepath() {
 				return options.getWorkerState().filepath;
 			}
-		});
-		if (options.vm) options.vm.context.__vitest_mocker__ = this.mocker;
+		}), options.vm) options.vm.context.__vitest_mocker__ = this.mocker;
 		else Object.defineProperty(globalThis, "__vitest_mocker__", {
 			configurable: true,
 			writable: true,
@@ -629,8 +520,7 @@ class VitestModuleRunner extends ModuleRunner {
 	}
 	async import(rawId) {
 		const resolved = await this.options.transport.resolveId(rawId);
-		if (!resolved) return super.import(rawId);
-		return super.import(resolved.url);
+		return resolved ? super.import(resolved.url) : super.import(rawId);
 	}
 	async fetchModule(url, importer) {
 		const module = await this.cachedModule(url, importer);
@@ -652,8 +542,7 @@ class VitestModuleRunner extends ModuleRunner {
 			const node = await this.fetchModule(mocked);
 			return this._cachedRequest(mocked, node, callstack, metadata);
 		}
-		if (mocked != null && typeof mocked === "object") return mocked;
-		return this._cachedRequest(url, mod, callstack, metadata);
+		return mocked != null && typeof mocked === "object" ? mocked : this._cachedRequest(url, mod, callstack, metadata);
 	}
 	/** @internal */
 	_invalidateSubTreeById(ids, invalidated = /* @__PURE__ */ new Set()) {
@@ -669,28 +558,21 @@ class VitestModuleRunner extends ModuleRunner {
 	}
 }
 
-const { readFileSync } = fs;
-const browserExternalId = "__vite-browser-external";
-const browserExternalLength = 24;
+const { readFileSync } = fs, browserExternalId = "__vite-browser-external", browserExternalLength = 24;
 const VITEST_VM_CONTEXT_SYMBOL = "__vitest_vm_context__";
-const cwd = process.cwd();
-const isWindows = process.platform === "win32";
+const cwd = process.cwd(), isWindows = process.platform === "win32";
 async function startVitestModuleRunner(options) {
-	const state = () => globalThis.__vitest_worker__ || options.state;
-	const rpc = () => state().rpc;
+	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);
+	}, listenForErrors(state);
 	const environment = () => {
 		const environment = state().environment;
 		return environment.viteEnvironment || environment.name;
-	};
-	const vm = options.context && options.externalModulesExecutor ? {
+	}, vm = options.context && options.externalModulesExecutor ? {
 		context: options.context,
 		externalModulesExecutor: options.externalModulesExecutor
-	} : void 0;
-	const evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
+	} : void 0, evaluator = options.evaluator || new VitestModuleEvaluator(vm, {
 		get moduleExecutionInfo() {
 			return state().moduleExecutionInfo;
 		},
@@ -698,8 +580,7 @@ async function startVitestModuleRunner(options) {
 			return state().config.deps.interopDefault;
 		},
 		getCurrentTestFilepath: () => state().filepath
-	});
-	const moduleRunner = new VitestModuleRunner({
+	}), moduleRunner = new VitestModuleRunner({
 		evaluatedModules: options.evaluatedModules,
 		evaluator,
 		mocker: options.mocker,
@@ -749,8 +630,7 @@ async function startVitestModuleRunner(options) {
 					// 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 });
-						error.code = "ERR_MODULE_NOT_FOUND";
-						throw error;
+						throw error.code = "ERR_MODULE_NOT_FOUND", error;
 					}
 					throw cause;
 				} finally {
@@ -764,9 +644,7 @@ async function startVitestModuleRunner(options) {
 		getWorkerState: state,
 		vm
 	});
-	await moduleRunner.import("/@vite/env");
-	await moduleRunner.mocker.initializeSpyModule();
-	return moduleRunner;
+	return await moduleRunner.import("/@vite/env"), await moduleRunner.mocker.initializeSpyModule(), moduleRunner;
 }
 function toBuiltin(id) {
 	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);