vitest 0.33.0 → 0.34.0

package/dist/{types-198fd1d9.d.ts → types-3c7dbfa5.d.ts}

@@ -1,8 +1,10 @@
 import { SnapshotResult, SnapshotStateOptions, SnapshotState } from '@vitest/snapshot';
 import { ExpectStatic } from '@vitest/expect';
+import * as vite from 'vite';
 import { ViteDevServer, UserConfig as UserConfig$1, TransformResult as TransformResult$1, CommonServerOptions, DepOptimizationConfig, AliasOptions } from 'vite';
 import * as _vitest_runner from '@vitest/runner';
 import { File, Test as Test$1, Suite, TaskResultPack, Task, CancelReason, TaskCustom, SequenceHooks, SequenceSetupFiles } from '@vitest/runner';
+import { RawSourceMap, FetchResult, ViteNodeResolveId, ModuleCacheMap, ViteNodeServerOptions } from 'vite-node';
 import { ChainableFunction } from '@vitest/runner/utils';
 import { ParsedStack, Awaitable as Awaitable$1, ErrorWithDiff, Arrayable as Arrayable$1 } from '@vitest/utils';
 import { TaskResult, Bench, Options } from 'tinybench';
@@ -10,7 +12,7 @@ import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
 import { MessagePort } from 'node:worker_threads';
-import { RawSourceMap, FetchResult, ViteNodeResolveId, ModuleCacheMap } from 'vite-node';
+import * as rollup from 'rollup';
 import { Stats } from 'node:fs';
 import * as chai from 'chai';
 
