vitest 0.14.1 → 0.15.1

package/dist/{chunk-api-setup.7945baf8.mjs → chunk-api-setup.ff687d0e.mjs}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.d6687931.mjs';
+import { c as createBirpc } from './chunk-vite-node-utils.c0a0e1b3.mjs';
 import require$$0$1 from 'stream';
 import require$$0 from 'zlib';
 import require$$3 from 'net';
@@ -9,11 +9,11 @@ import require$$2 from 'events';
 import require$$1 from 'https';
 import require$$2$1 from 'http';
 import url from 'url';
-import { A as API_PATH } from './chunk-constants.41584d81.mjs';
-import { j as interpretSourcePos, b as parseStacktrace } from './chunk-utils-source-map.4408ba82.mjs';
+import { A as API_PATH } from './chunk-constants.7b9cfc82.mjs';
+import { j as interpretSourcePos, b as parseStacktrace } from './chunk-utils-source-map.2556cba8.mjs';
 import 'module';
 import 'vm';
-import './chunk-utils-global.624991bc.mjs';
+import './chunk-utils-global.79a8b1cc.mjs';
 import 'tty';
 import 'local-pkg';
 import 'path';
@@ -126,6 +126,9 @@ var constants = {
   NOOP: () => {}
 };
 
+var unmask$1;
+var mask;
+
 const { EMPTY_BUFFER: EMPTY_BUFFER$3 } = constants;
 
 /**
@@ -225,30 +228,31 @@ function toBuffer$2(data) {
   return buf;
 }
 
-try {
-  const bufferUtil = require('bufferutil');
+bufferUtil$1.exports = {
+  concat: concat$1,
+  mask: _mask,
+  toArrayBuffer: toArrayBuffer$1,
+  toBuffer: toBuffer$2,
+  unmask: _unmask
+};
+
+/* istanbul ignore else  */
+if (!process.env.WS_NO_BUFFER_UTIL) {
+  try {
+    const bufferUtil = require('bufferutil');
 
-  bufferUtil$1.exports = {
-    concat: concat$1,
-    mask(source, mask, output, offset, length) {
+    mask = bufferUtil$1.exports.mask = function (source, mask, output, offset, length) {
       if (length < 48) _mask(source, mask, output, offset, length);
       else bufferUtil.mask(source, mask, output, offset, length);
-    },
-    toArrayBuffer: toArrayBuffer$1,
-    toBuffer: toBuffer$2,
-    unmask(buffer, mask) {
+    };
+
+    unmask$1 = bufferUtil$1.exports.unmask = function (buffer, mask) {
       if (buffer.length < 32) _unmask(buffer, mask);
       else bufferUtil.unmask(buffer, mask);
-    }
-  };
-} catch (e) /* istanbul ignore next */ {
-  bufferUtil$1.exports = {
-    concat: concat$1,
-    mask: _mask,
-    toArrayBuffer: toArrayBuffer$1,
-    toBuffer: toBuffer$2,
-    unmask: _unmask
-  };
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
 }
 
 const kDone = Symbol('kDone');
@@ -817,6 +821,8 @@ function inflateOnError(err) {
 
 var validation = {exports: {}};
 
+var isValidUTF8_1;
+
 //
 // Allowed token characters:
 //
@@ -922,22 +928,23 @@ function _isValidUTF8(buf) {
   return true;
 }
 
-try {
-  const isValidUTF8 = require('utf-8-validate');
+validation.exports = {
+  isValidStatusCode: isValidStatusCode$2,
+  isValidUTF8: _isValidUTF8,
+  tokenChars: tokenChars$2
+};
 
-  validation.exports = {
-    isValidStatusCode: isValidStatusCode$2,
-    isValidUTF8(buf) {
+/* istanbul ignore else  */
+if (!process.env.WS_NO_UTF_8_VALIDATE) {
+  try {
+    const isValidUTF8 = require('utf-8-validate');
+
+    isValidUTF8_1 = validation.exports.isValidUTF8 = function (buf) {
       return buf.length < 150 ? _isValidUTF8(buf) : isValidUTF8(buf);
-    },
-    tokenChars: tokenChars$2
-  };
-} catch (e) /* istanbul ignore next */ {
-  validation.exports = {
-    isValidStatusCode: isValidStatusCode$2,
-    isValidUTF8: _isValidUTF8,
-    tokenChars: tokenChars$2
-  };
+    };
+  } catch (e) {
+    // Continue regardless of the error.
+  }
 }
 
 const { Writable } = require$$0$1;

package/dist/{chunk-constants.41584d81.mjs → chunk-constants.7b9cfc82.mjs}

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'url';
-import { l as resolve } from './chunk-utils-global.624991bc.mjs';
+import { m as resolve } from './chunk-utils-global.79a8b1cc.mjs';
 
 const distDir = resolve(fileURLToPath(import.meta.url), "../../dist");
 const defaultPort = 51204;

package/dist/{chunk-defaults.a820faeb.mjs → chunk-defaults.dc6dc23d.mjs}

@@ -1,7 +1,142 @@
 import { existsSync, promises } from 'fs';
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
-import { t as toArray, l as resolve } from './chunk-utils-global.624991bc.mjs';
+import { C as toArray, m as resolve } from './chunk-utils-global.79a8b1cc.mjs';
+
+/*
+How it works:
+`this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
+*/
+
+class Node {
+	value;
+	next;
+
+	constructor(value) {
+		this.value = value;
+	}
+}
+
+class Queue {
+	#head;
+	#tail;
+	#size;
+
+	constructor() {
+		this.clear();
+	}
+
+	enqueue(value) {
+		const node = new Node(value);
+
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+
+		this.#size++;
+	}
+
+	dequeue() {
+		const current = this.#head;
+		if (!current) {
+			return;
+		}
+
+		this.#head = this.#head.next;
+		this.#size--;
+		return current.value;
+	}
+
+	clear() {
+		this.#head = undefined;
+		this.#tail = undefined;
+		this.#size = 0;
+	}
+
+	get size() {
+		return this.#size;
+	}
+
+	* [Symbol.iterator]() {
+		let current = this.#head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+}
+
+function pLimit(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
+
+	const queue = new Queue();
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.size > 0) {
+			queue.dequeue()();
+		}
+	};
+
+	const run = async (fn, resolve, args) => {
+		activeCount++;
+
+		const result = (async () => fn(...args))();
+
+		resolve(result);
+
+		try {
+			await result;
+		} catch {}
+
+		next();
+	};
+
+	const enqueue = (fn, resolve, args) => {
+		queue.enqueue(run.bind(undefined, fn, resolve, args));
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
+	};
+
+	const generator = (fn, ...args) => new Promise(resolve => {
+		enqueue(fn, resolve, args);
+	});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount,
+		},
+		pendingCount: {
+			get: () => queue.size,
+		},
+		clearQueue: {
+			value: () => {
+				queue.clear();
+			},
+		},
+	});
+
+	return generator;
+}
 
 const defaultInclude = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
 const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/cypress/**", "**/.{idea,git,cache,output,temp}/**"];
@@ -64,8 +199,12 @@ const config = {
   ui: false,
   uiBase: "/__vitest__/",
   open: true,
+  css: {
+    include: [/\.module\./]
+  },
   coverage: coverageConfigDefaults,
-  fakeTimers: fakeTimersDefaults
+  fakeTimers: fakeTimersDefaults,
+  maxConcurrency: 5
 };
 const configDefaults = Object.freeze(config);
 
@@ -160,4 +299,4 @@ async function reportCoverage(ctx) {
   }
 }
 
-export { cleanCoverage as a, reportCoverage as b, configDefaults as c, resolveC8Options as r, takeCoverage as t };
+export { cleanCoverage as a, reportCoverage as b, configDefaults as c, pLimit as p, resolveC8Options as r, takeCoverage as t };

package/dist/{chunk-install-pkg.6f5930c3.mjs → chunk-install-pkg.3fa50769.mjs}

@@ -2,7 +2,7 @@ import path$2 from 'path';
 import fs$2 from 'fs';
 import require$$0 from 'util';
 import childProcess$1 from 'child_process';
-import { p as pathKey, s as signalExit, m as mergeStream$1, g as getStream$1, c as crossSpawn$1, o as onetime$1 } from './vendor-index.a2a385d8.mjs';
+import { p as pathKey, s as signalExit, m as mergeStream$1, g as getStream$1, c as crossSpawn$1, o as onetime$1 } from './vendor-index.e5dc6622.mjs';
 import require$$0$1 from 'os';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
 import 'assert';

package/dist/{chunk-integrations-globals.f0c5e97f.mjs → chunk-integrations-globals.df0878f4.mjs}

@@ -1,20 +1,20 @@
-import { g as globalApis } from './chunk-constants.41584d81.mjs';
-import { i as index } from './vendor-entry.93b045ee.mjs';
+import { g as globalApis } from './chunk-constants.7b9cfc82.mjs';
+import { i as index } from './vendor-entry.7ec02ea2.mjs';
 import 'url';
-import './chunk-utils-global.624991bc.mjs';
+import './chunk-utils-global.79a8b1cc.mjs';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'fs';
-import './chunk-runtime-chain.6a3c6576.mjs';
+import './chunk-runtime-chain.ce7f4b92.mjs';
 import 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.44043bb4.mjs';
-import './chunk-utils-source-map.4408ba82.mjs';
+import './chunk-runtime-rpc.5e78af38.mjs';
+import './chunk-utils-source-map.2556cba8.mjs';
 import './chunk-integrations-spy.674b628e.mjs';
 import 'tinyspy';
 import 'util';
-import './chunk-defaults.a820faeb.mjs';
+import './chunk-defaults.dc6dc23d.mjs';
 import 'module';
 
 function registerApiGlobally() {

package/dist/{chunk-runtime-chain.6a3c6576.mjs → chunk-runtime-chain.ce7f4b92.mjs}

@@ -1,9 +1,9 @@
-import chai$1, { expect as expect$1, AssertionError, util } from 'chai';
+import chai$1, { expect, AssertionError, util } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { r as rpc } from './chunk-runtime-rpc.44043bb4.mjs';
-import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, a as getWorkerState, b as getNames, c as assertTypes, p as picocolors, e as safeSetTimeout, f as safeClearTimeout, n as noop, t as toArray, r as resetModules } from './chunk-utils-global.624991bc.mjs';
+import { r as rpc } from './chunk-runtime-rpc.5e78af38.mjs';
+import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, a as getWorkerState, b as getNames, c as assertTypes, p as picocolors, e as getFullName, f as safeSetTimeout, h as safeClearTimeout, n as noop, r as resetModules } from './chunk-utils-global.79a8b1cc.mjs';
 import fs, { promises } from 'fs';
-import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.4408ba82.mjs';
+import { p as plugins_1, f as format_1, g as getOriginalPos, a as posToNumber, n as numberToPos, l as lineSplitRE, b as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.2556cba8.mjs';
 import { i as isMockFunction, s as spyOn, f as fn, a as spies } from './chunk-integrations-spy.674b628e.mjs';
 import require$$0, { format } from 'util';
 
@@ -375,6 +375,18 @@ const sparseArrayEquality = (a, b) => {
   const bKeys = Object.keys(b);
   return equals(a, b, [iterableEquality, typeEquality], true) && equals(aKeys, bKeys);
 };
+const generateToBeMessage = (deepEqualityName, expected = "#{this}", actual = "#{exp}") => {
+  const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
+  if (["toStrictEqual", "toEqual"].includes(deepEqualityName))
+    return `${toBeMessage}
+
+If it should pass with deep equality, replace "toBe" with "${deepEqualityName}"
+
+Expected: ${expected}
+Received: serializes to the same string
+`;
+  return toBeMessage;
+};
 
 var naturalCompare$1 = {exports: {}};
 
@@ -526,11 +538,15 @@ function normalizeNewlines(string) {
 }
 async function saveSnapshotFile(snapshotData, snapshotPath) {
   const snapshots = Object.keys(snapshotData).sort(naturalCompare$1.exports).map((key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);
-  ensureDirectoryExists(snapshotPath);
-  await promises.writeFile(snapshotPath, `${writeSnapshotVersion()}
+  const content = `${writeSnapshotVersion()}
 
 ${snapshots.join("\n\n")}
-`, "utf-8");
+`;
+  const skipWriting = fs.existsSync(snapshotPath) && await promises.readFile(snapshotPath, "utf8") === content;
+  if (skipWriting)
+    return;
+  ensureDirectoryExists(snapshotPath);
+  await promises.writeFile(snapshotPath, content, "utf-8");
 }
 function prepareExpected(expected) {
   function findStartIndent() {
@@ -924,7 +940,7 @@ class SnapshotClient {
       try {
         const pass2 = equals(received, properties, [iterableEquality, subsetEquality]);
         if (!pass2)
-          expect$1(received).equals(properties);
+          expect(received).equals(properties);
         else
           received = deepMergeSnapshot(received, properties);
       } catch (err) {
@@ -946,7 +962,7 @@ class SnapshotClient {
     });
     if (!pass) {
       try {
-        expect$1(actual.trim()).equals(expected ? expected.trim() : "");
+        expect(actual.trim()).equals(expected ? expected.trim() : "");
       } catch (error2) {
         error2.message = errorMessage || `Snapshot \`${key || "unknown"}\` mismatched`;
         throw error2;
@@ -1052,24 +1068,20 @@ const SnapshotPlugin = (chai, utils) => {
   });
 };
 
+const GLOBAL_EXPECT = Symbol.for("expect-global");
 const MATCHERS_OBJECT = Symbol.for("matchers-object");
-if (!Object.prototype.hasOwnProperty.call(global, MATCHERS_OBJECT)) {
-  const defaultState = {
-    assertionCalls: 0,
-    isExpectingAssertions: false,
-    isExpectingAssertionsError: null,
-    expectedAssertionsNumber: null,
-    expectedAssertionsNumberErrorGen: null
-  };
+
+if (!Object.prototype.hasOwnProperty.call(globalThis, MATCHERS_OBJECT)) {
   Object.defineProperty(globalThis, MATCHERS_OBJECT, {
-    value: {
-      state: defaultState
-    }
+    value: /* @__PURE__ */ new WeakMap()
   });
 }
