vitest 0.14.2 → 0.15.2

package/dist/{chunk-api-setup.aa092488.mjs → chunk-api-setup.8cd5e92a.mjs}

@@ -1,5 +1,5 @@
 import { promises } from 'fs';
-import { c as createBirpc } from './chunk-vite-node-utils.b9738a10.mjs';
+import { c as createBirpc } from './chunk-vite-node-utils.1bbdb2c1.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.da1921b9.mjs';
-import { j as interpretSourcePos, b as parseStacktrace } from './chunk-utils-source-map.790e5c11.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.2684ee9f.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.da1921b9.mjs → chunk-constants.7b9cfc82.mjs}

@@ -1,5 +1,5 @@
 import { fileURLToPath } from 'url';
-import { l as resolve } from './chunk-utils-global.2684ee9f.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.45dc5e3d.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.2684ee9f.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-integrations-globals.edcc399b.mjs → chunk-integrations-globals.d0c363a6.mjs}

@@ -1,20 +1,20 @@
-import { g as globalApis } from './chunk-constants.da1921b9.mjs';
-import { i as index } from './vendor-entry.ba490394.mjs';
+import { g as globalApis } from './chunk-constants.7b9cfc82.mjs';
+import { i as index } from './vendor-entry.efeeaa5c.mjs';
 import 'url';
-import './chunk-utils-global.2684ee9f.mjs';
+import './chunk-utils-global.79a8b1cc.mjs';
 import 'tty';
 import 'local-pkg';
 import 'path';
 import 'fs';
-import './chunk-runtime-chain.52571387.mjs';
+import './chunk-runtime-chain.7103058b.mjs';
 import 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.bcd3613c.mjs';
-import './chunk-utils-source-map.790e5c11.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.45dc5e3d.mjs';
+import './chunk-defaults.dc6dc23d.mjs';
 import 'module';
 
 function registerApiGlobally() {

package/dist/{chunk-runtime-chain.52571387.mjs → chunk-runtime-chain.7103058b.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.bcd3613c.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.2684ee9f.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.790e5c11.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';
 
@@ -737,7 +737,7 @@ class SnapshotState {
         this._uncheckedKeys.delete(uncheckedKey);
     });
   }
-  _getInlineSnapshotStack(stacks) {
+  _inferInlineSnapshotStack(stacks) {
     const promiseIndex = stacks.findIndex((i) => i.method.match(/__VITEST_(RESOLVES|REJECTS)__/));
     if (promiseIndex !== -1)
       return stacks[promiseIndex + 3];
@@ -750,11 +750,12 @@ class SnapshotState {
       const error = options.error || new Error("Unknown error");
       const stacks = parseStacktrace(error, true);
       stacks.forEach((i) => i.file = slash(i.file));
-      const stack = this._getInlineSnapshotStack(stacks);
+      const stack = this._inferInlineSnapshotStack(stacks);
       if (!stack) {
         throw new Error(`Vitest: Couldn't infer stack frame for inline snapshot.
 ${JSON.stringify(stacks)}`);
       }
+      stack.column--;
       this._inlineSnapshots.push(__spreadValues$3({
         snapshot: receivedSerialized
       }, stack));
@@ -921,6 +922,10 @@ class SnapshotClient {
   clearTest() {
     this.test = void 0;
   }
+  skipTestSnapshots(test) {
+    var _a;
+    (_a = this.snapshotState) == null ? void 0 : _a.markSnapshotsAsCheckedForTest(test.name);
+  }
   assert(options) {
     const {
       test = this.test,
@@ -940,7 +945,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) {
@@ -962,7 +967,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;
@@ -1068,24 +1073,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) {
@@ -1489,24 +1490,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) {
@@ -1542,8 +1525,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
@@ -1737,7 +1720,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") || "";
@@ -1745,7 +1728,7 @@ const getMatcherState = (assertion) => {
     iterableEquality,
     subsetEquality
   });
-  const matcherState = __spreadProps(__spreadValues$1({}, getState()), {
+  const matcherState = __spreadProps(__spreadValues$1({}, getState(expect)), {
     isNot,
     utils: jestUtils,
     promise,
@@ -1770,13 +1753,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);
@@ -1788,7 +1771,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() {
@@ -1829,22 +1812,57 @@ 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,
+  writable: true,
+  configurable: true
+});
 
 const collectorContext = {
   tasks: [],
@@ -1893,6 +1911,11 @@ function createTestContext(test) {
       return _expect;
     }
   });
+  Object.defineProperty(context, "_local", {
+    get() {
+      return _expect != null;
+    }
+  });
   return context;
 }
 function makeTimeoutMsg(isHook, timeout) {
@@ -2032,7 +2055,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));
       });
     };
@@ -2046,7 +2069,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));
       });
     };