@@ -457,16 +459,21 @@ declare class WorkspaceProject {
     server: ViteDevServer;
     vitenode: ViteNodeServer;
     runner: ViteNodeRunner;
-    browser: ViteDevServer;
+    browser?: ViteDevServer;
     typechecker?: Typechecker;
     closingPromise: Promise<unknown> | undefined;
     browserProvider: BrowserProvider | undefined;
+    testFilesList: string[];
     constructor(path: string | number, ctx: Vitest);
     getName(): string;
     isCore(): boolean;
+    getModuleById(id: string): vite.ModuleNode | undefined;
+    getSourceMapModuleById(id: string): rollup.SourceMap | null | undefined;
+    getBrowserSourceMapModuleById(id: string): rollup.SourceMap | null | undefined;
     get reporters(): Reporter[];
     globTestFiles(filters?: string[]): Promise<string[]>;
     globAllTestFiles(config: ResolvedConfig, cwd: string): Promise<string[]>;
+    isTestFile(id: string): boolean;
     globFiles(include: string[], exclude: string[], cwd: string): Promise<string[]>;
     isTargetFile(id: string, source?: string): Promise<boolean>;
     isInSourceTestFile(code: string): boolean;
@@ -543,14 +550,53 @@ interface ProcessPool {
     close: () => Promise<void>;
 }
 
-interface CollectingPromise {
-    promise: Promise<void>;
-    resolve: () => void;
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType$1<T> = T extends (...args: infer U) => any ? U : never;
+type MutableArray<T extends readonly any[]> = {
+    -readonly [k in keyof T]: T[k];
+};
+interface Constructable {
+    new (...args: any[]): any;
+}
+interface ModuleCache {
+    promise?: Promise<any>;
+    exports?: any;
+    code?: string;
+}
+interface EnvironmentReturn {
+    teardown(global: any): Awaitable<void>;
+}
+interface VmEnvironmentReturn {
+    getVmContext(): {
+        [key: string]: any;
+    };
+    teardown(): Awaitable<void>;
+}
+interface Environment {
+    name: string;
+    transformMode: 'web' | 'ssr';
+    setupVM?(options: Record<string, any>): Awaitable<VmEnvironmentReturn>;
+    setup(global: any, options: Record<string, any>): Awaitable<EnvironmentReturn>;
+}
+interface UserConsoleLog {
+    content: string;
+    type: 'stdout' | 'stderr';
+    taskId?: string;
+    time: number;
+    size: number;
+}
+interface ModuleGraphData {
+    graph: Record<string, string[]>;
+    externalized: string[];
+    inlined: string[];
 }
+type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+
 declare class StateManager {
     filesMap: Map<string, File[]>;
     pathsSet: Set<string>;
-    collectingPromise: CollectingPromise | undefined;
     browserTestPromises: Map<string, {
         resolve: (v: unknown) => void;
         reject: (v: unknown) => void;
@@ -570,7 +616,11 @@ declare class StateManager {
     getFailedFilepaths(): string[];
     collectPaths(paths?: string[]): void;
     collectFiles(files?: File[]): void;
-    clearFiles(project: WorkspaceProject, paths?: string[]): void;
+    clearFiles(_project: {
+        config: {
+            name: string;
+        };
+    }, paths?: string[]): void;
     updateId(task: Task): void;
     updateTasks(packs: TaskResultPack[]): void;
     updateUserLog(log: UserConsoleLog): void;
@@ -578,6 +628,11 @@ declare class StateManager {
     cancelFiles(files: string[], root: string): void;
 }
 
+interface ErrorOptions {
+    type?: string;
+    fullStack?: boolean;
+    project?: WorkspaceProject;
+}
 declare class Logger {
     ctx: Vitest;
     console: Console;
@@ -599,7 +654,7 @@ declare class Logger {
     clearFullScreen(message: string): void;
     clearScreen(message: string, force?: boolean): void;
     private _clearScreen;
-    printError(err: unknown, fullStack?: boolean, type?: string): Promise<void>;
+    printError(err: unknown, options?: ErrorOptions): Promise<void>;
     printNoTestFound(filters?: string[]): void;
     printBanner(): void;
     printUnhandledErrors(errors: unknown[]): Promise<void>;
@@ -694,6 +749,7 @@ declare class Vitest {
     setServer(options: UserConfig, server: ViteDevServer, cliOptions: UserConfig): Promise<void>;
     private createCoreWorkspace;
     getCoreWorkspaceProject(): WorkspaceProject | null;
+    getProjectByTaskId(taskId: string): WorkspaceProject;
     private resolveWorkspace;
     private initCoverageProvider;
     private initBrowserProviders;
@@ -732,16 +788,6 @@ declare class Vitest {
     onCancel(fn: (reason: CancelReason) => void): void;
 }
 
-type MockFactoryWithHelper = (importOriginal: <T = unknown>() => Promise<T>) => any;
-type MockFactory = () => any;
-type MockMap = Map<string, Record<string, string | null | MockFactory>>;
-interface PendingSuiteMock {
-    id: string;
-    importer: string;
-    type: 'mock' | 'unmock';
-    factory?: MockFactory;
-}
-
 interface TestSequencer {
     /**
      * Slicing tests into shards. Will be run before `sort`.
@@ -790,42 +836,6 @@ declare class BasicReporter extends BaseReporter {
     reportSummary(files: File[], errors: unknown[]): Promise<void>;
 }
 
-type Awaitable<T> = T | PromiseLike<T>;
-type Nullable<T> = T | null | undefined;
-type Arrayable<T> = T | Array<T>;
-type ArgumentsType$1<T> = T extends (...args: infer U) => any ? U : never;
-type MutableArray<T extends readonly any[]> = {
-    -readonly [k in keyof T]: T[k];
-};
-interface Constructable {
-    new (...args: any[]): any;
-}
-interface ModuleCache {
-    promise?: Promise<any>;
-    exports?: any;
-    code?: string;
-}
-interface EnvironmentReturn {
-    teardown: (global: any) => Awaitable<void>;
-}
-interface Environment {
-    name: string;
-    setup(global: any, options: Record<string, any>): Awaitable<EnvironmentReturn>;
-}
-interface UserConsoleLog {
-    content: string;
-    type: 'stdout' | 'stderr';
-    taskId?: string;
-    time: number;
-    size: number;
-}
-interface ModuleGraphData {
-    graph: Record<string, string[]>;
-    externalized: string[];
-    inlined: string[];
-}
-type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
-
 interface ListRendererOptions$1 {
     renderSucceed?: boolean;
     logger: Logger;
@@ -920,7 +930,7 @@ declare class JUnitReporter implements Reporter {
     private fileFd?;
     onInit(ctx: Vitest): Promise<void>;
     writeElement(name: string, attrs: Record<string, any>, children: () => Promise<void>): Promise<void>;
-    writeErrorDetails(error: ErrorWithDiff): Promise<void>;
+    writeErrorDetails(task: Task, error: ErrorWithDiff): Promise<void>;
     writeLogs(task: Task, type: 'err' | 'out'): Promise<void>;
     writeTasks(tasks: Task[], filename: string): Promise<void>;
     onFinished(files?: _vitest_runner.File[]): Promise<void>;
@@ -995,10 +1005,6 @@ declare const ReportersMap: {
 };
 type BuiltinReporters = keyof typeof ReportersMap;
 
-declare function createExpect(test?: Test$1): ExpectStatic;
-declare const globalExpect: ExpectStatic;
-
-declare function setupChaiConfig(config: ChaiConfig): void;
 type ChaiConfig = Omit<Partial<typeof chai.config>, 'useProxy' | 'proxyExcludedKeys'>;
 
 // Type definitions for istanbul-lib-report 3.0
@@ -1109,9 +1115,14 @@ type BirpcReturn<RemoteFunctions, LocalFunctions = {}> = {
     $functions: LocalFunctions;
 };
 
+type MockFactoryWithHelper = (importOriginal: <T = unknown>() => Promise<T>) => any;
+type MockFactory = () => any;
+type MockMap = Map<string, Record<string, string | null | MockFactory>>;
+
+type TransformMode = 'web' | 'ssr';
 interface RuntimeRPC {
-    fetch: (id: string, environment: VitestEnvironment) => Promise<FetchResult>;
-    resolveId: (id: string, importer: string | undefined, environment: VitestEnvironment) => Promise<ViteNodeResolveId | null>;
+    fetch: (id: string, environment: TransformMode) => Promise<FetchResult>;
+    resolveId: (id: string, importer: string | undefined, environment: TransformMode) => Promise<ViteNodeResolveId | null>;
     getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
     onFinished: (files: File[], errors?: unknown[]) => void;
     onWorkerExit: (error: unknown, code?: number) => void;
@@ -1121,8 +1132,8 @@ interface RuntimeRPC {
     onCollected: (files: File[]) => void;
     onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
     onTaskUpdate: (pack: TaskResultPack[]) => void;
-    onCancel(reason: CancelReason): void;
-    getCountOfFailedTests(): number;
+    onCancel: (reason: CancelReason) => void;
+    getCountOfFailedTests: () => number;
     snapshotSaved: (snapshot: SnapshotResult) => void;
     resolveSnapshotPath: (testPath: string) => string;
 }
@@ -1131,6 +1142,12 @@ interface RunnerRPC {
 }
 interface ContextTestEnvironment {
     name: VitestEnvironment;
+    environment?: Environment;
+    transformMode?: TransformMode;
+    options: EnvironmentOptions | null;
+}
+interface ResolvedTestEnvironment {
+    environment: Environment;
     options: EnvironmentOptions | null;
 }
 interface ContextRPC {
@@ -1148,12 +1165,14 @@ type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeReso
 interface AfterSuiteRunMeta {
     coverage?: unknown;
 }
+type WorkerRPC = BirpcReturn<RuntimeRPC>;
 interface WorkerGlobalState {
-    ctx: WorkerContext;
+    ctx: ContextRPC;
     config: ResolvedConfig;
-    rpc: BirpcReturn<RuntimeRPC>;
+    rpc: WorkerRPC;
     current?: Test$1;
     filepath?: string;
+    environment: Environment;
     environmentTeardownRun?: boolean;
     onCancel: Promise<CancelReason>;
     moduleCache: ModuleCacheMap;
@@ -1198,18 +1217,16 @@ interface CoverageProviderModule {
 }
 type CoverageReporter = keyof ReportOptions;
 type CoverageReporterWithOptions<ReporterName extends CoverageReporter = CoverageReporter> = ReporterName extends CoverageReporter ? ReportOptions[ReporterName] extends never ? [ReporterName, {}] : [ReporterName, Partial<ReportOptions[ReporterName]>] : never;
-type Provider = 'c8' | 'v8' | 'istanbul' | 'custom' | undefined;
+type Provider = 'v8' | 'istanbul' | 'custom' | undefined;
 type CoverageOptions<T extends Provider = Provider> = T extends 'istanbul' ? ({
     provider: T;
-} & CoverageIstanbulOptions) : T extends 'c8' ? ({
-    provider: T;
-} & CoverageC8Options) : T extends 'v8' ? ({
+} & CoverageIstanbulOptions) : T extends 'v8' ? ({
     provider: T;
 } & CoverageV8Options) : T extends 'custom' ? ({
     provider: T;
 } & CustomProviderOptions) : ({
     provider?: T;
-} & (CoverageC8Options));
+} & (CoverageV8Options));
 /** Fields that have default values. Internally these will always be defined. */
 type FieldsWithDefaultValues = 'enabled' | 'clean' | 'cleanOnRerun' | 'reportsDirectory' | 'exclude' | 'extension' | 'reportOnFailure';
 type ResolvedCoverageOptions<T extends Provider = Provider> = CoverageOptions<T> & Required<Pick<CoverageOptions<T>, FieldsWithDefaultValues>> & {
@@ -1324,7 +1341,7 @@ interface BaseCoverageOptions {
     /**
      * Generate coverage report even when tests fail.
      *
-     * @default true
+     * @default false
      */
     reportOnFailure?: boolean;
 }
@@ -1336,32 +1353,6 @@ interface CoverageIstanbulOptions extends BaseCoverageOptions {
      */
     ignoreClassMethods?: string[];
 }
-interface CoverageC8Options extends BaseCoverageOptions {
-    /**
-     * Allow files from outside of your cwd.
-     *
-     * @default false
-     */
-    allowExternal?: boolean;
-    /**
-     * Exclude coverage under `/node_modules/`
-     *
-     * @default true
-     */
-    excludeNodeModules?: boolean;
-    /**
-     * Specifies the directories that are used when `--all` is enabled.
-     *
-     * @default cwd
-    */
-    src?: string[];
-    /**
-     * Shortcut for `--check-coverage --lines 100 --functions 100 --branches 100 --statements 100`
-     *
-     * @default false
-     */
-    100?: boolean;
-}
 interface CoverageV8Options extends BaseCoverageOptions {
     /**
      * Shortcut for `--check-coverage --lines 100 --functions 100 --branches 100 --statements 100`
@@ -1506,7 +1497,7 @@ type BenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', [
 
 type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
 type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
-type VitestPool = 'browser' | 'threads' | 'child_process';
+type VitestPool = 'browser' | 'threads' | 'child_process' | 'experimentalVmThreads';
 type CSSModuleScopeStrategy = 'stable' | 'scoped' | 'non-scoped';
 type ApiConfig = Pick<CommonServerOptions, 'port' | 'strictPort' | 'host'>;
 
@@ -1558,13 +1549,30 @@ interface SequenceOptions {
     hooks?: SequenceHooks;
 }
 type DepsOptimizationOptions = Omit<DepOptimizationConfig, 'disabled' | 'noDiscovery'> & {
-    enabled: boolean;
+    enabled?: boolean;
 };
+interface TransformModePatterns {
+    /**
+     * Use SSR transform pipeline for all modules inside specified tests.
+     * Vite plugins will receive `ssr: true` flag when processing those files.
+     *
+     * @default tests with node or edge environment
+     */
+    ssr?: string[];
+    /**
+     * First do a normal transform pipeline (targeting browser),
+     * then then do a SSR rewrite to run the code in Node.
+     * Vite plugins will receive `ssr: false` flag when processing those files.
+     *
+     * @default tests with jsdom or happy-dom environment
+     */
+    web?: string[];
+}
 interface DepsOptions {
     /**
      * Enable dependency optimization. This can improve the performance of your tests.
      */
-    experimentalOptimizer?: {
+    optimizer?: {
         web?: DepsOptimizationOptions;
         ssr?: DepsOptimizationOptions;
     };
@@ -1575,6 +1583,8 @@ interface DepsOptions {
      * And does not support HMR on reload.
      *
      * Typically, packages under `node_modules` are externalized.
+     *
+     * @deprecated If you rely on vite-node directly, use `server.deps.external` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.exclude`.
      */
     external?: (string | RegExp)[];
     /**
@@ -1583,6 +1593,8 @@ interface DepsOptions {
      * This could be helpful to handle packages that ship `.js` in ESM format (that Node can't handle).
      *
      * If `true`, every dependency will be inlined
+     *
+     * @deprecated If you rely on vite-node directly, use `server.deps.inline` instead. Otherwise, consider using `deps.optimizer.{web,ssr}.include`.
      */
     inline?: (string | RegExp)[] | true;
     /**
@@ -1597,11 +1609,14 @@ interface DepsOptions {
      * cause some misalignment if a package have different logic in ESM and CJS mode.
      *
      * @default false
+     *
+     * @deprecated Use `server.deps.fallbackCJS` instead.
      */
     fallbackCJS?: boolean;
     /**
      * Use experimental Node loader to resolve imports inside node_modules using Vite resolve algorithm.
      * @default false
+     * @deprecated If you rely on aliases inside external packages, use `deps.optimizer.{web,ssr}.include` instead.
      */
     registerNodeLoader?: boolean;
     /**
@@ -1641,8 +1656,13 @@ interface InlineConfig {
     includeSource?: string[];
     /**
      * Handling for dependencies inlining or externalizing
+     *
      */
     deps?: DepsOptions;
+    /**
+     * Vite-node server options
+     */
+    server?: Omit<ViteNodeServerOptions, 'transformMode'>;
     /**
      * Base directory to scan for the test files
      *
@@ -1727,6 +1747,19 @@ interface InlineConfig {
      * Also definable individually per reporter by using an object instead.
      */
     outputFile?: string | (Partial<Record<BuiltinReporters, string>> & Record<string, string>);
+    /**
+     * Run tests using VM context in a worker pool.
+     *
+     * This makes tests run faster, but VM module is unstable. Your tests might leak memory.
+     */
+    experimentalVmThreads?: boolean;
+    /**
+     * Specifies the memory limit for workers before they are recycled.
+     * If you see your worker leaking memory, try to tinker this value.
+     *
+     * This only has effect on workers that run tests in VM context.
+     */
+    experimentalVmWorkerMemoryLimit?: string | number;
     /**
      * Enable multi-threading
      *
@@ -1768,7 +1801,7 @@ interface InlineConfig {
     /**
      * Default timeout to wait for close when Vitest shuts down, in milliseconds
      *
-     * @default 1000
+     * @default 10000
      */
     teardownTimeout?: number;
     /**
@@ -1881,25 +1914,9 @@ interface InlineConfig {
      */
     uiBase?: string;
     /**
-     * Determine the transform method of modules
+     * Determine the transform method for all modules inported inside a test that matches the glob pattern.
      */
-    transformMode?: {
-        /**
-         * Use SSR transform pipeline for the specified files.
-         * Vite plugins will receive `ssr: true` flag when processing those files.
-         *
-         * @default [/\.([cm]?[jt]sx?|json)$/]
-         */
-        ssr?: RegExp[];
-        /**
-         * First do a normal transform pipeline (targeting browser),
-         * then then do a SSR rewrite to run the code in Node.
-         * Vite plugins will receive `ssr: false` flag when processing those files.
-         *
-         * @default other than `ssr`
-         */
-        web?: RegExp[];
-    };
+    testTransformMode?: TransformModePatterns;
     /**
      * Format options for snapshot testing.
      */
@@ -2079,7 +2096,7 @@ interface UserConfig extends InlineConfig {
      */
     shard?: string;
 }
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'browser' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence' | 'typecheck' | 'runner' | 'experimentalVmWorkerMemoryLimit'> {
     mode: VitestRunMode;
     base?: string;
     config?: string;
@@ -2112,6 +2129,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     };
     typecheck: TypecheckConfig;
     runner?: string;
+    experimentalVmWorkerMemoryLimit?: number | null;
 }
 type ProjectConfig = Omit<UserConfig, 'sequencer' | 'shard' | 'watch' | 'run' | 'cache' | 'update' | 'reporters' | 'outputFile' | 'maxThreads' | 'minThreads' | 'useAtomics' | 'teardownTimeout' | 'silent' | 'watchExclude' | 'forceRerunTriggers' | 'testNamePattern' | 'ui' | 'open' | 'uiBase' | 'snapshotFormat' | 'resolveSnapshotPath' | 'passWithNoTests' | 'onConsoleLog' | 'dangerouslyIgnoreUnhandledErrors' | 'slowTestThreshold' | 'inspect' | 'inspectBrk' | 'deps' | 'coverage'> & {
     sequencer?: Omit<SequenceOptions, 'sequencer' | 'seed'>;
@@ -2205,4 +2223,4 @@ type Context = RootAndTarget & {
     lastActivePath?: string;
 };
 
-export { VitestEnvironment as $, AfterSuiteRunMeta as A, BaseCoverageOptions as B, CoverageOptions as C, Reporter as D, Environment as E, FileOptions as F, globalExpect as G, HtmlOptions as H, createExpect as I, setupChaiConfig as J, ChaiConfig as K, LcovOptions as L, MockFactory as M, RawErrsMap as N, TscErrorInfo as O, ProjectOptions as P, CollectLineNumbers as Q, ResolvedConfig as R, CollectLines as S, TeamcityOptions as T, UserConfig as U, VitestRunMode as V, WorkspaceSpec as W, RootAndTarget as X, Context as Y, JSDOMOptions as Z, BuiltinEnvironment as _, CoverageProvider as a, VitestPool as a0, CSSModuleScopeStrategy as a1, ApiConfig as a2, EnvironmentOptions as a3, DepsOptimizationOptions as a4, InlineConfig as a5, TypecheckConfig as a6, RuntimeRPC as a7, RunnerRPC as a8, ContextTestEnvironment as a9, ContextRPC as aa, WorkerContext as ab, ResolveIdFunction as ac, WorkerGlobalState as ad, Awaitable as ae, Nullable as af, Arrayable as ag, ArgumentsType$1 as ah, MutableArray as ai, Constructable as aj, ModuleCache as ak, EnvironmentReturn as al, OnServerRestartHandler as am, ReportContext as an, CoverageReporter as ao, BenchmarkUserOptions as ap, Benchmark as aq, BenchmarkResult as ar, BenchFunction as as, CoverageProviderModule as b, ResolvedCoverageOptions as c, CoverageV8Options as d, CoverageC8Options as e, CustomProviderOptions as f, CoverageIstanbulOptions as g, CloverOptions as h, CoberturaOptions as i, HtmlSpaOptions as j, LcovOnlyOptions as k, TextOptions as l, FakeTimerInstallOpts as m, ProjectConfig as n, Vitest as o, PendingSuiteMock as p, MockMap as q, TestSequencer as r, WorkspaceProject as s, startVitest as t, TestSequencerConstructor as u, BenchmarkAPI as v, MockFactoryWithHelper as w, RuntimeConfig as x, UserConsoleLog as y, ModuleGraphData as z };
+export { Arrayable as $, AfterSuiteRunMeta as A, BaseCoverageOptions as B, CoverageOptions as C, DepsOptimizationOptions as D, Environment as E, FakeTimerInstallOpts as F, TypecheckConfig as G, RuntimeRPC as H, InlineConfig as I, JSDOMOptions as J, RunnerRPC as K, ContextTestEnvironment as L, MockFactoryWithHelper as M, ResolvedTestEnvironment as N, ContextRPC as O, ProjectConfig as P, WorkerContext as Q, ResolvedConfig as R, ResolveIdFunction as S, TestSequencer as T, UserConfig as U, VitestRunMode as V, WorkspaceSpec as W, WorkerRPC as X, WorkerGlobalState as Y, Awaitable as Z, Nullable as _, CoverageProvider as a, ArgumentsType$1 as a0, MutableArray as a1, Constructable as a2, ModuleCache as a3, EnvironmentReturn as a4, VmEnvironmentReturn as a5, OnServerRestartHandler as a6, ReportContext as a7, CoverageReporter as a8, CoverageIstanbulOptions as a9, CustomProviderOptions as aa, BenchmarkUserOptions as ab, Benchmark as ac, BenchmarkResult as ad, BenchFunction as ae, CoverageProviderModule as b, ResolvedCoverageOptions as c, CoverageV8Options as d, Vitest as e, WorkspaceProject as f, TestSequencerConstructor as g, BenchmarkAPI as h, RuntimeConfig as i, UserConsoleLog as j, ModuleGraphData as k, Reporter as l, RawErrsMap as m, TscErrorInfo as n, CollectLineNumbers as o, CollectLines as p, RootAndTarget as q, Context as r, startVitest as s, BuiltinEnvironment as t, VitestEnvironment as u, VitestPool as v, CSSModuleScopeStrategy as w, ApiConfig as x, EnvironmentOptions as y, TransformModePatterns as z };

package/dist/vendor-base.9c08bbd0.js

@@ -0,0 +1,96 @@
+import '@vitest/utils';
+
+function collectOwnProperties(obj, collector) {
+  const collect = typeof collector === "function" ? collector : (key) => collector.add(key);
+  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 isPrimitive(value) {
+  return value === null || typeof value !== "function" && typeof value !== "object";
+}
+function getAllMockableProperties(obj, isModule, constructors) {
+  const {
+    Map,
+    Object: Object2,
+    Function,
+    RegExp,
+    Array: Array2
+  } = constructors;
+  const allProps = new Map();
+  let curr = obj;
+  do {
+    if (curr === Object2.prototype || curr === Function.prototype || curr === RegExp.prototype)
+      break;
+    collectOwnProperties(curr, (key) => {
+      const descriptor = Object2.getOwnPropertyDescriptor(curr, key);
+      if (descriptor)
+        allProps.set(key, { key, descriptor });
+    });
+  } while (curr = Object2.getPrototypeOf(curr));
+  if (isModule && !allProps.has("default") && "default" in obj) {
+    const descriptor = Object2.getOwnPropertyDescriptor(obj, "default");
+    if (descriptor)
+      allProps.set("default", { key: "default", descriptor });
+  }
+  return Array2.from(allProps.values());
+}
+function slash(str) {
+  return str.replace(/\\/g, "/");
+}
+function noop() {
+}
+function toArray(array) {
+  if (array === null || array === void 0)
+    array = [];
+  if (Array.isArray(array))
+    return array;
+  return [array];
+}
+function toString(v) {
+  return Object.prototype.toString.call(v);
+}
+function isPlainObject(val) {
+  return toString(val) === "[object Object]" && (!val.constructor || val.constructor.name === "Object");
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source === void 0)
+    return target;
+  if (isMergeableObject(target) && isMergeableObject(source)) {
+    Object.keys(source).forEach((key) => {
+      if (isMergeableObject(source[key])) {
+        if (!target[key])
+          target[key] = {};
+        deepMerge(target[key], source[key]);
+      } else {
+        target[key] = source[key];
+      }
+    });
+  }
+  return deepMerge(target, ...sources);
+}
+function isMergeableObject(item) {
+  return isPlainObject(item) && !Array.isArray(item);
+}
+function stdout() {
+  return console._stdout || process.stdout;
+}
+class AggregateErrorPonyfill extends Error {
+  errors;
+  constructor(errors, message = "") {
+    super(message);
+    this.errors = [...errors];
+  }
+}
+
+export { AggregateErrorPonyfill as A, stdout as a, getAllMockableProperties as b, deepMerge as d, groupBy as g, isPrimitive as i, noop as n, slash as s, toArray as t };

package/dist/{vendor-coverage.2e41927a.js → vendor-coverage.78040316.js}

@@ -1,5 +1,4 @@
 const CoverageProviderMap = {
-  c8: "@vitest/coverage-c8",
   v8: "@vitest/coverage-v8",
   istanbul: "@vitest/coverage-istanbul"
 };
@@ -7,7 +6,7 @@ async function resolveCoverageProviderModule(options, loader) {
   if (!(options == null ? void 0 : options.enabled) || !options.provider)
     return null;
   const provider = options.provider;
-  if (provider === "c8" || provider === "v8" || provider === "istanbul") {
+  if (provider === "v8" || provider === "istanbul") {
     const { default: coverageModule } = await loader.executeId(CoverageProviderMap[provider]);
     if (!coverageModule)
       throw new Error(`Failed to load ${CoverageProviderMap[provider]}. Default export is missing.`);

package/dist/vendor-date.6e993429.js

@@ -0,0 +1,50 @@
+const RealDate = Date;
+let now = null;
+class MockDate extends RealDate {
+  constructor(y, m, d, h, M, s, ms) {
+    super();
+    let date;
+    switch (arguments.length) {
+      case 0:
+        if (now !== null)
+          date = new RealDate(now.valueOf());
+        else
+          date = new RealDate();
+        break;
+      case 1:
+        date = new RealDate(y);
+        break;
+      default:
+        d = typeof d === "undefined" ? 1 : d;
+        h = h || 0;
+        M = M || 0;
+        s = s || 0;
+        ms = ms || 0;
+        date = new RealDate(y, m, d, h, M, s, ms);
+        break;
+    }
+    return date;
+  }
+}
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
+  return new MockDate().valueOf();
+};
+MockDate.parse = function(dateString) {
+  return RealDate.parse(dateString);
+};
+MockDate.toString = function() {
+  return RealDate.toString();
+};
+function mockDate(date) {
+  const dateObj = new RealDate(date.valueOf());
+  if (Number.isNaN(dateObj.getTime()))
+    throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+  globalThis.Date = MockDate;
+  now = dateObj.valueOf();
+}
+function resetDate() {
+  globalThis.Date = RealDate;
+}
+
+export { RealDate as R, mockDate as m, resetDate as r };