vitest 4.1.2 → 4.1.4

package/dist/chunks/{test.p_J6dB8a.js → test.D1JkM1w4.js}

@@ -2,346 +2,17 @@ import { getCurrentTest, updateTask, createTaskCollector, getCurrentSuite, getHo
 import { assertTypes, createSimpleStackTrace, createDefer } from '@vitest/utils/helpers';
 import { getSafeTimers, delay } from '@vitest/utils/timers';
 import { a as getBenchOptions, g as getBenchFn } from './benchmark.CX_oY03V.js';
-import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.BX5Fg8C4.js';
+import { i as isChildProcess, w as waitForImportsToResolve, r as resetModules, g as getWorkerState } from './utils.BX5Fg8C4.js';
 import { chai, wrapAssertion, recordAsyncExpect, createAssertionMessage, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, ChaiStyleAssertions, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
 import { getNames, getTests, getTestName, createChainable, matchesTags } from '@vitest/runner/utils';
 import { processError } from '@vitest/utils/error';
 import { normalize } from 'pathe';
-import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '@vitest/spy';
 import '@vitest/utils/offset';
 import { parseSingleStack } from '@vitest/utils/source-map';
 import { c as commonjsGlobal } from './_commonjsHelpers.D26ty3Ew.js';
 import { R as RealDate, b as resetDate, m as mockDate, r as rpc } from './rpc.MzXet3jl.js';
-
-// these matchers are not supported because they don't make sense with poll
-const unsupported = [
-	"matchSnapshot",
-	"toMatchSnapshot",
-	"toMatchInlineSnapshot",
-	"toThrowErrorMatchingSnapshot",
-	"toThrowErrorMatchingInlineSnapshot",
-	"throws",
-	"Throw",
-	"throw",
-	"toThrow",
-	"toThrowError"
-];
-/**
-* Attaches a `cause` property to the error if missing, copies the stack trace from the source, and throws.
-*
-* @param error - The error to throw
-* @param source - Error to copy the stack trace from
-*
-* @throws Always throws the provided error with an amended stack trace
-*/
-function throwWithCause(error, source) {
-	if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
-	throw copyStackTrace$1(error, source);
-}
-function createExpectPoll(expect) {
-	return function poll(fn, options = {}) {
-		const defaults = getWorkerState().config.expect?.poll ?? {};
-		const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
-		// @ts-expect-error private poll access
-		const assertion = expect(null, message).withContext({ poll: true });
-		fn = fn.bind(assertion);
-		const test = chai.util.flag(assertion, "vitest-test");
-		if (!test) throw new Error("expect.poll() must be called inside a test");
-		const proxy = new Proxy(assertion, { get(target, key, receiver) {
-			const assertionFunction = Reflect.get(target, key, receiver);
-			if (typeof assertionFunction !== "function") return assertionFunction instanceof chai.Assertion ? proxy : assertionFunction;
-			if (key === "assert") return assertionFunction;
-			if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
-			return function(...args) {
-				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
-				const promise = async () => {
-					const { setTimeout, clearTimeout } = getSafeTimers();
-					let executionPhase = "fn";
-					let hasTimedOut = false;
-					const timerId = setTimeout(() => {
-						hasTimedOut = true;
-					}, timeout);
-					chai.util.flag(assertion, "_name", key);
-					const onSettled = chai.util.flag(assertion, "_poll.onSettled");
-					try {
-						while (true) {
-							const isLastAttempt = hasTimedOut;
-							if (isLastAttempt) chai.util.flag(assertion, "_isLastPollAttempt", true);
-							try {
-								executionPhase = "fn";
-								const obj = await fn();
-								chai.util.flag(assertion, "object", obj);
-								executionPhase = "assertion";
-								const output = await assertionFunction.call(assertion, ...args);
-								await onSettled?.({
-									assertion,
-									status: "pass"
-								});
-								return output;
-							} catch (err) {
-								if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) {
-									await onSettled?.({
-										assertion,
-										status: "fail"
-									});
-									throwWithCause(err, STACK_TRACE_ERROR);
-								}
-								await delay(interval, setTimeout);
-							}
-						}
-					} finally {
-						clearTimeout(timerId);
-					}
-				};
-				let awaited = false;
-				test.onFinished ??= [];
-				test.onFinished.push(() => {
-					if (!awaited) {
-						const negated = chai.util.flag(assertion, "negate") ? "not." : "";
-						const assertionString = `expect.${chai.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
-						throw copyStackTrace$1(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\n\nawait ${assertionString}\n`), STACK_TRACE_ERROR);
-					}
-				});
-				let resultPromise;
-				// only .then is enough to check awaited, but we type this as `Promise<void>` in global types
-				// so let's follow it
-				return {
-					then(onFulfilled, onRejected) {
-						awaited = true;
-						return (resultPromise ||= promise()).then(onFulfilled, onRejected);
-					},
-					catch(onRejected) {
-						awaited = true;
-						return (resultPromise ||= promise()).catch(onRejected);
-					},
-					finally(onFinally) {
-						awaited = true;
-						return (resultPromise ||= promise()).finally(onFinally);
-					},
-					[Symbol.toStringTag]: "Promise"
-				};
-			};
-		} });
-		return proxy;
-	};
-}
-function copyStackTrace$1(target, source) {
-	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
-	return target;
-}
-
-let _client;
-function getSnapshotClient() {
-	if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
-		return equals(received, expected, [iterableEquality, subsetEquality]);
-	} });
-	return _client;
-}
-function getError(expected, promise) {
-	if (typeof expected !== "function") {
-		if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
-		// when "promised", it receives thrown error
-		return expected;
-	}
-	try {
-		expected();
-	} catch (e) {
-		return e;
-	}
-	throw new Error("snapshot function didn't throw");
-}
-function getTestNames(test) {
-	return {
-		filepath: test.file.filepath,
-		name: getNames(test).slice(1).join(" > "),
-		testId: test.id
-	};
-}
-const SnapshotPlugin = (chai, utils) => {
-	function getTest(assertionName, obj) {
-		const test = utils.flag(obj, "vitest-test");
-		if (!test) throw new Error(`'${assertionName}' cannot be used without test context`);
-		return test;
-	}
-	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(properties, message) {
-		utils.flag(this, "_name", key);
-		if (utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
-		const expected = utils.flag(this, "object");
-		const test = getTest(key, this);
-		if (typeof properties === "string" && typeof message === "undefined") {
-			message = properties;
-			properties = void 0;
-		}
-		const errorMessage = utils.flag(this, "message");
-		getSnapshotClient().assert({
-			received: expected,
-			message,
-			isInline: false,
-			properties,
-			errorMessage,
-			...getTestNames(test)
-		});
-	}));
-	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
-		utils.flag(this, "_name", "toMatchFileSnapshot");
-		if (utils.flag(this, "negate")) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
-		const error = /* @__PURE__ */ new Error("resolves");
-		const expected = utils.flag(this, "object");
-		const test = getTest("toMatchFileSnapshot", this);
-		const errorMessage = utils.flag(this, "message");
-		return recordAsyncExpect(test, getSnapshotClient().assertRaw({
-			received: expected,
-			message,
-			isInline: false,
-			rawSnapshot: { file },
-			errorMessage,
-			...getTestNames(test)
-		}), createAssertionMessage(utils, this, true), error, utils.flag(this, "soft"));
-	});
-	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(properties, inlineSnapshot, message) {
-		utils.flag(this, "_name", "toMatchInlineSnapshot");
-		if (utils.flag(this, "negate")) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
-		const test = getTest("toMatchInlineSnapshot", this);
-		const expected = utils.flag(this, "object");
-		const error = utils.flag(this, "error");
-		if (typeof properties === "string") {
-			message = inlineSnapshot;
-			inlineSnapshot = properties;
-			properties = void 0;
-		}
-		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-		const errorMessage = utils.flag(this, "message");
-		getSnapshotClient().assert({
-			received: expected,
-			message,
-			isInline: true,
-			properties,
-			inlineSnapshot,
-			error,
-			errorMessage,
-			...getTestNames(test)
-		});
-	}));
-	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(properties, message) {
-		utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
-		if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
-		const expected = utils.flag(this, "object");
-		const test = getTest("toThrowErrorMatchingSnapshot", this);
-		const promise = utils.flag(this, "promise");
-		const errorMessage = utils.flag(this, "message");
-		getSnapshotClient().assert({
-			received: getError(expected, promise),
-			message,
-			errorMessage,
-			...getTestNames(test)
-		});
-	}));
-	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshot, message) {
-		if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
-		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
-		const expected = utils.flag(this, "object");
-		const error = utils.flag(this, "error");
-		const promise = utils.flag(this, "promise");
-		const errorMessage = utils.flag(this, "message");
-		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-		getSnapshotClient().assert({
-			received: getError(expected, promise),
-			message,
-			inlineSnapshot,
-			isInline: true,
-			error,
-			errorMessage,
-			...getTestNames(test)
-		});
-	}));
-	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
-};
-
-chai.use(JestExtend);
-chai.use(JestChaiExpect);
-chai.use(ChaiStyleAssertions);
-chai.use(SnapshotPlugin);
-chai.use(JestAsymmetricMatchers);
-
-function createExpect(test) {
-	const expect = ((value, message) => {
-		const { assertionCalls } = getState(expect);
-		setState({ assertionCalls: assertionCalls + 1 }, expect);
-		const assert = chai.expect(value, message);
-		const _test = test || getCurrentTest();
-		if (_test)
- // @ts-expect-error internal
-		return assert.withTest(_test);
-		else return assert;
-	});
-	Object.assign(expect, chai.expect);
-	Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
-	expect.getState = () => getState(expect);
-	expect.setState = (state) => setState(state, expect);
-	// @ts-expect-error global is not typed
-	const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
-	setState({
-		...globalState,
-		assertionCalls: 0,
-		isExpectingAssertions: false,
-		isExpectingAssertionsError: null,
-		expectedAssertionsNumber: null,
-		expectedAssertionsNumberErrorGen: null,
-		get testPath() {
-			return getWorkerState().filepath;
-		},
-		currentTestName: test ? test.fullTestName ?? "" : globalState.currentTestName
-	}, expect);
-	expect.assert = chai.assert;
-	// @ts-expect-error untyped
-	expect.extend = (matchers) => chai.expect.extend(expect, matchers);
-	expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
-	expect.soft = (...args) => {
-		// @ts-expect-error private soft access
-		return expect(...args).withContext({ soft: true });
-	};
-	expect.poll = createExpectPoll(expect);
-	expect.unreachable = (message) => {
-		chai.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
-	};
-	function assertions(expected) {
-		const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
-		if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
-		expect.setState({
-			expectedAssertionsNumber: expected,
-			expectedAssertionsNumberErrorGen: errorGen
-		});
-	}
-	function hasAssertions() {
-		const error = /* @__PURE__ */ new Error("expected any number of assertion, but got none");
-		if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
-		expect.setState({
-			isExpectingAssertions: true,
-			isExpectingAssertionsError: error
-		});
-	}
-	chai.util.addMethod(expect, "assertions", assertions);
-	chai.util.addMethod(expect, "hasAssertions", hasAssertions);
-	expect.extend(customMatchers);
-	return expect;
-}
-const globalExpect = createExpect();
-Object.defineProperty(globalThis, GLOBAL_EXPECT, {
-	value: globalExpect,
-	writable: true,
-	configurable: true
-});
-const assert = chai.assert;
-const should = chai.should;
-
-/**
-* Gives access to injected context provided from the main thread.
-* This usually returns a value provided by `globalSetup` or an external library.
-*/
-function inject(key) {
-	return getWorkerState().providedContext[key];
-}
+import { addSerializer, stripSnapshotIndentation, SnapshotClient } from '@vitest/snapshot';
 
 var fakeTimersSrc = {};
 
