@manifest-network/manifest-mcp-core 0.1.0

package/dist/node_modules/@vitest/runner/dist/index.js

@@ -0,0 +1,1381 @@
+import { format, formatRegExp, objDisplay } from "../../utils/dist/display.js";
+import { assertTypes, createDefer, filterOutComments, isNegativeNaN, isObject, objectAttr, ordinal, toArray, unique } from "../../utils/dist/helpers.js";
+import { getSafeTimers } from "../../utils/dist/timers.js";
+import { createChainable, createNoTagsError, createTaskName, findTestFileStackTrace, getChainableContext, validateTags } from "./chunk-tasks.js";
+//#region ../../node_modules/@vitest/runner/dist/index.js
+var PendingError = class extends Error {
+	constructor(message, task, note) {
+		super(message);
+		this.code = "VITEST_PENDING";
+		this.message = message;
+		this.note = note;
+		this.taskId = task.id;
+	}
+};
+var FixtureDependencyError = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "FixtureDependencyError";
+	}
+};
+var FixtureAccessError = class extends Error {
+	constructor(..._args2) {
+		super(..._args2);
+		this.name = "FixtureAccessError";
+	}
+};
+var FixtureParseError = class extends Error {
+	constructor(..._args3) {
+		super(..._args3);
+		this.name = "FixtureParseError";
+	}
+};
+const fnMap = /* @__PURE__ */ new WeakMap();
+const testFixtureMap = /* @__PURE__ */ new WeakMap();
+const hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+	fnMap.set(key, fn);
+}
+function getFn(key) {
+	return fnMap.get(key);
+}
+function setTestFixture(key, fixture) {
+	testFixtureMap.set(key, fixture);
+}
+function getTestFixtures(key) {
+	return testFixtureMap.get(key);
+}
+function setHooks(key, hooks) {
+	hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+	return hooksMap.get(key);
+}
+var TestFixtures = class TestFixtures {
+	static clearDefinitions() {
+		TestFixtures._definitions.length = 0;
+	}
+	static getWorkerContexts() {
+		return TestFixtures._definitions.map((f) => f.getWorkerContext());
+	}
+	static getFileContexts(file) {
+		return TestFixtures._definitions.map((f) => f.getFileContext(file));
+	}
+	constructor(registrations) {
+		this._overrides = /* @__PURE__ */ new WeakMap();
+		this._registrations = registrations ?? /* @__PURE__ */ new Map();
+		this._suiteContexts = /* @__PURE__ */ new WeakMap();
+		TestFixtures._definitions.push(this);
+	}
+	extend(runner, userFixtures) {
+		const { suite } = getCurrentSuite();
+		const isTopLevel = !suite || suite.file === suite;
+		return new TestFixtures(this.parseUserFixtures(runner, userFixtures, isTopLevel));
+	}
+	get(suite) {
+		let currentSuite = suite;
+		while (currentSuite) {
+			const overrides = this._overrides.get(currentSuite);
+			if (overrides) return overrides;
+			if (currentSuite === currentSuite.file) break;
+			currentSuite = currentSuite.suite || currentSuite.file;
+		}
+		return this._registrations;
+	}
+	override(runner, userFixtures) {
+		const { suite: currentSuite, file } = getCurrentSuite();
+		const suite = currentSuite || file;
+		const isTopLevel = !currentSuite || currentSuite.file === currentSuite;
+		const suiteRegistrations = new Map(this.get(suite));
+		const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel, suiteRegistrations);
+		if (isTopLevel) this._registrations = registrations;
+		else this._overrides.set(suite, registrations);
+	}
+	getFileContext(file) {
+		if (!this._suiteContexts.has(file)) this._suiteContexts.set(file, Object.create(null));
+		return this._suiteContexts.get(file);
+	}
+	getWorkerContext() {
+		if (!this._suiteContexts.has(TestFixtures._workerContextSuite)) this._suiteContexts.set(TestFixtures._workerContextSuite, Object.create(null));
+		return this._suiteContexts.get(TestFixtures._workerContextSuite);
+	}
+	parseUserFixtures(runner, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {
+		const errors = [];
+		Object.entries(userFixtures).forEach(([name, fn]) => {
+			let options;
+			let value;
+			let _options;
+			if (Array.isArray(fn) && fn.length >= 2 && isObject(fn[1]) && Object.keys(fn[1]).some((key) => TestFixtures._fixtureOptionKeys.includes(key))) {
+				_options = fn[1];
+				options = {
+					auto: _options.auto ?? false,
+					scope: _options.scope ?? "test",
+					injected: _options.injected ?? false
+				};
+				value = options.injected ? runner.injectValue?.(name) ?? fn[0] : fn[0];
+			} else value = fn;
+			const parent = registrations.get(name);
+			if (parent && options) {
+				if (parent.scope !== options.scope) errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered with a "${options.scope}" scope.`));
+				if (parent.auto !== options.auto) errors.push(new FixtureDependencyError(`The "${name}" fixture was already registered as { auto: ${options.auto} }.`));
+			} else if (parent) options = {
+				auto: parent.auto,
+				scope: parent.scope,
+				injected: parent.injected
+			};
+			else if (!options) options = {
+				auto: false,
+				injected: false,
+				scope: "test"
+			};
+			if (options.scope && !TestFixtures._fixtureScopes.includes(options.scope)) errors.push(new FixtureDependencyError(`The "${name}" fixture has unknown scope "${options.scope}".`));
+			if (!supportNonTest && options.scope !== "test") errors.push(new FixtureDependencyError(`The "${name}" fixture cannot be defined with a ${options.scope} scope${!_options?.scope && parent?.scope ? " (inherited from the base fixture)" : ""} inside the describe block. Define it at the top level of the file instead.`));
+			const deps = isFixtureFunction(value) ? getUsedProps(value) : /* @__PURE__ */ new Set();
+			const item = {
+				name,
+				value,
+				auto: options.auto ?? false,
+				injected: options.injected ?? false,
+				scope: options.scope ?? "test",
+				deps,
+				parent
+			};
+			registrations.set(name, item);
+			if (item.scope === "worker" && (runner.pool === "vmThreads" || runner.pool === "vmForks")) item.scope = "file";
+		});
+		for (const fixture of registrations.values()) for (const depName of fixture.deps) {
+			if (TestFixtures._builtinFixtures.includes(depName)) continue;
+			const dep = registrations.get(depName);
+			if (!dep) {
+				errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on unknown fixture "${depName}".`));
+				continue;
+			}
+			if (depName === fixture.name && !fixture.parent) {
+				errors.push(new FixtureDependencyError(`The "${fixture.name}" fixture depends on itself, but does not have a base implementation.`));
+				continue;
+			}
+			if (TestFixtures._fixtureScopes.indexOf(fixture.scope) > TestFixtures._fixtureScopes.indexOf(dep.scope)) {
+				errors.push(new FixtureDependencyError(`The ${fixture.scope} "${fixture.name}" fixture cannot depend on a ${dep.scope} fixture "${dep.name}".`));
+				continue;
+			}
+		}
+		if (errors.length === 1) throw errors[0];
+		else if (errors.length > 1) throw new AggregateError(errors, "Cannot resolve user fixtures. See errors for more information.");
+		return registrations;
+	}
+};
+TestFixtures._definitions = [];
+TestFixtures._builtinFixtures = [
+	"task",
+	"signal",
+	"onTestFailed",
+	"onTestFinished",
+	"skip",
+	"annotate"
+];
+TestFixtures._fixtureOptionKeys = [
+	"auto",
+	"injected",
+	"scope"
+];
+TestFixtures._fixtureScopes = [
+	"test",
+	"file",
+	"worker"
+];
+TestFixtures._workerContextSuite = { type: "worker" };
+const cleanupFnArrayMap = /* @__PURE__ */ new WeakMap();
+const contextHasFixturesCache = /* @__PURE__ */ new WeakMap();
+function withFixtures(fn, options) {
+	const collector = getCurrentSuite();
+	const suite = options?.suite || collector.suite || collector.file;
+	return async (hookContext) => {
+		const context = hookContext || options?.context;
+		if (!context) {
+			if (options?.suiteHook) validateSuiteHook(fn, options.suiteHook, options.stackTraceError);
+			return fn({});
+		}
+		const fixtures = options?.fixtures || getTestFixtures(context);
+		if (!fixtures) return fn(context);
+		const registrations = fixtures.get(suite);
+		if (!registrations.size) return fn(context);
+		const usedFixtures = [];
+		const usedProps = getUsedProps(fn);
+		for (const fixture of registrations.values()) if (fixture.auto || usedProps.has(fixture.name)) usedFixtures.push(fixture);
+		if (!usedFixtures.length) return fn(context);
+		if (!cleanupFnArrayMap.has(context)) cleanupFnArrayMap.set(context, []);
+		const cleanupFnArray = cleanupFnArrayMap.get(context);
+		const pendingFixtures = resolveDeps(usedFixtures, registrations);
+		if (!pendingFixtures.length) return fn(context);
+		if (options?.suiteHook) {
+			const testScopedFixtures = pendingFixtures.filter((f) => f.scope === "test");
+			if (testScopedFixtures.length > 0) {
+				const fixtureNames = testScopedFixtures.map((f) => `"${f.name}"`).join(", ");
+				const error = new FixtureDependencyError(`Test-scoped fixtures cannot be used inside ${options.suiteHook} hook. The following fixtures are test-scoped: ${fixtureNames}. Use { scope: 'file' } or { scope: 'worker' } fixtures instead, or move the logic to ${{
+					aroundAll: "aroundEach",
+					beforeAll: "beforeEach",
+					afterAll: "afterEach"
+				}[options.suiteHook]} hook.`);
+				if (options.stackTraceError?.stack) error.stack = error.message + options.stackTraceError.stack.replace(options.stackTraceError.message, "");
+				throw error;
+			}
+		}
+		if (!contextHasFixturesCache.has(context)) contextHasFixturesCache.set(context, /* @__PURE__ */ new WeakSet());
+		const cachedFixtures = contextHasFixturesCache.get(context);
+		for (const fixture of pendingFixtures) if (fixture.scope === "test") {
+			if (cachedFixtures.has(fixture)) continue;
+			cachedFixtures.add(fixture);
+			const resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
+			context[fixture.name] = resolvedValue;
+			cleanupFnArray.push(() => {
+				cachedFixtures.delete(fixture);
+			});
+		} else {
+			const resolvedValue = await resolveScopeFixtureValue(fixtures, suite, fixture);
+			context[fixture.name] = resolvedValue;
+		}
+		return fn(context);
+	};
+}
+function isFixtureFunction(value) {
+	return typeof value === "function";
+}
+function resolveTestFixtureValue(fixture, context, cleanupFnArray) {
+	if (!isFixtureFunction(fixture.value)) return fixture.value;
+	return resolveFixtureFunction(fixture.value, context, cleanupFnArray);
+}
+const scopedFixturePromiseCache = /* @__PURE__ */ new WeakMap();
+async function resolveScopeFixtureValue(fixtures, suite, fixture) {
+	const workerContext = fixtures.getWorkerContext();
+	const fileContext = fixtures.getFileContext(suite.file);
+	const fixtureContext = fixture.scope === "worker" ? workerContext : fileContext;
+	if (!isFixtureFunction(fixture.value)) {
+		fixtureContext[fixture.name] = fixture.value;
+		return fixture.value;
+	}
+	if (fixture.name in fixtureContext) return fixtureContext[fixture.name];
+	if (scopedFixturePromiseCache.has(fixture)) return scopedFixturePromiseCache.get(fixture);
+	if (!cleanupFnArrayMap.has(fixtureContext)) cleanupFnArrayMap.set(fixtureContext, []);
+	const cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);
+	const promise = resolveFixtureFunction(fixture.value, fixture.scope === "file" ? {
+		...workerContext,
+		...fileContext
+	} : fixtureContext, cleanupFnFileArray).then((value) => {
+		fixtureContext[fixture.name] = value;
+		scopedFixturePromiseCache.delete(fixture);
+		return value;
+	});
+	scopedFixturePromiseCache.set(fixture, promise);
+	return promise;
+}
+async function resolveFixtureFunction(fixtureFn, context, cleanupFnArray) {
+	const useFnArgPromise = createDefer();
+	let isUseFnArgResolved = false;
+	const fixtureReturn = fixtureFn(context, async (useFnArg) => {
+		isUseFnArgResolved = true;
+		useFnArgPromise.resolve(useFnArg);
+		const useReturnPromise = createDefer();
+		cleanupFnArray.push(async () => {
+			useReturnPromise.resolve();
+			await fixtureReturn;
+		});
+		await useReturnPromise;
+	}).catch((e) => {
+		if (!isUseFnArgResolved) {
+			useFnArgPromise.reject(e);
+			return;
+		}
+		throw e;
+	});
+	return useFnArgPromise;
+}
+function resolveDeps(usedFixtures, registrations, depSet = /* @__PURE__ */ new Set(), pendingFixtures = []) {
+	usedFixtures.forEach((fixture) => {
+		if (pendingFixtures.includes(fixture)) return;
+		if (!isFixtureFunction(fixture.value) || !fixture.deps) {
+			pendingFixtures.push(fixture);
+			return;
+		}
+		if (depSet.has(fixture)) if (fixture.parent) fixture = fixture.parent;
+		else throw new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[...depSet].reverse().map((d) => d.name).join(" <- ")}`);
+		depSet.add(fixture);
+		resolveDeps([...fixture.deps].map((n) => n === fixture.name ? fixture.parent : registrations.get(n)).filter((n) => !!n), registrations, depSet, pendingFixtures);
+		pendingFixtures.push(fixture);
+		depSet.clear();
+	});
+	return pendingFixtures;
+}
+function validateSuiteHook(fn, hook, suiteError) {
+	const usedProps = getUsedProps(fn, {
+		sourceError: suiteError,
+		suiteHook: hook
+	});
+	if (usedProps.size) {
+		const error = new FixtureAccessError(`The ${hook} hook uses fixtures "${[...usedProps].join("\", \"")}", but has no access to context. Did you forget to call it as "test.${hook}()" instead of "${hook}()"?\nIf you used internal "suite" task as the first argument previously, access it in the second argument instead. See https://vitest.dev/guide/test-context#suite-level-hooks`);
+		if (suiteError) error.stack = suiteError.stack?.replace(suiteError.message, error.message);
+		throw error;
+	}
+}
+const kPropsSymbol = Symbol("$vitest:fixture-props");
+const kPropNamesSymbol = Symbol("$vitest:fixture-prop-names");
+function configureProps(fn, options) {
+	Object.defineProperty(fn, kPropsSymbol, {
+		value: options,
+		enumerable: false
+	});
+}
+function memoProps(fn, props) {
+	fn[kPropNamesSymbol] = props;
+	return props;
+}
+function getUsedProps(fn, { sourceError, suiteHook } = {}) {
+	if (kPropNamesSymbol in fn) return fn[kPropNamesSymbol];
+	const { index: fixturesIndex = 0, original: implementation = fn } = kPropsSymbol in fn ? fn[kPropsSymbol] : {};
+	let fnString = filterOutComments(implementation.toString());
+	if (/__async\((?:this|null), (?:null|arguments|\[[_0-9, ]*\]), function\*/.test(fnString)) fnString = fnString.split(/__async\((?:this|null),/)[1];
+	const match = fnString.match(/[^(]*\(([^)]*)/);
+	if (!match) return memoProps(fn, /* @__PURE__ */ new Set());
+	const args = splitByComma(match[1]);
+	if (!args.length) return memoProps(fn, /* @__PURE__ */ new Set());
+	const fixturesArgument = args[fixturesIndex];
+	if (!fixturesArgument) return memoProps(fn, /* @__PURE__ */ new Set());
+	if (!(fixturesArgument[0] === "{" && fixturesArgument.endsWith("}"))) {
+		const ordinalArgument = ordinal(fixturesIndex + 1);
+		const error = new FixtureParseError(`The ${ordinalArgument} argument inside a fixture must use object destructuring pattern, e.g. ({ task } => {}). Instead, received "${fixturesArgument}".${suiteHook ? ` If you used internal "suite" task as the ${ordinalArgument} argument previously, access it in the ${ordinal(fixturesIndex + 2)} argument instead.` : ""}`);
+		if (sourceError) error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+		throw error;
+	}
+	const props = splitByComma(fixturesArgument.slice(1, -1).replace(/\s/g, "")).map((prop) => {
+		return prop.replace(/:.*|=.*/g, "");
+	});
+	const last = props.at(-1);
+	if (last && last.startsWith("...")) {
+		const error = new FixtureParseError(`Rest parameters are not supported in fixtures, received "${last}".`);
+		if (sourceError) error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+		throw error;
+	}
+	return memoProps(fn, new Set(props));
+}
+function splitByComma(s) {
+	const result = [];
+	const stack = [];
+	let start = 0;
+	for (let i = 0; i < s.length; i++) if (s[i] === "{" || s[i] === "[") stack.push(s[i] === "{" ? "}" : "]");
+	else if (s[i] === stack.at(-1)) stack.pop();
+	else if (!stack.length && s[i] === ",") {
+		const token = s.substring(start, i).trim();
+		if (token) result.push(token);
+		start = i + 1;
+	}
+	const lastToken = s.substring(start).trim();
+	if (lastToken) result.push(lastToken);
+	return result;
+}
+let _test;
+function getCurrentTest() {
+	return _test;
+}
+function getDefaultHookTimeout() {
+	return getRunner().config.hookTimeout;
+}
+const CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
+const CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
+const AROUND_TIMEOUT_KEY = Symbol.for("VITEST_AROUND_TIMEOUT");
+const AROUND_STACK_TRACE_KEY = Symbol.for("VITEST_AROUND_STACK_TRACE");
+/**
+* Registers a callback function to be executed once before all tests within the current suite.
+* This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
+*
+* **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeAll to set up a database connection
+* beforeAll(async () => {
+*   await database.connect();
+* });
+* ```
+*/
+function beforeAll(fn, timeout = getDefaultHookTimeout()) {
+	assertTypes(fn, "\"beforeAll\" callback", ["function"]);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const context = getChainableContext(this);
+	return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(withSuiteFixtures("beforeAll", fn, context, stackTraceError), timeout, true, stackTraceError), {
+		[CLEANUP_TIMEOUT_KEY]: timeout,
+		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function to be executed once after all tests within the current suite have completed.
+* This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
+*
+* **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterAll to close a database connection
+* afterAll(async () => {
+*   await database.disconnect();
+* });
+* ```
+*/
+function afterAll(fn, timeout) {
+	assertTypes(fn, "\"afterAll\" callback", ["function"]);
+	const context = getChainableContext(this);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	return getCurrentSuite().on("afterAll", withTimeout(withSuiteFixtures("afterAll", fn, context, stackTraceError), timeout ?? getDefaultHookTimeout(), true, stackTraceError));
+}
+/**
+* Registers a callback function to be executed before each test within the current suite.
+* This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+*
+* **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeEach to reset a database state
+* beforeEach(async () => {
+*   await database.reset();
+* });
+* ```
+*/
+function beforeEach(fn, timeout = getDefaultHookTimeout()) {
+	assertTypes(fn, "\"beforeEach\" callback", ["function"]);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const wrapper = (context, suite) => {
+		return withFixtures(fn, { suite })(context);
+	};
+	return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
+		[CLEANUP_TIMEOUT_KEY]: timeout,
+		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function to be executed after each test within the current suite has completed.
+* This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
+*
+* **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterEach to delete temporary files created during a test
+* afterEach(async () => {
+*   await fileSystem.deleteTempFiles();
+* });
+* ```
+*/
+function afterEach(fn, timeout) {
+	assertTypes(fn, "\"afterEach\" callback", ["function"]);
+	const wrapper = (context, suite) => {
+		return withFixtures(fn, { suite })(context);
+	};
+	return getCurrentSuite().on("afterEach", withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+}
+createTestHook("onTestFailed", (test, handler, timeout) => {
+	test.onFailed || (test.onFailed = []);
+	test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+});
+createTestHook("onTestFinished", (test, handler, timeout) => {
+	test.onFinished || (test.onFinished = []);
+	test.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+});
+/**
+* Registers a callback function that wraps around all tests within the current suite.
+* The callback receives a `runSuite` function that must be called to run the suite's tests.
+* This hook is useful for scenarios where you need to wrap an entire suite in a context
+* (e.g., starting a server, opening a database connection that all tests share).
+*
+* **Note:** When multiple `aroundAll` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the suite. Must call `runSuite()` to run the tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundAll to wrap suite in a tracing span
+* aroundAll(async (runSuite) => {
+*   await tracer.trace('test-suite', runSuite);
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundAll with fixtures
+* aroundAll(async (runSuite, { db }) => {
+*   await db.transaction(() => runSuite());
+* });
+* ```
+*/
+function aroundAll(fn, timeout) {
+	assertTypes(fn, "\"aroundAll\" callback", ["function"]);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+	const context = getChainableContext(this);
+	return getCurrentSuite().on("aroundAll", Object.assign(withSuiteFixtures("aroundAll", fn, context, stackTraceError, 1), {
+		[AROUND_TIMEOUT_KEY]: resolvedTimeout,
+		[AROUND_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function that wraps around each test within the current suite.
+* The callback receives a `runTest` function that must be called to run the test.
+* This hook is useful for scenarios where you need to wrap tests in a context (e.g., database transactions).
+*
+* **Note:** When multiple `aroundEach` hooks are registered, they are nested inside each other.
+* The first registered hook is the outermost wrapper.
+*
+* @param {Function} fn - The callback function that wraps the test. Must call `runTest()` to run the test.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using aroundEach to wrap tests in a database transaction
+* aroundEach(async (runTest) => {
+*   await database.transaction(() => runTest());
+* });
+* ```
+* @example
+* ```ts
+* // Example of using aroundEach with fixtures
+* aroundEach(async (runTest, { db }) => {
+*   await db.transaction(() => runTest());
+* });
+* ```
+*/
+function aroundEach(fn, timeout) {
+	assertTypes(fn, "\"aroundEach\" callback", ["function"]);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const resolvedTimeout = timeout ?? getDefaultHookTimeout();
+	const wrapper = (runTest, context, suite) => {
+		const innerFn = (ctx) => fn(runTest, ctx, suite);
+		configureProps(innerFn, {
+			index: 1,
+			original: fn
+		});
+		return withFixtures(innerFn, { suite })(context);
+	};
+	return getCurrentSuite().on("aroundEach", Object.assign(wrapper, {
+		[AROUND_TIMEOUT_KEY]: resolvedTimeout,
+		[AROUND_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+function withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex = 0) {
+	return (...args) => {
+		const suite = args.at(-1);
+		const prefix = args.slice(0, -1);
+		const wrapper = (ctx) => fn(...prefix, ctx, suite);
+		configureProps(wrapper, {
+			index: contextIndex,
+			original: fn
+		});
+		const fixtures = context?.getFixtures();
+		const fileContext = fixtures?.getFileContext(suite.file);
+		return withFixtures(wrapper, {
+			suiteHook,
+			fixtures,
+			context: fileContext,
+			stackTraceError
+		})();
+	};
+}
+function createTestHook(name, handler) {
+	return (fn, timeout) => {
+		assertTypes(fn, `"${name}" callback`, ["function"]);
+		const current = getCurrentTest();
+		if (!current) throw new Error(`Hook ${name}() can only be called inside a test`);
+		return handler(current, fn, timeout);
+	};
+}
+/**
+* Creates a suite of tests, allowing for grouping and hierarchical organization of tests.
+* Suites can contain both tests and other suites, enabling complex test structures.
+*
+* @param {string} name - The name of the suite, used for identification and reporting.
+* @param {Function} fn - A function that defines the tests and suites within this suite.
+* @example
+* ```ts
+* // Define a suite with two tests
+* suite('Math operations', () => {
+*   test('should add two numbers', () => {
+*     expect(add(1, 2)).toBe(3);
+*   });
+*
+*   test('should subtract two numbers', () => {
+*     expect(subtract(5, 2)).toBe(3);
+*   });
+* });
+* ```
+* @example
+* ```ts
+* // Define nested suites
+* suite('String operations', () => {
+*   suite('Trimming', () => {
+*     test('should trim whitespace from start and end', () => {
+*       expect('  hello  '.trim()).toBe('hello');
+*     });
+*   });
+*
+*   suite('Concatenation', () => {
+*     test('should concatenate two strings', () => {
+*       expect('hello' + ' ' + 'world').toBe('hello world');
+*     });
+*   });
+* });
+* ```
+*/
+const suite = createSuite();
+createTest(function(name, optionsOrFn, optionsOrTest) {
+	if (getCurrentTest()) throw new Error("Calling the test function inside another test function is not allowed. Please put it inside \"describe\" or \"suite\" so it can be properly collected.");
+	getCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+});
+let runner;
+let defaultSuite;
+let currentTestFilepath;
+function assert(condition, message) {
+	if (!condition) throw new Error(`Vitest failed to find ${message}. One of the following is possible:
+- "vitest" is imported directly without running "vitest" command
+- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)
+- "vitest" is imported inside Vite / Vitest config file
+- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues
+`);
+}
+function getRunner() {
+	assert(runner, "the runner");
+	return runner;
+}
+function getCurrentSuite() {
+	const currentSuite = collectorContext.currentSuite || defaultSuite;
+	assert(currentSuite, "the current suite");
+	return currentSuite;
+}
+function createSuiteHooks() {
+	return {
+		beforeAll: [],
+		afterAll: [],
+		beforeEach: [],
+		afterEach: [],
+		aroundEach: [],
+		aroundAll: []
+	};
+}
+const POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
+function parseArguments(optionsOrFn, timeoutOrTest) {
+	if (timeoutOrTest != null && typeof timeoutOrTest === "object") throw new TypeError(`Signature "test(name, fn, { ... })" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);
+	let options = {};
+	let fn;
+	if (typeof timeoutOrTest === "number") options = { timeout: timeoutOrTest };
+	else if (typeof optionsOrFn === "object") options = optionsOrFn;
+	if (typeof optionsOrFn === "function") {
+		if (typeof timeoutOrTest === "function") throw new TypeError("Cannot use two functions as arguments. Please use the second argument for options.");
+		fn = optionsOrFn;
+	} else if (typeof timeoutOrTest === "function") fn = timeoutOrTest;
+	return {
+		options,
+		handler: fn
+	};
+}
+function createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions) {
+	const tasks = [];
+	let suite;
+	initSuite(true);
+	const task = function(name = "", options = {}) {
+		const currentSuite = collectorContext.currentSuite?.suite;
+		const testTags = unique([...(currentSuite ?? collectorContext.currentSuite?.file)?.tags || [], ...toArray(options.tags)]);
+		const tagsOptions = testTags.map((tag) => {
+			const tagDefinition = runner.config.tags?.find((t) => t.name === tag);
+			if (!tagDefinition && runner.config.strictTags) throw createNoTagsError(runner.config.tags, tag);
+			return tagDefinition;
+		}).filter((r) => r != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {
+			const { name, description, priority, meta, ...options } = tag;
+			Object.assign(acc, options);
+			if (meta) acc.meta = Object.assign(acc.meta ?? Object.create(null), meta);
+			return acc;
+		}, {});
+		const testOwnMeta = options.meta;
+		options = {
+			...tagsOptions,
+			...options
+		};
+		const timeout = options.timeout ?? runner.config.testTimeout;
+		const parentMeta = currentSuite?.meta;
+		const tagMeta = tagsOptions.meta;
+		const testMeta = Object.create(null);
+		if (tagMeta) Object.assign(testMeta, tagMeta);
+		if (parentMeta) Object.assign(testMeta, parentMeta);
+		if (testOwnMeta) Object.assign(testMeta, testOwnMeta);
+		const task = {
+			id: "",
+			name,
+			fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),
+			fullTestName: createTaskName([currentSuite?.fullTestName, name]),
+			suite: currentSuite,
+			each: options.each,
+			fails: options.fails,
+			context: void 0,
+			type: "test",
+			file: currentSuite?.file ?? collectorContext.currentSuite?.file,
+			timeout,
+			retry: options.retry ?? runner.config.retry,
+			repeats: options.repeats,
+			mode: options.only ? "only" : options.skip ? "skip" : options.todo ? "todo" : "run",
+			meta: testMeta,
+			annotations: [],
+			artifacts: [],
+			tags: testTags
+		};
+		const handler = options.handler;
+		if (task.mode === "run" && !handler) task.mode = "todo";
+		if (options.concurrent || !options.sequential && runner.config.sequence.concurrent) task.concurrent = true;
+		task.shuffle = suiteOptions?.shuffle;
+		const context = createTestContext(task, runner);
+		Object.defineProperty(task, "context", {
+			value: context,
+			enumerable: false
+		});
+		setTestFixture(context, options.fixtures ?? new TestFixtures());
+		const limit = Error.stackTraceLimit;
+		Error.stackTraceLimit = 10;
+		const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+		Error.stackTraceLimit = limit;
+		if (handler) setFn(task, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), task.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));
+		if (runner.config.includeTaskLocation) {
+			const error = stackTraceError.stack;
+			const stack = findTestFileStackTrace(currentTestFilepath, error);
+			if (stack) task.location = {
+				line: stack.line,
+				column: stack.column
+			};
+		}
+		tasks.push(task);
+		return task;
+	};
+	const test = createTest(function(name, optionsOrFn, timeoutOrTest) {
+		let { options, handler } = parseArguments(optionsOrFn, timeoutOrTest);
+		if (typeof suiteOptions === "object") options = Object.assign({}, suiteOptions, options);
+		const concurrent = this.concurrent ?? (!this.sequential && options?.concurrent);
+		if (options.concurrent != null && concurrent != null) options.concurrent = concurrent;
+		const sequential = this.sequential ?? (!this.concurrent && options?.sequential);
+		if (options.sequential != null && sequential != null) options.sequential = sequential;
+		const test = task(formatName(name), {
+			...this,
+			...options,
+			handler
+		});
+		test.type = "test";
+	});
+	const collector = {
+		type: "collector",
+		name,
+		mode,
+		suite,
+		options: suiteOptions,
+		test,
+		file: suite.file,
+		tasks,
+		collect,
+		task,
+		clear,
+		on: addHook
+	};
+	function addHook(name, ...fn) {
+		getHooks(suite)[name].push(...fn);
+	}
+	function initSuite(includeLocation) {
+		if (typeof suiteOptions === "number") suiteOptions = { timeout: suiteOptions };
+		const currentSuite = collectorContext.currentSuite?.suite;
+		const parentTask = currentSuite ?? collectorContext.currentSuite?.file;
+		const suiteTags = toArray(suiteOptions?.tags);
+		validateTags(runner.config, suiteTags);
+		suite = {
+			id: "",
+			type: "suite",
+			name,
+			fullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),
+			fullTestName: createTaskName([currentSuite?.fullTestName, name]),
+			suite: currentSuite,
+			mode,
+			each,
+			file: currentSuite?.file ?? collectorContext.currentSuite?.file,
+			shuffle: suiteOptions?.shuffle,
+			tasks: [],
+			meta: suiteOptions?.meta ?? Object.create(null),
+			concurrent: suiteOptions?.concurrent,
+			tags: unique([...parentTask?.tags || [], ...suiteTags])
+		};
+		setHooks(suite, createSuiteHooks());
+	}
+	function clear() {
+		tasks.length = 0;
+		initSuite(false);
+	}
+	async function collect(file) {
+		if (!file) throw new TypeError("File is required to collect tasks.");
+		if (factory) await runWithSuite(collector, () => factory(test));
+		const allChildren = [];
+		for (const i of tasks) allChildren.push(i.type === "collector" ? await i.collect(file) : i);
+		suite.tasks = allChildren;
+		return suite;
+	}
+	collectTask(collector);
+	return collector;
+}
+function withAwaitAsyncAssertions(fn, task) {
+	return (async (...args) => {
+		const fnResult = await fn(...args);
+		if (task.promises) {
+			const errors = (await Promise.allSettled(task.promises)).map((r) => r.status === "rejected" ? r.reason : void 0).filter(Boolean);
+			if (errors.length) throw errors;
+		}
+		return fnResult;
+	});
+}
+function createSuite() {
+	function suiteFn(name, factoryOrOptions, optionsOrFactory) {
+		if (getCurrentTest()) throw new Error("Calling the suite function inside test function is not allowed. It can be only called at the top level or inside another suite function.");
+		const currentSuite = collectorContext.currentSuite || defaultSuite;
+		let { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);
+		const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;
+		const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;
+		const { meta: parentMeta, ...parentOptions } = currentSuite?.options || {};
+		options = {
+			...parentOptions,
+			...options
+		};
+		const shuffle = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle;
+		if (shuffle != null) options.shuffle = shuffle;
+		let mode = this.only ?? options.only ? "only" : this.skip ?? options.skip ? "skip" : this.todo ?? options.todo ? "todo" : "run";
+		if (mode === "run" && !factory) mode = "todo";
+		const isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;
+		const isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;
+		if (isConcurrent != null) options.concurrent = isConcurrent && !isSequential;
+		if (isSequential != null) options.sequential = isSequential && !isConcurrent;
+		if (parentMeta) options.meta = Object.assign(Object.create(null), parentMeta, options.meta);
+		return createSuiteCollector(formatName(name), factory, mode, this.each, options);
+	}
+	suiteFn.each = function(cases, ...args) {
+		const context = getChainableContext(this);
+		const suite = context.withContext();
+		context.setContext("each", true);
+		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
+		return (name, optionsOrFn, fnOrOptions) => {
+			const _name = formatName(name);
+			const arrayOnlyCases = cases.every(Array.isArray);
+			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+			const fnFirst = typeof optionsOrFn === "function";
+			cases.forEach((i, idx) => {
+				const items = Array.isArray(i) ? i : [i];
+				if (fnFirst) if (arrayOnlyCases) suite(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
+				else suite(formatTitle(_name, items, idx), handler ? () => handler(i) : void 0, options.timeout);
+				else if (arrayOnlyCases) suite(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
+				else suite(formatTitle(_name, items, idx), options, handler ? () => handler(i) : void 0);
+			});
+			context.setContext("each", void 0);
+		};
+	};
+	suiteFn.for = function(cases, ...args) {
+		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
+		return (name, optionsOrFn, fnOrOptions) => {
+			const name_ = formatName(name);
+			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+			cases.forEach((item, idx) => {
+				suite(formatTitle(name_, toArray(item), idx), options, handler ? () => handler(item) : void 0);
+			});
+		};
+	};
+	suiteFn.skipIf = (condition) => condition ? suite.skip : suite;
+	suiteFn.runIf = (condition) => condition ? suite : suite.skip;
+	return createChainable([
+		"concurrent",
+		"sequential",
+		"shuffle",
+		"skip",
+		"only",
+		"todo"
+	], suiteFn);
+}
+function createTaskCollector(fn) {
+	const taskFn = fn;
+	taskFn.each = function(cases, ...args) {
+		const context = getChainableContext(this);
+		const test = context.withContext();
+		context.setContext("each", true);
+		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
+		return (name, optionsOrFn, fnOrOptions) => {
+			const _name = formatName(name);
+			const arrayOnlyCases = cases.every(Array.isArray);
+			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+			const fnFirst = typeof optionsOrFn === "function";
+			cases.forEach((i, idx) => {
+				const items = Array.isArray(i) ? i : [i];
+				if (fnFirst) if (arrayOnlyCases) test(formatTitle(_name, items, idx), handler ? () => handler(...items) : void 0, options.timeout);
+				else test(formatTitle(_name, items, idx), handler ? () => handler(i) : void 0, options.timeout);
+				else if (arrayOnlyCases) test(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : void 0);
+				else test(formatTitle(_name, items, idx), options, handler ? () => handler(i) : void 0);
+			});
+			context.setContext("each", void 0);
+		};
+	};
+	taskFn.for = function(cases, ...args) {
+		const test = getChainableContext(this).withContext();
+		if (Array.isArray(cases) && args.length) cases = formatTemplateString(cases, args);
+		return (name, optionsOrFn, fnOrOptions) => {
+			const _name = formatName(name);
+			const { options, handler } = parseArguments(optionsOrFn, fnOrOptions);
+			cases.forEach((item, idx) => {
+				const handlerWrapper = handler ? (ctx) => handler(item, ctx) : void 0;
+				if (handlerWrapper) configureProps(handlerWrapper, {
+					index: 1,
+					original: handler
+				});
+				test(formatTitle(_name, toArray(item), idx), options, handlerWrapper);
+			});
+		};
+	};
+	taskFn.skipIf = function(condition) {
+		return condition ? this.skip : this;
+	};
+	taskFn.runIf = function(condition) {
+		return condition ? this : this.skip;
+	};
+	/**
+	* Parse builder pattern arguments into a fixtures object.
+	* Handles both builder pattern (name, options?, value) and object syntax.
+	*/
+	function parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {
+		if (typeof fixturesOrName !== "string") return fixturesOrName;
+		const fixtureName = fixturesOrName;
+		let fixtureOptions;
+		let fixtureValue;
+		if (maybeFn !== void 0) {
+			fixtureOptions = optionsOrFn;
+			fixtureValue = maybeFn;
+		} else if (optionsOrFn !== null && typeof optionsOrFn === "object" && !Array.isArray(optionsOrFn) && ("scope" in optionsOrFn || "auto" in optionsOrFn)) {
+			fixtureOptions = optionsOrFn;
+			fixtureValue = {};
+		} else {
+			fixtureOptions = void 0;
+			fixtureValue = optionsOrFn;
+		}
+		if (typeof fixtureValue === "function") {
+			const builderFn = fixtureValue;
+			const fixture = async (ctx, use) => {
+				let cleanup;
+				const onCleanup = (fn) => {
+					if (cleanup !== void 0) throw new Error("onCleanup can only be called once per fixture. Define separate fixtures if you need multiple cleanup functions.");
+					cleanup = fn;
+				};
+				await use(await builderFn(ctx, { onCleanup }));
+				if (cleanup) await cleanup();
+			};
+			configureProps(fixture, { original: builderFn });
+			if (fixtureOptions) return { [fixtureName]: [fixture, fixtureOptions] };
+			return { [fixtureName]: fixture };
+		}
+		if (fixtureOptions) return { [fixtureName]: [fixtureValue, fixtureOptions] };
+		return { [fixtureName]: fixtureValue };
+	}
+	taskFn.override = function(fixturesOrName, optionsOrFn, maybeFn) {
+		const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+		getChainableContext(this).getFixtures().override(runner, userFixtures);
+		return this;
+	};
+	taskFn.scoped = function(fixtures) {
+		console.warn(`test.scoped() is deprecated and will be removed in future versions. Please use test.override() instead.`);
+		return this.override(fixtures);
+	};
+	taskFn.extend = function(fixturesOrName, optionsOrFn, maybeFn) {
+		const userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);
+		const fixtures = getChainableContext(this).getFixtures().extend(runner, userFixtures);
+		const _test = createTest(function(name, optionsOrFn, optionsOrTest) {
+			fn.call(this, formatName(name), optionsOrFn, optionsOrTest);
+		});
+		getChainableContext(_test).mergeContext({ fixtures });
+		return _test;
+	};
+	taskFn.describe = suite;
+	taskFn.suite = suite;
+	taskFn.beforeEach = beforeEach;
+	taskFn.afterEach = afterEach;
+	taskFn.beforeAll = beforeAll;
+	taskFn.afterAll = afterAll;
+	taskFn.aroundEach = aroundEach;
+	taskFn.aroundAll = aroundAll;
+	return createChainable([
+		"concurrent",
+		"sequential",
+		"skip",
+		"only",
+		"todo",
+		"fails"
+	], taskFn, { fixtures: new TestFixtures() });
+}
+function createTest(fn) {
+	return createTaskCollector(fn);
+}
+function formatName(name) {
+	return typeof name === "string" ? name : typeof name === "function" ? name.name || "<anonymous>" : String(name);
+}
+function formatTitle(template, items, idx) {
+	if (template.includes("%#") || template.includes("%$")) template = template.replace(/%%/g, "__vitest_escaped_%__").replace(/%#/g, `${idx}`).replace(/%\$/g, `${idx + 1}`).replace(/__vitest_escaped_%__/g, "%%");
+	const count = template.split("%").length - 1;
+	if (template.includes("%f")) (template.match(/%f/g) || []).forEach((_, i) => {
+		if (isNegativeNaN(items[i]) || Object.is(items[i], -0)) {
+			let occurrence = 0;
+			template = template.replace(/%f/g, (match) => {
+				occurrence++;
+				return occurrence === i + 1 ? "-%f" : match;
+			});
+		}
+	});
+	const isObjectItem = isObject(items[0]);
+	function formatAttribute(s) {
+		return s.replace(/\$([$\w.]+)/g, (_, key) => {
+			const isArrayKey = /^\d+$/.test(key);
+			if (!isObjectItem && !isArrayKey) return `$${key}`;
+			const arrayElement = isArrayKey ? objectAttr(items, key) : void 0;
+			return objDisplay(isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement, { truncate: runner?.config?.chaiConfig?.truncateThreshold });
+		});
+	}
+	let output = "";
+	let i = 0;
+	handleRegexMatch(template, formatRegExp, (match) => {
+		if (i < count) output += format(match[0], items[i++]);
+		else output += match[0];
+	}, (nonMatch) => {
+		output += formatAttribute(nonMatch);
+	});
+	return output;
+}
+function handleRegexMatch(input, regex, onMatch, onNonMatch) {
+	let lastIndex = 0;
+	for (const m of input.matchAll(regex)) {
+		if (lastIndex < m.index) onNonMatch(input.slice(lastIndex, m.index));
+		onMatch(m);
+		lastIndex = m.index + m[0].length;
+	}
+	if (lastIndex < input.length) onNonMatch(input.slice(lastIndex));
+}
+function formatTemplateString(cases, args) {
+	const header = cases.join("").trim().replace(/ /g, "").split("\n").map((i) => i.split("|"))[0];
+	const res = [];
+	for (let i = 0; i < Math.floor(args.length / header.length); i++) {
+		const oneCase = {};
+		for (let j = 0; j < header.length; j++) oneCase[header[j]] = args[i * header.length + j];
+		res.push(oneCase);
+	}
+	return res;
+}
+const now$2 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+const collectorContext = {
+	tasks: [],
+	currentSuite: null
+};
+function collectTask(task) {
+	collectorContext.currentSuite?.tasks.push(task);
+}
+async function runWithSuite(suite, fn) {
+	const prev = collectorContext.currentSuite;
+	collectorContext.currentSuite = suite;
+	await fn();
+	collectorContext.currentSuite = prev;
+}
+function withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {
+	if (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) return fn;
+	const { setTimeout, clearTimeout } = getSafeTimers();
+	return (function runWithTimeout(...args) {
+		const startTime = now$2();
+		const runner = getRunner();
+		runner._currentTaskStartTime = startTime;
+		runner._currentTaskTimeout = timeout;
+		return new Promise((resolve_, reject_) => {
+			const timer = setTimeout(() => {
+				clearTimeout(timer);
+				rejectTimeoutError();
+			}, timeout);
+			timer.unref?.();
+			function rejectTimeoutError() {
+				const error = makeTimeoutError(isHook, timeout, stackTraceError);
+				onTimeout?.(args, error);
+				reject_(error);
+			}
+			function resolve(result) {
+				runner._currentTaskStartTime = void 0;
+				runner._currentTaskTimeout = void 0;
+				clearTimeout(timer);
+				if (now$2() - startTime >= timeout) {
+					rejectTimeoutError();
+					return;
+				}
+				resolve_(result);
+			}
+			function reject(error) {
+				runner._currentTaskStartTime = void 0;
+				runner._currentTaskTimeout = void 0;
+				clearTimeout(timer);
+				reject_(error);
+			}
+			try {
+				const result = fn(...args);
+				if (typeof result === "object" && result != null && typeof result.then === "function") result.then(resolve, reject);
+				else resolve(result);
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
+function withCancel(fn, signal) {
+	return (function runWithCancel(...args) {
+		return new Promise((resolve, reject) => {
+			signal.addEventListener("abort", () => reject(signal.reason));
+			try {
+				const result = fn(...args);
+				if (typeof result === "object" && result != null && typeof result.then === "function") result.then(resolve, reject);
+				else resolve(result);
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
+const abortControllers = /* @__PURE__ */ new WeakMap();
+function abortIfTimeout([context], error) {
+	if (context) abortContextSignal(context, error);
+}
+function abortContextSignal(context, error) {
+	abortControllers.get(context)?.abort(error);
+}
+function createTestContext(test, runner) {
+	const context = function() {
+		throw new Error("done() callback is deprecated, use promise instead");
+	};
+	let abortController = abortControllers.get(context);
+	if (!abortController) {
+		abortController = new AbortController();
+		abortControllers.set(context, abortController);
+	}
+	context.signal = abortController.signal;
+	context.task = test;
+	context.skip = (condition, note) => {
+		if (condition === false) return;
+		test.result ?? (test.result = { state: "skip" });
+		test.result.pending = true;
+		throw new PendingError("test is skipped; abort execution", test, typeof condition === "string" ? condition : note);
+	};
+	context.annotate = ((message, type, attachment) => {
+		if (test.result && test.result.state !== "run") throw new Error(`Cannot annotate tests outside of the test run. The test "${test.name}" finished running with the "${test.result.state}" state already.`);
+		const annotation = {
+			message,
+			type: typeof type === "object" || type === void 0 ? "notice" : type
+		};
+		const annotationAttachment = typeof type === "object" ? type : attachment;
+		if (annotationAttachment) {
+			annotation.attachment = annotationAttachment;
+			manageArtifactAttachment(annotation.attachment);
+		}
+		return recordAsyncOperation(test, recordArtifact(test, {
+			type: "internal:annotation",
+			annotation
+		}).then(async ({ annotation }) => {
+			if (!runner.onTestAnnotate) throw new Error(`Test runner doesn't support test annotations.`);
+			await finishSendTasksUpdate(runner);
+			const resolvedAnnotation = await runner.onTestAnnotate(test, annotation);
+			test.annotations.push(resolvedAnnotation);
+			return resolvedAnnotation;
+		}));
+	});
+	context.onTestFailed = (handler, timeout) => {
+		test.onFailed || (test.onFailed = []);
+		test.onFailed.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
+	};
+	context.onTestFinished = (handler, timeout) => {
+		test.onFinished || (test.onFinished = []);
+		test.onFinished.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), (_, error) => abortController.abort(error)));
+	};
+	return runner.extendTaskContext?.(context) || context;
+}
+function makeTimeoutError(isHook, timeout, stackTraceError) {
+	const message = `${isHook ? "Hook" : "Test"} timed out in ${timeout}ms.\nIf this is a long-running ${isHook ? "hook" : "test"}, pass a timeout value as the last argument or configure it globally with "${isHook ? "hookTimeout" : "testTimeout"}".`;
+	const error = new Error(message);
+	if (stackTraceError?.stack) error.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);
+	return error;
+}
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+const unixNow = Date.now;
+const { clearTimeout, setTimeout } = getSafeTimers();
+const packs = /* @__PURE__ */ new Map();
+const eventsPacks = [];
+const pendingTasksUpdates = [];
+function sendTasksUpdate(runner) {
+	if (packs.size) {
+		const taskPacks = Array.from(packs).map(([id, task]) => {
+			return [
+				id,
+				task[0],
+				task[1]
+			];
+		});
+		const p = runner.onTaskUpdate?.(taskPacks, eventsPacks);
+		if (p) {
+			pendingTasksUpdates.push(p);
+			p.then(() => pendingTasksUpdates.splice(pendingTasksUpdates.indexOf(p), 1), () => {});
+		}
+		eventsPacks.length = 0;
+		packs.clear();
+	}
+}
+async function finishSendTasksUpdate(runner) {
+	sendTasksUpdate(runner);
+	await Promise.all(pendingTasksUpdates);
+}
+function throttle(fn, ms) {
+	let last = 0;
+	let pendingCall;
+	return function call(...args) {
+		const now = unixNow();
+		if (now - last > ms) {
+			last = now;
+			clearTimeout(pendingCall);
+			pendingCall = void 0;
+			return fn.apply(this, args);
+		}
+		pendingCall ?? (pendingCall = setTimeout(() => call.bind(this)(...args), ms));
+	};
+}
+throttle(sendTasksUpdate, 100);
+/**
+* @experimental
+* @advanced
+*
+* Records a custom test artifact during test execution.
+*
+* This function allows you to attach structured data, files, or metadata to a test.
+*
+* Vitest automatically injects the source location where the artifact was created and manages any attachments you include.
+*
+* **Note:** artifacts must be recorded before the task is reported. Any artifacts recorded after that will not be included in the task.
+*
+* @param task - The test task context, typically accessed via `this.task` in custom matchers or `context.task` in tests
+* @param artifact - The artifact to record. Must extend {@linkcode TestArtifactBase}
+*
+* @returns A promise that resolves to the recorded artifact with location injected
+*
+* @throws {Error} If the test runner doesn't support artifacts
+*
+* @example
+* ```ts
+* // In a custom assertion
+* async function toHaveValidSchema(this: MatcherState, actual: unknown) {
+*   const validation = validateSchema(actual)
+*
+*   await recordArtifact(this.task, {
+*     type: 'my-plugin:schema-validation',
+*     passed: validation.valid,
+*     errors: validation.errors,
+*   })
+*
+*   return { pass: validation.valid, message: () => '...' }
+* }
+* ```
+*/
+async function recordArtifact(task, artifact) {
+	const runner = getRunner();
+	const stack = findTestFileStackTrace(task.file.filepath, (/* @__PURE__ */ new Error("STACK_TRACE")).stack);
+	if (stack) {
+		artifact.location = {
+			file: stack.file,
+			line: stack.line,
+			column: stack.column
+		};
+		if (artifact.type === "internal:annotation") artifact.annotation.location = artifact.location;
+	}
+	if (Array.isArray(artifact.attachments)) for (const attachment of artifact.attachments) manageArtifactAttachment(attachment);
+	if (artifact.type === "internal:annotation") return artifact;
+	if (!runner.onTestArtifactRecord) throw new Error(`Test runner doesn't support test artifacts.`);
+	await finishSendTasksUpdate(runner);
+	const resolvedArtifact = await runner.onTestArtifactRecord(task, artifact);
+	task.artifacts.push(resolvedArtifact);
+	return resolvedArtifact;
+}
+const table = [];
+for (let i = 65; i < 91; i++) table.push(String.fromCharCode(i));
+for (let i = 97; i < 123; i++) table.push(String.fromCharCode(i));
+for (let i = 0; i < 10; i++) table.push(i.toString(10));
+table.push("+", "/");
+function encodeUint8Array(bytes) {
+	let base64 = "";
+	const len = bytes.byteLength;
+	for (let i = 0; i < len; i += 3) if (len === i + 1) {
+		const a = (bytes[i] & 252) >> 2;
+		const b = (bytes[i] & 3) << 4;
+		base64 += table[a];
+		base64 += table[b];
+		base64 += "==";
+	} else if (len === i + 2) {
+		const a = (bytes[i] & 252) >> 2;
+		const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+		const c = (bytes[i + 1] & 15) << 2;
+		base64 += table[a];
+		base64 += table[b];
+		base64 += table[c];
+		base64 += "=";
+	} else {
+		const a = (bytes[i] & 252) >> 2;
+		const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+		const c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;
+		const d = bytes[i + 2] & 63;
+		base64 += table[a];
+		base64 += table[b];
+		base64 += table[c];
+		base64 += table[d];
+	}
+	return base64;
+}
+/**
+* Records an async operation associated with a test task.
+*
+* This function tracks promises that should be awaited before a test completes.
+* The promise is automatically removed from the test's promise list once it settles.
+*/
+function recordAsyncOperation(test, promise) {
+	promise = promise.finally(() => {
+		if (!test.promises) return;
+		const index = test.promises.indexOf(promise);
+		if (index !== -1) test.promises.splice(index, 1);
+	});
+	if (!test.promises) test.promises = [];
+	test.promises.push(promise);
+	return promise;
+}
+/**
+* Validates and prepares a test attachment for serialization.
+*
+* This function ensures attachments have either `body` or `path` set (but not both), and converts `Uint8Array` bodies to base64-encoded strings for easier serialization.
+*
+* @param attachment - The attachment to validate and prepare
+*
+* @throws {TypeError} If neither `body` nor `path` is provided
+* @throws {TypeError} If both `body` and `path` are provided
+*/
+function manageArtifactAttachment(attachment) {
+	if (attachment.body == null && !attachment.path) throw new TypeError(`Test attachment requires "body" or "path" to be set. Both are missing.`);
+	if (attachment.body && attachment.path) throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
+	if (attachment.body instanceof Uint8Array) attachment.body = encodeUint8Array(attachment.body);
+}
+//#endregion
+export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks };
+
+//# sourceMappingURL=index.js.map