vitest 4.0.7 → 4.0.9

package/dist/chunks/{vi.BZvkKVkM.js → vi.CyIUVSoU.js}

@@ -1,7 +1,7 @@
 import { chai, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
 import { getCurrentTest } from '@vitest/runner';
 import { getNames, getTestName } from '@vitest/runner/utils';
-import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.CG9h5ccR.js';
+import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.DvEY5TfP.js';
 import { getSafeTimers } from '@vitest/utils/timers';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import '@vitest/utils/error';
@@ -10,7 +10,7 @@ import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunctio
 import '@vitest/utils/offset';
 import { parseSingleStack } from '@vitest/utils/source-map';
 import { c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.-jtEtIeV.js';
+import { R as RealDate, r as resetDate, m as mockDate } from './date.Bq6ZW5rf.js';
 
 // these matchers are not supported because they don't make sense with poll
 const unsupported = [
@@ -27,7 +27,10 @@ const unsupported = [
 ];
 function createExpectPoll(expect) {
 	return function poll(fn, options = {}) {
-		const defaults = getWorkerState().config.expect?.poll ?? {}, { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options, assertion = expect(null, message).withContext({ poll: true });
+		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");
@@ -37,31 +40,43 @@ function createExpectPoll(expect) {
 			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"), promise = () => new Promise((resolve, reject) => {
-					let intervalId, timeoutId, lastError;
-					const { setTimeout, clearTimeout } = getSafeTimers(), check = async () => {
+				const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+				const promise = () => new Promise((resolve, reject) => {
+					let intervalId;
+					let timeoutId;
+					let lastError;
+					const { setTimeout, clearTimeout } = getSafeTimers();
+					const check = async () => {
 						try {
 							chai.util.flag(assertion, "_name", key);
 							const obj = await fn();
-							chai.util.flag(assertion, "object", obj), resolve(await assertionFunction.call(assertion, ...args)), clearTimeout(intervalId), clearTimeout(timeoutId);
+							chai.util.flag(assertion, "object", obj);
+							resolve(await assertionFunction.call(assertion, ...args));
+							clearTimeout(intervalId);
+							clearTimeout(timeoutId);
 						} catch (err) {
-							if (lastError = err, !chai.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
+							lastError = err;
+							if (!chai.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
 						}
 					};
 					timeoutId = setTimeout(() => {
-						clearTimeout(intervalId), chai.util.flag(assertion, "_isLastPollAttempt", true);
+						clearTimeout(intervalId);
+						chai.util.flag(assertion, "_isLastPollAttempt", true);
 						const rejectWithCause = (error) => {
 							if (error.cause == null) error.cause = /* @__PURE__ */ new Error("Matcher did not succeed in time.");
 							reject(copyStackTrace$1(error, STACK_TRACE_ERROR));
 						};
 						check().then(() => rejectWithCause(lastError)).catch((e) => rejectWithCause(e));
-					}, timeout), check();
+					}, timeout);
+					check();
 				});
 				let awaited = false;
-				test.onFinished ??= [], test.onFinished.push(() => {
+				test.onFinished ??= [];
+				test.onFinished.push(() => {
 					if (!awaited) {
-						const negated = chai.util.flag(assertion, "negate") ? "not." : "", assertionString = `expect.${chai.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)"}.${negated}${String(key)}()`, error = /* @__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`);
-						throw copyStackTrace$1(error, STACK_TRACE_ERROR);
+						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;
@@ -69,7 +84,8 @@ function createExpectPoll(expect) {
 				// so let's follow it
 				return {
 					then(onFulfilled, onRejected) {
-						return awaited = true, (resultPromise ||= promise()).then(onFulfilled, onRejected);
+						awaited = true;
+						return (resultPromise ||= promise()).then(onFulfilled, onRejected);
 					},
 					catch(onRejected) {
 						return (resultPromise ||= promise()).catch(onRejected);
@@ -90,22 +106,27 @@ function copyStackTrace$1(target, source) {
 }
 
 function createAssertionMessage(util, assertion, hasArgs) {
-	const not = util.flag(assertion, "negate") ? "not." : "", name = `${util.flag(assertion, "_name")}(${"expected" })`, promiseName = util.flag(assertion, "promise");
+	const not = util.flag(assertion, "negate") ? "not." : "";
+	const name = `${util.flag(assertion, "_name")}(${"expected" })`;
+	const promiseName = util.flag(assertion, "promise");
 	return `expect(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
 }
 function recordAsyncExpect(_test, promise, assertion, error) {
 	const test = _test;
 	// record promise for test, that resolves before test ends
 	if (test && promise instanceof Promise) {
-		// record promise
-		if (promise = promise.finally(() => {
+		// if promise is explicitly awaited, remove it from the list
+		promise = promise.finally(() => {
 			if (!test.promises) return;
 			const index = test.promises.indexOf(promise);
 			if (index !== -1) test.promises.splice(index, 1);
-		}), !test.promises) test.promises = [];
+		});
+		// record promise
+		if (!test.promises) test.promises = [];
 		test.promises.push(promise);
 		let resolved = false;
-		return test.onFinished ??= [], test.onFinished.push(() => {
+		test.onFinished ??= [];
+		test.onFinished.push(() => {
 			if (!resolved) {
 				const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(error.stack);
 				console.warn([
@@ -115,9 +136,11 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 					stack
 				].join(""));
 			}
-		}), {
+		});
+		return {
 			then(onFulfilled, onRejected) {
-				return resolved = true, promise.then(onFulfilled, onRejected);
+				resolved = true;
+				return promise.then(onFulfilled, onRejected);
 			},
 			catch(onRejected) {
 				return promise.catch(onRejected);
@@ -165,9 +188,14 @@ const SnapshotPlugin = (chai, utils) => {
 		return test;
 	}
 	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
-		if (utils.flag(this, "_name", key), utils.flag(this, "negate")) throw new Error(`${key} cannot be used with "not"`);
-		const expected = utils.flag(this, "object"), test = getTest(key, this);
-		if (typeof properties === "string" && typeof message === "undefined") message = properties, properties = void 0;
+		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,
@@ -179,22 +207,33 @@ const SnapshotPlugin = (chai, utils) => {
 		});
 	});
 	utils.addMethod(chai.Assertion.prototype, "toMatchFileSnapshot", function(file, message) {
-		if (utils.flag(this, "_name", "toMatchFileSnapshot"), utils.flag(this, "negate")) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
-		const error = /* @__PURE__ */ new Error("resolves"), expected = utils.flag(this, "object"), test = getTest("toMatchFileSnapshot", this), errorMessage = utils.flag(this, "message"), promise = getSnapshotClient().assertRaw({
+		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)
-		});
-		return recordAsyncExpect(test, promise, createAssertionMessage(utils, this), error);
-	}), utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
-		if (utils.flag(this, "_name", "toMatchInlineSnapshot"), utils.flag(this, "negate")) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
+		}), createAssertionMessage(utils, this), error);
+	});
+	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(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);
 		if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-		const expected = utils.flag(this, "object"), error = utils.flag(this, "error");
-		if (typeof properties === "string") message = inlineSnapshot, inlineSnapshot = properties, properties = void 0;
+		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({
@@ -207,20 +246,29 @@ const SnapshotPlugin = (chai, utils) => {
 			errorMessage,
 			...getTestNames(test)
 		});
-	}), utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
-		if (utils.flag(this, "_name", "toThrowErrorMatchingSnapshot"), utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingSnapshot cannot be used with \"not\"");
-		const expected = utils.flag(this, "object"), test = getTest("toThrowErrorMatchingSnapshot", this), promise = utils.flag(this, "promise"), errorMessage = utils.flag(this, "message");
+	});
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(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", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+	});
+	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingInlineSnapshot", function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
 		if (utils.flag(this, "negate")) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
 		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
 		if (test.each || test.suite?.each) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-		const expected = utils.flag(this, "object"), error = utils.flag(this, "error"), promise = utils.flag(this, "promise"), errorMessage = utils.flag(this, "message");
+		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),
@@ -231,19 +279,30 @@ const SnapshotPlugin = (chai, utils) => {
 			errorMessage,
 			...getTestNames(test)
 		});
-	}), utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+	});
+	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 
-chai.use(JestExtend), chai.use(JestChaiExpect), chai.use(SnapshotPlugin), chai.use(JestAsymmetricMatchers);
+chai.use(JestExtend);
+chai.use(JestChaiExpect);
+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), _test = test || getCurrentTest();
-		return _test ? assert.withTest(_test) : assert;
+		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);
+	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({
@@ -257,10 +316,17 @@ function createExpect(test) {
 			return getWorkerState().filepath;
 		},
 		currentTestName: test ? getTestName(test) : globalState.currentTestName
-	}, expect), expect.assert = chai.assert, expect.extend = (matchers) => chai.expect.extend(expect, matchers), expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters), expect.soft = (...args) => {
+	}, 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) => {
+	};
+	expect.poll = createExpectPoll(expect);
+	expect.unreachable = (message) => {
 		chai.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
 	};
 	function assertions(expected) {
@@ -279,7 +345,10 @@ function createExpect(test) {
 			isExpectingAssertionsError: error
 		});
 	}
