vitest 4.0.0-beta.1 → 4.0.0-beta.10

package/dist/chunks/{typechecker.CVytUJuF.js → typechecker.DB-fIMaH.js}

@@ -10,16 +10,13 @@ import { parseAstAsync } from 'vite';
 
 const REGEXP_WRAP_PREFIX = "$$vitest:";
 function getOutputFile(config, reporter) {
-	if (!config?.outputFile) return;
-	if (typeof config.outputFile === "string") return config.outputFile;
-	return config.outputFile[reporter];
+	if (config?.outputFile) return typeof config.outputFile === "string" ? config.outputFile : config.outputFile[reporter];
 }
 /**
 * Prepares `SerializedConfig` for serialization, e.g. `node:v8.serialize`
 */
 function wrapSerializableConfig(config) {
-	let testNamePattern = config.testNamePattern;
-	let defines = config.defines;
+	let testNamePattern = config.testNamePattern, defines = config.defines;
 	// v8 serialize does not support regex
 	if (testNamePattern && typeof testNamePattern !== "string") testNamePattern = `${REGEXP_WRAP_PREFIX}${testNamePattern.toString()}`;
 	// v8 serialize drops properties with undefined value
@@ -33,6 +30,49 @@ function wrapSerializableConfig(config) {
 		defines
 	};
 }
