vitest 2.1.3 → 2.1.5

package/dist/runners.js

@@ -1,25 +1,153 @@
-import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
-import { g as getSnapshotClient, c as createExpect, v as vi } from './chunks/vi.BskyZC5g.js';
-import 'pathe';
-import { g as getTestName } from './chunks/tasks.BZnCS9aT.js';
-import { createDefer, getSafeTimers } from '@vitest/utils';
-import { g as getWorkerState } from './chunks/utils.Ck2hJTRs.js';
-import './chunks/env.CmHVDJnw.js';
-import { r as rpc } from './chunks/rpc.B7Mfb-Yf.js';
-import { getTests, getNames } from '@vitest/runner/utils';
 import { updateTask } from '@vitest/runner';
-import { a as getBenchOptions, g as getBenchFn } from './chunks/benchmark.C8CRJYG4.js';
+import { createDefer, getSafeTimers } from '@vitest/utils';
+import { a as getBenchOptions, g as getBenchFn } from './chunks/benchmark.Cdu9hjj4.js';
+import { g as getWorkerState } from './chunks/utils.C8RiOc4B.js';
+import { setState, GLOBAL_EXPECT, getState } from '@vitest/expect';
+import { getTests, getNames, getTestName } from '@vitest/runner/utils';
+import { g as getSnapshotClient, c as createExpect, v as vi } from './chunks/vi.DgezovHB.js';
+import { r as rpc } from './chunks/rpc.C3q9uwRX.js';
 import 'chai';
 import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
 import '@vitest/utils/source-map';
-import './chunks/base.DwXGwWst.js';
 import './chunks/date.W2xKR2qe.js';
 import '@vitest/spy';
