vitest 2.0.4 → 2.0.5

package/dist/index.d.ts

@@ -1,30 +1,111 @@
-import { TaskPopulated, File, TaskResultPack } from '@vitest/runner';
-export { CancelReason, Custom, DoneCallback, ExtendedContext, File, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, RuntimeContext, SequenceHooks, SequenceSetupFiles, Suite, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, Task, TaskBase, TaskContext, TaskCustomOptions, TaskMeta, TaskResult, TaskResultPack, TaskState, Test, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-export { b as bench } from './suite-CRLAhsm0.js';
-import { ExpectStatic } from '@vitest/expect';
+import { V as VitestEnvironment$1, S as SerializedSpec, b as RawErrsMap$1, T as TscErrorInfo$1, c as CollectLineNumbers$1, d as CollectLines$1, e as RootAndTarget$1, f as Context$1, C as CoverageProvider$1, g as ReportContext$1, a as CoverageProviderModule$1, h as CoverageReporter$1, i as CoverageProviderName, j as CoverageOptions$1, R as ResolvedCoverageOptions$1, B as BaseCoverageOptions$1, k as CoverageIstanbulOptions$1, l as CoverageV8Options$1, m as CustomProviderOptions$1, n as Reporter$1, o as Vitest$1, p as BrowserScript$1, q as BrowserConfigOptions$1, r as BuiltinEnvironment$1, P as Pool$1, s as PoolOptions$1, t as CSSModuleScopeStrategy$1, A as ApiConfig$1, u as VitestRunMode$1, D as DepsOptimizationOptions$1, v as TransformModePatterns$1, I as InlineConfig$1, w as TypecheckConfig$1, U as UserConfig$1, x as ResolvedConfig$1, y as ProjectConfig$1, z as UserWorkspaceConfig$1, E as BenchmarkUserOptions$1 } from './chunks/reporters.C_zwCd4j.js';
+import { Plugin } from '@vitest/pretty-format';
+import { SnapshotState } from '@vitest/snapshot';
+export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
+import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
 export { Assertion, AsymmetricMatchersContaining, ExpectPollOptions, ExpectStatic, JestAssertion } from '@vitest/expect';
-import { F as FakeTimerInstallOpts, M as MockFactoryWithHelper, h as RuntimeConfig, i as ProvidedContext, R as ResolvedConfig, j as ModuleGraphData, k as Reporter, l as BirpcReturn } from './reporters-B7ebVMkT.js';
-export { Y as AfterSuiteRunMeta, A as ApiConfig, a1 as ArgumentsType, a0 as Arrayable, _ as Awaitable, B as BaseCoverageOptions, ah as BenchFunction, af as Benchmark, ai as BenchmarkAPI, ag as BenchmarkResult, ae as BenchmarkUserOptions, G as BrowserConfigOptions, z as BrowserScript, s as BuiltinEnvironment, t as CSSModuleScopeStrategy, n as CollectLineNumbers, o as CollectLines, a3 as Constructable, q as Context, f as ContextRPC, N as ContextTestEnvironment, ab as CoverageIstanbulOptions, C as CoverageOptions, b as CoverageProvider, c as CoverageProviderModule, aa as CoverageReporter, ac as CoverageV8Options, ad as CustomProviderOptions, D as DepsOptimizationOptions, E as Environment, u as EnvironmentOptions, a5 as EnvironmentReturn, H as HappyDOMOptions, I as InlineConfig, J as JSDOMOptions, a4 as ModuleCache, a2 as MutableArray, $ as Nullable, a8 as OnServerRestartHandler, P as Pool, r as PoolOptions, y as ProjectConfig, m as RawErrsMap, a9 as ReportContext, X as ResolveIdFunction, a as ResolvedCoverageOptions, O as ResolvedTestEnvironment, p as RootAndTarget, L as RunnerRPC, e as RuntimeRPC, S as SerializableSpec, w as TransformModePatterns, T as TscErrorInfo, x as TypecheckConfig, U as UserConfig, a7 as UserConsoleLog, K as UserWorkspaceConfig, Q as Vitest, V as VitestEnvironment, v as VitestRunMode, a6 as VmEnvironmentReturn, g as WorkerContext, W as WorkerGlobalState, Z as WorkerRPC } from './reporters-B7ebVMkT.js';
+import { B as BenchmarkResult } from './chunks/benchmark.puBFxyfE.js';
+export { b as BenchFunction, a as Benchmark, c as BenchmarkAPI } from './chunks/benchmark.puBFxyfE.js';
+import { U as UserConsoleLog, P as ProvidedContext, M as ModuleGraphData, b as Awaitable$1, N as Nullable$1, c as Arrayable$1, d as ArgumentsType$1, e as MutableArray$1, C as Constructable$1, O as OnServerRestartHandler$1, a as EnvironmentReturn$1, V as VmEnvironmentReturn$1, E as Environment$1, R as ResolvedTestEnvironment$1, J as JSDOMOptions$1, H as HappyDOMOptions$1, f as EnvironmentOptions$1 } from './chunks/environment.0M5R1SX_.js';
+export { A as AfterSuiteRunMeta, g as ModuleCache } from './chunks/environment.0M5R1SX_.js';
+import { TaskPopulated, TaskResultPack, File as File$1, Suite as Suite$1, Test as Test$1, Custom as Custom$1, Task as Task$1, SequenceHooks as SequenceHooks$1, SequenceSetupFiles as SequenceSetupFiles$1 } from '@vitest/runner';
+export { CancelReason, DoneCallback, ExtendedContext, HookCleanupCallback, HookListener, OnTestFailedHandler, RunMode, Custom as RunnerCustomCase, Task as RunnerTask, Test as RunnerTestCase, File as RunnerTestFile, Suite as RunnerTestSuite, RuntimeContext, SuiteAPI, SuiteCollector, SuiteFactory, SuiteHooks, TaskBase, TaskContext, TaskCustomOptions, TaskMeta, TaskResult, TaskResultPack, TaskState, TestAPI, TestContext, TestFunction, TestOptions, afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
+export { b as bench } from './chunks/suite.CcK46U-P.js';
+import { F as FakeTimerInstallOpts, R as RuntimeOptions, S as SerializedConfig } from './chunks/config.DCnyCTbs.js';
+export { b as RuntimeConfig, a as SerializedCoverageConfig } from './chunks/config.DCnyCTbs.js';
+import { M as MockFactoryWithHelper, a as BirpcReturn } from './chunks/worker.C5iHKIaJ.js';
+export { C as ContextRPC, e as ContextTestEnvironment, c as ResolveIdFunction, b as RunnerRPC, R as RuntimeRPC, W as WorkerGlobalState, d as WorkerRPC } from './chunks/worker.C5iHKIaJ.js';
 import { spyOn, fn, MaybeMockedDeep, MaybeMocked, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export { Mock, MockContext, MockInstance, Mocked, MockedClass, MockedFunction, MockedObject } from '@vitest/spy';
-export { SnapshotData, SnapshotMatchOptions, SnapshotResult, SnapshotSerializer, SnapshotStateOptions, SnapshotSummary, SnapshotUpdateState, UncheckedSnapshot } from '@vitest/snapshot';
+export { W as WorkerContext } from './chunks/worker.DKkAC4Qw.js';
+export { ErrorWithDiff, ParsedStack, SerializedError, TestError } from '@vitest/utils';
 export { DiffOptions } from '@vitest/utils/diff';
-import { TransformResult } from 'vite';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
-export { ErrorWithDiff, ParsedStack } from '@vitest/utils';
 export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
-import '@vitest/runner/utils';
-import '@vitest/pretty-format';
+import 'vite';
 import 'vite-node';
 import 'node:stream';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
-import 'node:worker_threads';
 import '@vitest/utils/source-map';
 import 'node:fs';
+import '@vitest/runner/utils';
+import '@vitest/snapshot/environment';
+import 'node:worker_threads';
+
+declare global {
+    namespace Chai {
+        interface Assertion {
+            containSubset: (expected: any) => Assertion;
+        }
+        interface Assert {
+            containSubset: (val: any, exp: any, msg?: string) => void;
+        }
+    }
+}
+interface SnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(snapshot: Partial<U>, message?: string): void;
+    (message?: string): void;
+}
+interface InlineSnapshotMatcher<T> {
+    <U extends {
+        [P in keyof T]: any;
+    }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+    (message?: string): void;
+}
+declare module '@vitest/expect' {
+    interface MatcherState {
+        environment: VitestEnvironment$1;
+        snapshotState: SnapshotState;
+    }
+    interface ExpectPollOptions {
+        interval?: number;
+        timeout?: number;
+        message?: string;
+    }
+    interface ExpectStatic {
+        unreachable: (message?: string) => never;
+        soft: <T>(actual: T, message?: string) => Assertion<T>;
+        poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+        addEqualityTesters: (testers: Array<Tester>) => void;
+        assertions: (expected: number) => void;
+        hasAssertions: () => void;
+        addSnapshotSerializer: (plugin: Plugin) => void;
+    }
+    interface Assertion<T> {
+        matchSnapshot: SnapshotMatcher<T>;
+        toMatchSnapshot: SnapshotMatcher<T>;
+        toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+        toThrowErrorMatchingSnapshot: (message?: string) => void;
+        toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
+        toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
+    }
+}
+declare module '@vitest/runner' {
+    interface TestContext {
+        expect: ExpectStatic;
+    }
+    interface TaskMeta {
+        typecheck?: boolean;
+        benchmark?: boolean;
+        failScreenshotPath?: string;
+    }
+    interface File {
+        prepareDuration?: number;
+        environmentLoad?: number;
+    }
+    interface TaskBase {
+        logs?: UserConsoleLog[];
+    }
+    interface TaskResult {
+        benchmark?: BenchmarkResult;
+    }
+}
 
 /**
  * Negates a boolean type.
@@ -1056,11 +1137,6 @@ interface AssertType {
 }
 declare const assertType: AssertType;
 
-interface BrowserUI {
-    setCurrentFileId: (fileId: string) => void;
-    setIframeViewport: (width: number, height: number) => Promise<void>;
-}
-
 /**
  * This utils allows computational intensive tasks to only be ran once
  * across test reruns to improve the watch mode performance.
@@ -1180,8 +1256,8 @@ interface VitestUtils {
     clearAllTimers: () => VitestUtils;
     /**
      * Creates a spy on a method or getter/setter of an object similar to [`vi.fn()`](https://vitest.dev/api/vi#vi-fn). It returns a [mock function](https://vitest.dev/api/mock).
-     *
      * @example
+     * ```ts
      * const cart = {
      *   getApples: () => 42
      * }
@@ -1191,14 +1267,15 @@ interface VitestUtils {
      * expect(cart.getApples()).toBe(10)
      * expect(spy).toHaveBeenCalled()
      * expect(spy).toHaveReturnedWith(10)
+     * ```
      */
     spyOn: typeof spyOn;
     /**
      * Creates a spy on a function, though can be initiated without one. Every time a function is invoked, it stores its call arguments, returns, and instances. Also, you can manipulate its behavior with [methods](https://vitest.dev/api/mock).
      *
      * If no function is given, mock will return `undefined`, when invoked.
-     *
      * @example
+     * ```ts
      * const getApples = vi.fn(() => 0)
      *
      * getApples()
@@ -1210,14 +1287,15 @@ interface VitestUtils {
      *
      * expect(getApples()).toBe(5)
      * expect(getApples).toHaveNthReturnedWith(2, 5)
+     * ```
      */
     fn: typeof fn;
     /**
      * Wait for the callback to execute successfully. If the callback throws an error or returns a rejected promise it will continue to wait until it succeeds or times out.
      *
      * This is very useful when you need to wait for some asynchronous action to complete, for example, when you start a server and need to wait for it to start.
-     *
      * @example
+     * ```ts
      * const server = createServer()
      *
      * await vi.waitFor(
@@ -1231,14 +1309,15 @@ interface VitestUtils {
      *     interval: 20, // default is 50
      *   }
      * )
+     * ```
      */
     waitFor: typeof waitFor;
     /**
      * This is similar to [`vi.waitFor`](https://vitest.dev/api/vi#vi-waitfor), but if the callback throws any errors, execution is immediately interrupted and an error message is received.
      *
      * If the callback returns a falsy value, the next check will continue until a truthy value is returned. This is useful when you need to wait for something to exist before taking the next step.
-     *
      * @example
+     * ```ts
      * const element = await vi.waitUntil(
      *   () => document.querySelector('.element'),
      *   {
@@ -1249,6 +1328,7 @@ interface VitestUtils {
      *
      * // do something with the element
      * expect(element.querySelector('.element-child')).toBeTruthy()
+     * ```
      */
     waitUntil: typeof waitUntil;
     /**
@@ -1301,11 +1381,13 @@ interface VitestUtils {
      * Imports module, bypassing all checks if it should be mocked.
      * Can be useful if you want to mock module partially.
      * @example
+     * ```ts
      * vi.mock('./example.js', async () => {
      *  const axios = await vi.importActual<typeof import('./example.js')>('./example.js')
      *
      *  return { ...axios, get: vi.fn() }
      * })
+     * ```
      * @param path Path to the module. Can be aliased, if your config supports it
      */
     importActual: <T = ESModuleExports>(path: string) => Promise<T>;
@@ -1314,9 +1396,11 @@ interface VitestUtils {
      *
      * Mocking algorithm is described in [documentation](https://vitest.dev/guide/mocking#modules).
      * @example
+     * ```ts
      * const example = await vi.importMock<typeof import('./example.js')>('./example.js')
      * example.calc.mockReturnValue(10)
      * expect(example.calc()).toBe(10)
+     * ```
      * @param path Path to the module. Can be aliased, if your config supports it
      * @returns Fully mocked module
      */
@@ -1327,6 +1411,7 @@ interface VitestUtils {
      * When `partial` is `true` it will expect a `Partial<T>` as a return value. By default, this will only make TypeScript believe that
      * the first level values are mocked. You can pass down `{ deep: true }` as a second argument to tell TypeScript that the whole object is mocked, if it actually is.
      * @example
+     * ```ts
      * import example from './example.js'
      * vi.mock('./example.js')
      *
@@ -1334,6 +1419,7 @@ interface VitestUtils {
      *  vi.mocked(example.calc).mockReturnValue(10)
      *  expect(example.calc(1, '+', 1)).toBe(10)
      * })
+     * ```
      * @param item Anything that can be mocked
      * @param deep If the object is deeply mocked
      * @param options If the object is partially or deeply mocked
@@ -1406,7 +1492,7 @@ interface VitestUtils {
     /**
      * Updates runtime config. You can only change values that are used when executing tests.
      */
-    setConfig: (config: RuntimeConfig) => void;
+    setConfig: (config: RuntimeOptions) => void;
     /**
      * If config was changed with `vi.setConfig`, this will reset it to the original state.
      */
@@ -1415,7 +1501,7 @@ interface VitestUtils {
 declare const vitest: VitestUtils;
 declare const vi: VitestUtils;
 
-declare function getRunningMode(): "run" | "watch";
+declare function getRunningMode(): "watch" | "run";
 declare function isWatchMode(): boolean;
 
 /**
@@ -1424,30 +1510,177 @@ declare function isWatchMode(): boolean;
  */
 declare function inject<T extends keyof ProvidedContext & string>(key: T): ProvidedContext[T];
 
-interface TransformResultWithSource extends TransformResult {
+interface BrowserUI {
+    setCurrentFileId: (fileId: string) => void;
+    setIframeViewport: (width: number, height: number) => Promise<void>;
+}
+
+interface SourceMap {
+    file: string;
+    mappings: string;
+    names: string[];
+    sources: string[];
+    sourcesContent?: string[];
+    version: number;
+    toString: () => string;
+    toUrl: () => string;
+}
+interface TransformResultWithSource {
+    code: string;
+    map: SourceMap | {
+        mappings: '';
+    } | null;
+    etag?: string;
+    deps?: string[];
+    dynamicDeps?: string[];
     source?: string;
 }
 interface WebSocketHandlers {
-    onCollected: (files?: File[]) => Promise<void>;
     onTaskUpdate: (packs: TaskResultPack[]) => void;
-    getFiles: () => File[];
-    getTestFiles: () => Promise<[{
-        name: string;
-        root: string;
-    }, file: string][]>;
+    getFiles: () => File$1[];
+    getTestFiles: () => Promise<SerializedSpec[]>;
     getPaths: () => string[];
-    getConfig: () => ResolvedConfig;
+    getConfig: () => SerializedConfig;
     getModuleGraph: (projectName: string, id: string, browser?: boolean) => Promise<ModuleGraphData>;
     getTransformResult: (projectName: string, id: string, browser?: boolean) => Promise<TransformResultWithSource | undefined>;
     readTestFile: (id: string) => Promise<string | null>;
     saveTestFile: (id: string, content: string) => Promise<void>;
     rerun: (files: string[]) => Promise<void>;
-    updateSnapshot: (file?: File) => Promise<void>;
+    updateSnapshot: (file?: File$1) => Promise<void>;
     getUnhandledErrors: () => unknown[];
 }
-interface WebSocketEvents extends Pick<Reporter, 'onCollected' | 'onFinished' | 'onTaskUpdate' | 'onUserConsoleLog' | 'onPathsCollected' | 'onSpecsCollected'> {
+interface WebSocketEvents {
+    onCollected?: (files?: File$1[]) => Awaitable$1<void>;
+    onFinished?: (files: File$1[], errors: unknown[], coverage?: unknown) => Awaitable$1<void>;
+    onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable$1<void>;
+    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable$1<void>;
+    onPathsCollected?: (paths?: string[]) => Awaitable$1<void>;
+    onSpecsCollected?: (specs?: SerializedSpec[]) => Awaitable$1<void>;
     onFinishedReportCoverage: () => void;
 }
 type WebSocketRPC = BirpcReturn<WebSocketEvents, WebSocketHandlers>;
 
-export { type AssertType, type BrowserUI, type ExpectTypeOf, ModuleGraphData, ProvidedContext, Reporter, ResolvedConfig, RuntimeConfig, type TransformResultWithSource, type VitestUtils, type WebSocketEvents, type WebSocketHandlers, type WebSocketRPC, assertType, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, inject, isFirstRun, isWatchMode, runOnce, vi, vitest };
+/** @deprecated import `TypeCheckRawErrorsMap` from `vitest/node` instead */
+type RawErrsMap = RawErrsMap$1;
+/** @deprecated import `TypeCheckErrorInfo` from `vitest/node` instead */
+type TscErrorInfo = TscErrorInfo$1;
+/** @deprecated import `TypeCheckCollectLineNumbers` from `vitest/node` instead */
+type CollectLineNumbers = CollectLineNumbers$1;
+/** @deprecated import `TypeCheckCollectLines` from `vitest/node` instead */
+type CollectLines = CollectLines$1;
+/** @deprecated import `TypeCheckRootAndTarget` from `vitest/node` instead */
+type RootAndTarget = RootAndTarget$1;
+/** @deprecated import `TypeCheckContext` from `vitest/node` instead */
+type Context = Context$1;
+/** @deprecated use `RunnerTestSuite` instead */
+type Suite = Suite$1;
+/** @deprecated use `RunnerTestFile` instead */
+type File = File$1;
+/** @deprecated use `RunnerTestCase` instead */
+type Test = Test$1;
+/** @deprecated use `RunnerCustomCase` instead */
+type Custom = Custom$1;
+/** @deprecated use `RunnerTask` instead */
+type Task = Task$1;
+
+/** @deprecated do not use, internal helper */
+type Awaitable<T> = Awaitable$1<T>;
+/** @deprecated do not use, internal helper */
+type Nullable<T> = Nullable$1<T>;
+/** @deprecated do not use, internal helper */
+type Arrayable<T> = Arrayable$1<T>;
+/** @deprecated do not use, internal helper */
+type ArgumentsType<T> = ArgumentsType$1<T>;
+/** @deprecated do not use, internal helper */
+type MutableArray<T extends readonly any[]> = MutableArray$1<T>;
+/** @deprecated do not use, internal helper */
+type Constructable = Constructable$1;
+/** @deprecated import from `vitest/node` instead */
+type OnServerRestartHandler = OnServerRestartHandler$1;
+
+/** @deprecated import from `vitest/environments` instead */
+type EnvironmentReturn = EnvironmentReturn$1;
+/** @deprecated import from `vitest/environments` instead */
+type VmEnvironmentReturn = VmEnvironmentReturn$1;
+/** @deprecated import from `vitest/environments` instead */
+type Environment = Environment$1;
+/** @deprecated do not use it */
+type ResolvedTestEnvironment = ResolvedTestEnvironment$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageProvider = CoverageProvider$1;
+/** @deprecated import from `vitest/node` instead */
+type ReportContext = ReportContext$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageProviderModule = CoverageProviderModule$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageReporter = CoverageReporter$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageOptions<T extends CoverageProviderName = CoverageProviderName> = CoverageOptions$1<T>;
+/** @deprecated import from `vitest/node` instead */
+type ResolvedCoverageOptions<T extends CoverageProviderName = CoverageProviderName> = ResolvedCoverageOptions$1<T>;
+/** @deprecated import from `vitest/node` instead */
+type BaseCoverageOptions = BaseCoverageOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageIstanbulOptions = CoverageIstanbulOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type CoverageV8Options = CoverageV8Options$1;
+/** @deprecated import from `vitest/node` instead */
+type CustomProviderOptions = CustomProviderOptions$1;
+
+/** @deprecated import from `vitest/node` instead */
+type Reporter = Reporter$1;
+/** @deprecated import from `vitest/node` instead */
+type Vitest = Vitest$1;
+
+/** @deprecated import from `vitest/node` instead */
+type BrowserScript = BrowserScript$1;
+/** @deprecated import from `vitest/node` instead */
+type BrowserConfigOptions = BrowserConfigOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type SequenceHooks = SequenceHooks$1;
+/** @deprecated import from `vitest/node` instead */
+type SequenceSetupFiles = SequenceSetupFiles$1;
+/** @deprecated import from `vitest/node` instead */
+type BuiltinEnvironment = BuiltinEnvironment$1;
+/** @deprecated import from `vitest/node` instead */
+type VitestEnvironment = VitestEnvironment$1;
+/** @deprecated import from `vitest/node` instead */
+type Pool = Pool$1;
+/** @deprecated import from `vitest/node` instead */
+type PoolOptions = PoolOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type CSSModuleScopeStrategy = CSSModuleScopeStrategy$1;
+/** @deprecated import from `vitest/node` instead */
+type ApiConfig = ApiConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type JSDOMOptions = JSDOMOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type HappyDOMOptions = HappyDOMOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type EnvironmentOptions = EnvironmentOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type VitestRunMode = VitestRunMode$1;
+/** @deprecated import from `vitest/node` instead */
+type DepsOptimizationOptions = DepsOptimizationOptions$1;
+/** @deprecated import from `vitest/node` instead */
+type TransformModePatterns = TransformModePatterns$1;
+/** @deprecated import from `vitest/node` instead */
+type InlineConfig = InlineConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type TypecheckConfig = TypecheckConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type UserConfig = UserConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type ResolvedConfig = ResolvedConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type ProjectConfig = ProjectConfig$1;
+/** @deprecated import from `vitest/node` instead */
+type UserWorkspaceConfig = UserWorkspaceConfig$1;
+
+/** @deprecated use `SerializedSpec` instead */
+type SerializableSpec = SerializedSpec;
+
+/** @deprecated import from `vitest/node` instead */
+type BenchmarkUserOptions = BenchmarkUserOptions$1;
+
+export { type ApiConfig, type ArgumentsType, type Arrayable, type AssertType, type Awaitable, type BaseCoverageOptions, BenchmarkResult, type BenchmarkUserOptions, type BrowserConfigOptions, type BrowserScript, type BrowserUI, type BuiltinEnvironment, type CSSModuleScopeStrategy, type CollectLineNumbers, type CollectLines, type Constructable, type Context, type CoverageIstanbulOptions, type CoverageOptions, type CoverageProvider, type CoverageProviderModule, type CoverageReporter, type CoverageV8Options, type Custom, type CustomProviderOptions, type DepsOptimizationOptions, type Environment, type EnvironmentOptions, type EnvironmentReturn, type ExpectTypeOf, type File, type HappyDOMOptions, type InlineConfig, type JSDOMOptions, ModuleGraphData, type MutableArray, type Nullable, type OnServerRestartHandler, type Pool, type PoolOptions, type ProjectConfig, ProvidedContext, type RawErrsMap, type ReportContext, type Reporter, type ResolvedConfig, type ResolvedCoverageOptions, type ResolvedTestEnvironment, type RootAndTarget, type SequenceHooks, type SequenceSetupFiles, type SerializableSpec, SerializedConfig, SerializedSpec, type Suite, type Task, type Test, type TransformModePatterns, type TransformResultWithSource, type TscErrorInfo, type TypecheckConfig, type UserConfig, UserConsoleLog, type UserWorkspaceConfig, type Vitest, type VitestEnvironment, type VitestRunMode, type VitestUtils, type VmEnvironmentReturn, type WebSocketEvents, type WebSocketHandlers, type WebSocketRPC, assertType, createExpect, globalExpect as expect, expectTypeOf, getRunningMode, inject, isFirstRun, isWatchMode, runOnce, vi, vitest };

package/dist/index.js

@@ -1,27 +1,27 @@
 export { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
-export { b as bench } from './vendor/benchmark.B6pblCp2.js';
-export { i as isFirstRun, a as runOnce } from './vendor/run-once.Db8Hgq9X.js';
-export { c as createExpect, a as expect, v as vi, b as vitest } from './vendor/vi.Elqer9-7.js';
-import { d as dist } from './vendor/index.DI9daj1Q.js';
-export { b as assertType, g as getRunningMode, i as inject, a as isWatchMode } from './vendor/index.DI9daj1Q.js';
+export { b as bench } from './chunks/benchmark.DDmpNjj-.js';
+import { d as dist } from './chunks/index.BfeNhc0N.js';
+export { a as assertType, g as getRunningMode, b as inject, i as isWatchMode } from './chunks/index.BfeNhc0N.js';
+export { i as isFirstRun, a as runOnce } from './chunks/run-once.Sxe67Wng.js';
+export { c as createExpect, a as expect, v as vi, b as vitest } from './chunks/vi.fiQ7lMRF.js';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import '@vitest/runner/utils';
 import '@vitest/utils';
-import './vendor/index.BJmtb_7W.js';
+import './chunks/index.DYufA6CZ.js';
 import 'pathe';
-import './vendor/global.7bFbnyXl.js';
-import './vendor/env.2ltrQNq0.js';
+import './chunks/utils.Ck2hJTRs.js';
+import './chunks/env.BU041cs9.js';
 import 'std-env';
-import './vendor/_commonjsHelpers.BFTU3MAI.js';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import '@vitest/expect';
 import '@vitest/snapshot';
 import '@vitest/utils/error';
-import './vendor/tasks.DhVtQBtW.js';
+import './chunks/tasks.BZnCS9aT.js';
 import '@vitest/utils/source-map';
-import './vendor/base.DRHPZCCj.js';
-import './vendor/date.W2xKR2qe.js';
+import './chunks/base.DSsbfkDg.js';
+import './chunks/date.W2xKR2qe.js';
 import '@vitest/spy';
 
 

package/dist/node.d.ts

@@ -1,26 +1,32 @@
-import { v as VitestRunMode, U as UserConfig, aj as VitestOptions, Q as Vitest, R as ResolvedConfig, i as ProvidedContext, ak as WorkspaceProject, e as RuntimeRPC, A as ApiConfig, al as Logger, am as TestSequencer, an as WorkspaceSpec } from './reporters-B7ebVMkT.js';
-export { ay as BrowserBuiltinProvider, az as BrowserCommand, aA as BrowserCommandContext, aE as BrowserOrchestrator, at as BrowserProvider, as as BrowserProviderInitializationOptions, av as BrowserProviderModule, ax as BrowserProviderOptions, z as BrowserScript, aB as BrowserServer, aC as BrowserServerState, aD as BrowserServerStateContext, au as CDPSession, aH as HTMLOptions, aG as JUnitOptions, aF as JsonOptions, ao as ProcessPool, aw as ResolvedBrowserOptions, ar as TestSequencerConstructor, aq as VitestPackageInstaller, ap as getFilePoolName } from './reporters-B7ebVMkT.js';
+import { u as VitestRunMode, U as UserConfig, F as VitestOptions, o as Vitest, x as ResolvedConfig, W as WorkspaceProject, A as ApiConfig, L as Logger, G as TestSequencer, H as WorkspaceSpec } from './chunks/reporters.C_zwCd4j.js';
+export { B as BaseCoverageOptions, E as BenchmarkUserOptions, $ as BrowserBuiltinProvider, a0 as BrowserCommand, a1 as BrowserCommandContext, q as BrowserConfigOptions, a5 as BrowserOrchestrator, Q as BrowserProvider, O as BrowserProviderInitializationOptions, Y as BrowserProviderModule, _ as BrowserProviderOptions, p as BrowserScript, a2 as BrowserServer, a3 as BrowserServerState, a4 as BrowserServerStateContext, r as BuiltinEnvironment, X as CDPSession, t as CSSModuleScopeStrategy, k as CoverageIstanbulOptions, j as CoverageOptions, C as CoverageProvider, a as CoverageProviderModule, h as CoverageReporter, l as CoverageV8Options, m as CustomProviderOptions, D as DepsOptimizationOptions, ag as FileDiagnostic, a8 as HTMLOptions, I as InlineConfig, a7 as JUnitOptions, a6 as JsonOptions, P as Pool, s as PoolOptions, J as ProcessPool, y as ProjectConfig, g as ReportContext, Z as ResolvedBrowserOptions, R as ResolvedCoverageOptions, al as ResolvedProjectConfig, ae as TaskOptions, a9 as TestCase, ad as TestCollection, af as TestDiagnostic, aa as TestFile, ac as TestProject, ah as TestResult, aj as TestResultFailed, ai as TestResultPassed, ak as TestResultSkipped, N as TestSequencerConstructor, ab as TestSuite, v as TransformModePatterns, c as TypeCheckCollectLineNumbers, d as TypeCheckCollectLines, f as TypeCheckContext, T as TypeCheckErrorInfo, b as TypeCheckRawErrorsMap, e as TypeCheckRootAndTarget, w as TypecheckConfig, z as UserWorkspaceConfig, V as VitestEnvironment, M as VitestPackageInstaller, K as getFilePoolName } from './chunks/reporters.C_zwCd4j.js';
 import { UserConfig as UserConfig$1, Plugin, ResolvedConfig as ResolvedConfig$1 } from 'vite';
 import * as vite from 'vite';
 export { vite as Vite };
 export { createServer, isFileServingAllowed, parseAst, parseAstAsync } from 'vite';
 import { Writable } from 'node:stream';
+import { P as ProvidedContext } from './chunks/environment.0M5R1SX_.js';
+export { f as EnvironmentOptions, H as HappyDOMOptions, J as JSDOMOptions, O as OnServerRestartHandler } from './chunks/environment.0M5R1SX_.js';
+import { R as RuntimeRPC } from './chunks/worker.C5iHKIaJ.js';
 import createDebug from 'debug';
+export { W as WorkerContext } from './chunks/worker.DKkAC4Qw.js';
+export { SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+export { b as RuntimeConfig } from './chunks/config.DCnyCTbs.js';
 import '@vitest/pretty-format';
-import '@vitest/runner';
 import 'vite-node';
 import '@vitest/snapshot';
-import '@vitest/expect';
-import '@vitest/runner/utils';
-import '@vitest/utils';
-import 'tinybench';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
-import 'node:worker_threads';
+import '@vitest/utils';
 import '@vitest/utils/source-map';
 import 'node:fs';
 import 'chai';
+import './chunks/benchmark.puBFxyfE.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import 'node:worker_threads';
+import '@vitest/snapshot/environment';
 
 declare function createVitest(mode: VitestRunMode, options: UserConfig, viteOverrides?: UserConfig$1, vitestOptions?: VitestOptions): Promise<Vitest>;
 
@@ -93,4 +99,4 @@ declare class BaseSequencer implements TestSequencer {
     sort(files: WorkspaceSpec[]): Promise<WorkspaceSpec[]>;
 }
 
-export { BaseSequencer, GitNotFoundError, type GlobalSetupContext, TestSequencer, FilesNotFoundError as TestsNotFoundError, Vitest, VitestPlugin, WorkspaceProject, WorkspaceSpec, createDebugger, createMethodsRPC, createVitest, distDir, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rootDir, startVitest };
+export { ApiConfig, BaseSequencer, GitNotFoundError, type GlobalSetupContext, ResolvedConfig, TestSequencer, FilesNotFoundError as TestsNotFoundError, UserConfig, Vitest, VitestPlugin, VitestRunMode, WorkspaceProject, WorkspaceSpec, createDebugger, createMethodsRPC, createVitest, distDir, parseCLI, registerConsoleShortcuts, resolveApiServerConfig, resolveConfig, resolveFsAllow, rootDir, startVitest };

package/dist/node.js

@@ -1,38 +1,36 @@
-export { G as GitNotFoundError, F as TestsNotFoundError, b as VitestPackageInstaller, V as VitestPlugin, a as createMethodsRPC, c as createVitest, g as getFilePoolName, r as registerConsoleShortcuts, e as resolveApiServerConfig, f as resolveConfig, d as resolveFsAllow, s as startVitest } from './vendor/cli-api.CTkP2Ier.js';
-export { p as parseCLI } from './vendor/cac.DFtWvZc2.js';
+export { G as GitNotFoundError, F as TestsNotFoundError, b as VitestPackageInstaller, V as VitestPlugin, a as createMethodsRPC, c as createVitest, g as getFilePoolName, r as registerConsoleShortcuts, e as resolveApiServerConfig, f as resolveConfig, d as resolveFsAllow, s as startVitest } from './chunks/cli-api.OKfd3qJ0.js';
+export { p as parseCLI } from './chunks/cac.DGgmCKmU.js';
 import createDebug from 'debug';
 export { distDir, rootDir } from './path.js';
-export { e as BaseSequencer } from './vendor/index.CuuL9y4g.js';
+export { h as BaseSequencer, d as TestCase, e as TestFile, i as TestProject, f as TestSuite } from './chunks/index.JbiJutJ_.js';
 export { createServer, isFileServingAllowed, parseAst, parseAstAsync } from 'vite';
 import 'node:fs';
 import 'pathe';
-import './vendor/coverage.BhYSDdTT.js';
-import './vendor/index.D4nqnQWz.js';
-import 'node:console';
-import './vendor/index.D6GZqexG.js';
+import './chunks/coverage.CqfT4xaf.js';
+import './chunks/index.CM5UI-4O.js';
 import 'node:path';
 import 'node:url';
 import 'node:process';
-import './vendor/_commonjsHelpers.BFTU3MAI.js';
+import './chunks/_commonjsHelpers.BFTU3MAI.js';
 import 'readline';
 import 'events';
-import './vendor/constants.CsnA4eRy.js';
+import './chunks/constants.CaAN7icJ.js';
 import 'node:worker_threads';
 import 'os';
 import 'path';
 import 'util';
-import './vendor/index.BMmMjLIQ.js';
+import './chunks/index.BMmMjLIQ.js';
 import 'stream';
 import 'fs';
 import 'vite-node/client';
 import '@vitest/snapshot/manager';
 import 'vite-node/server';
 import '@vitest/runner/utils';
-import './vendor/base.DRHPZCCj.js';
+import './chunks/base.DSsbfkDg.js';
 import '@vitest/utils';
-import './vendor/env.2ltrQNq0.js';
+import './chunks/env.BU041cs9.js';
 import 'std-env';
-import './vendor/index.BpSiYbpB.js';
+import './chunks/index.BpSiYbpB.js';
 import 'zlib';
 import 'buffer';
 import 'crypto';
@@ -55,17 +53,16 @@ import 'tinyrainbow';
 import 'vite-node/utils';
 import 'magic-string';
 import '@vitest/utils/ast';
-import './vendor/index.BJmtb_7W.js';
-import './vendor/global.7bFbnyXl.js';
+import './chunks/index.DYufA6CZ.js';
+import './chunks/utils.Ck2hJTRs.js';
 import 'node:readline';
-import './vendor/utils.BySfPUwy.js';
-import './vendor/tasks.DhVtQBtW.js';
+import './chunks/utils.DpP_sDwr.js';
+import './chunks/tasks.BZnCS9aT.js';
 import 'node:perf_hooks';
-import './chunks/runtime-console.C2L2zykk.js';
 import 'node:stream';
-import './vendor/date.W2xKR2qe.js';
 import 'execa';
 import 'module';
+import 'node:console';
 import 'assert';
 
 function createDebugger(namespace) {