@antdv-next/x-sdk 0.0.2 → 0.0.4

package/dist/node_modules/{vitest/dist/chunks/test.CBQUpOM3.js → .pnpm/vitest@4.1.10_@types_node@24.12.0_@vitest_browser-preview@4.1.10_@vitest_coverage-v8@4._55bf307888d746e7433721e12ae091d9/node_modules/vitest/dist/chunks/test.DNmyFkvJ.js}

@@ -1,320 +1,17 @@
-import { assertTypes, createSimpleStackTrace } from "../@vitest/utils/helpers.js";
-import { delay, getSafeTimers } from "../@vitest/utils/timers.js";
-import { parseSingleStack } from "../@vitest/utils/source-map.js";
-import { getCurrentTest, getNames } from "../@vitest/runner/chunk-artifact.js";
-import { getWorkerState, isChildProcess, resetModules, waitForImportsToResolve } from "./utils.BX5Fg8C4.js";
-import { clearAllMocks, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn } from "../@vitest/spy/index.js";
-import { Assertion, assert as assert$1, expect, use, utils_exports } from "../vendor/chai.js";
-import { ASYMMETRIC_MATCHERS_OBJECT, ChaiStyleAssertions, GLOBAL_EXPECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, addCustomEqualityTesters, createAssertionMessage, customMatchers, equals, getState, iterableEquality, recordAsyncExpect, setState, subsetEquality, wrapAssertion } from "../@vitest/expect/index.js";
-import { SnapshotClient, addSerializer, stripSnapshotIndentation } from "../@vitest/snapshot/index.js";
-import { commonjsGlobal } from "./_commonjsHelpers.D26ty3Ew.js";
-import { RealDate, mockDate, resetDate } from "./rpc.MzXet3jl.js";
-//#region ../../node_modules/vitest/dist/chunks/test.CBQUpOM3.js
-var 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;
-		const assertion = expect(null, message).withContext({ poll: true });
-		fn = fn.bind(assertion);
-		const test = utils_exports.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 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);
-					utils_exports.flag(assertion, "_name", key);
-					const onSettled = utils_exports.flag(assertion, "_poll.onSettled");
-					try {
-						while (true) {
-							const isLastAttempt = hasTimedOut;
-							if (isLastAttempt) utils_exports.flag(assertion, "_isLastPollAttempt", true);
-							try {
-								executionPhase = "fn";
-								const obj = await fn();
-								utils_exports.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" && utils_exports.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 = utils_exports.flag(assertion, "negate") ? "not." : "";
-						const assertionString = `expect.${utils_exports.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;
-				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;
-}
-var _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}`);
-		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
-	};
-}
-var 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);
-};
-use(JestExtend);
-use(JestChaiExpect);
-use(ChaiStyleAssertions);
-use(SnapshotPlugin);
-use(JestAsymmetricMatchers);
-function createExpect(test) {
-	const expect$1 = ((value, message) => {
-		const { assertionCalls } = getState(expect$1);
-		setState({ assertionCalls: assertionCalls + 1 }, expect$1);
-		const assert = expect(value, message);
-		const _test = test || getCurrentTest();
-		if (_test) return assert.withTest(_test);
-		else return assert;
-	});
-	Object.assign(expect$1, expect);
-	Object.assign(expect$1, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
-	expect$1.getState = () => getState(expect$1);
-	expect$1.setState = (state) => setState(state, expect$1);
-	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$1);
-	expect$1.assert = assert$1;
-	expect$1.extend = (matchers) => expect.extend(expect$1, matchers);
-	expect$1.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
-	expect$1.soft = (...args) => {
-		return expect$1(...args).withContext({ soft: true });
-	};
-	expect$1.poll = createExpectPoll(expect$1);
-	expect$1.unreachable = (message) => {
-		assert$1.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$1.getState().assertionCalls}`);
-		if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
-		expect$1.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$1.setState({
-			isExpectingAssertions: true,
-			isExpectingAssertionsError: error
-		});
-	}
-	utils_exports.addMethod(expect$1, "assertions", assertions);
-	utils_exports.addMethod(expect$1, "hasAssertions", hasAssertions);
-	expect$1.extend(customMatchers);
-	return expect$1;
-}
-var globalExpect = createExpect();
-Object.defineProperty(globalThis, GLOBAL_EXPECT, {
-	value: globalExpect,
-	writable: true,
-	configurable: true
-});
+import { assertTypes, createSimpleStackTrace } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/helpers.js";
+import { delay, getSafeTimers } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/timers.js";
+import { parseSingleStack } from "../../../../../@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/source-map.js";
+import { G as getNames, j as getCurrentTest } from "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/chunk-artifact.js";
+import "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/index.js";
+import "../../../../../@vitest_runner@4.1.10/node_modules/@vitest/runner/dist/utils.js";
+import { g as getWorkerState, i as isChildProcess, r as resetModules, w as waitForImportsToResolve } from "./utils.BX5Fg8C4.js";
+import { clearAllMocks, fn, isMockFunction, resetAllMocks, restoreAllMocks, spyOn } from "../../../../../@vitest_spy@4.1.10/node_modules/@vitest/spy/dist/index.js";
+import { Assertion, assert as assert$1, expect, use, util as utils_exports } from "../../../../../chai@6.2.2/node_modules/chai/index.js";
+import { ASYMMETRIC_MATCHERS_OBJECT, ChaiStyleAssertions, GLOBAL_EXPECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, addCustomEqualityTesters, createAssertionMessage, customMatchers, equals, getState, iterableEquality, recordAsyncExpect, setState, subsetEquality, wrapAssertion } from "../../../../../@vitest_expect@4.1.10/node_modules/@vitest/expect/dist/index.js";
+import { c as commonjsGlobal } from "./_commonjsHelpers.D26ty3Ew.js";
+import { R as RealDate, b as resetDate, m as mockDate } from "./rpc.MzXet3jl.js";
+import { SnapshotClient, addSerializer, stripSnapshotIndentation } from "../../../../../@vitest_snapshot@4.1.10/node_modules/@vitest/snapshot/dist/index.js";
+//#region ../../node_modules/.pnpm/vitest@4.1.10_@types+node@24.12.0_@vitest+browser-preview@4.1.10_@vitest+coverage-v8@4._55bf307888d746e7433721e12ae091d9/node_modules/vitest/dist/chunks/test.DNmyFkvJ.js
 var fakeTimersSrc = {};
 var global;
 var hasRequiredGlobal;
@@ -1396,7 +1093,8 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`);
 				const originalPerfDescriptor = Object.getOwnPropertyDescriptor(target, method);
 				if (originalPerfDescriptor && originalPerfDescriptor.get && !originalPerfDescriptor.set) {
 					Object.defineProperty(clock, `_${method}`, originalPerfDescriptor);
-					Object.defineProperty(target, method, Object.getOwnPropertyDescriptor(clock, method));
+					const perfDescriptor = Object.getOwnPropertyDescriptor(clock, method);
+					Object.defineProperty(target, method, perfDescriptor);
 				} else target[method] = clock[method];
 			} else {
 				target[method] = function() {
@@ -1831,7 +1529,8 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`);
 					clock.next();
 					checkIsNearInfiniteLimit(clock, i);
 				}
-				throw getInfiniteLoopError(clock, firstTimer(clock));
+				const excessJob = firstTimer(clock);
+				throw getInfiniteLoopError(clock, excessJob);
 			};
 			clock.runToFrame = function runToFrame() {
 				return clock.tick(getTimeToNextFrame());
@@ -1865,7 +1564,8 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`);
 									checkIsNearInfiniteLimit(clock, i);
 									return;
 								}