-import 'std-env';
-import './chunks/index.BpSiYbpB.js';
-import './chunks/index.CxRxs566.js';
+import './chunks/index.68735LiX.js';
+
+function createBenchmarkResult(name) {
+  return {
+    name,
+    rank: 0,
+    rme: 0,
+    samples: []
+  };
+}
+const benchmarkTasks = /* @__PURE__ */ new WeakMap();
+async function runBenchmarkSuite(suite, runner) {
+  const { Task, Bench } = await runner.importTinybench();
+  const start = performance.now();
+  const benchmarkGroup = [];
+  const benchmarkSuiteGroup = [];
+  for (const task of suite.tasks) {
+    if (task.mode !== "run") {
+      continue;
+    }
+    if (task.meta?.benchmark) {
+      benchmarkGroup.push(task);
+    } else if (task.type === "suite") {
+      benchmarkSuiteGroup.push(task);
+    }
+  }
+  for (const subSuite of benchmarkSuiteGroup) {
+    await runBenchmarkSuite(subSuite, runner);
+  }
+  if (benchmarkGroup.length) {
+    const defer = createDefer();
+    suite.result = {
+      state: "run",
+      startTime: start,
+      benchmark: createBenchmarkResult(suite.name)
+    };
+    updateTask$1(suite);
+    const addBenchTaskListener = (task, benchmark) => {
+      task.addEventListener(
+        "complete",
+        (e) => {
+          const task2 = e.task;
+          const taskRes = task2.result;
+          const result = benchmark.result.benchmark;
+          Object.assign(result, taskRes);
+          const samples = result.samples;
+          result.sampleCount = samples.length;
+          result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
+          if (!runner.config.benchmark?.includeSamples) {
+            result.samples.length = 0;
+          }
+          updateTask$1(benchmark);
+        },
+        {
+          once: true
+        }
+      );
+      task.addEventListener(
+        "error",
+        (e) => {
+          const task2 = e.task;
+          defer.reject(benchmark ? task2.result.error : e);
+        },
+        {
+          once: true
+        }
+      );
+    };
+    benchmarkGroup.forEach((benchmark) => {
+      const options = getBenchOptions(benchmark);
+      const benchmarkInstance = new Bench(options);
+      const benchmarkFn = getBenchFn(benchmark);
+      benchmark.result = {
+        state: "run",
+        startTime: start,
+        benchmark: createBenchmarkResult(benchmark.name)
+      };
+      const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
+      benchmarkTasks.set(benchmark, task);
+      addBenchTaskListener(task, benchmark);
+      updateTask$1(benchmark);
+    });
+    const { setTimeout } = getSafeTimers();
+    const tasks = [];
+    for (const benchmark of benchmarkGroup) {
+      const task = benchmarkTasks.get(benchmark);
+      await task.warmup();
+      tasks.push([
+        await new Promise(
+          (resolve) => setTimeout(async () => {
+            resolve(await task.run());
+          })
+        ),
+        benchmark
+      ]);
+    }
+    suite.result.duration = performance.now() - start;
+    suite.result.state = "pass";
+    tasks.sort(([taskA], [taskB]) => taskA.result.mean - taskB.result.mean).forEach(([, benchmark], idx) => {
+      benchmark.result.state = "pass";
+      if (benchmark) {
+        const result = benchmark.result.benchmark;
+        result.rank = Number(idx) + 1;
+        updateTask$1(benchmark);
+      }
+    });
+    updateTask$1(suite);
+    defer.resolve(null);
+    await defer;
+  }
+  function updateTask$1(task) {
+    updateTask(task, runner);
+  }
+}
+class NodeBenchmarkRunner {
+  constructor(config) {
+    this.config = config;
+  }
+  __vitest_executor;
+  async importTinybench() {
+    return await import('tinybench');
+  }
+  importFile(filepath, source) {
+    if (source === "setup") {
+      getWorkerState().moduleCache.delete(filepath);
+    }
+    return this.__vitest_executor.executeId(filepath);
+  }
+  async runSuite(suite) {
+    await runBenchmarkSuite(suite, this);
+  }
+  async runTask() {
+    throw new Error("`test()` and `it()` is only available in test mode.");
+  }
+}
 
 class VitestTestRunner {
   constructor(config) {
@@ -171,138 +299,4 @@ function clearModuleMocks(config) {
   }
 }
 
-function createBenchmarkResult(name) {
-  return {
-    name,
-    rank: 0,
-    rme: 0,
-    samples: []
-  };
-}
-const benchmarkTasks = /* @__PURE__ */ new WeakMap();
-async function runBenchmarkSuite(suite, runner) {
-  const { Task, Bench } = await runner.importTinybench();
-  const start = performance.now();
-  const benchmarkGroup = [];
-  const benchmarkSuiteGroup = [];
-  for (const task of suite.tasks) {
-    if (task.mode !== "run") {
-      continue;
-    }
-    if (task.meta?.benchmark) {
-      benchmarkGroup.push(task);
-    } else if (task.type === "suite") {
-      benchmarkSuiteGroup.push(task);
-    }
-  }
-  for (const subSuite of benchmarkSuiteGroup) {
-    await runBenchmarkSuite(subSuite, runner);
-  }
-  if (benchmarkGroup.length) {
-    const defer = createDefer();
-    suite.result = {
-      state: "run",
-      startTime: start,
-      benchmark: createBenchmarkResult(suite.name)
-    };
-    updateTask$1(suite);
-    const addBenchTaskListener = (task, benchmark) => {
-      task.addEventListener(
-        "complete",
-        (e) => {
-          const task2 = e.task;
-          const taskRes = task2.result;
-          const result = benchmark.result.benchmark;
-          Object.assign(result, taskRes);
-          const samples = result.samples;
-          result.sampleCount = samples.length;
-          result.median = samples.length % 2 ? samples[Math.floor(samples.length / 2)] : (samples[samples.length / 2] + samples[samples.length / 2 - 1]) / 2;
-          if (!runner.config.benchmark?.includeSamples) {
-            result.samples.length = 0;
-          }
-          updateTask$1(benchmark);
-        },
-        {
-          once: true
-        }
-      );
-      task.addEventListener(
-        "error",
-        (e) => {
-          const task2 = e.task;
-          defer.reject(benchmark ? task2.result.error : e);
-        },
-        {
-          once: true
-        }
-      );
-    };
-    benchmarkGroup.forEach((benchmark) => {
-      const options = getBenchOptions(benchmark);
-      const benchmarkInstance = new Bench(options);
-      const benchmarkFn = getBenchFn(benchmark);
-      benchmark.result = {
-        state: "run",
-        startTime: start,
-        benchmark: createBenchmarkResult(benchmark.name)
-      };
-      const task = new Task(benchmarkInstance, benchmark.name, benchmarkFn);
-      benchmarkTasks.set(benchmark, task);
-      addBenchTaskListener(task, benchmark);
-      updateTask$1(benchmark);
-    });
-    const { setTimeout } = getSafeTimers();
-    const tasks = [];
-    for (const benchmark of benchmarkGroup) {
-      const task = benchmarkTasks.get(benchmark);
-      await task.warmup();
-      tasks.push([
-        await new Promise(
-          (resolve) => setTimeout(async () => {
-            resolve(await task.run());
-          })
-        ),
-        benchmark
-      ]);
-    }
-    suite.result.duration = performance.now() - start;
-    suite.result.state = "pass";
-    tasks.sort(([taskA], [taskB]) => taskA.result.mean - taskB.result.mean).forEach(([, benchmark], idx) => {
-      benchmark.result.state = "pass";
-      if (benchmark) {
-        const result = benchmark.result.benchmark;
-        result.rank = Number(idx) + 1;
-        updateTask$1(benchmark);
-      }
-    });
-    updateTask$1(suite);
-    defer.resolve(null);
-    await defer;
-  }
-  function updateTask$1(task) {
-    updateTask(task, runner);
-  }
-}
-class NodeBenchmarkRunner {
-  constructor(config) {
-    this.config = config;
-  }
-  __vitest_executor;
-  async importTinybench() {
-    return await import('tinybench');
-  }
-  importFile(filepath, source) {
-    if (source === "setup") {
-      getWorkerState().moduleCache.delete(filepath);
-    }
-    return this.__vitest_executor.executeId(filepath);
-  }
-  async runSuite(suite) {
-    await runBenchmarkSuite(suite, this);
-  }
-  async runTask() {
-    throw new Error("`test()` and `it()` is only available in test mode.");
-  }
-}
-
 export { NodeBenchmarkRunner, VitestTestRunner };

package/dist/snapshot.js

@@ -1,8 +1,4 @@
-export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.Bx4JZjMG.js';
+export { VitestNodeSnapshotEnvironment as VitestSnapshotEnvironment } from './chunks/node.AKq966Jp.js';
 import '@vitest/snapshot/environment';
-import 'pathe';
-import '@vitest/runner/utils';
+import './chunks/utils.C8RiOc4B.js';
 import '@vitest/utils';
-import './chunks/utils.Ck2hJTRs.js';
-import './chunks/env.CmHVDJnw.js';
-import 'std-env';

package/dist/suite.d.ts

@@ -1,5 +1,5 @@
+export { g as getBenchFn, a as getBenchOptions } from './chunks/suite.B2jumIFP.js';
 export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
-export { g as getBenchFn, a as getBenchOptions } from './chunks/suite.BMWOKiTe.js';
-import './chunks/benchmark.JVlTzojj.js';
+import './chunks/benchmark.geERunq4.js';
 import 'tinybench';

package/dist/suite.js

@@ -1,9 +1,5 @@
+export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.Cdu9hjj4.js';
 export { createTaskCollector, getCurrentSuite, getCurrentTest, getFn, getHooks, setFn, setHooks } from '@vitest/runner';
 export { createChainable } from '@vitest/runner/utils';
-export { g as getBenchFn, a as getBenchOptions } from './chunks/benchmark.C8CRJYG4.js';
 import '@vitest/utils';
-import './chunks/index.CxRxs566.js';
-import 'pathe';
-import './chunks/utils.Ck2hJTRs.js';
-import './chunks/env.CmHVDJnw.js';
-import 'std-env';
+import './chunks/utils.C8RiOc4B.js';

package/dist/worker.js

@@ -1,18 +1,18 @@
 import { pathToFileURL } from 'node:url';
+import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
 import { workerId } from 'tinypool';
 import { ViteNodeRunner, ModuleCacheMap } from 'vite-node/client';
 import { readFileSync } from 'node:fs';
 import { resolve, normalize } from 'pathe';
-import { e as environments } from './chunks/index.lVXYBqEP.js';
-import { i as isChildProcess, s as setProcessTitle } from './chunks/base.DwXGwWst.js';
+import { e as environments } from './chunks/index.K90BXFOx.js';
 import { s as setupInspect } from './chunks/inspector.70d6emsh.js';
-import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.B7Mfb-Yf.js';
+import { c as createRuntimeRpc, a as rpcDone } from './chunks/rpc.C3q9uwRX.js';
+import { i as isChildProcess, s as setProcessTitle } from './chunks/utils.C8RiOc4B.js';
 import { d as disposeInternalListeners } from './chunks/utils.Cn0zI1t3.js';
 import 'node:console';
-import '@vitest/utils';
 import 'node:module';
-import './chunks/index.BpSiYbpB.js';
-import './chunks/utils.Ck2hJTRs.js';
+import '@vitest/utils';
+import './chunks/index.68735LiX.js';
 
 function isBuiltinEnvironment(env) {
   return env in environments;
@@ -113,7 +113,10 @@ async function execute(method, ctx) {
         prepare: prepareStart
       },
       rpc,
-      providedContext: ctx.providedContext
+      providedContext: ctx.providedContext,
+      onFilterStackTrace(stack) {
+        return createStackString(parseStacktrace(stack));
+      }
     };
     const methodName = method === "collect" ? "collectTests" : "runTests";
     if (!worker[methodName] || typeof worker[methodName] !== "function") {

package/dist/workers/forks.js

@@ -1,19 +1,20 @@
 import v8 from 'node:v8';
+import { r as runBaseTests } from '../chunks/base.BZZh4cSm.js';
 import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.Cn0zI1t3.js';
-import { r as runBaseTests } from '../chunks/base.BO5Jx7vw.js';
-import '@vitest/utils';
 import 'vite-node/client';
-import '../chunks/utils.Ck2hJTRs.js';
-import '../chunks/execute._eQQfgI8.js';
-import 'node:vm';
-import 'node:url';
+import '../chunks/execute.2pr0rHgK.js';
 import 'node:fs';
-import 'vite-node/utils';
-import 'pathe';
+import 'node:url';
+import 'node:vm';
 import '@vitest/utils/error';
+import 'pathe';
+import 'vite-node/utils';
 import '../path.js';
+import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
+import '@vitest/utils';
+import '../chunks/utils.C8RiOc4B.js';
 
 class ForksBaseWorker {
   getRpcOptions() {

package/dist/workers/runVmTests.js

@@ -1,39 +1,35 @@
 import { createRequire } from 'node:module';
-import util from 'node:util';
-import timers from 'node:timers';
 import { performance } from 'node:perf_hooks';
+import timers from 'node:timers';
+import util from 'node:util';
 import { startTests, collectTests } from '@vitest/runner';
-import { installSourcemapsSupport } from 'vite-node/source-map';
 import { KNOWN_ASSET_TYPES } from 'vite-node/constants';
-import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.4GFF2h22.js';
-import { a as startCoverageInsideWorker, s as stopCoverageInsideWorker } from '../chunks/coverage.zlNdAMHK.js';
-import { V as VitestIndex } from '../chunks/index.-d_XpZEA.js';
-import { g as getWorkerState } from '../chunks/utils.Ck2hJTRs.js';
-import { s as setupCommonEnv } from '../chunks/setup-common.BKyF15v_.js';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { s as setupChaiConfig, r as resolveTestRunner, a as resolveSnapshotEnvironment } from '../chunks/index.nEwtF0bu.js';
+import { s as startCoverageInsideWorker, a as stopCoverageInsideWorker } from '../chunks/coverage.BoMDb1ip.js';
+import { V as VitestIndex } from '../chunks/index.ckWaX2gY.js';
 import { c as closeInspector } from '../chunks/inspector.70d6emsh.js';
+import { s as setupCommonEnv } from '../chunks/setup-common.Dj6BZI3u.js';
+import { g as getWorkerState } from '../chunks/utils.C8RiOc4B.js';
 import 'chai';
-import 'pathe';
+import 'node:path';
 import '../path.js';
 import 'node:url';
-import '../chunks/rpc.B7Mfb-Yf.js';
+import '../chunks/rpc.C3q9uwRX.js';
 import '@vitest/utils';
-import '../chunks/index.BpSiYbpB.js';
-import '../chunks/benchmark.C8CRJYG4.js';
+import '../chunks/index.68735LiX.js';
+import '../chunks/vi.DgezovHB.js';
+import '@vitest/expect';
 import '@vitest/runner/utils';
-import '../chunks/index.CxRxs566.js';
-import '../chunks/env.CmHVDJnw.js';
-import 'std-env';
-import '../chunks/run-once.Sxe67Wng.js';
-import '../chunks/vi.BskyZC5g.js';
 import '../chunks/_commonjsHelpers.BFTU3MAI.js';
-import '@vitest/expect';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import '../chunks/tasks.BZnCS9aT.js';
 import '@vitest/utils/source-map';
-import '../chunks/base.DwXGwWst.js';
 import '../chunks/date.W2xKR2qe.js';
 import '@vitest/spy';
+import '../chunks/run-once.2ogXb3JV.js';
+import '../chunks/benchmark.Cdu9hjj4.js';
+import 'expect-type';
 
 async function run(method, files, config, executor) {
   const workerState = getWorkerState();

package/dist/workers/threads.js

@@ -1,18 +1,19 @@
-import { r as runBaseTests } from '../chunks/base.BO5Jx7vw.js';
+import { r as runBaseTests } from '../chunks/base.BZZh4cSm.js';
 import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
 import 'vite-node/client';
-import '../chunks/utils.Ck2hJTRs.js';
-import '../chunks/execute._eQQfgI8.js';
-import 'node:vm';
-import 'node:url';
+import '../chunks/execute.2pr0rHgK.js';
 import 'node:fs';
-import 'vite-node/utils';
-import 'pathe';
+import 'node:url';
+import 'node:vm';
 import '@vitest/utils/error';
+import 'pathe';
+import 'vite-node/utils';
 import '../path.js';
-import '@vitest/utils';
+import 'node:path';
 import '@vitest/mocker';
 import 'node:module';
+import '@vitest/utils';
+import '../chunks/utils.C8RiOc4B.js';
 
 class ThreadsBaseWorker {
   getRpcOptions(ctx) {

package/dist/workers/vmForks.js

@@ -1,26 +1,23 @@
 import v8 from 'node:v8';
 import { c as createForksRpcOptions, u as unwrapSerializableConfig } from '../chunks/utils.Cn0zI1t3.js';
-import { r as runVmTests } from '../chunks/vm.DB_hLchi.js';
+import { r as runVmTests } from '../chunks/vm.Zr4qWzDJ.js';
 import '@vitest/utils';
-import 'node:vm';
 import 'node:url';
+import 'node:vm';
 import 'pathe';
-import '../chunks/console.CfT1Wjed.js';
-import 'node:stream';
-import 'node:console';
+import '../path.js';
 import 'node:path';
+import '../chunks/console.BYGVloWk.js';
+import 'node:console';
+import 'node:stream';
 import 'tinyrainbow';
 import '../chunks/date.W2xKR2qe.js';
-import '@vitest/runner/utils';
-import '../chunks/utils.Ck2hJTRs.js';
-import '../chunks/env.CmHVDJnw.js';
-import 'std-env';
-import '../chunks/execute._eQQfgI8.js';
+import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/execute.2pr0rHgK.js';
 import 'node:fs';
+import '@vitest/utils/error';
 import 'vite-node/client';
 import 'vite-node/utils';
-import '@vitest/utils/error';
-import '../path.js';
 import '@vitest/mocker';
 import 'node:module';
 import 'vite-node/constants';

package/dist/workers/vmThreads.js

@@ -1,25 +1,22 @@
 import { a as createThreadsRpcOptions } from '../chunks/utils.Cn0zI1t3.js';
-import { r as runVmTests } from '../chunks/vm.DB_hLchi.js';
+import { r as runVmTests } from '../chunks/vm.Zr4qWzDJ.js';
 import '@vitest/utils';
-import 'node:vm';
 import 'node:url';
+import 'node:vm';
 import 'pathe';
-import '../chunks/console.CfT1Wjed.js';
-import 'node:stream';
-import 'node:console';
+import '../path.js';
 import 'node:path';
+import '../chunks/console.BYGVloWk.js';
+import 'node:console';
+import 'node:stream';
 import 'tinyrainbow';
 import '../chunks/date.W2xKR2qe.js';
-import '@vitest/runner/utils';
-import '../chunks/utils.Ck2hJTRs.js';
-import '../chunks/env.CmHVDJnw.js';
-import 'std-env';
-import '../chunks/execute._eQQfgI8.js';
+import '../chunks/utils.C8RiOc4B.js';
+import '../chunks/execute.2pr0rHgK.js';
 import 'node:fs';
+import '@vitest/utils/error';
 import 'vite-node/client';
 import 'vite-node/utils';
-import '@vitest/utils/error';
-import '../path.js';
 import '@vitest/mocker';
 import 'node:module';
 import 'vite-node/constants';

package/dist/workers.d.ts

@@ -1,15 +1,22 @@
-import * as v8 from 'v8';
-import { S as SerializedConfig } from './chunks/config.Crbj2GAb.js';
-import { W as WorkerContext } from './chunks/worker.CcJLfX8w.js';
-import { B as BirpcOptions, R as RuntimeRPC, C as ContextRPC, W as WorkerGlobalState } from './chunks/worker.B6RjTtbk.js';
+import { W as WorkerGlobalState, C as ContextRPC, B as BirpcOptions, R as RuntimeRPC } from './chunks/worker.tN5KGIih.js';
 import { Awaitable } from '@vitest/utils';
-import '@vitest/pretty-format';
+import * as v8 from 'v8';
+import { S as SerializedConfig } from './chunks/config.Cy0C388Z.js';
+import { W as WorkerContext } from './chunks/worker.B9FxPCaC.js';
 import '@vitest/runner';
+import 'vite-node';
+import './chunks/environment.LoooBwUu.js';
 import '@vitest/snapshot';
+import '@vitest/pretty-format';
 import '@vitest/snapshot/environment';
 import 'node:worker_threads';
-import 'vite-node';
-import './chunks/environment.CzISCQ7o.js';
+
+declare function provideWorkerState(context: any, state: WorkerGlobalState): WorkerGlobalState;
+
+declare function run(ctx: ContextRPC): Promise<void>;
+declare function collect(ctx: ContextRPC): Promise<void>;
+
+declare function runBaseTests(method: 'run' | 'collect', state: WorkerGlobalState): Promise<void>;
 
 type WorkerRpcOptions = Pick<BirpcOptions<RuntimeRPC>, 'on' | 'post' | 'serialize' | 'deserialize'>;
 interface VitestWorker {
@@ -25,13 +32,6 @@ declare function createForksRpcOptions(nodeV8: typeof v8): WorkerRpcOptions;
  */
 declare function unwrapSerializableConfig(config: SerializedConfig): SerializedConfig;
 
-declare function provideWorkerState(context: any, state: WorkerGlobalState): WorkerGlobalState;
-
-declare function run(ctx: ContextRPC): Promise<void>;
-declare function collect(ctx: ContextRPC): Promise<void>;
-
 declare function runVmTests(method: 'run' | 'collect', state: WorkerGlobalState): Promise<void>;
 
-declare function runBaseTests(method: 'run' | 'collect', state: WorkerGlobalState): Promise<void>;
-
 export { type VitestWorker, type WorkerRpcOptions, collect as collectVitestWorkerTests, createForksRpcOptions, createThreadsRpcOptions, provideWorkerState, runBaseTests, run as runVitestWorker, runVmTests, unwrapSerializableConfig };

package/dist/workers.js

@@ -1,33 +1,30 @@
-export { c as createForksRpcOptions, a as createThreadsRpcOptions, u as unwrapSerializableConfig } from './chunks/utils.Cn0zI1t3.js';
-export { p as provideWorkerState } from './chunks/utils.Ck2hJTRs.js';
+export { p as provideWorkerState } from './chunks/utils.C8RiOc4B.js';
 export { collect as collectVitestWorkerTests, run as runVitestWorker } from './worker.js';
-export { r as runVmTests } from './chunks/vm.DB_hLchi.js';
-export { r as runBaseTests } from './chunks/base.BO5Jx7vw.js';
+export { r as runBaseTests } from './chunks/base.BZZh4cSm.js';
+export { c as createForksRpcOptions, a as createThreadsRpcOptions, u as unwrapSerializableConfig } from './chunks/utils.Cn0zI1t3.js';
+export { r as runVmTests } from './chunks/vm.Zr4qWzDJ.js';
 import '@vitest/utils';
 import 'node:url';
+import '@vitest/utils/source-map';
 import 'tinypool';
 import 'vite-node/client';
 import 'node:fs';
 import 'pathe';
-import './chunks/index.lVXYBqEP.js';
+import './chunks/index.K90BXFOx.js';
 import 'node:console';
-import './chunks/base.DwXGwWst.js';
 import './chunks/inspector.70d6emsh.js';
 import 'node:module';
-import './chunks/rpc.B7Mfb-Yf.js';
-import './chunks/index.BpSiYbpB.js';
+import './chunks/rpc.C3q9uwRX.js';
+import './chunks/index.68735LiX.js';
+import './chunks/execute.2pr0rHgK.js';
 import 'node:vm';
-import './chunks/console.CfT1Wjed.js';
-import 'node:stream';
-import 'node:path';
-import 'tinyrainbow';
-import './chunks/date.W2xKR2qe.js';
-import '@vitest/runner/utils';
-import './chunks/env.CmHVDJnw.js';
-import 'std-env';
-import './chunks/execute._eQQfgI8.js';
-import 'vite-node/utils';
 import '@vitest/utils/error';
+import 'vite-node/utils';
 import './path.js';
+import 'node:path';
 import '@vitest/mocker';
+import './chunks/console.BYGVloWk.js';
+import 'node:stream';
+import 'tinyrainbow';
+import './chunks/date.W2xKR2qe.js';
 import 'vite-node/constants';