vitest 4.0.0-beta.9 → 4.0.1

package/dist/chunks/{index.BIP7prJq.js → index.CcRZ6fUh.js}

@@ -1,18 +1,22 @@
 import { existsSync, readFileSync, promises } from 'node:fs';
 import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
-import { resolve, dirname, isAbsolute, relative, basename, normalize } from 'pathe';
-import { g as getOutputFile, h as hasFailedSnapshot, T as TypeCheckError } from './typechecker.DB-fIMaH.js';
+import { resolve as resolve$1, dirname, isAbsolute, relative, basename, join, normalize } from 'pathe';
 import { performance as performance$1 } from 'node:perf_hooks';
-import { getTestName, getFullName, hasFailed, getTests, getSuites, getTasks } from '@vitest/runner/utils';
-import { slash, toArray, isPrimitive, inspect, positionToOffset, lineSplitRE } from '@vitest/utils';
+import { getTests, getTestName, hasFailed, getSuites, generateHash, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, getTasks, getFullName } from '@vitest/runner/utils';
+import { slash, toArray, isPrimitive } from '@vitest/utils/helpers';
 import { parseStacktrace, parseErrorStacktrace, defaultStackIgnorePatterns } from '@vitest/utils/source-map';
 import c from 'tinyrainbow';
 import { i as isTTY } from './env.D4Lgay0q.js';
 import { stripVTControlCharacters } from 'node:util';
 import { Console } from 'node:console';
 import { Writable } from 'node:stream';
+import { inspect } from '@vitest/utils/display';
+import nodeos__default, { hostname } from 'node:os';
+import { x } from 'tinyexec';
+import { distDir } from '../path.js';
+import { parseAstAsync } from 'vite';
+import { positionToOffset, lineSplitRE } from '@vitest/utils/offset';
 import { createRequire } from 'node:module';
-import { hostname } from 'node:os';
 
 /// <reference types="../types/index.d.ts" />
 
@@ -24,7 +28,7 @@ const {keys} = Object;
 const Primitive = String;   // it could be Number
 const primitive = 'string'; // it could be 'number'
 
-const ignore = {};
+const ignore$1 = {};
 const object = 'object';
 
 const noop = (_, value) => value;
@@ -46,13 +50,13 @@ const revive = (input, parsed, output, $) => {
       const tmp = input[value];
       if (typeof tmp === object && !parsed.has(tmp)) {
         parsed.add(tmp);
-        output[k] = ignore;
+        output[k] = ignore$1;
         lazy.push({k, a: [input, parsed, tmp, $]});
       }
       else
         output[k] = $.call(output, k, tmp);
     }
