vitest 0.0.77 → 0.0.81

package/dist/cli.js

@@ -1,13 +1,13 @@
 import require$$2, { EventEmitter } from 'events';
-import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, d as c, F as F_POINTER, e as F_DOWN, f as F_LONG_DASH, g as F_DOWN_RIGHT, h as F_DOT, i as F_CHECK, j as F_CROSS, k as cliTruncate, l as F_RIGHT, p as printError } from './error-c9295525.js';
-import { performance } from 'perf_hooks';
+import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, d as c, F as F_POINTER, e as F_DOWN, f as F_LONG_DASH, g as F_DOWN_RIGHT, h as F_DOT, i as F_CHECK, j as F_CROSS, k as cliTruncate, l as F_RIGHT, p as printError } from './error-6bb44a98.js';
 import path, { isAbsolute, relative, dirname, basename, resolve } from 'path';
-import { g as getNames, s as slash, a as getTests, b as getSuites, h as hasFailed } from './utils-9dcc4050.js';
 import process$2 from 'process';
-import require$$0 from 'assert';
 import { promises } from 'fs';
 import { createServer } from 'vite';
-import { d as defaultIncludes, a as defaultExcludes, b as defaultPort, c as configFiles, e as distDir } from './constants-2435fa16.js';
+import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as configFiles, e as distDir } from './constants-1268ea5c.js';
+import { performance } from 'perf_hooks';
+import { g as getNames, s as slash, a as getTests, b as getSuites, t as toArray, h as hasFailed } from './utils-9dcc4050.js';
+import require$$0 from 'assert';
 import { MessageChannel } from 'worker_threads';
 import { pathToFileURL } from 'url';
 import Piscina from 'piscina';
@@ -632,1483 +632,1516 @@ const cac = (name = "") => new CAC(name);
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var version = "0.0.77";
-
-const ESC = '\u001B[';
-const OSC = '\u001B]';
-const BEL = '\u0007';
-const SEP = ';';
-const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
+var version = "0.0.81";
 
-const ansiEscapes = {};
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
 
