vitest 0.29.6 → 0.29.8

package/dist/{chunk-runtime-mocker.344fec90.js → chunk-runtime-mocker.3283818a.js}

@@ -4,13 +4,13 @@ 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 { processError } from '@vitest/runner/utils';
-import { g as getWorkerState, b as getCurrentEnvironment } from './chunk-utils-env.04ffbef7.js';
+import { g as getWorkerState, a as getCurrentEnvironment } from './chunk-utils-global.fd174983.js';
 import { d as distDir } from './chunk-paths.e36446b4.js';
 import { existsSync, readdirSync } from 'node:fs';
 import { getColors, getType } from '@vitest/utils';
-import { e as getAllMockableProperties } from './chunk-utils-base.81f83dbd.js';
+import { f as getAllMockableProperties } from './chunk-utils-base.b5ddfcc9.js';
 import { spyOn } from '@vitest/spy';
-import { r as rpc } from './chunk-runtime-rpc.1b5714dc.js';
+import { r as rpc } from './chunk-runtime-rpc.d6aa57f8.js';
 
 const filterPublicKeys = ["__esModule", Symbol.asyncIterator, Symbol.hasInstance, Symbol.isConcatSpreadable, Symbol.iterator, Symbol.match, Symbol.matchAll, Symbol.replace, Symbol.search, Symbol.split, Symbol.species, Symbol.toPrimitive, Symbol.toStringTag, Symbol.unscopables];
 class RefTracker {

package/dist/{chunk-runtime-rpc.1b5714dc.js → chunk-runtime-rpc.d6aa57f8.js}

@@ -1,5 +1,5 @@
 import { getSafeTimers } from '@vitest/utils';
-import { g as getWorkerState } from './chunk-utils-env.04ffbef7.js';
+import { g as getWorkerState } from './chunk-utils-global.fd174983.js';
 
 const { get } = Reflect;
 const safeRandom = Math.random;

package/dist/{chunk-runtime-setup.a49dc2f9.js → chunk-runtime-setup.5d504677.js}

@@ -1,5 +1,5 @@
 import { setSafeTimers } from '@vitest/utils';
-import { a as resetRunOnceCounter } from './chunk-integrations-run-once.a2b4758b.js';
+import { a as resetRunOnceCounter } from './chunk-integrations-run-once.ea614f17.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.a473e88a.js')).registerApiGlobally();
+    (await import('./chunk-integrations-globals.49802775.js')).registerApiGlobally();
 }
 function setupDefines(defines) {
   for (const key in defines)

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

@@ -14,6 +14,9 @@ function groupBy(collection, iteratee) {
     return acc;
   }, {});
 }
+function isPrimitive(value) {
+  return value === null || typeof value !== "function" && typeof value !== "object";
+}
 function getAllMockableProperties(obj, isModule) {
   const allProps = /* @__PURE__ */ new Map();
   let curr = obj;
@@ -85,4 +88,4 @@ function getEnvironmentTransformMode(config, environment) {
   return environment === "happy-dom" || environment === "jsdom" ? "web" : "ssr";
 }
 
-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 };
+export { isPrimitive as a, getEnvironmentTransformMode as b, noop as c, deepMerge as d, stdout as e, getAllMockableProperties as f, groupBy as g, isObject as i, notNullish as n, slash as s, toArray as t };

package/dist/{chunk-utils-env.04ffbef7.js → chunk-utils-env.6b856dbf.js}

@@ -1,18 +1,12 @@
 import { relative } from 'pathe';
 import 'std-env';
 import '@vitest/runner/utils';
+import { g as getWorkerState } from './chunk-utils-global.fd174983.js';
 import '@vitest/utils';
 
 var _a;
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
 
-function getWorkerState() {
-  return globalThis.__vitest_worker__;
-}
-function getCurrentEnvironment() {
-  return globalThis.__vitest_environment__;
-}
-
 const isWindows = isNode && process.platform === "win32";
 const getRunMode = () => getWorkerState().config.mode;
 const isRunningInBenchmark = () => getRunMode() === "benchmark";
@@ -67,4 +61,4 @@ function getCallLastIndex(code) {
   return null;
 }
 
-export { getCallLastIndex as a, getCurrentEnvironment as b, isNode as c, relativePath as d, removeUndefinedValues as e, isWindows as f, getWorkerState as g, isRunningInBenchmark as i, resetModules as r };
+export { isNode as a, relativePath as b, removeUndefinedValues as c, isWindows as d, getCallLastIndex as g, isRunningInBenchmark as i, resetModules as r };

