vitest 3.2.0-beta.2 → 3.2.0

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

@@ -2,15 +2,16 @@ import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, J
 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.CgTj3MsC.js';
+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 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 { parseSingleStack } from '@vitest/utils/source-map';
-import { R as RealDate, r as resetDate, m as mockDate } from './date.CDOsz-HY.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 = [
 	"matchSnapshot",
 	"toMatchSnapshot",
@@ -28,23 +29,16 @@ function createExpectPoll(expect) {
 		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 });
 		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");
-		}
+		if (!test) throw new Error("expect.poll() must be called inside a test");
 		const proxy = new Proxy(assertion, { get(target, key, receiver) {
 			const assertionFunction = Reflect.get(target, key, receiver);
-			if (typeof assertionFunction !== "function") {
-				return assertionFunction instanceof chai$1.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.`);
-			}
+			if (typeof assertionFunction !== "function") return assertionFunction instanceof chai$1.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 = new Error("STACK_TRACE_ERROR");
 				const promise = () => new Promise((resolve, reject) => {
@@ -62,9 +56,7 @@ function createExpectPoll(expect) {
 							clearTimeout(timeoutId);
 						} catch (err) {
 							lastError = err;
-							if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) {
-								intervalId = setTimeout(check, interval);
-							}
+							if (!chai$1.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
 						}
 					};
 					timeoutId = setTimeout(() => {
@@ -89,6 +81,8 @@ function createExpectPoll(expect) {
 					}
 				});
 				let resultPromise;
+				// only .then is enough to check awaited, but we type this as `Promise<void>` in global types
+				// so let's follow it
 				return {
 					then(onFulfilled, onRejected) {
 						awaited = true;
@@ -108,9 +102,7 @@ function createExpectPoll(expect) {
 	};
 }
 function copyStackTrace$1(target, source) {
-	if (source.stack !== undefined) {
-		target.stack = source.stack.replace(source.message, target.message);
-	}
+	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
 }
 
@@ -222,19 +214,16 @@ function createAssertionMessage(util, assertion, hasArgs) {
 }
 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(() => {
-			if (!test.promises) {
-				return;
-			}
+			if (!test.promises) return;
 			const index = test.promises.indexOf(promise);
-			if (index !== -1) {
-				test.promises.splice(index, 1);
-			}
+			if (index !== -1) test.promises.splice(index, 1);
 		});
-		if (!test.promises) {
-			test.promises = [];
-		}
+		// record promise
+		if (!test.promises) test.promises = [];
 		test.promises.push(promise);
 		let resolved = false;
 		test.onFinished ??= [];
@@ -269,18 +258,15 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 
 let _client;
 function getSnapshotClient() {
-	if (!_client) {
-		_client = new SnapshotClient({ isEqual: (received, expected) => {
-			return equals(received, expected, [iterableEquality, subsetEquality]);
-		} });
-	}
+	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}`);
-		}
+		if (!promise) throw new Error(`expected must be a function, received ${typeof expected}`);
+		// when "promised", it receives thrown error
 		return expected;
 	}
 	try {
@@ -300,41 +286,33 @@ function getTestNames(test) {
 const SnapshotPlugin = (chai, utils) => {
 	function getTest(assertionName, obj) {
 		const test = utils.flag(obj, "vitest-test");
-		if (!test) {
-			throw new Error(`'${assertionName}' cannot be used without test context`);
-		}
+		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, function(properties, message) {
-			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 = undefined;
-			}
-			const errorMessage = utils.flag(this, "message");
-			getSnapshotClient().assert({
-				received: expected,
-				message,
-				isInline: false,
-				properties,
-				errorMessage,
-				...getTestNames(test)
-			});
+	for (const key of ["matchSnapshot", "toMatchSnapshot"]) utils.addMethod(chai.Assertion.prototype, key, function(properties, message) {
+		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 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");
 		const isNot = utils.flag(this, "negate");
-		if (isNot) {
-			throw new Error("toMatchFileSnapshot cannot be used with \"not\"");
-		}
+		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);
@@ -352,24 +330,18 @@ const SnapshotPlugin = (chai, utils) => {
 	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\"");
-		}
+		if (isNot) throw new Error("toMatchInlineSnapshot cannot be used with \"not\"");
 		const test = getTest("toMatchInlineSnapshot", this);
 		const isInsideEach = test.each || test.suite?.each;
-		if (isInsideEach) {
-			throw new Error("InlineSnapshot cannot be used inside of test.each or describe.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 = undefined;
-		}
-		if (inlineSnapshot) {
-			inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
+			properties = void 0;
 		}
+		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
 		const errorMessage = utils.flag(this, "message");
 		getSnapshotClient().assert({
 			received: expected,
@@ -385,9 +357,7 @@ const SnapshotPlugin = (chai, utils) => {
 	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\"");
-		}
+		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");
@@ -401,21 +371,15 @@ const SnapshotPlugin = (chai, utils) => {
 	});
 	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\"");
-		}
+		if (isNot) throw new Error("toThrowErrorMatchingInlineSnapshot cannot be used with \"not\"");
 		const test = getTest("toThrowErrorMatchingInlineSnapshot", this);
 		const isInsideEach = test.each || test.suite?.each;
-		if (isInsideEach) {
-			throw new Error("InlineSnapshot cannot be used inside of test.each or describe.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");
-		if (inlineSnapshot) {
-			inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
-		}
+		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
 		getSnapshotClient().assert({
 			received: getError(expected, promise),
 			message,
@@ -441,16 +405,16 @@ function createExpect(test) {
 		setState({ assertionCalls: assertionCalls + 1 }, expect);
 		const assert = chai$1.expect(value, message);
 		const _test = test || getCurrentTest();
-		if (_test) {
-			return assert.withTest(_test);
-		} else {
-			return assert;
-		}
+		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);
+	// @ts-expect-error global is not typed
 	const globalState = getState(globalThis[GLOBAL_EXPECT]) || {};
 	setState({
 		...globalState,
@@ -465,9 +429,11 @@ function createExpect(test) {
 		},
 		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) => {
+		// @ts-expect-error private soft access
 		return expect(...args).withContext({ soft: true });
 	};
 	expect.poll = createExpectPoll(expect);
@@ -476,9 +442,7 @@ function createExpect(test) {
 	};
 	function assertions(expected) {
 		const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
-		if (Error.captureStackTrace) {
-			Error.captureStackTrace(errorGen(), assertions);
-		}
+		if (Error.captureStackTrace) Error.captureStackTrace(errorGen(), assertions);
 		expect.setState({
 			expectedAssertionsNumber: expected,
 			expectedAssertionsNumberErrorGen: errorGen
@@ -486,9 +450,7 @@ function createExpect(test) {
 	}
 	function hasAssertions() {
 		const error = new Error("expected any number of assertion, but got none");
-		if (Error.captureStackTrace) {
-			Error.captureStackTrace(error, hasAssertions);
-		}
+		if (Error.captureStackTrace) Error.captureStackTrace(error, hasAssertions);
 		expect.setState({
 			isExpectingAssertions: true,
 			isExpectingAssertionsError: error
@@ -3611,6 +3573,12 @@ var fakeTimersSrcExports = requireFakeTimersSrc();
 class FakeTimers {
 	_global;
 	_clock;
+	// | _fakingTime | _fakingDate |
+	// +-------------+-------------+
+	// | false       | falsy       | initial
+	// | false       | truthy     | vi.setSystemTime called first (for mocking only Date without fake timers)
+	// | true        | falsy       | vi.useFakeTimers called first
+	// | true        | truthy     | unreachable
 	_fakingTime;
 	_fakingDate;
 	_fakeTimers;
@@ -3624,74 +3592,52 @@ class FakeTimers {
 		this._global = global;
 	}
 	clearAllTimers() {
-		if (this._fakingTime) {
-			this._clock.reset();
-		}
+		if (this._fakingTime) this._clock.reset();
 	}
 	dispose() {
 		this.useRealTimers();
 	}
 	runAllTimers() {
-		if (this._checkFakeTimers()) {
-			this._clock.runAll();
-		}
+		if (this._checkFakeTimers()) this._clock.runAll();
 	}
 	async runAllTimersAsync() {
-		if (this._checkFakeTimers()) {
-			await this._clock.runAllAsync();
-		}
+		if (this._checkFakeTimers()) await this._clock.runAllAsync();
 	}
 	runOnlyPendingTimers() {
-		if (this._checkFakeTimers()) {
-			this._clock.runToLast();
-		}
+		if (this._checkFakeTimers()) this._clock.runToLast();
 	}
 	async runOnlyPendingTimersAsync() {
-		if (this._checkFakeTimers()) {
-			await this._clock.runToLastAsync();
-		}
+		if (this._checkFakeTimers()) await this._clock.runToLastAsync();
 	}
 	advanceTimersToNextTimer(steps = 1) {
-		if (this._checkFakeTimers()) {
-			for (let i = steps; i > 0; i--) {
-				this._clock.next();
-				this._clock.tick(0);
-				if (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--) {
-				await this._clock.nextAsync();
-				this._clock.tick(0);
-				if (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) {
-		if (this._checkFakeTimers()) {
-			this._clock.tick(msToRun);
-		}
+		if (this._checkFakeTimers()) this._clock.tick(msToRun);
 	}
 	async advanceTimersByTimeAsync(msToRun) {
-		if (this._checkFakeTimers()) {
-			await this._clock.tickAsync(msToRun);
-		}
+		if (this._checkFakeTimers()) await this._clock.tickAsync(msToRun);
 	}
 	advanceTimersToNextFrame() {
-		if (this._checkFakeTimers()) {
-			this._clock.runToFrame();
-		}
+		if (this._checkFakeTimers()) this._clock.runToFrame();
 	}
 	runAllTicks() {
-		if (this._checkFakeTimers()) {
-			this._clock.runMicrotasks();
-		}
+		if (this._checkFakeTimers())
+ // @ts-expect-error method not exposed
+		this._clock.runMicrotasks();
 	}
 	useRealTimers() {
 		if (this._fakingDate) {
@@ -3704,14 +3650,10 @@ class FakeTimers {
 		}
 	}
 	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._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");
-			}
+			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,
@@ -3730,9 +3672,8 @@ class FakeTimers {
 	}
 	setSystemTime(now) {
 		const date = typeof now === "undefined" || now instanceof Date ? now : new Date(now);
-		if (this._fakingTime) {
-			this._clock.setSystemTime(date);
-		} else {
+		if (this._fakingTime) this._clock.setSystemTime(date);
+		else {
 			this._fakingDate = date ?? new Date(this.getRealSystemTime());
 			mockDate(this._fakingDate);
 		}
@@ -3744,9 +3685,7 @@ class FakeTimers {
 		return this._now();
 	}
 	getTimerCount() {
-		if (this._checkFakeTimers()) {
-			return this._clock.countTimers();
-		}
+		if (this._checkFakeTimers()) return this._clock.countTimers();
 		return 0;
 	}
 	configure(config) {
@@ -3756,17 +3695,13 @@ 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("Timers are not mocked. Try calling \"vi.useFakeTimers()\" first.");
 		return this._fakingTime;
 	}
 }
 
 function copyStackTrace(target, source) {
-	if (source.stack !== undefined) {
-		target.stack = source.stack.replace(source.message, target.message);
-	}
+	if (source.stack !== void 0) target.stack = source.stack.replace(source.message, target.message);
 	return target;
 }
 function waitFor(callback, options = {}) {
@@ -3779,31 +3714,19 @@ function waitFor(callback, options = {}) {
 		let timeoutId;
 		let intervalId;
 		const onResolve = (result) => {
-			if (timeoutId) {
-				clearTimeout(timeoutId);
-			}
-			if (intervalId) {
-				clearInterval(intervalId);
-			}
+			if (timeoutId) clearTimeout(timeoutId);
+			if (intervalId) clearInterval(intervalId);
 			resolve(result);
 		};
 		const handleTimeout = () => {
-			if (intervalId) {
-				clearInterval(intervalId);
-			}
+			if (intervalId) clearInterval(intervalId);
 			let error = lastError;
-			if (!error) {
-				error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
-			}
+			if (!error) error = copyStackTrace(new Error("Timed out in waitFor!"), STACK_TRACE_ERROR);
 			reject(error);
 		};
 		const checkCallback = () => {
-			if (vi.isFakeTimers()) {
-				vi.advanceTimersByTime(interval);
-			}
-			if (promiseStatus === "pending") {
-				return;
-			}
+			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+			if (promiseStatus === "pending") return;
 			try {
 				const result = callback();
 				if (result !== null && typeof result === "object" && typeof result.then === "function") {
@@ -3824,9 +3747,7 @@ function waitFor(callback, options = {}) {
 				lastError = error;
 			}
 		};
-		if (checkCallback() === true) {
-			return;
-		}
+		if (checkCallback() === true) return;
 		timeoutId = setTimeout(handleTimeout, timeout);
 		intervalId = setInterval(checkCallback, interval);
 	});
@@ -3840,34 +3761,20 @@ function waitUntil(callback, options = {}) {
 		let timeoutId;
 		let intervalId;
 		const onReject = (error) => {
-			if (intervalId) {
-				clearInterval(intervalId);
-			}
-			if (!error) {
-				error = copyStackTrace(new Error("Timed out in waitUntil!"), STACK_TRACE_ERROR);
-			}
+			if (intervalId) clearInterval(intervalId);
+			if (!error) error = copyStackTrace(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);
-			}
+			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") {
-				return;
-			}
+			if (vi.isFakeTimers()) vi.advanceTimersByTime(interval);
+			if (promiseStatus === "pending") return;
 			try {
 				const result = callback();
 				if (result !== null && typeof result === "object" && typeof result.then === "function") {
@@ -3880,16 +3787,12 @@ function waitUntil(callback, options = {}) {
 						promiseStatus = "rejected";
 						onReject(rejectedValue);
 					});
-				} else {
-					return onResolve(result);
-				}
+				} else return onResolve(result);
 			} catch (error) {
 				onReject(error);
 			}
 		};
-		if (checkCallback() === true) {
-			return;
-		}
+		if (checkCallback() === true) return;
 		timeoutId = setTimeout(onReject, timeout);
 		intervalId = setInterval(checkCallback, interval);
 	});
@@ -3903,8 +3806,8 @@ function createVitest() {
 		global: globalThis,
 		config: workerState.config.fakeTimers
 	});
-	const _stubsGlobal = new Map();
-	const _stubsEnv = new Map();
+	const _stubsGlobal = /* @__PURE__ */ new Map();
+	const _stubsEnv = /* @__PURE__ */ new Map();
 	const _envBooleans = [
 		"PROD",
 		"DEV",
@@ -3913,18 +3816,13 @@ function createVitest() {
 	const 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) {
-				timers().configure({
-					...workerState.config.fakeTimers,
-					...config
-				});
-			} else {
-				timers().configure(workerState.config.fakeTimers);
+				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) timers().configure({
+				...workerState.config.fakeTimers,
+				...config
+			});
+			else timers().configure(workerState.config.fakeTimers);
 			timers().useFakeTimers();
 			return utils;
 		},
@@ -4001,29 +3899,21 @@ function createVitest() {
 			return factory();
 		},
 		mock(path, factory) {
-			if (typeof path !== "string") {
-				throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
-			}
+			if (typeof path !== "string") throw new TypeError(`vi.mock() expects a string path, but received a ${typeof path}`);
 			const importer = getImporter("mock");
 			_mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
 		},
 		unmock(path) {
-			if (typeof path !== "string") {
-				throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);
-			}
+			if (typeof path !== "string") throw new TypeError(`vi.unmock() expects a string path, but received a ${typeof path}`);
 			_mocker().queueUnmock(path, getImporter("unmock"));
 		},
 		doMock(path, factory) {
-			if (typeof path !== "string") {
-				throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
-			}
+			if (typeof path !== "string") throw new TypeError(`vi.doMock() expects a string path, but received a ${typeof path}`);
 			const importer = getImporter("doMock");
 			_mocker().queueMock(path, importer, typeof factory === "function" ? () => factory(() => _mocker().importActual(path, importer, _mocker().getMockContext().callstack)) : factory);
 		},
 		doUnmock(path) {
-			if (typeof path !== "string") {
-				throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
-			}
+			if (typeof path !== "string") throw new TypeError(`vi.doUnmock() expects a string path, but received a ${typeof path}`);
 			_mocker().queueUnmock(path, getImporter("doUnmock"));
 		},
 		async importActual(path) {
@@ -4054,9 +3944,7 @@ function createVitest() {
 			return utils;
 		},
 		stubGlobal(name, value) {
-			if (!_stubsGlobal.has(name)) {
-				_stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
-			}
+			if (!_stubsGlobal.has(name)) _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
 			Object.defineProperty(globalThis, name, {
 				value,
 				writable: true,
@@ -4066,36 +3954,24 @@ function createVitest() {
 			return 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 === undefined) {
-				delete process.env[name];
-			} else {
-				process.env[name] = String(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);
 			return utils;
 		},
 		unstubAllGlobals() {
 			_stubsGlobal.forEach((original, name) => {
-				if (!original) {
-					Reflect.deleteProperty(globalThis, name);
-				} else {
-					Object.defineProperty(globalThis, name, original);
-				}
+				if (!original) Reflect.deleteProperty(globalThis, name);
+				else Object.defineProperty(globalThis, name, original);
 			});
 			_stubsGlobal.clear();
 			return utils;
 		},
 		unstubAllEnvs() {
 			_stubsEnv.forEach((original, name) => {
-				if (original === undefined) {
-					delete process.env[name];
-				} else {
-					process.env[name] = original;
-				}
+				if (original === void 0) delete process.env[name];
+				else process.env[name] = original;
 			});
 			_stubsEnv.clear();
 			return utils;
@@ -4108,15 +3984,11 @@ function createVitest() {
 			return waitForImportsToResolve();
 		},
 		setConfig(config) {
-			if (!_config) {
-				_config = { ...workerState.config };
-			}
+			if (!_config) _config = { ...workerState.config };
 			Object.assign(workerState.config, config);
 		},
 		resetConfig() {
-			if (_config) {
-				Object.assign(workerState.config, _config);
-			}
+			if (_config) Object.assign(workerState.config, _config);
 		}
 	};
 	return utils;
@@ -4124,13 +3996,15 @@ function createVitest() {
 const vitest = createVitest();
 const vi = vitest;
 function _mocker() {
+	// @ts-expect-error injected by vite-nide
 	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.`);
+		throw new Error(`Vitest mocker was not initialized in this environment. vi.${String(name)}() is forbidden.`);
 	} });
 }
 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) => {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
 	});