vitest 0.28.4 → 0.29.0

package/dist/{chunk-runtime-mocker.eb0c265c.js → chunk-runtime-mocker.a048e92d.js}

@@ -1,12 +1,16 @@
-import { ViteNodeRunner } from 'vite-node/client';
-import { isInternalRequest } from 'vite-node/utils';
-import { resolve, isAbsolute, dirname, join, basename, extname, normalize } from 'pathe';
+import { pathToFileURL } from 'node:url';
+import { ModuleCacheMap, ViteNodeRunner } from 'vite-node/client';
+import { isInternalRequest, isPrimitive } from 'vite-node/utils';
+import { isAbsolute, dirname, join, basename, extname, resolve, normalize, relative } from 'pathe';
 import { i as isNodeBuiltin } from './vendor-index.bdee400f.js';
-import { g as getWorkerState, b as getCurrentEnvironment } from './chunk-utils-global.442d1d33.js';
+import { processError } from '@vitest/runner/utils';
+import { g as getWorkerState, b as getCurrentEnvironment } from './chunk-utils-global.727b6d25.js';
+import { d as distDir } from './chunk-constants.797d3ebf.js';
 import { existsSync, readdirSync } from 'node:fs';
 import { getColors, getType } from '@vitest/utils';
-import { g as getAllMockableProperties } from './chunk-utils-base.904102a8.js';
-import { d as distDir } from './chunk-constants.797d3ebf.js';
+import { e as getAllMockableProperties } from './chunk-utils-base.81f83dbd.js';
+import { spyOn } from '@vitest/spy';
+import { r as rpc } from './chunk-runtime-rpc.971b3848.js';
 
 class RefTracker {
   constructor() {
@@ -30,21 +34,26 @@ function isSpecialProp(prop, parentType) {
   return parentType.includes("Function") && typeof prop === "string" && ["arguments", "callee", "caller", "length", "name"].includes(prop);
 }
 const _VitestMocker = class {
-  constructor(runner) {
-    this.runner = runner;
+  constructor(executor) {
+    this.executor = executor;
     this.resolveCache = /* @__PURE__ */ new Map();
   }
   get root() {
-    return this.runner.options.root;
+    return this.executor.options.root;
   }
   get base() {
-    return this.runner.options.base;
+    return this.executor.options.base;
   }
   get mockMap() {
-    return this.runner.options.mockMap;
+    return this.executor.options.mockMap;
   }
   get moduleCache() {
-    return this.runner.moduleCache;
+    return this.executor.moduleCache;
+  }
+  deleteCachedItem(id) {
+    const mockId = this.getMockPath(id);
+    if (this.moduleCache.has(mockId))
+      this.moduleCache.delete(mockId);
   }
   getSuiteFilepath() {
     return getWorkerState().filepath || "global";
@@ -59,7 +68,7 @@ const _VitestMocker = class {
     };
   }
   async resolvePath(rawId, importer) {
-    const [id, fsPath] = await this.runner.resolveUrl(rawId, importer);
+    const [id, fsPath] = await this.executor.resolveUrl(rawId, importer);
     const external = !isAbsolute(fsPath) || fsPath.includes("/node_modules/") ? rawId : null;
     return {
       id,
@@ -87,7 +96,7 @@ const _VitestMocker = class {
       exports = await mock();
     } catch (err) {
       const vitestError = new Error(
-        '[vitest] There was an error, when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/#vi-mock'
+        '[vitest] There was an error when mocking a module. If you are using "vi.mock" factory, make sure there are no top level variables inside, since this call is hoisted to top of the file. Read more: https://vitest.dev/api/#vi-mock'
       );
       vitestError.cause = err;
       throw vitestError;
@@ -103,6 +112,8 @@ const _VitestMocker = class {
           if (target instanceof Promise)
             return target.then.bind(target);
         } else if (!(prop in target)) {
+          if (prop === "__esModule")
+            return void 0;
           const c = getColors();
           throw new Error(
             `[vitest] No "${String(prop)}" export is defined on the "${mockpath}" mock. Did you forget to return it from "vi.mock"?
@@ -155,12 +166,6 @@ ${c.green(`vi.mock("${mockpath}", async () => {
     return existsSync(fullPath) ? fullPath : null;
   }
   mockObject(object, mockExports = {}) {
-    if (!_VitestMocker.spyModule) {
-      throw new Error(
-        "Error: Spy module is not defined. This is likely an internal bug in Vitest. Please report it to https://github.com/vitest-dev/vitest/issues"
-      );
-    }
-    const spyModule = _VitestMocker.spyModule;
     const finalizers = new Array();
     const refs = new RefTracker();
     const define = (container, key, value) => {
@@ -203,7 +208,7 @@ ${c.green(`vi.mock("${mockpath}", async () => {
         if (!define(newContainer, property, isFunction ? value : {}))
           continue;
         if (isFunction) {
-          spyModule.spyOn(newContainer, property).mockImplementation(() => void 0);
+          spyOn(newContainer, property).mockImplementation(() => void 0);
           Object.defineProperty(newContainer[property], "length", { value: 0 });
         }
         refs.track(value, newContainer[property]);
@@ -222,9 +227,7 @@ ${c.green(`vi.mock("${mockpath}", async () => {
     const mock = this.mockMap.get(suitefile);
     if (mock && id in mock)
       delete mock[id];
-    const mockId = this.getMockPath(id);
-    if (this.moduleCache.get(mockId))
-      this.moduleCache.delete(mockId);
+    this.deleteCachedItem(id);
   }
   mockPath(originalId, path, external, factory) {
     const suitefile = this.getSuiteFilepath();
@@ -235,10 +238,11 @@ ${c.green(`vi.mock("${mockpath}", async () => {
     resolves[id] = originalId;
     this.mockMap.set(suitefile, mocks);
     this.resolveCache.set(suitefile, resolves);
+    this.deleteCachedItem(id);
   }
   async importActual(rawId, importee) {
     const { id, fsPath } = await this.resolvePath(rawId, importee);
-    const result = await this.runner.cachedRequest(id, fsPath, [importee]);
+    const result = await this.executor.cachedRequest(id, fsPath, [importee]);
     return result;
   }
   async importMock(rawId, importee) {
@@ -248,17 +252,12 @@ ${c.green(`vi.mock("${mockpath}", async () => {
     if (mock === void 0)
       mock = this.resolveMockPath(fsPath, external);
     if (mock === null) {
-      const mod = await this.runner.cachedRequest(id, fsPath, [importee]);
+      const mod = await this.executor.cachedRequest(id, fsPath, [importee]);
       return this.mockObject(mod);
     }
     if (typeof mock === "function")
       return this.callFunctionMock(fsPath, mock);
-    return this.runner.dependencyRequest(mock, mock, [importee]);
-  }
-  async initializeSpyModule() {
-    if (_VitestMocker.spyModule)
-      return;
-    _VitestMocker.spyModule = await this.runner.executeId(_VitestMocker.spyModulePath);
+    return this.executor.dependencyRequest(mock, mock, [importee]);
   }
   async requestWithMock(url, callstack) {
     if (_VitestMocker.pendingIds.length)
@@ -272,7 +271,7 @@ ${c.green(`vi.mock("${mockpath}", async () => {
         return cache.exports;
       const exports = {};
       this.moduleCache.set(mockPath, { exports });
-      const mod = await this.runner.directRequest(url, url, callstack);
+      const mod = await this.executor.directRequest(url, url, callstack);
       this.mockObject(mod, exports);
       return exports;
     }
@@ -295,18 +294,55 @@ ${c.green(`vi.mock("${mockpath}", async () => {
 };
 let VitestMocker = _VitestMocker;
 VitestMocker.pendingIds = [];
-VitestMocker.spyModulePath = resolve(distDir, "spy.js");
 
-async function executeInViteNode(options) {
-  const runner = new VitestRunner(options);
+async function createVitestExecutor(options) {
+  const runner = new VitestExecutor(options);
   await runner.executeId("/@vite/env");
-  await runner.mocker.initializeSpyModule();
-  const result = [];
-  for (const file of options.files)
-    result.push(await runner.executeFile(file));
-  return result;
+  return runner;
+}
+let _viteNode;
+const moduleCache = new ModuleCacheMap();
+const mockMap = /* @__PURE__ */ new Map();
+async function startViteNode(ctx) {
+  if (_viteNode)
+    return _viteNode;
+  const { config } = ctx;
+  const processExit = process.exit;
+  process.exit = (code = process.exitCode || 0) => {
+    const error = new Error(`process.exit called with "${code}"`);
+    rpc().onWorkerExit(error, code);
+    return processExit(code);
+  };
+  function catchError(err, type) {
+    var _a;
+    const worker = getWorkerState();
+    const error = processError(err);
+    if (worker.filepath && !isPrimitive(error)) {
+      error.VITEST_TEST_NAME = (_a = worker.current) == null ? void 0 : _a.name;
+      error.VITEST_TEST_PATH = relative(config.root, worker.filepath);
+    }
+    rpc().onUnhandledError(error, type);
+  }
+  process.on("uncaughtException", (e) => catchError(e, "Uncaught Exception"));
+  process.on("unhandledRejection", (e) => catchError(e, "Unhandled Rejection"));
+  const executor = await createVitestExecutor({
+    fetchModule(id) {
+      return rpc().fetch(id, ctx.environment.name);
+    },
+    resolveId(id, importer) {
+      return rpc().resolveId(id, importer, ctx.environment.name);
+    },
+    moduleCache,
+    mockMap,
+    interopDefault: config.deps.interopDefault,
+    root: config.root,
+    base: config.base
+  });
+  const { run } = await import(pathToFileURL(resolve(distDir, "entry.js")).href);
+  _viteNode = { run, executor };
+  return _viteNode;
 }
-class VitestRunner extends ViteNodeRunner {
+class VitestExecutor extends ViteNodeRunner {
   constructor(options) {
     super(options);
     this.options = options;
@@ -323,10 +359,10 @@ class VitestRunner extends ViteNodeRunner {
     const environment = getCurrentEnvironment();
     return environment === "node" ? !isNodeBuiltin(id) : !id.startsWith("node:");
   }
-  async resolveUrl(id, importee) {
-    if (importee && importee.startsWith("mock:"))
-      importee = importee.slice(5);
-    return super.resolveUrl(id, importee);
+  async resolveUrl(id, importer) {
+    if (importer && importer.startsWith("mock:"))
+      importer = importer.slice(5);
+    return super.resolveUrl(id, importer);
   }
   async dependencyRequest(id, fsPath, callstack) {
     const mocked = await this.mocker.requestWithMock(fsPath, callstack);
@@ -345,4 +381,4 @@ class VitestRunner extends ViteNodeRunner {
   }
 }
 
-export { VitestRunner as V, executeInViteNode as e };
+export { VitestExecutor as V, mockMap as a, moduleCache as m, startViteNode as s };

package/dist/chunk-runtime-rpc.971b3848.js

@@ -0,0 +1,61 @@
+import { getSafeTimers } from '@vitest/utils';
+import { g as getWorkerState } from './chunk-utils-global.727b6d25.js';
+
+const { get } = Reflect;
+const safeRandom = Math.random;
+function withSafeTimers(fn) {
+  const { setTimeout, clearTimeout, nextTick, setImmediate, clearImmediate } = getSafeTimers();
+  const currentSetTimeout = globalThis.setTimeout;
+  const currentClearTimeout = globalThis.clearTimeout;
+  const currentRandom = globalThis.Math.random;
+  const currentNextTick = globalThis.process.nextTick;
+  const currentSetImmediate = globalThis.setImmediate;
+  const currentClearImmediate = globalThis.clearImmediate;
+  try {
+    globalThis.setTimeout = setTimeout;
+    globalThis.clearTimeout = clearTimeout;
+    globalThis.Math.random = safeRandom;
+    globalThis.process.nextTick = nextTick;
+    globalThis.setImmediate = setImmediate;
+    globalThis.clearImmediate = clearImmediate;
+    const result = fn();
+    return result;
+  } finally {
+    globalThis.setTimeout = currentSetTimeout;
+    globalThis.clearTimeout = currentClearTimeout;
+    globalThis.Math.random = currentRandom;
+    globalThis.setImmediate = currentSetImmediate;
+    globalThis.clearImmediate = currentClearImmediate;
+    nextTick(() => {
+      globalThis.process.nextTick = currentNextTick;
+    });
+  }
+}
+const promises = /* @__PURE__ */ new Set();
+const rpcDone = () => {
+  if (!promises.size)
+    return;
+  const awaitable = Array.from(promises);
+  return Promise.all(awaitable);
+};
+const rpc = () => {
+  const { rpc: rpc2 } = getWorkerState();
+  return new Proxy(rpc2, {
+    get(target, p, handler) {
+      const sendCall = get(target, p, handler);
+      const safeSendCall = (...args) => withSafeTimers(async () => {
+        const result = sendCall(...args);
+        promises.add(result);
+        try {
+          return await result;
+        } finally {
+          promises.delete(result);
+        }
+      });
+      safeSendCall.asEvent = sendCall.asEvent;
+      return safeSendCall;
+    }
+  });
+};
+
+export { rpcDone as a, rpc as r };

package/dist/{chunk-runtime-setup.7dfc1a6a.js → chunk-runtime-setup.992bb661.js}

@@ -1,5 +1,5 @@
 import { setSafeTimers } from '@vitest/utils';
-import { a as resetRunOnceCounter } from './chunk-integrations-run-once.38756e30.js';
+import { a as resetRunOnceCounter } from './chunk-integrations-run-once.9012f759.js';
 
 let globalSetup = false;
 async function setupCommonEnv(config) {
@@ -10,7 +10,7 @@ async function setupCommonEnv(config) {
   globalSetup = true;
   setSafeTimers();
   if (config.globals)
-    (await import('./chunk-integrations-globals.aacbac4d.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.b56fcb06.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)

package/dist/{chunk-snapshot-env.6457638e.js → chunk-snapshot-env.a347d647.js}

@@ -2,10 +2,10 @@ let _snapshotEnvironment;
 function setupSnapshotEnvironment(environment) {
   _snapshotEnvironment = environment;
 }
-function getSnapshotEnironment() {
+function getSnapshotEnvironment() {
   if (!_snapshotEnvironment)
     throw new Error("Snapshot environment is not setup");
   return _snapshotEnvironment;
 }
 
-export { getSnapshotEnironment as g, setupSnapshotEnvironment as s };
+export { getSnapshotEnvironment as g, setupSnapshotEnvironment as s };

package/dist/{chunk-utils-base.904102a8.js → chunk-utils-base.81f83dbd.js}

@@ -6,6 +6,14 @@ function collectOwnProperties(obj, collector) {
   Object.getOwnPropertyNames(obj).forEach(collect);
   Object.getOwnPropertySymbols(obj).forEach(collect);
 }
+function groupBy(collection, iteratee) {
+  return collection.reduce((acc, item) => {
+    const key = iteratee(item);
+    acc[key] || (acc[key] = []);
+    acc[key].push(item);
+    return acc;
+  }, {});
+}
 function getAllMockableProperties(obj, isModule) {
   const allProps = /* @__PURE__ */ new Map();
   let curr = obj;
@@ -70,5 +78,11 @@ function isMergeableObject(item) {
 function stdout() {
   return console._stdout || process.stdout;
 }
+function getEnvironmentTransformMode(config, environment) {
+  var _a, _b;
+  if (!((_b = (_a = config.deps) == null ? void 0 : _a.experimentalOptimizer) == null ? void 0 : _b.enabled))
+    return void 0;
+  return environment === "happy-dom" || environment === "jsdom" ? "web" : "ssr";
+}
 
-export { noop as a, stdout as b, deepMerge as d, getAllMockableProperties as g, isObject as i, notNullish as n, slash as s, toArray as t };
+export { getEnvironmentTransformMode as a, noop as b, stdout as c, deepMerge as d, getAllMockableProperties as e, groupBy as g, isObject as i, notNullish as n, slash as s, toArray as t };

package/dist/{chunk-utils-global.442d1d33.js → chunk-utils-global.727b6d25.js}

@@ -63,11 +63,5 @@ function getCallLastIndex(code) {
   }
   return null;
 }
-class AggregateErrorPonyfill extends Error {
-  constructor(errors, message = "") {
-    super(message);
-    this.errors = [...errors];
-  }
-}
 
-export { AggregateErrorPonyfill as A, getCallLastIndex as a, getCurrentEnvironment as b, relativePath as c, removeUndefinedValues as d, isWindows as e, getWorkerState as g, isRunningInBenchmark as i, resetModules as r };
+export { getCallLastIndex as a, getCurrentEnvironment as b, relativePath as c, removeUndefinedValues as d, isWindows as e, getWorkerState as g, isRunningInBenchmark as i, resetModules as r };

package/dist/{chunk-utils-import.0402c9db.js → chunk-utils-import.ec15dcad.js}

@@ -1,16 +1,16 @@
 import { getCurrentSuite } from '@vitest/runner';
 import { createChainable, getNames } from '@vitest/runner/utils';
-import { getSafeTimers, noop } from '@vitest/utils';
-import { g as getWorkerState, i as isRunningInBenchmark, a as getCallLastIndex, b as getCurrentEnvironment, r as resetModules } from './chunk-utils-global.442d1d33.js';
+import { getSafeTimers, noop, createSimpleStackTrace } from '@vitest/utils';
+import { g as getWorkerState, i as isRunningInBenchmark, a as getCallLastIndex, b as getCurrentEnvironment, r as resetModules } from './chunk-utils-global.727b6d25.js';
 import * as chai$1 from 'chai';
 import { expect } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
 import { equals, iterableEquality, subsetEquality, JestExtend, JestChaiExpect, JestAsymmetricMatchers, GLOBAL_EXPECT, getState, setState } from '@vitest/expect';
-import { r as rpc } from './chunk-runtime-rpc.9c0386cc.js';
+import { r as rpc } from './chunk-runtime-rpc.971b3848.js';
 import { join, dirname } from 'pathe';
-import { g as getSnapshotEnironment } from './chunk-snapshot-env.6457638e.js';
-import { i as isObject, s as slash } from './chunk-utils-base.904102a8.js';
-import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE, a as parseStacktrace, g as getFullName, b as parseSingleStack } from './chunk-utils-tasks.a9a8d8e1.js';
+import { g as getSnapshotEnvironment } from './chunk-snapshot-env.a347d647.js';
+import { i as isObject } from './chunk-utils-base.81f83dbd.js';
+import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE, a as parseErrorStacktrace, g as getFullName, b as parseSingleStack } from './chunk-utils-tasks.b41c8284.js';
 import require$$0 from 'util';
 import { spyOn, fn, isMockFunction, spies } from '@vitest/spy';
 
@@ -2568,7 +2568,7 @@ const addSerializer = (plugin) => {
 const getSerializers = () => PLUGINS;
 
 const SNAPSHOT_VERSION = "1";
-const writeSnapshotVersion = () => `// Vitest Snapshot v${SNAPSHOT_VERSION}`;
+const writeSnapshotVersion = () => `// Vitest Snapshot v${SNAPSHOT_VERSION}, https://vitest.dev/guide/snapshot.html`;
 const testNameToKey = (testName, count) => `${testName} ${count}`;
 const keyToTestName = (key) => {
   if (!/ \d+$/.test(key))
@@ -2618,7 +2618,7 @@ function printBacktickString(str) {
 }
 async function ensureDirectoryExists(filePath) {
   try {
-    const environment = getSnapshotEnironment();
+    const environment = getSnapshotEnvironment();
     await environment.prepareDirectory(join(dirname(filePath)));
   } catch {
   }
@@ -2627,7 +2627,7 @@ function normalizeNewlines(string) {
   return string.replace(/\r\n|\r/g, "\n");
 }
 async function saveSnapshotFile(snapshotData, snapshotPath) {
-  const environment = getSnapshotEnironment();
+  const environment = getSnapshotEnvironment();
   const snapshots = Object.keys(snapshotData).sort(naturalCompare$1.exports).map(
     (key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`
   );
@@ -2699,7 +2699,7 @@ function deepMergeSnapshot(target, source) {
 }
 
 async function saveInlineSnapshots(snapshots) {
-  const environment = getSnapshotEnironment();
+  const environment = getSnapshotEnvironment();
   const MagicString = (await import('./chunk-magic-string.3a794426.js')).default;
   const files = new Set(snapshots.map((i) => i.file));
   await Promise.all(Array.from(files).map(async (file) => {
@@ -2815,10 +2815,10 @@ class SnapshotState {
       printBasicPrototype: false,
       ...options.snapshotFormat
     };
-    this._environment = getSnapshotEnironment();
+    this._environment = getSnapshotEnvironment();
   }
   static async create(testFilePath, options) {
-    const environment = getSnapshotEnironment();
+    const environment = getSnapshotEnvironment();
     const snapshotPath = await environment.resolvePath(testFilePath);
     const content = await environment.readSnapshotFile(snapshotPath);
     return new SnapshotState(testFilePath, snapshotPath, content, options);
@@ -2839,9 +2839,7 @@ class SnapshotState {
   _addSnapshot(key, receivedSerialized, options) {
     this._dirty = true;
     if (options.isInline) {
-      const error = options.error || new Error("Unknown error");
-      const stacks = parseStacktrace(error, true);
-      stacks.forEach((i) => i.file = slash(i.file));
+      const stacks = parseErrorStacktrace(options.error || new Error("snapshot"), true);
       const stack = this._inferInlineSnapshotStack(stacks);
       if (!stack) {
         throw new Error(
@@ -3271,19 +3269,6 @@ Object.defineProperty(globalThis, GLOBAL_EXPECT, {
   configurable: true
 });
 
-function createSimpleStackTrace(options) {
-  const { message = "error", stackTraceLimit = 1 } = options || {};
-  const limit = Error.stackTraceLimit;
-  const prepareStackTrace = Error.prepareStackTrace;
-  Error.stackTraceLimit = stackTraceLimit;
-  Error.prepareStackTrace = (e) => e.stack;
-  const err = new Error(message);
-  const stackTrace = err.stack || "";
-  Error.prepareStackTrace = prepareStackTrace;
-  Error.stackTraceLimit = limit;
-  return stackTrace;
-}
-
 /**
  * A reference to the global object
  *
@@ -6014,7 +5999,11 @@ class VitestUtils {
     this._mocker = typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : null;
     this._mockedDate = null;
     if (!this._mocker) {
-      const errorMsg = 'Vitest was initialized with native Node instead of Vite Node.\n\nOne of the following is possible:\n- "vitest" is imported outside of your tests (in that case, use "vitest/node" or import.meta.vitest)\n- "vitest" is imported inside "globalSetup" (use "setupFiles", because "globalSetup" runs in a different context)\n- Your dependency inside "node_modules" imports "vitest" directly (in that case, inline that dependency, using "deps.inline" config)\n- Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues\n';
+      const errorMsg = `Vitest was initialized with native Node instead of Vite Node.
+
+It's possible that you are importing "vitest" directly inside "globalSetup". In that case, use "setupFiles" because "globalSetup" runs in a different context.
+Otherwise, it might be a Vitest bug. Please report it to https://github.com/vitest-dev/vitest/issues
+`;
       throw new Error(errorMsg);
     }
     const workerState = getWorkerState();

package/dist/{chunk-utils-tasks.a9a8d8e1.js → chunk-utils-tasks.b41c8284.js}

@@ -1,11 +1,11 @@
 import { getNames, getTests } from '@vitest/runner/utils';
 import { resolve } from 'pathe';
-import { n as notNullish } from './chunk-utils-base.904102a8.js';
+import { n as notNullish } from './chunk-utils-base.81f83dbd.js';
 
 function hasFailedSnapshot(suite) {
   return getTests(suite).some((s) => {
     var _a, _b;
-    return (_b = (_a = s.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.some((e) => e.message.match(/Snapshot .* mismatched/));
+    return (_b = (_a = s.result) == null ? void 0 : _a.errors) == null ? void 0 : _b.some((e) => e && e.message && e.message.match(/Snapshot .* mismatched/));
   });
 }
 function getFullName(task, separator = " > ") {
@@ -58,18 +58,22 @@ function parseSingleStack(raw) {
     column: parseInt(columnNumber)
   };
 }
-function parseStacktrace(e, full = false) {
+function parseStacktrace(stack, full = false) {
+  const stackFrames = stack.split("\n").map((raw) => {
+    const stack2 = parseSingleStack(raw);
+    if (!stack2 || !full && stackIgnorePatterns.some((p) => stack2.file.match(p)))
+      return null;
+    return stack2;
+  }).filter(notNullish);
+  return stackFrames;
+}
+function parseErrorStacktrace(e, full = false) {
   if (!e)
     return [];
   if (e.stacks)
     return e.stacks;
   const stackStr = e.stack || e.stackStr || "";
-  const stackFrames = stackStr.split("\n").map((raw) => {
-    const stack = parseSingleStack(raw);
-    if (!stack || !full && stackIgnorePatterns.some((p) => stack.file.match(p)))
-      return null;
-    return stack;
-  }).filter(notNullish);
+  const stackFrames = parseStacktrace(stackStr, full);
   e.stacks = stackFrames;
   return stackFrames;
 }
@@ -100,4 +104,4 @@ function offsetToLineNumber(source, offset) {
   return line + 1;
 }
 
-export { parseStacktrace as a, parseSingleStack as b, getFullName as g, hasFailedSnapshot as h, lineSplitRE as l, offsetToLineNumber as o, positionToOffset as p };
+export { parseErrorStacktrace as a, parseSingleStack as b, getFullName as g, hasFailedSnapshot as h, lineSplitRE as l, offsetToLineNumber as o, positionToOffset as p };

package/dist/cli-wrapper.js

@@ -1,6 +1,6 @@
 import { fileURLToPath } from 'url';
 import c from 'picocolors';
-import { e as execa } from './vendor-index.618ca5a1.js';
+import { e as execa } from './vendor-index.2cbcdd1e.js';
 import { E as EXIT_CODE_RESTART } from './chunk-constants.797d3ebf.js';
 import 'node:buffer';
 import 'node:path';
@@ -11,7 +11,6 @@ import 'path';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'fs';
 import 'node:url';
-import 'os';
 import 'node:os';
 import 'assert';
 import 'events';

package/dist/cli.js

@@ -1,33 +1,33 @@
 import { normalize } from 'pathe';
 import cac from 'cac';
 import c from 'picocolors';
-import { v as version, s as startVitest, d as divider } from './chunk-node-pkg.94145502.js';
+import { v as version, s as startVitest, d as divider } from './chunk-node-pkg.88e7e848.js';
 import './chunk-constants.797d3ebf.js';
 import 'node:url';
 import './chunk-utils-env.860d90c2.js';
 import 'std-env';
-import './chunk-integrations-coverage.48e6286b.js';
+import './chunk-integrations-coverage.e0a6acd2.js';
 import 'local-pkg';
-import 'util';
-import 'path';
-import './chunk-env-node.ffd1183b.js';
+import './chunk-env-node.affdd278.js';
 import 'node:console';
 import 'vite';
 import 'node:path';
 import 'node:process';
 import 'node:fs';
+import 'path';
 import 'os';
+import 'util';
 import 'stream';
 import 'events';
 import 'fs';
 import './vendor-_commonjsHelpers.addc3445.js';
 import 'vite-node/client';
 import 'vite-node/server';
-import './chunk-utils-global.442d1d33.js';
+import './chunk-utils-global.727b6d25.js';
 import '@vitest/runner/utils';
 import '@vitest/utils';
 import 'node:fs/promises';
-import './vendor-index.618ca5a1.js';
+import './vendor-index.2cbcdd1e.js';
 import 'node:buffer';
 import 'node:child_process';
 import 'child_process';
@@ -38,12 +38,13 @@ import 'source-map';
 import 'module';
 import 'acorn';
 import 'acorn-walk';
+import 'node:v8';
+import './vendor-index.783e7f3e.js';
+import './chunk-utils-base.81f83dbd.js';
 import 'node:worker_threads';
 import 'tinypool';
-import './vendor-index.783e7f3e.js';
 import 'perf_hooks';
-import './chunk-utils-base.904102a8.js';
-import './chunk-utils-tasks.a9a8d8e1.js';
+import './chunk-utils-tasks.b41c8284.js';
 import 'crypto';
 import 'vite-node/utils';
 import '@vitest/utils/diff';
@@ -53,7 +54,7 @@ import 'strip-literal';
 import 'readline';
 
 const cli = cac("vitest");
-cli.version(version).option("-r, --root <path>", "Root path").option("-c, --config <path>", "Path to config file").option("-u, --update", "Update snapshot").option("-w, --watch", "Enable watch mode").option("-t, --testNamePattern <pattern>", "Run tests with full names matching the specified regexp pattern").option("--dir <path>", "Base directory to scan for the test files").option("--ui", "Enable UI").option("--open", "Open UI automatically (default: !process.env.CI))").option("--api [api]", "Serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "Enabled threads (default: true)").option("--silent", "Silent console output from tests").option("--isolate", "Isolate environment for each test file (default: true)").option("--reporter <name>", "Specify reporters").option("--outputDiffMaxSize <length>", "Object diff output max size (default: 10000)").option("--outputDiffMaxLines <length>", "Max lines in diff output window (default: 50)").option("--outputTruncateLength <length>", "Diff output line length (default: 80)").option("--outputDiffLines <lines>", "Number of lines in single diff (default: 15)").option("--outputFile <filename/-s>", "Write test results to a file when supporter reporter is also specified, use cac's dot notation for individual outputs of multiple reporters").option("--coverage", "Enable coverage report").option("--run", "Disable watch mode").option("--mode <name>", "Override Vite mode (default: test)").option("--globals", "Inject apis globally").option("--dom", "Mock browser api with happy-dom").option("--browser", "Run tests in browser").option("--environment <env>", "Specify runner environment (default: node)").option("--passWithNoTests", "Pass when no tests found").option("--logHeapUsage", "Show the size of heap for each test").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--dangerouslyIgnoreUnhandledErrors", "Ignore any unhandled errors that occur").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order)").option("--segfaultRetry <times>", "Return tests on segment fault (default: 0)", { default: 0 }).option("--no-color", "Removes colors from the console output").option("--inspect", "Enable Node.js inspector").option("--inspect-brk", "Enable Node.js inspector with break").help();
+cli.version(version).option("-r, --root <path>", "Root path").option("-c, --config <path>", "Path to config file").option("-u, --update", "Update snapshot").option("-w, --watch", "Enable watch mode").option("-t, --testNamePattern <pattern>", "Run tests with full names matching the specified regexp pattern").option("--dir <path>", "Base directory to scan for the test files").option("--ui", "Enable UI").option("--open", "Open UI automatically (default: !process.env.CI))").option("--api [api]", "Serve API, available options: --api.port <port>, --api.host [host] and --api.strictPort").option("--threads", "Enabled threads (default: true)").option("--single-thread", "Run tests inside a single thread, requires --threads (default: false)").option("--silent", "Silent console output from tests").option("--isolate", "Isolate environment for each test file (default: true)").option("--reporter <name>", "Specify reporters").option("--outputDiffMaxSize <length>", "Object diff output max size (default: 10000)").option("--outputDiffMaxLines <length>", "Max lines in diff output window (default: 50)").option("--outputTruncateLength <length>", "Diff output line length (default: 80)").option("--outputDiffLines <lines>", "Number of lines in single diff (default: 15)").option("--outputFile <filename/-s>", "Write test results to a file when supporter reporter is also specified, use cac's dot notation for individual outputs of multiple reporters").option("--coverage", "Enable coverage report").option("--run", "Disable watch mode").option("--mode <name>", "Override Vite mode (default: test)").option("--globals", "Inject apis globally").option("--dom", "Mock browser api with happy-dom").option("--browser", "Run tests in browser").option("--environment <env>", "Specify runner environment (default: node)").option("--passWithNoTests", "Pass when no tests found").option("--logHeapUsage", "Show the size of heap for each test").option("--allowOnly", "Allow tests and suites that are marked as only (default: !process.env.CI)").option("--dangerouslyIgnoreUnhandledErrors", "Ignore any unhandled errors that occur").option("--shard <shard>", "Test suite shard to execute in a format of <index>/<count>").option("--changed [since]", "Run tests that are affected by the changed files (default: false)").option("--sequence <options>", "Define in what order to run tests (use --sequence.shuffle to run tests in random order)").option("--segfaultRetry <times>", "Return tests on segment fault (default: 0)", { default: 0 }).option("--no-color", "Removes colors from the console output").option("--inspect", "Enable Node.js inspector").option("--inspect-brk", "Enable Node.js inspector with break").help();
 cli.command("run [...filters]").action(run);
 cli.command("related [...filters]").action(runRelated);
 cli.command("watch [...filters]").action(watch);

package/dist/config.cjs

@@ -30,7 +30,7 @@ const coverageConfigDefaults = {
   cleanOnRerun: true,
   reportsDirectory: "./coverage",
   exclude: defaultCoverageExcludes,
-  reporter: ["text", "html", "clover", "json"],
+  reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
 const fakeTimersDefaults = {