-ansiEscapes.cursorTo = (x, y) => {
-	if (typeof x !== 'number') {
-		throw new TypeError('The `x` argument is required');
-	}
+class Node {
+	value;
+	next;
 
-	if (typeof y !== 'number') {
-		return ESC + (x + 1) + 'G';
+	constructor(value) {
+		this.value = value;
 	}
+}
 
-	return ESC + (y + 1) + ';' + (x + 1) + 'H';
-};
+class Queue {
+	#head;
+	#tail;
+	#size;
 
-ansiEscapes.cursorMove = (x, y) => {
-	if (typeof x !== 'number') {
-		throw new TypeError('The `x` argument is required');
+	constructor() {
+		this.clear();
 	}
 
-	let returnValue = '';
+	enqueue(value) {
+		const node = new Node(value);
 
-	if (x < 0) {
-		returnValue += ESC + (-x) + 'D';
-	} else if (x > 0) {
-		returnValue += ESC + x + 'C';
-	}
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
 
-	if (y < 0) {
-		returnValue += ESC + (-y) + 'A';
-	} else if (y > 0) {
-		returnValue += ESC + y + 'B';
+		this.#size++;
 	}
 
-	return returnValue;
-};
-
-ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
-ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
-ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
-ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
-
-ansiEscapes.cursorLeft = ESC + 'G';
-ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
-ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
-ansiEscapes.cursorGetPosition = ESC + '6n';
-ansiEscapes.cursorNextLine = ESC + 'E';
-ansiEscapes.cursorPrevLine = ESC + 'F';
-ansiEscapes.cursorHide = ESC + '?25l';
-ansiEscapes.cursorShow = ESC + '?25h';
+	dequeue() {
+		const current = this.#head;
+		if (!current) {
+			return;
+		}
 
-ansiEscapes.eraseLines = count => {
-	let clear = '';
+		this.#head = this.#head.next;
+		this.#size--;
+		return current.value;
+	}
 
-	for (let i = 0; i < count; i++) {
-		clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
+	clear() {
+		this.#head = undefined;
+		this.#tail = undefined;
+		this.#size = 0;
 	}
 
-	if (count) {
-		clear += ansiEscapes.cursorLeft;
+	get size() {
+		return this.#size;
 	}
 
-	return clear;
-};
+	* [Symbol.iterator]() {
+		let current = this.#head;
 
-ansiEscapes.eraseEndLine = ESC + 'K';
-ansiEscapes.eraseStartLine = ESC + '1K';
-ansiEscapes.eraseLine = ESC + '2K';
-ansiEscapes.eraseDown = ESC + 'J';
-ansiEscapes.eraseUp = ESC + '1J';
-ansiEscapes.eraseScreen = ESC + '2J';
-ansiEscapes.scrollUp = ESC + 'S';
-ansiEscapes.scrollDown = ESC + 'T';
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+}
 
-ansiEscapes.clearScreen = '\u001Bc';
+function pLimit(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
 
-ansiEscapes.clearTerminal = process.platform === 'win32' ?
-	`${ansiEscapes.eraseScreen}${ESC}0f` :
-	// 1. Erases the screen (Only done in case `2` is not supported)
-	// 2. Erases the whole screen including scrollback buffer
-	// 3. Moves cursor to the top-left position
-	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
-	`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
+	const queue = new Queue();
+	let activeCount = 0;
 
-ansiEscapes.beep = BEL;
+	const next = () => {
+		activeCount--;
 
-ansiEscapes.link = (text, url) => {
-	return [
-		OSC,
-		'8',
-		SEP,
-		SEP,
-		url,
-		BEL,
-		text,
-		OSC,
-		'8',
-		SEP,
-		SEP,
-		BEL
-	].join('');
-};
+		if (queue.size > 0) {
+			queue.dequeue()();
+		}
+	};
 
-ansiEscapes.image = (buffer, options = {}) => {
-	let returnValue = `${OSC}1337;File=inline=1`;
+	const run = async (fn, resolve, args) => {
+		activeCount++;
 
-	if (options.width) {
-		returnValue += `;width=${options.width}`;
-	}
+		const result = (async () => fn(...args))();
 
-	if (options.height) {
-		returnValue += `;height=${options.height}`;
-	}
+		resolve(result);
 
-	if (options.preserveAspectRatio === false) {
-		returnValue += ';preserveAspectRatio=0';
-	}
+		try {
+			await result;
+		} catch {}
 
-	return returnValue + ':' + buffer.toString('base64') + BEL;
-};
+		next();
+	};
 
-ansiEscapes.iTerm = {
-	setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
+	const enqueue = (fn, resolve, args) => {
+		queue.enqueue(run.bind(undefined, fn, resolve, args));
 
-	annotation: (message, options = {}) => {
-		let returnValue = `${OSC}1337;`;
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
 
-		const hasX = typeof options.x !== 'undefined';
-		const hasY = typeof options.y !== 'undefined';
-		if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== 'undefined')) {
-			throw new Error('`x`, `y` and `length` must be defined when `x` or `y` is defined');
-		}
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
+	};
 
-		message = message.replace(/\|/g, '');
+	const generator = (fn, ...args) => new Promise(resolve => {
+		enqueue(fn, resolve, args);
+	});
 
-		returnValue += options.isHidden ? 'AddHiddenAnnotation=' : 'AddAnnotation=';
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount,
+		},
+		pendingCount: {
+			get: () => queue.size,
+		},
+		clearQueue: {
+			value: () => {
+				queue.clear();
+			},
+		},
+	});
 
-		if (options.length > 0) {
-			returnValue +=
-					(hasX ?
-						[message, options.length, options.x, options.y] :
-						[options.length, message]).join('|');
-		} else {
-			returnValue += message;
-		}
+	return generator;
+}
 
-		return returnValue + BEL;
+class EndError extends Error {
+	constructor(value) {
+		super();
+		this.value = value;
 	}
-};
-
-var onetime$2 = {exports: {}};
+}
 
-var mimicFn$2 = {exports: {}};
+// The input can also be a promise, so we await it.
+const testElement = async (element, tester) => tester(await element);
 
-const mimicFn$1 = (to, from) => {
-	for (const prop of Reflect.ownKeys(from)) {
-		Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
+// The input can also be a promise, so we `Promise.all()` them both.
+const finder = async element => {
+	const values = await Promise.all(element);
+	if (values[1] === true) {
+		throw new EndError(values[0]);
 	}
 
-	return to;
+	return false;
 };
 
-mimicFn$2.exports = mimicFn$1;
-// TODO: Remove this for the next major release
-mimicFn$2.exports.default = mimicFn$1;
+async function pLocate(
+	iterable,
+	tester,
+	{
+		concurrency = Number.POSITIVE_INFINITY,
+		preserveOrder = true,
+	} = {},
+) {
+	const limit = pLimit(concurrency);
 
-const mimicFn = mimicFn$2.exports;
-
-const calledFunctions = new WeakMap();
-
-const onetime = (function_, options = {}) => {
-	if (typeof function_ !== 'function') {
-		throw new TypeError('Expected a function');
-	}
-
-	let returnValue;
-	let callCount = 0;
-	const functionName = function_.displayName || function_.name || '<anonymous>';
+	// Start all the promises concurrently with optional limit.
+	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
 
-	const onetime = function (...arguments_) {
-		calledFunctions.set(onetime, ++callCount);
+	// Check the promises either serially or concurrently.
+	const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
 
-		if (callCount === 1) {
-			returnValue = function_.apply(this, arguments_);
-			function_ = null;
-		} else if (options.throw === true) {
-			throw new Error(`Function \`${functionName}\` can only be called once`);
+	try {
+		await Promise.all(items.map(element => checkLimit(finder, element)));
+	} catch (error) {
+		if (error instanceof EndError) {
+			return error.value;
 		}
 
-		return returnValue;
-	};
-
-	mimicFn(onetime, function_);
-	calledFunctions.set(onetime, callCount);
-
-	return onetime;
-};
-
-onetime$2.exports = onetime;
-// TODO: Remove this for the next major release
-onetime$2.exports.default = onetime;
-
-onetime$2.exports.callCount = function_ => {
-	if (!calledFunctions.has(function_)) {
-		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+		throw error;
 	}
+}
 
-	return calledFunctions.get(function_);
+const typeMappings = {
+	directory: 'isDirectory',
+	file: 'isFile',
 };
 
-var onetime$1 = onetime$2.exports;
+function checkType(type) {
+	if (type in typeMappings) {
+		return;
+	}
 
-var signalExit$1 = {exports: {}};
+	throw new Error(`Invalid type specified: ${type}`);
+}
 
-var signals$1 = {exports: {}};
+const matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();
 
-(function (module) {
-// This is not the set of all possible signals.
-//
-// It IS, however, the set of all signals that trigger
-// an exit on either Linux or BSD systems.  Linux is a
-// superset of the signal names supported on BSD, and
-// the unknown signals just fail to register, so we can
-// catch that easily enough.
-//
-// Don't bother with SIGKILL.  It's uncatchable, which
-// means that we can't fire any callbacks anyway.
-//
-// If a user does happen to register a handler on a non-
-// fatal signal like SIGWINCH or something, and then
-// exit, it'll end up firing `process.emit('exit')`, so
-// the handler will be fired anyway.
-//
-// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
-// artificially, inherently leave the process in a
-// state from which it is not safe to try and enter JS
-// listeners.
-module.exports = [
-  'SIGABRT',
-  'SIGALRM',
-  'SIGHUP',
-  'SIGINT',
-  'SIGTERM'
-];
+async function locatePath(
+	paths,
+	{
+		cwd = process$2.cwd(),
+		type = 'file',
+		allowSymlinks = true,
+		concurrency,
+		preserveOrder,
+	} = {},
+) {
+	checkType(type);
 
-if (process.platform !== 'win32') {
-  module.exports.push(
-    'SIGVTALRM',
-    'SIGXCPU',
-    'SIGXFSZ',
-    'SIGUSR2',
-    'SIGTRAP',
-    'SIGSYS',
-    'SIGQUIT',
-    'SIGIOT'
-    // should detect profiler and enable/disable accordingly.
-    // see #21
-    // 'SIGPROF'
-  );
-}
+	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
 
-if (process.platform === 'linux') {
-  module.exports.push(
-    'SIGIO',
-    'SIGPOLL',
-    'SIGPWR',
-    'SIGSTKFLT',
-    'SIGUNUSED'
-  );
+	return pLocate(paths, async path_ => {
+		try {
+			const stat = await statFunction(path.resolve(cwd, path_));
+			return matchType(type, stat);
+		} catch {
+			return false;
+		}
+	}, {concurrency, preserveOrder});
 }
-}(signals$1));
-
-// Note: since nyc uses this module to output coverage, any lines
-// that are in the direct sync flow of nyc's outputCoverage are
-// ignored, since we can never get coverage for them.
-// grab a reference to node's real process object right away
-var process$1 = commonjsGlobal.process;
 
-const processOk = function (process) {
-  return process &&
-    typeof process === 'object' &&
-    typeof process.removeListener === 'function' &&
-    typeof process.emit === 'function' &&
-    typeof process.reallyExit === 'function' &&
-    typeof process.listeners === 'function' &&
-    typeof process.kill === 'function' &&
-    typeof process.pid === 'number' &&
-    typeof process.on === 'function'
-};
+const findUpStop = Symbol('findUpStop');
 
-// some kind of non-node environment, just no-op
-/* istanbul ignore if */
-if (!processOk(process$1)) {
-  signalExit$1.exports = function () {};
-} else {
-  var assert = require$$0;
-  var signals = signals$1.exports;
-  var isWin = /^win/i.test(process$1.platform);
+async function findUpMultiple(name, options = {}) {
+	let directory = path.resolve(options.cwd || '');
+	const {root} = path.parse(directory);
+	const stopAt = path.resolve(directory, options.stopAt || root);
+	const limit = options.limit || Number.POSITIVE_INFINITY;
+	const paths = [name].flat();
 
-  var EE = require$$2;
-  /* istanbul ignore if */
-  if (typeof EE !== 'function') {
-    EE = EE.EventEmitter;
-  }
+	const runMatcher = async locateOptions => {
+		if (typeof name !== 'function') {
+			return locatePath(paths, locateOptions);
+		}
 
-  var emitter;
-  if (process$1.__signal_exit_emitter__) {
-    emitter = process$1.__signal_exit_emitter__;
-  } else {
-    emitter = process$1.__signal_exit_emitter__ = new EE();
-    emitter.count = 0;
-    emitter.emitted = {};
-  }
+		const foundPath = await name(locateOptions.cwd);
+		if (typeof foundPath === 'string') {
+			return locatePath([foundPath], locateOptions);
+		}
 
-  // Because this emitter is a global, we have to check to see if a
-  // previous version of this library failed to enable infinite listeners.
-  // I know what you're about to say.  But literally everything about
-  // signal-exit is a compromise with evil.  Get used to it.
-  if (!emitter.infinite) {
-    emitter.setMaxListeners(Infinity);
-    emitter.infinite = true;
-  }
+		return foundPath;
+	};
 
-  signalExit$1.exports = function (cb, opts) {
-    /* istanbul ignore if */
-    if (!processOk(commonjsGlobal.process)) {
-      return
-    }
-    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+	const matches = [];
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		// eslint-disable-next-line no-await-in-loop
+		const foundPath = await runMatcher({...options, cwd: directory});
 
-    if (loaded === false) {
-      load();
-    }
+		if (foundPath === findUpStop) {
+			break;
+		}
 
-    var ev = 'exit';
-    if (opts && opts.alwaysLast) {
-      ev = 'afterexit';
-    }
+		if (foundPath) {
+			matches.push(path.resolve(directory, foundPath));
+		}
 
-    var remove = function () {
-      emitter.removeListener(ev, cb);
-      if (emitter.listeners('exit').length === 0 &&
-          emitter.listeners('afterexit').length === 0) {
-        unload();
-      }
-    };
-    emitter.on(ev, cb);
+		if (directory === stopAt || matches.length >= limit) {
+			break;
+		}
 
-    return remove
-  };
+		directory = path.dirname(directory);
+	}
 
-  var unload = function unload () {
-    if (!loaded || !processOk(commonjsGlobal.process)) {
-      return
-    }
-    loaded = false;
+	return matches;
+}
 
-    signals.forEach(function (sig) {
-      try {
-        process$1.removeListener(sig, sigListeners[sig]);
-      } catch (er) {}
-    });
-    process$1.emit = originalProcessEmit;
-    process$1.reallyExit = originalProcessReallyExit;
-    emitter.count -= 1;
-  };
-  signalExit$1.exports.unload = unload;
+async function findUp(name, options = {}) {
+	const matches = await findUpMultiple(name, {...options, limit: 1});
+	return matches[0];
+}
 
-  var emit = function emit (event, code, signal) {
-    /* istanbul ignore if */
-    if (emitter.emitted[event]) {
-      return
-    }
-    emitter.emitted[event] = true;
-    emitter.emit(event, code, signal);
-  };
-
-  // { <signal>: <listener fn>, ... }
-  var sigListeners = {};
-  signals.forEach(function (sig) {
-    sigListeners[sig] = function listener () {
-      /* istanbul ignore if */
-      if (!processOk(commonjsGlobal.process)) {
-        return
-      }
-      // If there are no other listeners, an exit is coming!
-      // Simplest way: remove us and then re-send the signal.
-      // We know that this will kill the process, so we can
-      // safely emit now.
-      var listeners = process$1.listeners(sig);
-      if (listeners.length === emitter.count) {
-        unload();
-        emit('exit', null, sig);
-        /* istanbul ignore next */
-        emit('afterexit', null, sig);
-        /* istanbul ignore next */
-        if (isWin && sig === 'SIGHUP') {
-          // "SIGHUP" throws an `ENOSYS` error on Windows,
-          // so use a supported signal instead
-          sig = 'SIGINT';
-        }
-        /* istanbul ignore next */
-        process$1.kill(process$1.pid, sig);
-      }
-    };
-  });
-
-  signalExit$1.exports.signals = function () {
-    return signals
+class SnapshotManager {
+  constructor(config) {
+    this.config = config;
+    this.summary = void 0;
+    this.clear();
+  }
+  clear() {
+    this.summary = emptySummary(this.config.snapshotOptions);
+  }
+  add(result) {
+    addSnapshotResult(this.summary, result);
+  }
+}
+function emptySummary(options) {
+  const summary = {
+    added: 0,
+    failure: false,
+    filesAdded: 0,
+    filesRemoved: 0,
+    filesRemovedList: [],
+    filesUnmatched: 0,
+    filesUpdated: 0,
+    matched: 0,
+    total: 0,
+    unchecked: 0,
+    uncheckedKeysByFile: [],
+    unmatched: 0,
+    updated: 0,
+    didUpdate: options.updateSnapshot === "all"
   };
-
-  var loaded = false;
-
-  var load = function load () {
-    if (loaded || !processOk(commonjsGlobal.process)) {
-      return
-    }
-    loaded = true;
-
-    // This is the number of onSignalExit's that are in play.
-    // It's important so that we can count the correct number of
-    // listeners on signals, and don't wait for the other one to
-    // handle it instead of us.
-    emitter.count += 1;
-
-    signals = signals.filter(function (sig) {
-      try {
-        process$1.on(sig, sigListeners[sig]);
-        return true
-      } catch (er) {
-        return false
-      }
+  return summary;
+}
+function addSnapshotResult(summary, result) {
+  if (result.added)
+    summary.filesAdded++;
+  if (result.fileDeleted)
+    summary.filesRemoved++;
+  if (result.unmatched)
+    summary.filesUnmatched++;
+  if (result.updated)
+    summary.filesUpdated++;
+  summary.added += result.added;
+  summary.matched += result.matched;
+  summary.unchecked += result.unchecked;
+  if (result.uncheckedKeys && result.uncheckedKeys.length > 0) {
+    summary.uncheckedKeysByFile.push({
+      filePath: result.filepath,
+      keys: result.uncheckedKeys
     });
-
-    process$1.emit = processEmit;
-    process$1.reallyExit = processReallyExit;
-  };
-  signalExit$1.exports.load = load;
-
-  var originalProcessReallyExit = process$1.reallyExit;
-  var processReallyExit = function processReallyExit (code) {
-    /* istanbul ignore if */
-    if (!processOk(commonjsGlobal.process)) {
-      return
-    }
-    process$1.exitCode = code || /* istanbul ignore next */ 0;
-    emit('exit', process$1.exitCode, null);
-    /* istanbul ignore next */
-    emit('afterexit', process$1.exitCode, null);
-    /* istanbul ignore next */
-    originalProcessReallyExit.call(process$1, process$1.exitCode);
-  };
-
-  var originalProcessEmit = process$1.emit;
-  var processEmit = function processEmit (ev, arg) {
-    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
-      /* istanbul ignore else */
-      if (arg !== undefined) {
-        process$1.exitCode = arg;
-      }
-      var ret = originalProcessEmit.apply(this, arguments);
-      /* istanbul ignore next */
-      emit('exit', process$1.exitCode, null);
-      /* istanbul ignore next */
-      emit('afterexit', process$1.exitCode, null);
-      /* istanbul ignore next */
-      return ret
-    } else {
-      return originalProcessEmit.apply(this, arguments)
-    }
-  };
+  }
+  summary.unmatched += result.unmatched;
+  summary.updated += result.updated;
+  summary.total += result.added + result.matched + result.unmatched + result.updated;
 }
 
-var signalExit = signalExit$1.exports;
-
-const restoreCursor = onetime$1(() => {
-	signalExit(() => {
-		process$2.stderr.write('\u001B[?25h');
-	}, {alwaysLast: true});
-});
+const ESC = '\u001B[';
+const OSC = '\u001B]';
+const BEL = '\u0007';
+const SEP = ';';
+const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
 
-let isHidden = false;
+const ansiEscapes = {};
 
-const cliCursor = {};
+ansiEscapes.cursorTo = (x, y) => {
+	if (typeof x !== 'number') {
+		throw new TypeError('The `x` argument is required');
+	}
 
-cliCursor.show = (writableStream = process$2.stderr) => {
-	if (!writableStream.isTTY) {
-		return;
+	if (typeof y !== 'number') {
+		return ESC + (x + 1) + 'G';
 	}
 
-	isHidden = false;
-	writableStream.write('\u001B[?25h');
+	return ESC + (y + 1) + ';' + (x + 1) + 'H';
 };
 
-cliCursor.hide = (writableStream = process$2.stderr) => {
-	if (!writableStream.isTTY) {
-		return;
+ansiEscapes.cursorMove = (x, y) => {
+	if (typeof x !== 'number') {
+		throw new TypeError('The `x` argument is required');
 	}
 
-	restoreCursor();
-	isHidden = true;
-	writableStream.write('\u001B[?25l');
-};
+	let returnValue = '';
 
-cliCursor.toggle = (force, writableStream) => {
-	if (force !== undefined) {
-		isHidden = force;
+	if (x < 0) {
+		returnValue += ESC + (-x) + 'D';
+	} else if (x > 0) {
+		returnValue += ESC + x + 'C';
 	}
 
-	if (isHidden) {
-		cliCursor.show(writableStream);
-	} else {
-		cliCursor.hide(writableStream);
+	if (y < 0) {
+		returnValue += ESC + (-y) + 'A';
+	} else if (y > 0) {
+		returnValue += ESC + y + 'B';
 	}
-};
 
-const ESCAPES = new Set([
-	'\u001B',
-	'\u009B',
-]);
+	return returnValue;
+};
 
-const END_CODE = 39;
-const ANSI_ESCAPE_BELL = '\u0007';
-const ANSI_CSI = '[';
-const ANSI_OSC = ']';
-const ANSI_SGR_TERMINATOR = 'm';
-const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
+ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
+ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
+ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
 
-const wrapAnsiCode = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
-const wrapAnsiHyperlink = uri => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
+ansiEscapes.cursorLeft = ESC + 'G';
+ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
+ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
+ansiEscapes.cursorGetPosition = ESC + '6n';
+ansiEscapes.cursorNextLine = ESC + 'E';
+ansiEscapes.cursorPrevLine = ESC + 'F';
+ansiEscapes.cursorHide = ESC + '?25l';
+ansiEscapes.cursorShow = ESC + '?25h';
 
-// Calculate the length of words split on ' ', ignoring
-// the extra characters added by ansi escape codes
-const wordLengths = string => string.split(' ').map(character => stringWidth(character));
+ansiEscapes.eraseLines = count => {
+	let clear = '';
 
-// Wrap a long word across multiple rows
-// Ansi escape codes do not count towards length
-const wrapWord = (rows, word, columns) => {
-	const characters = [...word];
+	for (let i = 0; i < count; i++) {
+		clear += ansiEscapes.eraseLine + (i < count - 1 ? ansiEscapes.cursorUp() : '');
+	}
 
-	let isInsideEscape = false;
-	let isInsideLinkEscape = false;
-	let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
+	if (count) {
+		clear += ansiEscapes.cursorLeft;
+	}
 
-	for (const [index, character] of characters.entries()) {
-		const characterLength = stringWidth(character);
+	return clear;
+};
 
-		if (visible + characterLength <= columns) {
-			rows[rows.length - 1] += character;
-		} else {
-			rows.push(character);
-			visible = 0;
-		}
-
-		if (ESCAPES.has(character)) {
-			isInsideEscape = true;
-			isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
-		}
-
-		if (isInsideEscape) {
-			if (isInsideLinkEscape) {
-				if (character === ANSI_ESCAPE_BELL) {
-					isInsideEscape = false;
-					isInsideLinkEscape = false;
-				}
-			} else if (character === ANSI_SGR_TERMINATOR) {
-				isInsideEscape = false;
-			}
+ansiEscapes.eraseEndLine = ESC + 'K';
+ansiEscapes.eraseStartLine = ESC + '1K';
+ansiEscapes.eraseLine = ESC + '2K';
+ansiEscapes.eraseDown = ESC + 'J';
+ansiEscapes.eraseUp = ESC + '1J';
+ansiEscapes.eraseScreen = ESC + '2J';
+ansiEscapes.scrollUp = ESC + 'S';
+ansiEscapes.scrollDown = ESC + 'T';
 
-			continue;
-		}
+ansiEscapes.clearScreen = '\u001Bc';
 
-		visible += characterLength;
+ansiEscapes.clearTerminal = process.platform === 'win32' ?
+	`${ansiEscapes.eraseScreen}${ESC}0f` :
+	// 1. Erases the screen (Only done in case `2` is not supported)
+	// 2. Erases the whole screen including scrollback buffer
+	// 3. Moves cursor to the top-left position
+	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
+	`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
 
-		if (visible === columns && index < characters.length - 1) {
-			rows.push('');
-			visible = 0;
-		}
-	}
+ansiEscapes.beep = BEL;
 
-	// It's possible that the last row we copy over is only
-	// ansi escape characters, handle this edge-case
-	if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
-		rows[rows.length - 2] += rows.pop();
-	}
+ansiEscapes.link = (text, url) => {
+	return [
+		OSC,
+		'8',
+		SEP,
+		SEP,
+		url,
+		BEL,
+		text,
+		OSC,
+		'8',
+		SEP,
+		SEP,
+		BEL
+	].join('');
 };
 
-// Trims spaces from a string ignoring invisible sequences
-const stringVisibleTrimSpacesRight = string => {
-	const words = string.split(' ');
-	let last = words.length;
+ansiEscapes.image = (buffer, options = {}) => {
+	let returnValue = `${OSC}1337;File=inline=1`;
 
-	while (last > 0) {
-		if (stringWidth(words[last - 1]) > 0) {
-			break;
-		}
+	if (options.width) {
+		returnValue += `;width=${options.width}`;
+	}
 
-		last--;
+	if (options.height) {
+		returnValue += `;height=${options.height}`;
 	}
 
-	if (last === words.length) {
-		return string;
+	if (options.preserveAspectRatio === false) {
+		returnValue += ';preserveAspectRatio=0';
 	}
 
-	return words.slice(0, last).join(' ') + words.slice(last).join('');
+	return returnValue + ':' + buffer.toString('base64') + BEL;
 };
 
-// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode
-//
-// 'hard' will never allow a string to take up more than columns characters
-//
-// 'soft' allows long words to expand past the column length
-const exec = (string, columns, options = {}) => {
-	if (options.trim !== false && string.trim() === '') {
-		return '';
-	}
-
-	let returnValue = '';
-	let escapeCode;
-	let escapeUrl;
+ansiEscapes.iTerm = {
+	setCwd: (cwd = process.cwd()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
 
-	const lengths = wordLengths(string);
-	let rows = [''];
+	annotation: (message, options = {}) => {
+		let returnValue = `${OSC}1337;`;
 
-	for (const [index, word] of string.split(' ').entries()) {
-		if (options.trim !== false) {
-			rows[rows.length - 1] = rows[rows.length - 1].trimStart();
+		const hasX = typeof options.x !== 'undefined';
+		const hasY = typeof options.y !== 'undefined';
+		if ((hasX || hasY) && !(hasX && hasY && typeof options.length !== 'undefined')) {
+			throw new Error('`x`, `y` and `length` must be defined when `x` or `y` is defined');
 		}
 
-		let rowLength = stringWidth(rows[rows.length - 1]);
-
-		if (index !== 0) {
-			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
-				// If we start with a new word but the current row length equals the length of the columns, add a new row
-				rows.push('');
-				rowLength = 0;
-			}
-
-			if (rowLength > 0 || options.trim === false) {
-				rows[rows.length - 1] += ' ';
-				rowLength++;
-			}
-		}
+		message = message.replace(/\|/g, '');
 
-		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
-		if (options.hard && lengths[index] > columns) {
-			const remainingColumns = (columns - rowLength);
-			const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
-			const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
-			if (breaksStartingNextLine < breaksStartingThisLine) {
-				rows.push('');
-			}
+		returnValue += options.isHidden ? 'AddHiddenAnnotation=' : 'AddAnnotation=';
 
-			wrapWord(rows, word, columns);
-			continue;
+		if (options.length > 0) {
+			returnValue +=
+					(hasX ?
+						[message, options.length, options.x, options.y] :
+						[options.length, message]).join('|');
+		} else {
+			returnValue += message;
 		}
 
-		if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
-			if (options.wordWrap === false && rowLength < columns) {
-				wrapWord(rows, word, columns);
-				continue;
-			}
+		return returnValue + BEL;
+	}
+};
 
-			rows.push('');
-		}
+var onetime$2 = {exports: {}};
 
-		if (rowLength + lengths[index] > columns && options.wordWrap === false) {
-			wrapWord(rows, word, columns);
-			continue;
-		}
+var mimicFn$2 = {exports: {}};
 
-		rows[rows.length - 1] += word;
+const mimicFn$1 = (to, from) => {
+	for (const prop of Reflect.ownKeys(from)) {
+		Object.defineProperty(to, prop, Object.getOwnPropertyDescriptor(from, prop));
 	}
 
-	if (options.trim !== false) {
-		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
-	}
+	return to;
+};
 
-	const pre = [...rows.join('\n')];
+mimicFn$2.exports = mimicFn$1;
+// TODO: Remove this for the next major release
+mimicFn$2.exports.default = mimicFn$1;
 
-	for (const [index, character] of pre.entries()) {
-		returnValue += character;
+const mimicFn = mimicFn$2.exports;
 
-		if (ESCAPES.has(character)) {
-			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
-			if (groups.code !== undefined) {
-				const code = Number.parseFloat(groups.code);
-				escapeCode = code === END_CODE ? undefined : code;
-			} else if (groups.uri !== undefined) {
-				escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
-			}
-		}
+const calledFunctions = new WeakMap();
 
-		const code = ansiStyles.codes.get(Number(escapeCode));
+const onetime = (function_, options = {}) => {
+	if (typeof function_ !== 'function') {
+		throw new TypeError('Expected a function');
+	}
 
-		if (pre[index + 1] === '\n') {
-			if (escapeUrl) {
-				returnValue += wrapAnsiHyperlink('');
-			}
+	let returnValue;
+	let callCount = 0;
+	const functionName = function_.displayName || function_.name || '<anonymous>';
 
-			if (escapeCode && code) {
-				returnValue += wrapAnsiCode(code);
-			}
-		} else if (character === '\n') {
-			if (escapeCode && code) {
-				returnValue += wrapAnsiCode(escapeCode);
-			}
+	const onetime = function (...arguments_) {
+		calledFunctions.set(onetime, ++callCount);
 
-			if (escapeUrl) {
-				returnValue += wrapAnsiHyperlink(escapeUrl);
-			}
+		if (callCount === 1) {
+			returnValue = function_.apply(this, arguments_);
+			function_ = null;
+		} else if (options.throw === true) {
+			throw new Error(`Function \`${functionName}\` can only be called once`);
 		}
-	}
 
-	return returnValue;
-};
+		return returnValue;
+	};
 
-// For each newline, invoke the method separately
-function wrapAnsi(string, columns, options) {
-	return String(string)
-		.normalize()
-		.replace(/\r\n/g, '\n')
-		.split('\n')
-		.map(line => exec(line, columns, options))
-		.join('\n');
-}
+	mimicFn(onetime, function_);
+	calledFunctions.set(onetime, callCount);
 
-const defaultTerminalHeight = 24;
+	return onetime;
+};
 
-const getWidth = stream => {
-	const {columns} = stream;
+onetime$2.exports = onetime;
+// TODO: Remove this for the next major release
+onetime$2.exports.default = onetime;
 
-	if (!columns) {
-		return 80;
+onetime$2.exports.callCount = function_ => {
+	if (!calledFunctions.has(function_)) {
+		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
 	}
 
-	return columns;
+	return calledFunctions.get(function_);
 };
 
-const fitToTerminalHeight = (stream, text) => {
-	const terminalHeight = stream.rows || defaultTerminalHeight;
-	const lines = text.split('\n');
+var onetime$1 = onetime$2.exports;
 
-	const toRemove = lines.length - terminalHeight;
-	if (toRemove <= 0) {
-		return text;
-	}
+var signalExit$1 = {exports: {}};
 
-	return sliceAnsi(
-		text,
-		lines.slice(0, toRemove).join('\n').length + 1,
-		text.length);
-};
-
-function createLogUpdate(stream, {showCursor = false} = {}) {
-	let previousLineCount = 0;
-	let previousWidth = getWidth(stream);
-	let previousOutput = '';
-
-	const render = (...arguments_) => {
-		if (!showCursor) {
-			cliCursor.hide();
-		}
-
-		let output = arguments_.join(' ') + '\n';
-		output = fitToTerminalHeight(stream, output);
-		const width = getWidth(stream);
-		if (output === previousOutput && previousWidth === width) {
-			return;
-		}
-
-		previousOutput = output;
-		previousWidth = width;
-		output = wrapAnsi(output, width, {
-			trim: false,
-			hard: true,
-			wordWrap: false,
-		});
-		stream.write(ansiEscapes.eraseLines(previousLineCount) + output);
-		previousLineCount = output.split('\n').length;
-	};
-
-	render.clear = () => {
-		stream.write(ansiEscapes.eraseLines(previousLineCount));
-		previousOutput = '';
-		previousWidth = getWidth(stream);
-		previousLineCount = 0;
-	};
+var signals$1 = {exports: {}};
 
-	render.done = () => {
-		previousOutput = '';
-		previousWidth = getWidth(stream);
-		previousLineCount = 0;
+(function (module) {
+// This is not the set of all possible signals.
+//
+// It IS, however, the set of all signals that trigger
+// an exit on either Linux or BSD systems.  Linux is a
+// superset of the signal names supported on BSD, and
+// the unknown signals just fail to register, so we can
+// catch that easily enough.
+//
+// Don't bother with SIGKILL.  It's uncatchable, which
+// means that we can't fire any callbacks anyway.
+//
+// If a user does happen to register a handler on a non-
+// fatal signal like SIGWINCH or something, and then
+// exit, it'll end up firing `process.emit('exit')`, so
+// the handler will be fired anyway.
+//
+// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
+// artificially, inherently leave the process in a
+// state from which it is not safe to try and enter JS
+// listeners.
+module.exports = [
+  'SIGABRT',
+  'SIGALRM',
+  'SIGHUP',
+  'SIGINT',
+  'SIGTERM'
+];
 
-		if (!showCursor) {
-			cliCursor.show();
-		}
-	};
+if (process.platform !== 'win32') {
+  module.exports.push(
+    'SIGVTALRM',
+    'SIGXCPU',
+    'SIGXFSZ',
+    'SIGUSR2',
+    'SIGTRAP',
+    'SIGSYS',
+    'SIGQUIT',
+    'SIGIOT'
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
 
-	return render;
+if (process.platform === 'linux') {
+  module.exports.push(
+    'SIGIO',
+    'SIGPOLL',
+    'SIGPWR',
+    'SIGSTKFLT',
+    'SIGUNUSED'
+  );
 }
+}(signals$1));
 
-createLogUpdate(process$2.stdout);
+// Note: since nyc uses this module to output coverage, any lines
+// that are in the direct sync flow of nyc's outputCoverage are
+// ignored, since we can never get coverage for them.
+// grab a reference to node's real process object right away
+var process$1 = commonjsGlobal.process;
 
-createLogUpdate(process$2.stderr);
+const processOk = function (process) {
+  return process &&
+    typeof process === 'object' &&
+    typeof process.removeListener === 'function' &&
+    typeof process.emit === 'function' &&
+    typeof process.reallyExit === 'function' &&
+    typeof process.listeners === 'function' &&
+    typeof process.kill === 'function' &&
+    typeof process.pid === 'number' &&
+    typeof process.on === 'function'
+};
 
-const DURATION_LONG = 300;
-const MAX_HEIGHT = 20;
-const spinnerMap = new WeakMap();
-const outputMap = new WeakMap();
-const pointer = c.yellow(F_POINTER);
-const skipped = c.yellow(F_DOWN);
-function divider(text, left, right) {
-  let length = process.stdout.columns;
-  if (!length || isNaN(length))
-    length = 10;
-  if (text) {
-    const textLength = stripAnsi(text).length;
-    if (left == null && right != null) {
-      left = length - textLength - right;
-    } else {
-      left = left ?? Math.floor((length - textLength) / 2);
-      right = length - textLength - left;
-    }
-    left = Math.max(0, left);
-    right = Math.max(0, right);
-    return `${F_LONG_DASH.repeat(left)}${text}${F_LONG_DASH.repeat(right)}`;
-  }
-  return F_LONG_DASH.repeat(length);
-}
-function formatTestPath(root, path) {
-  var _a;
-  if (isAbsolute(path))
-    path = relative(root, path);
-  const dir = dirname(path);
-  const ext = ((_a = path.match(/(\.(spec|test)\.[cm]?[tj]sx?)$/)) == null ? void 0 : _a[0]) || "";
-  const base = basename(path, ext);
-  return slash(c.dim(`${dir}/`) + c.bold(base)) + c.dim(ext);
-}
-function renderSnapshotSummary(rootDir, snapshots) {
-  const summary = [];
-  if (snapshots.added)
-    summary.push(c.bold(c.green(`${snapshots.added} written`)));
-  if (snapshots.unmatched)
-    summary.push(c.bold(c.red(`${snapshots.unmatched} failed`)));
-  if (snapshots.updated)
-    summary.push(c.bold(c.green(`${snapshots.updated} updated `)));
-  if (snapshots.filesRemoved) {
-    if (snapshots.didUpdate)
-      summary.push(c.bold(c.green(`${snapshots.filesRemoved} files removed `)));
-    else
-      summary.push(c.bold(c.yellow(`${snapshots.filesRemoved} files obsolete `)));
+// some kind of non-node environment, just no-op
+/* istanbul ignore if */
+if (!processOk(process$1)) {
+  signalExit$1.exports = function () {};
+} else {
+  var assert = require$$0;
+  var signals = signals$1.exports;
+  var isWin = /^win/i.test(process$1.platform);
+
+  var EE = require$$2;
+  /* istanbul ignore if */
+  if (typeof EE !== 'function') {
+    EE = EE.EventEmitter;
   }
-  if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) {
-    const [head, ...tail] = snapshots.filesRemovedList;
-    summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, head)}`);
-    tail.forEach((key) => {
-      summary.push(`  ${c.gray(F_DOT)} ${formatTestPath(rootDir, key)}`);
-    });
+
+  var emitter;
+  if (process$1.__signal_exit_emitter__) {
+    emitter = process$1.__signal_exit_emitter__;
+  } else {
+    emitter = process$1.__signal_exit_emitter__ = new EE();
+    emitter.count = 0;
+    emitter.emitted = {};
   }
-  if (snapshots.unchecked) {
-    if (snapshots.didUpdate)
-      summary.push(c.bold(c.green(`${snapshots.unchecked} removed`)));
-    else
-      summary.push(c.bold(c.yellow(`${snapshots.unchecked} obsolete`)));
-    snapshots.uncheckedKeysByFile.forEach((uncheckedFile) => {
-      summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, uncheckedFile.filePath)}`);
-      uncheckedFile.keys.forEach((key) => summary.push(`  ${c.gray(F_DOT)} ${key}`));
-    });
+
+  // Because this emitter is a global, we have to check to see if a
+  // previous version of this library failed to enable infinite listeners.
+  // I know what you're about to say.  But literally everything about
+  // signal-exit is a compromise with evil.  Get used to it.
+  if (!emitter.infinite) {
+    emitter.setMaxListeners(Infinity);
+    emitter.infinite = true;
   }
-  return summary;
-}
-function getStateString(tasks, name = "tests") {
-  if (tasks.length === 0)
-    return c.dim(`no ${name}`);
-  const passed = tasks.filter((i) => {
-    var _a;
-    return ((_a = i.result) == null ? void 0 : _a.state) === "pass";
-  });
-  const failed = tasks.filter((i) => {
-    var _a;
-    return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
-  });
-  const skipped2 = tasks.filter((i) => i.mode === "skip");
-  const todo = tasks.filter((i) => i.mode === "todo");
-  return [
-    failed.length ? c.bold(c.red(`${failed.length} failed`)) : null,
-    passed.length ? c.bold(c.green(`${passed.length} passed`)) : null,
-    skipped2.length ? c.yellow(`${skipped2.length} skipped`) : null,
-    todo.length ? c.gray(`${todo.length} todo`) : null
-  ].filter(Boolean).join(c.dim(" | ")) + c.gray(` (${tasks.length})`);
-}
-function getStateSymbol(task) {
-  if (task.mode === "skip" || task.mode === "todo")
-    return skipped;
-  if (!task.result)
-    return c.gray("\xB7");
-  if (task.result.state === "run") {
-    if (task.type === "suite")
-      return pointer;
-    let spinner = spinnerMap.get(task);
-    if (!spinner) {
-      spinner = elegantSpinner();
-      spinnerMap.set(task, spinner);
+
+  signalExit$1.exports = function (cb, opts) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return
     }
-    return c.yellow(spinner());
-  }
-  if (task.result.state === "pass")
-    return c.green(F_CHECK);
-  if (task.result.state === "fail") {
-    return task.type === "suite" ? pointer : c.red(F_CROSS);
-  }
-  return " ";
-}
-function renderTree(tasks, level = 0) {
-  var _a, _b, _c, _d;
-  let output = [];
-  for (const task of tasks) {
-    let delta = 1;
-    let suffix = task.mode === "skip" || task.mode === "todo" ? ` ${c.dim("[skipped]")}` : "";
-    const prefix = ` ${getStateSymbol(task)} `;
-    if (task.type === "suite")
-      suffix += c.dim(` (${getTests(task).length})`);
-    if ((_a = task.result) == null ? void 0 : _a.end) {
-      const duration = task.result.end - task.result.start;
-      if (duration > DURATION_LONG)
-        suffix += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
+    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
+
+    if (loaded === false) {
+      load();
     }
-    if (task.name)
-      output.push("  ".repeat(level) + prefix + task.name + suffix);
-    else
-      delta = 0;
-    if (((_b = task.result) == null ? void 0 : _b.state) !== "pass" && outputMap.get(task) != null) {
-      let data = outputMap.get(task);
-      if (typeof data === "string") {
-        data = stripAnsi(data.trim().split("\n").filter(Boolean).pop());
-        if (data === "")
-          data = void 0;
-      }
-      if (data != null) {
-        const out = `${"  ".repeat(level)}${F_RIGHT} ${data}`;
-        output.push(`   ${c.gray(cliTruncate(out, process.stdout.columns - 3))}`);
-      }
+
+    var ev = 'exit';
+    if (opts && opts.alwaysLast) {
+      ev = 'afterexit';
     }
-    if ((((_c = task.result) == null ? void 0 : _c.state) === "fail" || ((_d = task.result) == null ? void 0 : _d.state) === "run") && task.type === "suite" && task.tasks.length > 0)
-      output = output.concat(renderTree(task.tasks, level + delta));
-  }
-  return output.slice(0, MAX_HEIGHT).join("\n");
-}
-const createRenderer = (_tasks) => {
-  let tasks = _tasks;
-  let timer;
-  const stdout = process.stdout;
-  const log = createLogUpdate(stdout);
-  function update() {
-    log(renderTree(tasks));
-  }
-  return {
-    start() {
-      if (timer)
-        return this;
-      timer = setInterval(update, 200);
-      return this;
-    },
-    update(_tasks2) {
-      tasks = _tasks2;
-      update();
-      return this;
-    },
-    async stop() {
-      if (timer) {
-        clearInterval(timer);
-        timer = void 0;
+
+    var remove = function () {
+      emitter.removeListener(ev, cb);
+      if (emitter.listeners('exit').length === 0 &&
+          emitter.listeners('afterexit').length === 0) {
+        unload();
       }
-      log.clear();
-      stdout.write(`${renderTree(tasks)}
-`);
-      return this;
-    },
-    clear() {
-      log.clear();
-    }
-  };
-};
-function getFullName(task) {
-  return getNames(task).join(c.dim(" > "));
-}
-const spinnerFrames = process.platform === "win32" ? ["-", "\\", "|", "/"] : ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-function elegantSpinner() {
-  let index = 0;
-  return () => {
-    index = ++index % spinnerFrames.length;
-    return spinnerFrames[index];
+    };
+    emitter.on(ev, cb);
+
+    return remove
   };
-}
 
-const isTTY = process.stdout.isTTY && !process.env.CI;
-class DefaultReporter {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.start = 0;
-    this.end = 0;
-    this.console = globalThis.console;
-    this.isFirstWatchRun = true;
-    const mode = ctx.config.watch ? c.yellow(" DEV ") : c.cyan(" RUN ");
-    this.log(`${c.inverse(c.bold(mode))} ${c.gray(this.ctx.config.root)}
-`);
-    this.start = performance.now();
-  }
-  log(...args) {
-    if (this.ctx.config.silent)
-      return;
-    this.console.log(...args);
-  }
-  error(...args) {
-    if (this.ctx.config.silent)
-      return;
-    this.console.error(...args);
-  }
-  relative(path) {
-    return relative(this.ctx.config.root, path);
-  }
-  onStart() {
-    if (isTTY) {
-      const files = this.ctx.state.getFiles(this.watchFilters);
-      if (!this.renderer)
-        this.renderer = createRenderer(files).start();
-      else
-        this.renderer.update(files);
-    }
-  }
-  onTaskUpdate(pack) {
-    var _a, _b, _c;
-    if (isTTY)
-      return;
-    const task = this.ctx.state.idMap[pack[0]];
-    if (task.type === "test" && ((_a = task.result) == null ? void 0 : _a.state) && ((_b = task.result) == null ? void 0 : _b.state) !== "run") {
-      this.log(` ${getStateSymbol(task)} ${getFullName(task)}`);
-      if (task.result.state === "fail")
-        this.log(c.red(`   ${F_RIGHT} ${(_c = task.result.error) == null ? void 0 : _c.message}`));
+  var unload = function unload () {
+    if (!loaded || !processOk(commonjsGlobal.process)) {
+      return
     }
-  }
-  async onFinished(files = this.ctx.state.getFiles()) {
-    var _a, _b;
-    this.end = performance.now();
-    await this.stopListRender();
-    this.log();
-    const suites = getSuites(files);
-    const tests = getTests(files);
-    const failedSuites = suites.filter((i) => {
-      var _a2;
-      return (_a2 = i.result) == null ? void 0 : _a2.error;
-    });
-    const failedTests = tests.filter((i) => {
-      var _a2;
-      return ((_a2 = i.result) == null ? void 0 : _a2.state) === "fail";
+    loaded = false;
+
+    signals.forEach(function (sig) {
+      try {
+        process$1.removeListener(sig, sigListeners[sig]);
+      } catch (er) {}
     });
-    const failedTotal = failedSuites.length + failedTests.length;
-    let current = 1;
-    const errorDivider = () => this.error(`${c.red(c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}
-`);
-    if (failedSuites.length) {
-      this.error(c.red(divider(c.bold(c.inverse(` Failed Suites ${failedSuites.length} `)))));
-      this.error();
-      for (const suite of failedSuites) {
-        this.error(c.red(`
-- ${getFullName(suite)}`));
-        await printError((_a = suite.result) == null ? void 0 : _a.error);
-        errorDivider();
-      }
+    process$1.emit = originalProcessEmit;
+    process$1.reallyExit = originalProcessReallyExit;
+    emitter.count -= 1;
+  };
+  signalExit$1.exports.unload = unload;
+
+  var emit = function emit (event, code, signal) {
+    /* istanbul ignore if */
+    if (emitter.emitted[event]) {
+      return
     }
-    if (failedTests.length) {
-      this.error(c.red(divider(c.bold(c.inverse(` Failed Tests ${failedTests.length} `)))));
-      this.error();
-      for (const test of failedTests) {
-        this.error(`${c.red(c.bold(c.inverse(" FAIL ")))} ${getFullName(test)}`);
-        await printError((_b = test.result) == null ? void 0 : _b.error);
-        errorDivider();
+    emitter.emitted[event] = true;
+    emitter.emit(event, code, signal);
+  };
+
+  // { <signal>: <listener fn>, ... }
+  var sigListeners = {};
+  signals.forEach(function (sig) {
+    sigListeners[sig] = function listener () {
+      /* istanbul ignore if */
+      if (!processOk(commonjsGlobal.process)) {
+        return
+      }
+      // If there are no other listeners, an exit is coming!
+      // Simplest way: remove us and then re-send the signal.
+      // We know that this will kill the process, so we can
+      // safely emit now.
+      var listeners = process$1.listeners(sig);
+      if (listeners.length === emitter.count) {
+        unload();
+        emit('exit', null, sig);
+        /* istanbul ignore next */
+        emit('afterexit', null, sig);
+        /* istanbul ignore next */
+        if (isWin && sig === 'SIGHUP') {
+          // "SIGHUP" throws an `ENOSYS` error on Windows,
+          // so use a supported signal instead
+          sig = 'SIGINT';
+        }
+        /* istanbul ignore next */
+        process$1.kill(process$1.pid, sig);
       }
-    }
-    const executionTime = this.end - this.start;
-    const threadTime = tests.reduce((acc, test) => {
-      var _a2;
-      return acc + (((_a2 = test.result) == null ? void 0 : _a2.end) ? test.result.end - test.result.start : 0);
-    }, 0);
-    const padTitle = (str) => c.dim(`${str.padStart(10)} `);
-    const time = (time2) => {
-      if (time2 > 1e3)
-        return `${(time2 / 1e3).toFixed(2)}s`;
-      return `${Math.round(time2)}ms`;
     };
-    const snapshotOutput = renderSnapshotSummary(this.ctx.config.root, this.ctx.snapshot.summary);
-    if (snapshotOutput.length) {
-      this.log(snapshotOutput.map((t, i) => i === 0 ? `${padTitle("Snapshots")} ${t}` : `${padTitle("")} ${t}`).join("\n"));
-      if (snapshotOutput.length > 1)
-        this.log();
+  });
+
+  signalExit$1.exports.signals = function () {
+    return signals
+  };
+
+  var loaded = false;
+
+  var load = function load () {
+    if (loaded || !processOk(commonjsGlobal.process)) {
+      return
     }
-    this.log(padTitle("Test Files"), getStateString(files));
-    this.log(padTitle("Tests"), getStateString(tests));
-    if (this.watchFilters)
-      this.log(padTitle("Time"), time(threadTime));
-    else
-      this.log(padTitle("Time"), time(executionTime) + c.gray(` (in thread ${time(threadTime)}, ${(executionTime / threadTime * 100).toFixed(2)}%)`));
-    this.log();
-  }
-  async onWatcherStart() {
-    await this.stopListRender();
-    const failed = getTests(this.ctx.state.getFiles()).filter((i) => {
-      var _a;
-      return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
+    loaded = true;
+
+    // This is the number of onSignalExit's that are in play.
+    // It's important so that we can count the correct number of
+    // listeners on signals, and don't wait for the other one to
+    // handle it instead of us.
+    emitter.count += 1;
+
+    signals = signals.filter(function (sig) {
+      try {
+        process$1.on(sig, sigListeners[sig]);
+        return true
+      } catch (er) {
+        return false
+      }
     });
-    if (failed.length)
-      this.log(`
-${c.bold(c.inverse(c.red(" FAIL ")))}${c.red(` ${failed.length} tests failed. Watching for file changes...`)}`);
-    else
-      this.log(`
-${c.bold(c.inverse(c.green(" PASS ")))}${c.green(" Waiting for file changes...")}`);
-    if (this.isFirstWatchRun) {
-      this.isFirstWatchRun = false;
-      this.log(c.gray("press any key to exit..."));
+
+    process$1.emit = processEmit;
+    process$1.reallyExit = processReallyExit;
+  };
+  signalExit$1.exports.load = load;
+
+  var originalProcessReallyExit = process$1.reallyExit;
+  var processReallyExit = function processReallyExit (code) {
+    /* istanbul ignore if */
+    if (!processOk(commonjsGlobal.process)) {
+      return
     }
-  }
-  async onWatcherRerun(files, trigger) {
-    await this.stopListRender();
-    this.watchFilters = files;
-    this.console.clear();
-    this.log(c.blue("Re-running tests...") + c.dim(` [ ${this.relative(trigger)} ]
-`));
-  }
-  async stopListRender() {
-    var _a;
-    (_a = this.renderer) == null ? void 0 : _a.stop();
-    this.renderer = void 0;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  onUserConsoleLog(log) {
-    var _a;
-    (_a = this.renderer) == null ? void 0 : _a.clear();
-    const task = log.taskId ? this.ctx.state.idMap[log.taskId] : void 0;
-    this.log(c.gray(log.type + c.dim(` | ${task ? getFullName(task) : "unknown test"}`)));
-    process[log.type].write(`${log.content}
-`);
-  }
-}
+    process$1.exitCode = code || /* istanbul ignore next */ 0;
+    emit('exit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    emit('afterexit', process$1.exitCode, null);
+    /* istanbul ignore next */
+    originalProcessReallyExit.call(process$1, process$1.exitCode);
+  };
 
-class SnapshotManager {
-  constructor(config) {
-    this.config = config;
-    this.summary = void 0;
-    this.clear();
-  }
-  clear() {
-    this.summary = emptySummary(this.config.snapshotOptions);
-  }
-  add(result) {
-    addSnapshotResult(this.summary, result);
-  }
-}
-function emptySummary(options) {
-  const summary = {
-    added: 0,
-    failure: false,
-    filesAdded: 0,
-    filesRemoved: 0,
-    filesRemovedList: [],
-    filesUnmatched: 0,
-    filesUpdated: 0,
-    matched: 0,
-    total: 0,
-    unchecked: 0,
-    uncheckedKeysByFile: [],
-    unmatched: 0,
-    updated: 0,
-    didUpdate: options.updateSnapshot === "all"
+  var originalProcessEmit = process$1.emit;
+  var processEmit = function processEmit (ev, arg) {
+    if (ev === 'exit' && processOk(commonjsGlobal.process)) {
+      /* istanbul ignore else */
+      if (arg !== undefined) {
+        process$1.exitCode = arg;
+      }
+      var ret = originalProcessEmit.apply(this, arguments);
+      /* istanbul ignore next */
+      emit('exit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      emit('afterexit', process$1.exitCode, null);
+      /* istanbul ignore next */
+      return ret
+    } else {
+      return originalProcessEmit.apply(this, arguments)
+    }
   };
-  return summary;
-}
-function addSnapshotResult(summary, result) {
-  if (result.added)
-    summary.filesAdded++;
-  if (result.fileDeleted)
-    summary.filesRemoved++;
-  if (result.unmatched)
-    summary.filesUnmatched++;
-  if (result.updated)
-    summary.filesUpdated++;
-  summary.added += result.added;
-  summary.matched += result.matched;
-  summary.unchecked += result.unchecked;
-  if (result.uncheckedKeys && result.uncheckedKeys.length > 0) {
-    summary.uncheckedKeysByFile.push({
-      filePath: result.filepath,
-      keys: result.uncheckedKeys
-    });
-  }
-  summary.unmatched += result.unmatched;
-  summary.updated += result.updated;
-  summary.total += result.added + result.matched + result.unmatched + result.updated;
 }
 
-/*
-How it works:
-`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
-*/
+var signalExit = signalExit$1.exports;
 
-class Node {
-	value;
-	next;
+const restoreCursor = onetime$1(() => {
+	signalExit(() => {
+		process$2.stderr.write('\u001B[?25h');
+	}, {alwaysLast: true});
+});
 
-	constructor(value) {
-		this.value = value;
+let isHidden = false;
+
+const cliCursor = {};
+
+cliCursor.show = (writableStream = process$2.stderr) => {
+	if (!writableStream.isTTY) {
+		return;
 	}
-}
 
-class Queue {
-	#head;
-	#tail;
-	#size;
+	isHidden = false;
+	writableStream.write('\u001B[?25h');
+};
 
-	constructor() {
-		this.clear();
+cliCursor.hide = (writableStream = process$2.stderr) => {
+	if (!writableStream.isTTY) {
+		return;
 	}
 
-	enqueue(value) {
-		const node = new Node(value);
+	restoreCursor();
+	isHidden = true;
+	writableStream.write('\u001B[?25l');
+};
 
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
+cliCursor.toggle = (force, writableStream) => {
+	if (force !== undefined) {
+		isHidden = force;
+	}
+
+	if (isHidden) {
+		cliCursor.show(writableStream);
+	} else {
+		cliCursor.hide(writableStream);
+	}
+};
+
+const ESCAPES = new Set([
+	'\u001B',
+	'\u009B',
+]);
+
+const END_CODE = 39;
+const ANSI_ESCAPE_BELL = '\u0007';
+const ANSI_CSI = '[';
+const ANSI_OSC = ']';
+const ANSI_SGR_TERMINATOR = 'm';
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+
+const wrapAnsiCode = code => `${ESCAPES.values().next().value}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = uri => `${ESCAPES.values().next().value}${ANSI_ESCAPE_LINK}${uri}${ANSI_ESCAPE_BELL}`;
+
+// Calculate the length of words split on ' ', ignoring
+// the extra characters added by ansi escape codes
+const wordLengths = string => string.split(' ').map(character => stringWidth(character));
+
+// Wrap a long word across multiple rows
+// Ansi escape codes do not count towards length
+const wrapWord = (rows, word, columns) => {
+	const characters = [...word];
+
+	let isInsideEscape = false;
+	let isInsideLinkEscape = false;
+	let visible = stringWidth(stripAnsi(rows[rows.length - 1]));
+
+	for (const [index, character] of characters.entries()) {
+		const characterLength = stringWidth(character);
+
+		if (visible + characterLength <= columns) {
+			rows[rows.length - 1] += character;
 		} else {
-			this.#head = node;
-			this.#tail = node;
+			rows.push(character);
+			visible = 0;
 		}
 
-		this.#size++;
-	}
+		if (ESCAPES.has(character)) {
+			isInsideEscape = true;
+			isInsideLinkEscape = characters.slice(index + 1).join('').startsWith(ANSI_ESCAPE_LINK);
+		}
+
+		if (isInsideEscape) {
+			if (isInsideLinkEscape) {
+				if (character === ANSI_ESCAPE_BELL) {
+					isInsideEscape = false;
+					isInsideLinkEscape = false;
+				}
+			} else if (character === ANSI_SGR_TERMINATOR) {
+				isInsideEscape = false;
+			}
 
-	dequeue() {
-		const current = this.#head;
-		if (!current) {
-			return;
+			continue;
 		}
 
-		this.#head = this.#head.next;
-		this.#size--;
-		return current.value;
-	}
+		visible += characterLength;
 
-	clear() {
-		this.#head = undefined;
-		this.#tail = undefined;
-		this.#size = 0;
+		if (visible === columns && index < characters.length - 1) {
+			rows.push('');
+			visible = 0;
+		}
 	}
 
-	get size() {
-		return this.#size;
+	// It's possible that the last row we copy over is only
+	// ansi escape characters, handle this edge-case
+	if (!visible && rows[rows.length - 1].length > 0 && rows.length > 1) {
+		rows[rows.length - 2] += rows.pop();
 	}
+};
 
-	* [Symbol.iterator]() {
-		let current = this.#head;
+// Trims spaces from a string ignoring invisible sequences
+const stringVisibleTrimSpacesRight = string => {
+	const words = string.split(' ');
+	let last = words.length;
 
-		while (current) {
-			yield current.value;
-			current = current.next;
+	while (last > 0) {
+		if (stringWidth(words[last - 1]) > 0) {
+			break;
 		}
+
+		last--;
 	}
-}
 
-function pLimit(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
-		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	if (last === words.length) {
+		return string;
 	}
 
-	const queue = new Queue();
-	let activeCount = 0;
+	return words.slice(0, last).join(' ') + words.slice(last).join('');
+};
 
-	const next = () => {
-		activeCount--;
+// The wrap-ansi module can be invoked in either 'hard' or 'soft' wrap mode
+//
+// 'hard' will never allow a string to take up more than columns characters
+//
+// 'soft' allows long words to expand past the column length
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === '') {
+		return '';
+	}
 
-		if (queue.size > 0) {
-			queue.dequeue()();
-		}
-	};
+	let returnValue = '';
+	let escapeCode;
+	let escapeUrl;
 
-	const run = async (fn, resolve, args) => {
-		activeCount++;
+	const lengths = wordLengths(string);
+	let rows = [''];
 
-		const result = (async () => fn(...args))();
+	for (const [index, word] of string.split(' ').entries()) {
+		if (options.trim !== false) {
+			rows[rows.length - 1] = rows[rows.length - 1].trimStart();
+		}
 
-		resolve(result);
+		let rowLength = stringWidth(rows[rows.length - 1]);
 
-		try {
-			await result;
-		} catch {}
+		if (index !== 0) {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				// If we start with a new word but the current row length equals the length of the columns, add a new row
+				rows.push('');
+				rowLength = 0;
+			}
 
-		next();
-	};
+			if (rowLength > 0 || options.trim === false) {
+				rows[rows.length - 1] += ' ';
+				rowLength++;
+			}
+		}
 
-	const enqueue = (fn, resolve, args) => {
-		queue.enqueue(run.bind(undefined, fn, resolve, args));
+		// In 'hard' wrap mode, the length of a line is never allowed to extend past 'columns'
+		if (options.hard && lengths[index] > columns) {
+			const remainingColumns = (columns - rowLength);
+			const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+			const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+			if (breaksStartingNextLine < breaksStartingThisLine) {
+				rows.push('');
+			}
 
-		(async () => {
-			// This function needs to wait until the next microtask before comparing
-			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
-			// when the run function is dequeued and called. The comparison in the if-statement
-			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
-			await Promise.resolve();
+			wrapWord(rows, word, columns);
+			continue;
+		}
 
-			if (activeCount < concurrency && queue.size > 0) {
-				queue.dequeue()();
+		if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+			if (options.wordWrap === false && rowLength < columns) {
+				wrapWord(rows, word, columns);
+				continue;
 			}
-		})();
-	};
 
-	const generator = (fn, ...args) => new Promise(resolve => {
-		enqueue(fn, resolve, args);
-	});
+			rows.push('');
+		}
 
-	Object.defineProperties(generator, {
-		activeCount: {
-			get: () => activeCount,
-		},
-		pendingCount: {
-			get: () => queue.size,
-		},
-		clearQueue: {
-			value: () => {
-				queue.clear();
-			},
-		},
-	});
+		if (rowLength + lengths[index] > columns && options.wordWrap === false) {
+			wrapWord(rows, word, columns);
+			continue;
+		}
 
-	return generator;
-}
+		rows[rows.length - 1] += word;
+	}
 
-class EndError extends Error {
-	constructor(value) {
-		super();
-		this.value = value;
+	if (options.trim !== false) {
+		rows = rows.map(row => stringVisibleTrimSpacesRight(row));
 	}
-}
 
-// The input can also be a promise, so we await it.
-const testElement = async (element, tester) => tester(await element);
+	const pre = [...rows.join('\n')];
 
-// The input can also be a promise, so we `Promise.all()` them both.
-const finder = async element => {
-	const values = await Promise.all(element);
-	if (values[1] === true) {
-		throw new EndError(values[0]);
-	}
+	for (const [index, character] of pre.entries()) {
+		returnValue += character;
 
-	return false;
-};
+		if (ESCAPES.has(character)) {
+			const {groups} = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`).exec(pre.slice(index).join('')) || {groups: {}};
+			if (groups.code !== undefined) {
+				const code = Number.parseFloat(groups.code);
+				escapeCode = code === END_CODE ? undefined : code;
+			} else if (groups.uri !== undefined) {
+				escapeUrl = groups.uri.length === 0 ? undefined : groups.uri;
+			}
+		}
 
-async function pLocate(
-	iterable,
-	tester,
-	{
-		concurrency = Number.POSITIVE_INFINITY,
-		preserveOrder = true,
-	} = {},
-) {
-	const limit = pLimit(concurrency);
+		const code = ansiStyles.codes.get(Number(escapeCode));
 
-	// Start all the promises concurrently with optional limit.
-	const items = [...iterable].map(element => [element, limit(testElement, element, tester)]);
+		if (pre[index + 1] === '\n') {
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink('');
+			}
 
-	// Check the promises either serially or concurrently.
-	const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(code);
+			}
+		} else if (character === '\n') {
+			if (escapeCode && code) {
+				returnValue += wrapAnsiCode(escapeCode);
+			}
 
-	try {
-		await Promise.all(items.map(element => checkLimit(finder, element)));
-	} catch (error) {
-		if (error instanceof EndError) {
-			return error.value;
+			if (escapeUrl) {
+				returnValue += wrapAnsiHyperlink(escapeUrl);
+			}
 		}
-
-		throw error;
 	}
-}
 
-const typeMappings = {
-	directory: 'isDirectory',
-	file: 'isFile',
+	return returnValue;
 };
 
-function checkType(type) {
-	if (type in typeMappings) {
-		return;
-	}
-
-	throw new Error(`Invalid type specified: ${type}`);
+// For each newline, invoke the method separately
+function wrapAnsi(string, columns, options) {
+	return String(string)
+		.normalize()
+		.replace(/\r\n/g, '\n')
+		.split('\n')
+		.map(line => exec(line, columns, options))
+		.join('\n');
 }
 
-const matchType = (type, stat) => type === undefined || stat[typeMappings[type]]();
+const defaultTerminalHeight = 24;
 
-async function locatePath(
-	paths,
-	{
-		cwd = process$2.cwd(),
-		type = 'file',
-		allowSymlinks = true,
-		concurrency,
-		preserveOrder,
-	} = {},
-) {
-	checkType(type);
+const getWidth = stream => {
+	const {columns} = stream;
 
-	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
+	if (!columns) {
+		return 80;
+	}
+
+	return columns;
+};
+
+const fitToTerminalHeight = (stream, text) => {
+	const terminalHeight = stream.rows || defaultTerminalHeight;
+	const lines = text.split('\n');
 
-	return pLocate(paths, async path_ => {
-		try {
-			const stat = await statFunction(path.resolve(cwd, path_));
-			return matchType(type, stat);
-		} catch {
-			return false;
-		}
-	}, {concurrency, preserveOrder});
-}
+	const toRemove = lines.length - terminalHeight;
+	if (toRemove <= 0) {
+		return text;
+	}
 
-const findUpStop = Symbol('findUpStop');
+	return sliceAnsi(
+		text,
+		lines.slice(0, toRemove).join('\n').length + 1,
+		text.length);
+};
 
-async function findUpMultiple(name, options = {}) {
-	let directory = path.resolve(options.cwd || '');
-	const {root} = path.parse(directory);
-	const stopAt = path.resolve(directory, options.stopAt || root);
-	const limit = options.limit || Number.POSITIVE_INFINITY;
-	const paths = [name].flat();
+function createLogUpdate(stream, {showCursor = false} = {}) {
+	let previousLineCount = 0;
+	let previousWidth = getWidth(stream);
+	let previousOutput = '';
 
-	const runMatcher = async locateOptions => {
-		if (typeof name !== 'function') {
-			return locatePath(paths, locateOptions);
+	const render = (...arguments_) => {
+		if (!showCursor) {
+			cliCursor.hide();
 		}
 
-		const foundPath = await name(locateOptions.cwd);
-		if (typeof foundPath === 'string') {
-			return locatePath([foundPath], locateOptions);
+		let output = arguments_.join(' ') + '\n';
+		output = fitToTerminalHeight(stream, output);
+		const width = getWidth(stream);
+		if (output === previousOutput && previousWidth === width) {
+			return;
 		}
 
-		return foundPath;
+		previousOutput = output;
+		previousWidth = width;
+		output = wrapAnsi(output, width, {
+			trim: false,
+			hard: true,
+			wordWrap: false,
+		});
+		stream.write(ansiEscapes.eraseLines(previousLineCount) + output);
+		previousLineCount = output.split('\n').length;
 	};
 
-	const matches = [];
-	// eslint-disable-next-line no-constant-condition
-	while (true) {
-		// eslint-disable-next-line no-await-in-loop
-		const foundPath = await runMatcher({...options, cwd: directory});
+	render.clear = () => {
+		stream.write(ansiEscapes.eraseLines(previousLineCount));
+		previousOutput = '';
+		previousWidth = getWidth(stream);
+		previousLineCount = 0;
+	};
 
-		if (foundPath === findUpStop) {
-			break;
-		}
+	render.done = () => {
+		previousOutput = '';
+		previousWidth = getWidth(stream);
+		previousLineCount = 0;
 
-		if (foundPath) {
-			matches.push(path.resolve(directory, foundPath));
+		if (!showCursor) {
+			cliCursor.show();
 		}
+	};
 
-		if (directory === stopAt || matches.length >= limit) {
-			break;
-		}
+	return render;
+}
 
-		directory = path.dirname(directory);
-	}
+createLogUpdate(process$2.stdout);
+
+createLogUpdate(process$2.stderr);
+
+const DURATION_LONG = 300;
+const MAX_HEIGHT = 20;
+const spinnerMap = new WeakMap();
+const outputMap = new WeakMap();
+const pointer = c.yellow(F_POINTER);
+const skipped = c.yellow(F_DOWN);
+function divider(text, left, right) {
+  let length = process.stdout.columns;
+  if (!length || isNaN(length))
+    length = 10;
+  if (text) {
+    const textLength = stripAnsi(text).length;
+    if (left == null && right != null) {
+      left = length - textLength - right;
+    } else {
+      left = left ?? Math.floor((length - textLength) / 2);
+      right = length - textLength - left;
+    }
+    left = Math.max(0, left);
+    right = Math.max(0, right);
+    return `${F_LONG_DASH.repeat(left)}${text}${F_LONG_DASH.repeat(right)}`;
+  }
+  return F_LONG_DASH.repeat(length);
+}
+function formatTestPath(root, path) {
+  var _a;
+  if (isAbsolute(path))
+    path = relative(root, path);
+  const dir = dirname(path);
+  const ext = ((_a = path.match(/(\.(spec|test)\.[cm]?[tj]sx?)$/)) == null ? void 0 : _a[0]) || "";
+  const base = basename(path, ext);
+  return slash(c.dim(`${dir}/`) + c.bold(base)) + c.dim(ext);
+}
+function renderSnapshotSummary(rootDir, snapshots) {
+  const summary = [];
+  if (snapshots.added)
+    summary.push(c.bold(c.green(`${snapshots.added} written`)));
+  if (snapshots.unmatched)
+    summary.push(c.bold(c.red(`${snapshots.unmatched} failed`)));
+  if (snapshots.updated)
+    summary.push(c.bold(c.green(`${snapshots.updated} updated `)));
+  if (snapshots.filesRemoved) {
+    if (snapshots.didUpdate)
+      summary.push(c.bold(c.green(`${snapshots.filesRemoved} files removed `)));
+    else
+      summary.push(c.bold(c.yellow(`${snapshots.filesRemoved} files obsolete `)));
+  }
+  if (snapshots.filesRemovedList && snapshots.filesRemovedList.length) {
+    const [head, ...tail] = snapshots.filesRemovedList;
+    summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, head)}`);
+    tail.forEach((key) => {
+      summary.push(`  ${c.gray(F_DOT)} ${formatTestPath(rootDir, key)}`);
+    });
+  }
+  if (snapshots.unchecked) {
+    if (snapshots.didUpdate)
+      summary.push(c.bold(c.green(`${snapshots.unchecked} removed`)));
+    else
+      summary.push(c.bold(c.yellow(`${snapshots.unchecked} obsolete`)));
+    snapshots.uncheckedKeysByFile.forEach((uncheckedFile) => {
+      summary.push(`${c.gray(F_DOWN_RIGHT)} ${formatTestPath(rootDir, uncheckedFile.filePath)}`);
+      uncheckedFile.keys.forEach((key) => summary.push(`  ${c.gray(F_DOT)} ${key}`));
+    });
+  }
+  return summary;
+}
+function getStateString(tasks, name = "tests") {
+  if (tasks.length === 0)
+    return c.dim(`no ${name}`);
+  const passed = tasks.filter((i) => {
+    var _a;
+    return ((_a = i.result) == null ? void 0 : _a.state) === "pass";
+  });
+  const failed = tasks.filter((i) => {
+    var _a;
+    return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
+  });
+  const skipped2 = tasks.filter((i) => i.mode === "skip");
+  const todo = tasks.filter((i) => i.mode === "todo");
+  return [
+    failed.length ? c.bold(c.red(`${failed.length} failed`)) : null,
+    passed.length ? c.bold(c.green(`${passed.length} passed`)) : null,
+    skipped2.length ? c.yellow(`${skipped2.length} skipped`) : null,
+    todo.length ? c.gray(`${todo.length} todo`) : null
+  ].filter(Boolean).join(c.dim(" | ")) + c.gray(` (${tasks.length})`);
+}
+function getStateSymbol(task) {
+  if (task.mode === "skip" || task.mode === "todo")
+    return skipped;
+  if (!task.result)
+    return c.gray("\xB7");
+  if (task.result.state === "run") {
+    if (task.type === "suite")
+      return pointer;
+    let spinner = spinnerMap.get(task);
+    if (!spinner) {
+      spinner = elegantSpinner();
+      spinnerMap.set(task, spinner);
+    }
+    return c.yellow(spinner());
+  }
+  if (task.result.state === "pass")
+    return c.green(F_CHECK);
+  if (task.result.state === "fail") {
+    return task.type === "suite" ? pointer : c.red(F_CROSS);
+  }
+  return " ";
+}
+function renderTree(tasks, level = 0) {
+  var _a, _b, _c, _d;
+  let output = [];
+  for (const task of tasks) {
+    let suffix = "";
+    const prefix = ` ${getStateSymbol(task)} `;
+    if (task.mode === "skip" || task.mode === "todo")
+      suffix += ` ${c.dim("[skipped]")}`;
+    if (task.type === "suite")
+      suffix += c.dim(` (${getTests(task).length})`);
+    if ((_a = task.result) == null ? void 0 : _a.end) {
+      const duration = task.result.end - task.result.start;
+      if (duration > DURATION_LONG)
+        suffix += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
+    }
+    output.push("  ".repeat(level) + prefix + task.name + suffix);
+    if (((_b = task.result) == null ? void 0 : _b.state) !== "pass" && outputMap.get(task) != null) {
+      let data = outputMap.get(task);
+      if (typeof data === "string") {
+        data = stripAnsi(data.trim().split("\n").filter(Boolean).pop());
+        if (data === "")
+          data = void 0;
+      }
+      if (data != null) {
+        const out = `${"  ".repeat(level)}${F_RIGHT} ${data}`;
+        output.push(`   ${c.gray(cliTruncate(out, process.stdout.columns - 3))}`);
+      }
+    }
+    if ((((_c = task.result) == null ? void 0 : _c.state) === "fail" || ((_d = task.result) == null ? void 0 : _d.state) === "run") && task.type === "suite" && task.tasks.length > 0)
+      output = output.concat(renderTree(task.tasks, level + 1));
+  }
+  return output.slice(0, MAX_HEIGHT).join("\n");
+}
+const createRenderer = (_tasks) => {
+  let tasks = _tasks;
+  let timer;
+  const stdout = process.stdout;
+  const log = createLogUpdate(stdout);
+  function update() {
+    log(renderTree(tasks));
+  }
+  return {
+    start() {
+      if (timer)
+        return this;
+      timer = setInterval(update, 200);
+      return this;
+    },
+    update(_tasks2) {
+      tasks = _tasks2;
+      update();
+      return this;
+    },
+    async stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      log.clear();
+      stdout.write(`${renderTree(tasks)}
+`);
+      return this;
+    },
+    clear() {
+      log.clear();
+    }
+  };
+};
+function getFullName(task) {
+  return getNames(task).join(c.dim(" > "));
+}
+const spinnerFrames = process.platform === "win32" ? ["-", "\\", "|", "/"] : ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function elegantSpinner() {
+  let index = 0;
+  return () => {
+    index = ++index % spinnerFrames.length;
+    return spinnerFrames[index];
+  };
+}
 
-	return matches;
+const isTTY = process.stdout.isTTY && !process.env.CI;
+class ConsoleReporter {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.start = 0;
+    this.end = 0;
+    this.console = globalThis.console;
+    this.isFirstWatchRun = true;
+    const mode = ctx.config.watch ? c.yellow(" DEV ") : c.cyan(" RUN ");
+    this.log(`${c.inverse(c.bold(mode))} ${c.gray(this.ctx.config.root)}
+`);
+    this.start = performance.now();
+  }
+  log(...args) {
+    if (this.ctx.config.silent)
+      return;
+    this.console.log(...args);
+  }
+  error(...args) {
+    if (this.ctx.config.silent)
+      return;
+    this.console.error(...args);
+  }
+  relative(path) {
+    return relative(this.ctx.config.root, path);
+  }
+  onStart() {
+    if (isTTY) {
+      const files = this.ctx.state.getFiles(this.watchFilters);
+      if (!this.renderer)
+        this.renderer = createRenderer(files).start();
+      else
+        this.renderer.update(files);
+    }
+  }
+  onTaskUpdate(pack) {
+    var _a, _b, _c;
+    if (isTTY)
+      return;
+    const task = this.ctx.state.idMap[pack[0]];
+    if (task.type === "test" && ((_a = task.result) == null ? void 0 : _a.state) && ((_b = task.result) == null ? void 0 : _b.state) !== "run") {
+      this.log(` ${getStateSymbol(task)} ${getFullName(task)}`);
+      if (task.result.state === "fail")
+        this.log(c.red(`   ${F_RIGHT} ${(_c = task.result.error) == null ? void 0 : _c.message}`));
+    }
+  }
+  async onFinished(files = this.ctx.state.getFiles()) {
+    var _a, _b;
+    this.end = performance.now();
+    await this.stopListRender();
+    this.log();
+    const suites = getSuites(files);
+    const tests = getTests(files);
+    const failedSuites = suites.filter((i) => {
+      var _a2;
+      return (_a2 = i.result) == null ? void 0 : _a2.error;
+    });
+    const failedTests = tests.filter((i) => {
+      var _a2;
+      return ((_a2 = i.result) == null ? void 0 : _a2.state) === "fail";
+    });
+    const failedTotal = failedSuites.length + failedTests.length;
+    let current = 1;
+    const errorDivider = () => this.error(`${c.red(c.dim(divider(`[${current++}/${failedTotal}]`, void 0, 1)))}
+`);
+    if (failedSuites.length) {
+      this.error(c.red(divider(c.bold(c.inverse(` Failed Suites ${failedSuites.length} `)))));
+      this.error();
+      for (const suite of failedSuites) {
+        this.error(c.red(`
+- ${getFullName(suite)}`));
+        await printError((_a = suite.result) == null ? void 0 : _a.error);
+        errorDivider();
+      }
+    }
+    if (failedTests.length) {
+      this.error(c.red(divider(c.bold(c.inverse(` Failed Tests ${failedTests.length} `)))));
+      this.error();
+      for (const test of failedTests) {
+        this.error(`${c.red(c.bold(c.inverse(" FAIL ")))} ${getFullName(test)}`);
+        await printError((_b = test.result) == null ? void 0 : _b.error);
+        errorDivider();
+      }
+    }
+    const executionTime = this.end - this.start;
+    const threadTime = tests.reduce((acc, test) => {
+      var _a2;
+      return acc + (((_a2 = test.result) == null ? void 0 : _a2.end) ? test.result.end - test.result.start : 0);
+    }, 0);
+    const padTitle = (str) => c.dim(`${str.padStart(10)} `);
+    const time = (time2) => {
+      if (time2 > 1e3)
+        return `${(time2 / 1e3).toFixed(2)}s`;
+      return `${Math.round(time2)}ms`;
+    };
+    const snapshotOutput = renderSnapshotSummary(this.ctx.config.root, this.ctx.snapshot.summary);
+    if (snapshotOutput.length) {
+      this.log(snapshotOutput.map((t, i) => i === 0 ? `${padTitle("Snapshots")} ${t}` : `${padTitle("")} ${t}`).join("\n"));
+      if (snapshotOutput.length > 1)
+        this.log();
+    }
+    this.log(padTitle("Test Files"), getStateString(files));
+    this.log(padTitle("Tests"), getStateString(tests));
+    if (this.watchFilters)
+      this.log(padTitle("Time"), time(threadTime));
+    else
+      this.log(padTitle("Time"), time(executionTime) + c.gray(` (in thread ${time(threadTime)}, ${(executionTime / threadTime * 100).toFixed(2)}%)`));
+    this.log();
+  }
+  async onWatcherStart() {
+    await this.stopListRender();
+    const failed = getTests(this.ctx.state.getFiles()).filter((i) => {
+      var _a;
+      return ((_a = i.result) == null ? void 0 : _a.state) === "fail";
+    });
+    if (failed.length)
+      this.log(`
+${c.bold(c.inverse(c.red(" FAIL ")))}${c.red(` ${failed.length} tests failed. Watching for file changes...`)}`);
+    else
+      this.log(`
+${c.bold(c.inverse(c.green(" PASS ")))}${c.green(" Waiting for file changes...")}`);
+    if (this.isFirstWatchRun) {
+      this.isFirstWatchRun = false;
+      this.log(c.gray("press any key to exit..."));
+    }
+  }
+  async onWatcherRerun(files, trigger) {
+    await this.stopListRender();
+    this.watchFilters = files;
+    this.console.clear();
+    this.log(c.blue("Re-running tests...") + c.dim(` [ ${this.relative(trigger)} ]
+`));
+  }
+  async stopListRender() {
+    var _a;
+    (_a = this.renderer) == null ? void 0 : _a.stop();
+    this.renderer = void 0;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  onUserConsoleLog(log) {
+    var _a;
+    (_a = this.renderer) == null ? void 0 : _a.clear();
+    const task = log.taskId ? this.ctx.state.idMap[log.taskId] : void 0;
+    this.log(c.gray(log.type + c.dim(` | ${task ? getFullName(task) : "unknown test"}`)));
+    process[log.type].write(`${log.content}
+`);
+  }
 }
 
-async function findUp(name, options = {}) {
-	const matches = await findUpMultiple(name, {...options, limit: 1});
-	return matches[0];
+class StateManager {
+  constructor() {
+    this.filesMap = {};
+    this.idMap = {};
+    this.taskFileMap = new WeakMap();
+  }
+  getFiles(keys) {
+    if (keys)
+      return keys.map((key) => this.filesMap[key]);
+    return Object.values(this.filesMap);
+  }
+  collectFiles(files) {
+    files.forEach((file) => {
+      this.filesMap[file.filepath] = file;
+      this.updateId(file);
+    });
+  }
+  updateId(task) {
+    if (this.idMap[task.id] === task)
+      return;
+    this.idMap[task.id] = task;
+    if (task.type === "suite") {
+      task.tasks.forEach((task2) => {
+        this.updateId(task2);
+      });
+    }
+  }
+  updateTasks(packs) {
+    for (const [id, result] of packs) {
+      if (this.idMap[id])
+        this.idMap[id].result = result;
+    }
+  }
 }
 
 var __defProp$1 = Object.defineProperty;
@@ -2127,7 +2160,7 @@ var __spreadValues$1 = (a, b) => {
     }
   return a;
 };
-async function initViteServer(options = {}) {
+async function initVitest(options = {}) {
   const root = resolve(options.root || process.cwd());
   process.chdir(root);
   if (options.dom)
@@ -2149,7 +2182,7 @@ async function initViteServer(options = {}) {
         },
         async configureServer(server2) {
           if (resolved.api)
-            server2.middlewares.use((await import('./middleware-37267df8.js')).default());
+            server2.middlewares.use((await import('./middleware-b567041c.js')).default());
         }
       }
     ],
@@ -2166,10 +2199,17 @@ async function initViteServer(options = {}) {
   await server.pluginContainer.buildStart({});
   if (typeof resolved.api === "number")
     await server.listen(resolved.api);
-  return {
+  const ctx = {
     server,
-    config: resolved
+    config: resolved,
+    state: new StateManager(),
+    snapshot: new SnapshotManager(resolved),
+    reporters: toArray(resolved.reporters),
+    console: globalThis.console
   };
+  if (!ctx.reporters.length)
+    ctx.reporters.push(new ConsoleReporter(ctx));
+  return ctx;
 }
 function resolveConfig(resolved, viteConfig) {
   var _a, _b;
@@ -2179,8 +2219,8 @@ function resolveConfig(resolved, viteConfig) {
   resolved.environment = resolved.environment || "node";
   resolved.threads = resolved.threads ?? true;
   resolved.interpretDefault = resolved.interpretDefault ?? true;
-  resolved.includes = resolved.includes ?? defaultIncludes;
-  resolved.excludes = resolved.excludes ?? defaultExcludes;
+  resolved.include = resolved.include ?? defaultInclude;
+  resolved.exclude = resolved.exclude ?? defaultExclude;
   const CI = !!process.env.CI;
   const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
   resolved.snapshotOptions = {
@@ -2196,7 +2236,7 @@ function resolveConfig(resolved, viteConfig) {
 }
 
 async function transformRequest(server, id) {
-  if (id.match(/\.(?:[cm]?[jt]s|json)$/)) {
+  if (id.match(/\.(?:[cm]?[jt]sx?|json)$/)) {
     return await server.transformRequest(id, { ssr: true });
   } else {
     const result = await server.transformRequest(id);
@@ -2267,7 +2307,6 @@ function createChannel(ctx) {
   const port = channel.port2;
   const workerPort = channel.port1;
   port.on("message", async ({ id, method, args = [] }) => {
-    var _a, _b, _c, _d, _e, _f;
     async function send(fn) {
       try {
         port.postMessage({ id, result: await fn() });
@@ -2276,20 +2315,32 @@ function createChannel(ctx) {
       }
     }
     switch (method) {
+      case "processExit":
+        process.exit(args[0] || 1);
+        return;
       case "snapshotSaved":
         return send(() => ctx.snapshot.add(args[0]));
       case "fetch":
         return send(() => transformRequest(ctx.server, ...args));
       case "onCollected":
         ctx.state.collectFiles(args[0]);
-        (_b = (_a = ctx.reporter).onStart) == null ? void 0 : _b.call(_a, args[0].map((i) => i.filepath));
+        ctx.reporters.forEach((r) => {
+          var _a;
+          return (_a = r.onStart) == null ? void 0 : _a.call(r, args[0].map((i) => i.filepath));
+        });
         return;
       case "onTaskUpdate":
         ctx.state.updateTasks([args[0]]);
-        (_d = (_c = ctx.reporter).onTaskUpdate) == null ? void 0 : _d.call(_c, args[0]);
+        ctx.reporters.forEach((r) => {
+          var _a;
+          return (_a = r.onTaskUpdate) == null ? void 0 : _a.call(r, args[0]);
+        });
         return;
       case "log":
-        (_f = (_e = ctx.reporter).onUserConsoleLog) == null ? void 0 : _f.call(_e, args[0]);
+        ctx.reporters.forEach((r) => {
+          var _a;
+          return (_a = r.onUserConsoleLog) == null ? void 0 : _a.call(r, args[0]);
+        });
         return;
     }
     console.error("Unhandled message", method, args);
@@ -2298,16 +2349,16 @@ function createChannel(ctx) {
 }
 
 function isTargetFile(id, config) {
-  if (mm.isMatch(id, config.excludes))
+  if (mm.isMatch(id, config.exclude))
     return false;
-  return mm.isMatch(id, config.includes);
+  return mm.isMatch(id, config.include);
 }
 async function globTestFiles(config) {
   var _a;
-  let testFilepaths = await fg(config.includes, {
+  let testFilepaths = await fg(config.include, {
     absolute: true,
     cwd: config.root,
-    ignore: config.excludes
+    ignore: config.exclude
   });
   if ((_a = config.cliFilters) == null ? void 0 : _a.length)
     testFilepaths = testFilepaths.filter((i) => config.cliFilters.some((f) => i.includes(f)));
@@ -2316,9 +2367,11 @@ async function globTestFiles(config) {
 
 const WATCHER_DEBOUNCE = 50;
 async function startWatcher(ctx, pool) {
-  var _a;
-  const { reporter, server } = ctx;
-  (_a = reporter.onWatcherStart) == null ? void 0 : _a.call(reporter);
+  const { server } = ctx;
+  ctx.reporters.forEach((r) => {
+    var _a;
+    return (_a = r.onWatcherStart) == null ? void 0 : _a.call(r);
+  });
   let timer;
   const changedTests = new Set();
   const seen = new Set();
@@ -2356,8 +2409,8 @@ async function startWatcher(ctx, pool) {
       }
       isFirstRun = false;
       ctx.state.getFiles().forEach((file) => {
-        var _a2;
-        if (((_a2 = file.result) == null ? void 0 : _a2.state) === "fail")
+        var _a;
+        if (((_a = file.result) == null ? void 0 : _a.state) === "fail")
           changedTests.add(file.filepath);
       });
       const invalidates = Array.from(seen);
@@ -2371,11 +2424,19 @@ async function startWatcher(ctx, pool) {
     }, WATCHER_DEBOUNCE);
   }
   async function start(tests, id, invalidates) {
-    var _a2, _b, _c;
-    await ((_a2 = reporter.onWatcherRerun) == null ? void 0 : _a2.call(reporter, tests, id));
+    await Promise.all(ctx.reporters.map((r) => {
+      var _a;
+      return (_a = r.onWatcherRerun) == null ? void 0 : _a.call(r, tests, id);
+    }));
     await pool.runTestFiles(tests, invalidates);
-    await ((_b = reporter.onFinished) == null ? void 0 : _b.call(reporter, ctx.state.getFiles(tests)));
-    await ((_c = reporter.onWatcherStart) == null ? void 0 : _c.call(reporter));
+    await Promise.all(ctx.reporters.map((r) => {
+      var _a;
+      return (_a = r.onFinished) == null ? void 0 : _a.call(r, ctx.state.getFiles(tests));
+    }));
+    await Promise.all(ctx.reporters.map((r) => {
+      var _a;
+      return (_a = r.onWatcherStart) == null ? void 0 : _a.call(r);
+    }));
   }
   if (process.stdin.isTTY) {
     readline.emitKeypressEvents(process.stdin);
@@ -2411,7 +2472,6 @@ function getAffectedTests(ctx, id, set = new Set(), seen = new Set()) {
 }
 
 async function start(ctx) {
-  var _a, _b;
   const { config } = ctx;
   const testFilepaths = await globTestFiles(config);
   if (!testFilepaths.length) {
@@ -2423,48 +2483,16 @@ async function start(ctx) {
   await pool.runTestFiles(testFilepaths);
   if (hasFailed(ctx.state.getFiles()))
     process.exitCode = 1;
-  await ((_b = (_a = ctx.reporter).onFinished) == null ? void 0 : _b.call(_a, ctx.state.getFiles()));
+  await Promise.all(ctx.reporters.map((r) => {
+    var _a;
+    return (_a = r.onFinished) == null ? void 0 : _a.call(r, ctx.state.getFiles());
+  }));
   if (config.watch)
     await startWatcher(ctx, pool);
   else
     await pool.close();
 }
 
-class StateManager {
-  constructor() {
-    this.filesMap = {};
-    this.idMap = {};
-    this.taskFileMap = new WeakMap();
-  }
-  getFiles(keys) {
-    if (keys)
-      return keys.map((key) => this.filesMap[key]);
-    return Object.values(this.filesMap);
-  }
-  collectFiles(files) {
-    files.forEach((file) => {
-      this.filesMap[file.filepath] = file;
-      this.updateId(file);
-    });
-  }
-  updateId(task) {
-    if (this.idMap[task.id] === task)
-      return;
-    this.idMap[task.id] = task;
-    if (task.type === "suite") {
-      task.tasks.forEach((task2) => {
-        this.updateId(task2);
-      });
-    }
-  }
-  updateTasks(packs) {
-    for (const [id, result] of packs) {
-      if (this.idMap[id])
-        this.idMap[id].result = result;
-    }
-  }
-}
-
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -2505,23 +2533,15 @@ async function run(cliFilters, argv) {
     console.log(c.magenta(c.bold("\nVitest is in closed beta exclusively for Sponsors")));
     console.log(c.yellow("Learn more at https://vitest.dev\n"));
   }
-  const { config, server } = await initViteServer(__spreadProps(__spreadValues({}, argv), { cliFilters }));
-  const ctx = process.__vitest__ = {
-    server,
-    config,
-    state: new StateManager(),
-    snapshot: new SnapshotManager(config),
-    reporter: config.reporter,
-    console: globalThis.console
-  };
-  ctx.reporter = ctx.reporter || new DefaultReporter(ctx);
+  const ctx = await initVitest(__spreadProps(__spreadValues({}, argv), { cliFilters }));
+  process.__vitest__ = ctx;
   try {
     await start(ctx);
   } catch (e) {
     process.exitCode = 1;
     throw e;
   } finally {
-    if (!config.watch)
-      await server.close();
+    if (!ctx.config.watch)
+      await ctx.server.close();
   }
 }