@@ -3681,7 +3352,7 @@ class FakeTimers {
 	}
 }
 
-function copyStackTrace(target, source) {
+function copyStackTrace$1(target, source) {
 	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
 }
@@ -3702,7 +3373,7 @@ function waitFor(callback, options = {}) {
 		const handleTimeout = () => {
 			if (intervalId) clearInterval(intervalId);
 			let error = lastError;
-			if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+			if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
 			reject(error);
 		};
 		const checkCallback = () => {
@@ -3743,7 +3414,7 @@ function waitUntil(callback, options = {}) {
 		let intervalId;
 		const onReject = (error) => {
 			if (intervalId) clearInterval(intervalId);
-			if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
+			if (!error) error = copyStackTrace$1(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
 			reject(error);
 		};
 		const onResolve = (result) => {
@@ -4012,6 +3683,488 @@ function getImporter(name) {
 	}) + 1])?.file || "";
 }
 
+// these matchers are not supported because they don't make sense with poll
+const unsupported = [
+	"matchSnapshot",
+	"toMatchSnapshot",
+	"toMatchInlineSnapshot",
+	"toThrowErrorMatchingSnapshot",
+	"toThrowErrorMatchingInlineSnapshot",
+	"throws",
+	"Throw",
+	"throw",
+	"toThrow",
+	"toThrowError"
+];
+/**
+* Attaches a `cause` property to the error if missing, copies the stack trace from the source, and throws.
+*
+* @param error - The error to throw
+* @param source - Error to copy the stack trace from
+*
+* @throws Always throws the provided error with an amended stack trace
+*/
+function throwWithCause(error, source) {
+	if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
+	throw copyStackTrace(error, source);
+}
+function createExpectPoll(expect) {
+	return function poll(fn, options = {}) {
+		const defaults = getWorkerState().config.expect?.poll ?? {};
+		const { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options;
+		// @ts-expect-error private poll access
+		const assertion = expect(null, message).withContext({ poll: true });
+		fn = fn.bind(assertion);
+		// injected so that domain snapshot can take over poll implementation.
+		chai.util.flag(assertion, "_poll.fn", fn);
+		chai.util.flag(assertion, "_poll.timeout", timeout);
+		chai.util.flag(assertion, "_poll.interval", interval);
+		const test = chai.util.flag(assertion, "vitest-test");
+		if (!test) throw new Error("expect.poll() must be called inside a test");
+		const proxy = new Proxy(assertion, { get(target, key, receiver) {
+			const assertionFunction = Reflect.get(target, key, receiver);
+			if (typeof assertionFunction !== "function") return assertionFunction instanceof chai.Assertion ? proxy : assertionFunction;
+			if (key === "assert") return assertionFunction;
+			if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
+			// Core poll stack-trace trick:
+			//   1. capture STACK_TRACE_ERROR here before entering the async poll loop
+			//   2. when the matcher eventually fails, rethrow via throwWithCause()
+			//      so the final error keeps this earlier stack
+			//
+			// For example, when user writes:
+			//    await expect.poll(...).toBeSomething()
+			// STACK_TRACE_ERROR.stack would look like
+			//   at ...(more internal stacks)...
+			//   at __VITEST_POLL_CHAIN__ .../packages/vitest/dist/...
+			//   at .../my-file.test.ts:12:3   (this points to `toBeSomething()` callsite in user test file)
+			// Vitest later filters out internal stacks from `vitest/dist`, so the reported errors correctly
+			// points to the user callsite for poll assertion errors.
+			//
+			// Inline snapshots piggyback on the same idea. We pass
+			// STACK_TRACE_ERROR through `chai.util.flag(assertion, 'error', ...)`.
+			// Inline snapshot assertion access the same error stack for
+			// extracting inline snapshot location to validate and update new snapshots.
+			return function __VITEST_POLL_CHAIN__(...args) {
+				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+				const promise = async () => {
+					chai.util.flag(assertion, "_name", key);
+					chai.util.flag(assertion, "error", STACK_TRACE_ERROR);
+					const onSettled = chai.util.flag(assertion, "_poll.onSettled");
+					if (Object.getOwnPropertyDescriptor(assertionFunction, "__vitest_poll_takeover__")?.value) try {
+						const output = await assertionFunction.call(assertion, ...args);
+						await onSettled?.({
+							assertion,
+							status: "pass"
+						});
+						return output;
+					} catch (err) {
+						await onSettled?.({
+							assertion,
+							status: "fail"
+						});
+						throwWithCause(err, STACK_TRACE_ERROR);
+					}
+					const { setTimeout, clearTimeout } = getSafeTimers();
+					let executionPhase = "fn";
+					let hasTimedOut = false;
+					const timerId = setTimeout(() => {
+						hasTimedOut = true;
+					}, timeout);
+					try {
+						while (true) {
+							const isLastAttempt = hasTimedOut;
+							if (isLastAttempt) chai.util.flag(assertion, "_isLastPollAttempt", true);
+							try {
+								executionPhase = "fn";
+								const obj = await fn();
+								chai.util.flag(assertion, "object", obj);
+								executionPhase = "assertion";
+								const output = await assertionFunction.call(assertion, ...args);
+								await onSettled?.({
+									assertion,
+									status: "pass"
+								});
+								return output;
+							} catch (err) {
+								if (isLastAttempt || executionPhase === "assertion" && chai.util.flag(assertion, "_poll.assert_once")) {
+									await onSettled?.({
+										assertion,
+										status: "fail"
+									});
+									throwWithCause(err, STACK_TRACE_ERROR);
+								}
+								await delay(interval, setTimeout);
+								if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+							}
+						}
+					} finally {
+						clearTimeout(timerId);
+					}
+				};
+				let awaited = false;
+				test.onFinished ??= [];
+				test.onFinished.push(() => {
+					if (!awaited) {
+						const negated = chai.util.flag(assertion, "negate") ? "not." : "";
+						const assertionString = `expect.${chai.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`;
+						throw copyStackTrace(/* @__PURE__ */ new Error(`${assertionString} was not awaited. This assertion is asynchronous and must be awaited; otherwise, it is not executed to avoid unhandled rejections:\n\nawait ${assertionString}\n`), STACK_TRACE_ERROR);
+					}
+				});
+				let resultPromise;
+				// only .then is enough to check awaited, but we type this as `Promise<void>` in global types
+				// so let's follow it
+				return {
+					then(onFulfilled, onRejected) {
+						awaited = true;
+						return (resultPromise ||= promise()).then(onFulfilled, onRejected);
+					},
+					catch(onRejected) {
+						awaited = true;
+						return (resultPromise ||= promise()).catch(onRejected);
+					},
+					finally(onFinally) {
+						awaited = true;
+						return (resultPromise ||= promise()).finally(onFinally);
+					},
+					[Symbol.toStringTag]: "Promise"
+				};
+			};
+		} });
+		return proxy;
+	};
+}
+function copyStackTrace(target, source) {
+	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
+	return target;
+}
+
+let _client;
+function getSnapshotClient() {
+	if (!_client) _client = new SnapshotClient({ isEqual: (received, expected) => {
+		return equals(received, expected, [iterableEquality, subsetEquality]);
+	} });
+	return _client;
+}
+function getError(expected, promise) {
+	if (typeof expected !== "function") {
+		if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
+		// when "promised", it receives thrown error
+		return expected;
+	}
+	try {
+		expected();
+	} catch (e) {
+		return e;
+	}
+	throw new Error("snapshot function didn't throw");
+}
+function getTestNames(test) {
+	return {
+		filepath: test.file.filepath,
+		name: getNames(test).slice(1).join(" > "),
+		testId: test.id
+	};
+}
+function getAssertionName(assertion) {
+	const name = chai.util.flag(assertion, "_name");
+	if (!name) throw new Error("Assertion name is not set. This is a bug in Vitest. Please, open a new issue with reproduction.");
+	return name;
+}
+function getTest(obj) {
+	const test = chai.util.flag(obj, "vitest-test");
+	if (!test) throw new Error(`'${getAssertionName(obj)}' cannot be used without test context`);
+	return test;
+}
+function validateAssertion(assertion) {
+	if (chai.util.flag(assertion, "negate")) throw new Error(`${getAssertionName(assertion)} cannot be used with "not"`);
+}
+const SnapshotPlugin = (chai, utils) => {
+	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, wrapAssertion(utils, key, function(propertiesOrHint, hint) {
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: utils.flag(this, "object"),
+			...normalizeArguments(propertiesOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(filepath, hint) {
+		// set name manually since it's not wrapped by wrapAssertion
+		utils.flag(this, "_name", "toMatchFileSnapshot");
+		// validate early synchronously just not to break some existing tests
+		validateAssertion(this);
+		const assertPromise = toMatchFileSnapshotImpl({
+			assertion: this,
+			received: utils.flag(this, "object"),
+			filepath,
+			hint
+		}).then((result) => assertMatchResult(result, chai.util.flag(this, "message")));
+		return recordAsyncExpect(getTest(this), assertPromise, createAssertionMessage(utils, this, true), /* @__PURE__ */ new Error("resolves"), utils.flag(this, "soft"));
+	});
+	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", wrapAssertion(utils, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: utils.flag(this, "object"),
+			isInline: true,
+			...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", wrapAssertion(utils, "toThrowErrorMatchingSnapshot", function(propertiesOrHint, hint) {
+		validateAssertion(this);
+		const received = utils.flag(this, "object");
+		const promise = utils.flag(this, "promise");
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: getError(received, promise),
+			...normalizeArguments(propertiesOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", wrapAssertion(utils, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT_OFFSET_3__(inlineSnapshotOrHint, hint) {
+		validateAssertion(this);
+		const received = utils.flag(this, "object");
+		const promise = utils.flag(this, "promise");
+		return assertMatchResult(toMatchSnapshotImpl({
+			assertion: this,
+			received: getError(received, promise),
+			isInline: true,
+			...normalizeInlineArguments(void 0, inlineSnapshotOrHint, hint)
+		}), chai.util.flag(this, "message"));
+	}));
+	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+};
+function toMatchDomainSnapshotImpl(opts) {
+	const { assertion } = opts;
+	validateAssertion(assertion);
+	const assertionName = getAssertionName(assertion);
+	const test = getTest(assertion);
+	let { inlineSnapshot } = opts;
+	if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+	const pollFn = chai.util.flag(assertion, "_poll.fn");
+	if (pollFn) return getSnapshotClient().pollMatchDomain({
+		poll: pollFn,
+		adapter: opts.adapter,
+		message: opts.hint,
+		isInline: opts.isInline,
+		errorMessage: chai.util.flag(assertion, "message"),
+		timeout: chai.util.flag(assertion, "_poll.timeout"),
+		interval: chai.util.flag(assertion, "_poll.interval"),
+		assertionName,
+		inlineSnapshot,
+		error: chai.util.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+	return getSnapshotClient().matchDomain({
+		received: opts.received,
+		adapter: opts.adapter,
+		message: opts.hint,
+		isInline: opts.isInline,
+		errorMessage: chai.util.flag(assertion, "message"),
+		assertionName,
+		inlineSnapshot,
+		error: chai.util.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+}
+// toMatchSnapshot(propertiesOrHint?, hint?)
+function normalizeArguments(propertiesOrHint, hint) {
+	if (typeof propertiesOrHint === "string") return { hint: propertiesOrHint };
+	return {
+		properties: propertiesOrHint,
+		hint
+	};
+}
+// toMatchInlineSnapshot(propertiesOrInlineSnapshot?, inlineSnapshotOrHint?, hint?)
+function normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+	let inlineSnapshot;
+	if (typeof propertiesOrInlineSnapshot === "string") {
+		inlineSnapshot = stripSnapshotIndentation(propertiesOrInlineSnapshot);
+		return {
+			inlineSnapshot,
+			hint: inlineSnapshotOrHint
+		};
+	}
+	if (inlineSnapshotOrHint) inlineSnapshot = stripSnapshotIndentation(inlineSnapshotOrHint);
+	return {
+		properties: propertiesOrInlineSnapshot,
+		inlineSnapshot,
+		hint
+	};
+}
+function toMatchSnapshotImpl(options) {
+	const { assertion } = options;
+	validateAssertion(assertion);
+	const assertionName = getAssertionName(assertion);
+	const test = getTest(assertion);
+	return getSnapshotClient().match({
+		received: options.received,
+		properties: options.properties,
+		message: options.hint,
+		isInline: options.isInline,
+		inlineSnapshot: options.inlineSnapshot,
+		assertionName,
+		error: chai.util.flag(assertion, "error"),
+		...getTestNames(test)
+	});
+}
+async function toMatchFileSnapshotImpl(options) {
+	const { assertion } = options;
+	validateAssertion(assertion);
+	const testNames = getTestNames(getTest(assertion));
+	const snapshotState = getSnapshotClient().getSnapshotState(testNames.filepath);
+	const rawSnapshotFile = await snapshotState.environment.resolveRawPath(testNames.filepath, options.filepath);
+	const rawSnapshotContent = await snapshotState.environment.readSnapshotFile(rawSnapshotFile);
+	return getSnapshotClient().match({
+		received: options.received,
+		message: options.hint,
+		rawSnapshot: {
+			file: rawSnapshotFile,
+			content: rawSnapshotContent ?? void 0
+		},
+		...testNames
+	});
+}
+function assertMatchResult(result, customMessage) {
+	if (!result.pass) {
+		const errorMessage = (customMessage ? `${customMessage}: ` : "") + result.message();
+		throw Object.assign(new Error(errorMessage), {
+			actual: result.actual,
+			expected: result.expected,
+			diffOptions: { expand: getWorkerState().config.snapshotOptions.expand }
+		});
+	}
+}
+/**
+* Composable snapshot matcher helpers for building custom snapshot matchers
+* with `expect.extend`.
+*
+* @experimental
+* @see https://vitest.dev/guide/snapshot.html#custom-snapshot-matchers
+*/
+const Snapshots = {
+	toMatchSnapshot(received, propertiesOrHint, hint) {
+		return toMatchSnapshotImpl({
+			assertion: this.assertion,
+			received,
+			...normalizeArguments(propertiesOrHint, hint)
+		});
+	},
+	toMatchInlineSnapshot(received, propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint) {
+		return toMatchSnapshotImpl({
+			assertion: this.assertion,
+			received,
+			isInline: true,
+			...normalizeInlineArguments(propertiesOrInlineSnapshot, inlineSnapshotOrHint, hint)
+		});
+	},
+	toMatchFileSnapshot(received, filepath, hint) {
+		return toMatchFileSnapshotImpl({
+			assertion: this.assertion,
+			received,
+			filepath,
+			hint
+		});
+	},
+	toMatchDomainSnapshot(domain, received) {
+		return toMatchDomainSnapshotImpl({
+			assertion: this.assertion,
+			adapter: domain,
+			received
+		});
+	},
+	toMatchDomainInlineSnapshot(domain, received, inlineSnapshot) {
+		return toMatchDomainSnapshotImpl({
+			assertion: this.assertion,
+			adapter: domain,
+			received,
+			isInline: true,
+			inlineSnapshot
+		});
+	}
+};
+
+chai.use(JestExtend);
+chai.use(JestChaiExpect);
+chai.use(ChaiStyleAssertions);
+chai.use(SnapshotPlugin);
+chai.use(JestAsymmetricMatchers);
+
+function createExpect(test) {
+	const expect = ((value, message) => {
+		const { assertionCalls } = getState(expect);
+		setState({ assertionCalls: assertionCalls + 1 }, expect);
+		const assert = chai.expect(value, message);
+		const _test = test || getCurrentTest();
+		if (_test)
+ // @ts-expect-error internal
+		return assert.withTest(_test);
+		else return assert;
+	});
+	Object.assign(expect, chai.expect);
+	Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+	expect.getState = () => getState(expect);
+	expect.setState = (state) => setState(state, expect);
+	// @ts-expect-error global is not typed
+	const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
+	setState({
+		...globalState,
+		assertionCalls: 0,
+		isExpectingAssertions: false,
+		isExpectingAssertionsError: null,
+		expectedAssertionsNumber: null,
+		expectedAssertionsNumberErrorGen: null,
+		get testPath() {
+			return getWorkerState().filepath;
+		},
+		currentTestName: test ? test.fullTestName ?? "" : globalState.currentTestName
+	}, expect);
+	expect.assert = chai.assert;
+	// @ts-expect-error untyped
+	expect.extend = (matchers) => chai.expect.extend(expect, matchers);
+	expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+	expect.soft = (...args) => {
+		// @ts-expect-error private soft access
+		return expect(...args).withContext({ soft: true });
+	};
+	expect.poll = createExpectPoll(expect);
+	expect.unreachable = (message) => {
+		chai.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+	};
+	function assertions(expected) {
+		const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
+		if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
+		expect.setState({
+			expectedAssertionsNumber: expected,
+			expectedAssertionsNumberErrorGen: errorGen
+		});
+	}
+	function hasAssertions() {
+		const error = /* @__PURE__ */ new Error("expected any number of assertion, but got none");
+		if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
+		expect.setState({
+			isExpectingAssertions: true,
+			isExpectingAssertionsError: error
+		});
+	}
+	chai.util.addMethod(expect, "assertions", assertions);
+	chai.util.addMethod(expect, "hasAssertions", hasAssertions);
+	expect.extend(customMatchers);
+	return expect;
+}
+const globalExpect = createExpect();
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
+	value: globalExpect,
+	writable: true,
+	configurable: true
+});
+const assert = chai.assert;
+const should = chai.should;
+
+/**
+* Gives access to injected context provided from the main thread.
+* This usually returns a value provided by `globalSetup` or an external library.
+*/
+function inject(key) {
+	return getWorkerState().providedContext[key];
+}
+
 function createBenchmarkResult(name) {
 	return {
 		name,
@@ -4274,4 +4427,4 @@ function clearModuleMocks(config) {
 	if (unstubGlobals) vi.unstubAllGlobals();
 }
 
-export { NodeBenchmarkRunner as N, TestRunner as T, assert as a, vitest as b, createExpect as c, globalExpect as g, inject as i, should as s, vi as v };
+export { NodeBenchmarkRunner as N, Snapshots as S, TestRunner as T, assert as a, vitest as b, createExpect as c, globalExpect as g, inject as i, should as s, vi as v };