-const getState = () => globalThis[MATCHERS_OBJECT].state;
-const setState = (state) => {
-  Object.assign(globalThis[MATCHERS_OBJECT].state, state);
+const getState = (expect) => globalThis[MATCHERS_OBJECT].get(expect);
+const setState = (state, expect) => {
+  const map = globalThis[MATCHERS_OBJECT];
+  const current = map.get(expect) || {};
+  Object.assign(current, state);
+  map.set(expect, current);
 };
 const JestChaiExpect = (chai, utils) => {
   function def(name, fn) {
@@ -1127,7 +1139,24 @@ const JestChaiExpect = (chai, utils) => {
   });
   def("toBe", function(expected) {
     const actual = this._obj;
-    return this.assert(Object.is(actual, expected), "expected #{this} to be #{exp} // Object.is equality", "expected #{this} not to be #{exp} // Object.is equality", expected, actual);
+    const pass = Object.is(actual, expected);
+    let deepEqualityName = "";
+    if (!pass) {
+      const toStrictEqualPass = equals(actual, expected, [
+        iterableEquality,
+        typeEquality,
+        sparseArrayEquality,
+        arrayBufferEquality
+      ], true);
+      if (toStrictEqualPass) {
+        deepEqualityName = "toStrictEqual";
+      } else {
+        const toEqualPass = equals(actual, expected, [iterableEquality]);
+        if (toEqualPass)
+          deepEqualityName = "toEqual";
+      }
+    }
+    return this.assert(pass, generateToBeMessage(deepEqualityName), "expected #{this} not to be #{exp} // Object.is equality", expected, actual);
   });
   def("toMatchObject", function(expected) {
     const actual = this._obj;
@@ -1456,24 +1485,6 @@ Number of calls: ${picocolors.exports.bold(spy.mock.calls.length)}
     });
     return proxy;
   });