-    else if (output[k] !== ignore)
+    else if (output[k] !== ignore$1)
       output[k] = $.call(output, k, value);
   }
   for (let {length} = lazy, i = 0; i < length; i++) {
@@ -74,7 +78,7 @@ const set = (known, input, value) => {
  * @param {(this: any, key: string, value: any) => any} [reviver]
  * @returns {any}
  */
-const parse = (text, reviver) => {
+const parse$1 = (text, reviver) => {
   const input = $parse(text, Primitives).map(primitives);
   const value = input[0];
   const $ = reviver || noop;
@@ -121,6 +125,51 @@ const stringify = (value, replacer, space) => {
   }
 };
 
+function getOutputFile(config, reporter) {
+	if (config?.outputFile) return typeof config.outputFile === "string" ? config.outputFile : config.outputFile[reporter];
+}
+function createDefinesScript(define) {
+	return !define || serializeDefine(define) === "{}" ? "" : `
+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);
+}
+
 class BlobReporter {
 	start = 0;
 	ctx;
@@ -158,7 +207,7 @@ class BlobReporter {
 			modules,
 			coverage,
 			executionTime
-		], reportFile = resolve(this.ctx.config.root, outputFile);
+		], reportFile = resolve$1(this.ctx.config.root, outputFile);
 		await writeBlob(report, reportFile), this.ctx.logger.log("blob report written to", reportFile);
 	}
 }
@@ -169,10 +218,10 @@ async function writeBlob(content, filename) {
 }
 async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
 	// using process.cwd() because --merge-reports can only be used in CLI
-	const resolvedDir = resolve(process.cwd(), blobsDirectory), blobsFiles = await readdir(resolvedDir), promises = blobsFiles.map(async (filename) => {
-		const fullPath = resolve(resolvedDir, filename), stats = await stat(fullPath);
-		if (!stats.isFile()) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
-		const content = await readFile(fullPath, "utf-8"), [version, files, errors, moduleKeys, coverage, executionTime] = parse(content);
+	const resolvedDir = resolve$1(process.cwd(), blobsDirectory), promises = (await readdir(resolvedDir)).map(async (filename) => {
+		const fullPath = resolve$1(resolvedDir, filename);
+		if (!(await stat(fullPath)).isFile()) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a file`);
+		const content = await readFile(fullPath, "utf-8"), [version, files, errors, moduleKeys, coverage, executionTime] = parse$1(content);
 		if (!version) throw new TypeError(`vitest.mergeReports() expects all paths in "${blobsDirectory}" to be files generated by the blob reporter, but "${filename}" is not a valid blob file`);
 		return {
 			version,
@@ -214,6 +263,55 @@ async function readBlobs(currentVersion, blobsDirectory, projectsArray) {
 	};
 }
 
+function hasFailedSnapshot(suite) {
+	return getTests(suite).some((s) => {
+		return s.result?.errors?.some((e) => typeof e?.message === "string" && e.message.match(/Snapshot .* mismatched/));
+	});
+}
+function convertTasksToEvents(file, onTask) {
+	const packs = [], events = [];
+	function visit(suite) {
+		onTask?.(suite), packs.push([
+			suite.id,
+			suite.result,
+			suite.meta
+		]), events.push([
+			suite.id,
+			"suite-prepare",
+			void 0
+		]), suite.tasks.forEach((task) => {
+			if (task.type === "suite") visit(task);
+			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
+		]);
+	}
+	return visit(file), {
+		packs,
+		events
+	};
+}
+
 const F_RIGHT = "→";
 const F_DOWN = "↓";
 const F_DOWN_RIGHT = "↳";
@@ -232,6 +330,7 @@ const testPass = c.green(F_CHECK);
 const taskFail = c.red(F_CROSS);
 const suiteFail = c.red(F_POINTER);
 const pending$1 = c.gray("·");
+const separator = c.dim(" > ");
 const labelDefaultColors = [
 	c.bgYellow,
 	c.bgCyan,
@@ -351,6 +450,7 @@ var utils = /*#__PURE__*/Object.freeze({
   pending: pending$1,
   pointer: pointer,
   renderSnapshotSummary: renderSnapshotSummary,
+  separator: separator,
   skipped: skipped,
   suiteFail: suiteFail,
   taskFail: taskFail,
@@ -440,19 +540,10 @@ class BaseReporter {
 		})), logs.forEach((log) => this.log(log));
 	}
 	printTestCase(moduleState, test) {
-		const testResult = test.result(), { duration, retryCount, repeatCount } = test.diagnostic() || {}, padding = this.getTestIndentation(test.task);
-		let suffix = this.getDurationPrefix(test.task);
-		if (retryCount != null && retryCount > 0) suffix += c.yellow(` (retry x${retryCount})`);
-		if (repeatCount != null && repeatCount > 0) suffix += c.yellow(` (repeat x${repeatCount})`);
-		if (testResult.state === "failed")
- // print short errors, full errors will be at the end in summary
-		this.log(c.red(` ${padding}${taskFail} ${this.getTestName(test.task, c.dim(" > "))}`) + suffix), testResult.errors.forEach((error) => {
-			const message = this.formatShortError(error);
-			if (message) this.log(c.red(`   ${padding}${message}`));
-		});
-		else if (duration && duration > this.ctx.config.slowTestThreshold) this.log(` ${padding}${c.yellow(c.dim(F_CHECK))} ${this.getTestName(test.task, c.dim(" > "))} ${suffix}`);
-		else if (this.ctx.config.hideSkippedTests && testResult.state === "skipped") ; else if (testResult.state === "skipped" && testResult.note) this.log(` ${padding}${getStateSymbol(test.task)} ${this.getTestName(test.task, c.dim(" > "))}${c.dim(c.gray(` [${testResult.note}]`))}`);
-		else if (this.renderSucceed || moduleState === "failed") this.log(` ${padding}${getStateSymbol(test.task)} ${this.getTestName(test.task, c.dim(" > "))}${suffix}`);
+		const testResult = test.result(), { duration = 0 } = test.diagnostic() || {}, padding = this.getTestIndentation(test.task), suffix = this.getTestCaseSuffix(test);
+		if (testResult.state === "failed") this.log(c.red(` ${padding}${taskFail} ${this.getTestName(test.task, separator)}`) + suffix);
+		else if (duration > this.ctx.config.slowTestThreshold) this.log(` ${padding}${c.yellow(c.dim(F_CHECK))} ${this.getTestName(test.task, separator)} ${suffix}`);
+		else if (this.ctx.config.hideSkippedTests && testResult.state === "skipped") ; else if (this.renderSucceed || moduleState === "failed") this.log(` ${padding}${this.getStateSymbol(test)} ${this.getTestName(test.task, separator)}${suffix}`);
 	}
 	getModuleLog(testModule, counts) {
 		let state = c.dim(`${counts.tests} test${counts.tests > 1 ? "s" : ""}`);
@@ -461,46 +552,65 @@ class BaseReporter {
 		let suffix = c.dim("(") + state + c.dim(")") + this.getDurationPrefix(testModule.task);
 		const diagnostic = testModule.diagnostic();
 		if (diagnostic.heap != null) suffix += c.magenta(` ${Math.floor(diagnostic.heap / 1024 / 1024)} MB heap used`);
-		let title = getStateSymbol(testModule.task);
-		if (testModule.meta().typecheck) title += ` ${c.bgBlue(c.bold(" TS "))}`;
-		if (testModule.project.name) title += ` ${formatProjectName(testModule.project, "")}`;
-		return ` ${title} ${testModule.task.name} ${suffix}`;
+		return ` ${this.getEntityPrefix(testModule)} ${testModule.task.name} ${suffix}`;
 	}
-	printTestSuite(_suite) {
-		// Suite name is included in getTestName by default
+	printTestSuite(testSuite) {
+		if (!this.renderSucceed) return;
+		const indentation = "  ".repeat(getIndentation(testSuite.task)), tests = Array.from(testSuite.children.allTests()), state = this.getStateSymbol(testSuite);
+		this.log(` ${indentation}${state} ${testSuite.name} ${c.dim(`(${tests.length})`)}`);
 	}
-	getTestName(test, separator) {
-		return getTestName(test, separator);
+	getTestName(test, _separator) {
+		return test.name;
 	}
 	getFullName(test, separator) {
-		return getFullName(test, separator);
+		if (test === test.file) return test.name;
+		let name = test.file.name;
+		if (test.location) name += c.dim(`:${test.location.line}:${test.location.column}`);
+		return name += separator, name += getTestName(test, separator), name;
 	}
-	formatShortError(error) {
-		return `${F_RIGHT} ${error.message}`;
-	}
-	getTestIndentation(_test) {
-		return "  ";
+	getTestIndentation(test) {
+		return "  ".repeat(getIndentation(test));
 	}
 	printAnnotations(test, console, padding = 0) {
 		const annotations = test.annotations();
 		if (!annotations.length) return;
-		const PADDING = " ".repeat(padding);
-		annotations.forEach(({ location, type, message }) => {
+		const PADDING = " ".repeat(padding), groupedAnnotations = {};
+		for (const group in annotations.forEach((annotation) => {
+			const { location, type } = annotation;
+			let group;
 			if (location) {
 				const file = relative(test.project.config.root, location.file);
-				this[console](`${PADDING}${c.blue(F_POINTER)} ${c.gray(`${file}:${location.line}:${location.column}`)} ${c.bold(type)}`);
-			} else this[console](`${PADDING}${c.blue(F_POINTER)} ${c.bold(type)}`);
+				group = `${c.gray(`${file}:${location.line}:${location.column}`)} ${c.bold(type)}`;
+			} else group = c.bold(type);
+			groupedAnnotations[group] ??= [], groupedAnnotations[group].push(annotation);
+		}), groupedAnnotations) this[console](`${PADDING}${c.blue(F_POINTER)} ${group}`), groupedAnnotations[group].forEach(({ message }) => {
 			this[console](`${PADDING}  ${c.blue(F_DOWN_RIGHT)} ${message}`);
 		});
 	}
+	getEntityPrefix(entity) {
+		let title = this.getStateSymbol(entity);
+		if (entity.project.name) title += ` ${formatProjectName(entity.project, "")}`;
+		if (entity.meta().typecheck) title += ` ${c.bgBlue(c.bold(" TS "))}`;
+		return title;
+	}
+	getTestCaseSuffix(testCase) {
+		const { heap, retryCount, repeatCount } = testCase.diagnostic() || {}, testResult = testCase.result();
+		let suffix = this.getDurationPrefix(testCase.task);
+		if (retryCount != null && retryCount > 0) suffix += c.yellow(` (retry x${retryCount})`);
+		if (repeatCount != null && repeatCount > 0) suffix += c.yellow(` (repeat x${repeatCount})`);
+		if (heap != null) suffix += c.magenta(` ${Math.floor(heap / 1024 / 1024)} MB heap used`);
+		if (testResult.state === "skipped" && testResult.note) suffix += c.dim(c.gray(` [${testResult.note}]`));
+		return suffix;
+	}
+	getStateSymbol(test) {
+		return getStateSymbol(test.task);
+	}
 	getDurationPrefix(task) {
-		if (!task.result?.duration) return "";
-		const color = task.result.duration > this.ctx.config.slowTestThreshold ? c.yellow : c.green;
-		return color(` ${Math.round(task.result.duration)}${c.dim("ms")}`);
+		const duration = task.result?.duration && Math.round(task.result?.duration);
+		return duration == null ? "" : (duration > this.ctx.config.slowTestThreshold ? c.yellow : c.green)(` ${duration}${c.dim("ms")}`);
 	}
 	onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
-		const failed = errors.length > 0 || hasFailed(files);
-		if (failed) this.log(withLabel("red", "FAIL", "Tests failed. Watching for file changes..."));
+		if (errors.length > 0 || hasFailed(files)) this.log(withLabel("red", "FAIL", "Tests failed. Watching for file changes..."));
 		else if (this.ctx.isCancelling) this.log(withLabel("red", "CANCELLED", "Test run cancelled. Watching for file changes..."));
 		else this.log(withLabel("green", "PASS", "Waiting for file changes..."));
 		const hints = [c.dim("press ") + c.bold("h") + c.dim(" to show help")];
@@ -531,7 +641,7 @@ class BaseReporter {
 		const output = log.type === "stdout" ? this.ctx.logger.outputStream : this.ctx.logger.errorStream, write = (msg) => output.write(msg);
 		let headerText = "unknown test";
 		const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0;
-		if (task) headerText = this.getFullName(task, c.dim(" > "));
+		if (task) headerText = this.getFullName(task, separator);
 		else if (log.taskId && log.taskId !== "__vitest__unknown_test__") headerText = log.taskId;
 		if (write(c.gray(log.type + c.dim(` | ${headerText}\n`)) + log.content), log.origin) {
 			// browser logs don't have an extra end of line at the end like Node.js does
@@ -550,8 +660,8 @@ class BaseReporter {
 	shouldLog(log, taskState) {
 		if (this.ctx.config.silent === true || this.ctx.config.silent === "passed-only" && taskState !== "failed") return false;
 		if (this.ctx.config.onConsoleLog) {
-			const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0, entity = task && this.ctx.state.getReportedEntity(task), shouldLog = this.ctx.config.onConsoleLog(log.content, log.type, entity);
-			if (shouldLog === false) return shouldLog;
+			const task = log.taskId ? this.ctx.state.idMap.get(log.taskId) : void 0, entity = task && this.ctx.state.getReportedEntity(task);
+			if (this.ctx.config.onConsoleLog(log.content, log.type, entity) === false) return false;
 		}
 		return true;
 	}
@@ -601,12 +711,12 @@ class BaseReporter {
 		if (errors.length) this.ctx.logger.printUnhandledErrors(errors), this.error();
 	}
 	reportBenchmarkSummary(files) {
-		const benches = getTests(files), topBenches = benches.filter((i) => i.result?.benchmark?.rank === 1);
+		const topBenches = getTests(files).filter((i) => i.result?.benchmark?.rank === 1);
 		this.log(`\n${withLabel("cyan", "BENCH", "Summary\n")}`);
 		for (const bench of topBenches) {
 			const group = bench.suite || bench.file;
 			if (!group) continue;
-			const groupName = this.getFullName(group, c.dim(" > ")), project = this.ctx.projects.find((p) => p.name === bench.file.projectName);
+			const groupName = this.getFullName(group, separator), project = this.ctx.projects.find((p) => p.name === bench.file.projectName);
 			this.log(`  ${formatProjectName(project)}${bench.name}${c.dim(` - ${groupName}`)}`);
 			const siblings = group.tasks.filter((i) => i.meta.benchmark && i.result?.benchmark && i !== bench).sort((a, b) => a.result.benchmark.rank - b.result.benchmark.rank);
 			for (const sibling of siblings) {
@@ -633,7 +743,7 @@ class BaseReporter {
 		for (const [error, tasks] of errorsQueue) {
 			for (const task of tasks) {
 				const filepath = task?.filepath || "", projectName = task?.projectName || task.file?.projectName || "", project = this.ctx.projects.find((p) => p.name === projectName);
-				let name = this.getFullName(task, c.dim(" > "));
+				let name = this.getFullName(task, separator);
 				if (filepath) name += c.dim(` [ ${this.relative(filepath)} ]`);
 				this.ctx.logger.error(`${c.bgRed(c.bold(" FAIL "))} ${formatProjectName(project)}${name}`);
 			}
@@ -664,6 +774,9 @@ function sum(items, cb) {
 		return total + Math.max(cb(next) || 0, 0);
 	}, 0);
 }
+function getIndentation(suite, level = 1) {
+	return suite.suite && !("filepath" in suite.suite) ? getIndentation(suite.suite, level + 1) : level;
+}
 
 const DEFAULT_RENDER_INTERVAL_MS = 1e3, ESC = "\x1B[", CLEAR_LINE = `${ESC}K`, MOVE_CURSOR_ONE_ROW_UP = `${ESC}1A`, SYNC_START = `${ESC}?2026h`, SYNC_END = `${ESC}?2026l`;
 /**
@@ -876,11 +989,10 @@ class SummaryReporter {
 		else if (state === "failed") this.modules.failed++;
 		else if (module.task.mode === "todo" && state === "skipped") this.modules.todo++;
 		else if (state === "skipped") this.modules.skipped++;
-		const left = this.modules.total - this.modules.completed;
 		// Keep finished tests visible in summary for a while if there are more tests left.
 		// When a new test starts in onTestModuleQueued it will take this ones place.
 		// This reduces flickering by making summary more stable.
-		if (left > this.maxParallelTests) this.finishedModules.set(module.id, setTimeout(() => {
+		if (this.modules.total - this.modules.completed > this.maxParallelTests) this.finishedModules.set(module.id, setTimeout(() => {
 			this.removeTestModule(module.id);
 		}, FINISHED_TEST_CLEANUP_TIME_MS).unref());
 		else
@@ -1097,6 +1209,1298 @@ function formatTests(states) {
 	return output += currentIcon.color(currentIcon.char.repeat(count)), output;
 }
 
+// src/vlq.ts
+var comma = ",".charCodeAt(0);
+var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var intToChar = new Uint8Array(64);
+var charToInt = new Uint8Array(128);
+for (let i = 0; i < chars.length; i++) {
+  const c = chars.charCodeAt(i);
+  intToChar[i] = c;
+  charToInt[c] = i;
+}
+function decodeInteger(reader, relative) {
+  let value = 0;
+  let shift = 0;
+  let integer = 0;
+  do {
+    const c = reader.next();
+    integer = charToInt[c];
+    value |= (integer & 31) << shift;
+    shift += 5;
+  } while (integer & 32);
+  const shouldNegate = value & 1;
+  value >>>= 1;
+  if (shouldNegate) {
+    value = -2147483648 | -value;
+  }
+  return relative + value;
+}
+function hasMoreVlq(reader, max) {
+  if (reader.pos >= max) return false;
+  return reader.peek() !== comma;
+}
+var StringReader = class {
+  constructor(buffer) {
+    this.pos = 0;
+    this.buffer = buffer;
+  }
+  next() {
+    return this.buffer.charCodeAt(this.pos++);
+  }
+  peek() {
+    return this.buffer.charCodeAt(this.pos);
+  }
+  indexOf(char) {
+    const { buffer, pos } = this;
+    const idx = buffer.indexOf(char, pos);
+    return idx === -1 ? buffer.length : idx;
+  }
+};
+
+// src/sourcemap-codec.ts
+function decode(mappings) {
+  const { length } = mappings;
+  const reader = new StringReader(mappings);
+  const decoded = [];
+  let genColumn = 0;
+  let sourcesIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let namesIndex = 0;
+  do {
+    const semi = reader.indexOf(";");
+    const line = [];
+    let sorted = true;
+    let lastCol = 0;
+    genColumn = 0;
+    while (reader.pos < semi) {
+      let seg;
+      genColumn = decodeInteger(reader, genColumn);
+      if (genColumn < lastCol) sorted = false;
+      lastCol = genColumn;
+      if (hasMoreVlq(reader, semi)) {
+        sourcesIndex = decodeInteger(reader, sourcesIndex);
+        sourceLine = decodeInteger(reader, sourceLine);
+        sourceColumn = decodeInteger(reader, sourceColumn);
+        if (hasMoreVlq(reader, semi)) {
+          namesIndex = decodeInteger(reader, namesIndex);
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn, namesIndex];
+        } else {
+          seg = [genColumn, sourcesIndex, sourceLine, sourceColumn];
+        }
+      } else {
+        seg = [genColumn];
+      }
+      line.push(seg);
+      reader.pos++;
+    }
+    if (!sorted) sort(line);
+    decoded.push(line);
+    reader.pos = semi + 1;
+  } while (reader.pos <= length);
+  return decoded;
+}
+function sort(line) {
+  line.sort(sortComparator$1);
+}
+function sortComparator$1(a, b) {
+  return a[0] - b[0];
+}
+
+// Matches the scheme of a URL, eg "http://"
+const schemeRegex = /^[\w+.-]+:\/\//;
+/**
+ * Matches the parts of a URL:
+ * 1. Scheme, including ":", guaranteed.
+ * 2. User/password, including "@", optional.
+ * 3. Host, guaranteed.
+ * 4. Port, including ":", optional.
+ * 5. Path, including "/", optional.
+ * 6. Query, including "?", optional.
+ * 7. Hash, including "#", optional.
+ */
+const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
+/**
+ * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
+ * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
+ *
+ * 1. Host, optional.
+ * 2. Path, which may include "/", guaranteed.
+ * 3. Query, including "?", optional.
+ * 4. Hash, including "#", optional.
+ */
+const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
+function isAbsoluteUrl(input) {
+    return schemeRegex.test(input);
+}
+function isSchemeRelativeUrl(input) {
+    return input.startsWith('//');
+}
+function isAbsolutePath(input) {
+    return input.startsWith('/');
+}
+function isFileUrl(input) {
+    return input.startsWith('file:');
+}
+function isRelative(input) {
+    return /^[.?#]/.test(input);
+}
+function parseAbsoluteUrl(input) {
+    const match = urlRegex.exec(input);
+    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
+}
+function parseFileUrl(input) {
+    const match = fileRegex.exec(input);
+    const path = match[2];
+    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
+}
+function makeUrl(scheme, user, host, port, path, query, hash) {
+    return {
+        scheme,
+        user,
+        host,
+        port,
+        path,
+        query,
+        hash,
+        type: 7 /* Absolute */,
+    };
+}
+function parseUrl(input) {
+    if (isSchemeRelativeUrl(input)) {
+        const url = parseAbsoluteUrl('http:' + input);
+        url.scheme = '';
+        url.type = 6 /* SchemeRelative */;
+        return url;
+    }
+    if (isAbsolutePath(input)) {
+        const url = parseAbsoluteUrl('http://foo.com' + input);
+        url.scheme = '';
+        url.host = '';
+        url.type = 5 /* AbsolutePath */;
+        return url;
+    }
+    if (isFileUrl(input))
+        return parseFileUrl(input);
+    if (isAbsoluteUrl(input))
+        return parseAbsoluteUrl(input);
+    const url = parseAbsoluteUrl('http://foo.com/' + input);
+    url.scheme = '';
+    url.host = '';
+    url.type = input
+        ? input.startsWith('?')
+            ? 3 /* Query */
+            : input.startsWith('#')
+                ? 2 /* Hash */
+                : 4 /* RelativePath */
+        : 1 /* Empty */;
+    return url;
+}
+function stripPathFilename(path) {
+    // If a path ends with a parent directory "..", then it's a relative path with excess parent
+    // paths. It's not a file, so we can't strip it.
+    if (path.endsWith('/..'))
+        return path;
+    const index = path.lastIndexOf('/');
+    return path.slice(0, index + 1);
+}
+function mergePaths(url, base) {
+    normalizePath(base, base.type);
+    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
+    // path).
+    if (url.path === '/') {
+        url.path = base.path;
+    }
+    else {
+        // Resolution happens relative to the base path's directory, not the file.
+        url.path = stripPathFilename(base.path) + url.path;
+    }
+}
+/**
+ * The path can have empty directories "//", unneeded parents "foo/..", or current directory
+ * "foo/.". We need to normalize to a standard representation.
+ */
+function normalizePath(url, type) {
+    const rel = type <= 4 /* RelativePath */;
+    const pieces = url.path.split('/');
+    // We need to preserve the first piece always, so that we output a leading slash. The item at
+    // pieces[0] is an empty string.
+    let pointer = 1;
+    // Positive is the number of real directories we've output, used for popping a parent directory.
+    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
+    let positive = 0;
+    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
+    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
+    // real directory, we won't need to append, unless the other conditions happen again.
+    let addTrailingSlash = false;
+    for (let i = 1; i < pieces.length; i++) {
+        const piece = pieces[i];
+        // An empty directory, could be a trailing slash, or just a double "//" in the path.
+        if (!piece) {
+            addTrailingSlash = true;
+            continue;
+        }
+        // If we encounter a real directory, then we don't need to append anymore.
+        addTrailingSlash = false;
+        // A current directory, which we can always drop.
+        if (piece === '.')
+            continue;
+        // A parent directory, we need to see if there are any real directories we can pop. Else, we
+        // have an excess of parents, and we'll need to keep the "..".
+        if (piece === '..') {
+            if (positive) {
+                addTrailingSlash = true;
+                positive--;
+                pointer--;
+            }
+            else if (rel) {
+                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
+                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
+                pieces[pointer++] = piece;
+            }
+            continue;
+        }
+        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
+        // any popped or dropped directories.
+        pieces[pointer++] = piece;
+        positive++;
+    }
+    let path = '';
+    for (let i = 1; i < pointer; i++) {
+        path += '/' + pieces[i];
+    }
+    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
+        path += '/';
+    }
+    url.path = path;
+}
+/**
+ * Attempts to resolve `input` URL/path relative to `base`.
+ */
+function resolve(input, base) {
+    if (!input && !base)
+        return '';
+    const url = parseUrl(input);
+    let inputType = url.type;
+    if (base && inputType !== 7 /* Absolute */) {
+        const baseUrl = parseUrl(base);
+        const baseType = baseUrl.type;
+        switch (inputType) {
+            case 1 /* Empty */:
+                url.hash = baseUrl.hash;
+            // fall through
+            case 2 /* Hash */:
+                url.query = baseUrl.query;
+            // fall through
+            case 3 /* Query */:
+            case 4 /* RelativePath */:
+                mergePaths(url, baseUrl);
+            // fall through
+            case 5 /* AbsolutePath */:
+                // The host, user, and port are joined, you can't copy one without the others.
+                url.user = baseUrl.user;
+                url.host = baseUrl.host;
+                url.port = baseUrl.port;
+            // fall through
+            case 6 /* SchemeRelative */:
+                // The input doesn't have a schema at least, so we need to copy at least that over.
+                url.scheme = baseUrl.scheme;
+        }
+        if (baseType > inputType)
+            inputType = baseType;
+    }
+    normalizePath(url, inputType);
+    const queryHash = url.query + url.hash;
+    switch (inputType) {
+        // This is impossible, because of the empty checks at the start of the function.
+        // case UrlType.Empty:
+        case 2 /* Hash */:
+        case 3 /* Query */:
+            return queryHash;
+        case 4 /* RelativePath */: {
+            // The first char is always a "/", and we need it to be relative.
+            const path = url.path.slice(1);
+            if (!path)
+                return queryHash || '.';
+            if (isRelative(base || input) && !isRelative(path)) {
+                // If base started with a leading ".", or there is no base and input started with a ".",
+                // then we need to ensure that the relative path starts with a ".". We don't know if
+                // relative starts with a "..", though, so check before prepending.
+                return './' + path + queryHash;
+            }
+            return path + queryHash;
+        }
+        case 5 /* AbsolutePath */:
+            return url.path + queryHash;
+        default:
+            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
+    }
+}
+
+// src/trace-mapping.ts
+
+// src/strip-filename.ts
+function stripFilename(path) {
+  if (!path) return "";
+  const index = path.lastIndexOf("/");
+  return path.slice(0, index + 1);
+}
+
+// src/resolve.ts
+function resolver(mapUrl, sourceRoot) {
+  const from = stripFilename(mapUrl);
+  const prefix = sourceRoot ? sourceRoot + "/" : "";
+  return (source) => resolve(prefix + (source || ""), from);
+}
+
+// src/sourcemap-segment.ts
+var COLUMN = 0;
+var SOURCES_INDEX = 1;
+var SOURCE_LINE = 2;
+var SOURCE_COLUMN = 3;
+var NAMES_INDEX = 4;
+var REV_GENERATED_LINE = 1;
+var REV_GENERATED_COLUMN = 2;
+
+// src/sort.ts
+function maybeSort(mappings, owned) {
+  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
+  if (unsortedIndex === mappings.length) return mappings;
+  if (!owned) mappings = mappings.slice();
+  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
+    mappings[i] = sortSegments(mappings[i], owned);
+  }
+  return mappings;
+}
+function nextUnsortedSegmentLine(mappings, start) {
+  for (let i = start; i < mappings.length; i++) {
+    if (!isSorted(mappings[i])) return i;
+  }
+  return mappings.length;
+}
+function isSorted(line) {
+  for (let j = 1; j < line.length; j++) {
+    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
+      return false;
+    }
+  }
+  return true;
+}
+function sortSegments(line, owned) {
+  if (!owned) line = line.slice();
+  return line.sort(sortComparator);
+}
+function sortComparator(a, b) {
+  return a[COLUMN] - b[COLUMN];
+}
+
+// src/by-source.ts
+function buildBySources(decoded, memos) {
+  const sources = memos.map(() => []);
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    for (let j = 0; j < line.length; j++) {
+      const seg = line[j];
+      if (seg.length === 1) continue;
+      const sourceIndex2 = seg[SOURCES_INDEX];
+      const sourceLine = seg[SOURCE_LINE];
+      const sourceColumn = seg[SOURCE_COLUMN];
+      const source = sources[sourceIndex2];
+      const segs = source[sourceLine] || (source[sourceLine] = []);
+      segs.push([sourceColumn, i, seg[COLUMN]]);
+    }
+  }
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    for (let j = 0; j < source.length; j++) {
+      const line = source[j];
+      if (line) line.sort(sortComparator);
+    }
+  }
+  return sources;
+}
+
+// src/binary-search.ts
+var found = false;
+function binarySearch(haystack, needle, low, high) {
+  while (low <= high) {
+    const mid = low + (high - low >> 1);
+    const cmp = haystack[mid][COLUMN] - needle;
+    if (cmp === 0) {
+      found = true;
+      return mid;
+    }
+    if (cmp < 0) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  found = false;
+  return low - 1;
+}
+function upperBound(haystack, needle, index) {
+  for (let i = index + 1; i < haystack.length; index = i++) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function lowerBound(haystack, needle, index) {
+  for (let i = index - 1; i >= 0; index = i--) {
+    if (haystack[i][COLUMN] !== needle) break;
+  }
+  return index;
+}
+function memoizedState() {
+  return {
+    lastKey: -1,
+    lastNeedle: -1,
+    lastIndex: -1
+  };
+}
+function memoizedBinarySearch(haystack, needle, state, key) {
+  const { lastKey, lastNeedle, lastIndex } = state;
+  let low = 0;
+  let high = haystack.length - 1;
+  if (key === lastKey) {
+    if (needle === lastNeedle) {
+      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
+      return lastIndex;
+    }
+    if (needle >= lastNeedle) {
+      low = lastIndex === -1 ? 0 : lastIndex;
+    } else {
+      high = lastIndex;
+    }
+  }
+  state.lastKey = key;
+  state.lastNeedle = needle;
+  return state.lastIndex = binarySearch(haystack, needle, low, high);
+}
+
+// src/types.ts
+function parse(map) {
+  return typeof map === "string" ? JSON.parse(map) : map;
+}
+
+// src/trace-mapping.ts
+var LINE_GTR_ZERO = "`line` must be greater than 0 (lines start at line 1)";
+var COL_GTR_EQ_ZERO = "`column` must be greater than or equal to 0 (columns start at column 0)";
+var LEAST_UPPER_BOUND = -1;
+var GREATEST_LOWER_BOUND = 1;
+var TraceMap = class {
+  constructor(map, mapUrl) {
+    const isString = typeof map === "string";
+    if (!isString && map._decodedMemo) return map;
+    const parsed = parse(map);
+    const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
+    this.version = version;
+    this.file = file;
+    this.names = names || [];
+    this.sourceRoot = sourceRoot;
+    this.sources = sources;
+    this.sourcesContent = sourcesContent;
+    this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
+    const resolve = resolver(mapUrl, sourceRoot);
+    this.resolvedSources = sources.map(resolve);
+    const { mappings } = parsed;
+    if (typeof mappings === "string") {
+      this._encoded = mappings;
+      this._decoded = void 0;
+    } else if (Array.isArray(mappings)) {
+      this._encoded = void 0;
+      this._decoded = maybeSort(mappings, isString);
+    } else if (parsed.sections) {
+      throw new Error(`TraceMap passed sectioned source map, please use FlattenMap export instead`);
+    } else {
+      throw new Error(`invalid source map: ${JSON.stringify(parsed)}`);
+    }
+    this._decodedMemo = memoizedState();
+    this._bySources = void 0;
+    this._bySourceMemos = void 0;
+  }
+};
+function cast(map) {
+  return map;
+}
+function decodedMappings(map) {
+  var _a;
+  return (_a = cast(map))._decoded || (_a._decoded = decode(cast(map)._encoded));
+}
+function originalPositionFor(map, needle) {
+  let { line, column, bias } = needle;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const decoded = decodedMappings(map);
+  if (line >= decoded.length) return OMapping(null, null, null, null);
+  const segments = decoded[line];
+  const index = traceSegmentInternal(
+    segments,
+    cast(map)._decodedMemo,
+    line,
+    column,
+    bias || GREATEST_LOWER_BOUND
+  );
+  if (index === -1) return OMapping(null, null, null, null);
+  const segment = segments[index];
+  if (segment.length === 1) return OMapping(null, null, null, null);
+  const { names, resolvedSources } = map;
+  return OMapping(
+    resolvedSources[segment[SOURCES_INDEX]],
+    segment[SOURCE_LINE] + 1,
+    segment[SOURCE_COLUMN],
+    segment.length === 5 ? names[segment[NAMES_INDEX]] : null
+  );
+}
+function generatedPositionFor(map, needle) {
+  const { source, line, column, bias } = needle;
+  return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
+}
+function eachMapping(map, cb) {
+  const decoded = decodedMappings(map);
+  const { names, resolvedSources } = map;
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    for (let j = 0; j < line.length; j++) {
+      const seg = line[j];
+      const generatedLine = i + 1;
+      const generatedColumn = seg[0];
+      let source = null;
+      let originalLine = null;
+      let originalColumn = null;
+      let name = null;
+      if (seg.length !== 1) {
+        source = resolvedSources[seg[1]];
+        originalLine = seg[2] + 1;
+        originalColumn = seg[3];
+      }
+      if (seg.length === 5) name = names[seg[4]];
+      cb({
+        generatedLine,
+        generatedColumn,
+        source,
+        originalLine,
+        originalColumn,
+        name
+      });
+    }
+  }
+}
+function OMapping(source, line, column, name) {
+  return { source, line, column, name };
+}
+function GMapping(line, column) {
+  return { line, column };
+}
+function traceSegmentInternal(segments, memo, line, column, bias) {
+  let index = memoizedBinarySearch(segments, column, memo, line);
+  if (found) {
+    index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
+  } else if (bias === LEAST_UPPER_BOUND) index++;
+  if (index === -1 || index === segments.length) return -1;
+  return index;
+}
+function generatedPosition(map, source, line, column, bias, all) {
+  var _a, _b;
+  line--;
+  if (line < 0) throw new Error(LINE_GTR_ZERO);
+  if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
+  const { sources, resolvedSources } = map;
+  let sourceIndex2 = sources.indexOf(source);
+  if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source);
+  if (sourceIndex2 === -1) return all ? [] : GMapping(null, null);
+  const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState));
+  const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos));
+  const segments = generated[sourceIndex2][line];
+  if (segments == null) return all ? [] : GMapping(null, null);
+  const memo = bySourceMemos[sourceIndex2];
+  const index = traceSegmentInternal(segments, memo, line, column, bias);
+  if (index === -1) return GMapping(null, null);
+  const segment = segments[index];
+  return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
+}
+
+// AST walker module for ESTree compatible trees
+
+
+// An ancestor walk keeps an array of ancestor nodes (including the
+// current node) and passes them to the callback as third parameter
+// (and also as state parameter when no other state is present).
+function ancestor(node, visitors, baseVisitor, state, override) {
+  var ancestors = [];
+  if (!baseVisitor) { baseVisitor = base
+  ; }(function c(node, st, override) {
+    var type = override || node.type;
+    var isNew = node !== ancestors[ancestors.length - 1];
+    if (isNew) { ancestors.push(node); }
+    baseVisitor[type](node, st, c);
+    if (visitors[type]) { visitors[type](node, st || ancestors, ancestors); }
+    if (isNew) { ancestors.pop(); }
+  })(node, state, override);
+}
+
+function skipThrough(node, st, c) { c(node, st); }
+function ignore(_node, _st, _c) {}
+
+// Node walkers.
+
+var base = {};
+
+base.Program = base.BlockStatement = base.StaticBlock = function (node, st, c) {
+  for (var i = 0, list = node.body; i < list.length; i += 1)
+    {
+    var stmt = list[i];
+
+    c(stmt, st, "Statement");
+  }
+};
+base.Statement = skipThrough;
+base.EmptyStatement = ignore;
+base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression =
+  function (node, st, c) { return c(node.expression, st, "Expression"); };
+base.IfStatement = function (node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Statement");
+  if (node.alternate) { c(node.alternate, st, "Statement"); }
+};
+base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };
+base.BreakStatement = base.ContinueStatement = ignore;
+base.WithStatement = function (node, st, c) {
+  c(node.object, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.SwitchStatement = function (node, st, c) {
+  c(node.discriminant, st, "Expression");
+  for (var i = 0, list = node.cases; i < list.length; i += 1) {
+    var cs = list[i];
+
+    c(cs, st);
+  }
+};
+base.SwitchCase = function (node, st, c) {
+  if (node.test) { c(node.test, st, "Expression"); }
+  for (var i = 0, list = node.consequent; i < list.length; i += 1)
+    {
+    var cons = list[i];
+
+    c(cons, st, "Statement");
+  }
+};
+base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
+  if (node.argument) { c(node.argument, st, "Expression"); }
+};
+base.ThrowStatement = base.SpreadElement =
+  function (node, st, c) { return c(node.argument, st, "Expression"); };
+base.TryStatement = function (node, st, c) {
+  c(node.block, st, "Statement");
+  if (node.handler) { c(node.handler, st); }
+  if (node.finalizer) { c(node.finalizer, st, "Statement"); }
+};
+base.CatchClause = function (node, st, c) {
+  if (node.param) { c(node.param, st, "Pattern"); }
+  c(node.body, st, "Statement");
+};
+base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.ForStatement = function (node, st, c) {
+  if (node.init) { c(node.init, st, "ForInit"); }
+  if (node.test) { c(node.test, st, "Expression"); }
+  if (node.update) { c(node.update, st, "Expression"); }
+  c(node.body, st, "Statement");
+};
+base.ForInStatement = base.ForOfStatement = function (node, st, c) {
+  c(node.left, st, "ForInit");
+  c(node.right, st, "Expression");
+  c(node.body, st, "Statement");
+};
+base.ForInit = function (node, st, c) {
+  if (node.type === "VariableDeclaration") { c(node, st); }
+  else { c(node, st, "Expression"); }
+};
+base.DebuggerStatement = ignore;
+
+base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };
+base.VariableDeclaration = function (node, st, c) {
+  for (var i = 0, list = node.declarations; i < list.length; i += 1)
+    {
+    var decl = list[i];
+
+    c(decl, st);
+  }
+};
+base.VariableDeclarator = function (node, st, c) {
+  c(node.id, st, "Pattern");
+  if (node.init) { c(node.init, st, "Expression"); }
+};
+
+base.Function = function (node, st, c) {
+  if (node.id) { c(node.id, st, "Pattern"); }
+  for (var i = 0, list = node.params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    c(param, st, "Pattern");
+  }
+  c(node.body, st, node.expression ? "Expression" : "Statement");
+};
+
+base.Pattern = function (node, st, c) {
+  if (node.type === "Identifier")
+    { c(node, st, "VariablePattern"); }
+  else if (node.type === "MemberExpression")
+    { c(node, st, "MemberPattern"); }
+  else
+    { c(node, st); }
+};
+base.VariablePattern = ignore;
+base.MemberPattern = skipThrough;
+base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };
+base.ArrayPattern = function (node, st, c) {
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+
+    if (elt) { c(elt, st, "Pattern"); }
+  }
+};
+base.ObjectPattern = function (node, st, c) {
+  for (var i = 0, list = node.properties; i < list.length; i += 1) {
+    var prop = list[i];
+
+    if (prop.type === "Property") {
+      if (prop.computed) { c(prop.key, st, "Expression"); }
+      c(prop.value, st, "Pattern");
+    } else if (prop.type === "RestElement") {
+      c(prop.argument, st, "Pattern");
+    }
+  }
+};
+
+base.Expression = skipThrough;
+base.ThisExpression = base.Super = base.MetaProperty = ignore;
+base.ArrayExpression = function (node, st, c) {
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+
+    if (elt) { c(elt, st, "Expression"); }
+  }
+};
+base.ObjectExpression = function (node, st, c) {
+  for (var i = 0, list = node.properties; i < list.length; i += 1)
+    {
+    var prop = list[i];
+
+    c(prop, st);
+  }
+};
+base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
+base.SequenceExpression = function (node, st, c) {
+  for (var i = 0, list = node.expressions; i < list.length; i += 1)
+    {
+    var expr = list[i];
+
+    c(expr, st, "Expression");
+  }
+};
+base.TemplateLiteral = function (node, st, c) {
+  for (var i = 0, list = node.quasis; i < list.length; i += 1)
+    {
+    var quasi = list[i];
+
+    c(quasi, st);
+  }
+
+  for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1)
+    {
+    var expr = list$1[i$1];
+
+    c(expr, st, "Expression");
+  }
+};
+base.TemplateElement = ignore;
+base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
+  c(node.argument, st, "Expression");
+};
+base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
+  c(node.left, st, "Expression");
+  c(node.right, st, "Expression");
+};
+base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
+  c(node.left, st, "Pattern");
+  c(node.right, st, "Expression");
+};
+base.ConditionalExpression = function (node, st, c) {
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Expression");
+  c(node.alternate, st, "Expression");
+};
+base.NewExpression = base.CallExpression = function (node, st, c) {
+  c(node.callee, st, "Expression");
+  if (node.arguments)
+    { for (var i = 0, list = node.arguments; i < list.length; i += 1)
+      {
+        var arg = list[i];
+
+        c(arg, st, "Expression");
+      } }
+};
+base.MemberExpression = function (node, st, c) {
+  c(node.object, st, "Expression");
+  if (node.computed) { c(node.property, st, "Expression"); }
+};
+base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
+  if (node.declaration)
+    { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); }
+  if (node.source) { c(node.source, st, "Expression"); }
+};
+base.ExportAllDeclaration = function (node, st, c) {
+  if (node.exported)
+    { c(node.exported, st); }
+  c(node.source, st, "Expression");
+};
+base.ImportDeclaration = function (node, st, c) {
+  for (var i = 0, list = node.specifiers; i < list.length; i += 1)
+    {
+    var spec = list[i];
+
+    c(spec, st);
+  }
+  c(node.source, st, "Expression");
+};
+base.ImportExpression = function (node, st, c) {
+  c(node.source, st, "Expression");
+};
+base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;
+
+base.TaggedTemplateExpression = function (node, st, c) {
+  c(node.tag, st, "Expression");
+  c(node.quasi, st, "Expression");
+};
+base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };
+base.Class = function (node, st, c) {
+  if (node.id) { c(node.id, st, "Pattern"); }
+  if (node.superClass) { c(node.superClass, st, "Expression"); }
+  c(node.body, st);
+};
+base.ClassBody = function (node, st, c) {
+  for (var i = 0, list = node.body; i < list.length; i += 1)
+    {
+    var elt = list[i];
+
+    c(elt, st);
+  }
+};
+base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) {
+  if (node.computed) { c(node.key, st, "Expression"); }
+  if (node.value) { c(node.value, st, "Expression"); }
+};
+
+async function collectTests(ctx, filepath) {
+	const request = await ctx.vite.environments.ssr.transformRequest(filepath);
+	if (!request) return null;
+	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}`),
+		name: testFilepath,
+		mode: "run",
+		tasks: [],
+		start: ast.start,
+		end: ast.end,
+		projectName,
+		meta: { typecheck: true },
+		file: null
+	};
+	file.file = file;
+	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")
+ // 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;
+			if (e0.type === "Literal" && e0.value === 0) return getName(e1);
+		}
+		return null;
+	};
+	ancestor(ast, { CallExpression(node) {
+		const { callee } = node, name = getName(callee);
+		if (!name || ![
+			"it",
+			"test",
+			"describe",
+			"suite"
+		].includes(name)) return;
+		const property = callee?.property?.name;
+		let mode = !property || property === name ? "run" : property;
+		// they will be picked up in the next iteration
+		if ([
+			"each",
+			"for",
+			"skipIf",
+			"runIf"
+		].includes(mode)) return;
+		let start;
+		const end = node.end;
+		// .each
+		if (callee.type === "CallExpression") start = callee.end;
+		else if (callee.type === "TaggedTemplateExpression") start = callee.end + 1;
+		else start = node.start;
+		const { arguments: [messageNode] } = node, message = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral" ? 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({
+			start,
+			end,
+			name: message,
+			type: name === "it" || name === "test" ? "test" : "suite",
+			mode,
+			task: null
+		});
+	} });
+	let lastSuite = file;
+	const updateLatestSuite = (index) => {
+		while (lastSuite.suite && lastSuite.end < index) lastSuite = lastSuite.suite;
+		return lastSuite;
+	};
+	definitions.sort((a, b) => a.start - b.start).forEach((definition) => {
+		const latestSuite = updateLatestSuite(definition.start);
+		let mode = definition.mode;
+		if (latestSuite.mode !== "run")
+ // inherit suite mode, if it's set
+		mode = latestSuite.mode;
+		if (definition.type === "suite") {
+			const task = {
+				type: definition.type,
+				id: "",
+				suite: latestSuite,
+				file,
+				tasks: [],
+				mode,
+				name: definition.name,
+				end: definition.end,
+				start: definition.start,
+				meta: { typecheck: true }
+			};
+			definition.task = task, latestSuite.tasks.push(task), lastSuite = task;
+			return;
+		}
+		const task = {
+			type: definition.type,
+			id: "",
+			suite: latestSuite,
+			file,
+			mode,
+			timeout: 0,
+			context: {},
+			name: definition.name,
+			end: definition.end,
+			start: definition.start,
+			annotations: [],
+			meta: { typecheck: true }
+		};
+		definition.task = task, latestSuite.tasks.push(task);
+	}), calculateSuiteHash(file);
+	const hasOnly = someTasksAreOnly(file);
+	return interpretTaskModes(file, ctx.config.testNamePattern, void 0, hasOnly, false, ctx.config.allowOnly), {
+		file,
+		parsed: request.code,
+		filepath,
+		map: request.map,
+		definitions
+	};
+}
+
+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(), [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];
+	// get errCode, errMsg
+	const execArr = errCodeRegExp.exec(errMsgRaw);
+	if (!execArr) return [errFilePath, null];
+	const errCodeStr = execArr.groups?.errCode ?? "";
+	if (!errCodeStr) return [errFilePath, null];
+	const line = Number(errLine), col = Number(errCol), errCode = Number(errCodeStr);
+	return [errFilePath, {
+		filePath: errFilePath,
+		errCode,
+		line,
+		column: col,
+		errMsg: errMsgRaw.slice(`error TS${errCode} `.length)
+	}];
+}
+async function getRawErrsMapFromTsCompile(tscErrorStdout) {
+	const rawErrsMap = /* @__PURE__ */ new Map();
+	return (await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
+		if (!next) return prev;
+		if (next[0] !== " ") prev.push(next);
+		else prev[prev.length - 1] += `\n${next}`;
+		return prev;
+	}, []).map((errInfoLine) => makeTscErrorInfo(errInfoLine)))).forEach(([errFilePath, errInfo]) => {
+		if (errInfo) if (!rawErrsMap.has(errFilePath)) rawErrsMap.set(errFilePath, [errInfo]);
+		else rawErrsMap.get(errFilePath)?.push(errInfo);
+	}), rawErrsMap;
+}
+
+function createIndexMap(source) {
+	const map = /* @__PURE__ */ new Map();
+	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;
+	}
+}
+class Typechecker {
+	_onParseStart;
+	_onParseEnd;
+	_onWatcherRerun;
+	_result = {
+		files: [],
+		sourceErrors: [],
+		time: 0
+	};
+	_startTime = 0;
+	_output = "";
+	_tests = {};
+	process;
+	files = [];
+	constructor(project) {
+		this.project = project;
+	}
+	setFiles(files) {
+		this.files = files;
+	}
+	onParseStart(fn) {
+		this._onParseStart = fn;
+	}
+	onParseEnd(fn) {
+		this._onParseEnd = fn;
+	}
+	onWatcherRerun(fn) {
+		this._onWatcherRerun = fn;
+	}
+	async collectFileTests(filepath) {
+		return collectTests(this.project, filepath);
+	}
+	getFiles() {
+		return this.files;
+	}
+	async collectTests() {
+		const tests = (await Promise.all(this.getFiles().map((filepath) => this.collectFileTests(filepath)))).reduce((acc, data) => {
+			return data && (acc[data.filepath] = data), acc;
+		}, {});
+		return this._tests = tests, tests;
+	}
+	markPassed(file) {
+		if (!file.result?.state) file.result = { state: "pass" };
+		const markTasks = (tasks) => {
+			for (const task of tasks) {
+				if ("tasks" in task) markTasks(task.tasks);
+				if (!task.result?.state && (task.mode === "run" || task.mode === "queued")) task.result = { state: "pass" };
+			}
+		};
+		markTasks(file.tasks);
+	}
+	async prepareResults(output) {
+		const typeErrors = await this.parseTscLikeOutput(output), testFiles = new Set(this.getFiles());
+		if (!this._tests) this._tests = await this.collectTests();
+		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)], 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 }) => {
+				const processedPos = traceMap ? findGeneratedPosition(traceMap, {
+					line: originalError.line,
+					column: originalError.column,
+					source: basename(path)
+				}) : 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), 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) => {
+			if (!testFiles.has(path)) sourceErrors.push(...errors.map(({ error }) => error));
+		}), {
+			files,
+			sourceErrors,
+			time: performance$1.now() - this._startTime
+		};
+	}
+	async parseTscLikeOutput(output) {
+		const errorsMap = await getRawErrsMapFromTsCompile(output), typesErrors = /* @__PURE__ */ new Map();
+		return errorsMap.forEach((errors, path) => {
+			const filepath = resolve$1(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"), error = new TypeCheckError(errMsg, [{
+					file: filepath,
+					line: info.line,
+					column: info.column,
+					method: ""
+				}]);
+				return Error.stackTraceLimit = limit, {
+					originalError: info,
+					error: {
+						name: error.name,
+						message: errMsg,
+						stacks: error.stacks,
+						stack: ""
+					}
+				};
+			});
+			typesErrors.set(filepath, suiteErrors);
+		}), typesErrors;
+	}
+	async stop() {
+		this.process?.kill(), this.process = void 0;
+	}
+	async ensurePackageInstalled(ctx, checker) {
+		if (checker !== "tsc" && checker !== "vue-tsc") return;
+		const packageName = checker === "tsc" ? "typescript" : "vue-tsc";
+		await ctx.packageInstaller.ensureInstalled(packageName, ctx.config.root);
+	}
+	getExitCode() {
+		return this.process?.exitCode != null && this.process.exitCode;
+	}
+	getOutput() {
+		return this._output;
+	}
+	async spawn() {
+		const { root, watch, typecheck } = this.project.config, args = [
+			"--noEmit",
+			"--pretty",
+			"false",
+			"--incremental",
+			"--tsBuildInfoFile",
+			join(process.versions.pnp ? join(nodeos__default.tmpdir(), this.project.hash) : distDir, "tsconfig.tmp.tsbuildinfo")
+		];
+		// use builtin watcher because it's faster
+		if (watch) args.push("--watch");
+		if (typecheck.allowJs) args.push("--allowJs", "--checkJs");
+		if (typecheck.tsconfig) args.push("-p", resolve$1(root, typecheck.tsconfig));
+		this._output = "", this._startTime = performance$1.now();
+		const child = x(typecheck.checker, args, {
+			nodeOptions: {
+				cwd: root,
+				stdio: "pipe"
+			},
+			throwOnError: false
+		});
+		this.process = child.process;
+		let rerunTriggered = false, dataReceived = false;
+		return new Promise((resolve, reject) => {
+			if (!child.process || !child.process.stdout) {
+				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) => {
+				if (dataReceived = true, this._output += chunk, watch) {
+					if (this._output.includes("File change detected") && !rerunTriggered) this._onWatcherRerun?.(), this._startTime = performance$1.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(/* @__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 }));
+			}
+			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
+				setTimeout(() => {
+					resolve({ result: child });
+				}, 200);
+				else resolve({ result: child });
+			}), 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, { 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;
+	}
+	getTestFiles() {
+		return Object.values(this._tests || {}).map((i) => i.file);
+	}
+	getTestPacksAndEvents() {
+		const packs = [], events = [];
+		for (const { file } of Object.values(this._tests || {})) {
+			const result = convertTasksToEvents(file);
+			packs.push(...result.packs), events.push(...result.events);
+		}
+		return {
+			packs,
+			events
+		};
+	}
+}
+function findGeneratedPosition(traceMap, { line, column, source }) {
+	const found = generatedPositionFor(traceMap, {
+		line,
+		column,
+		source
+	});
+	if (found.line !== null) return found;
+	// find the next source token position when the exact error position doesn't exist in source map.
+	// this can happen, for example, when the type error is in the comment "// @ts-expect-error"
+	// and comments are stripped away in the generated code.
+	const mappings = [];
+	eachMapping(traceMap, (m) => {
+		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);
+	return next ? {
+		line: next.generatedLine,
+		column: next.generatedColumn
+	} : {
+		line: null,
+		column: null
+	};
+}
+
 // use Logger with custom Console to capture entire error printing
 function capturePrintError(error, ctx, options) {
 	let output = "";
@@ -1105,12 +2509,12 @@ function capturePrintError(error, ctx, options) {
 	} }), console = new Console(writable), logger = {
 		error: console.error.bind(console),
 		highlight: ctx.logger.highlight.bind(ctx.logger)
-	}, result = printError(error, ctx, logger, {
-		showCodeFrame: false,
-		...options
-	});
+	};
 	return {
-		nearest: result?.nearest,
+		nearest: printError(error, ctx, logger, {
+			showCodeFrame: false,
+			...options
+		})?.nearest,
 		output
 	};
 }
@@ -1158,19 +2562,17 @@ function printErrorInner(error, project, options) {
 	const stacks = options.parseErrorStacktrace(e), nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find((stack) => {
 		// we are checking that this module was processed by us at one point
 		try {
-			const environments = [...Object.values(project._vite?.environments || {}), ...Object.values(project.browser?.vite.environments || {})], hasResult = environments.some((environment) => {
-				const modules = environment.moduleGraph.getModulesByFile(stack.file);
-				return [...modules?.values() || []].some((module) => !!module.transformResult);
-			});
-			return hasResult && existsSync(stack.file);
+			return [...Object.values(project._vite?.environments || {}), ...Object.values(project.browser?.vite.environments || {})].some((environment) => {
+				return [...environment.moduleGraph.getModulesByFile(stack.file)?.values() || []].some((module) => !!module.transformResult);
+			}) && existsSync(stack.file);
 		} catch {
 			return false;
 		}
 	});
 	if (type) printErrorType(type, project.vitest);
 	if (printErrorMessage(e, logger), options.screenshotPaths?.length) {
-		const length = options.screenshotPaths.length;
-		if (logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`), logger.error(options.screenshotPaths.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n")), !e.diff) logger.error();
+		const uniqueScreenshots = Array.from(new Set(options.screenshotPaths)), length = uniqueScreenshots.length;
+		if (logger.error(`\nFailure screenshot${length > 1 ? "s" : ""}:`), logger.error(uniqueScreenshots.map((p) => `  - ${c.dim(relative(process.cwd(), p))}`).join("\n")), !e.diff) logger.error();
 	}
 	if (e.codeFrame) logger.error(`${e.codeFrame}\n`);
 	if ("__vitest_rollup_error__" in e) {
@@ -1252,7 +2654,7 @@ function handleImportOutsideModuleError(stack, logger) {
 	if (!esmErrors.some((e) => stack.includes(e))) return;
 	const path = normalize(stack.split("\n")[0].trim());
 	let name = path.split("/node_modules/").pop() || "";
-	if (name?.startsWith("@")) name = name.split("/").slice(0, 2).join("/");
+	if (name[0] === "@") name = name.split("/").slice(0, 2).join("/");
 	else name = name.split("/")[0];
 	if (name) printModuleWarningForPackage(logger, path, name);
 	else printModuleWarningForSourceCode(logger, path);
@@ -1348,7 +2750,7 @@ class GithubActionsReporter {
 		this.ctx = ctx;
 	}
 	onTestCaseAnnotate(testCase, annotation) {
-		if (!annotation.location) return;
+		if (!annotation.location || this.options.displayAnnotations === false) return;
 		const type = getTitle(annotation.type), formatted = formatMessage({
 			command: getType(annotation.type),
 			properties: {
@@ -1409,7 +2811,7 @@ const BUILT_IN_TYPES = [
 	"warning"
 ];
 function getTitle(type) {
-	return BUILT_IN_TYPES.includes(type) ? void 0 : type;
+	if (!BUILT_IN_TYPES.includes(type)) return type;
 }
 function getType(type) {
 	return BUILT_IN_TYPES.includes(type) ? type : "notice";
@@ -1436,8 +2838,7 @@ function escapeProperty(s) {
 class HangingProcessReporter {
 	whyRunning;
 	onInit() {
-		const _require = createRequire(import.meta.url);
-		this.whyRunning = _require("why-is-node-running");
+		this.whyRunning = createRequire(import.meta.url)("why-is-node-running");
 	}
 	onProcessTimeout() {
 		this.whyRunning?.();
@@ -1525,7 +2926,7 @@ class JsonReporter {
 	async writeReport(report) {
 		const outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "json");
 		if (outputFile) {
-			const reportFile = resolve(this.ctx.config.root, outputFile), outputDirectory = dirname(reportFile);
+			const reportFile = resolve$1(this.ctx.config.root, outputFile), outputDirectory = dirname(reportFile);
 			if (!existsSync(outputDirectory)) await promises.mkdir(outputDirectory, { recursive: true });
 			await promises.writeFile(reportFile, report, "utf-8"), this.ctx.logger.log(`JSON report written to ${reportFile}`);
 		} else this.ctx.logger.log(report);
@@ -1594,11 +2995,10 @@ class JUnitReporter {
 		this.ctx = ctx;
 		const outputFile = this.options.outputFile ?? getOutputFile(this.ctx.config, "junit");
 		if (outputFile) {
-			this.reportFile = resolve(this.ctx.config.root, outputFile);
+			this.reportFile = resolve$1(this.ctx.config.root, outputFile);
 			const outputDirectory = dirname(this.reportFile);
 			if (!existsSync(outputDirectory)) await promises.mkdir(outputDirectory, { recursive: true });
-			const fileFd = await promises.open(this.reportFile, "w+");
-			this.fileFd = fileFd, this.baseLog = async (text) => {
+			this.fileFd = await promises.open(this.reportFile, "w+"), this.baseLog = async (text) => {
 				if (!this.fileFd) this.fileFd = await promises.open(this.reportFile, "w+");
 				await promises.writeFile(this.fileFd, `${text}\n`);
 			};
@@ -1761,7 +3161,7 @@ class TapReporter {
 					this.logger.log(`# ${type}: ${message}`);
 				}), this.logger.unindent();
 				if (task.result?.state === "fail" && task.result.errors) this.logger.indent(), task.result.errors.forEach((error) => {
-					const stacks = task.file.pool === "browser" ? project.browser?.parseErrorStacktrace(error) || [] : parseErrorStacktrace(error, { frameFilter: this.ctx.config.onStackTrace }), stack = stacks[0];
+					const stack = (task.file.pool === "browser" ? project.browser?.parseErrorStacktrace(error) || [] : parseErrorStacktrace(error, { frameFilter: this.ctx.config.onStackTrace }))[0];
 					if (this.logger.log("---"), this.logger.log("error:"), this.logger.indent(), this.logErrorDetails(error), this.logger.unindent(), stack) this.logger.log(`at: ${yamlString(`${stack.file}:${stack.line}:${stack.column}`)}`);
 					if (error.showDiff) this.logger.log(`actual: ${yamlString(error.actual)}`), this.logger.log(`expected: ${yamlString(error.expected)}`);
 				}), this.logger.log("..."), this.logger.unindent();
@@ -1792,48 +3192,26 @@ class TapFlatReporter extends TapReporter {
 	}
 }
 
+class TreeReporter extends DefaultReporter {
+	verbose = true;
+	renderSucceed = true;
+}
+
 class VerboseReporter extends DefaultReporter {
 	verbose = true;
 	renderSucceed = true;
-	printTestModule(module) {
-		// still print the test module in TTY,
-		// but don't print it in the CLI because we
-		// print all the tests when they finish
-		// instead of printing them when the test file finishes
-		if (this.isTTY) return super.printTestModule(module);
+	printTestModule(_module) {
+		// don't print test module, only print tests
 	}
 	onTestCaseResult(test) {
-		// don't print tests in TTY as they go, only print them
-		// in the CLI when they finish
-		if (super.onTestCaseResult(test), this.isTTY) return;
+		super.onTestCaseResult(test);
 		const testResult = test.result();
 		if (this.ctx.config.hideSkippedTests && testResult.state === "skipped") return;
-		let title = ` ${getStateSymbol(test.task)} `;
-		if (test.project.name) title += formatProjectName(test.project);
-		title += getFullName(test.task, c.dim(" > ")), title += this.getDurationPrefix(test.task);
-		const diagnostic = test.diagnostic();
-		if (diagnostic?.heap != null) title += c.magenta(` ${Math.floor(diagnostic.heap / 1024 / 1024)} MB heap used`);
-		if (testResult.state === "skipped" && testResult.note) title += c.dim(c.gray(` [${testResult.note}]`));
-		if (this.log(title), testResult.state === "failed") testResult.errors.forEach((error) => this.log(c.red(`   ${F_RIGHT} ${error?.message}`)));
+		let title = ` ${this.getEntityPrefix(test)} `;
+		if (title += test.module.task.name, test.location) title += c.dim(`:${test.location.line}:${test.location.column}`);
+		if (title += separator, title += getTestName(test.task, separator), title += this.getTestCaseSuffix(test), this.log(title), testResult.state === "failed") testResult.errors.forEach((error) => this.log(c.red(`   ${F_RIGHT} ${error.message}`)));
 		if (test.annotations().length) this.log(), this.printAnnotations(test, "log", 3), this.log();
 	}
-	printTestSuite(testSuite) {
-		const indentation = "  ".repeat(getIndentation(testSuite.task)), tests = Array.from(testSuite.children.allTests()), state = getStateSymbol(testSuite.task);
-		this.log(` ${indentation}${state} ${testSuite.name} ${c.dim(`(${tests.length})`)}`);
-	}
-	getTestName(test) {
-		return test.name;
-	}
-	getTestIndentation(test) {
-		return "  ".repeat(getIndentation(test));
-	}
-	formatShortError() {
-		// Short errors are not shown in tree-view
-		return "";
-	}
-}
-function getIndentation(suite, level = 1) {
-	return suite.suite && !("filepath" in suite.suite) ? getIndentation(suite.suite, level + 1) : level;
 }
 
 const ReportersMap = {
@@ -1845,8 +3223,9 @@ const ReportersMap = {
 	"tap": TapReporter,
 	"tap-flat": TapFlatReporter,
 	"junit": JUnitReporter,
+	"tree": TreeReporter,
 	"hanging-process": HangingProcessReporter,
 	"github-actions": GithubActionsReporter
 };
 
-export { BlobReporter as B, DefaultReporter as D, F_RIGHT as F, GithubActionsReporter as G, HangingProcessReporter as H, JsonReporter as J, ReportersMap as R, TapFlatReporter as T, VerboseReporter as V, DotReporter as a, JUnitReporter as b, TapReporter as c, printError as d, errorBanner as e, formatProjectName as f, getStateSymbol as g, divider as h, generateCodeFrame as i, parse as p, readBlobs as r, stringify as s, truncateString as t, utils as u, withLabel as w };
+export { BlobReporter as B, DefaultReporter as D, F_RIGHT as F, GithubActionsReporter as G, HangingProcessReporter as H, JsonReporter as J, ReportersMap as R, TapFlatReporter as T, VerboseReporter as V, DotReporter as a, JUnitReporter as b, TapReporter as c, stringify as d, TraceMap as e, formatProjectName as f, getStateSymbol as g, ancestor as h, printError as i, errorBanner as j, divider as k, Typechecker as l, generateCodeFrame as m, createDefinesScript as n, originalPositionFor as o, parse$1 as p, convertTasksToEvents as q, readBlobs as r, separator as s, truncateString as t, utils as u, withLabel as w };