vitest 4.0.0-beta.1 → 4.0.0-beta.11

package/dist/chunks/{vi.bdSIJ99Y.js → vi.CiJ0Laa6.js}

@@ -1,15 +1,16 @@
-import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
+import { chai as chai$1, 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 * as chai$1 from 'chai';
-import { g as getWorkerState, a as getCurrentEnvironment, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.XdZDrNZV.js';
-import { getSafeTimers, assertTypes, createSimpleStackTrace } from '@vitest/utils';
+import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.DGKhod2J.js';
+import { getSafeTimers } from '@vitest/utils/timers';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.js';
 import { stripSnapshotIndentation, addSerializer, SnapshotClient } from '@vitest/snapshot';
 import '@vitest/utils/error';
-import { fn, spyOn, mocks, isMockFunction } from '@vitest/spy';
+import { assertTypes, createSimpleStackTrace } from '@vitest/utils/helpers';
+import { fn, spyOn, restoreAllMocks, resetAllMocks, clearAllMocks, isMockFunction } from '@vitest/spy';
+import '@vitest/utils/offset';
 import { parseSingleStack } from '@vitest/utils/source-map';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.Bq6ZW5rf.js';
+import { R as RealDate, r as resetDate, m as mockDate } from './date.-jtEtIeV.js';
 
 // these matchers are not supported because they don't make sense with poll
 const unsupported = [
@@ -26,11 +27,7 @@ const unsupported = [
 ];
 function createExpectPoll(expect) {
 	return function poll(fn, options = {}) {
-		const state = getWorkerState();
-		const defaults = state.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 });
+		const state = getWorkerState(), defaults = state.config.expect?.poll ?? {}, { interval = defaults.interval ?? 50, timeout = defaults.timeout ?? 1e3, message } = options, assertion = expect(null, message).withContext({ poll: true });
 		fn = fn.bind(assertion);
 		const test = chai$1.util.flag(assertion, "vitest-test");
 		if (!test) throw new Error("expect.poll() must be called inside a test");
@@ -40,43 +37,30 @@ 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 = new Error("STACK_TRACE_ERROR");
-				const promise = () => new Promise((resolve, reject) => {
-					let intervalId;
-					let timeoutId;
-					let lastError;
-					const { setTimeout, clearTimeout } = getSafeTimers();
-					const check = async () => {
+				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 () => {
 						try {
 							chai$1.util.flag(assertion, "_name", key);
 							const obj = await fn();
-							chai$1.util.flag(assertion, "object", obj);
-							resolve(await assertionFunction.call(assertion, ...args));
-							clearTimeout(intervalId);
-							clearTimeout(timeoutId);
+							chai$1.util.flag(assertion, "object", obj), resolve(await assertionFunction.call(assertion, ...args)), clearTimeout(intervalId), clearTimeout(timeoutId);
 						} catch (err) {
-							lastError = err;
-							if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
+							if (lastError = err, !chai$1.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
 						}
 					};
 					timeoutId = setTimeout(() => {
-						clearTimeout(intervalId);
-						chai$1.util.flag(assertion, "_isLastPollAttempt", true);
-						const rejectWithCause = (cause) => {
-							reject(copyStackTrace$1(new Error("Matcher did not succeed in time.", { cause }), STACK_TRACE_ERROR));
+						clearTimeout(intervalId), chai$1.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$1.util.flag(assertion, "negate") ? "not." : "";
-						const name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)";
-						const assertionString = `expect.${name}.${negated}${String(key)}()`;
-						const error = 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`);
+						const negated = chai$1.util.flag(assertion, "negate") ? "not." : "", name = chai$1.util.flag(assertion, "_poll.element") ? "element(locator)" : "poll(assertion)", assertionString = `expect.${name}.${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);
 					}
 				});
@@ -85,8 +69,7 @@ function createExpectPoll(expect) {
 				// so let's follow it
 				return {
 					then(onFulfilled, onRejected) {
-						awaited = true;
-						return (resultPromise ||= promise()).then(onFulfilled, onRejected);
+						return awaited = true, (resultPromise ||= promise()).then(onFulfilled, onRejected);
 					},
 					catch(onRejected) {
 						return (resultPromise ||= promise()).catch(onRejected);
@@ -206,31 +189,24 @@ var chaiSubsetExports = requireChaiSubset();
 var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
 
 function createAssertionMessage(util, assertion, hasArgs) {
-	const not = util.flag(assertion, "negate") ? "not." : "";
-	const name = `${util.flag(assertion, "_name")}(${"expected" })`;
-	const promiseName = util.flag(assertion, "promise");
-	const promise = promiseName ? `.${promiseName}` : "";
+	const not = util.flag(assertion, "negate") ? "not." : "", name = `${util.flag(assertion, "_name")}(${"expected" })`, promiseName = util.flag(assertion, "promise"), promise = promiseName ? `.${promiseName}` : "";
 	return `expect(actual)${promise}.${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) {
-		// if promise is explicitly awaited, remove it from the list
-		promise = promise.finally(() => {
+		// record promise
+		if (promise = promise.finally(() => {
 			if (!test.promises) return;
 			const index = test.promises.indexOf(promise);
 			if (index !== -1) test.promises.splice(index, 1);
-		});
-		// record promise
-		if (!test.promises) test.promises = [];
+		}), !test.promises) test.promises = [];
 		test.promises.push(promise);
 		let resolved = false;
-		test.onFinished ??= [];
-		test.onFinished.push(() => {
+		return test.onFinished ??= [], test.onFinished.push(() => {
 			if (!resolved) {
-				const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || "");
-				const stack = processor(error.stack);
+				const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""), stack = processor(error.stack);
 				console.warn([
 					`Promise returned by \`${assertion}\` was not awaited. `,
 					"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in Vitest 3. ",
@@ -238,11 +214,9 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 					stack
 				].join(""));
 			}
-		});
-		return {
+		}), {
 			then(onFulfilled, onRejected) {
-				resolved = true;
-				return promise.then(onFulfilled, onRejected);
+				return resolved = true, promise.then(onFulfilled, onRejected);
 			},
 			catch(onRejected) {
 				return promise.catch(onRejected);
@@ -293,12 +267,8 @@ const SnapshotPlugin = (chai, utils) => {
 		utils.flag(this, "_name", key);
 		const isNot = utils.flag(this, "negate");
 		if (isNot) 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 expected = utils.flag(this, "object"), 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,
@@ -313,11 +283,7 @@ const SnapshotPlugin = (chai, utils) => {
 		utils.flag(this, "_name", "toMatchFileSnapshot");
 		const isNot = utils.flag(this, "negate");
 		if (isNot) throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
-		const error = new Error("resolves");
-		const expected = utils.flag(this, "object");
-		const test = getTest("toMatchFileSnapshot", this);
-		const errorMessage = utils.flag(this, "message");
-		const promise = getSnapshotClient().assertRaw({
+		const error = /* @__PURE__ */ new Error("resolves"), expected = utils.flag(this, "object"), test = getTest("toMatchFileSnapshot", this), errorMessage = utils.flag(this, "message"), promise = getSnapshotClient().assertRaw({
 			received: expected,
 			message,
 			isInline: false,
@@ -326,21 +292,14 @@ const SnapshotPlugin = (chai, utils) => {
 			...getTestNames(test)
 		});
 		return recordAsyncExpect(test, promise, createAssertionMessage(utils, this), error);
-	});
-	utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
+	}), utils.addMethod(chai.Assertion.prototype, "toMatchInlineSnapshot", function __INLINE_SNAPSHOT__(properties, inlineSnapshot, message) {
 		utils.flag(this, "_name", "toMatchInlineSnapshot");
 		const isNot = utils.flag(this, "negate");
 		if (isNot) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
-		const test = getTest("toMatchInlineSnapshot", this);
-		const isInsideEach = test.each || test.suite?.each;
+		const test = getTest("toMatchInlineSnapshot", this), isInsideEach = test.each || test.suite?.each;
 		if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-		const expected = utils.flag(this, "object");
-		const error = utils.flag(this, "error");
-		if (typeof properties === "string") {
-			message = inlineSnapshot;
-			inlineSnapshot = properties;
-			properties = void 0;
-		}
+		const expected = utils.flag(this, "object"), 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({
@@ -353,32 +312,23 @@ const SnapshotPlugin = (chai, utils) => {
 			errorMessage,
 			...getTestNames(test)
 		});
-	});
-	utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
+	}), utils.addMethod(chai.Assertion.prototype, "toThrowErrorMatchingSnapshot", function(message) {
 		utils.flag(this, "_name", "toThrowErrorMatchingSnapshot");
 		const isNot = utils.flag(this, "negate");
 		if (isNot) 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");
+		const expected = utils.flag(this, "object"), test = getTest("toThrowErrorMatchingSnapshot", this), promise = utils.flag(this, "promise"), 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) {
 		const isNot = utils.flag(this, "negate");
 		if (isNot) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
-		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
-		const isInsideEach = test.each || test.suite?.each;
+		const test = getTest("toThrowErrorMatchingInlineSnapshot", this), isInsideEach = test.each || test.suite?.each;
 		if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
-		const expected = utils.flag(this, "object");
-		const error = utils.flag(this, "error");
-		const promise = utils.flag(this, "promise");
-		const errorMessage = utils.flag(this, "message");
+		const expected = utils.flag(this, "object"), error = utils.flag(this, "error"), promise = utils.flag(this, "promise"), errorMessage = utils.flag(this, "message");
 		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
 		getSnapshotClient().assert({
 			received: getError(expected, promise),
@@ -389,31 +339,19 @@ const SnapshotPlugin = (chai, utils) => {
 			errorMessage,
 			...getTestNames(test)
 		});
-	});
-	utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
+	}), utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 
-chai$1.use(JestExtend);
-chai$1.use(JestChaiExpect);
-chai$1.use(Subset);
-chai$1.use(SnapshotPlugin);
-chai$1.use(JestAsymmetricMatchers);
+chai$1.use(JestExtend), chai$1.use(JestChaiExpect), chai$1.use(Subset), chai$1.use(SnapshotPlugin), chai$1.use(JestAsymmetricMatchers);
 
 function createExpect(test) {
-	const expect = (value, message) => {
+	const expect = ((value, message) => {
 		const { assertionCalls } = getState(expect);
 		setState({ assertionCalls: assertionCalls + 1 }, expect);
-		const assert = chai$1.expect(value, message);
-		const _test = test || getCurrentTest();
-		if (_test)
- // @ts-expect-error internal
-		return assert.withTest(_test);
-		else return assert;
-	};
-	Object.assign(expect, chai$1.expect);
-	Object.assign(expect, globalThis[ASYMMETRIC_MATCHERS_OBJECT]);
-	expect.getState = () => getState(expect);
-	expect.setState = (state) => setState(state, expect);
+		const assert = chai$1.expect(value, message), _test = test || getCurrentTest();
+		return _test ? assert.withTest(_test) : assert;
+	});
+	Object.assign(expect, chai$1.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({
@@ -423,25 +361,18 @@ function createExpect(test) {
 		isExpectingAssertionsError: null,
 		expectedAssertionsNumber: null,
 		expectedAssertionsNumberErrorGen: null,
-		environment: getCurrentEnvironment(),
 		get testPath() {
 			return getWorkerState().filepath;
 		},
 		currentTestName: test ? getTestName(test) : globalState.currentTestName
-	}, expect);
-	// @ts-expect-error untyped
-	expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
-	expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters);
-	expect.soft = (...args) => {
+	}, expect), expect.extend = (matchers) => chai$1.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$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
 	};
 	function assertions(expected) {
-		const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
+		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,
@@ -449,17 +380,14 @@ function createExpect(test) {
 		});
 	}
 	function hasAssertions() {
-		const error = new Error("expected any number of assertion, but got none");
+		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$1.util.addMethod(expect, "assertions", assertions);
-	chai$1.util.addMethod(expect, "hasAssertions", hasAssertions);
-	expect.extend(customMatchers);
-	return expect;
+	return chai$1.util.addMethod(expect, "assertions", assertions), chai$1.util.addMethod(expect, "hasAssertions", hasAssertions), expect.extend(customMatchers), expect;
 }
 const globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT, {
@@ -467,6 +395,8 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
 	writable: true,
 	configurable: true
 });
+const assert = chai$1.assert;
+const should = chai$1.should;
 
 /**
 * Gives access to injected context provided from the main thread.
@@ -3576,20 +3506,16 @@ class FakeTimers {
 	// | _fakingTime | _fakingDate |
 	// +-------------+-------------+
 	// | false       | falsy       | initial
-	// | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
+	// | false       | truthy      | vi.setSystemTime called first (for mocking only Date without fake timers)
 	// | true        | falsy       | vi.useFakeTimers called first
-	// | true        | truthy     | unreachable
+	// | true        | truthy      | unreachable
 	_fakingTime;
 	_fakingDate;
 	_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();
@@ -3610,19 +3536,13 @@ class FakeTimers {
 		if (this._checkFakeTimers()) await this._clock.runToLastAsync();
 	}
 	advanceTimersToNextTimer(steps = 1) {
-		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;
+		if (this._checkFakeTimers()) {
+			for (let i = steps; i > 0; i--) if (this._clock.next(), this._clock.tick(0), this._clock.countTimers() === 0) break;
 		}
 	}
 	async advanceTimersToNextTimerAsync(steps = 1) {
-		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;
+		if (this._checkFakeTimers()) {
+			for (let i = steps; i > 0; i--) if (await this._clock.nextAsync(), this._clock.tick(0), this._clock.countTimers() === 0) break;
 		}
 	}
 	advanceTimersByTime(msToRun) {
@@ -3640,43 +3560,32 @@ 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() {
-		if (this._fakingDate) throw new Error("\"setSystemTime\" was called already and date was mocked. Reset timers using `vi.useRealTimers()` if you want to use fake timers again.");
-		if (!this._fakingTime) {
-			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");
-			this._clock = this._fakeTimers.install({
-				now: Date.now(),
-				...this._userConfig,
-				toFake: this._userConfig?.toFake || toFake,
-				ignoreMissingTimers: true
-			});
-			this._fakingTime = true;
-		}
+		const fakeDate = this._fakingDate || Date.now();
+		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");
+		this._clock = this._fakeTimers.install({
+			now: fakeDate,
+			...this._userConfig,
+			toFake: this._userConfig?.toFake || toFake,
+			ignoreMissingTimers: 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;
@@ -3685,8 +3594,7 @@ class FakeTimers {
 		return this._now();
 	}
 	getTimerCount() {
-		if (this._checkFakeTimers()) return this._clock.countTimers();
-		return 0;
+		return this._checkFakeTimers() ? this._clock.countTimers() : 0;
 	}
 	configure(config) {
 		this._userConfig = config;
@@ -3695,7 +3603,7 @@ class FakeTimers {
 		return this._fakingTime;
 	}
 	_checkFakeTimers() {
-		if (!this._fakingTime) throw new Error("Timers are not mocked. Try calling \"vi.useFakeTimers()\" first.");
+		if (!this._fakingTime) throw new Error("A function to advance timers was called but the timers APIs are not mocked. Call `vi.useFakeTimers()` in the test file first.");
 		return this._fakingTime;
 	}
 }
@@ -3705,180 +3613,135 @@ function copyStackTrace(target, source) {
 	return target;
 }
 function waitFor(callback, options = {}) {
-	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
-	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-	const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+	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");
 	return new Promise((resolve, reject) => {
-		let lastError;
-		let promiseStatus = "idle";
-		let timeoutId;
-		let intervalId;
+		let lastError, promiseStatus = "idle", timeoutId, intervalId;
 		const onResolve = (result) => {
 			if (timeoutId) clearTimeout(timeoutId);
 			if (intervalId) clearInterval(intervalId);
 			resolve(result);
-		};
-		const handleTimeout = () => {
+		}, handleTimeout = () => {
 			if (intervalId) clearInterval(intervalId);
 			let error = lastError;
-			if (!error) error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
+			if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
 			reject(error);
-		};
-		const checkCallback = () => {
+		}, checkCallback = () => {
 			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
-			if (promiseStatus === "pending") return;
-			try {
+			if (promiseStatus !== "pending") 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 {
-					onResolve(result);
-					return true;
-				}
+				} else return onResolve(result), true;
 			} catch (error) {
 				lastError = error;
 			}
 		};
-		if (checkCallback() === true) return;
-		timeoutId = setTimeout(handleTimeout, timeout);
-		intervalId = setInterval(checkCallback, interval);
+		checkCallback() !== true && (timeoutId = setTimeout(handleTimeout, timeout), intervalId = setInterval(checkCallback, interval));
 	});
 }
 function waitUntil(callback, options = {}) {
-	const { setTimeout, setInterval, clearTimeout, clearInterval } = getSafeTimers();
-	const { interval = 50, timeout = 1e3 } = typeof options === "number" ? { timeout: options } : options;
-	const STACK_TRACE_ERROR = new Error("STACK_TRACE_ERROR");
+	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");
 	return new Promise((resolve, reject) => {
-		let promiseStatus = "idle";
-		let timeoutId;
-		let intervalId;
+		let promiseStatus = "idle", timeoutId, intervalId;
 		const onReject = (error) => {
 			if (intervalId) clearInterval(intervalId);
-			if (!error) error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
+			if (!error) error = copyStackTrace(/* @__PURE__ */ new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
 			reject(error);
-		};
-		const onResolve = (result) => {
-			if (!result) return;
-			if (timeoutId) clearTimeout(timeoutId);
-			if (intervalId) clearInterval(intervalId);
-			resolve(result);
-			return true;
-		};
-		const checkCallback = () => {
+		}, onResolve = (result) => {
+			if (result) {
+				if (timeoutId) clearTimeout(timeoutId);
+				if (intervalId) clearInterval(intervalId);
+				return resolve(result), true;
+			}
+		}, checkCallback = () => {
 			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
-			if (promiseStatus === "pending") return;
-			try {
+			if (promiseStatus !== "pending") 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);
 			}
 		};
-		if (checkCallback() === true) return;
-		timeoutId = setTimeout(onReject, timeout);
-		intervalId = setInterval(checkCallback, interval);
+		checkCallback() !== true && (timeoutId = setTimeout(onReject, timeout), intervalId = setInterval(checkCallback, interval));
 	});
 }
 
 function createVitest() {
 	let _config = null;
-	const workerState = getWorkerState();
+	const state = () => getWorkerState();
 	let _timers;
 	const timers = () => _timers ||= new FakeTimers({
 		global: globalThis,
-		config: workerState.config.fakeTimers
-	});
-	const _stubsGlobal = /* @__PURE__ */ new Map();
-	const _stubsEnv = /* @__PURE__ */ new Map();
-	const _envBooleans = [
+		config: state().config.fakeTimers
+	}), _stubsGlobal = /* @__PURE__ */ new Map(), _stubsEnv = /* @__PURE__ */ new Map(), _envBooleans = [
 		"PROD",
 		"DEV",
 		"SSR"
-	];
-	const utils = {
+	], utils = {
 		useFakeTimers(config) {
 			if (isChildProcess()) {
-				if (config?.toFake?.includes("nextTick") || workerState.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.");
+				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.");
 			}
 			if (config) timers().configure({
-				...workerState.config.fakeTimers,
+				...state().config.fakeTimers,
 				...config
 			});
-			else timers().configure(workerState.config.fakeTimers);
-			timers().useFakeTimers();
-			return utils;
+			else timers().configure(state().config.fakeTimers);
+			return timers().useFakeTimers(), utils;
 		},
 		isFakeTimers() {
 			return timers().isFakeTimers();
 		},
 		useRealTimers() {
-			timers().useRealTimers();
-			return utils;
+			return timers().useRealTimers(), utils;
 		},
 		runOnlyPendingTimers() {
-			timers().runOnlyPendingTimers();
-			return utils;
+			return timers().runOnlyPendingTimers(), utils;
 		},
 		async runOnlyPendingTimersAsync() {
-			await timers().runOnlyPendingTimersAsync();
-			return utils;
+			return await timers().runOnlyPendingTimersAsync(), utils;
 		},
 		runAllTimers() {
-			timers().runAllTimers();
-			return utils;
+			return timers().runAllTimers(), utils;
 		},
 		async runAllTimersAsync() {
-			await timers().runAllTimersAsync();
-			return utils;
+			return await timers().runAllTimersAsync(), utils;
 		},
 		runAllTicks() {
-			timers().runAllTicks();
-			return utils;
+			return timers().runAllTicks(), utils;
 		},
 		advanceTimersByTime(ms) {
-			timers().advanceTimersByTime(ms);
-			return utils;
+			return timers().advanceTimersByTime(ms), utils;
 		},
 		async advanceTimersByTimeAsync(ms) {
-			await timers().advanceTimersByTimeAsync(ms);
-			return utils;
+			return await timers().advanceTimersByTimeAsync(ms), utils;
 		},
 		advanceTimersToNextTimer() {
-			timers().advanceTimersToNextTimer();
-			return utils;
+			return timers().advanceTimersToNextTimer(), utils;
 		},
 		async advanceTimersToNextTimerAsync() {
-			await timers().advanceTimersToNextTimerAsync();
-			return utils;
+			return await timers().advanceTimersToNextTimerAsync(), utils;
 		},
 		advanceTimersToNextFrame() {
-			timers().advanceTimersToNextFrame();
-			return utils;
+			return timers().advanceTimersToNextFrame(), utils;
 		},
 		getTimerCount() {
 			return timers().getTimerCount();
 		},
 		setSystemTime(time) {
-			timers().setSystemTime(time);
-			return utils;
+			return timers().setSystemTime(time), utils;
 		},
 		getMockedSystemTime() {
 			return timers().getMockedSystemTime();
@@ -3887,16 +3750,14 @@ function createVitest() {
 			return timers().getRealSystemTime();
 		},
 		clearAllTimers() {
-			timers().clearAllTimers();
-			return utils;
+			return timers().clearAllTimers(), utils;
 		},
 		spyOn,
 		fn,
 		waitFor,
 		waitUntil,
 		hoisted(factory) {
-			assertTypes(factory, "\"vi.hoisted\" factory", ["function"]);
-			return factory();
+			return assertTypes(factory, "\"vi.hoisted\" factory", ["function"]), factory();
 		},
 		mock(path, factory) {
 			if (typeof path !== "string") throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
@@ -3914,16 +3775,19 @@ function createVitest() {
 		},
 		doUnmock(path) {
 			if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
-			_mocker().queueUnmock(path, getImporter("doUnmock"));
+			const importer = getImporter("doUnmock");
+			_mocker().queueUnmock(path, importer);
 		},
 		async importActual(path) {
-			return _mocker().importActual(path, getImporter("importActual"), _mocker().getMockContext().callstack);
+			const importer = getImporter("importActual");
+			return _mocker().importActual(path, importer, _mocker().getMockContext().callstack);
 		},
 		async importMock(path) {
-			return _mocker().importMock(path, getImporter("importMock"));
+			const importer = getImporter("importMock");
+			return _mocker().importMock(path, importer);
 		},
-		mockObject(value) {
-			return _mocker().mockObject({ value }).value;
+		mockObject(value, options) {
+			return _mocker().mockObject({ value }, void 0, options?.spy ? "autospy" : "automock").value;
 		},
 		mocked(item, _options = {}) {
 			return item;
@@ -3932,63 +3796,56 @@ function createVitest() {
 			return isMockFunction(fn);
 		},
 		clearAllMocks() {
-			[...mocks].reverse().forEach((spy) => spy.mockClear());
-			return utils;
+			return clearAllMocks(), utils;
 		},
 		resetAllMocks() {
-			[...mocks].reverse().forEach((spy) => spy.mockReset());
-			return utils;
+			return resetAllMocks(), utils;
 		},
 		restoreAllMocks() {
-			[...mocks].reverse().forEach((spy) => spy.mockRestore());
-			return utils;
+			return restoreAllMocks(), utils;
 		},
 		stubGlobal(name, value) {
 			if (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
-			Object.defineProperty(globalThis, name, {
+			return Object.defineProperty(globalThis, name, {
 				value,
 				writable: true,
 				configurable: true,
 				enumerable: true
-			});
-			return utils;
+			}), utils;
 		},
 		stubEnv(name, value) {
-			if (!_stubsEnv.has(name)) _stubsEnv.set(name, process.env[name]);
-			if (_envBooleans.includes(name)) process.env[name] = value ? "1" : "";
-			else if (value === void 0) delete process.env[name];
-			else process.env[name] = String(value);
+			const env = state().metaEnv;
+			if (!_stubsEnv.has(name)) _stubsEnv.set(name, env[name]);
+			if (_envBooleans.includes(name)) env[name] = value ? "1" : "";
+			else if (value === void 0) delete env[name];
+			else env[name] = String(value);
 			return utils;
 		},
 		unstubAllGlobals() {
-			_stubsGlobal.forEach((original, name) => {
+			return _stubsGlobal.forEach((original, name) => {
 				if (!original) Reflect.deleteProperty(globalThis, name);
 				else Object.defineProperty(globalThis, name, original);
-			});
-			_stubsGlobal.clear();
-			return utils;
+			}), _stubsGlobal.clear(), utils;
 		},
 		unstubAllEnvs() {
-			_stubsEnv.forEach((original, name) => {
-				if (original === void 0) delete process.env[name];
-				else process.env[name] = original;
-			});
-			_stubsEnv.clear();
-			return utils;
+			const env = state().metaEnv;
+			return _stubsEnv.forEach((original, name) => {
+				if (original === void 0) delete env[name];
+				else env[name] = original;
+			}), _stubsEnv.clear(), utils;
 		},
 		resetModules() {
-			resetModules(workerState.moduleCache);
-			return utils;
+			return resetModules(state().evaluatedModules), utils;
 		},
 		async dynamicImportSettled() {
 			return waitForImportsToResolve();
 		},
 		setConfig(config) {
-			if (!_config) _config = { ...workerState.config };
-			Object.assign(workerState.config, config);
+			if (!_config) _config = { ...state().config };
+			Object.assign(state().config, config);
 		},
 		resetConfig() {
-			if (_config) Object.assign(workerState.config, _config);
+			if (_config) Object.assign(state().config, _config);
 		}
 	};
 	return utils;
@@ -4002,14 +3859,10 @@ function _mocker() {
 	} });
 }
 function getImporter(name) {
-	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 });
-	const stackArray = stackTrace.split("\n");
-	// if there is no message in a stack trace, use the item - 1
-	const importerStackIndex = stackArray.findIndex((stack) => {
+	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 }), stackArray = stackTrace.split("\n"), importerStackIndex = stackArray.findLastIndex((stack) => {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
-	});
-	const stack = parseSingleStack(stackArray[importerStackIndex + 1]);
+	}), stack = parseSingleStack(stackArray[importerStackIndex + 1]);
 	return stack?.file || "";
 }
 
-export { globalExpect as a, vitest as b, createExpect as c, getSnapshotClient as g, inject as i, vi as v };
+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 };