+function createDefinesScript(define) {
+	if (!define) return "";
+	const serializedDefine = serializeDefine(define);
+	return serializedDefine === "{}" ? "" : `
+const defines = ${serializeDefine(define)}
+Object.keys(defines).forEach((key) => {
+  const segments = key.split('.')
+  let target = globalThis
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]
+    if (i === segments.length - 1) {
+      target[segment] = defines[key]
+    } else {
+      target = target[segment] || (target[segment] = {})
+    }
+  }
+})
+  `;
+}
+/**
+* Like `JSON.stringify` but keeps raw string values as a literal
+* in the generated code. For example: `"window"` would refer to
+* the global `window` object directly.
+*/
+function serializeDefine(define) {
+	const userDefine = {};
+	for (const key in define) {
+		// vitest sets this to avoid vite:client-inject plugin
+		if (key === "process.env.NODE_ENV" && define[key] === "process.env.NODE_ENV") continue;
+		// import.meta.env.* is handled in `importAnalysis` plugin
+		if (!key.startsWith("import.meta.env.")) userDefine[key] = define[key];
+	}
+	let res = `{`;
+	const keys = Object.keys(userDefine).sort();
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i], val = userDefine[key];
+		if (res += `${JSON.stringify(key)}: ${handleDefineValue(val)}`, i !== keys.length - 1) res += `, `;
+	}
+	return `${res}}`;
+}
+function handleDefineValue(value) {
+	return typeof value === "undefined" ? "undefined" : typeof value === "string" ? value : JSON.stringify(value);
+}
 
 function hasFailedSnapshot(suite) {
 	return getTests(suite).some((s) => {
@@ -40,58 +80,44 @@ function hasFailedSnapshot(suite) {
 	});
 }
 function convertTasksToEvents(file, onTask) {
-	const packs = [];
-	const events = [];
+	const packs = [], events = [];
 	function visit(suite) {
-		onTask?.(suite);
-		packs.push([
+		onTask?.(suite), packs.push([
 			suite.id,
 			suite.result,
 			suite.meta
-		]);
-		events.push([
+		]), events.push([
 			suite.id,
 			"suite-prepare",
 			void 0
-		]);
-		suite.tasks.forEach((task) => {
+		]), suite.tasks.forEach((task) => {
 			if (task.type === "suite") visit(task);
-			else {
-				onTask?.(task);
-				if (suite.mode !== "skip" && suite.mode !== "todo") {
-					packs.push([
-						task.id,
-						task.result,
-						task.meta
-					]);
-					events.push([
-						task.id,
-						"test-prepare",
-						void 0
-					]);
-					task.annotations.forEach((annotation) => {
-						events.push([
-							task.id,
-							"test-annotation",
-							{ annotation }
-						]);
-					});
-					events.push([
-						task.id,
-						"test-finished",
-						void 0
-					]);
-				}
-			}
-		});
-		events.push([
+			else if (onTask?.(task), suite.mode !== "skip" && suite.mode !== "todo") packs.push([
+				task.id,
+				task.result,
+				task.meta
+			]), events.push([
+				task.id,
+				"test-prepare",
+				void 0
+			]), task.annotations.forEach((annotation) => {
+				events.push([
+					task.id,
+					"test-annotation",
+					{ annotation }
+				]);
+			}), events.push([
+				task.id,
+				"test-finished",
+				void 0
+			]);
+		}), events.push([
 			suite.id,
 			"suite-finished",
 			void 0
 		]);
 	}
-	visit(file);
-	return {
+	return visit(file), {
 		packs,
 		events
 	};
@@ -374,13 +400,9 @@ base.MethodDefinition = base.PropertyDefinition = base.Property = function (node
 };
 
 async function collectTests(ctx, filepath) {
-	const request = await ctx.vitenode.transformRequest(filepath, filepath);
+	const request = await ctx.vite.environments.ssr.transformRequest(filepath);
 	if (!request) return null;
-	const ast = await parseAstAsync(request.code);
-	const testFilepath = relative(ctx.config.root, filepath);
-	const projectName = ctx.name;
-	const typecheckSubprojectName = projectName ? `${projectName}:__typecheck__` : "__typecheck__";
-	const file = {
+	const ast = await parseAstAsync(request.code), testFilepath = relative(ctx.config.root, filepath), projectName = ctx.name, typecheckSubprojectName = projectName ? `${projectName}:__typecheck__` : "__typecheck__", file = {
 		filepath,
 		type: "suite",
 		id: generateHash(`${testFilepath}${typecheckSubprojectName}`),
@@ -394,24 +416,19 @@ async function collectTests(ctx, filepath) {
 		file: null
 	};
 	file.file = file;
-	const definitions = [];
-	const getName = (callee) => {
+	const definitions = [], getName = (callee) => {
 		if (!callee) return null;
 		if (callee.type === "Identifier") return callee.name;
 		if (callee.type === "CallExpression") return getName(callee.callee);
 		if (callee.type === "TaggedTemplateExpression") return getName(callee.tag);
-		if (callee.type === "MemberExpression") {
-			if (callee.object?.type === "Identifier" && [
-				"it",
-				"test",
-				"describe",
-				"suite"
-			].includes(callee.object.name)) return callee.object?.name;
-			// direct call as `__vite_ssr_exports_0__.test()`
-			if (callee.object?.name?.startsWith("__vite_ssr_")) return getName(callee.property);
-			// call as `__vite_ssr__.test.skip()`
-			return getName(callee.object?.property);
-		}
+		if (callee.type === "MemberExpression")
+ // call as `__vite_ssr__.test.skip()`
+		return callee.object?.type === "Identifier" && [
+			"it",
+			"test",
+			"describe",
+			"suite"
+		].includes(callee.object.name) ? callee.object?.name : callee.object?.name?.startsWith("__vite_ssr_") ? getName(callee.property) : getName(callee.object?.property);
 		// unwrap (0, ...)
 		if (callee.type === "SequenceExpression" && callee.expressions.length === 2) {
 			const [e0, e1] = callee.expressions;
@@ -420,10 +437,8 @@ async function collectTests(ctx, filepath) {
 		return null;
 	};
 	ancestor(ast, { CallExpression(node) {
-		const { callee } = node;
-		const name = getName(callee);
-		if (!name) return;
-		if (![
+		const { callee } = node, name = getName(callee);
+		if (!name || ![
 			"it",
 			"test",
 			"describe",
@@ -444,9 +459,7 @@ async function collectTests(ctx, filepath) {
 		if (callee.type === "CallExpression") start = callee.end;
 		else if (callee.type === "TaggedTemplateExpression") start = callee.end + 1;
 		else start = node.start;
-		const { arguments: [messageNode] } = node;
-		const isQuoted = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral";
-		const message = isQuoted ? request.code.slice(messageNode.start + 1, messageNode.end - 1) : request.code.slice(messageNode.start, messageNode.end);
+		const { arguments: [messageNode] } = node, isQuoted = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral", message = isQuoted ? request.code.slice(messageNode.start + 1, messageNode.end - 1) : request.code.slice(messageNode.start, messageNode.end);
 		// cannot statically analyze, so we always skip it
 		if (mode === "skipIf" || mode === "runIf") mode = "skip";
 		definitions.push({
@@ -482,9 +495,7 @@ async function collectTests(ctx, filepath) {
 				start: definition.start,
 				meta: { typecheck: true }
 			};
-			definition.task = task;
-			latestSuite.tasks.push(task);
-			lastSuite = task;
+			definition.task = task, latestSuite.tasks.push(task), lastSuite = task;
 			return;
 		}
 		const task = {
@@ -501,13 +512,10 @@ async function collectTests(ctx, filepath) {
 			annotations: [],
 			meta: { typecheck: true }
 		};
-		definition.task = task;
-		latestSuite.tasks.push(task);
-	});
-	calculateSuiteHash(file);
+		definition.task = task, latestSuite.tasks.push(task);
+	}), calculateSuiteHash(file);
 	const hasOnly = someTasksAreOnly(file);
-	interpretTaskModes(file, ctx.config.testNamePattern, void 0, hasOnly, false, ctx.config.allowOnly);
-	return {
+	return interpretTaskModes(file, ctx.config.testNamePattern, void 0, hasOnly, false, ctx.config.allowOnly), {
 		file,
 		parsed: request.code,
 		filepath,
@@ -516,14 +524,11 @@ async function collectTests(ctx, filepath) {
 	};
 }
 
-const newLineRegExp = /\r?\n/;
-const errCodeRegExp = /error TS(?<errCode>\d+)/;
+const newLineRegExp = /\r?\n/, errCodeRegExp = /error TS(?<errCode>\d+)/;
 async function makeTscErrorInfo(errInfo) {
 	const [errFilePathPos = "", ...errMsgRawArr] = errInfo.split(":");
 	if (!errFilePathPos || errMsgRawArr.length === 0 || errMsgRawArr.join("").length === 0) return ["unknown filepath", null];
-	const errMsgRaw = errMsgRawArr.join("").trim();
-	// get filePath, line, col
-	const [errFilePath, errPos] = errFilePathPos.slice(0, -1).split("(");
+	const errMsgRaw = errMsgRawArr.join("").trim(), [errFilePath, errPos] = errFilePathPos.slice(0, -1).split("(");
 	if (!errFilePath || !errPos) return ["unknown filepath", null];
 	const [errLine, errCol] = errPos.split(",");
 	if (!errLine || !errCol) return [errFilePath, null];
@@ -532,9 +537,7 @@ async function makeTscErrorInfo(errInfo) {
 	if (!execArr) return [errFilePath, null];
 	const errCodeStr = execArr.groups?.errCode ?? "";
 	if (!errCodeStr) return [errFilePath, null];
-	const line = Number(errLine);
-	const col = Number(errCol);
-	const errCode = Number(errCodeStr);
+	const line = Number(errLine), col = Number(errCol), errCode = Number(errCodeStr);
 	return [errFilePath, {
 		filePath: errFilePath,
 		errCode,
@@ -544,43 +547,30 @@ async function makeTscErrorInfo(errInfo) {
 	}];
 }
 async function getRawErrsMapFromTsCompile(tscErrorStdout) {
-	const rawErrsMap = /* @__PURE__ */ new Map();
-	// Merge details line with main line (i.e. which contains file path)
-	const infos = await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
+	const rawErrsMap = /* @__PURE__ */ new Map(), infos = await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
 		if (!next) return prev;
-		else if (!next.startsWith(" ")) prev.push(next);
+		if (!next.startsWith(" ")) prev.push(next);
 		else prev[prev.length - 1] += `\n${next}`;
 		return prev;
 	}, []).map((errInfoLine) => makeTscErrorInfo(errInfoLine)));
-	infos.forEach(([errFilePath, errInfo]) => {
-		if (!errInfo) return;
-		if (!rawErrsMap.has(errFilePath)) rawErrsMap.set(errFilePath, [errInfo]);
+	return infos.forEach(([errFilePath, errInfo]) => {
+		if (errInfo) if (!rawErrsMap.has(errFilePath)) rawErrsMap.set(errFilePath, [errInfo]);
 		else rawErrsMap.get(errFilePath)?.push(errInfo);
-	});
-	return rawErrsMap;
+	}), rawErrsMap;
 }
 
 function createIndexMap(source) {
 	const map = /* @__PURE__ */ new Map();
-	let index = 0;
-	let line = 1;
-	let column = 1;
-	for (const char of source) {
-		map.set(`${line}:${column}`, index++);
-		if (char === "\n" || char === "\r\n") {
-			line++;
-			column = 0;
-		} else column++;
-	}
+	let index = 0, line = 1, column = 1;
+	for (const char of source) if (map.set(`${line}:${column}`, index++), char === "\n" || char === "\r\n") line++, column = 0;
+	else column++;
 	return map;
 }
 
 class TypeCheckError extends Error {
 	name = "TypeCheckError";
 	constructor(message, stacks) {
-		super(message);
-		this.message = message;
-		this.stacks = stacks;
+		super(message), this.message = message, this.stacks = stacks;
 	}
 }
 class Typechecker {
@@ -620,12 +610,9 @@ class Typechecker {
 	}
 	async collectTests() {
 		const tests = (await Promise.all(this.getFiles().map((filepath) => this.collectFileTests(filepath)))).reduce((acc, data) => {
-			if (!data) return acc;
-			acc[data.filepath] = data;
-			return acc;
+			return data && (acc[data.filepath] = data), acc;
 		}, {});
-		this._tests = tests;
-		return tests;
+		return this._tests = tests, tests;
 	}
 	markPassed(file) {
 		if (!file.result?.state) file.result = { state: "pass" };
@@ -638,26 +625,17 @@ class Typechecker {
 		markTasks(file.tasks);
 	}
 	async prepareResults(output) {
-		const typeErrors = await this.parseTscLikeOutput(output);
-		const testFiles = new Set(this.getFiles());
+		const typeErrors = await this.parseTscLikeOutput(output), testFiles = new Set(this.getFiles());
 		if (!this._tests) this._tests = await this.collectTests();
-		const sourceErrors = [];
-		const files = [];
-		testFiles.forEach((path) => {
-			const { file, definitions, map, parsed } = this._tests[path];
-			const errors = typeErrors.get(path);
-			files.push(file);
-			if (!errors) {
+		const sourceErrors = [], files = [];
+		return testFiles.forEach((path) => {
+			const { file, definitions, map, parsed } = this._tests[path], errors = typeErrors.get(path);
+			if (files.push(file), !errors) {
 				this.markPassed(file);
 				return;
 			}
-			const sortedDefinitions = [...definitions.sort((a, b) => b.start - a.start)];
-			// has no map for ".js" files that use // @ts-check
-			const traceMap = map && new TraceMap(map);
-			const indexMap = createIndexMap(parsed);
-			const markState = (task, state) => {
-				task.result = { state: task.mode === "run" || task.mode === "only" ? state : task.mode };
-				if (task.suite) markState(task.suite, state);
+			const sortedDefinitions = [...definitions.sort((a, b) => b.start - a.start)], traceMap = map && new TraceMap(map), indexMap = createIndexMap(parsed), markState = (task, state) => {
+				if (task.result = { state: task.mode === "run" || task.mode === "only" ? state : task.mode }, task.suite) markState(task.suite, state);
 				else if (task.file && task !== task.file) markState(task.file, state);
 			};
 			errors.forEach(({ error, originalError }) => {
@@ -665,53 +643,37 @@ class Typechecker {
 					line: originalError.line,
 					column: originalError.column,
 					source: basename(path)
-				}) : originalError;
-				const line = processedPos.line ?? originalError.line;
-				const column = processedPos.column ?? originalError.column;
-				const index = indexMap.get(`${line}:${column}`);
-				const definition = index != null && sortedDefinitions.find((def) => def.start <= index && def.end >= index);
-				const suite = definition ? definition.task : file;
-				const state = suite.mode === "run" || suite.mode === "only" ? "fail" : suite.mode;
-				const errors = suite.result?.errors || [];
-				suite.result = {
+				}) : originalError, line = processedPos.line ?? originalError.line, column = processedPos.column ?? originalError.column, index = indexMap.get(`${line}:${column}`), definition = index != null && sortedDefinitions.find((def) => def.start <= index && def.end >= index), suite = definition ? definition.task : file, state = suite.mode === "run" || suite.mode === "only" ? "fail" : suite.mode, errors = suite.result?.errors || [];
+				if (suite.result = {
 					state,
 					errors
-				};
-				errors.push(error);
-				if (state === "fail") {
+				}, errors.push(error), state === "fail") {
 					if (suite.suite) markState(suite.suite, "fail");
 					else if (suite.file && suite !== suite.file) markState(suite.file, "fail");
 				}
-			});
-			this.markPassed(file);
-		});
-		typeErrors.forEach((errors, path) => {
+			}), this.markPassed(file);
+		}), typeErrors.forEach((errors, path) => {
 			if (!testFiles.has(path)) sourceErrors.push(...errors.map(({ error }) => error));
-		});
-		return {
+		}), {
 			files,
 			sourceErrors,
 			time: performance.now() - this._startTime
 		};
 	}
 	async parseTscLikeOutput(output) {
-		const errorsMap = await getRawErrsMapFromTsCompile(output);
-		const typesErrors = /* @__PURE__ */ new Map();
-		errorsMap.forEach((errors, path) => {
-			const filepath = resolve(this.project.config.root, path);
-			const suiteErrors = errors.map((info) => {
+		const errorsMap = await getRawErrsMapFromTsCompile(output), typesErrors = /* @__PURE__ */ new Map();
+		return errorsMap.forEach((errors, path) => {
+			const filepath = resolve(this.project.config.root, path), suiteErrors = errors.map((info) => {
 				const limit = Error.stackTraceLimit;
 				Error.stackTraceLimit = 0;
 				// Some expect-type errors have the most useful information on the second line e.g. `This expression is not callable.\n  Type 'ExpectString<number>' has no call signatures.`
-				const errMsg = info.errMsg.replace(/\r?\n\s*(Type .* has no call signatures)/g, " $1");
-				const error = new TypeCheckError(errMsg, [{
+				const errMsg = info.errMsg.replace(/\r?\n\s*(Type .* has no call signatures)/g, " $1"), error = new TypeCheckError(errMsg, [{
 					file: filepath,
 					line: info.line,
 					column: info.column,
 					method: ""
 				}]);
-				Error.stackTraceLimit = limit;
-				return {
+				return Error.stackTraceLimit = limit, {
 					originalError: info,
 					error: {
 						name: error.name,
@@ -722,12 +684,10 @@ class Typechecker {
 				};
 			});
 			typesErrors.set(filepath, suiteErrors);
-		});
-		return typesErrors;
+		}), typesErrors;
 	}
 	async stop() {
-		this.process?.kill();
-		this.process = void 0;
+		this.process?.kill(), this.process = void 0;
 	}
 	async ensurePackageInstalled(ctx, checker) {
 		if (checker !== "tsc" && checker !== "vue-tsc") return;
@@ -741,8 +701,7 @@ class Typechecker {
 		return this._output;
 	}
 	async spawn() {
-		const { root, watch, typecheck } = this.project.config;
-		const args = [
+		const { root, watch, typecheck } = this.project.config, args = [
 			"--noEmit",
 			"--pretty",
 			"false",
@@ -754,8 +713,7 @@ class Typechecker {
 		if (watch) args.push("--watch");
 		if (typecheck.allowJs) args.push("--allowJs", "--checkJs");
 		if (typecheck.tsconfig) args.push("-p", resolve(root, typecheck.tsconfig));
-		this._output = "";
-		this._startTime = performance.now();
+		this._output = "", this._startTime = performance.now();
 		const child = x(typecheck.checker, args, {
 			nodeOptions: {
 				cwd: root,
@@ -764,44 +722,26 @@ class Typechecker {
 			throwOnError: false
 		});
 		this.process = child.process;
-		let rerunTriggered = false;
-		let dataReceived = false;
+		let rerunTriggered = false, dataReceived = false;
 		return new Promise((resolve, reject) => {
 			if (!child.process || !child.process.stdout) {
-				reject(new Error(`Failed to initialize ${typecheck.checker}. This is a bug in Vitest - please, open an issue with reproduction.`));
+				reject(/* @__PURE__ */ new Error(`Failed to initialize ${typecheck.checker}. This is a bug in Vitest - please, open an issue with reproduction.`));
 				return;
 			}
 			child.process.stdout.on("data", (chunk) => {
-				dataReceived = true;
-				this._output += chunk;
-				if (!watch) return;
-				if (this._output.includes("File change detected") && !rerunTriggered) {
-					this._onWatcherRerun?.();
-					this._startTime = performance.now();
-					this._result.sourceErrors = [];
-					this._result.files = [];
-					this._tests = null;
-					rerunTriggered = true;
-				}
-				if (/Found \w+ errors*. Watching for/.test(this._output)) {
-					rerunTriggered = false;
-					this.prepareResults(this._output).then((result) => {
-						this._result = result;
-						this._onParseEnd?.(result);
-					});
-					this._output = "";
+				if (dataReceived = true, this._output += chunk, watch) {
+					if (this._output.includes("File change detected") && !rerunTriggered) this._onWatcherRerun?.(), this._startTime = performance.now(), this._result.sourceErrors = [], this._result.files = [], this._tests = null, rerunTriggered = true;
+					if (/Found \w+ errors*. Watching for/.test(this._output)) rerunTriggered = false, this.prepareResults(this._output).then((result) => {
+						this._result = result, this._onParseEnd?.(result);
+					}), this._output = "";
 				}
 			});
-			const timeout = setTimeout(() => reject(new Error(`${typecheck.checker} spawn timed out`)), this.project.config.typecheck.spawnTimeout);
+			const timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`${typecheck.checker} spawn timed out`)), this.project.config.typecheck.spawnTimeout);
 			function onError(cause) {
-				clearTimeout(timeout);
-				reject(new Error("Spawning typechecker failed - is typescript installed?", { cause }));
+				clearTimeout(timeout), reject(new Error("Spawning typechecker failed - is typescript installed?", { cause }));
 			}
-			child.process.once("spawn", () => {
-				this._onParseStart?.();
-				child.process?.off("error", onError);
-				clearTimeout(timeout);
-				if (process.platform === "win32")
+			if (child.process.once("spawn", () => {
+				if (this._onParseStart?.(), child.process?.off("error", onError), clearTimeout(timeout), process.platform === "win32")
  // on Windows, the process might be spawned but fail to start
 				// we wait for a potential error here. if "close" event didn't trigger,
 				// we resolve the promise
@@ -809,22 +749,16 @@ class Typechecker {
 					resolve({ result: child });
 				}, 200);
 				else resolve({ result: child });
-			});
-			if (process.platform === "win32") child.process.once("close", (code) => {
-				if (code != null && code !== 0 && !dataReceived) onError(new Error(`The ${typecheck.checker} command exited with code ${code}.`));
+			}), process.platform === "win32") child.process.once("close", (code) => {
+				if (code != null && code !== 0 && !dataReceived) onError(/* @__PURE__ */ new Error(`The ${typecheck.checker} command exited with code ${code}.`));
 			});
 			child.process.once("error", onError);
 		});
 	}
 	async start() {
 		if (this.process) return;
-		const { watch } = this.project.config;
-		const { result: child } = await this.spawn();
-		if (!watch) {
-			await child;
-			this._result = await this.prepareResults(this._output);
-			await this._onParseEnd?.(this._result);
-		}
+		const { watch } = this.project.config, { result: child } = await this.spawn();
+		if (!watch) await child, this._result = await this.prepareResults(this._output), await this._onParseEnd?.(this._result);
 	}
 	getResult() {
 		return this._result;
@@ -833,12 +767,10 @@ class Typechecker {
 		return Object.values(this._tests || {}).map((i) => i.file);
 	}
 	getTestPacksAndEvents() {
-		const packs = [];
-		const events = [];
+		const packs = [], events = [];
 		for (const { file } of Object.values(this._tests || {})) {
 			const result = convertTasksToEvents(file);
-			packs.push(...result.packs);
-			events.push(...result.events);
+			packs.push(...result.packs), events.push(...result.events);
 		}
 		return {
 			packs,
@@ -861,14 +793,13 @@ function findGeneratedPosition(traceMap, { line, column, source }) {
 		if (m.source === source && m.originalLine !== null && m.originalColumn !== null && (line === m.originalLine ? column < m.originalColumn : line < m.originalLine)) mappings.push(m);
 	});
 	const next = mappings.sort((a, b) => a.originalLine === b.originalLine ? a.originalColumn - b.originalColumn : a.originalLine - b.originalLine).at(0);
-	if (next) return {
+	return next ? {
 		line: next.generatedLine,
 		column: next.generatedColumn
-	};
-	return {
+	} : {
 		line: null,
 		column: null
 	};
 }
 
-export { TypeCheckError as T, Typechecker as a, convertTasksToEvents as c, getOutputFile as g, hasFailedSnapshot as h, wrapSerializableConfig as w };
+export { TypeCheckError as T, Typechecker as a, ancestor as b, createDefinesScript as c, convertTasksToEvents as d, getOutputFile as g, hasFailedSnapshot as h, wrapSerializableConfig as w };

package/dist/chunks/{utils.CAioKnHs.js → utils.C2YI6McM.js}

@@ -1,11 +1,6 @@
 import { parseRegexp } from '@vitest/utils';
 
-const REGEXP_WRAP_PREFIX = "$$vitest:";
-// Store global APIs in case process is overwritten by tests
-const processSend = process.send?.bind(process);
-const processOn = process.on?.bind(process);
-const processOff = process.off?.bind(process);
-const dispose = [];
+const REGEXP_WRAP_PREFIX = "$$vitest:", processSend = process.send?.bind(process), processOn = process.on?.bind(process), processOff = process.off?.bind(process), dispose = [];
 function createThreadsRpcOptions({ port }) {
 	return {
 		post: (v) => {
@@ -31,12 +26,9 @@ function createForksRpcOptions(nodeV8) {
 		},
 		on(fn) {
 			const handler = (message, ...extras) => {
-				// Do not react on Tinypool's internal messaging
-				if (message?.__tinypool_worker_message__) return;
-				return fn(message, ...extras);
+				if (!message?.__tinypool_worker_message__) return fn(message, ...extras);
 			};
-			processOn("message", handler);
-			dispose.push(() => processOff("message", handler));
+			processOn("message", handler), dispose.push(() => processOff("message", handler));
 		}
 	};
 }
@@ -46,11 +38,10 @@ function createForksRpcOptions(nodeV8) {
 function unwrapSerializableConfig(config) {
 	if (config.testNamePattern && typeof config.testNamePattern === "string") {
 		const testNamePattern = config.testNamePattern;
-		if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) config.testNamePattern = parseRegexp(testNamePattern.slice(REGEXP_WRAP_PREFIX.length));
+		if (testNamePattern.startsWith(REGEXP_WRAP_PREFIX)) config.testNamePattern = parseRegexp(testNamePattern.slice(9));
 	}
 	if (config.defines && Array.isArray(config.defines.keys) && config.defines.original) {
-		const { keys, original } = config.defines;
-		const defines = {};
+		const { keys, original } = config.defines, defines = {};
 		// Apply all keys from the original. Entries which had undefined value are missing from original now
 		for (const key of keys) defines[key] = original[key];
 		config.defines = defines;