@antdv-next/x-sdk 0.0.1 → 0.0.3

package/dist/node_modules/.pnpm/@voidzero-dev_vite-plus-test@0.1.14_@types_node@24.12.0_@voidzero-dev_vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/runner/chunk-artifact.js

@@ -0,0 +1,1513 @@
+import { format, formatRegExp, objDisplay } from "../utils/display.js";
+import { assertTypes, createDefer, filterOutComments, isNegativeNaN, isObject, objectAttr, ordinal, toArray, unique } from "../utils/helpers.js";
+import { getSafeTimers } from "../utils/timers.js";
+import { parseSingleStack } from "../utils/source-map.js";
+//#region ../../node_modules/.pnpm/@voidzero-dev+vite-plus-test@0.1.14_@types+node@24.12.0_@voidzero-dev+vite-plus-core@0._0c620f79340a656256b2ffe23b3e6dd1/node_modules/@voidzero-dev/vite-plus-test/dist/@vitest/runner/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 FixtureDependencyError = class extends Error {
+	name = "FixtureDependencyError";
+};
+var FixtureAccessError = class extends Error {
+	name = "FixtureAccessError";
+};
+var FixtureParseError = class extends Error {
+	name = "FixtureParseError";
+};
+var fnMap = /* @__PURE__ */ new WeakMap();
+var testFixtureMap = /* @__PURE__ */ new WeakMap();
+var hooksMap = /* @__PURE__ */ new WeakMap();
+function setFn(key, fn) {
+	fnMap.set(key, fn);
+}
+function setTestFixture(key, fixture) {
+	testFixtureMap.set(key, fixture);
+}
+function getTestFixtures(key) {
+	return testFixtureMap.get(key);
+}
+function setHooks(key, hooks) {
+	hooksMap.set(key, hooks);
+}
+function getHooks(key) {
+	return hooksMap.get(key);
+}
+var 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;
+	}
+};
+var cleanupFnArrayMap = /* @__PURE__ */ new WeakMap();
+var contextHasFixturesCache = /* @__PURE__ */ new WeakMap();
+function withFixtures(fn, options) {
+	const collector = getCurrentSuite();
+	const suite = options?.suite || collector.suite || collector.file;
+	return async (hookContext) => {
+		const context = hookContext || options?.context;
+		if (!context) {
+			if (options?.suiteHook) validateSuiteHook(fn, options.suiteHook, options.stackTraceError);
+			return fn({});
+		}
+		const fixtures = options?.fixtures || getTestFixtures(context);
+		if (!fixtures) return fn(context);
+		const registrations = fixtures.get(suite);
+		if (!registrations.size) return fn(context);
+		const usedFixtures = [];
+		const usedProps = getUsedProps(fn);
+		for (const fixture of registrations.values()) if (fixture.auto || usedProps.has(fixture.name)) usedFixtures.push(fixture);
+		if (!usedFixtures.length) return fn(context);
+		if (!cleanupFnArrayMap.has(context)) cleanupFnArrayMap.set(context, []);
+		const cleanupFnArray = cleanupFnArrayMap.get(context);
+		const pendingFixtures = resolveDeps(usedFixtures, registrations);
+		if (!pendingFixtures.length) return fn(context);
+		if (options?.suiteHook) {
+			const testScopedFixtures = pendingFixtures.filter((f) => f.scope === "test");
+			if (testScopedFixtures.length > 0) {
+				const fixtureNames = testScopedFixtures.map((f) => `"${f.name}"`).join(", ");
+				const error = new FixtureDependencyError(`Test-scoped fixtures cannot be used inside ${options.suiteHook} hook. The following fixtures are test-scoped: ${fixtureNames}. Use { scope: 'file' } or { scope: 'worker' } fixtures instead, or move the logic to ${{
+					aroundAll: "aroundEach",
+					beforeAll: "beforeEach",
+					afterAll: "afterEach"
+				}[options.suiteHook]} hook.`);
+				if (options.stackTraceError?.stack) error.stack = error.message + options.stackTraceError.stack.replace(options.stackTraceError.message, "");
+				throw error;
+			}
+		}
+		if (!contextHasFixturesCache.has(context)) contextHasFixturesCache.set(context, /* @__PURE__ */ new WeakSet());
+		const cachedFixtures = contextHasFixturesCache.get(context);
+		for (const fixture of pendingFixtures) if (fixture.scope === "test") {
+			if (cachedFixtures.has(fixture)) continue;
+			cachedFixtures.add(fixture);
+			const resolvedValue = await resolveTestFixtureValue(fixture, context, cleanupFnArray);
+			context[fixture.name] = resolvedValue;
+			cleanupFnArray.push(() => {
+				cachedFixtures.delete(fixture);
+			});
+		} else {
+			const resolvedValue = await resolveScopeFixtureValue(fixtures, suite, fixture);
+			context[fixture.name] = resolvedValue;
+		}
+		return fn(context);
+	};
+}
+function isFixtureFunction(value) {
+	return typeof value === "function";
+}
+function resolveTestFixtureValue(fixture, context, cleanupFnArray) {
+	if (!isFixtureFunction(fixture.value)) return fixture.value;
+	return resolveFixtureFunction(fixture.value, fixture.name, context, cleanupFnArray);
+}
+var 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;
+	}
+}
+var kPropsSymbol = Symbol("$vitest:fixture-props");
+var 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;
+}
+var _test;
+function getCurrentTest() {
+	return _test;
+}
+var 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;
+}
+var CLEANUP_TIMEOUT_KEY = Symbol.for("VITEST_CLEANUP_TIMEOUT");
+var CLEANUP_STACK_TRACE_KEY = Symbol.for("VITEST_CLEANUP_STACK_TRACE");
+var AROUND_TIMEOUT_KEY = Symbol.for("VITEST_AROUND_TIMEOUT");
+var AROUND_STACK_TRACE_KEY = Symbol.for("VITEST_AROUND_STACK_TRACE");
+/**
+* Registers a callback function to be executed once before all tests within the current suite.
+* This hook is useful for scenarios where you need to perform setup operations that are common to all tests in a suite, such as initializing a database connection or setting up a test environment.
+*
+* **Note:** The `beforeAll` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeAll to set up a database connection
+* beforeAll(async () => {
+*   await database.connect();
+* });
+* ```
+*/
+function beforeAll(fn, timeout = getDefaultHookTimeout()) {
+	assertTypes(fn, "\"beforeAll\" callback", ["function"]);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const context = getChainableContext(this);
+	return getCurrentSuite().on("beforeAll", Object.assign(withTimeout(withSuiteFixtures("beforeAll", fn, context, stackTraceError), timeout, true, stackTraceError), {
+		[CLEANUP_TIMEOUT_KEY]: timeout,
+		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function to be executed once after all tests within the current suite have completed.
+* This hook is useful for scenarios where you need to perform cleanup operations after all tests in a suite have run, such as closing database connections or cleaning up temporary files.
+*
+* **Note:** The `afterAll` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after all tests.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterAll to close a database connection
+* afterAll(async () => {
+*   await database.disconnect();
+* });
+* ```
+*/
+function afterAll(fn, timeout) {
+	assertTypes(fn, "\"afterAll\" callback", ["function"]);
+	const context = getChainableContext(this);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	return getCurrentSuite().on("afterAll", withTimeout(withSuiteFixtures("afterAll", fn, context, stackTraceError), timeout ?? getDefaultHookTimeout(), true, stackTraceError));
+}
+/**
+* Registers a callback function to be executed before each test within the current suite.
+* This hook is useful for scenarios where you need to reset or reinitialize the test environment before each test runs, such as resetting database states, clearing caches, or reinitializing variables.
+*
+* **Note:** The `beforeEach` hooks are executed in the order they are defined one after another. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed before each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using beforeEach to reset a database state
+* beforeEach(async () => {
+*   await database.reset();
+* });
+* ```
+*/
+function beforeEach(fn, timeout = getDefaultHookTimeout()) {
+	assertTypes(fn, "\"beforeEach\" callback", ["function"]);
+	const stackTraceError = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const wrapper = (context, suite) => {
+		return withFixtures(fn, { suite })(context);
+	};
+	return getCurrentSuite().on("beforeEach", Object.assign(withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, stackTraceError, abortIfTimeout), {
+		[CLEANUP_TIMEOUT_KEY]: timeout,
+		[CLEANUP_STACK_TRACE_KEY]: stackTraceError
+	}));
+}
+/**
+* Registers a callback function to be executed after each test within the current suite has completed.
+* This hook is useful for scenarios where you need to clean up or reset the test environment after each test runs, such as deleting temporary files, clearing test-specific database entries, or resetting mocked functions.
+*
+* **Note:** The `afterEach` hooks are running in reverse order of their registration. You can configure this by changing the `sequence.hooks` option in the config file.
+*
+* @param {Function} fn - The callback function to be executed after each test. This function receives an `TestContext` parameter if additional test context is needed.
+* @param {number} [timeout] - Optional timeout in milliseconds for the hook. If not provided, the default hook timeout from the runner's configuration is used.
+* @returns {void}
+* @example
+* ```ts
+* // Example of using afterEach to delete temporary files created during a test
+* afterEach(async () => {
+*   await fileSystem.deleteTempFiles();
+* });
+* ```
+*/
+function afterEach(fn, timeout) {
+	assertTypes(fn, "\"afterEach\" callback", ["function"]);
+	const wrapper = (context, suite) => {
+		return withFixtures(fn, { suite })(context);
+	};
+	return getCurrentSuite().on("afterEach", withTimeout(wrapper, timeout ?? getDefaultHookTimeout(), true, /* @__PURE__ */ new Error("STACK_TRACE_ERROR"), abortIfTimeout));
+}
+/**
+* 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 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;
+	}
+}
+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 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 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');
+*     });
+*   });
+* });
+* ```
+*/
+var 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);
+* });
+* ```
+*/
+var 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');
+*     });
+*   });
+* });
+* ```
+*/
+var 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);
+* });
+* ```
+*/
+var it = test;
+var runner;
+var defaultSuite;
+var currentTestFilepath;
+function assert(condition, message) {
+	if (!condition) throw new Error(`Vitest failed to find ${message}. One of the following is possible:
+- "vitest" is imported directly without running "vitest" command
+- "vitest" is imported inside "globalSetup" (to fix this, use "setupFiles" instead, because "globalSetup" runs in a different context)
+- "vitest" is imported inside Vite / Vitest config file
+- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues
+`);
+}
+function getRunner() {
+	assert(runner, "the runner");
+	return runner;
+}
+function getCurrentSuite() {
+	const currentSuite = collectorContext.currentSuite || defaultSuite;
+	assert(currentSuite, "the current suite");
+	return currentSuite;
+}
+function createSuiteHooks() {
+	return {
+		beforeAll: [],
+		afterAll: [],
+		beforeEach: [],
+		afterEach: [],
+		aroundEach: [],
+		aroundAll: []
+	};
+}
+var 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;
+}
+var now$2 = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+var 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);
+			}
+		});
+	});
+}
+var 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;
+}
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now;
+Date.now;
+var { clearTimeout, setTimeout } = getSafeTimers();
+var packs = /* @__PURE__ */ new Map();
+var eventsPacks = [];
+var 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);
+}
+/**
+* @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;
+}
+var table = [];
+for (let i = 65; i < 91; i++) table.push(String.fromCharCode(i));
+for (let i = 97; i < 123; i++) table.push(String.fromCharCode(i));
+for (let i = 0; i < 10; i++) table.push(i.toString(10));
+table.push("+", "/");
+function encodeUint8Array(bytes) {
+	let base64 = "";
+	const len = bytes.byteLength;
+	for (let i = 0; i < len; i += 3) if (len === i + 1) {
+		const a = (bytes[i] & 252) >> 2;
+		const b = (bytes[i] & 3) << 4;
+		base64 += table[a];
+		base64 += table[b];
+		base64 += "==";
+	} else if (len === i + 2) {
+		const a = (bytes[i] & 252) >> 2;
+		const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+		const c = (bytes[i + 1] & 15) << 2;
+		base64 += table[a];
+		base64 += table[b];
+		base64 += table[c];
+		base64 += "=";
+	} else {
+		const a = (bytes[i] & 252) >> 2;
+		const b = (bytes[i] & 3) << 4 | (bytes[i + 1] & 240) >> 4;
+		const c = (bytes[i + 1] & 15) << 2 | (bytes[i + 2] & 192) >> 6;
+		const d = bytes[i + 2] & 63;
+		base64 += table[a];
+		base64 += table[b];
+		base64 += table[c];
+		base64 += table[d];
+	}
+	return base64;
+}
+/**
+* Records an async operation associated with a test task.
+*
+* This function tracks promises that should be awaited before a test completes.
+* The promise is automatically removed from the test's promise list once it settles.
+*/
+function recordAsyncOperation(test, promise) {
+	promise = promise.finally(() => {
+		if (!test.promises) return;
+		const index = test.promises.indexOf(promise);
+		if (index !== -1) test.promises.splice(index, 1);
+	});
+	if (!test.promises) test.promises = [];
+	test.promises.push(promise);
+	return promise;
+}
+/**
+* Validates and prepares a test attachment for serialization.
+*
+* This function ensures attachments have either `body` or `path` set (but not both), and converts `Uint8Array` bodies to base64-encoded strings for easier serialization.
+*
+* @param attachment - The attachment to validate and prepare
+*
+* @throws {TypeError} If neither `body` nor `path` is provided
+* @throws {TypeError} If both `body` and `path` are provided
+*/
+function manageArtifactAttachment(attachment) {
+	if (attachment.body == null && !attachment.path) throw new TypeError(`Test attachment requires "body" or "path" to be set. Both are missing.`);
+	if (attachment.body && attachment.path) throw new TypeError(`Test attachment requires only one of "body" or "path" to be set. Both are specified.`);
+	if (attachment.body instanceof Uint8Array) attachment.body = encodeUint8Array(attachment.body);
+}
+//#endregion
+export { createTaskName as B, findTestFileStackTrace as C, getNames as G, 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, getHooks as l, it as m, setHooks as q, recordArtifact as r, setFn as s, suite as u, test as v, createChainable as y };