-  utils.addMethod(chai.expect, "assertions", function assertions(expected) {
-    const errorGen = () => new Error(`expected number of assertions to be ${expected}, but got ${getState().assertionCalls}`);
-    if (Error.captureStackTrace)
-      Error.captureStackTrace(errorGen(), assertions);
-    setState({
-      expectedAssertionsNumber: expected,
-      expectedAssertionsNumberErrorGen: errorGen
-    });
-  });
-  utils.addMethod(chai.expect, "hasAssertions", function hasAssertions() {
-    const error = new Error("expected any number of assertion, but got none");
-    if (Error.captureStackTrace)
-      Error.captureStackTrace(error, hasAssertions);
-    setState({
-      isExpectingAssertions: true,
-      isExpectingAssertionsError: error
-    });
-  });
   utils.addMethod(chai.expect, "addSnapshotSerializer", addSerializer);
 };
 function toString(value) {
@@ -1509,8 +1520,8 @@ class AsymmetricMatcher {
     this.inverse = inverse;
     this.$$typeof = Symbol.for("jest.asymmetricMatcher");
   }
-  getMatcherContext() {
-    return __spreadProps$1(__spreadValues$2({}, getState()), {
+  getMatcherContext(expect) {
+    return __spreadProps$1(__spreadValues$2({}, getState(expect || globalThis[GLOBAL_EXPECT])), {
       equals,
       isNot: this.inverse,
       utils: matcherUtils
@@ -1704,7 +1715,7 @@ var __spreadValues$1 = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 const isAsyncFunction = (fn) => typeof fn === "function" && fn[Symbol.toStringTag] === "AsyncFunction";
-const getMatcherState = (assertion) => {
+const getMatcherState = (assertion, expect) => {
   const obj = assertion._obj;
   const isNot = util.flag(assertion, "negate");
   const promise = util.flag(assertion, "promise") || "";
@@ -1712,7 +1723,7 @@ const getMatcherState = (assertion) => {
     iterableEquality,
     subsetEquality
   });
-  const matcherState = __spreadProps(__spreadValues$1({}, getState()), {
+  const matcherState = __spreadProps(__spreadValues$1({}, getState(expect)), {
     isNot,
     utils: jestUtils,
     promise,
@@ -1737,13 +1748,13 @@ function JestExtendPlugin(expect, matchers) {
   return (c, utils) => {
     Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
       function expectSyncWrapper(...args) {
-        const { state, isNot, obj } = getMatcherState(this);
+        const { state, isNot, obj } = getMatcherState(this, expect);
         const { pass, message, actual, expected } = expectAssertion.call(state, obj, ...args);
         if (pass && isNot || !pass && !isNot)
           throw new JestExtendError(message(), actual, expected);
       }
       async function expectAsyncWrapper(...args) {
-        const { state, isNot, obj } = getMatcherState(this);
+        const { state, isNot, obj } = getMatcherState(this, expect);
         const { pass, message, actual, expected } = await expectAssertion.call(state, obj, ...args);
         if (pass && isNot || !pass && !isNot)
           throw new JestExtendError(message(), actual, expected);
@@ -1755,7 +1766,7 @@ function JestExtendPlugin(expect, matchers) {
           super(sample, inverse);
         }
         asymmetricMatch(other) {
-          const { pass } = expectAssertion.call(this.getMatcherContext(), other, ...this.sample);
+          const { pass } = expectAssertion.call(this.getMatcherContext(expect), other, ...this.sample);
           return this.inverse ? !pass : pass;
         }
         toString() {
@@ -1796,22 +1807,55 @@ chai$1.use(SnapshotPlugin);
 chai$1.use(JestAsymmetricMatchers);
 
 function createExpect(test) {
-  const expect2 = (value, message) => {
-    const { assertionCalls } = getState();
-    setState({ assertionCalls: assertionCalls + 1 });
+  var _a;
+  const expect = (value, message) => {
+    const { assertionCalls } = getState(expect);
+    setState({ assertionCalls: assertionCalls + 1 }, expect);
     const assert2 = chai$1.expect(value, message);
     if (test)
       return assert2.withTest(test);
     else
       return assert2;
   };
-  Object.assign(expect2, chai$1.expect);
-  expect2.getState = getState;
-  expect2.setState = setState;
-  expect2.extend = (matchers) => chai$1.expect.extend(expect2, matchers);
-  return expect2;
+  Object.assign(expect, chai$1.expect);
+  expect.getState = () => getState(expect);
+  expect.setState = (state) => setState(state, expect);
+  setState({
+    assertionCalls: 0,
+    isExpectingAssertions: false,
+    isExpectingAssertionsError: null,
+    expectedAssertionsNumber: null,
+    expectedAssertionsNumberErrorGen: null,
+    testPath: (_a = test == null ? void 0 : test.suite.file) == null ? void 0 : _a.filepath,
+    currentTestName: test ? getFullName(test) : void 0
+  }, expect);
+  expect.extend = (matchers) => chai$1.expect.extend(expect, matchers);
+  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);
+    expect.setState({
+      expectedAssertionsNumber: expected,
+      expectedAssertionsNumberErrorGen: errorGen
+    });
+  }
+  function hasAssertions() {
+    const error = new Error("expected any number of assertion, but got none");
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(error, hasAssertions);
+    expect.setState({
+      isExpectingAssertions: true,
+      isExpectingAssertionsError: error
+    });
+  }
+  util.addMethod(expect, "assertions", assertions);
+  util.addMethod(expect, "hasAssertions", hasAssertions);
+  return expect;
 }
-const expect = createExpect();
+const globalExpect = createExpect();
+Object.defineProperty(globalThis, GLOBAL_EXPECT, {
+  value: globalExpect
+});
 
 const collectorContext = {
   tasks: [],
@@ -1860,6 +1904,11 @@ function createTestContext(test) {
       return _expect;
     }
   });
+  Object.defineProperty(context, "_local", {
+    get() {
+      return _expect != null;
+    }
+  });
   return context;
 }
 function makeTimeoutMsg(isHook, timeout) {
@@ -1999,7 +2048,7 @@ function createSuite() {
   suite2.each = (cases) => {
     return (name, fn) => {
       cases.forEach((i, idx) => {
-        const items = toArray(i);
+        const items = Array.isArray(i) ? i : [i];
         suite2(formatTitle(name, items, idx), () => fn(...items));
       });
     };
@@ -2013,7 +2062,7 @@ function createTest(fn) {
   test2.each = (cases) => {
     return (name, fn2) => {
       cases.forEach((i, idx) => {
-        const items = toArray(i);
+        const items = Array.isArray(i) ? i : [i];
         test2(formatTitle(name, items, idx), () => fn2(...items));
       });
     };
@@ -2080,7 +2129,7 @@ if (typeof commonjsGlobal !== "undefined") {
     globalObject$1 = self;
 }
 
-var global$1 = globalObject$1;
+var global = globalObject$1;
 
 var call = Function.call;
 
@@ -2788,7 +2837,7 @@ function valueToString(value) {
 var valueToString_1 = valueToString;
 
 var lib = {
-    global: global$1,
+    global: global,
     calledInOrder: calledInOrder_1,
     className: className_1,
     deprecated: deprecated,
@@ -4558,7 +4607,11 @@ function withGlobal(_global) {
 /* eslint-enable complexity */
 
 /** @type {FakeTimers} */
-withGlobal(globalObject);
+const defaultImplementation = withGlobal(globalObject);
+
+defaultImplementation.timers;
+defaultImplementation.createClock;
+defaultImplementation.install;
 var withGlobal_1 = withGlobal;
 
 const RealDate = Date;
@@ -4872,4 +4925,4 @@ function isWatchMode() {
   return getRunningMode() === "watch";
 }
 
-export { getState as A, RealDate as R, isFirstRun as a, beforeAll as b, afterAll as c, describe as d, beforeEach as e, afterEach as f, createExpect as g, expect as h, it as i, vi as j, getRunningMode as k, isWatchMode as l, resetRunOnceCounter as m, clearCollectorContext as n, defaultSuite as o, setHooks as p, getHooks as q, runOnce as r, suite as s, test as t, collectorContext as u, vitest as v, withCallback as w, getSnapshotClient as x, setState as y, getFn as z };
+export { getState as A, GLOBAL_EXPECT as G, RealDate as R, isFirstRun as a, beforeAll as b, afterAll as c, describe as d, beforeEach as e, afterEach as f, createExpect as g, globalExpect as h, it as i, vi as j, getRunningMode as k, isWatchMode as l, resetRunOnceCounter as m, clearCollectorContext as n, defaultSuite as o, setHooks as p, getHooks as q, runOnce as r, suite as s, test as t, collectorContext as u, vitest as v, withCallback as w, getSnapshotClient as x, setState as y, getFn as z };