-								reject(getInfiniteLoopError(clock, firstTimer(clock)));
+								const excessJob = firstTimer(clock);
+								reject(getInfiniteLoopError(clock, excessJob));
 							} catch (e) {
 								reject(e);
 							}
@@ -1936,7 +1636,8 @@ To automatically clean-up native timers, use \`shouldClearNativeTimers\`.`);
 			return clock;
 		}
 		function createIntervalTick(clock, delta) {
-			clock.attachedInterval = originalSetInterval(doIntervalTick.bind(null, clock, delta), delta);
+			const intervalTick = doIntervalTick.bind(null, clock, delta);
+			clock.attachedInterval = originalSetInterval(intervalTick, delta);
 		}
 		/**
 		* @param {Config=} [config] Optional config
@@ -2309,7 +2010,7 @@ var FakeTimers = class {
 		return this._fakingTime;
 	}
 };
-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;
 }
@@ -2330,7 +2031,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 = () => {
@@ -2371,7 +2072,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) => {
@@ -2508,7 +2209,7 @@ function createVitest() {
 		waitUntil,
 		defineHelper: (fn) => {
 			return function __VITEST_HELPER__(...args) {
-				const result = fn(...args);
+				const result = fn.apply(this, args);
 				if (result && typeof result === "object" && typeof result.then === "function") return (async function __VITEST_HELPER__() {
 					return await result;
 				})();
@@ -2624,7 +2325,8 @@ function createVitest() {
 	};
 	return utils;
 }
-var vi = createVitest();
+var vitest = createVitest();
+var vi = vitest;
 function _mocker() {
 	return typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, { get(_, name) {
 		throw new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);
@@ -2636,5 +2338,359 @@ function getImporter(name) {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`) || stack.includes(` at ${name} (`);
 	}) + 1])?.file || "";
 }
+var 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;
+		const assertion = expect(null, message).withContext({ poll: true });
+		fn = fn.bind(assertion);
+		utils_exports.flag(assertion, "_poll.fn", fn);
+		utils_exports.flag(assertion, "_poll.timeout", timeout);
+		utils_exports.flag(assertion, "_poll.interval", interval);
+		const test = utils_exports.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 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 __VITEST_POLL_CHAIN__(...args) {
+				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+				const promise = async () => {
+					utils_exports.flag(assertion, "_name", key);
+					utils_exports.flag(assertion, "error", STACK_TRACE_ERROR);
+					const onSettled = utils_exports.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) utils_exports.flag(assertion, "_isLastPollAttempt", true);
+							try {
+								executionPhase = "fn";
+								const obj = await fn();
+								utils_exports.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" && utils_exports.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 = utils_exports.flag(assertion, "negate") ? "not." : "";
+						const assertionString = `expect.${utils_exports.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;
+				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;
+}
+var _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}`);
+		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 = utils_exports.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 = utils_exports.flag(obj, "vitest-test");
+	if (!test) throw new Error(`'${getAssertionName(obj)}' cannot be used without test context`);
+	return test;
+}
+function validateAssertion(assertion) {
+	if (utils_exports.flag(assertion, "negate")) throw new Error(`${getAssertionName(assertion)} cannot be used with "not"`);
+}
+var 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) {
+		utils.flag(this, "_name", "toMatchFileSnapshot");
+		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 normalizeArguments(propertiesOrHint, hint) {
+	if (typeof propertiesOrHint === "string") return { hint: propertiesOrHint };
+	return {
+		properties: propertiesOrHint,
+		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: utils_exports.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 }
+		});
+	}
+}
+use(JestExtend);
+use(JestChaiExpect);
+use(ChaiStyleAssertions);
+use(SnapshotPlugin);
+use(JestAsymmetricMatchers);
+function createExpect(test) {
+	const expect$1 = ((value, message) => {
+		const { assertionCalls } = getState(expect$1);
+		setState({ assertionCalls: assertionCalls + 1 }, expect$1);
+		const assert = expect(value, message);
+		const _test = test || getCurrentTest();
+		if (_test) return assert.withTest(_test);
+		else return assert;
+	});
+	Object.assign(expect$1, expect);
+	Object.assign(expect$1, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
+	expect$1.getState = () => getState(expect$1);
+	expect$1.setState = (state) => setState(state, expect$1);
+	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$1);
+	expect$1.assert = assert$1;
+	expect$1.extend = (matchers) => expect.extend(expect$1, matchers);
+	expect$1.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
+	expect$1.soft = (...args) => {
+		return expect$1(...args).withContext({ soft: true });
+	};
+	expect$1.poll = createExpectPoll(expect$1);
+	expect$1.unreachable = (message) => {
+		assert$1.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$1.getState().assertionCalls}`);
+		if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
+		expect$1.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$1.setState({
+			isExpectingAssertions: true,
+			isExpectingAssertionsError: error
+		});
+	}
+	utils_exports.addMethod(expect$1, "assertions", assertions);
+	utils_exports.addMethod(expect$1, "hasAssertions", hasAssertions);
+	expect$1.extend(customMatchers);
+	return expect$1;
+}
+var globalExpect = createExpect();
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
+	value: globalExpect,
+	writable: true,
+	configurable: true
+});
 //#endregion
-export { globalExpect, vi };
+export { vitest as b, createExpect as c, globalExpect as g, vi as v };