@@ -2113,7 +2136,7 @@ if (typeof commonjsGlobal !== "undefined") {
     globalObject$1 = self;
 }
 
-var global$1 = globalObject$1;
+var global = globalObject$1;
 
 var call = Function.call;
 
@@ -2821,7 +2844,7 @@ function valueToString(value) {
 var valueToString_1 = valueToString;
 
 var lib = {
-    global: global$1,
+    global: global,
     calledInOrder: calledInOrder_1,
     className: className_1,
     deprecated: deprecated,
@@ -4591,7 +4614,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;
@@ -4905,4 +4932,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 };

package/dist/{chunk-runtime-mocker.292c0e16.mjs → chunk-runtime-mocker.d3ca0a4e.mjs}

@@ -1,8 +1,8 @@
-import { n as normalizeRequestId, i as isNodeBuiltin, b as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.b9738a10.mjs';
+import { n as normalizeRequestId, i as isNodeBuiltin, b as toFilePath, V as ViteNodeRunner } from './chunk-vite-node-utils.1bbdb2c1.mjs';
 import { normalizePath } from 'vite';
-import { a as getWorkerState, J as isWindows, K as mergeSlashes, d as dirname, l as resolve, k as basename, L as getType, M as getAllProperties, s as slash } from './chunk-utils-global.2684ee9f.mjs';
+import { a as getWorkerState, J as isWindows, K as mergeSlashes, d as dirname, m as resolve, l as basename, L as getType, M as getAllProperties, s as slash } from './chunk-utils-global.79a8b1cc.mjs';
 import { existsSync, readdirSync } from 'fs';
-import { d as distDir } from './chunk-constants.da1921b9.mjs';
+import { d as distDir } from './chunk-constants.7b9cfc82.mjs';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;

package/dist/{chunk-runtime-rpc.bcd3613c.mjs → chunk-runtime-rpc.5e78af38.mjs}

@@ -1,4 +1,4 @@
-import { a as getWorkerState, w as withSafeTimers } from './chunk-utils-global.2684ee9f.mjs';
+import { a as getWorkerState, w as withSafeTimers } from './chunk-utils-global.79a8b1cc.mjs';
 
 const rpc = () => {
   const { rpc: rpc2 } = getWorkerState();

package/dist/{chunk-utils-global.2684ee9f.mjs → chunk-utils-global.79a8b1cc.mjs}

@@ -510,4 +510,4 @@ class AggregateErrorPonyfill extends Error {
   }
 }
 
-export { AggregateErrorPonyfill as A, safeSetInterval as B, safeClearInterval as C, normalize as D, deepMerge as E, toNamespacedPath as F, ensurePackageInstalled as G, stdout as H, extname as I, isWindows as J, mergeSlashes as K, getType as L, getAllProperties as M, deepClone as N, partitionSuiteChildren as O, hasTests as P, getWorkerState as a, getNames as b, assertTypes as c, dirname as d, safeSetTimeout as e, safeClearTimeout as f, getCallLastIndex as g, notNullish as h, isObject as i, join as j, basename as k, resolve as l, isAbsolute as m, noop as n, relative as o, picocolors as p, isNode as q, resetModules as r, slash as s, toArray as t, getTests as u, getFullName as v, withSafeTimers as w, hasFailed as x, hasFailedSnapshot as y, getSuites as z };
+export { AggregateErrorPonyfill as A, safeClearInterval as B, toArray as C, normalize as D, deepMerge as E, toNamespacedPath as F, ensurePackageInstalled as G, stdout as H, extname as I, isWindows as J, mergeSlashes as K, getType as L, getAllProperties as M, deepClone as N, partitionSuiteChildren as O, hasTests as P, getWorkerState as a, getNames as b, assertTypes as c, dirname as d, getFullName as e, safeSetTimeout as f, getCallLastIndex as g, safeClearTimeout as h, isObject as i, join as j, notNullish as k, basename as l, resolve as m, noop as n, isAbsolute as o, picocolors as p, relative as q, resetModules as r, slash as s, isNode as t, getTests as u, hasFailed as v, withSafeTimers as w, hasFailedSnapshot as x, getSuites as y, safeSetInterval as z };

package/dist/{chunk-utils-source-map.790e5c11.mjs → chunk-utils-source-map.2556cba8.mjs}

@@ -1,4 +1,4 @@
-import { s as slash, h as notNullish, p as picocolors } from './chunk-utils-global.2684ee9f.mjs';
+import { s as slash, k as notNullish, p as picocolors } from './chunk-utils-global.79a8b1cc.mjs';
 
 var build = {};