-	return chai.util.addMethod(expect, "assertions", assertions), chai.util.addMethod(expect, "hasAssertions", hasAssertions), expect.extend(customMatchers), expect;
+	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, {
@@ -515,7 +584,7 @@ var hasRequiredDeprecated;
 function requireDeprecated () {
 	if (hasRequiredDeprecated) return deprecated;
 	hasRequiredDeprecated = 1;
-	(function (exports) {
+	(function (exports$1) {
 
 		/**
 		 * Returns a function that will invoke the supplied function and print a
@@ -524,9 +593,9 @@ function requireDeprecated () {
 		 * @param  {string} msg
 		 * @returns {Function}
 		 */
-		exports.wrap = function (func, msg) {
+		exports$1.wrap = function (func, msg) {
 		    var wrapped = function () {
-		        exports.printWarning(msg);
+		        exports$1.printWarning(msg);
 		        return func.apply(this, arguments);
 		    };
 		    if (func.prototype) {
@@ -542,7 +611,7 @@ function requireDeprecated () {
 		 * @param  {string} funcName
 		 * @returns {string}
 		 */
-		exports.defaultMsg = function (packageName, funcName) {
+		exports$1.defaultMsg = function (packageName, funcName) {
 		    return `${packageName}.${funcName} is deprecated and will be removed from the public API in a future version of ${packageName}.`;
 		};
 
@@ -551,7 +620,7 @@ function requireDeprecated () {
 		 * @param  {string} msg
 		 * @returns {undefined}
 		 */
-		exports.printWarning = function (msg) {
+		exports$1.printWarning = function (msg) {
 		    /* istanbul ignore next */
 		    if (typeof process === "object" && process.emitWarning) {
 		        // Emit Warnings in Node
@@ -770,7 +839,7 @@ var hasRequiredTypeDetect;
 function requireTypeDetect () {
 	if (hasRequiredTypeDetect) return typeDetect$1.exports;
 	hasRequiredTypeDetect = 1;
-	(function (module, exports) {
+	(function (module, exports$1) {
 		(function (global, factory) {
 			module.exports = factory() ;
 		}(typeDetect, (function () {
@@ -3406,7 +3475,11 @@ class FakeTimers {
 	_userConfig;
 	_now = RealDate.now;
 	constructor({ global, config }) {
-		this._userConfig = config, this._fakingDate = null, this._fakingTime = false, this._fakeTimers = fakeTimersSrcExports.withGlobal(global), this._global = global;
+		this._userConfig = config;
+		this._fakingDate = null;
+		this._fakingTime = false;
+		this._fakeTimers = fakeTimersSrcExports.withGlobal(global);
+		this._global = global;
 	}
 	clearAllTimers() {
 		if (this._fakingTime) this._clock.reset();
@@ -3427,13 +3500,19 @@ class FakeTimers {
 		if (this._checkFakeTimers()) await this._clock.runToLastAsync();
 	}
 	advanceTimersToNextTimer(steps = 1) {
-		if (this._checkFakeTimers()) {
-			for (let i = steps; i > 0; i--) if (this._clock.next(), this._clock.tick(0), this._clock.countTimers() === 0) break;
+		if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+			this._clock.next();
+			// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250
+			this._clock.tick(0);
+			if (this._clock.countTimers() === 0) break;
 		}
 	}
 	async advanceTimersToNextTimerAsync(steps = 1) {
-		if (this._checkFakeTimers()) {
-			for (let i = steps; i > 0; i--) if (await this._clock.nextAsync(), this._clock.tick(0), this._clock.countTimers() === 0) break;
+		if (this._checkFakeTimers()) for (let i = steps; i > 0; i--) {
+			await this._clock.nextAsync();
+			// Fire all timers at this point: https://github.com/sinonjs/fake-timers/issues/250
+			this._clock.tick(0);
+			if (this._clock.countTimers() === 0) break;
 		}
 	}
 	advanceTimersByTime(msToRun) {
@@ -3451,12 +3530,21 @@ class FakeTimers {
 		this._clock.runMicrotasks();
 	}
 	useRealTimers() {
-		if (this._fakingDate) resetDate(), this._fakingDate = null;
-		if (this._fakingTime) this._clock.uninstall(), this._fakingTime = false;
+		if (this._fakingDate) {
+			resetDate();
+			this._fakingDate = null;
+		}
+		if (this._fakingTime) {
+			this._clock.uninstall();
+			this._fakingTime = false;
+		}
 	}
 	useFakeTimers() {
 		const fakeDate = this._fakingDate || Date.now();
-		if (this._fakingDate) resetDate(), this._fakingDate = null;
+		if (this._fakingDate) {
+			resetDate();
+			this._fakingDate = null;
+		}
 		if (this._fakingTime) this._clock.uninstall();
 		const toFake = Object.keys(this._fakeTimers.timers).filter((timer) => timer !== "nextTick" && timer !== "queueMicrotask");
 		if (this._userConfig?.toFake?.includes("nextTick") && isChildProcess()) throw new Error("process.nextTick cannot be mocked inside child_process");
@@ -3465,18 +3553,23 @@ class FakeTimers {
 			...this._userConfig,
 			toFake: this._userConfig?.toFake || toFake,
 			ignoreMissingTimers: true
-		}), this._fakingTime = true;
+		});
+		this._fakingTime = true;
 	}
 	reset() {
 		if (this._checkFakeTimers()) {
 			const { now } = this._clock;
-			this._clock.reset(), this._clock.setSystemTime(now);
+			this._clock.reset();
+			this._clock.setSystemTime(now);
 		}
 	}
 	setSystemTime(now) {
 		const date = typeof now === "undefined" || now instanceof Date ? now : new Date(now);
 		if (this._fakingTime) this._clock.setSystemTime(date);
-		else this._fakingDate = date ?? new Date(this.getRealSystemTime()), mockDate(this._fakingDate);
+		else {
+			this._fakingDate = date ?? new Date(this.getRealSystemTime());
+			mockDate(this._fakingDate);
+		}
 	}
 	getMockedSystemTime() {
 		return this._fakingTime ? new Date(this._clock.now) : this._fakingDate;
@@ -3485,7 +3578,8 @@ class FakeTimers {
 		return this._now();
 	}
 	getTimerCount() {
-		return this._checkFakeTimers() ? this._clock.countTimers() : 0;
+		if (this._checkFakeTimers()) return this._clock.countTimers();
+		return 0;
 	}
 	configure(config) {
 		this._userConfig = config;
@@ -3504,68 +3598,96 @@ function copyStackTrace(target, source) {
 	return target;
 }
 function waitFor(callback, options = {}) {
-	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers(), { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options, STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
 	return new Promise((resolve, reject) => {
-		let lastError, promiseStatus = "idle", timeoutId, intervalId;
+		let lastError;
+		let promiseStatus = "idle";
+		let timeoutId;
+		let intervalId;
 		const onResolve = (result) => {
 			if (timeoutId) clearTimeout(timeoutId);
 			if (intervalId) clearInterval(intervalId);
 			resolve(result);
-		}, handleTimeout = () => {
+		};
+		const handleTimeout = () => {
 			if (intervalId) clearInterval(intervalId);
 			let error = lastError;
 			if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
 			reject(error);
-		}, checkCallback = () => {
+		};
+		const checkCallback = () => {
 			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
-			if (promiseStatus !== "pending") try {
+			if (promiseStatus === "pending") return;
+			try {
 				const result = callback();
 				if (result !== null && typeof result === "object" && typeof result.then === "function") {
 					const thenable = result;
-					promiseStatus = "pending", thenable.then((resolvedValue) => {
-						promiseStatus = "resolved", onResolve(resolvedValue);
+					promiseStatus = "pending";
+					thenable.then((resolvedValue) => {
+						promiseStatus = "resolved";
+						onResolve(resolvedValue);
 					}, (rejectedValue) => {
-						promiseStatus = "rejected", lastError = rejectedValue;
+						promiseStatus = "rejected";
+						lastError = rejectedValue;
 					});
-				} else return onResolve(result), true;
+				} else {
+					onResolve(result);
+					return true;
+				}
 			} catch (error) {
 				lastError = error;
 			}
 		};
-		checkCallback() !== true && (timeoutId = setTimeout(handleTimeout, timeout), intervalId = setInterval(checkCallback, interval));
+		if (checkCallback() === true) return;
+		timeoutId = setTimeout(handleTimeout, timeout);
+		intervalId = setInterval(checkCallback, interval);
 	});
 }
 function waitUntil(callback, options = {}) {
-	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers(), { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options, STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
+	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
+	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
+	const STACK_TRACE_ERROR = /* @__PURE__ */ new Error("STACK_TRACE_ERROR");
 	return new Promise((resolve, reject) => {
-		let promiseStatus = "idle", timeoutId, intervalId;
+		let promiseStatus = "idle";
+		let timeoutId;
+		let intervalId;
 		const onReject = (error) => {
 			if (intervalId) clearInterval(intervalId);
 			if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
 			reject(error);
-		}, onResolve = (result) => {
-			if (result) {
-				if (timeoutId) clearTimeout(timeoutId);
-				if (intervalId) clearInterval(intervalId);
-				return resolve(result), true;
-			}
-		}, checkCallback = () => {
+		};
+		const onResolve = (result) => {
+			if (!result) return;
+			if (timeoutId) clearTimeout(timeoutId);
+			if (intervalId) clearInterval(intervalId);
+			resolve(result);
+			return true;
+		};
+		const checkCallback = () => {
 			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
-			if (promiseStatus !== "pending") try {
+			if (promiseStatus === "pending") return;
+			try {
 				const result = callback();
 				if (result !== null && typeof result === "object" && typeof result.then === "function") {
 					const thenable = result;
-					promiseStatus = "pending", thenable.then((resolvedValue) => {
-						promiseStatus = "resolved", onResolve(resolvedValue);
+					promiseStatus = "pending";
+					thenable.then((resolvedValue) => {
+						promiseStatus = "resolved";
+						onResolve(resolvedValue);
 					}, (rejectedValue) => {
-						promiseStatus = "rejected", onReject(rejectedValue);
+						promiseStatus = "rejected";
+						onReject(rejectedValue);
 					});
 				} else return onResolve(result);
 			} catch (error) {
 				onReject(error);
 			}
 		};
-		checkCallback() !== true && (timeoutId = setTimeout(onReject, timeout), intervalId = setInterval(checkCallback, interval));
+		if (checkCallback() === true) return;
+		timeoutId = setTimeout(onReject, timeout);
+		intervalId = setInterval(checkCallback, interval);
 	});
 }
 
@@ -3576,11 +3698,15 @@ function createVitest() {
 	const timers = () => _timers ||= new FakeTimers({
 		global: globalThis,
 		config: state().config.fakeTimers
-	}), _stubsGlobal = /* @__PURE__ */ new Map(), _stubsEnv = /* @__PURE__ */ new Map(), _envBooleans = [
+	});
+	const _stubsGlobal = /* @__PURE__ */ new Map();
+	const _stubsEnv = /* @__PURE__ */ new Map();
+	const _envBooleans = [
 		"PROD",
 		"DEV",
 		"SSR"
-	], utils = {
+	];
+	const utils = {
 		useFakeTimers(config) {
 			if (isChildProcess()) {
 				if (config?.toFake?.includes("nextTick") || state().config?.fakeTimers?.toFake?.includes("nextTick")) throw new Error("vi.useFakeTimers({ toFake: [\"nextTick\"] }) is not supported in node:child_process. Use --pool=threads if mocking nextTick is required.");
@@ -3590,49 +3716,62 @@ function createVitest() {
 				...config
 			});
 			else timers().configure(state().config.fakeTimers);
-			return timers().useFakeTimers(), utils;
+			timers().useFakeTimers();
+			return utils;
 		},
 		isFakeTimers() {
 			return timers().isFakeTimers();
 		},
 		useRealTimers() {
-			return timers().useRealTimers(), utils;
+			timers().useRealTimers();
+			return utils;
 		},
 		runOnlyPendingTimers() {
-			return timers().runOnlyPendingTimers(), utils;
+			timers().runOnlyPendingTimers();
+			return utils;
 		},
 		async runOnlyPendingTimersAsync() {
-			return await timers().runOnlyPendingTimersAsync(), utils;
+			await timers().runOnlyPendingTimersAsync();
+			return utils;
 		},
 		runAllTimers() {
-			return timers().runAllTimers(), utils;
+			timers().runAllTimers();
+			return utils;
 		},
 		async runAllTimersAsync() {
-			return await timers().runAllTimersAsync(), utils;
+			await timers().runAllTimersAsync();
+			return utils;
 		},
 		runAllTicks() {
-			return timers().runAllTicks(), utils;
+			timers().runAllTicks();
+			return utils;
 		},
 		advanceTimersByTime(ms) {
-			return timers().advanceTimersByTime(ms), utils;
+			timers().advanceTimersByTime(ms);
+			return utils;
 		},
 		async advanceTimersByTimeAsync(ms) {
-			return await timers().advanceTimersByTimeAsync(ms), utils;
+			await timers().advanceTimersByTimeAsync(ms);
+			return utils;
 		},
 		advanceTimersToNextTimer() {
-			return timers().advanceTimersToNextTimer(), utils;
+			timers().advanceTimersToNextTimer();
+			return utils;
 		},
 		async advanceTimersToNextTimerAsync() {
-			return await timers().advanceTimersToNextTimerAsync(), utils;
+			await timers().advanceTimersToNextTimerAsync();
+			return utils;
 		},
 		advanceTimersToNextFrame() {
-			return timers().advanceTimersToNextFrame(), utils;
+			timers().advanceTimersToNextFrame();
+			return utils;
 		},
 		getTimerCount() {
 			return timers().getTimerCount();
 		},
 		setSystemTime(time) {
-			return timers().setSystemTime(time), utils;
+			timers().setSystemTime(time);
+			return utils;
 		},
 		getMockedSystemTime() {
 			return timers().getMockedSystemTime();
@@ -3641,14 +3780,16 @@ function createVitest() {
 			return timers().getRealSystemTime();
 		},
 		clearAllTimers() {
-			return timers().clearAllTimers(), utils;
+			timers().clearAllTimers();
+			return utils;
 		},
 		spyOn,
 		fn,
 		waitFor,
 		waitUntil,
 		hoisted(factory) {
-			return assertTypes(factory, "\"vi.hoisted\" factory", ["function"]), factory();
+			assertTypes(factory, "\"vi.hoisted\" factory", ["function"]);
+			return factory();
 		},
 		mock(path, factory) {
 			if (typeof path !== "string") throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
@@ -3687,22 +3828,26 @@ function createVitest() {
 			return isMockFunction(fn);
 		},
 		clearAllMocks() {
-			return clearAllMocks(), utils;
+			clearAllMocks();
+			return utils;
 		},
 		resetAllMocks() {
-			return resetAllMocks(), utils;
+			resetAllMocks();
+			return utils;
 		},
 		restoreAllMocks() {
-			return restoreAllMocks(), utils;
+			restoreAllMocks();
+			return utils;
 		},
 		stubGlobal(name, value) {
 			if (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
-			return Object.defineProperty(globalThis, name, {
+			Object.defineProperty(globalThis, name, {
 				value,
 				writable: true,
 				configurable: true,
 				enumerable: true
-			}), utils;
+			});
+			return utils;
 		},
 		stubEnv(name, value) {
 			const env = state().metaEnv;
@@ -3713,20 +3858,25 @@ function createVitest() {
 			return utils;
 		},
 		unstubAllGlobals() {
-			return _stubsGlobal.forEach((original, name) => {
+			_stubsGlobal.forEach((original, name) => {
 				if (!original) Reflect.deleteProperty(globalThis, name);
 				else Object.defineProperty(globalThis, name, original);
-			}), _stubsGlobal.clear(), utils;
+			});
+			_stubsGlobal.clear();
+			return utils;
 		},
 		unstubAllEnvs() {
 			const env = state().metaEnv;
-			return _stubsEnv.forEach((original, name) => {
+			_stubsEnv.forEach((original, name) => {
 				if (original === void 0) delete env[name];
 				else env[name] = original;
-			}), _stubsEnv.clear(), utils;
+			});
+			_stubsEnv.clear();
+			return utils;
 		},
 		resetModules() {
-			return resetModules(state().evaluatedModules), utils;
+			resetModules(state().evaluatedModules);
+			return utils;
 		},
 		async dynamicImportSettled() {
 			return waitForImportsToResolve();
@@ -3750,10 +3900,10 @@ function _mocker() {
 	} });
 }
 function getImporter(name) {
-	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n"), importerStackIndex = stackArray.findLastIndex((stack) => {
+	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n");
+	return parseSingleStack(stackArray[stackArray.findLastIndex((stack) => {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
-	});
-	return parseSingleStack(stackArray[importerStackIndex + 1])?.file || "";
+	}) + 1])?.file || "";
 }
 
 export { getSnapshotClient as a, assert as b, createExpect as c, vitest as d, globalExpect as g, inject as i, should as s, vi as v };