@cartanova/qgrid-cli 2.4.7 → 2.4.9

package/bundle/dist/node_modules/.pnpm/@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/chunk-artifact.js

@@ -0,0 +1,2756 @@
+import { format, formatRegExp, objDisplay } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/display.js";
+import { assertTypes, createDefer, filterOutComments, isNegativeNaN, isObject, objectAttr, ordinal, shuffle, toArray, unique } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js";
+import { processError } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/error.js";
+import { getSafeTimers } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/timers.js";
+import { parseSingleStack } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/source-map.js";
+import { b as relative } from "../../../../../pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.js";
+import "../../../../../pathe@2.0.3/node_modules/pathe/dist/index.js";
+//#region ../../node_modules/.pnpm/@vitest+runner@4.1.10/node_modules/@vitest/runner/dist/chunk-artifact.js
+var PendingError = class extends Error {
+	code = "VITEST_PENDING";
+	taskId;
+	constructor(message, task, note) {
+		super(message);
+		this.message = message;
+		this.note = note;
+		this.taskId = task.id;
+	}
+};
+var TestRunAbortError = class extends Error {
+	name = "TestRunAbortError";
+	reason;
+	constructor(message, reason) {
+		super(message);
+		this.reason = reason;
+	}
+};
+var FixtureDependencyError = class extends Error {
+	name = "FixtureDependencyError";
+};
+var FixtureAccessError = class extends Error {
+	name = "FixtureAccessError";
+};
+var FixtureParseError = class extends Error {
+	name = "FixtureParseError";
+};
+var AroundHookSetupError = class extends Error {
+	name = "AroundHookSetupError";
+};
+var AroundHookTeardownError = class extends Error {
+	name = "AroundHookTeardownError";
+};
+var AroundHookMultipleCallsError = class extends Error {
+	name = "AroundHookMultipleCallsError";
+};
+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);
+}
+const FIXTURE_STACK_TRACE_KEY = Symbol.for("VITEST_FIXTURE_STACK_TRACE");
+var TestFixtures = class TestFixtures {
+	_suiteContexts;
+	_overrides = /* @__PURE__ */ new WeakMap();
+	_registrations;
+	static _definitions = [];
+	static _builtinFixtures = [
+		"task",
+		"signal",
+		"onTestFailed",
+		"onTestFinished",
+		"skip",
+		"annotate"
+	];
+	static _fixtureOptionKeys = [
+		"auto",
+		"injected",
+		"scope"
+	];
+	static _fixtureScopes = [
+		"test",
+		"file",
+		"worker"
+	];
+	static _workerContextSuite = { type: "worker" };
+	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));
+	}
+	static isFixtureOptions(obj) {
+		return isObject(obj) && Object.keys(obj).some((key) => TestFixtures._fixtureOptionKeys.includes(key));
+	}
+	constructor(registrations) {
+		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;
+		const registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel);
+		return new TestFixtures(registrations);
+	}
+	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 && TestFixtures.isFixtureOptions(fn[1])) {
+				_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
+			};
+			if (isFixtureFunction(value)) Object.assign(value, { [FIXTURE_STACK_TRACE_KEY]: /* @__PURE__ */ new Error("STACK_TRACE_ERROR") });
+			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;
+	}
+};
+const cleanupFnArrayMap = /* @__PURE__ */ new WeakMap();
+async function callFixtureCleanup(context) {
+	const cleanupFnArray = cleanupFnArrayMap.get(context) ?? [];
+	for (const cleanup of cleanupFnArray.reverse()) await cleanup();
+	cleanupFnArrayMap.delete(context);
+}
+/**
+* Returns the current number of cleanup functions registered for the context.
+* This can be used as a checkpoint to later clean up only fixtures added after this point.
+*/
+function getFixtureCleanupCount(context) {
+	return cleanupFnArrayMap.get(context)?.length ?? 0;
+}
+/**
+* Cleans up only fixtures that were added after the given checkpoint index.
+* This is used by aroundEach to clean up fixtures created inside runTest()
+* while preserving fixtures that were created for aroundEach itself.
+*/
+async function callFixtureCleanupFrom(context, fromIndex) {
+	const cleanupFnArray = cleanupFnArrayMap.get(context);
+	if (!cleanupFnArray || cleanupFnArray.length <= fromIndex) return;
+	const toCleanup = cleanupFnArray.slice(fromIndex);
+	for (const cleanup of toCleanup.reverse()) await cleanup();
+	cleanupFnArray.length = fromIndex;
+}
+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 (isAutoFixture(fixture, options) || 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 isAutoFixture(fixture, options) {
+	if (!fixture.auto) return false;
+	if (options?.suiteHook && fixture.scope === "test") return false;
+	return true;
+}
+function isFixtureFunction(value) {
+	return typeof value === "function";
+}
+function resolveTestFixtureValue(fixture, context, cleanupFnArray) {
+	if (!isFixtureFunction(fixture.value)) return fixture.value;
+	return resolveFixtureFunction(fixture.value, fixture.name, 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.name, 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, fixtureName, context, cleanupFnArray) {
+	const useFnArgPromise = createDefer();
+	const stackTraceError = FIXTURE_STACK_TRACE_KEY in fixtureFn && fixtureFn[FIXTURE_STACK_TRACE_KEY] instanceof Error ? fixtureFn[FIXTURE_STACK_TRACE_KEY] : void 0;
+	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;
+	}).then(() => {
+		if (!isUseFnArgResolved) {
+			const error = /* @__PURE__ */ new Error(`Fixture "${fixtureName}" returned without calling "use". Make sure to call "use" in every code path of the fixture function.`);
+			if (stackTraceError?.stack) error.stack = error.message + stackTraceError.stack.replace(stackTraceError.message, "");
+			useFnArgPromise.reject(error);
+		}
+	}).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 setCurrentTest(test) {
+	_test = test;
+}
+function getCurrentTest() {
+	return _test;
+}
+const tests = [];
+function addRunningTest(test) {
+	tests.push(test);
+	return () => {
+		tests.splice(tests.indexOf(test));
+	};
+}
+function getRunningTests() {
+	return tests;
+}
+const kChainableContext = Symbol("kChainableContext");
+function getChainableContext(chainable) {
+	return chainable?.[kChainableContext];
+}
+function createChainable(keys, fn, context) {
+	function create(context) {
+		const chain = function(...args) {
+			return fn.apply(context, args);
+		};
+		Object.assign(chain, fn);
+		Object.defineProperty(chain, kChainableContext, {
+			value: {
+				withContext: () => chain.bind(context),
+				getFixtures: () => context.fixtures,
+				setContext: (key, value) => {
+					context[key] = value;
+				},
+				mergeContext: (ctx) => {
+					Object.assign(context, ctx);
+				}
+			},
+			enumerable: false
+		});
+		for (const key of keys) Object.defineProperty(chain, key, { get() {
+			return create({
+				...context,
+				[key]: true
+			});
+		} });
+		return chain;
+	}
+	const chain = create(context ?? {});
+	Object.defineProperty(chain, "fn", {
+		value: fn,
+		enumerable: false
+	});
+	return chain;
+}
+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");
+function getBeforeHookCleanupCallback(hook, result, context) {
+	if (typeof result === "function") return withTimeout(result, CLEANUP_TIMEOUT_KEY in hook && typeof hook[CLEANUP_TIMEOUT_KEY] === "number" ? hook[CLEANUP_TIMEOUT_KEY] : getDefaultHookTimeout(), true, CLEANUP_STACK_TRACE_KEY in hook && hook[CLEANUP_STACK_TRACE_KEY] instanceof Error ? hook[CLEANUP_STACK_TRACE_KEY] : void 0, (_, error) => {
+		if (context) abortContextSignal(context, error);
+	});
+}
+/**
+* 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));
+}
+/**
+* Registers a callback function to be executed when a test fails within the current suite.
+* This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.
+*
+* **Note:** The `onTestFailed` 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 upon a test failure. The function receives the test result (including errors).
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @throws {Error} Throws an error if the function is not called within a test.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using onTestFailed to log failure details
+* onTestFailed(({ errors }) => {
+*   console.log(`Test failed: ${test.name}`, errors);
+* });
+* ```
+*/
+const onTestFailed = createTestHook("onTestFailed", (test, handler, timeout) => {
+	test.onFailed ||= [];
+	test.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+});
+/**
+* Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).
+* This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.
+*
+* This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.
+*
+* **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* **Note:** The `onTestFinished` hook is not called if the test is canceled with a dynamic `ctx.skip()` call.
+*
+* @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @throws {Error} Throws an error if the function is not called within a test.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using onTestFinished for cleanup
+* const db = await connectToDatabase();
+* onTestFinished(async () => {
+*   await db.disconnect();
+* });
+* ```
+*/
+const onTestFinished = createTestHook("onTestFinished", (test, handler, timeout) => {
+	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 getAroundHookTimeout(hook) {
+	return AROUND_TIMEOUT_KEY in hook && typeof hook[AROUND_TIMEOUT_KEY] === "number" ? hook[AROUND_TIMEOUT_KEY] : getDefaultHookTimeout();
+}
+function getAroundHookStackTrace(hook) {
+	return AROUND_STACK_TRACE_KEY in hook && hook[AROUND_STACK_TRACE_KEY] instanceof Error ? hook[AROUND_STACK_TRACE_KEY] : void 0;
+}
+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);
+	};
+}
+/**
+* If any tasks been marked as `only`, mark all other tasks as `skip`.
+*/
+function interpretTaskModes(file, namePattern, testLocations, testIds, testTagsFilter, onlyMode, parentIsOnly, allowOnly) {
+	const matchedLocations = [];
+	const traverseSuite = (suite, parentIsOnly, parentMatchedWithLocation) => {
+		const suiteIsOnly = parentIsOnly || suite.mode === "only";
+		const hasSomeTasksOnly = onlyMode && suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
+		suite.tasks.forEach((t) => {
+			const includeTask = hasSomeTasksOnly ? t.mode === "only" || t.type === "suite" && someTasksAreOnly(t) : suiteIsOnly || t.mode === "only";
+			if (onlyMode) {
+				if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
+					if (t.mode === "only") {
+						checkAllowOnly(t, allowOnly);
+						t.mode = "run";
+					}
+				} else if (t.mode === "run" && !includeTask) t.mode = "skip";
+				else if (t.mode === "only") {
+					checkAllowOnly(t, allowOnly);
+					t.mode = "run";
+				}
+			}
+			let hasLocationMatch = parentMatchedWithLocation;
+			if (testLocations !== void 0 && testLocations.length !== 0) {
+				if (t.location && testLocations?.includes(t.location.line)) {
+					t.mode = "run";
+					matchedLocations.push(t.location.line);
+					hasLocationMatch = true;
+				} else if (parentMatchedWithLocation) t.mode = "run";
+				else if (t.type === "test") t.mode = "skip";
+			}
+			if (t.type === "test") {
+				if (namePattern && !getTaskFullName(t).match(namePattern)) t.mode = "skip";
+				if (testIds && !testIds.includes(t.id)) t.mode = "skip";
+				if (testTagsFilter && !testTagsFilter(t.tags || [])) t.mode = "skip";
+			} else if (t.type === "suite") if (t.mode === "skip") skipAllTasks(t);
+			else if (t.mode === "todo") todoAllTasks(t);
+			else traverseSuite(t, includeTask, hasLocationMatch);
+		});
+		if (suite.mode === "run" || suite.mode === "queued") {
+			if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run" && i.mode !== "queued")) suite.mode = "skip";
+		}
+	};
+	traverseSuite(file, parentIsOnly, false);
+	const nonMatching = testLocations?.filter((loc) => !matchedLocations.includes(loc));
+	if (nonMatching && nonMatching.length !== 0) {
+		const message = nonMatching.length === 1 ? `line ${nonMatching[0]}` : `lines ${nonMatching.join(", ")}`;
+		if (file.result === void 0) file.result = {
+			state: "fail",
+			errors: []
+		};
+		if (file.result.errors === void 0) file.result.errors = [];
+		file.result.errors.push(processError(/* @__PURE__ */ new Error(`No test found in ${file.name} in ${message}`)));
+	}
+}
+function getTaskFullName(task) {
+	return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
+}
+function someTasksAreOnly(suite) {
+	return suite.tasks.some((t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t));
+}
+function skipAllTasks(suite) {
+	suite.tasks.forEach((t) => {
+		if (t.mode === "run" || t.mode === "queued") {
+			t.mode = "skip";
+			if (t.type === "suite") skipAllTasks(t);
+		}
+	});
+}
+function todoAllTasks(suite) {
+	suite.tasks.forEach((t) => {
+		if (t.mode === "run" || t.mode === "queued") {
+			t.mode = "todo";
+			if (t.type === "suite") todoAllTasks(t);
+		}
+	});
+}
+function checkAllowOnly(task, allowOnly) {
+	if (allowOnly) return;
+	task.result = {
+		state: "fail",
+		errors: [processError(/* @__PURE__ */ new Error("[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"))]
+	};
+}
+/* @__NO_SIDE_EFFECTS__ */
+function generateHash(str) {
+	let hash = 0;
+	if (str.length === 0) return `${hash}`;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return `${hash}`;
+}
+function calculateSuiteHash(parent) {
+	parent.tasks.forEach((t, idx) => {
+		t.id = `${parent.id}_${idx}`;
+		if (t.type === "suite") calculateSuiteHash(t);
+	});
+}
+function createFileTask(filepath, root, projectName, pool, viteEnvironment) {
+	const path = relative(root, filepath);
+	const file = {
+		id: /* @__PURE__ */ generateFileHash(path, projectName),
+		name: path,
+		fullName: path,
+		type: "suite",
+		mode: "queued",
+		filepath,
+		tasks: [],
+		meta: Object.create(null),
+		projectName,
+		file: void 0,
+		pool,
+		viteEnvironment
+	};
+	file.file = file;
+	return file;
+}
+/**
+* Generate a unique ID for a file based on its path and project name
+* @param file File relative to the root of the project to keep ID the same between different machines
+* @param projectName The name of the test project
+*/
+/* @__NO_SIDE_EFFECTS__ */
+function generateFileHash(file, projectName) {
+	return /* @__PURE__ */ generateHash(`${file}${projectName || ""}`);
+}
+function findTestFileStackTrace(testFilePath, error) {
+	const lines = error.split("\n").slice(1);
+	for (const line of lines) {
+		const stack = parseSingleStack(line);
+		if (stack && stack.file === testFilePath) return stack;
+	}
+}
+/**
+* Return a function for running multiple async operations with limited concurrency.
+*/
+function limitConcurrency(concurrency = Infinity) {
+	let count = 0;
+	let head;
+	let tail;
+	const finish = () => {
+		count--;
+		if (head) {
+			head[0]();
+			head = head[1];
+			tail = head && tail;
+		}
+	};
+	const acquire = () => {
+		let released = false;
+		const release = () => {
+			if (!released) {
+				released = true;
+				finish();
+			}
+		};
+		if (count++ < concurrency) return release;
+		return new Promise((resolve) => {
+			if (tail) tail = tail[1] = [() => resolve(release)];
+			else head = tail = [() => resolve(release)];
+		});
+	};
+	const limiterFn = (func, ...args) => {
+		function run(release) {
+			try {
+				const result = func(...args);
+				if (result instanceof Promise) return result.finally(release);
+				release();
+				return Promise.resolve(result);
+			} catch (error) {
+				release();
+				return Promise.reject(error);
+			}
+		}
+		const release = acquire();
+		return release instanceof Promise ? release.then(run) : run(release);
+	};
+	return Object.assign(limiterFn, { acquire });
+}
+/**
+* Partition in tasks groups by consecutive concurrent
+*/
+function partitionSuiteChildren(suite) {
+	let tasksGroup = [];
+	const tasksGroups = [];
+	for (const c of suite.tasks) if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) tasksGroup.push(c);
+	else {
+		tasksGroups.push(tasksGroup);
+		tasksGroup = [c];
+	}
+	if (tasksGroup.length > 0) tasksGroups.push(tasksGroup);
+	return tasksGroups;
+}
+const filterMap = /* @__PURE__ */ new WeakMap();
+/**
+* @experimental
+*/
+function matchesTags(testTags) {
+	const runner = getRunner();
+	const tagsFilter = runner._currentSpecification?.testTagsFilter ?? runner.config.tagsFilter;
+	if (!tagsFilter) return true;
+	let tagsFilterPredicate = filterMap.get(tagsFilter);
+	if (!tagsFilterPredicate) {
+		tagsFilterPredicate = createTagsFilter(tagsFilter, runner.config.tags);
+		filterMap.set(tagsFilter, tagsFilterPredicate);
+	}
+	return tagsFilterPredicate(testTags);
+}
+function validateTags(config, tags) {
+	if (!config.strictTags) return;
+	const availableTags = new Set(config.tags.map((tag) => tag.name));
+	for (const tag of tags) if (!availableTags.has(tag)) throw createNoTagsError(config.tags, tag);
+}
+function createNoTagsError(availableTags, tag, prefix = "tag") {
+	if (!availableTags.length) throw new Error(`The Vitest config does't define any "tags", cannot apply "${tag}" ${prefix} for this test. See: https://vitest.dev/guide/test-tags`);
+	throw new Error(`The ${prefix} "${tag}" is not defined in the configuration. Available tags are:\n${availableTags.map((t) => `- ${t.name}${t.description ? `: ${t.description}` : ""}`).join("\n")}`);
+}
+function createTagsFilter(tagsExpr, availableTags) {
+	const matchers = tagsExpr.map((expr) => parseTagsExpression(expr, availableTags));
+	return (testTags) => {
+		return matchers.every((matcher) => matcher(testTags));
+	};
+}
+function parseTagsExpression(expr, availableTags) {
+	const stream = new TokenStream(tokenize(expr), expr);
+	const ast = parseOrExpression(stream, availableTags);
+	if (stream.peek().type !== "EOF") throw new Error(`Invalid tags expression: unexpected "${formatToken(stream.peek())}" in "${expr}"`);
+	return (tags) => evaluateNode(ast, tags);
+}
+function formatToken(token) {
+	switch (token.type) {
+		case "TAG": return token.value;
+		default: return formatTokenType(token.type);
+	}
+}
+function tokenize(expr) {
+	const tokens = [];
+	let i = 0;
+	while (i < expr.length) {
+		if (expr[i] === " " || expr[i] === "	") {
+			i++;
+			continue;
+		}
+		if (expr[i] === "(") {
+			tokens.push({ type: "LPAREN" });
+			i++;
+			continue;
+		}
+		if (expr[i] === ")") {
+			tokens.push({ type: "RPAREN" });
+			i++;
+			continue;
+		}
+		if (expr[i] === "!") {
+			tokens.push({ type: "NOT" });
+			i++;
+			continue;
+		}
+		if (expr.slice(i, i + 2) === "&&") {
+			tokens.push({ type: "AND" });
+			i += 2;
+			continue;
+		}
+		if (expr.slice(i, i + 2) === "||") {
+			tokens.push({ type: "OR" });
+			i += 2;
+			continue;
+		}
+		if (/^and(?:\s|\)|$)/i.test(expr.slice(i))) {
+			tokens.push({ type: "AND" });
+			i += 3;
+			continue;
+		}
+		if (/^or(?:\s|\)|$)/i.test(expr.slice(i))) {
+			tokens.push({ type: "OR" });
+			i += 2;
+			continue;
+		}
+		if (/^not\s/i.test(expr.slice(i))) {
+			tokens.push({ type: "NOT" });
+			i += 3;
+			continue;
+		}
+		let tag = "";
+		while (i < expr.length && expr[i] !== " " && expr[i] !== "	" && expr[i] !== "(" && expr[i] !== ")" && expr[i] !== "!" && expr[i] !== "&" && expr[i] !== "|") {
+			const remaining = expr.slice(i);
+			if (tag === "" && (/^and(?:\s|\)|$)/i.test(remaining) || /^or(?:\s|\)|$)/i.test(remaining) || /^not\s/i.test(remaining))) break;
+			tag += expr[i];
+			i++;
+		}
+		if (tag) tokens.push({
+			type: "TAG",
+			value: tag
+		});
+	}
+	tokens.push({ type: "EOF" });
+	return tokens;
+}
+var TokenStream = class {
+	pos = 0;
+	constructor(tokens, expr) {
+		this.tokens = tokens;
+		this.expr = expr;
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	next() {
+		return this.tokens[this.pos++];
+	}
+	expect(type) {
+		const token = this.next();
+		if (token.type !== type) {
+			if (type === "RPAREN" && token.type === "EOF") throw new Error(`Invalid tags expression: missing closing ")" in "${this.expr}"`);
+			throw new Error(`Invalid tags expression: expected "${formatTokenType(type)}" but got "${formatToken(token)}" in "${this.expr}"`);
+		}
+		return token;
+	}
+	unexpectedToken() {
+		const token = this.peek();
+		if (token.type === "EOF") throw new Error(`Invalid tags expression: unexpected end of expression in "${this.expr}"`);
+		throw new Error(`Invalid tags expression: unexpected "${formatToken(token)}" in "${this.expr}"`);
+	}
+};
+function formatTokenType(type) {
+	switch (type) {
+		case "TAG": return "tag";
+		case "AND": return "and";
+		case "OR": return "or";
+		case "NOT": return "not";
+		case "LPAREN": return "(";
+		case "RPAREN": return ")";
+		case "EOF": return "end of expression";
+	}
+}
+function parseOrExpression(stream, availableTags) {
+	let left = parseAndExpression(stream, availableTags);
+	while (stream.peek().type === "OR") {
+		stream.next();
+		const right = parseAndExpression(stream, availableTags);
+		left = {
+			type: "or",
+			left,
+			right
+		};
+	}
+	return left;
+}
+function parseAndExpression(stream, availableTags) {
+	let left = parseUnaryExpression(stream, availableTags);
+	while (stream.peek().type === "AND") {
+		stream.next();
+		const right = parseUnaryExpression(stream, availableTags);
+		left = {
+			type: "and",
+			left,
+			right
+		};
+	}
+	return left;
+}
+function parseUnaryExpression(stream, availableTags) {
+	if (stream.peek().type === "NOT") {
+		stream.next();
+		return {
+			type: "not",
+			operand: parseUnaryExpression(stream, availableTags)
+		};
+	}
+	return parsePrimaryExpression(stream, availableTags);
+}
+function parsePrimaryExpression(stream, availableTags) {
+	const token = stream.peek();
+	if (token.type === "LPAREN") {
+		stream.next();
+		const expr = parseOrExpression(stream, availableTags);
+		stream.expect("RPAREN");
+		return expr;
+	}
+	if (token.type === "TAG") {
+		stream.next();
+		const tagValue = token.value;
+		return {
+			type: "tag",
+			value: tagValue,
+			pattern: resolveTagPattern(tagValue, availableTags)
+		};
+	}
+	stream.unexpectedToken();
+}
+function createWildcardRegex(pattern) {
+	return new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+}
+function resolveTagPattern(tagPattern, availableTags) {
+	if (tagPattern.includes("*")) {
+		const regex = createWildcardRegex(tagPattern);
+		if (!availableTags.some((tag) => regex.test(tag.name))) throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+		return regex;
+	}
+	if (!availableTags.length || !availableTags.some((tag) => tag.name === tagPattern)) throw createNoTagsError(availableTags, tagPattern, "tag pattern");
+	return null;
+}
+function evaluateNode(node, tags) {
+	switch (node.type) {
+		case "tag":
+			if (node.pattern) return tags.some((tag) => node.pattern.test(tag));
+			return tags.includes(node.value);
+		case "not": return !evaluateNode(node.operand, tags);
+		case "and": return evaluateNode(node.left, tags) && evaluateNode(node.right, tags);
+		case "or": return evaluateNode(node.left, tags) || evaluateNode(node.right, tags);
+	}
+}
+function isTestCase(s) {
+	return s.type === "test";
+}
+function getTests(suite) {
+	const tests = [];
+	const arraySuites = toArray(suite);
+	for (const s of arraySuites) if (isTestCase(s)) tests.push(s);
+	else for (const task of s.tasks) if (isTestCase(task)) tests.push(task);
+	else {
+		const taskTests = getTests(task);
+		for (const test of taskTests) tests.push(test);
+	}
+	return tests;
+}
+function getTasks(tasks = []) {
+	return toArray(tasks).flatMap((s) => isTestCase(s) ? [s] : [s, ...getTasks(s.tasks)]);
+}
+function getSuites(suite) {
+	return toArray(suite).flatMap((s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []);
+}
+function hasTests(suite) {
+	return toArray(suite).some((s) => s.tasks.some((c) => isTestCase(c) || hasTests(c)));
+}
+function hasFailed(suite) {
+	return toArray(suite).some((s) => s.result?.state === "fail" || s.type === "suite" && hasFailed(s.tasks));
+}
+function getNames(task) {
+	const names = [task.name];
+	let current = task;
+	while (current?.suite) {
+		current = current.suite;
+		if (current?.name) names.unshift(current.name);
+	}
+	if (current !== task.file) names.unshift(task.file.name);
+	return names;
+}
+function getFullName(task, separator = " > ") {
+	return getNames(task).join(separator);
+}
+function getTestName(task, separator = " > ") {
+	return getNames(task).slice(1).join(separator);
+}
+function createTaskName(names, separator = " > ") {
+	return names.filter((name) => name !== void 0).join(separator);
+}
+/**
+* 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();
+/**
+* Defines a test case with a given name and test function. The test function can optionally be configured with test options.
+*
+* @param {string | Function} name - The name of the test or a function that will be used as a test name.
+* @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.
+* @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.
+* @throws {Error} If called inside another test function.
+* @example
+* ```ts
+* // Define a simple test
+* test('should add two numbers', () => {
+*   expect(add(1, 2)).toBe(3);
+* });
+* ```
+* @example
+* ```ts
+* // Define a test with options
+* test('should subtract two numbers', { retry: 3 }, () => {
+*   expect(subtract(5, 2)).toBe(3);
+* });
+* ```
+*/
+const test = 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);
+});
+/**
+* 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
+* describe('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
+* describe('String operations', () => {
+*   describe('Trimming', () => {
+*     test('should trim whitespace from start and end', () => {
+*       expect('  hello  '.trim()).toBe('hello');
+*     });
+*   });
+*
+*   describe('Concatenation', () => {
+*     test('should concatenate two strings', () => {
+*       expect('hello' + ' ' + 'world').toBe('hello world');
+*     });
+*   });
+* });
+* ```
+*/
+const describe = suite;
+/**
+* Defines a test case with a given name and test function. The test function can optionally be configured with test options.
+*
+* @param {string | Function} name - The name of the test or a function that will be used as a test name.
+* @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.
+* @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.
+* @throws {Error} If called inside another test function.
+* @example
+* ```ts
+* // Define a simple test
+* it('adds two numbers', () => {
+*   expect(add(1, 2)).toBe(3);
+* });
+* ```
+* @example
+* ```ts
+* // Define a test with options
+* it('subtracts two numbers', { retry: 3 }, () => {
+*   expect(subtract(5, 2)).toBe(3);
+* });
+* ```
+*/
+const it = test;
+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 getDefaultSuite() {
+	assert(defaultSuite, "the default suite");
+	return defaultSuite;
+}
+function getRunner() {
+	assert(runner, "the runner");
+	return runner;
+}
+function createDefaultSuite(runner) {
+	const config = runner.config.sequence;
+	const options = {};
+	if (config.concurrent != null) options.concurrent = config.concurrent;
+	const collector = suite("", options, () => {});
+	delete collector.suite;
+	return collector;
+}
+function clearCollectorContext(file, currentRunner) {
+	currentTestFilepath = file.filepath;
+	runner = currentRunner;
+	if (!defaultSuite) defaultSuite = createDefaultSuite(currentRunner);
+	defaultSuite.file = file;
+	collectorContext.tasks.length = 0;
+	defaultSuite.clear();
+	collectorContext.currentSuite = defaultSuite;
+}
+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])
+		};
+		if (runner && includeLocation && runner.config.includeTaskLocation) {
+			const limit = Error.stackTraceLimit;
+			Error.stackTraceLimit = 15;
+			const error = (/* @__PURE__ */ new Error("stacktrace")).stack;
+			Error.stackTraceLimit = limit;
+			const stack = findTestFileStackTrace(currentTestFilepath, error);
+			if (stack) suite.location = {
+				line: stack.line,
+				column: stack.column
+			};
+		}
+		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) && TestFixtures.isFixtureOptions(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 ??= { 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.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.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;
+}
+async function runSetupFiles(config, files, runner) {
+	if (config.sequence.setupFiles === "parallel") await Promise.all(files.map(async (fsPath) => {
+		await runner.importFile(fsPath, "setup");
+	}));
+	else for (const fsPath of files) await runner.importFile(fsPath, "setup");
+}
+const now$1 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+async function collectTests(specs, runner) {
+	const files = [];
+	const config = runner.config;
+	const $ = runner.trace;
+	let defaultTagsFilter;
+	for (const spec of specs) {
+		const filepath = typeof spec === "string" ? spec : spec.filepath;
+		await $("collect_spec", { "code.file.path": filepath }, async () => {
+			runner._currentSpecification = typeof spec === "string" ? { filepath: spec } : spec;
+			const testLocations = typeof spec === "string" ? void 0 : spec.testLocations;
+			const testNamePattern = typeof spec === "string" ? void 0 : spec.testNamePattern;
+			const testIds = typeof spec === "string" ? void 0 : spec.testIds;
+			const testTagsFilter = typeof spec === "object" && spec.testTagsFilter ? createTagsFilter(spec.testTagsFilter, config.tags) : void 0;
+			const fileTags = typeof spec === "string" ? [] : spec.fileTags || [];
+			const file = createFileTask(filepath, config.root, config.name, runner.pool, runner.viteEnvironment);
+			file.tags = fileTags;
+			file.shuffle = config.sequence.shuffle;
+			try {
+				validateTags(runner.config, fileTags);
+				runner.onCollectStart?.(file);
+				clearCollectorContext(file, runner);
+				const setupFiles = toArray(config.setupFiles);
+				if (setupFiles.length) {
+					const setupStart = now$1();
+					await runSetupFiles(config, setupFiles, runner);
+					file.setupDuration = now$1() - setupStart;
+				} else file.setupDuration = 0;
+				const collectStart = now$1();
+				await runner.importFile(filepath, "collect");
+				const durations = runner.getImportDurations?.();
+				if (durations) file.importDurations = durations;
+				const defaultTasks = await getDefaultSuite().collect(file);
+				const fileHooks = createSuiteHooks();
+				mergeHooks(fileHooks, getHooks(defaultTasks));
+				for (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) if (c.type === "test" || c.type === "suite") file.tasks.push(c);
+				else if (c.type === "collector") {
+					const suite = await c.collect(file);
+					if (suite.name || suite.tasks.length) {
+						mergeHooks(fileHooks, getHooks(suite));
+						file.tasks.push(suite);
+					}
+				}
+				setHooks(file, fileHooks);
+				file.collectDuration = now$1() - collectStart;
+			} catch (e) {
+				file.result = {
+					state: "fail",
+					errors: e instanceof AggregateError ? e.errors.map((e) => processError(e, runner.config.diffOptions)) : [processError(e, runner.config.diffOptions)]
+				};
+				const durations = runner.getImportDurations?.();
+				if (durations) file.importDurations = durations;
+			}
+			calculateSuiteHash(file);
+			const hasOnlyTasks = someTasksAreOnly(file);
+			if (!testTagsFilter && !defaultTagsFilter && config.tagsFilter) defaultTagsFilter = createTagsFilter(config.tagsFilter, config.tags);
+			interpretTaskModes(file, testNamePattern ?? config.testNamePattern, testLocations, testIds, testTagsFilter ?? defaultTagsFilter, hasOnlyTasks, false, config.allowOnly);
+			if (file.mode === "queued") file.mode = "run";
+			files.push(file);
+		});
+	}
+	return files;
+}
+function mergeHooks(baseHooks, hooks) {
+	for (const _key in hooks) {
+		const key = _key;
+		baseHooks[key].push(...hooks[key]);
+	}
+	return baseHooks;
+}
+const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+const unixNow = Date.now;
+const { clearTimeout, setTimeout } = getSafeTimers();
+let limitMaxConcurrency;
+/**
+* Normalizes retry configuration to extract individual values.
+* Handles both number and object forms.
+*/
+function getRetryCount(retry) {
+	if (retry === void 0) return 0;
+	if (typeof retry === "number") return retry;
+	return retry.count ?? 0;
+}
+function getRetryDelay(retry) {
+	if (retry === void 0) return 0;
+	if (typeof retry === "number") return 0;
+	return retry.delay ?? 0;
+}
+function getRetryCondition(retry) {
+	if (retry === void 0) return;
+	if (typeof retry === "number") return;
+	return retry.condition;
+}
+function updateSuiteHookState(task, name, state, runner) {
+	if (!task.result) task.result = { state: "run" };
+	if (!task.result.hooks) task.result.hooks = {};
+	const suiteHooks = task.result.hooks;
+	if (suiteHooks) {
+		suiteHooks[name] = state;
+		let event = state === "run" ? "before-hook-start" : "before-hook-end";
+		if (name === "afterAll" || name === "afterEach") event = state === "run" ? "after-hook-start" : "after-hook-end";
+		updateTask(event, task, runner);
+	}
+}
+function getSuiteHooks(suite, name, sequence) {
+	const hooks = getHooks(suite)[name];
+	if (sequence === "stack" && (name === "afterAll" || name === "afterEach")) return hooks.slice().reverse();
+	return hooks;
+}
+async function callTestHooks(runner, test, hooks, sequence) {
+	if (sequence === "stack") hooks = hooks.slice().reverse();
+	if (!hooks.length) return;
+	const context = test.context;
+	const onTestFailed = test.context.onTestFailed;
+	const onTestFinished = test.context.onTestFinished;
+	context.onTestFailed = () => {
+		throw new Error(`Cannot call "onTestFailed" inside a test hook.`);
+	};
+	context.onTestFinished = () => {
+		throw new Error(`Cannot call "onTestFinished" inside a test hook.`);
+	};
+	if (sequence === "parallel") try {
+		await Promise.all(hooks.map((fn) => limitMaxConcurrency(() => fn(test.context))));
+	} catch (e) {
+		failTask(test.result, e, runner.config.diffOptions);
+	}
+	else for (const fn of hooks) try {
+		await limitMaxConcurrency(() => fn(test.context));
+	} catch (e) {
+		failTask(test.result, e, runner.config.diffOptions);
+	}
+	context.onTestFailed = onTestFailed;
+	context.onTestFinished = onTestFinished;
+}
+async function callSuiteHook(suite, currentTask, name, runner, args) {
+	const sequence = runner.config.sequence.hooks;
+	const callbacks = [];
+	const parentSuite = "filepath" in suite ? null : suite.suite || suite.file;
+	if (name === "beforeEach" && parentSuite) callbacks.push(...await callSuiteHook(parentSuite, currentTask, name, runner, args));
+	const hooks = getSuiteHooks(suite, name, sequence);
+	if (hooks.length > 0) updateSuiteHookState(currentTask, name, "run", runner);
+	async function runHook(hook) {
+		return limitMaxConcurrency(async () => {
+			return getBeforeHookCleanupCallback(hook, await hook(...args), name === "beforeEach" ? args[0] : void 0);
+		});
+	}
+	if (sequence === "parallel") callbacks.push(...await Promise.all(hooks.map((hook) => runHook(hook))));
+	else for (const hook of hooks) callbacks.push(await runHook(hook));
+	if (hooks.length > 0) updateSuiteHookState(currentTask, name, "pass", runner);
+	if (name === "afterEach" && parentSuite) callbacks.push(...await callSuiteHook(parentSuite, currentTask, name, runner, args));
+	return callbacks;
+}
+function getAroundEachHooks(suite) {
+	const hooks = [];
+	const parentSuite = "filepath" in suite ? null : suite.suite || suite.file;
+	if (parentSuite) hooks.push(...getAroundEachHooks(parentSuite));
+	hooks.push(...getHooks(suite).aroundEach);
+	return hooks;
+}
+function getAroundAllHooks(suite) {
+	return getHooks(suite).aroundAll;
+}
+function makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError) {
+	const message = `The ${phase} phase of "${hookName}" hook timed out after ${timeout}ms.`;
+	const error = new (phase === "setup" ? AroundHookSetupError : AroundHookTeardownError)(message);
+	if (stackTraceError?.stack) error.stack = stackTraceError.stack.replace(stackTraceError.message, error.message);
+	return error;
+}
+async function callAroundHooks(runInner, options) {
+	const { hooks, hookName, callbackName, onTimeout, invokeHook } = options;
+	if (!hooks.length) {
+		await runInner();
+		return;
+	}
+	const hookErrors = [];
+	const createTimeoutPromise = (timeout, phase, stackTraceError) => {
+		let timer;
+		let timedout = false;
+		const promise = new Promise((_, reject) => {
+			if (timeout > 0 && timeout !== Number.POSITIVE_INFINITY) {
+				timer = setTimeout(() => {
+					timedout = true;
+					const error = makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError);
+					onTimeout?.(error);
+					reject(error);
+				}, timeout);
+				timer.unref?.();
+			}
+		});
+		const clear = () => {
+			if (timer) {
+				clearTimeout(timer);
+				timer = void 0;
+			}
+		};
+		return {
+			promise,
+			clear,
+			isTimedOut: () => timedout
+		};
+	};
+	const runNextHook = async (index) => {
+		if (index >= hooks.length) return runInner();
+		const hook = hooks[index];
+		const timeout = getAroundHookTimeout(hook);
+		const stackTraceError = getAroundHookStackTrace(hook);
+		let useCalled = false;
+		let setupTimeout;
+		let teardownTimeout;
+		let setupLimitConcurrencyRelease;
+		let teardownLimitConcurrencyRelease;
+		let resolveUseCalled;
+		const useCalledPromise = new Promise((resolve) => {
+			resolveUseCalled = resolve;
+		});
+		let resolveUseReturned;
+		const useReturnedPromise = new Promise((resolve) => {
+			resolveUseReturned = resolve;
+		});
+		let resolveHookComplete;
+		let rejectHookComplete;
+		const hookCompletePromise = new Promise((resolve, reject) => {
+			resolveHookComplete = resolve;
+			rejectHookComplete = reject;
+		});
+		const use = async () => {
+			if (setupTimeout.isTimedOut()) throw new Error("__VITEST_INTERNAL_AROUND_HOOK_ABORT__");
+			if (useCalled) throw new AroundHookMultipleCallsError(`The \`${callbackName}\` callback was called multiple times in the \`${hookName}\` hook. The callback can only be called once per hook.`);
+			useCalled = true;
+			resolveUseCalled();
+			setupTimeout.clear();
+			setupLimitConcurrencyRelease?.();
+			await runNextHook(index + 1).catch((e) => hookErrors.push(e));
+			teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
+			teardownTimeout = createTimeoutPromise(timeout, "teardown", stackTraceError);
+			resolveUseReturned();
+		};
+		setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire();
+		setupTimeout = createTimeoutPromise(timeout, "setup", stackTraceError);
+		(async () => {
+			try {
+				await invokeHook(hook, use);
+				if (!useCalled) throw new AroundHookSetupError(`The \`${callbackName}\` callback was not called in the \`${hookName}\` hook. Make sure to call \`${callbackName}\` to run the ${hookName === "aroundEach" ? "test" : "suite"}.`);
+				resolveHookComplete();
+			} catch (error) {
+				rejectHookComplete(error);
+			} finally {
+				setupLimitConcurrencyRelease?.();
+				teardownLimitConcurrencyRelease?.();
+			}
+		})();
+		try {
+			await Promise.race([
+				useCalledPromise,
+				hookCompletePromise,
+				setupTimeout.promise
+			]);
+		} finally {
+			setupLimitConcurrencyRelease?.();
+			setupTimeout.clear();
+		}
+		await Promise.race([useReturnedPromise, hookCompletePromise]);
+		try {
+			await Promise.race([hookCompletePromise, teardownTimeout?.promise]);
+		} finally {
+			teardownLimitConcurrencyRelease?.();
+			teardownTimeout?.clear();
+		}
+	};
+	await runNextHook(0).catch((e) => hookErrors.push(e));
+	if (hookErrors.length > 0) throw hookErrors;
+}
+async function callAroundAllHooks(suite, runSuiteInner) {
+	await callAroundHooks(runSuiteInner, {
+		hooks: getAroundAllHooks(suite),
+		hookName: "aroundAll",
+		callbackName: "runSuite()",
+		invokeHook: (hook, use) => hook(use, suite)
+	});
+}
+async function callAroundEachHooks(suite, test, runTest) {
+	await callAroundHooks(() => runTest(getFixtureCleanupCount(test.context)), {
+		hooks: getAroundEachHooks(suite),
+		hookName: "aroundEach",
+		callbackName: "runTest()",
+		onTimeout: (error) => abortContextSignal(test.context, error),
+		invokeHook: (hook, use) => hook(use, test.context, suite)
+	});
+}
+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 ??= setTimeout(() => call.bind(this)(...args), ms);
+	};
+}
+const sendTasksUpdateThrottled = throttle(sendTasksUpdate, 100);
+function updateTask(event, task, runner) {
+	eventsPacks.push([
+		task.id,
+		event,
+		void 0
+	]);
+	packs.set(task.id, [task.result, task.meta]);
+	sendTasksUpdateThrottled(runner);
+}
+async function callCleanupHooks(runner, cleanups) {
+	const sequence = runner.config.sequence.hooks;
+	if (sequence === "stack") cleanups = cleanups.slice().reverse();
+	if (sequence === "parallel") await Promise.all(cleanups.map(async (fn) => {
+		if (typeof fn !== "function") return;
+		await limitMaxConcurrency(() => fn());
+	}));
+	else for (const fn of cleanups) {
+		if (typeof fn !== "function") continue;
+		await limitMaxConcurrency(() => fn());
+	}
+}
+/**
+* Determines if a test should be retried based on its retryCondition configuration
+*/
+function passesRetryCondition(test, errors) {
+	const condition = getRetryCondition(test.retry);
+	if (!errors || errors.length === 0) return false;
+	if (!condition) return true;
+	const error = errors[errors.length - 1];
+	if (condition instanceof RegExp) return condition.test(error.message || "");
+	else if (typeof condition === "function") return condition(error);
+	return false;
+}
+async function runTest(test, runner) {
+	await runner.onBeforeRunTask?.(test);
+	if (test.mode !== "run" && test.mode !== "queued") {
+		updateTask("test-prepare", test, runner);
+		updateTask("test-finished", test, runner);
+		return;
+	}
+	if (test.result?.state === "fail") {
+		updateTask("test-failed-early", test, runner);
+		return;
+	}
+	const start = now();
+	test.result = {
+		state: "run",
+		startTime: unixNow(),
+		retryCount: 0
+	};
+	updateTask("test-prepare", test, runner);
+	const cleanupRunningTest = addRunningTest(test);
+	setCurrentTest(test);
+	const suite = test.suite || test.file;
+	const $ = runner.trace;
+	const repeats = test.repeats ?? 0;
+	for (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {
+		const retry = getRetryCount(test.retry);
+		for (let retryCount = 0; retryCount <= retry; retryCount++) {
+			let beforeEachCleanups = [];
+			await callAroundEachHooks(suite, test, async (fixtureCheckpoint) => {
+				try {
+					await runner.onBeforeTryTask?.(test, {
+						retry: retryCount,
+						repeats: repeatCount
+					});
+					test.result.repeatCount = repeatCount;
+					beforeEachCleanups = await $("test.beforeEach", () => callSuiteHook(suite, test, "beforeEach", runner, [test.context, suite]));
+					if (runner.runTask) await $("test.callback", () => limitMaxConcurrency(() => runner.runTask(test)));
+					else {
+						const fn = getFn(test);
+						if (!fn) throw new Error("Test function is not found. Did you add it using `setFn`?");
+						await $("test.callback", () => limitMaxConcurrency(() => fn()));
+					}
+					await runner.onAfterTryTask?.(test, {
+						retry: retryCount,
+						repeats: repeatCount
+					});
+					if (test.result.state !== "fail") test.result.state = "pass";
+				} catch (e) {
+					failTask(test.result, e, runner.config.diffOptions);
+				}
+				try {
+					await runner.onTaskFinished?.(test);
+				} catch (e) {
+					failTask(test.result, e, runner.config.diffOptions);
+				}
+				try {
+					await $("test.afterEach", () => callSuiteHook(suite, test, "afterEach", runner, [test.context, suite]));
+					if (beforeEachCleanups.length) await $("test.cleanup", () => callCleanupHooks(runner, beforeEachCleanups));
+					await callFixtureCleanupFrom(test.context, fixtureCheckpoint);
+				} catch (e) {
+					failTask(test.result, e, runner.config.diffOptions);
+				}
+				if (test.onFinished?.length) await $("test.onFinished", () => callTestHooks(runner, test, test.onFinished, "stack"));
+				if (test.result.state === "fail" && test.onFailed?.length) await $("test.onFailed", () => callTestHooks(runner, test, test.onFailed, runner.config.sequence.hooks));
+				test.onFailed = void 0;
+				test.onFinished = void 0;
+				await runner.onAfterRetryTask?.(test, {
+					retry: retryCount,
+					repeats: repeatCount
+				});
+			}).catch((error) => {
+				failTask(test.result, error, runner.config.diffOptions);
+			});
+			try {
+				await callFixtureCleanup(test.context);
+			} catch (e) {
+				failTask(test.result, e, runner.config.diffOptions);
+			}
+			if (test.result?.pending || test.result?.state === "skip") {
+				test.mode = "skip";
+				test.result = {
+					state: "skip",
+					note: test.result?.note,
+					pending: true,
+					duration: now() - start
+				};
+				updateTask("test-finished", test, runner);
+				setCurrentTest(void 0);
+				cleanupRunningTest();
+				return;
+			}
+			if (test.result.state === "pass") break;
+			if (retryCount < retry) {
+				if (!passesRetryCondition(test, test.result.errors)) break;
+				test.result.state = "run";
+				test.result.retryCount = (test.result.retryCount ?? 0) + 1;
+				const delay = getRetryDelay(test.retry);
+				if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+			}
+			updateTask("test-retried", test, runner);
+		}
+	}
+	if (test.fails) if (test.result.state === "pass") {
+		const error = processError(/* @__PURE__ */ new Error("Expect test to fail"));
+		test.result.state = "fail";
+		test.result.errors = [error];
+	} else {
+		test.result.state = "pass";
+		test.result.errors = void 0;
+	}
+	cleanupRunningTest();
+	setCurrentTest(void 0);
+	test.result.duration = now() - start;
+	await runner.onAfterRunTask?.(test);
+	updateTask("test-finished", test, runner);
+}
+function failTask(result, err, diffOptions) {
+	if (err instanceof PendingError) {
+		result.state = "skip";
+		result.note = err.note;
+		result.pending = true;
+		return;
+	}
+	if (err instanceof TestRunAbortError) {
+		result.state = "skip";
+		result.note = err.message;
+		return;
+	}
+	result.state = "fail";
+	const errors = Array.isArray(err) ? err : [err];
+	for (const e of errors) {
+		const errors = e instanceof AggregateError ? e.errors.map((e) => processError(e, diffOptions)) : [processError(e, diffOptions)];
+		result.errors ??= [];
+		result.errors.push(...errors);
+	}
+}
+function markTasksAsSkipped(suite, runner) {
+	suite.tasks.forEach((t) => {
+		t.mode = "skip";
+		t.result = {
+			...t.result,
+			state: "skip"
+		};
+		updateTask("test-finished", t, runner);
+		if (t.type === "suite") markTasksAsSkipped(t, runner);
+	});
+}
+function markPendingTasksAsSkipped(suite, runner, note) {
+	suite.tasks.forEach((t) => {
+		if (!t.result || t.result.state === "run") {
+			t.mode = "skip";
+			t.result = {
+				...t.result,
+				state: "skip",
+				note
+			};
+			updateTask("test-cancel", t, runner);
+		}
+		if (t.type === "suite") markPendingTasksAsSkipped(t, runner, note);
+	});
+}
+async function runSuite(suite, runner) {
+	await runner.onBeforeRunSuite?.(suite);
+	if (suite.result?.state === "fail") {
+		markTasksAsSkipped(suite, runner);
+		updateTask("suite-failed-early", suite, runner);
+		return;
+	}
+	const start = now();
+	const mode = suite.mode;
+	suite.result = {
+		state: mode === "skip" || mode === "todo" ? mode : "run",
+		startTime: unixNow()
+	};
+	const $ = runner.trace;
+	updateTask("suite-prepare", suite, runner);
+	let beforeAllCleanups = [];
+	if (suite.mode === "skip") {
+		suite.result.state = "skip";
+		updateTask("suite-finished", suite, runner);
+	} else if (suite.mode === "todo") {
+		suite.result.state = "todo";
+		updateTask("suite-finished", suite, runner);
+	} else {
+		let suiteRan = false;
+		try {
+			await callAroundAllHooks(suite, async () => {
+				suiteRan = true;
+				try {
+					try {
+						beforeAllCleanups = await $("suite.beforeAll", () => callSuiteHook(suite, suite, "beforeAll", runner, [suite]));
+					} catch (e) {
+						failTask(suite.result, e, runner.config.diffOptions);
+						markTasksAsSkipped(suite, runner);
+						return;
+					}
+					if (runner.runSuite) await runner.runSuite(suite);
+					else for (let tasksGroup of partitionSuiteChildren(suite)) if (tasksGroup[0].concurrent === true) {
+						const groupLimiter = limitConcurrency(runner.config.maxConcurrency);
+						await Promise.all(tasksGroup.map((c) => groupLimiter(() => runSuiteChild(c, runner))));
+					} else {
+						const { sequence } = runner.config;
+						if (suite.shuffle) tasksGroup = shuffle([tasksGroup.filter((group) => group.type === "suite"), tasksGroup.filter((group) => group.type === "test")], sequence.seed).flatMap((group) => shuffle(group, sequence.seed));
+						for (const c of tasksGroup) await runSuiteChild(c, runner);
+					}
+				} finally {
+					try {
+						await $("suite.afterAll", () => callSuiteHook(suite, suite, "afterAll", runner, [suite]));
+						if (beforeAllCleanups.length) await $("suite.cleanup", () => callCleanupHooks(runner, beforeAllCleanups));
+						if (suite.file === suite) {
+							const contexts = TestFixtures.getFileContexts(suite.file);
+							await Promise.all(contexts.map((context) => callFixtureCleanup(context)));
+						}
+					} catch (e) {
+						failTask(suite.result, e, runner.config.diffOptions);
+					}
+				}
+			});
+		} catch (e) {
+			if (!suiteRan) markTasksAsSkipped(suite, runner);
+			failTask(suite.result, e, runner.config.diffOptions);
+		}
+		if (suite.mode === "run" || suite.mode === "queued") if (!runner.config.passWithNoTests && !hasTests(suite)) {
+			suite.result.state = "fail";
+			if (!suite.result.errors?.length) {
+				const error = processError(/* @__PURE__ */ new Error(`No test found in suite ${suite.name}`));
+				suite.result.errors = [error];
+			}
+		} else if (hasFailed(suite)) suite.result.state = "fail";
+		else suite.result.state = "pass";
+		suite.result.duration = now() - start;
+		await runner.onAfterRunSuite?.(suite);
+		updateTask("suite-finished", suite, runner);
+	}
+}
+async function runSuiteChild(c, runner) {
+	const $ = runner.trace;
+	if (c.type === "test") return $("run.test", {
+		"vitest.test.id": c.id,
+		"vitest.test.name": c.name,
+		"vitest.test.mode": c.mode,
+		"vitest.test.timeout": c.timeout,
+		"code.file.path": c.file.filepath,
+		"code.line.number": c.location?.line,
+		"code.column.number": c.location?.column
+	}, () => runTest(c, runner));
+	else if (c.type === "suite") return $("run.suite", {
+		"vitest.suite.id": c.id,
+		"vitest.suite.name": c.name,
+		"vitest.suite.mode": c.mode,
+		"code.file.path": c.file.filepath,
+		"code.line.number": c.location?.line,
+		"code.column.number": c.location?.column
+	}, () => runSuite(c, runner));
+}
+async function runFiles(files, runner) {
+	limitMaxConcurrency ??= limitConcurrency(runner.config.maxConcurrency);
+	for (const file of files) {
+		if (!file.tasks.length && !runner.config.passWithNoTests) {
+			if (!file.result?.errors?.length) file.result = {
+				state: "fail",
+				errors: [processError(/* @__PURE__ */ new Error(`No test suite found in file ${file.filepath}`))]
+			};
+		}
+		await runner.trace("run.spec", {
+			"code.file.path": file.filepath,
+			"vitest.suite.tasks.length": file.tasks.length
+		}, () => runSuite(file, runner));
+	}
+}
+const workerRunners = /* @__PURE__ */ new WeakSet();
+function defaultTrace(_, attributes, cb) {
+	if (typeof attributes === "function") return attributes();
+	return cb();
+}
+async function startTests(specs, runner) {
+	runner.trace ??= defaultTrace;
+	const cancel = runner.cancel?.bind(runner);
+	runner.cancel = (reason) => {
+		const error = new TestRunAbortError("The test run was aborted by the user.", reason);
+		getRunningTests().forEach((test) => {
+			abortContextSignal(test.context, error);
+			markPendingTasksAsSkipped(test.file, runner, error.message);
+		});
+		return cancel?.(reason);
+	};
+	if (!workerRunners.has(runner)) {
+		runner.onCleanupWorkerContext?.(async () => {
+			await Promise.all([...TestFixtures.getWorkerContexts()].map((context) => callFixtureCleanup(context))).finally(() => {
+				TestFixtures.clearDefinitions();
+			});
+		});
+		workerRunners.add(runner);
+	}
+	try {
+		const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
+		await runner.onBeforeCollect?.(paths);
+		const files = await collectTests(specs, runner);
+		await runner.onCollected?.(files);
+		await runner.onBeforeRunFiles?.(files);
+		await runFiles(files, runner);
+		await runner.onAfterRunFiles?.(files);
+		await finishSendTasksUpdate(runner);
+		return files;
+	} finally {
+		runner.cancel = cancel;
+	}
+}
+async function publicCollect(specs, runner) {
+	runner.trace ??= defaultTrace;
+	const paths = specs.map((f) => typeof f === "string" ? f : f.filepath);
+	await runner.onBeforeCollect?.(paths);
+	const files = await collectTests(specs, runner);
+	await runner.onCollected?.(files);
+	return files;
+}
+/**
+* @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.path && attachment.bodyEncoding) throw new TypeError(`Test attachment with "path" should not have "bodyEncoding" specified.`);
+	if (attachment.body instanceof Uint8Array) attachment.body = encodeUint8Array(attachment.body);
+	if (attachment.body != null) attachment.bodyEncoding ??= "base64";
+}
+//#endregion
+export { createTagsFilter as A, createTaskName as B, findTestFileStackTrace as C, generateFileHash as D, generateHash as E, getFullName as F, getNames as G, getSuites as H, getTasks as I, getTestName as J, getTests as K, hasFailed as L, hasTests as M, interpretTaskModes as N, isTestCase as O, limitConcurrency as P, matchesTags as Q, partitionSuiteChildren as R, someTasksAreOnly as S, validateTags as T, afterAll as a, afterEach as b, aroundAll as c, aroundEach as d, beforeAll as e, beforeEach as f, createTaskCollector as g, describe as h, getCurrentSuite as i, getCurrentTest as j, getFn as k, getHooks as l, it as m, onTestFinished as n, onTestFailed as o, publicCollect as p, setHooks as q, recordArtifact as r, setFn as s, startTests as t, suite as u, test as v, updateTask as w, calculateSuiteHash as x, createChainable as y, createFileTask as z };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"chunk-artifact.js","names":[],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+runner@4.1.10/node_modules/@vitest/runner/dist/chunk-artifact.js"],"sourcesContent":["import { processError } from '@vitest/utils/error';\nimport { isObject, filterOutComments, ordinal, createDefer, assertTypes, toArray, isNegativeNaN, unique, objectAttr, shuffle } from '@vitest/utils/helpers';\nimport { getSafeTimers } from '@vitest/utils/timers';\nimport { format, formatRegExp, objDisplay } from '@vitest/utils/display';\nimport { parseSingleStack } from '@vitest/utils/source-map';\nimport { relative } from 'pathe';\n\nclass PendingError extends Error {\n\tcode = \"VITEST_PENDING\";\n\ttaskId;\n\tconstructor(message, task, note) {\n\t\tsuper(message);\n\t\tthis.message = message;\n\t\tthis.note = note;\n\t\tthis.taskId = task.id;\n\t}\n}\nclass TestRunAbortError extends Error {\n\tname = \"TestRunAbortError\";\n\treason;\n\tconstructor(message, reason) {\n\t\tsuper(message);\n\t\tthis.reason = reason;\n\t}\n}\nclass FixtureDependencyError extends Error {\n\tname = \"FixtureDependencyError\";\n}\nclass FixtureAccessError extends Error {\n\tname = \"FixtureAccessError\";\n}\nclass FixtureParseError extends Error {\n\tname = \"FixtureParseError\";\n}\nclass AroundHookSetupError extends Error {\n\tname = \"AroundHookSetupError\";\n}\nclass AroundHookTeardownError extends Error {\n\tname = \"AroundHookTeardownError\";\n}\nclass AroundHookMultipleCallsError extends Error {\n\tname = \"AroundHookMultipleCallsError\";\n}\n\n// use WeakMap here to make the Test and Suite object serializable\nconst fnMap = new WeakMap();\nconst testFixtureMap = new WeakMap();\nconst hooksMap = new WeakMap();\nfunction setFn(key, fn) {\n\tfnMap.set(key, fn);\n}\nfunction getFn(key) {\n\treturn fnMap.get(key);\n}\nfunction setTestFixture(key, fixture) {\n\ttestFixtureMap.set(key, fixture);\n}\nfunction getTestFixtures(key) {\n\treturn testFixtureMap.get(key);\n}\nfunction setHooks(key, hooks) {\n\thooksMap.set(key, hooks);\n}\nfunction getHooks(key) {\n\treturn hooksMap.get(key);\n}\n\nconst FIXTURE_STACK_TRACE_KEY = Symbol.for(\"VITEST_FIXTURE_STACK_TRACE\");\nclass TestFixtures {\n\t_suiteContexts;\n\t_overrides = new WeakMap();\n\t_registrations;\n\tstatic _definitions = [];\n\tstatic _builtinFixtures = [\n\t\t\"task\",\n\t\t\"signal\",\n\t\t\"onTestFailed\",\n\t\t\"onTestFinished\",\n\t\t\"skip\",\n\t\t\"annotate\"\n\t];\n\tstatic _fixtureOptionKeys = [\n\t\t\"auto\",\n\t\t\"injected\",\n\t\t\"scope\"\n\t];\n\tstatic _fixtureScopes = [\n\t\t\"test\",\n\t\t\"file\",\n\t\t\"worker\"\n\t];\n\tstatic _workerContextSuite = { type: \"worker\" };\n\tstatic clearDefinitions() {\n\t\tTestFixtures._definitions.length = 0;\n\t}\n\tstatic getWorkerContexts() {\n\t\treturn TestFixtures._definitions.map((f) => f.getWorkerContext());\n\t}\n\tstatic getFileContexts(file) {\n\t\treturn TestFixtures._definitions.map((f) => f.getFileContext(file));\n\t}\n\tstatic isFixtureOptions(obj) {\n\t\treturn isObject(obj) && Object.keys(obj).some((key) => TestFixtures._fixtureOptionKeys.includes(key));\n\t}\n\tconstructor(registrations) {\n\t\tthis._registrations = registrations ?? new Map();\n\t\tthis._suiteContexts = new WeakMap();\n\t\tTestFixtures._definitions.push(this);\n\t}\n\textend(runner, userFixtures) {\n\t\tconst { suite } = getCurrentSuite();\n\t\tconst isTopLevel = !suite || suite.file === suite;\n\t\tconst registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel);\n\t\treturn new TestFixtures(registrations);\n\t}\n\tget(suite) {\n\t\tlet currentSuite = suite;\n\t\twhile (currentSuite) {\n\t\t\tconst overrides = this._overrides.get(currentSuite);\n\t\t\t// return the closest override\n\t\t\tif (overrides) {\n\t\t\t\treturn overrides;\n\t\t\t}\n\t\t\tif (currentSuite === currentSuite.file) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcurrentSuite = currentSuite.suite || currentSuite.file;\n\t\t}\n\t\treturn this._registrations;\n\t}\n\toverride(runner, userFixtures) {\n\t\tconst { suite: currentSuite, file } = getCurrentSuite();\n\t\tconst suite = currentSuite || file;\n\t\tconst isTopLevel = !currentSuite || currentSuite.file === currentSuite;\n\t\t// Create a copy of the closest parent's registrations to avoid modifying them\n\t\t// For chained calls, this.get(suite) returns this suite's overrides; for first call, returns parent's\n\t\tconst suiteRegistrations = new Map(this.get(suite));\n\t\tconst registrations = this.parseUserFixtures(runner, userFixtures, isTopLevel, suiteRegistrations);\n\t\t// If defined in top-level, just override all registrations\n\t\t// We don't support overriding suite-level fixtures anyway (it will throw an error)\n\t\tif (isTopLevel) {\n\t\t\tthis._registrations = registrations;\n\t\t} else {\n\t\t\tthis._overrides.set(suite, registrations);\n\t\t}\n\t}\n\tgetFileContext(file) {\n\t\tif (!this._suiteContexts.has(file)) {\n\t\t\tthis._suiteContexts.set(file, Object.create(null));\n\t\t}\n\t\treturn this._suiteContexts.get(file);\n\t}\n\tgetWorkerContext() {\n\t\tif (!this._suiteContexts.has(TestFixtures._workerContextSuite)) {\n\t\t\tthis._suiteContexts.set(TestFixtures._workerContextSuite, Object.create(null));\n\t\t}\n\t\treturn this._suiteContexts.get(TestFixtures._workerContextSuite);\n\t}\n\tparseUserFixtures(runner, userFixtures, supportNonTest, registrations = new Map(this._registrations)) {\n\t\tconst errors = [];\n\t\tObject.entries(userFixtures).forEach(([name, fn]) => {\n\t\t\tlet options;\n\t\t\tlet value;\n\t\t\tlet _options;\n\t\t\tif (Array.isArray(fn) && fn.length >= 2 && TestFixtures.isFixtureOptions(fn[1])) {\n\t\t\t\t_options = fn[1];\n\t\t\t\toptions = {\n\t\t\t\t\tauto: _options.auto ?? false,\n\t\t\t\t\tscope: _options.scope ?? \"test\",\n\t\t\t\t\tinjected: _options.injected ?? false\n\t\t\t\t};\n\t\t\t\tvalue = options.injected ? runner.injectValue?.(name) ?? fn[0] : fn[0];\n\t\t\t} else {\n\t\t\t\tvalue = fn;\n\t\t\t}\n\t\t\tconst parent = registrations.get(name);\n\t\t\tif (parent && options) {\n\t\t\t\tif (parent.scope !== options.scope) {\n\t\t\t\t\terrors.push(new FixtureDependencyError(`The \"${name}\" fixture was already registered with a \"${options.scope}\" scope.`));\n\t\t\t\t}\n\t\t\t\tif (parent.auto !== options.auto) {\n\t\t\t\t\terrors.push(new FixtureDependencyError(`The \"${name}\" fixture was already registered as { auto: ${options.auto} }.`));\n\t\t\t\t}\n\t\t\t} else if (parent) {\n\t\t\t\toptions = {\n\t\t\t\t\tauto: parent.auto,\n\t\t\t\t\tscope: parent.scope,\n\t\t\t\t\tinjected: parent.injected\n\t\t\t\t};\n\t\t\t} else if (!options) {\n\t\t\t\toptions = {\n\t\t\t\t\tauto: false,\n\t\t\t\t\tinjected: false,\n\t\t\t\t\tscope: \"test\"\n\t\t\t\t};\n\t\t\t}\n\t\t\tif (options.scope && !TestFixtures._fixtureScopes.includes(options.scope)) {\n\t\t\t\terrors.push(new FixtureDependencyError(`The \"${name}\" fixture has unknown scope \"${options.scope}\".`));\n\t\t\t}\n\t\t\tif (!supportNonTest && options.scope !== \"test\") {\n\t\t\t\terrors.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.`));\n\t\t\t}\n\t\t\tconst deps = isFixtureFunction(value) ? getUsedProps(value) : new Set();\n\t\t\tconst item = {\n\t\t\t\tname,\n\t\t\t\tvalue,\n\t\t\t\tauto: options.auto ?? false,\n\t\t\t\tinjected: options.injected ?? false,\n\t\t\t\tscope: options.scope ?? \"test\",\n\t\t\t\tdeps,\n\t\t\t\tparent\n\t\t\t};\n\t\t\tif (isFixtureFunction(value)) {\n\t\t\t\tObject.assign(value, { [FIXTURE_STACK_TRACE_KEY]: new Error(\"STACK_TRACE_ERROR\") });\n\t\t\t}\n\t\t\tregistrations.set(name, item);\n\t\t\tif (item.scope === \"worker\" && (runner.pool === \"vmThreads\" || runner.pool === \"vmForks\")) {\n\t\t\t\titem.scope = \"file\";\n\t\t\t}\n\t\t});\n\t\t// validate fixture dependency scopes\n\t\tfor (const fixture of registrations.values()) {\n\t\t\tfor (const depName of fixture.deps) {\n\t\t\t\tif (TestFixtures._builtinFixtures.includes(depName)) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst dep = registrations.get(depName);\n\t\t\t\tif (!dep) {\n\t\t\t\t\terrors.push(new FixtureDependencyError(`The \"${fixture.name}\" fixture depends on unknown fixture \"${depName}\".`));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (depName === fixture.name && !fixture.parent) {\n\t\t\t\t\terrors.push(new FixtureDependencyError(`The \"${fixture.name}\" fixture depends on itself, but does not have a base implementation.`));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (TestFixtures._fixtureScopes.indexOf(fixture.scope) > TestFixtures._fixtureScopes.indexOf(dep.scope)) {\n\t\t\t\t\terrors.push(new FixtureDependencyError(`The ${fixture.scope} \"${fixture.name}\" fixture cannot depend on a ${dep.scope} fixture \"${dep.name}\".`));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (errors.length === 1) {\n\t\t\tthrow errors[0];\n\t\t} else if (errors.length > 1) {\n\t\t\tthrow new AggregateError(errors, \"Cannot resolve user fixtures. See errors for more information.\");\n\t\t}\n\t\treturn registrations;\n\t}\n}\nconst cleanupFnArrayMap = new WeakMap();\nasync function callFixtureCleanup(context) {\n\tconst cleanupFnArray = cleanupFnArrayMap.get(context) ?? [];\n\tfor (const cleanup of cleanupFnArray.reverse()) {\n\t\tawait cleanup();\n\t}\n\tcleanupFnArrayMap.delete(context);\n}\n/**\n* Returns the current number of cleanup functions registered for the context.\n* This can be used as a checkpoint to later clean up only fixtures added after this point.\n*/\nfunction getFixtureCleanupCount(context) {\n\treturn cleanupFnArrayMap.get(context)?.length ?? 0;\n}\n/**\n* Cleans up only fixtures that were added after the given checkpoint index.\n* This is used by aroundEach to clean up fixtures created inside runTest()\n* while preserving fixtures that were created for aroundEach itself.\n*/\nasync function callFixtureCleanupFrom(context, fromIndex) {\n\tconst cleanupFnArray = cleanupFnArrayMap.get(context);\n\tif (!cleanupFnArray || cleanupFnArray.length <= fromIndex) {\n\t\treturn;\n\t}\n\t// Get items added after the checkpoint\n\tconst toCleanup = cleanupFnArray.slice(fromIndex);\n\t// Clean up in reverse order\n\tfor (const cleanup of toCleanup.reverse()) {\n\t\tawait cleanup();\n\t}\n\t// Remove cleaned up items from the array, keeping items before checkpoint\n\tcleanupFnArray.length = fromIndex;\n}\nconst contextHasFixturesCache = new WeakMap();\nfunction withFixtures(fn, options) {\n\tconst collector = getCurrentSuite();\n\tconst suite = options?.suite || collector.suite || collector.file;\n\treturn async (hookContext) => {\n\t\tconst context = hookContext || options?.context;\n\t\tif (!context) {\n\t\t\tif (options?.suiteHook) {\n\t\t\t\tvalidateSuiteHook(fn, options.suiteHook, options.stackTraceError);\n\t\t\t}\n\t\t\treturn fn({});\n\t\t}\n\t\tconst fixtures = options?.fixtures || getTestFixtures(context);\n\t\tif (!fixtures) {\n\t\t\treturn fn(context);\n\t\t}\n\t\tconst registrations = fixtures.get(suite);\n\t\tif (!registrations.size) {\n\t\t\treturn fn(context);\n\t\t}\n\t\tconst usedFixtures = [];\n\t\tconst usedProps = getUsedProps(fn);\n\t\tfor (const fixture of registrations.values()) {\n\t\t\tif (isAutoFixture(fixture, options) || usedProps.has(fixture.name)) {\n\t\t\t\tusedFixtures.push(fixture);\n\t\t\t}\n\t\t}\n\t\tif (!usedFixtures.length) {\n\t\t\treturn fn(context);\n\t\t}\n\t\tif (!cleanupFnArrayMap.has(context)) {\n\t\t\tcleanupFnArrayMap.set(context, []);\n\t\t}\n\t\tconst cleanupFnArray = cleanupFnArrayMap.get(context);\n\t\tconst pendingFixtures = resolveDeps(usedFixtures, registrations);\n\t\tif (!pendingFixtures.length) {\n\t\t\treturn fn(context);\n\t\t}\n\t\t// Check if suite-level hook is trying to access test-scoped fixtures\n\t\t// Suite hooks (beforeAll/afterAll/aroundAll) can only access file/worker scoped fixtures\n\t\tif (options?.suiteHook) {\n\t\t\tconst testScopedFixtures = pendingFixtures.filter((f) => f.scope === \"test\");\n\t\t\tif (testScopedFixtures.length > 0) {\n\t\t\t\tconst fixtureNames = testScopedFixtures.map((f) => `\"${f.name}\"`).join(\", \");\n\t\t\t\tconst alternativeHook = {\n\t\t\t\t\taroundAll: \"aroundEach\",\n\t\t\t\t\tbeforeAll: \"beforeEach\",\n\t\t\t\t\tafterAll: \"afterEach\"\n\t\t\t\t};\n\t\t\t\tconst 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 ${alternativeHook[options.suiteHook]} hook.`);\n\t\t\t\t// Use stack trace from hook registration for better error location\n\t\t\t\tif (options.stackTraceError?.stack) {\n\t\t\t\t\terror.stack = error.message + options.stackTraceError.stack.replace(options.stackTraceError.message, \"\");\n\t\t\t\t}\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t}\n\t\tif (!contextHasFixturesCache.has(context)) {\n\t\t\tcontextHasFixturesCache.set(context, new WeakSet());\n\t\t}\n\t\tconst cachedFixtures = contextHasFixturesCache.get(context);\n\t\tfor (const fixture of pendingFixtures) {\n\t\t\tif (fixture.scope === \"test\") {\n\t\t\t\t// fixture could be already initialized during \"before\" hook\n\t\t\t\t// we can't check \"fixture.name\" in context because context may\n\t\t\t\t// access the parent fixture ({ a: ({ a }) => {} })\n\t\t\t\tif (cachedFixtures.has(fixture)) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tcachedFixtures.add(fixture);\n\t\t\t\tconst resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);\n\t\t\t\tcontext[fixture.name] = resolvedValue;\n\t\t\t\tcleanupFnArray.push(() => {\n\t\t\t\t\tcachedFixtures.delete(fixture);\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tconst resolvedValue = await resolveScopeFixtureValue(fixtures, suite, fixture);\n\t\t\t\tcontext[fixture.name] = resolvedValue;\n\t\t\t}\n\t\t}\n\t\treturn fn(context);\n\t};\n}\nfunction isAutoFixture(fixture, options) {\n\tif (!fixture.auto) {\n\t\treturn false;\n\t}\n\t// suite hook doesn't automatically trigger unused test-scoped fixtures.\n\tif (options?.suiteHook && fixture.scope === \"test\") {\n\t\treturn false;\n\t}\n\treturn true;\n}\nfunction isFixtureFunction(value) {\n\treturn typeof value === \"function\";\n}\nfunction resolveTestFixtureValue(fixture, context, cleanupFnArray) {\n\tif (!isFixtureFunction(fixture.value)) {\n\t\treturn fixture.value;\n\t}\n\treturn resolveFixtureFunction(fixture.value, fixture.name, context, cleanupFnArray);\n}\nconst scopedFixturePromiseCache = new WeakMap();\nasync function resolveScopeFixtureValue(fixtures, suite, fixture) {\n\tconst workerContext = fixtures.getWorkerContext();\n\tconst fileContext = fixtures.getFileContext(suite.file);\n\tconst fixtureContext = fixture.scope === \"worker\" ? workerContext : fileContext;\n\tif (!isFixtureFunction(fixture.value)) {\n\t\tfixtureContext[fixture.name] = fixture.value;\n\t\treturn fixture.value;\n\t}\n\tif (fixture.name in fixtureContext) {\n\t\treturn fixtureContext[fixture.name];\n\t}\n\tif (scopedFixturePromiseCache.has(fixture)) {\n\t\treturn scopedFixturePromiseCache.get(fixture);\n\t}\n\tif (!cleanupFnArrayMap.has(fixtureContext)) {\n\t\tcleanupFnArrayMap.set(fixtureContext, []);\n\t}\n\tconst cleanupFnFileArray = cleanupFnArrayMap.get(fixtureContext);\n\tconst promise = resolveFixtureFunction(fixture.value, fixture.name, fixture.scope === \"file\" ? {\n\t\t...workerContext,\n\t\t...fileContext\n\t} : fixtureContext, cleanupFnFileArray).then((value) => {\n\t\tfixtureContext[fixture.name] = value;\n\t\tscopedFixturePromiseCache.delete(fixture);\n\t\treturn value;\n\t});\n\tscopedFixturePromiseCache.set(fixture, promise);\n\treturn promise;\n}\nasync function resolveFixtureFunction(fixtureFn, fixtureName, context, cleanupFnArray) {\n\t// wait for `use` call to extract fixture value\n\tconst useFnArgPromise = createDefer();\n\tconst stackTraceError = FIXTURE_STACK_TRACE_KEY in fixtureFn && fixtureFn[FIXTURE_STACK_TRACE_KEY] instanceof Error ? fixtureFn[FIXTURE_STACK_TRACE_KEY] : undefined;\n\tlet isUseFnArgResolved = false;\n\tconst fixtureReturn = fixtureFn(context, async (useFnArg) => {\n\t\t// extract `use` argument\n\t\tisUseFnArgResolved = true;\n\t\tuseFnArgPromise.resolve(useFnArg);\n\t\t// suspend fixture teardown by holding off `useReturnPromise` resolution until cleanup\n\t\tconst useReturnPromise = createDefer();\n\t\tcleanupFnArray.push(async () => {\n\t\t\t// start teardown by resolving `use` Promise\n\t\t\tuseReturnPromise.resolve();\n\t\t\t// wait for finishing teardown\n\t\t\tawait fixtureReturn;\n\t\t});\n\t\tawait useReturnPromise;\n\t}).then(() => {\n\t\t// fixture returned without calling use()\n\t\tif (!isUseFnArgResolved) {\n\t\t\tconst error = new Error(`Fixture \"${fixtureName}\" returned without calling \"use\". Make sure to call \"use\" in every code path of the fixture function.`);\n\t\t\tif (stackTraceError?.stack) {\n\t\t\t\terror.stack = error.message + stackTraceError.stack.replace(stackTraceError.message, \"\");\n\t\t\t}\n\t\t\tuseFnArgPromise.reject(error);\n\t\t}\n\t}).catch((e) => {\n\t\t// treat fixture setup error as test failure\n\t\tif (!isUseFnArgResolved) {\n\t\t\tuseFnArgPromise.reject(e);\n\t\t\treturn;\n\t\t}\n\t\t// otherwise re-throw to avoid silencing error during cleanup\n\t\tthrow e;\n\t});\n\treturn useFnArgPromise;\n}\nfunction resolveDeps(usedFixtures, registrations, depSet = new Set(), pendingFixtures = []) {\n\tusedFixtures.forEach((fixture) => {\n\t\tif (pendingFixtures.includes(fixture)) {\n\t\t\treturn;\n\t\t}\n\t\tif (!isFixtureFunction(fixture.value) || !fixture.deps) {\n\t\t\tpendingFixtures.push(fixture);\n\t\t\treturn;\n\t\t}\n\t\tif (depSet.has(fixture)) {\n\t\t\tif (fixture.parent) {\n\t\t\t\tfixture = fixture.parent;\n\t\t\t} else {\n\t\t\t\tthrow new Error(`Circular fixture dependency detected: ${fixture.name} <- ${[...depSet].reverse().map((d) => d.name).join(\" <- \")}`);\n\t\t\t}\n\t\t}\n\t\tdepSet.add(fixture);\n\t\tresolveDeps([...fixture.deps].map((n) => n === fixture.name ? fixture.parent : registrations.get(n)).filter((n) => !!n), registrations, depSet, pendingFixtures);\n\t\tpendingFixtures.push(fixture);\n\t\tdepSet.clear();\n\t});\n\treturn pendingFixtures;\n}\nfunction validateSuiteHook(fn, hook, suiteError) {\n\tconst usedProps = getUsedProps(fn, {\n\t\tsourceError: suiteError,\n\t\tsuiteHook: hook\n\t});\n\tif (usedProps.size) {\n\t\tconst 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}()\"?\\n` + `If 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`);\n\t\tif (suiteError) {\n\t\t\terror.stack = suiteError.stack?.replace(suiteError.message, error.message);\n\t\t}\n\t\tthrow error;\n\t}\n}\nconst kPropsSymbol = Symbol(\"$vitest:fixture-props\");\nconst kPropNamesSymbol = Symbol(\"$vitest:fixture-prop-names\");\nfunction configureProps(fn, options) {\n\tObject.defineProperty(fn, kPropsSymbol, {\n\t\tvalue: options,\n\t\tenumerable: false\n\t});\n}\nfunction memoProps(fn, props) {\n\tfn[kPropNamesSymbol] = props;\n\treturn props;\n}\nfunction getUsedProps(fn, { sourceError, suiteHook } = {}) {\n\tif (kPropNamesSymbol in fn) {\n\t\treturn fn[kPropNamesSymbol];\n\t}\n\tconst { index: fixturesIndex = 0, original: implementation = fn } = kPropsSymbol in fn ? fn[kPropsSymbol] : {};\n\tlet fnString = filterOutComments(implementation.toString());\n\t// match lowered async function and strip it off\n\t// example code on esbuild-try https://esbuild.github.io/try/#YgAwLjI0LjAALS1zdXBwb3J0ZWQ6YXN5bmMtYXdhaXQ9ZmFsc2UAZQBlbnRyeS50cwBjb25zdCBvID0gewogIGYxOiBhc3luYyAoKSA9PiB7fSwKICBmMjogYXN5bmMgKGEpID0+IHt9LAogIGYzOiBhc3luYyAoYSwgYikgPT4ge30sCiAgZjQ6IGFzeW5jIGZ1bmN0aW9uKGEpIHt9LAogIGY1OiBhc3luYyBmdW5jdGlvbiBmZihhKSB7fSwKICBhc3luYyBmNihhKSB7fSwKCiAgZzE6IGFzeW5jICgpID0+IHt9LAogIGcyOiBhc3luYyAoeyBhIH0pID0+IHt9LAogIGczOiBhc3luYyAoeyBhIH0sIGIpID0+IHt9LAogIGc0OiBhc3luYyBmdW5jdGlvbiAoeyBhIH0pIHt9LAogIGc1OiBhc3luYyBmdW5jdGlvbiBnZyh7IGEgfSkge30sCiAgYXN5bmMgZzYoeyBhIH0pIHt9LAoKICBoMTogYXN5bmMgKCkgPT4ge30sCiAgLy8gY29tbWVudCBiZXR3ZWVuCiAgaDI6IGFzeW5jIChhKSA9PiB7fSwKfQ\n\t//   __async(this, null, function*\n\t//   __async(this, arguments, function*\n\t//   __async(this, [_0, _1], function*\n\tif (/__async\\((?:this|null), (?:null|arguments|\\[[_0-9, ]*\\]), function\\*/.test(fnString)) {\n\t\tfnString = fnString.split(/__async\\((?:this|null),/)[1];\n\t}\n\tconst match = fnString.match(/[^(]*\\(([^)]*)/);\n\tif (!match) {\n\t\treturn memoProps(fn, new Set());\n\t}\n\tconst args = splitByComma(match[1]);\n\tif (!args.length) {\n\t\treturn memoProps(fn, new Set());\n\t}\n\tconst fixturesArgument = args[fixturesIndex];\n\tif (!fixturesArgument) {\n\t\treturn memoProps(fn, new Set());\n\t}\n\tif (!(fixturesArgument[0] === \"{\" && fixturesArgument.endsWith(\"}\"))) {\n\t\tconst ordinalArgument = ordinal(fixturesIndex + 1);\n\t\tconst 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.` : \"\"}`);\n\t\tif (sourceError) {\n\t\t\terror.stack = sourceError.stack?.replace(sourceError.message, error.message);\n\t\t}\n\t\tthrow error;\n\t}\n\tconst _first = fixturesArgument.slice(1, -1).replace(/\\s/g, \"\");\n\tconst props = splitByComma(_first).map((prop) => {\n\t\treturn prop.replace(/:.*|=.*/g, \"\");\n\t});\n\tconst last = props.at(-1);\n\tif (last && last.startsWith(\"...\")) {\n\t\tconst error = new FixtureParseError(`Rest parameters are not supported in fixtures, received \"${last}\".`);\n\t\tif (sourceError) {\n\t\t\terror.stack = sourceError.stack?.replace(sourceError.message, error.message);\n\t\t}\n\t\tthrow error;\n\t}\n\treturn memoProps(fn, new Set(props));\n}\nfunction splitByComma(s) {\n\tconst result = [];\n\tconst stack = [];\n\tlet start = 0;\n\tfor (let i = 0; i < s.length; i++) {\n\t\tif (s[i] === \"{\" || s[i] === \"[\") {\n\t\t\tstack.push(s[i] === \"{\" ? \"}\" : \"]\");\n\t\t} else if (s[i] === stack.at(-1)) {\n\t\t\tstack.pop();\n\t\t} else if (!stack.length && s[i] === \",\") {\n\t\t\tconst token = s.substring(start, i).trim();\n\t\t\tif (token) {\n\t\t\t\tresult.push(token);\n\t\t\t}\n\t\t\tstart = i + 1;\n\t\t}\n\t}\n\tconst lastToken = s.substring(start).trim();\n\tif (lastToken) {\n\t\tresult.push(lastToken);\n\t}\n\treturn result;\n}\n\nlet _test;\nfunction setCurrentTest(test) {\n\t_test = test;\n}\nfunction getCurrentTest() {\n\treturn _test;\n}\nconst tests = [];\nfunction addRunningTest(test) {\n\ttests.push(test);\n\treturn () => {\n\t\ttests.splice(tests.indexOf(test));\n\t};\n}\nfunction getRunningTests() {\n\treturn tests;\n}\n\nconst kChainableContext = Symbol(\"kChainableContext\");\nfunction getChainableContext(chainable) {\n\treturn chainable?.[kChainableContext];\n}\nfunction createChainable(keys, fn, context) {\n\tfunction create(context) {\n\t\tconst chain = function(...args) {\n\t\t\treturn fn.apply(context, args);\n\t\t};\n\t\tObject.assign(chain, fn);\n\t\tObject.defineProperty(chain, kChainableContext, {\n\t\t\tvalue: {\n\t\t\t\twithContext: () => chain.bind(context),\n\t\t\t\tgetFixtures: () => context.fixtures,\n\t\t\t\tsetContext: (key, value) => {\n\t\t\t\t\tcontext[key] = value;\n\t\t\t\t},\n\t\t\t\tmergeContext: (ctx) => {\n\t\t\t\t\tObject.assign(context, ctx);\n\t\t\t\t}\n\t\t\t},\n\t\t\tenumerable: false\n\t\t});\n\t\tfor (const key of keys) {\n\t\t\tObject.defineProperty(chain, key, { get() {\n\t\t\t\treturn create({\n\t\t\t\t\t...context,\n\t\t\t\t\t[key]: true\n\t\t\t\t});\n\t\t\t} });\n\t\t}\n\t\treturn chain;\n\t}\n\tconst chain = create(context ?? {});\n\tObject.defineProperty(chain, \"fn\", {\n\t\tvalue: fn,\n\t\tenumerable: false\n\t});\n\treturn chain;\n}\n\nfunction getDefaultHookTimeout() {\n\treturn getRunner().config.hookTimeout;\n}\nconst CLEANUP_TIMEOUT_KEY = Symbol.for(\"VITEST_CLEANUP_TIMEOUT\");\nconst CLEANUP_STACK_TRACE_KEY = Symbol.for(\"VITEST_CLEANUP_STACK_TRACE\");\nconst AROUND_TIMEOUT_KEY = Symbol.for(\"VITEST_AROUND_TIMEOUT\");\nconst AROUND_STACK_TRACE_KEY = Symbol.for(\"VITEST_AROUND_STACK_TRACE\");\nfunction getBeforeHookCleanupCallback(hook, result, context) {\n\tif (typeof result === \"function\") {\n\t\tconst timeout = CLEANUP_TIMEOUT_KEY in hook && typeof hook[CLEANUP_TIMEOUT_KEY] === \"number\" ? hook[CLEANUP_TIMEOUT_KEY] : getDefaultHookTimeout();\n\t\tconst stackTraceError = CLEANUP_STACK_TRACE_KEY in hook && hook[CLEANUP_STACK_TRACE_KEY] instanceof Error ? hook[CLEANUP_STACK_TRACE_KEY] : undefined;\n\t\treturn withTimeout(result, timeout, true, stackTraceError, (_, error) => {\n\t\t\tif (context) {\n\t\t\t\tabortContextSignal(context, error);\n\t\t\t}\n\t\t});\n\t}\n}\n/**\n* Registers a callback function to be executed once before all tests within the current suite.\n* 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.\n*\n* **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.\n*\n* @param {Function} fn - The callback function to be executed before all tests.\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using beforeAll to set up a database connection\n* beforeAll(async () => {\n*   await database.connect();\n* });\n* ```\n*/\nfunction beforeAll(fn, timeout = getDefaultHookTimeout()) {\n\tassertTypes(fn, \"\\\"beforeAll\\\" callback\", [\"function\"]);\n\tconst stackTraceError = new Error(\"STACK_TRACE_ERROR\");\n\tconst context = getChainableContext(this);\n\treturn getCurrentSuite().on(\"beforeAll\", Object.assign(withTimeout(withSuiteFixtures(\"beforeAll\", fn, context, stackTraceError), timeout, true, stackTraceError), {\n\t\t[CLEANUP_TIMEOUT_KEY]: timeout,\n\t\t[CLEANUP_STACK_TRACE_KEY]: stackTraceError\n\t}));\n}\n/**\n* Registers a callback function to be executed once after all tests within the current suite have completed.\n* 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.\n*\n* **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.\n*\n* @param {Function} fn - The callback function to be executed after all tests.\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using afterAll to close a database connection\n* afterAll(async () => {\n*   await database.disconnect();\n* });\n* ```\n*/\nfunction afterAll(fn, timeout) {\n\tassertTypes(fn, \"\\\"afterAll\\\" callback\", [\"function\"]);\n\tconst context = getChainableContext(this);\n\tconst stackTraceError = new Error(\"STACK_TRACE_ERROR\");\n\treturn getCurrentSuite().on(\"afterAll\", withTimeout(withSuiteFixtures(\"afterAll\", fn, context, stackTraceError), timeout ?? getDefaultHookTimeout(), true, stackTraceError));\n}\n/**\n* Registers a callback function to be executed before each test within the current suite.\n* 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.\n*\n* **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.\n*\n* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using beforeEach to reset a database state\n* beforeEach(async () => {\n*   await database.reset();\n* });\n* ```\n*/\nfunction beforeEach(fn, timeout = getDefaultHookTimeout()) {\n\tassertTypes(fn, \"\\\"beforeEach\\\" callback\", [\"function\"]);\n\tconst stackTraceError = new Error(\"STACK_TRACE_ERROR\");\n\tconst wrapper = (context, suite) => {\n\t\tconst fixtureResolver = withFixtures(fn, { suite });\n\t\treturn fixtureResolver(context);\n\t};\n\treturn getCurrentSuite().on(\"beforeEach\", Object.assign(withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {\n\t\t[CLEANUP_TIMEOUT_KEY]: timeout,\n\t\t[CLEANUP_STACK_TRACE_KEY]: stackTraceError\n\t}));\n}\n/**\n* Registers a callback function to be executed after each test within the current suite has completed.\n* 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.\n*\n* **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.\n*\n* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using afterEach to delete temporary files created during a test\n* afterEach(async () => {\n*   await fileSystem.deleteTempFiles();\n* });\n* ```\n*/\nfunction afterEach(fn, timeout) {\n\tassertTypes(fn, \"\\\"afterEach\\\" callback\", [\"function\"]);\n\tconst wrapper = (context, suite) => {\n\t\tconst fixtureResolver = withFixtures(fn, { suite });\n\t\treturn fixtureResolver(context);\n\t};\n\treturn getCurrentSuite().on(\"afterEach\", withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, new Error(\"STACK_TRACE_ERROR\"), abortIfTimeout));\n}\n/**\n* Registers a callback function to be executed when a test fails within the current suite.\n* This function allows for custom actions to be performed in response to test failures, such as logging, cleanup, or additional diagnostics.\n*\n* **Note:** The `onTestFailed` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.\n*\n* @param {Function} fn - The callback function to be executed upon a test failure. The function receives the test result (including errors).\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @throws {Error} Throws an error if the function is not called within a test.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using onTestFailed to log failure details\n* onTestFailed(({ errors }) => {\n*   console.log(`Test failed: ${test.name}`, errors);\n* });\n* ```\n*/\nconst onTestFailed = createTestHook(\"onTestFailed\", (test, handler, timeout) => {\n\ttest.onFailed ||= [];\n\ttest.onFailed.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error(\"STACK_TRACE_ERROR\"), abortIfTimeout));\n});\n/**\n* Registers a callback function to be executed when the current test finishes, regardless of the outcome (pass or fail).\n* This function is ideal for performing actions that should occur after every test execution, such as cleanup, logging, or resetting shared resources.\n*\n* This hook is useful if you have access to a resource in the test itself and you want to clean it up after the test finishes. It is a more compact way to clean up resources than using the combination of `beforeEach` and `afterEach`.\n*\n* **Note:** The `onTestFinished` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.\n*\n* **Note:** The `onTestFinished` hook is not called if the test is canceled with a dynamic `ctx.skip()` call.\n*\n* @param {Function} fn - The callback function to be executed after a test finishes. The function can receive parameters providing details about the completed test, including its success or failure status.\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @throws {Error} Throws an error if the function is not called within a test.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using onTestFinished for cleanup\n* const db = await connectToDatabase();\n* onTestFinished(async () => {\n*   await db.disconnect();\n* });\n* ```\n*/\nconst onTestFinished = createTestHook(\"onTestFinished\", (test, handler, timeout) => {\n\ttest.onFinished ||= [];\n\ttest.onFinished.push(withTimeout(handler, timeout ?? getDefaultHookTimeout(), true, new Error(\"STACK_TRACE_ERROR\"), abortIfTimeout));\n});\n/**\n* Registers a callback function that wraps around all tests within the current suite.\n* The callback receives a `runSuite` function that must be called to run the suite's tests.\n* This hook is useful for scenarios where you need to wrap an entire suite in a context\n* (e.g., starting a server, opening a database connection that all tests share).\n*\n* **Note:** When multiple `aroundAll` hooks are registered, they are nested inside each other.\n* The first registered hook is the outermost wrapper.\n*\n* @param {Function} fn - The callback function that wraps the suite. Must call `runSuite()` to run the tests.\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using aroundAll to wrap suite in a tracing span\n* aroundAll(async (runSuite) => {\n*   await tracer.trace('test-suite', runSuite);\n* });\n* ```\n* @example\n* ```ts\n* // Example of using aroundAll with fixtures\n* aroundAll(async (runSuite, { db }) => {\n*   await db.transaction(() => runSuite());\n* });\n* ```\n*/\nfunction aroundAll(fn, timeout) {\n\tassertTypes(fn, \"\\\"aroundAll\\\" callback\", [\"function\"]);\n\tconst stackTraceError = new Error(\"STACK_TRACE_ERROR\");\n\tconst resolvedTimeout = timeout ?? getDefaultHookTimeout();\n\tconst context = getChainableContext(this);\n\treturn getCurrentSuite().on(\"aroundAll\", Object.assign(withSuiteFixtures(\"aroundAll\", fn, context, stackTraceError, 1), {\n\t\t[AROUND_TIMEOUT_KEY]: resolvedTimeout,\n\t\t[AROUND_STACK_TRACE_KEY]: stackTraceError\n\t}));\n}\n/**\n* Registers a callback function that wraps around each test within the current suite.\n* The callback receives a `runTest` function that must be called to run the test.\n* This hook is useful for scenarios where you need to wrap tests in a context (e.g., database transactions).\n*\n* **Note:** When multiple `aroundEach` hooks are registered, they are nested inside each other.\n* The first registered hook is the outermost wrapper.\n*\n* @param {Function} fn - The callback function that wraps the test. Must call `runTest()` to run the test.\n* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.\n* @returns {void}\n* @example\n* ```ts\n* // Example of using aroundEach to wrap tests in a database transaction\n* aroundEach(async (runTest) => {\n*   await database.transaction(() => runTest());\n* });\n* ```\n* @example\n* ```ts\n* // Example of using aroundEach with fixtures\n* aroundEach(async (runTest, { db }) => {\n*   await db.transaction(() => runTest());\n* });\n* ```\n*/\nfunction aroundEach(fn, timeout) {\n\tassertTypes(fn, \"\\\"aroundEach\\\" callback\", [\"function\"]);\n\tconst stackTraceError = new Error(\"STACK_TRACE_ERROR\");\n\tconst resolvedTimeout = timeout ?? getDefaultHookTimeout();\n\tconst wrapper = (runTest, context, suite) => {\n\t\tconst innerFn = (ctx) => fn(runTest, ctx, suite);\n\t\tconfigureProps(innerFn, {\n\t\t\tindex: 1,\n\t\t\toriginal: fn\n\t\t});\n\t\tconst fixtureResolver = withFixtures(innerFn, { suite });\n\t\treturn fixtureResolver(context);\n\t};\n\treturn getCurrentSuite().on(\"aroundEach\", Object.assign(wrapper, {\n\t\t[AROUND_TIMEOUT_KEY]: resolvedTimeout,\n\t\t[AROUND_STACK_TRACE_KEY]: stackTraceError\n\t}));\n}\nfunction withSuiteFixtures(suiteHook, fn, context, stackTraceError, contextIndex = 0) {\n\treturn (...args) => {\n\t\tconst suite = args.at(-1);\n\t\tconst prefix = args.slice(0, -1);\n\t\tconst wrapper = (ctx) => fn(...prefix, ctx, suite);\n\t\tconfigureProps(wrapper, {\n\t\t\tindex: contextIndex,\n\t\t\toriginal: fn\n\t\t});\n\t\tconst fixtures = context?.getFixtures();\n\t\tconst fileContext = fixtures?.getFileContext(suite.file);\n\t\tconst fixtured = withFixtures(wrapper, {\n\t\t\tsuiteHook,\n\t\t\tfixtures,\n\t\t\tcontext: fileContext,\n\t\t\tstackTraceError\n\t\t});\n\t\treturn fixtured();\n\t};\n}\nfunction getAroundHookTimeout(hook) {\n\treturn AROUND_TIMEOUT_KEY in hook && typeof hook[AROUND_TIMEOUT_KEY] === \"number\" ? hook[AROUND_TIMEOUT_KEY] : getDefaultHookTimeout();\n}\nfunction getAroundHookStackTrace(hook) {\n\treturn AROUND_STACK_TRACE_KEY in hook && hook[AROUND_STACK_TRACE_KEY] instanceof Error ? hook[AROUND_STACK_TRACE_KEY] : undefined;\n}\nfunction createTestHook(name, handler) {\n\treturn (fn, timeout) => {\n\t\tassertTypes(fn, `\"${name}\" callback`, [\"function\"]);\n\t\tconst current = getCurrentTest();\n\t\tif (!current) {\n\t\t\tthrow new Error(`Hook ${name}() can only be called inside a test`);\n\t\t}\n\t\treturn handler(current, fn, timeout);\n\t};\n}\n\n/**\n* If any tasks been marked as `only`, mark all other tasks as `skip`.\n*/\nfunction interpretTaskModes(file, namePattern, testLocations, testIds, testTagsFilter, onlyMode, parentIsOnly, allowOnly) {\n\tconst matchedLocations = [];\n\tconst traverseSuite = (suite, parentIsOnly, parentMatchedWithLocation) => {\n\t\tconst suiteIsOnly = parentIsOnly || suite.mode === \"only\";\n\t\t// Check if any tasks in this suite have `.only` - if so, only those should run\n\t\tconst hasSomeTasksOnly = onlyMode && suite.tasks.some((t) => t.mode === \"only\" || t.type === \"suite\" && someTasksAreOnly(t));\n\t\tsuite.tasks.forEach((t) => {\n\t\t\t// Check if either the parent suite or the task itself are marked as included\n\t\t\t// If there are tasks with `.only` in this suite, only include those (not all tasks from describe.only)\n\t\t\tconst includeTask = hasSomeTasksOnly ? t.mode === \"only\" || t.type === \"suite\" && someTasksAreOnly(t) : suiteIsOnly || t.mode === \"only\";\n\t\t\tif (onlyMode) {\n\t\t\t\tif (t.type === \"suite\" && (includeTask || someTasksAreOnly(t))) {\n\t\t\t\t\t// Don't skip this suite\n\t\t\t\t\tif (t.mode === \"only\") {\n\t\t\t\t\t\tcheckAllowOnly(t, allowOnly);\n\t\t\t\t\t\tt.mode = \"run\";\n\t\t\t\t\t}\n\t\t\t\t} else if (t.mode === \"run\" && !includeTask) {\n\t\t\t\t\tt.mode = \"skip\";\n\t\t\t\t} else if (t.mode === \"only\") {\n\t\t\t\t\tcheckAllowOnly(t, allowOnly);\n\t\t\t\t\tt.mode = \"run\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet hasLocationMatch = parentMatchedWithLocation;\n\t\t\t// Match test location against provided locations, only run if present\n\t\t\t// in `testLocations`. Note: if `includeTaskLocation` is not enabled,\n\t\t\t// all test will be skipped.\n\t\t\tif (testLocations !== undefined && testLocations.length !== 0) {\n\t\t\t\tif (t.location && testLocations?.includes(t.location.line)) {\n\t\t\t\t\tt.mode = \"run\";\n\t\t\t\t\tmatchedLocations.push(t.location.line);\n\t\t\t\t\thasLocationMatch = true;\n\t\t\t\t} else if (parentMatchedWithLocation) {\n\t\t\t\t\tt.mode = \"run\";\n\t\t\t\t} else if (t.type === \"test\") {\n\t\t\t\t\tt.mode = \"skip\";\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (t.type === \"test\") {\n\t\t\t\tif (namePattern && !getTaskFullName(t).match(namePattern)) {\n\t\t\t\t\tt.mode = \"skip\";\n\t\t\t\t}\n\t\t\t\tif (testIds && !testIds.includes(t.id)) {\n\t\t\t\t\tt.mode = \"skip\";\n\t\t\t\t}\n\t\t\t\tif (testTagsFilter && !testTagsFilter(t.tags || [])) {\n\t\t\t\t\tt.mode = \"skip\";\n\t\t\t\t}\n\t\t\t} else if (t.type === \"suite\") {\n\t\t\t\tif (t.mode === \"skip\") {\n\t\t\t\t\tskipAllTasks(t);\n\t\t\t\t} else if (t.mode === \"todo\") {\n\t\t\t\t\ttodoAllTasks(t);\n\t\t\t\t} else {\n\t\t\t\t\ttraverseSuite(t, includeTask, hasLocationMatch);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\t// if all subtasks are skipped, mark as skip\n\t\tif (suite.mode === \"run\" || suite.mode === \"queued\") {\n\t\t\tif (suite.tasks.length && suite.tasks.every((i) => i.mode !== \"run\" && i.mode !== \"queued\")) {\n\t\t\t\tsuite.mode = \"skip\";\n\t\t\t}\n\t\t}\n\t};\n\ttraverseSuite(file, parentIsOnly, false);\n\tconst nonMatching = testLocations?.filter((loc) => !matchedLocations.includes(loc));\n\tif (nonMatching && nonMatching.length !== 0) {\n\t\tconst message = nonMatching.length === 1 ? `line ${nonMatching[0]}` : `lines ${nonMatching.join(\", \")}`;\n\t\tif (file.result === undefined) {\n\t\t\tfile.result = {\n\t\t\t\tstate: \"fail\",\n\t\t\t\terrors: []\n\t\t\t};\n\t\t}\n\t\tif (file.result.errors === undefined) {\n\t\t\tfile.result.errors = [];\n\t\t}\n\t\tfile.result.errors.push(processError(new Error(`No test found in ${file.name} in ${message}`)));\n\t}\n}\nfunction getTaskFullName(task) {\n\treturn `${task.suite ? `${getTaskFullName(task.suite)} ` : \"\"}${task.name}`;\n}\nfunction someTasksAreOnly(suite) {\n\treturn suite.tasks.some((t) => t.mode === \"only\" || t.type === \"suite\" && someTasksAreOnly(t));\n}\nfunction skipAllTasks(suite) {\n\tsuite.tasks.forEach((t) => {\n\t\tif (t.mode === \"run\" || t.mode === \"queued\") {\n\t\t\tt.mode = \"skip\";\n\t\t\tif (t.type === \"suite\") {\n\t\t\t\tskipAllTasks(t);\n\t\t\t}\n\t\t}\n\t});\n}\nfunction todoAllTasks(suite) {\n\tsuite.tasks.forEach((t) => {\n\t\tif (t.mode === \"run\" || t.mode === \"queued\") {\n\t\t\tt.mode = \"todo\";\n\t\t\tif (t.type === \"suite\") {\n\t\t\t\ttodoAllTasks(t);\n\t\t\t}\n\t\t}\n\t});\n}\nfunction checkAllowOnly(task, allowOnly) {\n\tif (allowOnly) {\n\t\treturn;\n\t}\n\tconst error = processError(new Error(\"[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error\"));\n\ttask.result = {\n\t\tstate: \"fail\",\n\t\terrors: [error]\n\t};\n}\n/* @__NO_SIDE_EFFECTS__ */\nfunction generateHash(str) {\n\tlet hash = 0;\n\tif (str.length === 0) {\n\t\treturn `${hash}`;\n\t}\n\tfor (let i = 0; i < str.length; i++) {\n\t\tconst char = str.charCodeAt(i);\n\t\thash = (hash << 5) - hash + char;\n\t\thash = hash & hash;\n\t}\n\treturn `${hash}`;\n}\nfunction calculateSuiteHash(parent) {\n\tparent.tasks.forEach((t, idx) => {\n\t\tt.id = `${parent.id}_${idx}`;\n\t\tif (t.type === \"suite\") {\n\t\t\tcalculateSuiteHash(t);\n\t\t}\n\t});\n}\nfunction createFileTask(filepath, root, projectName, pool, viteEnvironment) {\n\tconst path = relative(root, filepath);\n\tconst file = {\n\t\tid: generateFileHash(path, projectName),\n\t\tname: path,\n\t\tfullName: path,\n\t\ttype: \"suite\",\n\t\tmode: \"queued\",\n\t\tfilepath,\n\t\ttasks: [],\n\t\tmeta: Object.create(null),\n\t\tprojectName,\n\t\tfile: undefined,\n\t\tpool,\n\t\tviteEnvironment\n\t};\n\tfile.file = file;\n\treturn file;\n}\n/**\n* Generate a unique ID for a file based on its path and project name\n* @param file File relative to the root of the project to keep ID the same between different machines\n* @param projectName The name of the test project\n*/\n/* @__NO_SIDE_EFFECTS__ */\nfunction generateFileHash(file, projectName) {\n\treturn /* @__PURE__ */ generateHash(`${file}${projectName || \"\"}`);\n}\nfunction findTestFileStackTrace(testFilePath, error) {\n\t// first line is the error message\n\tconst lines = error.split(\"\\n\").slice(1);\n\tfor (const line of lines) {\n\t\tconst stack = parseSingleStack(line);\n\t\tif (stack && stack.file === testFilePath) {\n\t\t\treturn stack;\n\t\t}\n\t}\n}\n\n/**\n* Return a function for running multiple async operations with limited concurrency.\n*/\nfunction limitConcurrency(concurrency = Infinity) {\n\t// The number of currently active + pending tasks.\n\tlet count = 0;\n\t// The head and tail of the pending task queue, built using a singly linked list.\n\t// Both head and tail are initially undefined, signifying an empty queue.\n\t// They both become undefined again whenever there are no pending tasks.\n\tlet head;\n\tlet tail;\n\t// A bookkeeping function executed whenever a task has been run to completion.\n\tconst finish = () => {\n\t\tcount--;\n\t\t// Check if there are further pending tasks in the queue.\n\t\tif (head) {\n\t\t\t// Allow the next pending task to run and pop it from the queue.\n\t\t\thead[0]();\n\t\t\thead = head[1];\n\t\t\t// The head may now be undefined if there are no further pending tasks.\n\t\t\t// In that case, set tail to undefined as well.\n\t\t\ttail = head && tail;\n\t\t}\n\t};\n\tconst acquire = () => {\n\t\tlet released = false;\n\t\tconst release = () => {\n\t\t\tif (!released) {\n\t\t\t\treleased = true;\n\t\t\t\tfinish();\n\t\t\t}\n\t\t};\n\t\tif (count++ < concurrency) {\n\t\t\treturn release;\n\t\t}\n\t\treturn new Promise((resolve) => {\n\t\t\tif (tail) {\n\t\t\t\t// There are pending tasks, so append to the queue.\n\t\t\t\ttail = tail[1] = [() => resolve(release)];\n\t\t\t} else {\n\t\t\t\t// No other pending tasks, initialize the queue with a new tail and head.\n\t\t\t\thead = tail = [() => resolve(release)];\n\t\t\t}\n\t\t});\n\t};\n\tconst limiterFn = (func, ...args) => {\n\t\tfunction run(release) {\n\t\t\ttry {\n\t\t\t\tconst result = func(...args);\n\t\t\t\tif (result instanceof Promise) {\n\t\t\t\t\treturn result.finally(release);\n\t\t\t\t}\n\t\t\t\trelease();\n\t\t\t\treturn Promise.resolve(result);\n\t\t\t} catch (error) {\n\t\t\t\trelease();\n\t\t\t\treturn Promise.reject(error);\n\t\t\t}\n\t\t}\n\t\tconst release = acquire();\n\t\treturn release instanceof Promise ? release.then(run) : run(release);\n\t};\n\treturn Object.assign(limiterFn, { acquire });\n}\n\n/**\n* Partition in tasks groups by consecutive concurrent\n*/\nfunction partitionSuiteChildren(suite) {\n\tlet tasksGroup = [];\n\tconst tasksGroups = [];\n\tfor (const c of suite.tasks) {\n\t\tif (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {\n\t\t\ttasksGroup.push(c);\n\t\t} else {\n\t\t\ttasksGroups.push(tasksGroup);\n\t\t\ttasksGroup = [c];\n\t\t}\n\t}\n\tif (tasksGroup.length > 0) {\n\t\ttasksGroups.push(tasksGroup);\n\t}\n\treturn tasksGroups;\n}\n\nconst filterMap = new WeakMap();\n/**\n* @experimental\n*/\nfunction matchesTags(testTags) {\n\tconst runner = getRunner();\n\tconst tagsFilter = runner._currentSpecification?.testTagsFilter ?? runner.config.tagsFilter;\n\tif (!tagsFilter) {\n\t\treturn true;\n\t}\n\tlet tagsFilterPredicate = filterMap.get(tagsFilter);\n\tif (!tagsFilterPredicate) {\n\t\ttagsFilterPredicate = createTagsFilter(tagsFilter, runner.config.tags);\n\t\tfilterMap.set(tagsFilter, tagsFilterPredicate);\n\t}\n\treturn tagsFilterPredicate(testTags);\n}\nfunction validateTags(config, tags) {\n\tif (!config.strictTags) {\n\t\treturn;\n\t}\n\tconst availableTags = new Set(config.tags.map((tag) => tag.name));\n\tfor (const tag of tags) {\n\t\tif (!availableTags.has(tag)) {\n\t\t\tthrow createNoTagsError(config.tags, tag);\n\t\t}\n\t}\n}\nfunction createNoTagsError(availableTags, tag, prefix = \"tag\") {\n\tif (!availableTags.length) {\n\t\tthrow new Error(`The Vitest config does't define any \"tags\", cannot apply \"${tag}\" ${prefix} for this test. See: https://vitest.dev/guide/test-tags`);\n\t}\n\tthrow new Error(`The ${prefix} \"${tag}\" is not defined in the configuration. Available tags are:\\n${availableTags.map((t) => `- ${t.name}${t.description ? `: ${t.description}` : \"\"}`).join(\"\\n\")}`);\n}\nfunction createTagsFilter(tagsExpr, availableTags) {\n\tconst matchers = tagsExpr.map((expr) => parseTagsExpression(expr, availableTags));\n\treturn (testTags) => {\n\t\treturn matchers.every((matcher) => matcher(testTags));\n\t};\n}\nfunction parseTagsExpression(expr, availableTags) {\n\tconst tokens = tokenize(expr);\n\tconst stream = new TokenStream(tokens, expr);\n\tconst ast = parseOrExpression(stream, availableTags);\n\tif (stream.peek().type !== \"EOF\") {\n\t\tthrow new Error(`Invalid tags expression: unexpected \"${formatToken(stream.peek())}\" in \"${expr}\"`);\n\t}\n\treturn (tags) => evaluateNode(ast, tags);\n}\nfunction formatToken(token) {\n\tswitch (token.type) {\n\t\tcase \"TAG\": return token.value;\n\t\tdefault: return formatTokenType(token.type);\n\t}\n}\nfunction tokenize(expr) {\n\tconst tokens = [];\n\tlet i = 0;\n\twhile (i < expr.length) {\n\t\tif (expr[i] === \" \" || expr[i] === \"\t\") {\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\t\tif (expr[i] === \"(\") {\n\t\t\ttokens.push({ type: \"LPAREN\" });\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\t\tif (expr[i] === \")\") {\n\t\t\ttokens.push({ type: \"RPAREN\" });\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\t\tif (expr[i] === \"!\") {\n\t\t\ttokens.push({ type: \"NOT\" });\n\t\t\ti++;\n\t\t\tcontinue;\n\t\t}\n\t\tif (expr.slice(i, i + 2) === \"&&\") {\n\t\t\ttokens.push({ type: \"AND\" });\n\t\t\ti += 2;\n\t\t\tcontinue;\n\t\t}\n\t\tif (expr.slice(i, i + 2) === \"||\") {\n\t\t\ttokens.push({ type: \"OR\" });\n\t\t\ti += 2;\n\t\t\tcontinue;\n\t\t}\n\t\tif (/^and(?:\\s|\\)|$)/i.test(expr.slice(i))) {\n\t\t\ttokens.push({ type: \"AND\" });\n\t\t\ti += 3;\n\t\t\tcontinue;\n\t\t}\n\t\tif (/^or(?:\\s|\\)|$)/i.test(expr.slice(i))) {\n\t\t\ttokens.push({ type: \"OR\" });\n\t\t\ti += 2;\n\t\t\tcontinue;\n\t\t}\n\t\tif (/^not\\s/i.test(expr.slice(i))) {\n\t\t\ttokens.push({ type: \"NOT\" });\n\t\t\ti += 3;\n\t\t\tcontinue;\n\t\t}\n\t\tlet tag = \"\";\n\t\twhile (i < expr.length && expr[i] !== \" \" && expr[i] !== \"\t\" && expr[i] !== \"(\" && expr[i] !== \")\" && expr[i] !== \"!\" && expr[i] !== \"&\" && expr[i] !== \"|\") {\n\t\t\tconst remaining = expr.slice(i);\n\t\t\t// Only treat and/or/not as operators if we're at the start of a tag (after whitespace)\n\t\t\t// This allows tags like \"demand\", \"editor\", \"cannot\" to work correctly\n\t\t\tif (tag === \"\" && (/^and(?:\\s|\\)|$)/i.test(remaining) || /^or(?:\\s|\\)|$)/i.test(remaining) || /^not\\s/i.test(remaining))) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\ttag += expr[i];\n\t\t\ti++;\n\t\t}\n\t\tif (tag) {\n\t\t\ttokens.push({\n\t\t\t\ttype: \"TAG\",\n\t\t\t\tvalue: tag\n\t\t\t});\n\t\t}\n\t}\n\ttokens.push({ type: \"EOF\" });\n\treturn tokens;\n}\nclass TokenStream {\n\tpos = 0;\n\tconstructor(tokens, expr) {\n\t\tthis.tokens = tokens;\n\t\tthis.expr = expr;\n\t}\n\tpeek() {\n\t\treturn this.tokens[this.pos];\n\t}\n\tnext() {\n\t\treturn this.tokens[this.pos++];\n\t}\n\texpect(type) {\n\t\tconst token = this.next();\n\t\tif (token.type !== type) {\n\t\t\tif (type === \"RPAREN\" && token.type === \"EOF\") {\n\t\t\t\tthrow new Error(`Invalid tags expression: missing closing \")\" in \"${this.expr}\"`);\n\t\t\t}\n\t\t\tthrow new Error(`Invalid tags expression: expected \"${formatTokenType(type)}\" but got \"${formatToken(token)}\" in \"${this.expr}\"`);\n\t\t}\n\t\treturn token;\n\t}\n\tunexpectedToken() {\n\t\tconst token = this.peek();\n\t\tif (token.type === \"EOF\") {\n\t\t\tthrow new Error(`Invalid tags expression: unexpected end of expression in \"${this.expr}\"`);\n\t\t}\n\t\tthrow new Error(`Invalid tags expression: unexpected \"${formatToken(token)}\" in \"${this.expr}\"`);\n\t}\n}\nfunction formatTokenType(type) {\n\tswitch (type) {\n\t\tcase \"TAG\": return \"tag\";\n\t\tcase \"AND\": return \"and\";\n\t\tcase \"OR\": return \"or\";\n\t\tcase \"NOT\": return \"not\";\n\t\tcase \"LPAREN\": return \"(\";\n\t\tcase \"RPAREN\": return \")\";\n\t\tcase \"EOF\": return \"end of expression\";\n\t}\n}\nfunction parseOrExpression(stream, availableTags) {\n\tlet left = parseAndExpression(stream, availableTags);\n\twhile (stream.peek().type === \"OR\") {\n\t\tstream.next();\n\t\tconst right = parseAndExpression(stream, availableTags);\n\t\tleft = {\n\t\t\ttype: \"or\",\n\t\t\tleft,\n\t\t\tright\n\t\t};\n\t}\n\treturn left;\n}\nfunction parseAndExpression(stream, availableTags) {\n\tlet left = parseUnaryExpression(stream, availableTags);\n\twhile (stream.peek().type === \"AND\") {\n\t\tstream.next();\n\t\tconst right = parseUnaryExpression(stream, availableTags);\n\t\tleft = {\n\t\t\ttype: \"and\",\n\t\t\tleft,\n\t\t\tright\n\t\t};\n\t}\n\treturn left;\n}\nfunction parseUnaryExpression(stream, availableTags) {\n\tif (stream.peek().type === \"NOT\") {\n\t\tstream.next();\n\t\tconst operand = parseUnaryExpression(stream, availableTags);\n\t\treturn {\n\t\t\ttype: \"not\",\n\t\t\toperand\n\t\t};\n\t}\n\treturn parsePrimaryExpression(stream, availableTags);\n}\nfunction parsePrimaryExpression(stream, availableTags) {\n\tconst token = stream.peek();\n\tif (token.type === \"LPAREN\") {\n\t\tstream.next();\n\t\tconst expr = parseOrExpression(stream, availableTags);\n\t\tstream.expect(\"RPAREN\");\n\t\treturn expr;\n\t}\n\tif (token.type === \"TAG\") {\n\t\tstream.next();\n\t\tconst tagValue = token.value;\n\t\tconst pattern = resolveTagPattern(tagValue, availableTags);\n\t\treturn {\n\t\t\ttype: \"tag\",\n\t\t\tvalue: tagValue,\n\t\t\tpattern\n\t\t};\n\t}\n\tstream.unexpectedToken();\n}\nfunction createWildcardRegex(pattern) {\n\treturn new RegExp(`^${pattern.replace(/[.+?^${}()|[\\]\\\\]/g, \"\\\\$&\").replace(/\\*/g, \".*\")}$`);\n}\nfunction resolveTagPattern(tagPattern, availableTags) {\n\tif (tagPattern.includes(\"*\")) {\n\t\tconst regex = createWildcardRegex(tagPattern);\n\t\tconst hasMatch = availableTags.some((tag) => regex.test(tag.name));\n\t\tif (!hasMatch) {\n\t\t\tthrow createNoTagsError(availableTags, tagPattern, \"tag pattern\");\n\t\t}\n\t\treturn regex;\n\t}\n\tif (!availableTags.length || !availableTags.some((tag) => tag.name === tagPattern)) {\n\t\tthrow createNoTagsError(availableTags, tagPattern, \"tag pattern\");\n\t}\n\treturn null;\n}\nfunction evaluateNode(node, tags) {\n\tswitch (node.type) {\n\t\tcase \"tag\":\n\t\t\tif (node.pattern) {\n\t\t\t\treturn tags.some((tag) => node.pattern.test(tag));\n\t\t\t}\n\t\t\treturn tags.includes(node.value);\n\t\tcase \"not\": return !evaluateNode(node.operand, tags);\n\t\tcase \"and\": return evaluateNode(node.left, tags) && evaluateNode(node.right, tags);\n\t\tcase \"or\": return evaluateNode(node.left, tags) || evaluateNode(node.right, tags);\n\t}\n}\n\nfunction isTestCase(s) {\n\treturn s.type === \"test\";\n}\nfunction getTests(suite) {\n\tconst tests = [];\n\tconst arraySuites = toArray(suite);\n\tfor (const s of arraySuites) {\n\t\tif (isTestCase(s)) {\n\t\t\ttests.push(s);\n\t\t} else {\n\t\t\tfor (const task of s.tasks) {\n\t\t\t\tif (isTestCase(task)) {\n\t\t\t\t\ttests.push(task);\n\t\t\t\t} else {\n\t\t\t\t\tconst taskTests = getTests(task);\n\t\t\t\t\tfor (const test of taskTests) {\n\t\t\t\t\t\ttests.push(test);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn tests;\n}\nfunction getTasks(tasks = []) {\n\treturn toArray(tasks).flatMap((s) => isTestCase(s) ? [s] : [s, ...getTasks(s.tasks)]);\n}\nfunction getSuites(suite) {\n\treturn toArray(suite).flatMap((s) => s.type === \"suite\" ? [s, ...getSuites(s.tasks)] : []);\n}\nfunction hasTests(suite) {\n\treturn toArray(suite).some((s) => s.tasks.some((c) => isTestCase(c) || hasTests(c)));\n}\nfunction hasFailed(suite) {\n\treturn toArray(suite).some((s) => s.result?.state === \"fail\" || s.type === \"suite\" && hasFailed(s.tasks));\n}\nfunction getNames(task) {\n\tconst names = [task.name];\n\tlet current = task;\n\twhile (current?.suite) {\n\t\tcurrent = current.suite;\n\t\tif (current?.name) {\n\t\t\tnames.unshift(current.name);\n\t\t}\n\t}\n\tif (current !== task.file) {\n\t\tnames.unshift(task.file.name);\n\t}\n\treturn names;\n}\nfunction getFullName(task, separator = \" > \") {\n\treturn getNames(task).join(separator);\n}\nfunction getTestName(task, separator = \" > \") {\n\treturn getNames(task).slice(1).join(separator);\n}\nfunction createTaskName(names, separator = \" > \") {\n\treturn names.filter((name) => name !== undefined).join(separator);\n}\n\n/**\n* Creates a suite of tests, allowing for grouping and hierarchical organization of tests.\n* Suites can contain both tests and other suites, enabling complex test structures.\n*\n* @param {string} name - The name of the suite, used for identification and reporting.\n* @param {Function} fn - A function that defines the tests and suites within this suite.\n* @example\n* ```ts\n* // Define a suite with two tests\n* suite('Math operations', () => {\n*   test('should add two numbers', () => {\n*     expect(add(1, 2)).toBe(3);\n*   });\n*\n*   test('should subtract two numbers', () => {\n*     expect(subtract(5, 2)).toBe(3);\n*   });\n* });\n* ```\n* @example\n* ```ts\n* // Define nested suites\n* suite('String operations', () => {\n*   suite('Trimming', () => {\n*     test('should trim whitespace from start and end', () => {\n*       expect('  hello  '.trim()).toBe('hello');\n*     });\n*   });\n*\n*   suite('Concatenation', () => {\n*     test('should concatenate two strings', () => {\n*       expect('hello' + ' ' + 'world').toBe('hello world');\n*     });\n*   });\n* });\n* ```\n*/\nconst suite = createSuite();\n/**\n* Defines a test case with a given name and test function. The test function can optionally be configured with test options.\n*\n* @param {string | Function} name - The name of the test or a function that will be used as a test name.\n* @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.\n* @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.\n* @throws {Error} If called inside another test function.\n* @example\n* ```ts\n* // Define a simple test\n* test('should add two numbers', () => {\n*   expect(add(1, 2)).toBe(3);\n* });\n* ```\n* @example\n* ```ts\n* // Define a test with options\n* test('should subtract two numbers', { retry: 3 }, () => {\n*   expect(subtract(5, 2)).toBe(3);\n* });\n* ```\n*/\nconst test = createTest(function(name, optionsOrFn, optionsOrTest) {\n\tif (getCurrentTest()) {\n\t\tthrow 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.\");\n\t}\n\tgetCurrentSuite().test.fn.call(this, formatName(name), optionsOrFn, optionsOrTest);\n});\n/**\n* Creates a suite of tests, allowing for grouping and hierarchical organization of tests.\n* Suites can contain both tests and other suites, enabling complex test structures.\n*\n* @param {string} name - The name of the suite, used for identification and reporting.\n* @param {Function} fn - A function that defines the tests and suites within this suite.\n* @example\n* ```ts\n* // Define a suite with two tests\n* describe('Math operations', () => {\n*   test('should add two numbers', () => {\n*     expect(add(1, 2)).toBe(3);\n*   });\n*\n*   test('should subtract two numbers', () => {\n*     expect(subtract(5, 2)).toBe(3);\n*   });\n* });\n* ```\n* @example\n* ```ts\n* // Define nested suites\n* describe('String operations', () => {\n*   describe('Trimming', () => {\n*     test('should trim whitespace from start and end', () => {\n*       expect('  hello  '.trim()).toBe('hello');\n*     });\n*   });\n*\n*   describe('Concatenation', () => {\n*     test('should concatenate two strings', () => {\n*       expect('hello' + ' ' + 'world').toBe('hello world');\n*     });\n*   });\n* });\n* ```\n*/\nconst describe = suite;\n/**\n* Defines a test case with a given name and test function. The test function can optionally be configured with test options.\n*\n* @param {string | Function} name - The name of the test or a function that will be used as a test name.\n* @param {TestOptions | TestFunction} [optionsOrFn] - Optional. The test options or the test function if no explicit name is provided.\n* @param {number | TestOptions | TestFunction} [optionsOrTest] - Optional. The test function or options, depending on the previous parameters.\n* @throws {Error} If called inside another test function.\n* @example\n* ```ts\n* // Define a simple test\n* it('adds two numbers', () => {\n*   expect(add(1, 2)).toBe(3);\n* });\n* ```\n* @example\n* ```ts\n* // Define a test with options\n* it('subtracts two numbers', { retry: 3 }, () => {\n*   expect(subtract(5, 2)).toBe(3);\n* });\n* ```\n*/\nconst it = test;\nlet runner;\nlet defaultSuite;\nlet currentTestFilepath;\nfunction assert(condition, message) {\n\tif (!condition) {\n\t\tthrow new Error(`Vitest failed to find ${message}. One of the following is possible:` + \"\\n- \\\"vitest\\\" is imported directly without running \\\"vitest\\\" command\" + \"\\n- \\\"vitest\\\" is imported inside \\\"globalSetup\\\" (to fix this, use \\\"setupFiles\\\" instead, because \\\"globalSetup\\\" runs in a different context)\" + \"\\n- \\\"vitest\\\" is imported inside Vite / Vitest config file\" + \"\\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\\n\");\n\t}\n}\nfunction getDefaultSuite() {\n\tassert(defaultSuite, \"the default suite\");\n\treturn defaultSuite;\n}\nfunction getRunner() {\n\tassert(runner, \"the runner\");\n\treturn runner;\n}\nfunction createDefaultSuite(runner) {\n\tconst config = runner.config.sequence;\n\tconst options = {};\n\tif (config.concurrent != null) {\n\t\toptions.concurrent = config.concurrent;\n\t}\n\tconst collector = suite(\"\", options, () => {});\n\t// no parent suite for top-level tests\n\tdelete collector.suite;\n\treturn collector;\n}\nfunction clearCollectorContext(file, currentRunner) {\n\tcurrentTestFilepath = file.filepath;\n\trunner = currentRunner;\n\tif (!defaultSuite) {\n\t\tdefaultSuite = createDefaultSuite(currentRunner);\n\t}\n\tdefaultSuite.file = file;\n\tcollectorContext.tasks.length = 0;\n\tdefaultSuite.clear();\n\tcollectorContext.currentSuite = defaultSuite;\n}\nfunction getCurrentSuite() {\n\tconst currentSuite = collectorContext.currentSuite || defaultSuite;\n\tassert(currentSuite, \"the current suite\");\n\treturn currentSuite;\n}\nfunction createSuiteHooks() {\n\treturn {\n\t\tbeforeAll: [],\n\t\tafterAll: [],\n\t\tbeforeEach: [],\n\t\tafterEach: [],\n\t\taroundEach: [],\n\t\taroundAll: []\n\t};\n}\nconst POSITIVE_INFINITY = Number.POSITIVE_INFINITY;\nfunction parseArguments(optionsOrFn, timeoutOrTest) {\n\tif (timeoutOrTest != null && typeof timeoutOrTest === \"object\") {\n\t\tthrow new TypeError(`Signature \"test(name, fn, { ... })\" was deprecated in Vitest 3 and removed in Vitest 4. Please, provide options as a second argument instead.`);\n\t}\n\tlet options = {};\n\tlet fn;\n\t// it('', () => {}, 1000)\n\tif (typeof timeoutOrTest === \"number\") {\n\t\toptions = { timeout: timeoutOrTest };\n\t} else if (typeof optionsOrFn === \"object\") {\n\t\toptions = optionsOrFn;\n\t}\n\tif (typeof optionsOrFn === \"function\") {\n\t\tif (typeof timeoutOrTest === \"function\") {\n\t\t\tthrow new TypeError(\"Cannot use two functions as arguments. Please use the second argument for options.\");\n\t\t}\n\t\tfn = optionsOrFn;\n\t} else if (typeof timeoutOrTest === \"function\") {\n\t\tfn = timeoutOrTest;\n\t}\n\treturn {\n\t\toptions,\n\t\thandler: fn\n\t};\n}\n// implementations\nfunction createSuiteCollector(name, factory = () => {}, mode, each, suiteOptions) {\n\tconst tasks = [];\n\tlet suite;\n\tinitSuite(true);\n\tconst task = function(name = \"\", options = {}) {\n\t\tconst currentSuite = collectorContext.currentSuite?.suite;\n\t\tconst parentTask = currentSuite ?? collectorContext.currentSuite?.file;\n\t\tconst parentTags = parentTask?.tags || [];\n\t\tconst testTags = unique([...parentTags, ...toArray(options.tags)]);\n\t\tconst tagsOptions = testTags.map((tag) => {\n\t\t\tconst tagDefinition = runner.config.tags?.find((t) => t.name === tag);\n\t\t\tif (!tagDefinition && runner.config.strictTags) {\n\t\t\t\tthrow createNoTagsError(runner.config.tags, tag);\n\t\t\t}\n\t\t\treturn tagDefinition;\n\t\t}).filter((r) => r != null).sort((tag1, tag2) => (tag2.priority ?? POSITIVE_INFINITY) - (tag1.priority ?? POSITIVE_INFINITY)).reduce((acc, tag) => {\n\t\t\tconst { name, description, priority, meta, ...options } = tag;\n\t\t\tObject.assign(acc, options);\n\t\t\tif (meta) {\n\t\t\t\tacc.meta = Object.assign(acc.meta ?? Object.create(null), meta);\n\t\t\t}\n\t\t\treturn acc;\n\t\t}, {});\n\t\tconst testOwnMeta = options.meta;\n\t\toptions = {\n\t\t\t...tagsOptions,\n\t\t\t...options\n\t\t};\n\t\tconst timeout = options.timeout ?? runner.config.testTimeout;\n\t\tconst parentMeta = currentSuite?.meta;\n\t\tconst tagMeta = tagsOptions.meta;\n\t\tconst testMeta = Object.create(null);\n\t\tif (tagMeta) {\n\t\t\tObject.assign(testMeta, tagMeta);\n\t\t}\n\t\tif (parentMeta) {\n\t\t\tObject.assign(testMeta, parentMeta);\n\t\t}\n\t\tif (testOwnMeta) {\n\t\t\tObject.assign(testMeta, testOwnMeta);\n\t\t}\n\t\tconst task = {\n\t\t\tid: \"\",\n\t\t\tname,\n\t\t\tfullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),\n\t\t\tfullTestName: createTaskName([currentSuite?.fullTestName, name]),\n\t\t\tsuite: currentSuite,\n\t\t\teach: options.each,\n\t\t\tfails: options.fails,\n\t\t\tcontext: undefined,\n\t\t\ttype: \"test\",\n\t\t\tfile: currentSuite?.file ?? collectorContext.currentSuite?.file,\n\t\t\ttimeout,\n\t\t\tretry: options.retry ?? runner.config.retry,\n\t\t\trepeats: options.repeats,\n\t\t\tmode: options.only ? \"only\" : options.skip ? \"skip\" : options.todo ? \"todo\" : \"run\",\n\t\t\tmeta: testMeta,\n\t\t\tannotations: [],\n\t\t\tartifacts: [],\n\t\t\ttags: testTags\n\t\t};\n\t\tconst handler = options.handler;\n\t\tif (task.mode === \"run\" && !handler) {\n\t\t\ttask.mode = \"todo\";\n\t\t}\n\t\tif (options.concurrent ?? (!options.sequential && runner.config.sequence.concurrent)) {\n\t\t\ttask.concurrent = true;\n\t\t}\n\t\ttask.shuffle = suiteOptions?.shuffle;\n\t\tconst context = createTestContext(task, runner);\n\t\t// create test context\n\t\tObject.defineProperty(task, \"context\", {\n\t\t\tvalue: context,\n\t\t\tenumerable: false\n\t\t});\n\t\tsetTestFixture(context, options.fixtures ?? new TestFixtures());\n\t\tconst limit = Error.stackTraceLimit;\n\t\tError.stackTraceLimit = 10;\n\t\tconst stackTraceError = new Error(\"STACK_TRACE_ERROR\");\n\t\tError.stackTraceLimit = limit;\n\t\tif (handler) {\n\t\t\tsetFn(task, withTimeout(withCancel(withAwaitAsyncAssertions(withFixtures(handler, { context }), task), task.context.signal), timeout, false, stackTraceError, (_, error) => abortIfTimeout([context], error)));\n\t\t}\n\t\tif (runner.config.includeTaskLocation) {\n\t\t\tconst error = stackTraceError.stack;\n\t\t\tconst stack = findTestFileStackTrace(currentTestFilepath, error);\n\t\t\tif (stack) {\n\t\t\t\ttask.location = {\n\t\t\t\t\tline: stack.line,\n\t\t\t\t\tcolumn: stack.column\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t\ttasks.push(task);\n\t\treturn task;\n\t};\n\tconst test = createTest(function(name, optionsOrFn, timeoutOrTest) {\n\t\tlet { options, handler } = parseArguments(optionsOrFn, timeoutOrTest);\n\t\t// inherit repeats, retry, timeout from suite\n\t\tif (typeof suiteOptions === \"object\") {\n\t\t\toptions = Object.assign({}, suiteOptions, options);\n\t\t}\n\t\t// inherit concurrent / sequential from suite\n\t\tconst concurrent = this.concurrent ?? (!this.sequential && options?.concurrent);\n\t\tif (options.concurrent != null && concurrent != null) {\n\t\t\toptions.concurrent = concurrent;\n\t\t}\n\t\tconst sequential = this.sequential ?? (!this.concurrent && options?.sequential);\n\t\tif (options.sequential != null && sequential != null) {\n\t\t\toptions.sequential = sequential;\n\t\t}\n\t\tconst test = task(formatName(name), {\n\t\t\t...this,\n\t\t\t...options,\n\t\t\thandler\n\t\t});\n\t\ttest.type = \"test\";\n\t});\n\tconst collector = {\n\t\ttype: \"collector\",\n\t\tname,\n\t\tmode,\n\t\tsuite,\n\t\toptions: suiteOptions,\n\t\ttest,\n\t\tfile: suite.file,\n\t\ttasks,\n\t\tcollect,\n\t\ttask,\n\t\tclear,\n\t\ton: addHook\n\t};\n\tfunction addHook(name, ...fn) {\n\t\tgetHooks(suite)[name].push(...fn);\n\t}\n\tfunction initSuite(includeLocation) {\n\t\tif (typeof suiteOptions === \"number\") {\n\t\t\tsuiteOptions = { timeout: suiteOptions };\n\t\t}\n\t\tconst currentSuite = collectorContext.currentSuite?.suite;\n\t\tconst parentTask = currentSuite ?? collectorContext.currentSuite?.file;\n\t\tconst suiteTags = toArray(suiteOptions?.tags);\n\t\tvalidateTags(runner.config, suiteTags);\n\t\tsuite = {\n\t\t\tid: \"\",\n\t\t\ttype: \"suite\",\n\t\t\tname,\n\t\t\tfullName: createTaskName([currentSuite?.fullName ?? collectorContext.currentSuite?.file?.fullName, name]),\n\t\t\tfullTestName: createTaskName([currentSuite?.fullTestName, name]),\n\t\t\tsuite: currentSuite,\n\t\t\tmode,\n\t\t\teach,\n\t\t\tfile: currentSuite?.file ?? collectorContext.currentSuite?.file,\n\t\t\tshuffle: suiteOptions?.shuffle,\n\t\t\ttasks: [],\n\t\t\tmeta: suiteOptions?.meta ?? Object.create(null),\n\t\t\tconcurrent: suiteOptions?.concurrent,\n\t\t\ttags: unique([...parentTask?.tags || [], ...suiteTags])\n\t\t};\n\t\tif (runner && includeLocation && runner.config.includeTaskLocation) {\n\t\t\tconst limit = Error.stackTraceLimit;\n\t\t\tError.stackTraceLimit = 15;\n\t\t\tconst error = new Error(\"stacktrace\").stack;\n\t\t\tError.stackTraceLimit = limit;\n\t\t\tconst stack = findTestFileStackTrace(currentTestFilepath, error);\n\t\t\tif (stack) {\n\t\t\t\tsuite.location = {\n\t\t\t\t\tline: stack.line,\n\t\t\t\t\tcolumn: stack.column\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t\tsetHooks(suite, createSuiteHooks());\n\t}\n\tfunction clear() {\n\t\ttasks.length = 0;\n\t\tinitSuite(false);\n\t}\n\tasync function collect(file) {\n\t\tif (!file) {\n\t\t\tthrow new TypeError(\"File is required to collect tasks.\");\n\t\t}\n\t\tif (factory) {\n\t\t\tawait runWithSuite(collector, () => factory(test));\n\t\t}\n\t\tconst allChildren = [];\n\t\tfor (const i of tasks) {\n\t\t\tallChildren.push(i.type === \"collector\" ? await i.collect(file) : i);\n\t\t}\n\t\tsuite.tasks = allChildren;\n\t\treturn suite;\n\t}\n\tcollectTask(collector);\n\treturn collector;\n}\nfunction withAwaitAsyncAssertions(fn, task) {\n\treturn (async (...args) => {\n\t\tconst fnResult = await fn(...args);\n\t\t// some async expect will be added to this array, in case user forget to await them\n\t\tif (task.promises) {\n\t\t\tconst result = await Promise.allSettled(task.promises);\n\t\t\tconst errors = result.map((r) => r.status === \"rejected\" ? r.reason : undefined).filter(Boolean);\n\t\t\tif (errors.length) {\n\t\t\t\tthrow errors;\n\t\t\t}\n\t\t}\n\t\treturn fnResult;\n\t});\n}\nfunction createSuite() {\n\tfunction suiteFn(name, factoryOrOptions, optionsOrFactory) {\n\t\tif (getCurrentTest()) {\n\t\t\tthrow 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.\");\n\t\t}\n\t\tconst currentSuite = collectorContext.currentSuite || defaultSuite;\n\t\tlet { options, handler: factory } = parseArguments(factoryOrOptions, optionsOrFactory);\n\t\tconst isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false;\n\t\tconst isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false;\n\t\tconst { meta: parentMeta, ...parentOptions } = currentSuite?.options || {};\n\t\t// inherit options from current suite\n\t\toptions = {\n\t\t\t...parentOptions,\n\t\t\t...options\n\t\t};\n\t\tconst shuffle = this.shuffle ?? options.shuffle ?? currentSuite?.options?.shuffle ?? runner?.config.sequence.shuffle;\n\t\tif (shuffle != null) {\n\t\t\toptions.shuffle = shuffle;\n\t\t}\n\t\tlet mode = this.only ?? options.only ? \"only\" : this.skip ?? options.skip ? \"skip\" : this.todo ?? options.todo ? \"todo\" : \"run\";\n\t\t// passed as test(name), assume it's a \"todo\"\n\t\tif (mode === \"run\" && !factory) {\n\t\t\tmode = \"todo\";\n\t\t}\n\t\t// inherit concurrent / sequential from suite\n\t\tconst isConcurrent = isConcurrentSpecified || options.concurrent && !isSequentialSpecified;\n\t\tconst isSequential = isSequentialSpecified || options.sequential && !isConcurrentSpecified;\n\t\tif (isConcurrent != null) {\n\t\t\toptions.concurrent = isConcurrent && !isSequential;\n\t\t}\n\t\tif (isSequential != null) {\n\t\t\toptions.sequential = isSequential && !isConcurrent;\n\t\t}\n\t\tif (parentMeta) {\n\t\t\toptions.meta = Object.assign(Object.create(null), parentMeta, options.meta);\n\t\t}\n\t\treturn createSuiteCollector(formatName(name), factory, mode, this.each, options);\n\t}\n\tsuiteFn.each = function(cases, ...args) {\n\t\tconst context = getChainableContext(this);\n\t\tconst suite = context.withContext();\n\t\tcontext.setContext(\"each\", true);\n\t\tif (Array.isArray(cases) && args.length) {\n\t\t\tcases = formatTemplateString(cases, args);\n\t\t}\n\t\treturn (name, optionsOrFn, fnOrOptions) => {\n\t\t\tconst _name = formatName(name);\n\t\t\tconst arrayOnlyCases = cases.every(Array.isArray);\n\t\t\tconst { options, handler } = parseArguments(optionsOrFn, fnOrOptions);\n\t\t\tconst fnFirst = typeof optionsOrFn === \"function\";\n\t\t\tcases.forEach((i, idx) => {\n\t\t\t\tconst items = Array.isArray(i) ? i : [i];\n\t\t\t\tif (fnFirst) {\n\t\t\t\t\tif (arrayOnlyCases) {\n\t\t\t\t\t\tsuite(formatTitle(_name, items, idx), handler ? () => handler(...items) : undefined, options.timeout);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tsuite(formatTitle(_name, items, idx), handler ? () => handler(i) : undefined, options.timeout);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (arrayOnlyCases) {\n\t\t\t\t\t\tsuite(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : undefined);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tsuite(formatTitle(_name, items, idx), options, handler ? () => handler(i) : undefined);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t\tcontext.setContext(\"each\", undefined);\n\t\t};\n\t};\n\tsuiteFn.for = function(cases, ...args) {\n\t\tif (Array.isArray(cases) && args.length) {\n\t\t\tcases = formatTemplateString(cases, args);\n\t\t}\n\t\treturn (name, optionsOrFn, fnOrOptions) => {\n\t\t\tconst name_ = formatName(name);\n\t\t\tconst { options, handler } = parseArguments(optionsOrFn, fnOrOptions);\n\t\t\tcases.forEach((item, idx) => {\n\t\t\t\tsuite(formatTitle(name_, toArray(item), idx), options, handler ? () => handler(item) : undefined);\n\t\t\t});\n\t\t};\n\t};\n\tsuiteFn.skipIf = (condition) => condition ? suite.skip : suite;\n\tsuiteFn.runIf = (condition) => condition ? suite : suite.skip;\n\treturn createChainable([\n\t\t\"concurrent\",\n\t\t\"sequential\",\n\t\t\"shuffle\",\n\t\t\"skip\",\n\t\t\"only\",\n\t\t\"todo\"\n\t], suiteFn);\n}\nfunction createTaskCollector(fn) {\n\tconst taskFn = fn;\n\ttaskFn.each = function(cases, ...args) {\n\t\tconst context = getChainableContext(this);\n\t\tconst test = context.withContext();\n\t\tcontext.setContext(\"each\", true);\n\t\tif (Array.isArray(cases) && args.length) {\n\t\t\tcases = formatTemplateString(cases, args);\n\t\t}\n\t\treturn (name, optionsOrFn, fnOrOptions) => {\n\t\t\tconst _name = formatName(name);\n\t\t\tconst arrayOnlyCases = cases.every(Array.isArray);\n\t\t\tconst { options, handler } = parseArguments(optionsOrFn, fnOrOptions);\n\t\t\tconst fnFirst = typeof optionsOrFn === \"function\";\n\t\t\tcases.forEach((i, idx) => {\n\t\t\t\tconst items = Array.isArray(i) ? i : [i];\n\t\t\t\tif (fnFirst) {\n\t\t\t\t\tif (arrayOnlyCases) {\n\t\t\t\t\t\ttest(formatTitle(_name, items, idx), handler ? () => handler(...items) : undefined, options.timeout);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttest(formatTitle(_name, items, idx), handler ? () => handler(i) : undefined, options.timeout);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tif (arrayOnlyCases) {\n\t\t\t\t\t\ttest(formatTitle(_name, items, idx), options, handler ? () => handler(...items) : undefined);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttest(formatTitle(_name, items, idx), options, handler ? () => handler(i) : undefined);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t\tcontext.setContext(\"each\", undefined);\n\t\t};\n\t};\n\ttaskFn.for = function(cases, ...args) {\n\t\tconst context = getChainableContext(this);\n\t\tconst test = context.withContext();\n\t\tif (Array.isArray(cases) && args.length) {\n\t\t\tcases = formatTemplateString(cases, args);\n\t\t}\n\t\treturn (name, optionsOrFn, fnOrOptions) => {\n\t\t\tconst _name = formatName(name);\n\t\t\tconst { options, handler } = parseArguments(optionsOrFn, fnOrOptions);\n\t\t\tcases.forEach((item, idx) => {\n\t\t\t\t// monkey-patch handler to allow parsing fixture\n\t\t\t\tconst handlerWrapper = handler ? (ctx) => handler(item, ctx) : undefined;\n\t\t\t\tif (handlerWrapper) {\n\t\t\t\t\tconfigureProps(handlerWrapper, {\n\t\t\t\t\t\tindex: 1,\n\t\t\t\t\t\toriginal: handler\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\ttest(formatTitle(_name, toArray(item), idx), options, handlerWrapper);\n\t\t\t});\n\t\t};\n\t};\n\ttaskFn.skipIf = function(condition) {\n\t\treturn condition ? this.skip : this;\n\t};\n\ttaskFn.runIf = function(condition) {\n\t\treturn condition ? this : this.skip;\n\t};\n\t/**\n\t* Parse builder pattern arguments into a fixtures object.\n\t* Handles both builder pattern (name, options?, value) and object syntax.\n\t*/\n\tfunction parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn) {\n\t\t// Object syntax: just return as-is\n\t\tif (typeof fixturesOrName !== \"string\") {\n\t\t\treturn fixturesOrName;\n\t\t}\n\t\tconst fixtureName = fixturesOrName;\n\t\tlet fixtureOptions;\n\t\tlet fixtureValue;\n\t\tif (maybeFn !== undefined) {\n\t\t\t// (name, options, value) or (name, options, fn)\n\t\t\tfixtureOptions = optionsOrFn;\n\t\t\tfixtureValue = maybeFn;\n\t\t} else {\n\t\t\t// (name, value) or (name, fn)\n\t\t\t// Check if optionsOrFn looks like fixture options (has scope or auto)\n\t\t\tif (optionsOrFn !== null && typeof optionsOrFn === \"object\" && !Array.isArray(optionsOrFn) && TestFixtures.isFixtureOptions(optionsOrFn)) {\n\t\t\t\t// (name, options) with no value - treat as empty object fixture\n\t\t\t\tfixtureOptions = optionsOrFn;\n\t\t\t\tfixtureValue = {};\n\t\t\t} else {\n\t\t\t\t// (name, value) or (name, fn)\n\t\t\t\tfixtureOptions = undefined;\n\t\t\t\tfixtureValue = optionsOrFn;\n\t\t\t}\n\t\t}\n\t\t// Function value: wrap with onCleanup pattern\n\t\tif (typeof fixtureValue === \"function\") {\n\t\t\tconst builderFn = fixtureValue;\n\t\t\t// Wrap builder pattern function (returns value) to use() pattern\n\t\t\tconst fixture = async (ctx, use) => {\n\t\t\t\tlet cleanup;\n\t\t\t\tconst onCleanup = (fn) => {\n\t\t\t\t\tif (cleanup !== undefined) {\n\t\t\t\t\t\tthrow new Error(`onCleanup can only be called once per fixture. ` + `Define separate fixtures if you need multiple cleanup functions.`);\n\t\t\t\t\t}\n\t\t\t\t\tcleanup = fn;\n\t\t\t\t};\n\t\t\t\tconst value = await builderFn(ctx, { onCleanup });\n\t\t\t\tawait use(value);\n\t\t\t\tif (cleanup) {\n\t\t\t\t\tawait cleanup();\n\t\t\t\t}\n\t\t\t};\n\t\t\tconfigureProps(fixture, { original: builderFn });\n\t\t\tif (fixtureOptions) {\n\t\t\t\treturn { [fixtureName]: [fixture, fixtureOptions] };\n\t\t\t}\n\t\t\treturn { [fixtureName]: fixture };\n\t\t}\n\t\t// Non-function value: use directly\n\t\tif (fixtureOptions) {\n\t\t\treturn { [fixtureName]: [fixtureValue, fixtureOptions] };\n\t\t}\n\t\treturn { [fixtureName]: fixtureValue };\n\t}\n\ttaskFn.override = function(fixturesOrName, optionsOrFn, maybeFn) {\n\t\tconst userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);\n\t\tgetChainableContext(this).getFixtures().override(runner, userFixtures);\n\t\treturn this;\n\t};\n\ttaskFn.scoped = function(fixtures) {\n\t\tconsole.warn(`test.scoped() is deprecated and will be removed in future versions. Please use test.override() instead.`);\n\t\treturn this.override(fixtures);\n\t};\n\ttaskFn.extend = function(fixturesOrName, optionsOrFn, maybeFn) {\n\t\tconst userFixtures = parseBuilderFixtures(fixturesOrName, optionsOrFn, maybeFn);\n\t\tconst fixtures = getChainableContext(this).getFixtures().extend(runner, userFixtures);\n\t\tconst _test = createTest(function(name, optionsOrFn, optionsOrTest) {\n\t\t\tfn.call(this, formatName(name), optionsOrFn, optionsOrTest);\n\t\t});\n\t\tgetChainableContext(_test).mergeContext({ fixtures });\n\t\treturn _test;\n\t};\n\ttaskFn.describe = suite;\n\ttaskFn.suite = suite;\n\ttaskFn.beforeEach = beforeEach;\n\ttaskFn.afterEach = afterEach;\n\ttaskFn.beforeAll = beforeAll;\n\ttaskFn.afterAll = afterAll;\n\ttaskFn.aroundEach = aroundEach;\n\ttaskFn.aroundAll = aroundAll;\n\tconst _test = createChainable([\n\t\t\"concurrent\",\n\t\t\"sequential\",\n\t\t\"skip\",\n\t\t\"only\",\n\t\t\"todo\",\n\t\t\"fails\"\n\t], taskFn, { fixtures: new TestFixtures() });\n\treturn _test;\n}\nfunction createTest(fn) {\n\treturn createTaskCollector(fn);\n}\nfunction formatName(name) {\n\treturn typeof name === \"string\" ? name : typeof name === \"function\" ? name.name || \"<anonymous>\" : String(name);\n}\nfunction formatTitle(template, items, idx) {\n\tif (template.includes(\"%#\") || template.includes(\"%$\")) {\n\t\t// '%#' match index of the test case\n\t\ttemplate = template.replace(/%%/g, \"__vitest_escaped_%__\").replace(/%#/g, `${idx}`).replace(/%\\$/g, `${idx + 1}`).replace(/__vitest_escaped_%__/g, \"%%\");\n\t}\n\tconst count = template.split(\"%\").length - 1;\n\tif (template.includes(\"%f\")) {\n\t\tconst placeholders = template.match(/%f/g) || [];\n\t\tplaceholders.forEach((_, i) => {\n\t\t\tif (isNegativeNaN(items[i]) || Object.is(items[i], -0)) {\n\t\t\t\t// Replace the i-th occurrence of '%f' with '-%f'\n\t\t\t\tlet occurrence = 0;\n\t\t\t\ttemplate = template.replace(/%f/g, (match) => {\n\t\t\t\t\toccurrence++;\n\t\t\t\t\treturn occurrence === i + 1 ? \"-%f\" : match;\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\t}\n\tconst isObjectItem = isObject(items[0]);\n\tfunction formatAttribute(s) {\n\t\treturn s.replace(/\\$([$\\w.]+)/g, (_, key) => {\n\t\t\tconst isArrayKey = /^\\d+$/.test(key);\n\t\t\tif (!isObjectItem && !isArrayKey) {\n\t\t\t\treturn `$${key}`;\n\t\t\t}\n\t\t\tconst arrayElement = isArrayKey ? objectAttr(items, key) : undefined;\n\t\t\tconst value = isObjectItem ? objectAttr(items[0], key, arrayElement) : arrayElement;\n\t\t\treturn objDisplay(value, { truncate: runner?.config?.chaiConfig?.truncateThreshold });\n\t\t});\n\t}\n\tlet output = \"\";\n\tlet i = 0;\n\thandleRegexMatch(\n\t\ttemplate,\n\t\tformatRegExp,\n\t\t// format \"%\"\n\t\t(match) => {\n\t\t\tif (i < count) {\n\t\t\t\toutput += format(match[0], items[i++]);\n\t\t\t} else {\n\t\t\t\toutput += match[0];\n\t\t\t}\n\t\t},\n\t\t// format \"$\"\n\t\t(nonMatch) => {\n\t\t\toutput += formatAttribute(nonMatch);\n\t\t}\n\t);\n\treturn output;\n}\n// based on https://github.com/unocss/unocss/blob/2e74b31625bbe3b9c8351570749aa2d3f799d919/packages/autocomplete/src/parse.ts#L11\nfunction handleRegexMatch(input, regex, onMatch, onNonMatch) {\n\tlet lastIndex = 0;\n\tfor (const m of input.matchAll(regex)) {\n\t\tif (lastIndex < m.index) {\n\t\t\tonNonMatch(input.slice(lastIndex, m.index));\n\t\t}\n\t\tonMatch(m);\n\t\tlastIndex = m.index + m[0].length;\n\t}\n\tif (lastIndex < input.length) {\n\t\tonNonMatch(input.slice(lastIndex));\n\t}\n}\nfunction formatTemplateString(cases, args) {\n\tconst header = cases.join(\"\").trim().replace(/ /g, \"\").split(\"\\n\").map((i) => i.split(\"|\"))[0];\n\tconst res = [];\n\tfor (let i = 0; i < Math.floor(args.length / header.length); i++) {\n\t\tconst oneCase = {};\n\t\tfor (let j = 0; j < header.length; j++) {\n\t\t\toneCase[header[j]] = args[i * header.length + j];\n\t\t}\n\t\tres.push(oneCase);\n\t}\n\treturn res;\n}\n\nconst now$2 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;\nconst collectorContext = {\n\ttasks: [],\n\tcurrentSuite: null\n};\nfunction collectTask(task) {\n\tcollectorContext.currentSuite?.tasks.push(task);\n}\nasync function runWithSuite(suite, fn) {\n\tconst prev = collectorContext.currentSuite;\n\tcollectorContext.currentSuite = suite;\n\tawait fn();\n\tcollectorContext.currentSuite = prev;\n}\nfunction withTimeout(fn, timeout, isHook = false, stackTraceError, onTimeout) {\n\tif (timeout <= 0 || timeout === Number.POSITIVE_INFINITY) {\n\t\treturn fn;\n\t}\n\tconst { setTimeout, clearTimeout } = getSafeTimers();\n\t// this function name is used to filter error in test/cli/test/fails.test.ts\n\treturn (function runWithTimeout(...args) {\n\t\tconst startTime = now$2();\n\t\tconst runner = getRunner();\n\t\trunner._currentTaskStartTime = startTime;\n\t\trunner._currentTaskTimeout = timeout;\n\t\treturn new Promise((resolve_, reject_) => {\n\t\t\tconst timer = setTimeout(() => {\n\t\t\t\tclearTimeout(timer);\n\t\t\t\trejectTimeoutError();\n\t\t\t}, timeout);\n\t\t\t// `unref` might not exist in browser\n\t\t\ttimer.unref?.();\n\t\t\tfunction rejectTimeoutError() {\n\t\t\t\tconst error = makeTimeoutError(isHook, timeout, stackTraceError);\n\t\t\t\tonTimeout?.(args, error);\n\t\t\t\treject_(error);\n\t\t\t}\n\t\t\tfunction resolve(result) {\n\t\t\t\trunner._currentTaskStartTime = undefined;\n\t\t\t\trunner._currentTaskTimeout = undefined;\n\t\t\t\tclearTimeout(timer);\n\t\t\t\t// if test/hook took too long in microtask, setTimeout won't be triggered,\n\t\t\t\t// but we still need to fail the test, see\n\t\t\t\t// https://github.com/vitest-dev/vitest/issues/2920\n\t\t\t\tif (now$2() - startTime >= timeout) {\n\t\t\t\t\trejectTimeoutError();\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tresolve_(result);\n\t\t\t}\n\t\t\tfunction reject(error) {\n\t\t\t\trunner._currentTaskStartTime = undefined;\n\t\t\t\trunner._currentTaskTimeout = undefined;\n\t\t\t\tclearTimeout(timer);\n\t\t\t\treject_(error);\n\t\t\t}\n\t\t\t// sync test/hook will be caught by try/catch\n\t\t\ttry {\n\t\t\t\tconst result = fn(...args);\n\t\t\t\t// the result is a thenable, we don't wrap this in Promise.resolve\n\t\t\t\t// to avoid creating new promises\n\t\t\t\tif (typeof result === \"object\" && result != null && typeof result.then === \"function\") {\n\t\t\t\t\tresult.then(resolve, reject);\n\t\t\t\t} else {\n\t\t\t\t\tresolve(result);\n\t\t\t\t}\n\t\t\t} \n\t\t\t// user sync test/hook throws an error\ncatch (error) {\n\t\t\t\treject(error);\n\t\t\t}\n\t\t});\n\t});\n}\nfunction withCancel(fn, signal) {\n\treturn (function runWithCancel(...args) {\n\t\treturn new Promise((resolve, reject) => {\n\t\t\tsignal.addEventListener(\"abort\", () => reject(signal.reason));\n\t\t\ttry {\n\t\t\t\tconst result = fn(...args);\n\t\t\t\tif (typeof result === \"object\" && result != null && typeof result.then === \"function\") {\n\t\t\t\t\tresult.then(resolve, reject);\n\t\t\t\t} else {\n\t\t\t\t\tresolve(result);\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\treject(error);\n\t\t\t}\n\t\t});\n\t});\n}\nconst abortControllers = new WeakMap();\nfunction abortIfTimeout([context], error) {\n\tif (context) {\n\t\tabortContextSignal(context, error);\n\t}\n}\nfunction abortContextSignal(context, error) {\n\tconst abortController = abortControllers.get(context);\n\tabortController?.abort(error);\n}\nfunction createTestContext(test, runner) {\n\tconst context = function() {\n\t\tthrow new Error(\"done() callback is deprecated, use promise instead\");\n\t};\n\tlet abortController = abortControllers.get(context);\n\tif (!abortController) {\n\t\tabortController = new AbortController();\n\t\tabortControllers.set(context, abortController);\n\t}\n\tcontext.signal = abortController.signal;\n\tcontext.task = test;\n\tcontext.skip = (condition, note) => {\n\t\tif (condition === false) {\n\t\t\t// do nothing\n\t\t\treturn undefined;\n\t\t}\n\t\ttest.result ??= { state: \"skip\" };\n\t\ttest.result.pending = true;\n\t\tthrow new PendingError(\"test is skipped; abort execution\", test, typeof condition === \"string\" ? condition : note);\n\t};\n\tcontext.annotate = ((message, type, attachment) => {\n\t\tif (test.result && test.result.state !== \"run\") {\n\t\t\tthrow new Error(`Cannot annotate tests outside of the test run. The test \"${test.name}\" finished running with the \"${test.result.state}\" state already.`);\n\t\t}\n\t\tconst annotation = {\n\t\t\tmessage,\n\t\t\ttype: typeof type === \"object\" || type === undefined ? \"notice\" : type\n\t\t};\n\t\tconst annotationAttachment = typeof type === \"object\" ? type : attachment;\n\t\tif (annotationAttachment) {\n\t\t\tannotation.attachment = annotationAttachment;\n\t\t\tmanageArtifactAttachment(annotation.attachment);\n\t\t}\n\t\treturn recordAsyncOperation(test, recordArtifact(test, {\n\t\t\ttype: \"internal:annotation\",\n\t\t\tannotation\n\t\t}).then(async ({ annotation }) => {\n\t\t\tif (!runner.onTestAnnotate) {\n\t\t\t\tthrow new Error(`Test runner doesn't support test annotations.`);\n\t\t\t}\n\t\t\tawait finishSendTasksUpdate(runner);\n\t\t\tconst resolvedAnnotation = await runner.onTestAnnotate(test, annotation);\n\t\t\ttest.annotations.push(resolvedAnnotation);\n\t\t\treturn resolvedAnnotation;\n\t\t}));\n\t});\n\tcontext.onTestFailed = (handler, timeout) => {\n\t\ttest.onFailed ||= [];\n\t\ttest.onFailed.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error(\"STACK_TRACE_ERROR\"), (_, error) => abortController.abort(error)));\n\t};\n\tcontext.onTestFinished = (handler, timeout) => {\n\t\ttest.onFinished ||= [];\n\t\ttest.onFinished.push(withTimeout(handler, timeout ?? runner.config.hookTimeout, true, new Error(\"STACK_TRACE_ERROR\"), (_, error) => abortController.abort(error)));\n\t};\n\treturn runner.extendTaskContext?.(context) || context;\n}\nfunction makeTimeoutError(isHook, timeout, stackTraceError) {\n\tconst 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\"}\".`;\n\tconst error = new Error(message);\n\tif (stackTraceError?.stack) {\n\t\terror.stack = stackTraceError.stack.replace(error.message, stackTraceError.message);\n\t}\n\treturn error;\n}\n\nasync function runSetupFiles(config, files, runner) {\n\tif (config.sequence.setupFiles === \"parallel\") {\n\t\tawait Promise.all(files.map(async (fsPath) => {\n\t\t\tawait runner.importFile(fsPath, \"setup\");\n\t\t}));\n\t} else {\n\t\tfor (const fsPath of files) {\n\t\t\tawait runner.importFile(fsPath, \"setup\");\n\t\t}\n\t}\n}\n\nconst now$1 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;\nasync function collectTests(specs, runner) {\n\tconst files = [];\n\tconst config = runner.config;\n\tconst $ = runner.trace;\n\tlet defaultTagsFilter;\n\tfor (const spec of specs) {\n\t\tconst filepath = typeof spec === \"string\" ? spec : spec.filepath;\n\t\tawait $(\"collect_spec\", { \"code.file.path\": filepath }, async () => {\n\t\t\trunner._currentSpecification = typeof spec === \"string\" ? { filepath: spec } : spec;\n\t\t\tconst testLocations = typeof spec === \"string\" ? undefined : spec.testLocations;\n\t\t\tconst testNamePattern = typeof spec === \"string\" ? undefined : spec.testNamePattern;\n\t\t\tconst testIds = typeof spec === \"string\" ? undefined : spec.testIds;\n\t\t\tconst testTagsFilter = typeof spec === \"object\" && spec.testTagsFilter ? createTagsFilter(spec.testTagsFilter, config.tags) : undefined;\n\t\t\tconst fileTags = typeof spec === \"string\" ? [] : spec.fileTags || [];\n\t\t\tconst file = createFileTask(filepath, config.root, config.name, runner.pool, runner.viteEnvironment);\n\t\t\tfile.tags = fileTags;\n\t\t\tfile.shuffle = config.sequence.shuffle;\n\t\t\ttry {\n\t\t\t\tvalidateTags(runner.config, fileTags);\n\t\t\t\trunner.onCollectStart?.(file);\n\t\t\t\tclearCollectorContext(file, runner);\n\t\t\t\tconst setupFiles = toArray(config.setupFiles);\n\t\t\t\tif (setupFiles.length) {\n\t\t\t\t\tconst setupStart = now$1();\n\t\t\t\t\tawait runSetupFiles(config, setupFiles, runner);\n\t\t\t\t\tconst setupEnd = now$1();\n\t\t\t\t\tfile.setupDuration = setupEnd - setupStart;\n\t\t\t\t} else {\n\t\t\t\t\tfile.setupDuration = 0;\n\t\t\t\t}\n\t\t\t\tconst collectStart = now$1();\n\t\t\t\tawait runner.importFile(filepath, \"collect\");\n\t\t\t\tconst durations = runner.getImportDurations?.();\n\t\t\t\tif (durations) {\n\t\t\t\t\tfile.importDurations = durations;\n\t\t\t\t}\n\t\t\t\tconst defaultTasks = await getDefaultSuite().collect(file);\n\t\t\t\tconst fileHooks = createSuiteHooks();\n\t\t\t\tmergeHooks(fileHooks, getHooks(defaultTasks));\n\t\t\t\tfor (const c of [...defaultTasks.tasks, ...collectorContext.tasks]) {\n\t\t\t\t\tif (c.type === \"test\" || c.type === \"suite\") {\n\t\t\t\t\t\tfile.tasks.push(c);\n\t\t\t\t\t} else if (c.type === \"collector\") {\n\t\t\t\t\t\tconst suite = await c.collect(file);\n\t\t\t\t\t\tif (suite.name || suite.tasks.length) {\n\t\t\t\t\t\t\tmergeHooks(fileHooks, getHooks(suite));\n\t\t\t\t\t\t\tfile.tasks.push(suite);\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// check that types are exhausted\n\t\t\t\t\t\tc;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tsetHooks(file, fileHooks);\n\t\t\t\tfile.collectDuration = now$1() - collectStart;\n\t\t\t} catch (e) {\n\t\t\t\tconst errors = e instanceof AggregateError ? e.errors.map((e) => processError(e, runner.config.diffOptions)) : [processError(e, runner.config.diffOptions)];\n\t\t\t\tfile.result = {\n\t\t\t\t\tstate: \"fail\",\n\t\t\t\t\terrors\n\t\t\t\t};\n\t\t\t\tconst durations = runner.getImportDurations?.();\n\t\t\t\tif (durations) {\n\t\t\t\t\tfile.importDurations = durations;\n\t\t\t\t}\n\t\t\t}\n\t\t\tcalculateSuiteHash(file);\n\t\t\tconst hasOnlyTasks = someTasksAreOnly(file);\n\t\t\tif (!testTagsFilter && !defaultTagsFilter && config.tagsFilter) {\n\t\t\t\tdefaultTagsFilter = createTagsFilter(config.tagsFilter, config.tags);\n\t\t\t}\n\t\t\tinterpretTaskModes(file, testNamePattern ?? config.testNamePattern, testLocations, testIds, testTagsFilter ?? defaultTagsFilter, hasOnlyTasks, false, config.allowOnly);\n\t\t\tif (file.mode === \"queued\") {\n\t\t\t\tfile.mode = \"run\";\n\t\t\t}\n\t\t\tfiles.push(file);\n\t\t});\n\t}\n\treturn files;\n}\nfunction mergeHooks(baseHooks, hooks) {\n\tfor (const _key in hooks) {\n\t\tconst key = _key;\n\t\tbaseHooks[key].push(...hooks[key]);\n\t}\n\treturn baseHooks;\n}\n\nconst now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;\nconst unixNow = Date.now;\nconst { clearTimeout, setTimeout } = getSafeTimers();\nlet limitMaxConcurrency;\n/**\n* Normalizes retry configuration to extract individual values.\n* Handles both number and object forms.\n*/\nfunction getRetryCount(retry) {\n\tif (retry === undefined) {\n\t\treturn 0;\n\t}\n\tif (typeof retry === \"number\") {\n\t\treturn retry;\n\t}\n\treturn retry.count ?? 0;\n}\nfunction getRetryDelay(retry) {\n\tif (retry === undefined) {\n\t\treturn 0;\n\t}\n\tif (typeof retry === \"number\") {\n\t\treturn 0;\n\t}\n\treturn retry.delay ?? 0;\n}\nfunction getRetryCondition(retry) {\n\tif (retry === undefined) {\n\t\treturn undefined;\n\t}\n\tif (typeof retry === \"number\") {\n\t\treturn undefined;\n\t}\n\treturn retry.condition;\n}\nfunction updateSuiteHookState(task, name, state, runner) {\n\tif (!task.result) {\n\t\ttask.result = { state: \"run\" };\n\t}\n\tif (!task.result.hooks) {\n\t\ttask.result.hooks = {};\n\t}\n\tconst suiteHooks = task.result.hooks;\n\tif (suiteHooks) {\n\t\tsuiteHooks[name] = state;\n\t\tlet event = state === \"run\" ? \"before-hook-start\" : \"before-hook-end\";\n\t\tif (name === \"afterAll\" || name === \"afterEach\") {\n\t\t\tevent = state === \"run\" ? \"after-hook-start\" : \"after-hook-end\";\n\t\t}\n\t\tupdateTask(event, task, runner);\n\t}\n}\nfunction getSuiteHooks(suite, name, sequence) {\n\tconst hooks = getHooks(suite)[name];\n\tif (sequence === \"stack\" && (name === \"afterAll\" || name === \"afterEach\")) {\n\t\treturn hooks.slice().reverse();\n\t}\n\treturn hooks;\n}\nasync function callTestHooks(runner, test, hooks, sequence) {\n\tif (sequence === \"stack\") {\n\t\thooks = hooks.slice().reverse();\n\t}\n\tif (!hooks.length) {\n\t\treturn;\n\t}\n\tconst context = test.context;\n\tconst onTestFailed = test.context.onTestFailed;\n\tconst onTestFinished = test.context.onTestFinished;\n\tcontext.onTestFailed = () => {\n\t\tthrow new Error(`Cannot call \"onTestFailed\" inside a test hook.`);\n\t};\n\tcontext.onTestFinished = () => {\n\t\tthrow new Error(`Cannot call \"onTestFinished\" inside a test hook.`);\n\t};\n\tif (sequence === \"parallel\") {\n\t\ttry {\n\t\t\tawait Promise.all(hooks.map((fn) => limitMaxConcurrency(() => fn(test.context))));\n\t\t} catch (e) {\n\t\t\tfailTask(test.result, e, runner.config.diffOptions);\n\t\t}\n\t} else {\n\t\tfor (const fn of hooks) {\n\t\t\ttry {\n\t\t\t\tawait limitMaxConcurrency(() => fn(test.context));\n\t\t\t} catch (e) {\n\t\t\t\tfailTask(test.result, e, runner.config.diffOptions);\n\t\t\t}\n\t\t}\n\t}\n\tcontext.onTestFailed = onTestFailed;\n\tcontext.onTestFinished = onTestFinished;\n}\nasync function callSuiteHook(suite, currentTask, name, runner, args) {\n\tconst sequence = runner.config.sequence.hooks;\n\tconst callbacks = [];\n\t// stop at file level\n\tconst parentSuite = \"filepath\" in suite ? null : suite.suite || suite.file;\n\tif (name === \"beforeEach\" && parentSuite) {\n\t\tcallbacks.push(...await callSuiteHook(parentSuite, currentTask, name, runner, args));\n\t}\n\tconst hooks = getSuiteHooks(suite, name, sequence);\n\tif (hooks.length > 0) {\n\t\tupdateSuiteHookState(currentTask, name, \"run\", runner);\n\t}\n\tasync function runHook(hook) {\n\t\treturn limitMaxConcurrency(async () => {\n\t\t\treturn getBeforeHookCleanupCallback(hook, await hook(...args), name === \"beforeEach\" ? args[0] : undefined);\n\t\t});\n\t}\n\tif (sequence === \"parallel\") {\n\t\tcallbacks.push(...await Promise.all(hooks.map((hook) => runHook(hook))));\n\t} else {\n\t\tfor (const hook of hooks) {\n\t\t\tcallbacks.push(await runHook(hook));\n\t\t}\n\t}\n\tif (hooks.length > 0) {\n\t\tupdateSuiteHookState(currentTask, name, \"pass\", runner);\n\t}\n\tif (name === \"afterEach\" && parentSuite) {\n\t\tcallbacks.push(...await callSuiteHook(parentSuite, currentTask, name, runner, args));\n\t}\n\treturn callbacks;\n}\nfunction getAroundEachHooks(suite) {\n\tconst hooks = [];\n\tconst parentSuite = \"filepath\" in suite ? null : suite.suite || suite.file;\n\tif (parentSuite) {\n\t\thooks.push(...getAroundEachHooks(parentSuite));\n\t}\n\thooks.push(...getHooks(suite).aroundEach);\n\treturn hooks;\n}\nfunction getAroundAllHooks(suite) {\n\treturn getHooks(suite).aroundAll;\n}\nfunction makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError) {\n\tconst message = `The ${phase} phase of \"${hookName}\" hook timed out after ${timeout}ms.`;\n\tconst ErrorClass = phase === \"setup\" ? AroundHookSetupError : AroundHookTeardownError;\n\tconst error = new ErrorClass(message);\n\tif (stackTraceError?.stack) {\n\t\terror.stack = stackTraceError.stack.replace(stackTraceError.message, error.message);\n\t}\n\treturn error;\n}\nasync function callAroundHooks(runInner, options) {\n\tconst { hooks, hookName, callbackName, onTimeout, invokeHook } = options;\n\tif (!hooks.length) {\n\t\tawait runInner();\n\t\treturn;\n\t}\n\tconst hookErrors = [];\n\tconst createTimeoutPromise = (timeout, phase, stackTraceError) => {\n\t\tlet timer;\n\t\tlet timedout = false;\n\t\tconst promise = new Promise((_, reject) => {\n\t\t\tif (timeout > 0 && timeout !== Number.POSITIVE_INFINITY) {\n\t\t\t\ttimer = setTimeout(() => {\n\t\t\t\t\ttimedout = true;\n\t\t\t\t\tconst error = makeAroundHookTimeoutError(hookName, phase, timeout, stackTraceError);\n\t\t\t\t\tonTimeout?.(error);\n\t\t\t\t\treject(error);\n\t\t\t\t}, timeout);\n\t\t\t\ttimer.unref?.();\n\t\t\t}\n\t\t});\n\t\tconst clear = () => {\n\t\t\tif (timer) {\n\t\t\t\tclearTimeout(timer);\n\t\t\t\ttimer = undefined;\n\t\t\t}\n\t\t};\n\t\treturn {\n\t\t\tpromise,\n\t\t\tclear,\n\t\t\tisTimedOut: () => timedout\n\t\t};\n\t};\n\tconst runNextHook = async (index) => {\n\t\tif (index >= hooks.length) {\n\t\t\treturn runInner();\n\t\t}\n\t\tconst hook = hooks[index];\n\t\tconst timeout = getAroundHookTimeout(hook);\n\t\tconst stackTraceError = getAroundHookStackTrace(hook);\n\t\tlet useCalled = false;\n\t\tlet setupTimeout;\n\t\tlet teardownTimeout;\n\t\tlet setupLimitConcurrencyRelease;\n\t\tlet teardownLimitConcurrencyRelease;\n\t\t// Promise that resolves when use() is called (setup phase complete)\n\t\tlet resolveUseCalled;\n\t\tconst useCalledPromise = new Promise((resolve) => {\n\t\t\tresolveUseCalled = resolve;\n\t\t});\n\t\t// Promise that resolves when use() returns (inner hooks complete, teardown phase starts)\n\t\tlet resolveUseReturned;\n\t\tconst useReturnedPromise = new Promise((resolve) => {\n\t\t\tresolveUseReturned = resolve;\n\t\t});\n\t\t// Promise that resolves when hook completes\n\t\tlet resolveHookComplete;\n\t\tlet rejectHookComplete;\n\t\tconst hookCompletePromise = new Promise((resolve, reject) => {\n\t\t\tresolveHookComplete = resolve;\n\t\t\trejectHookComplete = reject;\n\t\t});\n\t\tconst use = async () => {\n\t\t\t// shouldn't continue to next (runTest/Suite or inner aroundEach/All) when aroundEach/All setup timed out.\n\t\t\tif (setupTimeout.isTimedOut()) {\n\t\t\t\t// we can throw any error to bail out.\n\t\t\t\t// this error is not seen by end users since `runNextHook` already rejected with timeout error\n\t\t\t\t// and this error is caught by `rejectHookComplete`.\n\t\t\t\tthrow new Error(\"__VITEST_INTERNAL_AROUND_HOOK_ABORT__\");\n\t\t\t}\n\t\t\tif (useCalled) {\n\t\t\t\tthrow new AroundHookMultipleCallsError(`The \\`${callbackName}\\` callback was called multiple times in the \\`${hookName}\\` hook. ` + `The callback can only be called once per hook.`);\n\t\t\t}\n\t\t\tuseCalled = true;\n\t\t\tresolveUseCalled();\n\t\t\t// Setup phase completed - clear setup timer\n\t\t\tsetupTimeout.clear();\n\t\t\tsetupLimitConcurrencyRelease?.();\n\t\t\t// Run inner hooks - don't time this against our teardown timeout\n\t\t\tawait runNextHook(index + 1).catch((e) => hookErrors.push(e));\n\t\t\tteardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire();\n\t\t\t// Start teardown timer after inner hooks complete - only times this hook's teardown code\n\t\t\tteardownTimeout = createTimeoutPromise(timeout, \"teardown\", stackTraceError);\n\t\t\t// Signal that use() is returning (teardown phase starting)\n\t\t\tresolveUseReturned();\n\t\t};\n\t\tsetupLimitConcurrencyRelease = await limitMaxConcurrency.acquire();\n\t\t// Start setup timeout\n\t\tsetupTimeout = createTimeoutPromise(timeout, \"setup\", stackTraceError);\n\t\t(async () => {\n\t\t\ttry {\n\t\t\t\tawait invokeHook(hook, use);\n\t\t\t\tif (!useCalled) {\n\t\t\t\t\tthrow new AroundHookSetupError(`The \\`${callbackName}\\` callback was not called in the \\`${hookName}\\` hook. ` + `Make sure to call \\`${callbackName}\\` to run the ${hookName === \"aroundEach\" ? \"test\" : \"suite\"}.`);\n\t\t\t\t}\n\t\t\t\tresolveHookComplete();\n\t\t\t} catch (error) {\n\t\t\t\trejectHookComplete(error);\n\t\t\t} finally {\n\t\t\t\tsetupLimitConcurrencyRelease?.();\n\t\t\t\tteardownLimitConcurrencyRelease?.();\n\t\t\t}\n\t\t})();\n\t\t// Wait for either: use() to be called OR hook to complete (error) OR setup timeout\n\t\ttry {\n\t\t\tawait Promise.race([\n\t\t\t\tuseCalledPromise,\n\t\t\t\thookCompletePromise,\n\t\t\t\tsetupTimeout.promise\n\t\t\t]);\n\t\t} finally {\n\t\t\tsetupLimitConcurrencyRelease?.();\n\t\t\tsetupTimeout.clear();\n\t\t}\n\t\t// Wait for use() to return (inner hooks complete) OR hook to complete (error during inner hooks)\n\t\tawait Promise.race([useReturnedPromise, hookCompletePromise]);\n\t\t// Now teardownTimeout is guaranteed to be set\n\t\t// Wait for hook to complete (teardown) OR teardown timeout\n\t\ttry {\n\t\t\tawait Promise.race([hookCompletePromise, teardownTimeout?.promise]);\n\t\t} finally {\n\t\t\tteardownLimitConcurrencyRelease?.();\n\t\t\tteardownTimeout?.clear();\n\t\t}\n\t};\n\tawait runNextHook(0).catch((e) => hookErrors.push(e));\n\tif (hookErrors.length > 0) {\n\t\tthrow hookErrors;\n\t}\n}\nasync function callAroundAllHooks(suite, runSuiteInner) {\n\tawait callAroundHooks(runSuiteInner, {\n\t\thooks: getAroundAllHooks(suite),\n\t\thookName: \"aroundAll\",\n\t\tcallbackName: \"runSuite()\",\n\t\tinvokeHook: (hook, use) => hook(use, suite)\n\t});\n}\nasync function callAroundEachHooks(suite, test, runTest) {\n\tawait callAroundHooks(\n\t\t// Take checkpoint right before runTest - at this point all aroundEach fixtures\n\t\t// have been resolved, so we can correctly identify which fixtures belong to\n\t\t// aroundEach (before checkpoint) vs inside runTest (after checkpoint)\n\t\t() => runTest(getFixtureCleanupCount(test.context)),\n\t\t{\n\t\t\thooks: getAroundEachHooks(suite),\n\t\t\thookName: \"aroundEach\",\n\t\t\tcallbackName: \"runTest()\",\n\t\t\tonTimeout: (error) => abortContextSignal(test.context, error),\n\t\t\tinvokeHook: (hook, use) => hook(use, test.context, suite)\n\t\t}\n\t);\n}\nconst packs = new Map();\nconst eventsPacks = [];\nconst pendingTasksUpdates = [];\nfunction sendTasksUpdate(runner) {\n\tif (packs.size) {\n\t\tconst taskPacks = Array.from(packs).map(([id, task]) => {\n\t\t\treturn [\n\t\t\t\tid,\n\t\t\t\ttask[0],\n\t\t\t\ttask[1]\n\t\t\t];\n\t\t});\n\t\tconst p = runner.onTaskUpdate?.(taskPacks, eventsPacks);\n\t\tif (p) {\n\t\t\tpendingTasksUpdates.push(p);\n\t\t\t// remove successful promise to not grow array indefinitely,\n\t\t\t// but keep rejections so finishSendTasksUpdate can handle them\n\t\t\tp.then(() => pendingTasksUpdates.splice(pendingTasksUpdates.indexOf(p), 1), () => {});\n\t\t}\n\t\teventsPacks.length = 0;\n\t\tpacks.clear();\n\t}\n}\nasync function finishSendTasksUpdate(runner) {\n\tsendTasksUpdate(runner);\n\tawait Promise.all(pendingTasksUpdates);\n}\nfunction throttle(fn, ms) {\n\tlet last = 0;\n\tlet pendingCall;\n\treturn function call(...args) {\n\t\tconst now = unixNow();\n\t\tif (now - last > ms) {\n\t\t\tlast = now;\n\t\t\tclearTimeout(pendingCall);\n\t\t\tpendingCall = undefined;\n\t\t\treturn fn.apply(this, args);\n\t\t}\n\t\t// Make sure fn is still called even if there are no further calls\n\t\tpendingCall ??= setTimeout(() => call.bind(this)(...args), ms);\n\t};\n}\n// throttle based on summary reporter's DURATION_UPDATE_INTERVAL_MS\nconst sendTasksUpdateThrottled = throttle(sendTasksUpdate, 100);\nfunction updateTask(event, task, runner) {\n\teventsPacks.push([\n\t\ttask.id,\n\t\tevent,\n\t\tundefined\n\t]);\n\tpacks.set(task.id, [task.result, task.meta]);\n\tsendTasksUpdateThrottled(runner);\n}\nasync function callCleanupHooks(runner, cleanups) {\n\tconst sequence = runner.config.sequence.hooks;\n\tif (sequence === \"stack\") {\n\t\tcleanups = cleanups.slice().reverse();\n\t}\n\tif (sequence === \"parallel\") {\n\t\tawait Promise.all(cleanups.map(async (fn) => {\n\t\t\tif (typeof fn !== \"function\") {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tawait limitMaxConcurrency(() => fn());\n\t\t}));\n\t} else {\n\t\tfor (const fn of cleanups) {\n\t\t\tif (typeof fn !== \"function\") {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tawait limitMaxConcurrency(() => fn());\n\t\t}\n\t}\n}\n/**\n* Determines if a test should be retried based on its retryCondition configuration\n*/\nfunction passesRetryCondition(test, errors) {\n\tconst condition = getRetryCondition(test.retry);\n\tif (!errors || errors.length === 0) {\n\t\treturn false;\n\t}\n\tif (!condition) {\n\t\treturn true;\n\t}\n\tconst error = errors[errors.length - 1];\n\tif (condition instanceof RegExp) {\n\t\treturn condition.test(error.message || \"\");\n\t} else if (typeof condition === \"function\") {\n\t\treturn condition(error);\n\t}\n\treturn false;\n}\nasync function runTest(test, runner) {\n\tawait runner.onBeforeRunTask?.(test);\n\tif (test.mode !== \"run\" && test.mode !== \"queued\") {\n\t\tupdateTask(\"test-prepare\", test, runner);\n\t\tupdateTask(\"test-finished\", test, runner);\n\t\treturn;\n\t}\n\tif (test.result?.state === \"fail\") {\n\t\t// should not be possible to get here, I think this is just copy pasted from suite\n\t\t// TODO: maybe someone fails tests in `beforeAll` hooks?\n\t\t// https://github.com/vitest-dev/vitest/pull/7069\n\t\tupdateTask(\"test-failed-early\", test, runner);\n\t\treturn;\n\t}\n\tconst start = now();\n\ttest.result = {\n\t\tstate: \"run\",\n\t\tstartTime: unixNow(),\n\t\tretryCount: 0\n\t};\n\tupdateTask(\"test-prepare\", test, runner);\n\tconst cleanupRunningTest = addRunningTest(test);\n\tsetCurrentTest(test);\n\tconst suite = test.suite || test.file;\n\tconst $ = runner.trace;\n\tconst repeats = test.repeats ?? 0;\n\tfor (let repeatCount = 0; repeatCount <= repeats; repeatCount++) {\n\t\tconst retry = getRetryCount(test.retry);\n\t\tfor (let retryCount = 0; retryCount <= retry; retryCount++) {\n\t\t\tlet beforeEachCleanups = [];\n\t\t\t// fixtureCheckpoint is passed by callAroundEachHooks - it represents the count\n\t\t\t// of fixture cleanup functions AFTER all aroundEach fixtures have been resolved\n\t\t\t// but BEFORE the test runs. This allows us to clean up only fixtures created\n\t\t\t// inside runTest while preserving aroundEach fixtures for teardown.\n\t\t\tawait callAroundEachHooks(suite, test, async (fixtureCheckpoint) => {\n\t\t\t\ttry {\n\t\t\t\t\tawait runner.onBeforeTryTask?.(test, {\n\t\t\t\t\t\tretry: retryCount,\n\t\t\t\t\t\trepeats: repeatCount\n\t\t\t\t\t});\n\t\t\t\t\ttest.result.repeatCount = repeatCount;\n\t\t\t\t\tbeforeEachCleanups = await $(\"test.beforeEach\", () => callSuiteHook(suite, test, \"beforeEach\", runner, [test.context, suite]));\n\t\t\t\t\tif (runner.runTask) {\n\t\t\t\t\t\tawait $(\"test.callback\", () => limitMaxConcurrency(() => runner.runTask(test)));\n\t\t\t\t\t} else {\n\t\t\t\t\t\tconst fn = getFn(test);\n\t\t\t\t\t\tif (!fn) {\n\t\t\t\t\t\t\tthrow new Error(\"Test function is not found. Did you add it using `setFn`?\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\tawait $(\"test.callback\", () => limitMaxConcurrency(() => fn()));\n\t\t\t\t\t}\n\t\t\t\t\tawait runner.onAfterTryTask?.(test, {\n\t\t\t\t\t\tretry: retryCount,\n\t\t\t\t\t\trepeats: repeatCount\n\t\t\t\t\t});\n\t\t\t\t\tif (test.result.state !== \"fail\") {\n\t\t\t\t\t\ttest.result.state = \"pass\";\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {\n\t\t\t\t\tfailTask(test.result, e, runner.config.diffOptions);\n\t\t\t\t}\n\t\t\t\ttry {\n\t\t\t\t\tawait runner.onTaskFinished?.(test);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tfailTask(test.result, e, runner.config.diffOptions);\n\t\t\t\t}\n\t\t\t\ttry {\n\t\t\t\t\tawait $(\"test.afterEach\", () => callSuiteHook(suite, test, \"afterEach\", runner, [test.context, suite]));\n\t\t\t\t\tif (beforeEachCleanups.length) {\n\t\t\t\t\t\tawait $(\"test.cleanup\", () => callCleanupHooks(runner, beforeEachCleanups));\n\t\t\t\t\t}\n\t\t\t\t\t// Only clean up fixtures created inside runTest (after the checkpoint)\n\t\t\t\t\t// Fixtures created for aroundEach will be cleaned up after aroundEach teardown\n\t\t\t\t\tawait callFixtureCleanupFrom(test.context, fixtureCheckpoint);\n\t\t\t\t} catch (e) {\n\t\t\t\t\tfailTask(test.result, e, runner.config.diffOptions);\n\t\t\t\t}\n\t\t\t\tif (test.onFinished?.length) {\n\t\t\t\t\tawait $(\"test.onFinished\", () => callTestHooks(runner, test, test.onFinished, \"stack\"));\n\t\t\t\t}\n\t\t\t\tif (test.result.state === \"fail\" && test.onFailed?.length) {\n\t\t\t\t\tawait $(\"test.onFailed\", () => callTestHooks(runner, test, test.onFailed, runner.config.sequence.hooks));\n\t\t\t\t}\n\t\t\t\ttest.onFailed = undefined;\n\t\t\t\ttest.onFinished = undefined;\n\t\t\t\tawait runner.onAfterRetryTask?.(test, {\n\t\t\t\t\tretry: retryCount,\n\t\t\t\t\trepeats: repeatCount\n\t\t\t\t});\n\t\t\t}).catch((error) => {\n\t\t\t\tfailTask(test.result, error, runner.config.diffOptions);\n\t\t\t});\n\t\t\t// Clean up fixtures that were created for aroundEach (before the checkpoint)\n\t\t\t// This runs after aroundEach teardown has completed\n\t\t\ttry {\n\t\t\t\tawait callFixtureCleanup(test.context);\n\t\t\t} catch (e) {\n\t\t\t\tfailTask(test.result, e, runner.config.diffOptions);\n\t\t\t}\n\t\t\t// skipped with new PendingError\n\t\t\tif (test.result?.pending || test.result?.state === \"skip\") {\n\t\t\t\ttest.mode = \"skip\";\n\t\t\t\ttest.result = {\n\t\t\t\t\tstate: \"skip\",\n\t\t\t\t\tnote: test.result?.note,\n\t\t\t\t\tpending: true,\n\t\t\t\t\tduration: now() - start\n\t\t\t\t};\n\t\t\t\tupdateTask(\"test-finished\", test, runner);\n\t\t\t\tsetCurrentTest(undefined);\n\t\t\t\tcleanupRunningTest();\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (test.result.state === \"pass\") {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (retryCount < retry) {\n\t\t\t\tconst shouldRetry = passesRetryCondition(test, test.result.errors);\n\t\t\t\tif (!shouldRetry) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\ttest.result.state = \"run\";\n\t\t\t\ttest.result.retryCount = (test.result.retryCount ?? 0) + 1;\n\t\t\t\tconst delay = getRetryDelay(test.retry);\n\t\t\t\tif (delay > 0) {\n\t\t\t\t\tawait new Promise((resolve) => setTimeout(resolve, delay));\n\t\t\t\t}\n\t\t\t}\n\t\t\t// update retry info\n\t\t\tupdateTask(\"test-retried\", test, runner);\n\t\t}\n\t}\n\t// if test is marked to be failed, flip the result\n\tif (test.fails) {\n\t\tif (test.result.state === \"pass\") {\n\t\t\tconst error = processError(new Error(\"Expect test to fail\"));\n\t\t\ttest.result.state = \"fail\";\n\t\t\ttest.result.errors = [error];\n\t\t} else {\n\t\t\ttest.result.state = \"pass\";\n\t\t\ttest.result.errors = undefined;\n\t\t}\n\t}\n\tcleanupRunningTest();\n\tsetCurrentTest(undefined);\n\ttest.result.duration = now() - start;\n\tawait runner.onAfterRunTask?.(test);\n\tupdateTask(\"test-finished\", test, runner);\n}\nfunction failTask(result, err, diffOptions) {\n\tif (err instanceof PendingError) {\n\t\tresult.state = \"skip\";\n\t\tresult.note = err.note;\n\t\tresult.pending = true;\n\t\treturn;\n\t}\n\tif (err instanceof TestRunAbortError) {\n\t\tresult.state = \"skip\";\n\t\tresult.note = err.message;\n\t\treturn;\n\t}\n\tresult.state = \"fail\";\n\tconst errors = Array.isArray(err) ? err : [err];\n\tfor (const e of errors) {\n\t\tconst errors = e instanceof AggregateError ? e.errors.map((e) => processError(e, diffOptions)) : [processError(e, diffOptions)];\n\t\tresult.errors ??= [];\n\t\tresult.errors.push(...errors);\n\t}\n}\nfunction markTasksAsSkipped(suite, runner) {\n\tsuite.tasks.forEach((t) => {\n\t\tt.mode = \"skip\";\n\t\tt.result = {\n\t\t\t...t.result,\n\t\t\tstate: \"skip\"\n\t\t};\n\t\tupdateTask(\"test-finished\", t, runner);\n\t\tif (t.type === \"suite\") {\n\t\t\tmarkTasksAsSkipped(t, runner);\n\t\t}\n\t});\n}\nfunction markPendingTasksAsSkipped(suite, runner, note) {\n\tsuite.tasks.forEach((t) => {\n\t\tif (!t.result || t.result.state === \"run\") {\n\t\t\tt.mode = \"skip\";\n\t\t\tt.result = {\n\t\t\t\t...t.result,\n\t\t\t\tstate: \"skip\",\n\t\t\t\tnote\n\t\t\t};\n\t\t\tupdateTask(\"test-cancel\", t, runner);\n\t\t}\n\t\tif (t.type === \"suite\") {\n\t\t\tmarkPendingTasksAsSkipped(t, runner, note);\n\t\t}\n\t});\n}\nasync function runSuite(suite, runner) {\n\tawait runner.onBeforeRunSuite?.(suite);\n\tif (suite.result?.state === \"fail\") {\n\t\tmarkTasksAsSkipped(suite, runner);\n\t\t// failed during collection\n\t\tupdateTask(\"suite-failed-early\", suite, runner);\n\t\treturn;\n\t}\n\tconst start = now();\n\tconst mode = suite.mode;\n\tsuite.result = {\n\t\tstate: mode === \"skip\" || mode === \"todo\" ? mode : \"run\",\n\t\tstartTime: unixNow()\n\t};\n\tconst $ = runner.trace;\n\tupdateTask(\"suite-prepare\", suite, runner);\n\tlet beforeAllCleanups = [];\n\tif (suite.mode === \"skip\") {\n\t\tsuite.result.state = \"skip\";\n\t\tupdateTask(\"suite-finished\", suite, runner);\n\t} else if (suite.mode === \"todo\") {\n\t\tsuite.result.state = \"todo\";\n\t\tupdateTask(\"suite-finished\", suite, runner);\n\t} else {\n\t\tlet suiteRan = false;\n\t\ttry {\n\t\t\tawait callAroundAllHooks(suite, async () => {\n\t\t\t\tsuiteRan = true;\n\t\t\t\ttry {\n\t\t\t\t\t// beforeAll\n\t\t\t\t\ttry {\n\t\t\t\t\t\tbeforeAllCleanups = await $(\"suite.beforeAll\", () => callSuiteHook(suite, suite, \"beforeAll\", runner, [suite]));\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\tfailTask(suite.result, e, runner.config.diffOptions);\n\t\t\t\t\t\tmarkTasksAsSkipped(suite, runner);\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\t// run suite children\n\t\t\t\t\tif (runner.runSuite) {\n\t\t\t\t\t\tawait runner.runSuite(suite);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tfor (let tasksGroup of partitionSuiteChildren(suite)) {\n\t\t\t\t\t\t\tif (tasksGroup[0].concurrent === true) {\n\t\t\t\t\t\t\t\tconst groupLimiter = limitConcurrency(runner.config.maxConcurrency);\n\t\t\t\t\t\t\t\tawait Promise.all(tasksGroup.map((c) => groupLimiter(() => runSuiteChild(c, runner))));\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tconst { sequence } = runner.config;\n\t\t\t\t\t\t\t\tif (suite.shuffle) {\n\t\t\t\t\t\t\t\t\t// run describe block independently from tests\n\t\t\t\t\t\t\t\t\tconst suites = tasksGroup.filter((group) => group.type === \"suite\");\n\t\t\t\t\t\t\t\t\tconst tests = tasksGroup.filter((group) => group.type === \"test\");\n\t\t\t\t\t\t\t\t\tconst groups = shuffle([suites, tests], sequence.seed);\n\t\t\t\t\t\t\t\t\ttasksGroup = groups.flatMap((group) => shuffle(group, sequence.seed));\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tfor (const c of tasksGroup) {\n\t\t\t\t\t\t\t\t\tawait runSuiteChild(c, runner);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} finally {\n\t\t\t\t\t// afterAll runs even if beforeAll or suite children fail\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait $(\"suite.afterAll\", () => callSuiteHook(suite, suite, \"afterAll\", runner, [suite]));\n\t\t\t\t\t\tif (beforeAllCleanups.length) {\n\t\t\t\t\t\t\tawait $(\"suite.cleanup\", () => callCleanupHooks(runner, beforeAllCleanups));\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (suite.file === suite) {\n\t\t\t\t\t\t\tconst contexts = TestFixtures.getFileContexts(suite.file);\n\t\t\t\t\t\t\tawait Promise.all(contexts.map((context) => callFixtureCleanup(context)));\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\tfailTask(suite.result, e, runner.config.diffOptions);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\t\t} catch (e) {\n\t\t\t// mark tasks as skipped if aroundAll failed before the suite callback was executed\n\t\t\tif (!suiteRan) {\n\t\t\t\tmarkTasksAsSkipped(suite, runner);\n\t\t\t}\n\t\t\tfailTask(suite.result, e, runner.config.diffOptions);\n\t\t}\n\t\tif (suite.mode === \"run\" || suite.mode === \"queued\") {\n\t\t\tif (!runner.config.passWithNoTests && !hasTests(suite)) {\n\t\t\t\tsuite.result.state = \"fail\";\n\t\t\t\tif (!suite.result.errors?.length) {\n\t\t\t\t\tconst error = processError(new Error(`No test found in suite ${suite.name}`));\n\t\t\t\t\tsuite.result.errors = [error];\n\t\t\t\t}\n\t\t\t} else if (hasFailed(suite)) {\n\t\t\t\tsuite.result.state = \"fail\";\n\t\t\t} else {\n\t\t\t\tsuite.result.state = \"pass\";\n\t\t\t}\n\t\t}\n\t\tsuite.result.duration = now() - start;\n\t\tawait runner.onAfterRunSuite?.(suite);\n\t\tupdateTask(\"suite-finished\", suite, runner);\n\t}\n}\nasync function runSuiteChild(c, runner) {\n\tconst $ = runner.trace;\n\tif (c.type === \"test\") {\n\t\treturn $(\"run.test\", {\n\t\t\t\"vitest.test.id\": c.id,\n\t\t\t\"vitest.test.name\": c.name,\n\t\t\t\"vitest.test.mode\": c.mode,\n\t\t\t\"vitest.test.timeout\": c.timeout,\n\t\t\t\"code.file.path\": c.file.filepath,\n\t\t\t\"code.line.number\": c.location?.line,\n\t\t\t\"code.column.number\": c.location?.column\n\t\t}, () => runTest(c, runner));\n\t} else if (c.type === \"suite\") {\n\t\treturn $(\"run.suite\", {\n\t\t\t\"vitest.suite.id\": c.id,\n\t\t\t\"vitest.suite.name\": c.name,\n\t\t\t\"vitest.suite.mode\": c.mode,\n\t\t\t\"code.file.path\": c.file.filepath,\n\t\t\t\"code.line.number\": c.location?.line,\n\t\t\t\"code.column.number\": c.location?.column\n\t\t}, () => runSuite(c, runner));\n\t}\n}\nasync function runFiles(files, runner) {\n\tlimitMaxConcurrency ??= limitConcurrency(runner.config.maxConcurrency);\n\tfor (const file of files) {\n\t\tif (!file.tasks.length && !runner.config.passWithNoTests) {\n\t\t\tif (!file.result?.errors?.length) {\n\t\t\t\tconst error = processError(new Error(`No test suite found in file ${file.filepath}`));\n\t\t\t\tfile.result = {\n\t\t\t\t\tstate: \"fail\",\n\t\t\t\t\terrors: [error]\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t\tawait runner.trace(\"run.spec\", {\n\t\t\t\"code.file.path\": file.filepath,\n\t\t\t\"vitest.suite.tasks.length\": file.tasks.length\n\t\t}, () => runSuite(file, runner));\n\t}\n}\nconst workerRunners = new WeakSet();\nfunction defaultTrace(_, attributes, cb) {\n\tif (typeof attributes === \"function\") {\n\t\treturn attributes();\n\t}\n\treturn cb();\n}\nasync function startTests(specs, runner) {\n\trunner.trace ??= defaultTrace;\n\tconst cancel = runner.cancel?.bind(runner);\n\t// Ideally, we need to have an event listener for this, but only have a runner here.\n\t// Adding another onCancel felt wrong (maybe it needs to be refactored)\n\trunner.cancel = (reason) => {\n\t\t// We intentionally create only one error since there is only one test run that can be cancelled\n\t\tconst error = new TestRunAbortError(\"The test run was aborted by the user.\", reason);\n\t\tgetRunningTests().forEach((test) => {\n\t\t\tabortContextSignal(test.context, error);\n\t\t\tmarkPendingTasksAsSkipped(test.file, runner, error.message);\n\t\t});\n\t\treturn cancel?.(reason);\n\t};\n\tif (!workerRunners.has(runner)) {\n\t\trunner.onCleanupWorkerContext?.(async () => {\n\t\t\tawait Promise.all([...TestFixtures.getWorkerContexts()].map((context) => callFixtureCleanup(context))).finally(() => {\n\t\t\t\tTestFixtures.clearDefinitions();\n\t\t\t});\n\t\t});\n\t\tworkerRunners.add(runner);\n\t}\n\ttry {\n\t\tconst paths = specs.map((f) => typeof f === \"string\" ? f : f.filepath);\n\t\tawait runner.onBeforeCollect?.(paths);\n\t\tconst files = await collectTests(specs, runner);\n\t\tawait runner.onCollected?.(files);\n\t\tawait runner.onBeforeRunFiles?.(files);\n\t\tawait runFiles(files, runner);\n\t\tawait runner.onAfterRunFiles?.(files);\n\t\tawait finishSendTasksUpdate(runner);\n\t\treturn files;\n\t} finally {\n\t\trunner.cancel = cancel;\n\t}\n}\nasync function publicCollect(specs, runner) {\n\trunner.trace ??= defaultTrace;\n\tconst paths = specs.map((f) => typeof f === \"string\" ? f : f.filepath);\n\tawait runner.onBeforeCollect?.(paths);\n\tconst files = await collectTests(specs, runner);\n\tawait runner.onCollected?.(files);\n\treturn files;\n}\n\n/**\n* @experimental\n* @advanced\n*\n* Records a custom test artifact during test execution.\n*\n* This function allows you to attach structured data, files, or metadata to a test.\n*\n* Vitest automatically injects the source location where the artifact was created and manages any attachments you include.\n*\n* **Note:** artifacts must be recorded before the task is reported. Any artifacts recorded after that will not be included in the task.\n*\n* @param task - The test task context, typically accessed via `this.task` in custom matchers or `context.task` in tests\n* @param artifact - The artifact to record. Must extend {@linkcode TestArtifactBase}\n*\n* @returns A promise that resolves to the recorded artifact with location injected\n*\n* @throws {Error} If the test runner doesn't support artifacts\n*\n* @example\n* ```ts\n* // In a custom assertion\n* async function toHaveValidSchema(this: MatcherState, actual: unknown) {\n*   const validation = validateSchema(actual)\n*\n*   await recordArtifact(this.task, {\n*     type: 'my-plugin:schema-validation',\n*     passed: validation.valid,\n*     errors: validation.errors,\n*   })\n*\n*   return { pass: validation.valid, message: () => '...' }\n* }\n* ```\n*/\nasync function recordArtifact(task, artifact) {\n\tconst runner = getRunner();\n\tconst stack = findTestFileStackTrace(task.file.filepath, new Error(\"STACK_TRACE\").stack);\n\tif (stack) {\n\t\tartifact.location = {\n\t\t\tfile: stack.file,\n\t\t\tline: stack.line,\n\t\t\tcolumn: stack.column\n\t\t};\n\t\tif (artifact.type === \"internal:annotation\") {\n\t\t\tartifact.annotation.location = artifact.location;\n\t\t}\n\t}\n\tif (Array.isArray(artifact.attachments)) {\n\t\tfor (const attachment of artifact.attachments) {\n\t\t\tmanageArtifactAttachment(attachment);\n\t\t}\n\t}\n\t// annotations won't resolve as artifacts for backwards compatibility until next major\n\tif (artifact.type === \"internal:annotation\") {\n\t\treturn artifact;\n\t}\n\tif (!runner.onTestArtifactRecord) {\n\t\tthrow new Error(`Test runner doesn't support test artifacts.`);\n\t}\n\tawait finishSendTasksUpdate(runner);\n\tconst resolvedArtifact = await runner.onTestArtifactRecord(task, artifact);\n\ttask.artifacts.push(resolvedArtifact);\n\treturn resolvedArtifact;\n}\nconst table = [];\nfor (let i = 65; i < 91; i++) {\n\ttable.push(String.fromCharCode(i));\n}\nfor (let i = 97; i < 123; i++) {\n\ttable.push(String.fromCharCode(i));\n}\nfor (let i = 0; i < 10; i++) {\n\ttable.push(i.toString(10));\n}\ntable.push(\"+\", \"/\");\nfunction encodeUint8Array(bytes) {\n\tlet base64 = \"\";\n\tconst len = bytes.byteLength;\n\tfor (let i = 0; i < len; i += 3) {\n\t\tif (len === i + 1) {\n\t\t\tconst a = (bytes[i] & 252) >> 2;\n\t\t\tconst b = (bytes[i] & 3) << 4;\n\t\t\tbase64 += table[a];\n\t\t\tbase64 += table[b];\n\t\t\tbase64 += \"==\";\n\t\t} else if (len === i + 2) {\n\t\t\tconst a = (bytes[i] & 252) >> 2;\n\t\t\tconst b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;\n\t\t\tconst c = (bytes[i + 1] & 15) << 2;\n\t\t\tbase64 += table[a];\n\t\t\tbase64 += table[b];\n\t\t\tbase64 += table[c];\n\t\t\tbase64 += \"=\";\n\t\t} else {\n\t\t\tconst a = (bytes[i] & 252) >> 2;\n\t\t\tconst b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;\n\t\t\tconst c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;\n\t\t\tconst d = bytes[i + 2] & 63;\n\t\t\tbase64 += table[a];\n\t\t\tbase64 += table[b];\n\t\t\tbase64 += table[c];\n\t\t\tbase64 += table[d];\n\t\t}\n\t}\n\treturn base64;\n}\n/**\n* Records an async operation associated with a test task.\n*\n* This function tracks promises that should be awaited before a test completes.\n* The promise is automatically removed from the test's promise list once it settles.\n*/\nfunction recordAsyncOperation(test, promise) {\n\t// if promise is explicitly awaited, remove it from the list\n\tpromise = promise.finally(() => {\n\t\tif (!test.promises) {\n\t\t\treturn;\n\t\t}\n\t\tconst index = test.promises.indexOf(promise);\n\t\tif (index !== -1) {\n\t\t\ttest.promises.splice(index, 1);\n\t\t}\n\t});\n\t// record promise\n\tif (!test.promises) {\n\t\ttest.promises = [];\n\t}\n\ttest.promises.push(promise);\n\treturn promise;\n}\n/**\n* Validates and prepares a test attachment for serialization.\n*\n* This function ensures attachments have either `body` or `path` set (but not both), and converts `Uint8Array` bodies to base64-encoded strings for easier serialization.\n*\n* @param attachment - The attachment to validate and prepare\n*\n* @throws {TypeError} If neither `body` nor `path` is provided\n* @throws {TypeError} If both `body` and `path` are provided\n*/\nfunction manageArtifactAttachment(attachment) {\n\tif (attachment.body == null && !attachment.path) {\n\t\tthrow new TypeError(`Test attachment requires \"body\" or \"path\" to be set. Both are missing.`);\n\t}\n\tif (attachment.body && attachment.path) {\n\t\tthrow new TypeError(`Test attachment requires only one of \"body\" or \"path\" to be set. Both are specified.`);\n\t}\n\tif (attachment.path && attachment.bodyEncoding) {\n\t\tthrow new TypeError(`Test attachment with \"path\" should not have \"bodyEncoding\" specified.`);\n\t}\n\t// convert to a string so it's easier to serialise\n\tif (attachment.body instanceof Uint8Array) {\n\t\tattachment.body = encodeUint8Array(attachment.body);\n\t}\n\tif (attachment.body != null) {\n\t\tattachment.bodyEncoding ??= \"base64\";\n\t}\n}\n\nexport { createTagsFilter as A, createTaskName as B, findTestFileStackTrace as C, generateFileHash as D, generateHash as E, getFullName as F, getNames as G, getSuites as H, getTasks as I, getTestName as J, getTests as K, hasFailed as L, hasTests as M, interpretTaskModes as N, isTestCase as O, limitConcurrency as P, matchesTags as Q, partitionSuiteChildren as R, someTasksAreOnly as S, validateTags as T, afterAll as a, afterEach as b, aroundAll as c, aroundEach as d, beforeAll as e, beforeEach as f, createTaskCollector as g, describe as h, getCurrentSuite as i, getCurrentTest as j, getFn as k, getHooks as l, it as m, onTestFinished as n, onTestFailed as o, publicCollect as p, setHooks as q, recordArtifact as r, setFn as s, startTests as t, suite as u, test as v, updateTask as w, calculateSuiteHash as x, createChainable as y, createFileTask as z };\n"],"x_google_ignoreList":[0],"mappings":"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"}