vitest 4.0.0-beta.11 → 4.0.0-beta.13

package/dist/chunks/{typechecker.gXq-5P3n.js → typechecker.BfOQ86_a.js}

@@ -30,9 +30,7 @@ function wrapSerializableConfig(config) {
 	};
 }
 function createDefinesScript(define) {
-	if (!define) return "";
-	const serializedDefine = serializeDefine(define);
-	return serializedDefine === "{}" ? "" : `
+	return !define || serializeDefine(define) === "{}" ? "" : `
 const defines = ${serializeDefine(define)}
 Object.keys(defines).forEach((key) => {
   const segments = key.split('.')
@@ -244,16 +242,6 @@ const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#
  * 4. Hash, including "#", optional.
  */
 const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
-var UrlType;
-(function (UrlType) {
-    UrlType[UrlType["Empty"] = 1] = "Empty";
-    UrlType[UrlType["Hash"] = 2] = "Hash";
-    UrlType[UrlType["Query"] = 3] = "Query";
-    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
-    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
-    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
-    UrlType[UrlType["Absolute"] = 7] = "Absolute";
-})(UrlType || (UrlType = {}));
 function isAbsoluteUrl(input) {
     return schemeRegex.test(input);
 }
@@ -287,21 +275,21 @@ function makeUrl(scheme, user, host, port, path, query, hash) {
         path,
         query,
         hash,
-        type: UrlType.Absolute,
+        type: 7 /* Absolute */,
     };
 }
 function parseUrl(input) {
     if (isSchemeRelativeUrl(input)) {
         const url = parseAbsoluteUrl('http:' + input);
         url.scheme = '';
-        url.type = UrlType.SchemeRelative;
+        url.type = 6 /* SchemeRelative */;
         return url;
     }
     if (isAbsolutePath(input)) {
         const url = parseAbsoluteUrl('http://foo.com' + input);
         url.scheme = '';
         url.host = '';
-        url.type = UrlType.AbsolutePath;
+        url.type = 5 /* AbsolutePath */;
         return url;
     }
     if (isFileUrl(input))
@@ -313,11 +301,11 @@ function parseUrl(input) {
     url.host = '';
     url.type = input
         ? input.startsWith('?')
-            ? UrlType.Query
+            ? 3 /* Query */
             : input.startsWith('#')
-                ? UrlType.Hash
-                : UrlType.RelativePath
-        : UrlType.Empty;
+                ? 2 /* Hash */
+                : 4 /* RelativePath */
+        : 1 /* Empty */;
     return url;
 }
 function stripPathFilename(path) {
@@ -345,7 +333,7 @@ function mergePaths(url, base) {
  * "foo/.". We need to normalize to a standard representation.
  */
 function normalizePath(url, type) {
-    const rel = type <= UrlType.RelativePath;
+    const rel = type <= 4 /* RelativePath */;
     const pieces = url.path.split('/');
     // We need to preserve the first piece always, so that we output a leading slash. The item at
     // pieces[0] is an empty string.
@@ -406,27 +394,27 @@ function resolve(input, base) {
         return '';
     const url = parseUrl(input);
     let inputType = url.type;
-    if (base && inputType !== UrlType.Absolute) {
+    if (base && inputType !== 7 /* Absolute */) {
         const baseUrl = parseUrl(base);
         const baseType = baseUrl.type;
         switch (inputType) {
-            case UrlType.Empty:
+            case 1 /* Empty */:
                 url.hash = baseUrl.hash;
             // fall through
-            case UrlType.Hash:
+            case 2 /* Hash */:
                 url.query = baseUrl.query;
             // fall through
-            case UrlType.Query:
-            case UrlType.RelativePath:
+            case 3 /* Query */:
+            case 4 /* RelativePath */:
                 mergePaths(url, baseUrl);
             // fall through
-            case UrlType.AbsolutePath:
+            case 5 /* AbsolutePath */:
                 // The host, user, and port are joined, you can't copy one without the others.
                 url.user = baseUrl.user;
                 url.host = baseUrl.host;
                 url.port = baseUrl.port;
             // fall through
-            case UrlType.SchemeRelative:
+            case 6 /* SchemeRelative */:
                 // The input doesn't have a schema at least, so we need to copy at least that over.
                 url.scheme = baseUrl.scheme;
         }
@@ -438,10 +426,10 @@ function resolve(input, base) {
     switch (inputType) {
         // This is impossible, because of the empty checks at the start of the function.
         // case UrlType.Empty:
-        case UrlType.Hash:
-        case UrlType.Query:
+        case 2 /* Hash */:
+        case 3 /* Query */:
             return queryHash;
-        case UrlType.RelativePath: {
+        case 4 /* RelativePath */: {
             // The first char is always a "/", and we need it to be relative.
             const path = url.path.slice(1);
             if (!path)
@@ -454,7 +442,7 @@ function resolve(input, base) {
             }
             return path + queryHash;
         }
-        case UrlType.AbsolutePath:
+        case 5 /* AbsolutePath */:
             return url.path + queryHash;
         default:
             return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
@@ -518,6 +506,32 @@ function sortComparator(a, b) {
   return a[COLUMN] - b[COLUMN];
 }
 
+// src/by-source.ts
+function buildBySources(decoded, memos) {
+  const sources = memos.map(() => []);
+  for (let i = 0; i < decoded.length; i++) {
+    const line = decoded[i];
+    for (let j = 0; j < line.length; j++) {
+      const seg = line[j];
+      if (seg.length === 1) continue;
+      const sourceIndex2 = seg[SOURCES_INDEX];
+      const sourceLine = seg[SOURCE_LINE];
+      const sourceColumn = seg[SOURCE_COLUMN];
+      const source = sources[sourceIndex2];
+      const segs = source[sourceLine] || (source[sourceLine] = []);
+      segs.push([sourceColumn, i, seg[COLUMN]]);
+    }
+  }
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    for (let j = 0; j < source.length; j++) {
+      const line = source[j];
+      if (line) line.sort(sortComparator);
+    }
+  }
+  return sources;
+}
+
 // src/binary-search.ts
 var found = false;
 function binarySearch(haystack, needle, low, high) {
@@ -576,41 +590,6 @@ function memoizedBinarySearch(haystack, needle, state, key) {
   return state.lastIndex = binarySearch(haystack, needle, low, high);
 }
 
-// src/by-source.ts
-function buildBySources(decoded, memos) {
-  const sources = memos.map(buildNullArray);
-  for (let i = 0; i < decoded.length; i++) {
-    const line = decoded[i];
-    for (let j = 0; j < line.length; j++) {
-      const seg = line[j];
-      if (seg.length === 1) continue;
-      const sourceIndex2 = seg[SOURCES_INDEX];
-      const sourceLine = seg[SOURCE_LINE];
-      const sourceColumn = seg[SOURCE_COLUMN];
-      const originalSource = sources[sourceIndex2];
-      const originalLine = originalSource[sourceLine] || (originalSource[sourceLine] = []);
-      const memo = memos[sourceIndex2];
-      let index = upperBound(
-        originalLine,
-        sourceColumn,
-        memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine)
-      );
-      memo.lastIndex = ++index;
-      insert(originalLine, index, [sourceColumn, i, seg[COLUMN]]);
-    }
-  }
-  return sources;
-}
-function insert(array, index, value) {
-  for (let i = array.length; i > index; i--) {
-    array[i] = array[i - 1];
-  }
-  array[index] = value;
-}
-function buildNullArray() {
-  return { __proto__: null };
-}
-
 // src/types.ts
 function parse(map) {
   return typeof map === "string" ? JSON.parse(map) : map;
@@ -735,7 +714,7 @@ function traceSegmentInternal(segments, memo, line, column, bias) {
   return index;
 }
 function generatedPosition(map, source, line, column, bias, all) {
-  var _a;
+  var _a, _b;
   line--;
   if (line < 0) throw new Error(LINE_GTR_ZERO);
   if (column < 0) throw new Error(COL_GTR_EQ_ZERO);
@@ -743,13 +722,11 @@ function generatedPosition(map, source, line, column, bias, all) {
   let sourceIndex2 = sources.indexOf(source);
   if (sourceIndex2 === -1) sourceIndex2 = resolvedSources.indexOf(source);
   if (sourceIndex2 === -1) return all ? [] : GMapping(null, null);
-  const generated = (_a = cast(map))._bySources || (_a._bySources = buildBySources(
-    decodedMappings(map),
-    cast(map)._bySourceMemos = sources.map(memoizedState)
-  ));
+  const bySourceMemos = (_a = cast(map))._bySourceMemos || (_a._bySourceMemos = sources.map(memoizedState));
+  const generated = (_b = cast(map))._bySources || (_b._bySources = buildBySources(decodedMappings(map), bySourceMemos));
   const segments = generated[sourceIndex2][line];
   if (segments == null) return all ? [] : GMapping(null, null);
-  const memo = cast(map)._bySourceMemos[sourceIndex2];
+  const memo = bySourceMemos[sourceIndex2];
   const index = traceSegmentInternal(segments, memo, line, column, bias);
   if (index === -1) return GMapping(null, null);
   const segment = segments[index];
@@ -1092,7 +1069,7 @@ async function collectTests(ctx, filepath) {
 		if (callee.type === "CallExpression") start = callee.end;
 		else if (callee.type === "TaggedTemplateExpression") start = callee.end + 1;
 		else start = node.start;
-		const { arguments: [messageNode] } = node, isQuoted = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral", message = isQuoted ? request.code.slice(messageNode.start + 1, messageNode.end - 1) : request.code.slice(messageNode.start, messageNode.end);
+		const { arguments: [messageNode] } = node, message = messageNode?.type === "Literal" || messageNode?.type === "TemplateLiteral" ? request.code.slice(messageNode.start + 1, messageNode.end - 1) : request.code.slice(messageNode.start, messageNode.end);
 		// cannot statically analyze, so we always skip it
 		if (mode === "skipIf" || mode === "runIf") mode = "skip";
 		definitions.push({
@@ -1180,13 +1157,13 @@ async function makeTscErrorInfo(errInfo) {
 	}];
 }
 async function getRawErrsMapFromTsCompile(tscErrorStdout) {
-	const rawErrsMap = /* @__PURE__ */ new Map(), infos = await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
+	const rawErrsMap = /* @__PURE__ */ new Map();
+	return (await Promise.all(tscErrorStdout.split(newLineRegExp).reduce((prev, next) => {
 		if (!next) return prev;
 		if (next[0] !== " ") prev.push(next);
 		else prev[prev.length - 1] += `\n${next}`;
 		return prev;
-	}, []).map((errInfoLine) => makeTscErrorInfo(errInfoLine)));
-	return infos.forEach(([errFilePath, errInfo]) => {
+	}, []).map((errInfoLine) => makeTscErrorInfo(errInfoLine)))).forEach(([errFilePath, errInfo]) => {
 		if (errInfo) if (!rawErrsMap.has(errFilePath)) rawErrsMap.set(errFilePath, [errInfo]);
 		else rawErrsMap.get(errFilePath)?.push(errInfo);
 	}), rawErrsMap;

package/dist/chunks/{utils.DGKhod2J.js → utils.CG9h5ccR.js}

@@ -4,10 +4,7 @@ const NAME_WORKER_STATE = "__vitest_worker__";
 function getWorkerState() {
 	// @ts-expect-error untyped global
 	const workerState = globalThis[NAME_WORKER_STATE];
-	if (!workerState) {
-		const errorMsg = "Vitest failed to access its internal state.\n\nOne of the following is possible:\n- \"vitest\" is imported directly without running \"vitest\" command\n- \"vitest\" is imported inside \"globalSetup\" (to fix this, use \"setupFiles\" instead, because \"globalSetup\" runs in a different context)\n- \"vitest\" is imported inside Vite / Vitest config file\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n";
-		throw new Error(errorMsg);
-	}
+	if (!workerState) throw new Error("Vitest failed to access its internal state.\n\nOne of the following is possible:\n- \"vitest\" is imported directly without running \"vitest\" command\n- \"vitest\" is imported inside \"globalSetup\" (to fix this, use \"setupFiles\" instead, because \"globalSetup\" runs in a different context)\n- \"vitest\" is imported inside Vite / Vitest config file\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n");
 	return workerState;
 }
 function provideWorkerState(context, state) {

package/dist/chunks/{vi.CiJ0Laa6.js → vi.B2--mG9U.js}

@@ -1,15 +1,15 @@
-import { chai as chai$1, equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, ASYMMETRIC_MATCHERS_OBJECT, getState, setState, addCustomEqualityTesters, customMatchers } from '@vitest/expect';
+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.DGKhod2J.js';
+import { g as getWorkerState, i as isChildProcess, w as waitForImportsToResolve, r as resetModules } from './utils.CG9h5ccR.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 { 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 { c as commonjsGlobal } from './_commonjsHelpers.BFTU3MAI.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
@@ -27,13 +27,13 @@ const unsupported = [
 ];
 function createExpectPoll(expect) {
 	return function poll(fn, options = {}) {
-		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 });
+		const defaults = getWorkerState().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");
+		const test = chai.util.flag(assertion, "vitest-test");
 		if (!test) throw new Error("expect.poll() must be called inside a test");
 		const proxy = new Proxy(assertion, { get(target, key, receiver) {
 			const assertionFunction = Reflect.get(target, key, receiver);
-			if (typeof assertionFunction !== "function") return assertionFunction instanceof chai$1.Assertion ? proxy : assertionFunction;
+			if (typeof assertionFunction !== "function") return assertionFunction instanceof chai.Assertion ? proxy : assertionFunction;
 			if (key === "assert") return assertionFunction;
 			if (typeof key === "string" && unsupported.includes(key)) throw new SyntaxError(`expect.poll() is not supported in combination with .${key}(). Use vi.waitFor() if your assertion condition is unstable.`);
 			return function(...args) {
@@ -41,15 +41,15 @@ function createExpectPoll(expect) {
 					let intervalId, timeoutId, lastError;
 					const { setTimeout, clearTimeout } = getSafeTimers(), check = async () => {
 						try {
-							chai$1.util.flag(assertion, "_name", key);
+							chai.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.util.flag(assertion, "object", obj), resolve(await assertionFunction.call(assertion, ...args)), clearTimeout(intervalId), clearTimeout(timeoutId);
 						} catch (err) {
-							if (lastError = err, !chai$1.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
+							if (lastError = err, !chai.util.flag(assertion, "_isLastPollAttempt")) intervalId = setTimeout(check, interval);
 						}
 					};
 					timeoutId = setTimeout(() => {
-						clearTimeout(intervalId), chai$1.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));
@@ -60,7 +60,7 @@ function createExpectPoll(expect) {
 				let awaited = false;
 				test.onFinished ??= [], test.onFinished.push(() => {
 					if (!awaited) {
-						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`);
+						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);
 					}
 				});
@@ -89,108 +89,9 @@ function copyStackTrace$1(target, source) {
 	return target;
 }
 
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
-var chaiSubset$1 = {exports: {}};
-
-var chaiSubset = chaiSubset$1.exports;
-
-var hasRequiredChaiSubset;
-
-function requireChaiSubset () {
-	if (hasRequiredChaiSubset) return chaiSubset$1.exports;
-	hasRequiredChaiSubset = 1;
-	(function (module, exports) {
-		(function() {
-			(function(chaiSubset) {
-				if (typeof commonjsRequire === 'function' && 'object' === 'object' && 'object' === 'object') {
-					return module.exports = chaiSubset;
-				} else {
-					return chai.use(chaiSubset);
-				}
-			})(function(chai, utils) {
-				var Assertion = chai.Assertion;
-				var assertionPrototype = Assertion.prototype;
-
-				Assertion.addMethod('containSubset', function (expected) {
-					var actual = utils.flag(this, 'object');
-					var showDiff = chai.config.showDiff;
-
-					assertionPrototype.assert.call(this,
-						compare(expected, actual),
-						'expected #{act} to contain subset #{exp}',
-						'expected #{act} to not contain subset #{exp}',
-						expected,
-						actual,
-						showDiff
-					);
-				});
-
-				chai.assert.containSubset = function(val, exp, msg) {
-					new chai.Assertion(val, msg).to.be.containSubset(exp);
-				};
-
-				function compare(expected, actual) {
-					if (expected === actual) {
-						return true;
-					}
-					if (typeof(actual) !== typeof(expected)) {
-						return false;
-					}
-					if (typeof(expected) !== 'object' || expected === null) {
-						return expected === actual;
-					}
-					if (!!expected && !actual) {
-						return false;
-					}
-
-					if (Array.isArray(expected)) {
-						if (typeof(actual.length) !== 'number') {
-							return false;
-						}
-						var aa = Array.prototype.slice.call(actual);
-						return expected.every(function (exp) {
-							return aa.some(function (act) {
-								return compare(exp, act);
-							});
-						});
-					}
-
-					if (expected instanceof Date) {
-						if (actual instanceof Date) {
-							return expected.getTime() === actual.getTime();
-						} else {
-							return false;
-						}
-					}
-
-					return Object.keys(expected).every(function (key) {
-						var eo = expected[key];
-						var ao = actual[key];
-						if (typeof(eo) === 'object' && eo !== null && ao !== null) {
-							return compare(eo, ao);
-						}
-						if (typeof(eo) === 'function') {
-							return eo(ao);
-						}
-						return ao === eo;
-					});
-				}
-			});
-
-		}).call(chaiSubset); 
-	} (chaiSubset$1));
-	return chaiSubset$1.exports;
-}
-
-var chaiSubsetExports = requireChaiSubset();
-var Subset = /*@__PURE__*/getDefaultExportFromCjs(chaiSubsetExports);
-
 function createAssertionMessage(util, assertion, hasArgs) {
-	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}`;
+	const not = util.flag(assertion, "negate") ? "not." : "", name = `${util.flag(assertion, "_name")}(${"expected" })`, promiseName = util.flag(assertion, "promise");
+	return `expect(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
 }
 function recordAsyncExpect(_test, promise, assertion, error) {
 	const test = _test;
@@ -206,7 +107,7 @@ function recordAsyncExpect(_test, promise, assertion, error) {
 		let resolved = false;
 		return test.onFinished ??= [], test.onFinished.push(() => {
 			if (!resolved) {
-				const processor = globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""), stack = processor(error.stack);
+				const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(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. ",
@@ -264,9 +165,7 @@ const SnapshotPlugin = (chai, utils) => {
 		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"`);
+		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;
 		const errorMessage = utils.flag(this, "message");
@@ -280,9 +179,7 @@ const SnapshotPlugin = (chai, utils) => {
 		});
 	});
 	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 (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({
 			received: expected,
 			message,
@@ -293,11 +190,9 @@ const SnapshotPlugin = (chai, utils) => {
 		});
 		return recordAsyncExpect(test, promise, createAssertionMessage(utils, this), error);
 	}), 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), isInsideEach = test.each || test.suite?.each;
-		if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+		if (utils.flag(this, "_name", "toMatchInlineSnapshot"), 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;
 		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
@@ -313,9 +208,7 @@ const SnapshotPlugin = (chai, utils) => {
 			...getTestNames(test)
 		});
 	}), 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 (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");
 		getSnapshotClient().assert({
 			received: getError(expected, promise),
@@ -324,10 +217,9 @@ const SnapshotPlugin = (chai, utils) => {
 			...getTestNames(test)
 		});
 	}), 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), isInsideEach = test.each || test.suite?.each;
-		if (isInsideEach) throw new Error("InlineSnapshot cannot be used inside of test.each or describe.each");
+		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");
 		if (inlineSnapshot) inlineSnapshot = stripSnapshotIndentation(inlineSnapshot);
 		getSnapshotClient().assert({
@@ -342,16 +234,16 @@ const SnapshotPlugin = (chai, utils) => {
 	}), 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.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$1.expect(value, message), _test = test || getCurrentTest();
+		const assert = chai.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);
+	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({
@@ -365,11 +257,11 @@ function createExpect(test) {
 			return getWorkerState().filepath;
 		},
 		currentTestName: test ? getTestName(test) : globalState.currentTestName
-	}, expect), expect.extend = (matchers) => chai$1.expect.extend(expect, matchers), expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters), expect.soft = (...args) => {
+	}, expect), expect.extend = (matchers) => chai.expect.extend(expect, matchers), expect.addEqualityTesters = (customTesters) => addCustomEqualityTesters(customTesters), expect.soft = (...args) => {
 		// @ts-expect-error private soft access
 		return expect(...args).withContext({ soft: true });
 	}, expect.poll = createExpectPoll(expect), expect.unreachable = (message) => {
-		chai$1.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+		chai.assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
 	};
 	function assertions(expected) {
 		const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
@@ -387,7 +279,7 @@ function createExpect(test) {
 			isExpectingAssertionsError: error
 		});
 	}
-	return chai$1.util.addMethod(expect, "assertions", assertions), chai$1.util.addMethod(expect, "hasAssertions", hasAssertions), expect.extend(customMatchers), expect;
+	return chai.util.addMethod(expect, "assertions", assertions), chai.util.addMethod(expect, "hasAssertions", hasAssertions), expect.extend(customMatchers), expect;
 }
 const globalExpect = createExpect();
 Object.defineProperty(globalThis, GLOBAL_EXPECT, {
@@ -395,16 +287,15 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
 	writable: true,
 	configurable: true
 });
-const assert = chai$1.assert;
-const should = chai$1.should;
+const assert = chai.assert;
+const should = chai.should;
 
 /**
 * Gives access to injected context provided from the main thread.
 * This usually returns a value provided by `globalSetup` or an external library.
 */
 function inject(key) {
-	const workerState = getWorkerState();
-	return workerState.providedContext[key];
+	return getWorkerState().providedContext[key];
 }
 
 var fakeTimersSrc = {};
@@ -3859,10 +3750,10 @@ function _mocker() {
 	} });
 }
 function getImporter(name) {
-	const stackTrace = createSimpleStackTrace({ stackTraceLimit: 5 }), stackArray = stackTrace.split("\n"), importerStackIndex = stackArray.findLastIndex((stack) => {
+	const stackArray = createSimpleStackTrace({ stackTraceLimit: 5 }).split("\n"), importerStackIndex = stackArray.findLastIndex((stack) => {
 		return stack.includes(` at Object.${name}`) || stack.includes(`${name}@`);
-	}), stack = parseSingleStack(stackArray[importerStackIndex + 1]);
-	return stack?.file || "";
+	});
+	return parseSingleStack(stackArray[importerStackIndex + 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 };

package/dist/chunks/{worker.rPGLlbkW.js → worker.DVTUM2IW.js}

@@ -4,11 +4,11 @@ import { readFileSync } from 'node:fs';
 import { isBuiltin } from 'node:module';
 import { pathToFileURL } from 'node:url';
 import { resolve } from 'pathe';
-import { b as VitestTransport } from './startModuleRunner.oAuCu1yL.js';
-import { e as environments } from './index.DIWhzsUh.js';
-import { s as setupInspect } from './inspector.CvQD-Nie.js';
-import { c as createRuntimeRpc, a as rpcDone } from './rpc.jKGRSXIH.js';
-import { i as isChildProcess } from './utils.DGKhod2J.js';
+import { b as VitestTransport } from './startModuleRunner.DPBo3mme.js';
+import { e as environments } from './index.Bt-upxGS.js';
+import { s as setupInspect } from './inspector.Br76Q2Mb.js';
+import { c as createRuntimeRpc, a as rpcDone } from './rpc.cD77ENhU.js';
+import { i as isChildProcess } from './utils.CG9h5ccR.js';
 
 function isBuiltinEnvironment(env) {
 	return env in environments;
@@ -24,13 +24,10 @@ async function createEnvironmentLoader(root, rpc) {
 			transport: new VitestTransport({
 				async fetchModule(id, importer, options) {
 					const result = await rpc.fetch(id, importer, "__vitest__", options);
-					if ("cached" in result) {
-						const code = readFileSync(result.tmp, "utf-8");
-						return {
-							code,
-							...result
-						};
-					}
+					if ("cached" in result) return {
+						code: readFileSync(result.tmp, "utf-8"),
+						...result
+					};
 					if (isWindows && "externalize" in result)
  // TODO: vitest returns paths for external modules, but Vite returns file://
 					// https://github.com/vitejs/vite/pull/20449
@@ -119,8 +116,7 @@ function parseRegexp(input) {
 }
 
 if (isChildProcess()) {
-	const isProfiling = process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"));
-	if (isProfiling)
+	if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir")))
  // Work-around for nodejs/node#55094
 	process.on("SIGTERM", () => {
 		process.exit();
@@ -186,7 +182,7 @@ function createImportMetaEnvProxy() {
 	];
 	return new Proxy(process.env, {
 		get(_, key) {
-			return typeof key === "string" ? booleanKeys.includes(key) ? !!process.env[key] : process.env[key] : void 0;
+			if (typeof key === "string") return booleanKeys.includes(key) ? !!process.env[key] : process.env[key];
 		},
 		set(_, key, value) {
 			if (typeof key !== "string") return true;

package/dist/chunks/{worker.d.B_Fd9M_w.d.ts → worker.d.buwuBpBt.d.ts}

@@ -1,6 +1,6 @@
 import { CancelReason, File, TestAnnotation, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
 import { FetchFunctionOptions, FetchResult, EvaluatedModules } from 'vite/module-runner';
-import { a as SerializedConfig } from './config.d.B_LthbQq.js';
+import { a as SerializedConfig } from './config.d.DGazh2r6.js';
 import { F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.BsToaxti.js';
 import { SnapshotResult } from '@vitest/snapshot';