package/dist/chunk-utils-global.fd174983.js

@@ -0,0 +1,8 @@
+function getWorkerState() {
+  return globalThis.__vitest_worker__;
+}
+function getCurrentEnvironment() {
+  return globalThis.__vitest_environment__;
+}
+
+export { getCurrentEnvironment as a, getWorkerState as g };

package/dist/{chunk-utils-import.39ffe9c5.js → chunk-utils-import.e488ace3.js}

@@ -1,16 +1,17 @@
 import { getCurrentSuite } from '@vitest/runner';
 import { createChainable, getNames } from '@vitest/runner/utils';
 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-env.04ffbef7.js';
+import { i as isRunningInBenchmark, g as getCallLastIndex, r as resetModules } from './chunk-utils-env.6b856dbf.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.1b5714dc.js';
+import { r as rpc } from './chunk-runtime-rpc.d6aa57f8.js';
 import { join, dirname } from 'pathe';
 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 { i as isObject } from './chunk-utils-base.b5ddfcc9.js';
+import { p as positionToOffset, o as offsetToLineNumber, l as lineSplitRE, a as parseErrorStacktrace, g as getFullName, b as parseSingleStack } from './chunk-utils-tasks.8781fd71.js';
+import { g as getWorkerState, a as getCurrentEnvironment } from './chunk-utils-global.fd174983.js';
 import require$$0 from 'util';
 import { spyOn, fn, isMockFunction, spies } from '@vitest/spy';
 
@@ -5989,205 +5990,203 @@ class FakeTimers {
   }
 }
 
-class VitestUtils {
-  constructor() {
-    this.spyOn = spyOn;
-    this.fn = fn;
-    this._stubsGlobal = /* @__PURE__ */ new Map();
-    this._stubsEnv = /* @__PURE__ */ new Map();
-    this._config = null;
-    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.
-
-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();
-    this._timers = new FakeTimers({
-      global: globalThis,
-      config: workerState.config.fakeTimers
-    });
-  }
-  useFakeTimers(config) {
-    if (config) {
-      this._timers.configure(config);
-    } else {
-      const workerState = getWorkerState();
-      this._timers.configure(workerState.config.fakeTimers);
+function createVitest() {
+  const _mocker = typeof __vitest_mocker__ !== "undefined" ? __vitest_mocker__ : new Proxy({}, {
+    get(name) {
+      throw new Error(
+        `Vitest mocker was not initialized in this environment. vi.${name}() is forbidden.`
+      );
     }
-    this._timers.useFakeTimers();
-    return this;
-  }
-  useRealTimers() {
-    this._timers.useRealTimers();
-    this._mockedDate = null;
-    return this;
-  }
-  runOnlyPendingTimers() {
-    this._timers.runOnlyPendingTimers();
-    return this;
-  }
-  async runOnlyPendingTimersAsync() {
-    await this._timers.runOnlyPendingTimersAsync();
-    return this;
-  }
-  runAllTimers() {
-    this._timers.runAllTimers();
-    return this;
-  }
-  async runAllTimersAsync() {
-    await this._timers.runAllTimersAsync();
-    return this;
-  }
-  runAllTicks() {
-    this._timers.runAllTicks();
-    return this;
-  }
-  advanceTimersByTime(ms) {
-    this._timers.advanceTimersByTime(ms);
-    return this;
-  }
-  async advanceTimersByTimeAsync(ms) {
-    await this._timers.advanceTimersByTimeAsync(ms);
-    return this;
-  }
-  advanceTimersToNextTimer() {
-    this._timers.advanceTimersToNextTimer();
-    return this;
-  }
-  async advanceTimersToNextTimerAsync() {
-    await this._timers.advanceTimersToNextTimerAsync();
-    return this;
-  }
-  getTimerCount() {
-    return this._timers.getTimerCount();
-  }
-  setSystemTime(time) {
-    const date = time instanceof Date ? time : new Date(time);
-    this._mockedDate = date;
-    this._timers.setSystemTime(date);
-    return this;
-  }
-  getMockedSystemTime() {
-    return this._mockedDate;
-  }
-  getRealSystemTime() {
-    return this._timers.getRealSystemTime();
-  }
-  clearAllTimers() {
-    this._timers.clearAllTimers();
-    return this;
-  }
-  getImporter() {
+  });
+  let _mockedDate = null;
+  let _config = null;
+  const workerState = getWorkerState();
+  const _timers = new FakeTimers({
+    global: globalThis,
+    config: workerState.config.fakeTimers
+  });
+  const _stubsGlobal = /* @__PURE__ */ new Map();
+  const _stubsEnv = /* @__PURE__ */ new Map();
+  const getImporter = () => {
     const stackTrace = createSimpleStackTrace({ stackTraceLimit: 4 });
     const importerStack = stackTrace.split("\n")[4];
     const stack = parseSingleStack(importerStack);
     return (stack == null ? void 0 : stack.file) || "";
-  }
-  mock(path, factory) {
-    const importer = this.getImporter();
-    this._mocker.queueMock(
-      path,
-      importer,
-      factory ? () => factory(() => this._mocker.importActual(path, importer)) : void 0
-    );
-  }
-  unmock(path) {
-    this._mocker.queueUnmock(path, this.getImporter());
-  }
-  doMock(path, factory) {
-    this._mocker.queueMock(path, this.getImporter(), factory);
-  }
-  doUnmock(path) {
-    this._mocker.queueUnmock(path, this.getImporter());
-  }
-  async importActual(path) {
-    return this._mocker.importActual(path, this.getImporter());
-  }
-  async importMock(path) {
-    return this._mocker.importMock(path, this.getImporter());
-  }
-  mocked(item, _options = {}) {
-    return item;
-  }
-  isMockFunction(fn2) {
-    return isMockFunction(fn2);
-  }
-  clearAllMocks() {
-    spies.forEach((spy) => spy.mockClear());
-    return this;
-  }
-  resetAllMocks() {
-    spies.forEach((spy) => spy.mockReset());
-    return this;
-  }
-  restoreAllMocks() {
-    spies.forEach((spy) => spy.mockRestore());
-    return this;
-  }
-  stubGlobal(name, value) {
-    if (!this._stubsGlobal.has(name))
-      this._stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
-    Object.defineProperty(globalThis, name, {
-      value,
-      writable: true,
-      configurable: true,
-      enumerable: true
-    });
-    return this;
-  }
-  stubEnv(name, value) {
-    if (!this._stubsEnv.has(name))
-      this._stubsEnv.set(name, process.env[name]);
-    process.env[name] = value;
-    return this;
-  }
-  unstubAllGlobals() {
-    this._stubsGlobal.forEach((original, name) => {
-      if (!original)
-        Reflect.deleteProperty(globalThis, name);
-      else
-        Object.defineProperty(globalThis, name, original);
-    });
-    this._stubsGlobal.clear();
-    return this;
-  }
-  unstubAllEnvs() {
-    this._stubsEnv.forEach((original, name) => {
-      if (original === void 0)
-        delete process.env[name];
-      else
-        process.env[name] = original;
-    });
-    this._stubsEnv.clear();
-    return this;
-  }
-  resetModules() {
-    const state = getWorkerState();
-    resetModules(state.moduleCache);
-    return this;
-  }
-  async dynamicImportSettled() {
-    return waitForImportsToResolve();
-  }
-  setConfig(config) {
-    const state = getWorkerState();
-    if (!this._config)
-      this._config = { ...state.config };
-    Object.assign(state.config, config);
-  }
-  resetConfig() {
-    if (this._config) {
+  };
+  return {
+    useFakeTimers(config) {
+      if (config) {
+        _timers.configure(config);
+      } else {
+        const workerState2 = getWorkerState();
+        _timers.configure(workerState2.config.fakeTimers);
+      }
+      _timers.useFakeTimers();
+      return this;
+    },
+    useRealTimers() {
+      _timers.useRealTimers();
+      _mockedDate = null;
+      return this;
+    },
+    runOnlyPendingTimers() {
+      _timers.runOnlyPendingTimers();
+      return this;
+    },
+    async runOnlyPendingTimersAsync() {
+      await _timers.runOnlyPendingTimersAsync();
+      return this;
+    },
+    runAllTimers() {
+      _timers.runAllTimers();
+      return this;
+    },
+    async runAllTimersAsync() {
+      await _timers.runAllTimersAsync();
+      return this;
+    },
+    runAllTicks() {
+      _timers.runAllTicks();
+      return this;
+    },
+    advanceTimersByTime(ms) {
+      _timers.advanceTimersByTime(ms);
+      return this;
+    },
+    async advanceTimersByTimeAsync(ms) {
+      await _timers.advanceTimersByTimeAsync(ms);
+      return this;
+    },
+    advanceTimersToNextTimer() {
+      _timers.advanceTimersToNextTimer();
+      return this;
+    },
+    async advanceTimersToNextTimerAsync() {
+      await _timers.advanceTimersToNextTimerAsync();
+      return this;
+    },
+    getTimerCount() {
+      return _timers.getTimerCount();
+    },
+    setSystemTime(time) {
+      const date = time instanceof Date ? time : new Date(time);
+      _mockedDate = date;
+      _timers.setSystemTime(date);
+      return this;
+    },
+    getMockedSystemTime() {
+      return _mockedDate;
+    },
+    getRealSystemTime() {
+      return _timers.getRealSystemTime();
+    },
+    clearAllTimers() {
+      _timers.clearAllTimers();
+      return this;
+    },
+    spyOn,
+    fn,
+    mock(path, factory) {
+      const importer = getImporter();
+      _mocker.queueMock(
+        path,
+        importer,
+        factory ? () => factory(() => _mocker.importActual(path, importer)) : void 0
+      );
+    },
+    unmock(path) {
+      _mocker.queueUnmock(path, getImporter());
+    },
+    doMock(path, factory) {
+      _mocker.queueMock(path, getImporter(), factory);
+    },
+    doUnmock(path) {
+      _mocker.queueUnmock(path, getImporter());
+    },
+    async importActual(path) {
+      return _mocker.importActual(path, getImporter());
+    },
+    async importMock(path) {
+      return _mocker.importMock(path, getImporter());
+    },
+    mocked(item, _options = {}) {
+      return item;
+    },
+    isMockFunction(fn2) {
+      return isMockFunction(fn2);
+    },
+    clearAllMocks() {
+      spies.forEach((spy) => spy.mockClear());
+      return this;
+    },
+    resetAllMocks() {
+      spies.forEach((spy) => spy.mockReset());
+      return this;
+    },
+    restoreAllMocks() {
+      spies.forEach((spy) => spy.mockRestore());
+      return this;
+    },
+    stubGlobal(name, value) {
+      if (!_stubsGlobal.has(name))
+        _stubsGlobal.set(name, Object.getOwnPropertyDescriptor(globalThis, name));
+      Object.defineProperty(globalThis, name, {
+        value,
+        writable: true,
+        configurable: true,
+        enumerable: true
+      });
+      return this;
+    },
+    stubEnv(name, value) {
+      if (!_stubsEnv.has(name))
+        _stubsEnv.set(name, process.env[name]);
+      process.env[name] = value;
+      return this;
+    },
+    unstubAllGlobals() {
+      _stubsGlobal.forEach((original, name) => {
+        if (!original)
+          Reflect.deleteProperty(globalThis, name);
+        else
+          Object.defineProperty(globalThis, name, original);
+      });
+      _stubsGlobal.clear();
+      return this;
+    },
+    unstubAllEnvs() {
+      _stubsEnv.forEach((original, name) => {
+        if (original === void 0)
+          delete process.env[name];
+        else
+          process.env[name] = original;
+      });
+      _stubsEnv.clear();
+      return this;
+    },
+    resetModules() {
       const state = getWorkerState();
-      Object.assign(state.config, this._config);
+      resetModules(state.moduleCache);
+      return this;
+    },
+    async dynamicImportSettled() {
+      return waitForImportsToResolve();
+    },
+    setConfig(config) {
+      const state = getWorkerState();
+      if (!_config)
+        _config = { ...state.config };
+      Object.assign(state.config, config);
+    },
+    resetConfig() {
+      if (_config) {
+        const state = getWorkerState();
+        Object.assign(state.config, _config);
+      }
     }
-  }
+  };
 }
-const vitest = new VitestUtils();
+const vitest = createVitest();
 const vi = vitest;
 
 export { RealDate as R, vi as a, bench as b, createExpect as c, getSnapshotClient as d, getBenchOptions as e, getBenchFn as f, globalExpect as g, vitest as v };

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

@@ -1,6 +1,6 @@
 import { getNames, getTests } from '@vitest/runner/utils';
 import { resolve } from 'pathe';
-import { n as notNullish } from './chunk-utils-base.81f83dbd.js';
+import { a as isPrimitive, n as notNullish } from './chunk-utils-base.b5ddfcc9.js';
 
 function hasFailedSnapshot(suite) {
   return getTests(suite).some((s) => {
@@ -68,7 +68,7 @@ function parseStacktrace(stack, full = false) {
   return stackFrames;
 }
 function parseErrorStacktrace(e, full = false) {
-  if (!e)
+  if (!e || isPrimitive(e))
     return [];
   if (e.stacks)
     return e.stacks;

package/dist/cli.js

@@ -1,15 +1,16 @@
 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.68fe5e35.js';
+import { v as version, s as startVitest, d as divider } from './chunk-node-pkg.30d8b37e.js';
 import './chunk-constants.bc18a549.js';
-import './chunk-integrations-coverage.e0a6acd2.js';
-import 'local-pkg';
+import './chunk-integrations-coverage.d93ee824.js';
 import './chunk-env-node.affdd278.js';
 import 'node:console';
-import './chunk-utils-env.04ffbef7.js';
+import 'local-pkg';
+import './chunk-utils-env.6b856dbf.js';
 import 'std-env';
 import '@vitest/runner/utils';
+import './chunk-utils-global.fd174983.js';
 import '@vitest/utils';
 import 'vite';
 import 'node:path';
@@ -37,7 +38,7 @@ import 'source-map';
 import 'module';
 import 'acorn';
 import 'acorn-walk';
-import './chunk-utils-base.81f83dbd.js';
+import './chunk-utils-base.b5ddfcc9.js';
 import 'crypto';
 import './chunk-paths.e36446b4.js';
 import 'node:v8';
@@ -45,7 +46,7 @@ import './vendor-index.783e7f3e.js';
 import 'node:worker_threads';
 import 'tinypool';
 import 'perf_hooks';
-import './chunk-utils-tasks.b41c8284.js';
+import './chunk-utils-tasks.8781fd71.js';
 import '@vitest/utils/diff';
 import 'vite-node/server';
 import './vendor-magic-string.es.b3bc5745.js';

package/dist/config.cjs

@@ -33,10 +33,6 @@ const coverageConfigDefaults = {
   reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
-const browserConfigDefaults = {
-  enabled: false,
-  headless: stdEnv.isCI
-};
 const fakeTimersDefaults = {
   loopLimit: 1e4,
   shouldClearNativeTimers: true,
@@ -65,7 +61,6 @@ const config = {
   hookTimeout: 1e4,
   teardownTimeout: 1e4,
   isolate: true,
-  browser: browserConfigDefaults,
   watchExclude: ["**/node_modules/**", "**/dist/**"],
   forceRerunTriggers: [
     "**/package.json/**",

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import { UserConfig as UserConfig$2, ConfigEnv } from 'vite';
 export { ConfigEnv } from 'vite';
-import { a1 as ResolvedCoverageOptions, U as UserConfig$1, a4 as CoverageC8Options, a5 as CustomProviderOptions, a3 as CoverageIstanbulOptions, af as HtmlOptions, ag as FileOptions, ah as CloverOptions, ai as CoberturaOptions, aj as HtmlSpaOptions, ak as LcovOptions, al as LcovOnlyOptions, am as TeamcityOptions, an as TextOptions, ao as ProjectOptions, F as FakeTimerInstallOpts } from './types-fafda418.js';
+import { a1 as ResolvedCoverageOptions, n as UserConfig$1, a4 as CoverageC8Options, a5 as CustomProviderOptions, a3 as CoverageIstanbulOptions, af as HtmlOptions, ag as FileOptions, ah as CloverOptions, ai as CoberturaOptions, aj as HtmlSpaOptions, ak as LcovOptions, al as LcovOnlyOptions, am as TeamcityOptions, an as TextOptions, ao as ProjectOptions, F as FakeTimerInstallOpts } from './types-94cfe4b4.js';
 import '@vitest/expect';
 import '@vitest/runner';
 import '@vitest/runner/types';
@@ -32,10 +32,6 @@ declare const config: {
     hookTimeout: number;
     teardownTimeout: number;
     isolate: boolean;
-    browser: {
-        readonly enabled: false;
-        readonly headless: boolean;
-    };
     watchExclude: string[];
     forceRerunTriggers: string[];
     update: boolean;

package/dist/config.js

@@ -29,10 +29,6 @@ const coverageConfigDefaults = {
   reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
-const browserConfigDefaults = {
-  enabled: false,
-  headless: isCI
-};
 const fakeTimersDefaults = {
   loopLimit: 1e4,
   shouldClearNativeTimers: true,
@@ -61,7 +57,6 @@ const config = {
   hookTimeout: 1e4,
   teardownTimeout: 1e4,
   isolate: true,
-  browser: browserConfigDefaults,
   watchExclude: ["**/node_modules/**", "**/dist/**"],
   forceRerunTriggers: [
     "**/package.json/**",

package/dist/coverage.d.ts

@@ -1,4 +1,4 @@
-import { a2 as BaseCoverageOptions, a1 as ResolvedCoverageOptions } from './types-fafda418.js';
+import { a2 as BaseCoverageOptions, a1 as ResolvedCoverageOptions } from './types-94cfe4b4.js';
 import '@vitest/expect';
 import 'vite';
 import '@vitest/runner';