vitest 0.22.0 → 0.23.1

package/dist/{global-74489cc9.d.ts → global-ea084c9f.d.ts}

@@ -1,6 +1,7 @@
 import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
-import { MessagePort } from 'worker_threads';
+import { Options, TaskResult as TaskResult$1, Bench } from 'tinybench';
 import { Stats } from 'fs';
+import { MessagePort } from 'worker_threads';
 
 /**
  * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
@@ -238,9 +239,21 @@ interface ViteHotContext {
 }
 declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
     normalizePath(fsPath: string): string;
-    set(fsPath: string, mod: Partial<ModuleCache$1>): this;
-    get(fsPath: string): ModuleCache$1 | undefined;
+    /**
+     * Assign partial data to the map
+     */
+    update(fsPath: string, mod: Partial<ModuleCache$1>): this;
+    set(fsPath: string, mod: ModuleCache$1): this;
+    get(fsPath: string): ModuleCache$1;
     delete(fsPath: string): boolean;
+    /**
+     * Invalidate modules that dependent on the given modules, up to the main entry
+     */
+    invalidateDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
+    /**
+     * Invalidate dependency modules of the given modules, down to the bottom-level dependencies
+     */
+    invalidateSubDepTree(ids: string[] | Set<string>, invalidated?: Set<string>): Set<string>;
 }
 declare class ViteNodeRunner {
     options: ViteNodeRunnerOptions;
@@ -304,6 +317,10 @@ interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
+    /**
+     * Module ids that imports this module
+     */
+    importers?: Set<string>;
 }
 interface ViteNodeRunnerOptions {
     root: string;
@@ -375,6 +392,7 @@ declare class ViteNodeServer {
     private fetchPromiseMap;
     private transformPromiseMap;
     fetchCache: Map<string, {
+        duration?: number | undefined;
         timestamp: number;
         result: FetchResult;
     }>;
@@ -484,7 +502,7 @@ interface CliOptions extends UserConfig {
      */
     run?: boolean;
 }
-declare function startVitest(cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<boolean>;
+declare function startVitest(mode: VitestRunMode, cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<boolean>;
 
 declare type FileStatsCache = Pick<Stats, 'size'>;
 declare class FilesStatsCache {
@@ -509,6 +527,7 @@ declare class VitestCache {
 }
 
 declare class Vitest {
+    readonly mode: VitestRunMode;
     config: ResolvedConfig;
     configOverride: Partial<ResolvedConfig> | undefined;
     server: ViteDevServer;
@@ -527,7 +546,7 @@ declare class Vitest {
     isFirstRun: boolean;
     restartsCount: number;
     runner: ViteNodeRunner;
-    constructor();
+    constructor(mode: VitestRunMode);
     private _onRestartListeners;
     setServer(options: UserConfig, server: ViteDevServer): Promise<void>;
     initCoverageProvider(): Promise<CoverageProvider | null | undefined>;
@@ -538,6 +557,7 @@ declare class Vitest {
     runFiles(paths: string[]): Promise<void>;
     rerunFiles(files?: string[], trigger?: string): Promise<void>;
     changeNamePattern(pattern: string, files?: string[], trigger?: string): Promise<void>;
+    changeFilenamePattern(pattern: string): Promise<void>;
     rerunFailed(): Promise<void>;
     updateSnapshot(files?: string[]): Promise<void>;
     private _rerunTimer;
@@ -554,7 +574,7 @@ declare class Vitest {
     globTestFiles(filters?: string[]): Promise<string[]>;
     isTargetFile(id: string, source?: string): Promise<boolean>;
     isInSourceTestFile(code: string): boolean;
-    onServerRestarted(fn: () => void): void;
+    onServerRestart(fn: OnServerRestartHandler): void;
 }
 
 declare type MockMap = Map<string, Record<string, string | null | (() => unknown)>>;
@@ -592,7 +612,7 @@ declare abstract class BaseReporter implements Reporter {
     onWatcherRerun(files: string[], trigger?: string): Promise<void>;
     onUserConsoleLog(log: UserConsoleLog): void;
     shouldLog(log: UserConsoleLog): boolean;
-    onServerRestart(): void;
+    onServerRestart(reason?: string): void;
     reportSummary(files: File[]): Promise<void>;
     private printTaskErrors;
     registerUnhandledRejection(): void;
@@ -636,7 +656,7 @@ interface Callsite {
     line: number;
     column: number;
 }
-declare class JsonReporter implements Reporter {
+declare class JsonReporter$1 implements Reporter {
     start: number;
     ctx: Vitest;
     onInit(ctx: Vitest): void;
@@ -648,7 +668,7 @@ declare class JsonReporter implements Reporter {
      * @param report
      */
     writeReport(report: string): Promise<void>;
-    protected getFailureLocation(test: Test): Callsite | undefined;
+    protected getFailureLocation(test: Task): Promise<Callsite | undefined>;
 }
 
 declare class VerboseReporter extends DefaultReporter {
@@ -684,11 +704,31 @@ declare class TapFlatReporter extends TapReporter {
     onFinished(files?: File[]): Promise<void>;
 }
 
+declare class JsonReporter implements Reporter {
+    start: number;
+    ctx: Vitest;
+    onInit(ctx: Vitest): void;
+    protected logTasks(files: File[]): Promise<void>;
+    onFinished(files?: File[]): Promise<void>;
+    /**
+     * Writes the report to an output file if specified in the config,
+     * or logs it to the console otherwise.
+     * @param report
+     */
+    writeReport(report: string): Promise<void>;
+}
+
+declare const BenchmarkReportsMap: {
+    default: typeof VerboseReporter;
+    json: typeof JsonReporter;
+};
+declare type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
+
 declare const ReportersMap: {
     default: typeof DefaultReporter;
     verbose: typeof VerboseReporter;
     dot: typeof DotReporter;
-    json: typeof JsonReporter;
+    json: typeof JsonReporter$1;
     tap: typeof TapReporter;
     'tap-flat': typeof TapFlatReporter;
     junit: typeof JUnitReporter;
@@ -964,6 +1004,7 @@ interface ModuleGraphData {
     externalized: string[];
     inlined: string[];
 }
+declare type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
 
 declare type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
 declare type ReturnType$1<T> = T extends (...args: any) => infer R ? R : never;
@@ -982,8 +1023,55 @@ declare type ChainableFunction<T extends string, Args extends any[], R = any, E
     (...args: Args): R;
 } & {
     [x in T]: ChainableFunction<T, Args, R, E>;
+} & {
+    fn: (this: Record<T, boolean | undefined>, ...args: Args) => R;
 } & E;
 
+interface BenchmarkUserOptions {
+    /**
+     * Include globs for benchmark test files
+     *
+     * @default ['**\/*.{bench,benchmark}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']
+     */
+    include?: string[];
+    /**
+     * Exclude globs for benchmark test files
+     * @default ['node_modules', 'dist', '.idea', '.git', '.cache']
+     */
+    exclude?: string[];
+    /**
+     * Include globs for in-source test files
+     *
+     * @default []
+     */
+    includeSource?: string[];
+    /**
+     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+     * and/or paths to custom reporters
+     */
+    reporters?: Arrayable<BenchmarkBuiltinReporters | Reporter>;
+}
+interface Benchmark extends TaskBase {
+    type: 'benchmark';
+    suite: Suite;
+    result?: TaskResult;
+    fails?: boolean;
+    options: Options;
+}
+interface BenchmarkResult extends TaskResult$1 {
+    name: string;
+    rank: number;
+}
+declare type BenchFunction = (this: Bench) => Promise<void> | void;
+declare type BenchmarkAPI = ChainableFunction<'skip', [
+    name: string,
+    fn: BenchFunction,
+    options?: Options
+], void> & {
+    skipIf(condition: any): BenchmarkAPI;
+    runIf(condition: any): BenchmarkAPI;
+};
+
 declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
 declare type TaskState = RunMode | 'pass' | 'fail';
 interface TaskBase {
@@ -995,6 +1083,7 @@ interface TaskBase {
     suite?: Suite;
     file?: File;
     result?: TaskResult;
+    retry?: number;
     logs?: UserConsoleLog[];
 }
 interface TaskResult {
@@ -1005,12 +1094,15 @@ interface TaskResult {
     error?: ErrorWithDiff;
     htmlError?: string;
     hooks?: Partial<Record<keyof SuiteHooks, TaskState>>;
+    benchmark?: BenchmarkResult;
+    retryCount?: number;
 }
 declare type TaskResultPack = [id: string, result: TaskResult | undefined];
 interface Suite extends TaskBase {
     type: 'suite';
     tasks: Task[];
     filepath?: string;
+    benchmark?: Bench;
 }
 interface File extends Suite {
     filepath: string;
@@ -1024,7 +1116,7 @@ interface Test<ExtraContext = {}> extends TaskBase {
     fails?: boolean;
     context: TestContext & ExtraContext;
 }
-declare type Task = Test | Suite | File;
+declare type Task = Test | Suite | File | Benchmark;
 declare type DoneCallback = (error?: any) => void;
 declare type TestFunction<ExtraContext = {}> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
 declare type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
@@ -1046,18 +1138,31 @@ interface SuiteEachFunction {
     <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>) => void;
 }
 interface TestEachFunction {
-    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>, timeout?: number) => void;
-    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>, timeout?: number) => void;
-    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>, timeout?: number) => void;
+    <T extends any[] | [any]>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T) => Awaitable<void>, options?: number | TestOptions) => void;
+    <T extends ReadonlyArray<any>>(cases: ReadonlyArray<T>): (name: string, fn: (...args: ExtractEachCallbackArgs<T>) => Awaitable<void>, options?: number | TestOptions) => void;
+    <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>, options?: number | TestOptions) => void;
 }
 declare type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
     name: string,
     fn?: TestFunction<ExtraContext>,
-    timeout?: number
+    options?: number | TestOptions
 ], void, {
     each: TestEachFunction;
-    <T extends ExtraContext>(name: string, fn?: TestFunction<T>, timeout?: number): void;
+    <T extends ExtraContext>(name: string, fn?: TestFunction<T>, options?: number | TestOptions): void;
 }>;
+interface TestOptions {
+    /**
+     * Test timeout.
+     */
+    timeout?: number;
+    /**
+     * Times to retry the test if fails. Useful for making flaky tests more stable.
+     * When retries is up, the last test error will be thrown.
+     *
+     * @default 1
+     */
+    retry?: number;
+}
 declare type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
     each: TestEachFunction;
     skipIf(condition: any): ChainableTestAPI<ExtraContext>;
@@ -1088,7 +1193,8 @@ interface SuiteCollector<ExtraContext = {}> {
     readonly mode: RunMode;
     type: 'collector';
     test: TestAPI<ExtraContext>;
-    tasks: (Suite | Test | SuiteCollector<ExtraContext>)[];
+    benchmark: BenchmarkAPI;
+    tasks: (Suite | Test | Benchmark | SuiteCollector<ExtraContext>)[];
     collect: (file?: File) => Promise<Suite>;
     clear: () => void;
     on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
@@ -1257,6 +1363,10 @@ interface BaseCoverageOptions {
      * @default 'text'
      */
     reporter?: Arrayable<CoverageReporter>;
+    /**
+     * List of files included in coverage as glob patterns
+     */
+    include?: string[];
     /**
      * List of files excluded from coverage as glob patterns
      */
@@ -1291,6 +1401,10 @@ interface BaseCoverageOptions {
      * Extensions for files to be included in coverage
      */
     extension?: string | string[];
+    /**
+     * Whether to include all files, including the untested ones into report
+     */
+    all?: boolean;
 }
 interface CoverageIstanbulOptions extends BaseCoverageOptions {
     ignoreClassMethods?: string[];
@@ -1314,8 +1428,6 @@ interface CoverageC8Options extends BaseCoverageOptions {
      * @default true
      */
     excludeNodeModules?: boolean;
-    include?: string[];
-    all?: boolean;
     src?: string[];
     100?: boolean;
 }
@@ -1409,11 +1521,13 @@ interface Reporter {
     onTestRemoved?: (trigger?: string) => Awaitable<void>;
     onWatcherStart?: () => Awaitable<void>;
     onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
-    onServerRestart?: () => Awaitable<void>;
+    onServerRestart?: (reason?: string) => Awaitable<void>;
     onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
 }
 
 declare type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
+declare type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
+declare type CSSModuleScopeStrategy = 'stable' | 'scoped' | 'non-scoped';
 declare type ApiConfig = Pick<CommonServerOptions, 'port' | 'strictPort' | 'host'>;
 
 interface EnvironmentOptions {
@@ -1421,8 +1535,16 @@ interface EnvironmentOptions {
      * jsdom options.
      */
     jsdom?: JSDOMOptions;
+    [x: string]: unknown;
 }
+declare type VitestRunMode = 'test' | 'benchmark';
 interface InlineConfig {
+    /**
+     * Benchmark options.
+     *
+     * @default {}
+    */
+    benchmark?: BenchmarkUserOptions;
     /**
      * Include globs for test files
      *
@@ -1498,9 +1620,11 @@ interface InlineConfig {
      *
      * Supports 'node', 'jsdom', 'happy-dom', 'edge-runtime'
      *
+     * If used unsupported string, will try to load the package `vitest-environment-${env}`
+     *
      * @default 'node'
      */
-    environment?: BuiltinEnvironment;
+    environment?: VitestEnvironment;
     /**
      * Environment options.
      */
@@ -1721,11 +1845,14 @@ interface InlineConfig {
      *
      * When excluded, the CSS files will be replaced with empty strings to bypass the subsequent processing.
      *
-     * @default { include: [/\.module\./] }
+     * @default { include: [], modules: { classNameStrategy: false } }
      */
     css?: boolean | {
         include?: RegExp | RegExp[];
         exclude?: RegExp | RegExp[];
+        modules?: {
+            classNameStrategy?: CSSModuleScopeStrategy;
+        };
     };
     /**
      * A number of tests that are allowed to run at the same time marked with `test.concurrent`.
@@ -1810,7 +1937,8 @@ interface UserConfig extends InlineConfig {
      */
     shard?: string;
 }
-interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'shard' | 'cache' | 'sequence'> {
+interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters' | 'coverage' | 'testNamePattern' | 'related' | 'api' | 'reporters' | 'resolveSnapshotPath' | 'benchmark' | 'shard' | 'cache' | 'sequence'> {
+    mode: VitestRunMode;
     base?: string;
     config?: string;
     filters?: string[];
@@ -1821,6 +1949,7 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     reporters: (Reporter | BuiltinReporters)[];
     defines: Record<string, any>;
     api?: ApiConfig;
+    benchmark?: Required<BenchmarkUserOptions>;
     shard?: {
         index: number;
         count: number;
@@ -1974,6 +2103,7 @@ interface MatcherState {
     isExpectingAssertions?: boolean;
     isExpectingAssertionsError?: Error | null;
     isNot: boolean;
+    environment: VitestEnvironment;
     promise: string;
     snapshotState: SnapshotState;
     suppressedErrors: Array<Error>;
@@ -2095,4 +2225,4 @@ declare global {
     }
 }
 
-export { Environment as $, ApiConfig as A, BuiltinEnvironment as B, WorkerRPC as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, WorkerGlobalState as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, Awaitable as K, Arrayable as L, ModuleGraphData as M, Nullable as N, ArgumentsType$1 as O, MergeInsertions as P, DeepMerge as Q, ResolvedConfig as R, Suite as S, TaskResultPack as T, UserConfig as U, Vitest as V, WorkerContext as W, MutableArray as X, Constructable as Y, ModuleCache as Z, EnvironmentReturn as _, File as a, UserConsoleLog as a0, Position as a1, ParsedStack as a2, ErrorWithDiff as a3, CoverageProvider as a4, CoverageProviderModule as a5, CoverageReporter as a6, CoverageOptions as a7, ResolvedCoverageOptions as a8, BaseCoverageOptions as a9, CoverageIstanbulOptions as aa, CoverageC8Options as ab, ModuleCacheMap as ac, ViteNodeRunnerOptions as ad, MockMap as ae, ViteNodeRunner as af, TestSequencer as ag, startVitest as ah, TestSequencerConstructor as ai, Reporter as b, RunMode as c, TaskState as d, TaskBase as e, TaskResult as f, Test as g, Task as h, TestFunction as i, TestAPI as j, SuiteAPI as k, HookCleanupCallback as l, SuiteHooks as m, SuiteCollector as n, SuiteFactory as o, RuntimeContext as p, TestContext as q, SnapshotData as r, SnapshotUpdateState as s, SnapshotStateOptions as t, SnapshotMatchOptions as u, SnapshotResult as v, UncheckedSnapshot as w, SnapshotSummary as x, ResolveIdFunction as y, AfterSuiteRunMeta as z };
+export { MutableArray as $, ApiConfig as A, BuiltinEnvironment as B, CSSModuleScopeStrategy as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, SnapshotSummary as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, ResolveIdFunction as K, AfterSuiteRunMeta as L, ModuleGraphData as M, WorkerRPC as N, WorkerGlobalState as O, Awaitable as P, Nullable as Q, ResolvedConfig as R, Suite as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, WorkerContext as W, Arrayable as X, ArgumentsType$1 as Y, MergeInsertions as Z, DeepMerge as _, File as a, Constructable as a0, ModuleCache as a1, EnvironmentReturn as a2, Environment as a3, UserConsoleLog as a4, Position as a5, ParsedStack as a6, ErrorWithDiff as a7, OnServerRestartHandler as a8, CoverageProvider as a9, CoverageProviderModule as aa, CoverageReporter as ab, CoverageOptions as ac, ResolvedCoverageOptions as ad, BaseCoverageOptions as ae, CoverageIstanbulOptions as af, CoverageC8Options as ag, BenchmarkUserOptions as ah, Benchmark as ai, BenchmarkResult as aj, BenchFunction as ak, BenchmarkAPI as al, ModuleCacheMap as am, ViteNodeRunnerOptions as an, MockMap as ao, ViteNodeRunner as ap, TestSequencer as aq, startVitest as ar, TestSequencerConstructor as as, Reporter as b, VitestRunMode as c, RunMode as d, TaskState as e, TaskBase as f, TaskResult as g, Test as h, Task as i, TestFunction as j, TestOptions as k, TestAPI as l, SuiteAPI as m, HookCleanupCallback as n, SuiteHooks as o, SuiteCollector as p, SuiteFactory as q, RuntimeContext as r, TestContext as s, Vitest as t, SnapshotData as u, SnapshotUpdateState as v, SnapshotStateOptions as w, SnapshotMatchOptions as x, SnapshotResult as y, UncheckedSnapshot as z };

package/dist/{index-9eded9ec.d.ts → index-5f09f4d0.d.ts}

@@ -1,5 +1,5 @@
 import { SpyImpl } from 'tinyspy';
-import { k as SuiteAPI, j as TestAPI, m as SuiteHooks, H as HookListener, q as TestContext, S as Suite, l as HookCleanupCallback, g as Test } from './global-74489cc9.js';
+import { m as SuiteAPI, l as TestAPI, al as BenchmarkAPI, o as SuiteHooks, H as HookListener, s as TestContext, S as Suite, n as HookCleanupCallback, h as Test } from './global-ea084c9f.js';
 
 interface MockResultReturn<T> {
     type: 'return';
@@ -102,6 +102,7 @@ declare function fn<TArgs extends any[] = any[], R = any>(implementation: (...ar
 
 declare const suite: SuiteAPI<{}>;
 declare const test: TestAPI<{}>;
+declare const bench: BenchmarkAPI;
 declare const describe: SuiteAPI<{}>;
 declare const it: TestAPI<{}>;
 
@@ -113,4 +114,4 @@ declare const afterEach: <ExtraContext = {}>(fn: HookListener<[TestContext & Ext
 declare function createExpect(test?: Test): Vi.ExpectStatic;
 declare const globalExpect: Vi.ExpectStatic;
 
-export { EnhancedSpy as E, MaybeMockedDeep as M, SpyInstance as S, MaybeMocked as a, MaybePartiallyMocked as b, MaybePartiallyMockedDeep as c, suite as d, describe as e, fn as f, beforeAll as g, afterAll as h, it as i, beforeEach as j, afterEach as k, globalExpect as l, createExpect as m, MockedFunction as n, MockedObject as o, MockInstance as p, Mock as q, MockContext as r, spyOn as s, test as t, Mocked as u, MockedClass as v };
+export { EnhancedSpy as E, MaybeMockedDeep as M, SpyInstance as S, MaybeMocked as a, MaybePartiallyMocked as b, MaybePartiallyMockedDeep as c, suite as d, describe as e, fn as f, bench as g, beforeAll as h, it as i, afterAll as j, beforeEach as k, afterEach as l, globalExpect as m, createExpect as n, MockedFunction as o, MockedObject as p, MockInstance as q, Mock as r, spyOn as s, test as t, MockContext as u, Mocked as v, MockedClass as w };

package/dist/index.d.ts

@@ -1,14 +1,15 @@
-import { s as spyOn, f as fn, M as MaybeMockedDeep, a as MaybeMocked, b as MaybePartiallyMocked, c as MaybePartiallyMockedDeep, E as EnhancedSpy } from './index-9eded9ec.js';
-export { E as EnhancedSpy, q as Mock, r as MockContext, p as MockInstance, u as Mocked, v as MockedClass, n as MockedFunction, o as MockedObject, S as SpyInstance, h as afterAll, k as afterEach, g as beforeAll, j as beforeEach, m as createExpect, e as describe, l as expect, i as it, d as suite, t as test } from './index-9eded9ec.js';
-import { D as DoneCallback, F as FakeTimerInstallOpts, a as File, T as TaskResultPack, R as ResolvedConfig, M as ModuleGraphData, b as Reporter } from './global-74489cc9.js';
-export { z as AfterSuiteRunMeta, A as ApiConfig, O as ArgumentsType, L as Arrayable, K as Awaitable, a9 as BaseCoverageOptions, B as BuiltinEnvironment, Y as Constructable, ab as CoverageC8Options, aa as CoverageIstanbulOptions, a7 as CoverageOptions, a4 as CoverageProvider, a5 as CoverageProviderModule, a6 as CoverageReporter, Q as DeepMerge, D as DoneCallback, $ as Environment, E as EnvironmentOptions, _ as EnvironmentReturn, a3 as ErrorWithDiff, a as File, l as HookCleanupCallback, H as HookListener, I as InlineConfig, J as JSDOMOptions, P as MergeInsertions, Z as ModuleCache, M as ModuleGraphData, X as MutableArray, N as Nullable, a2 as ParsedStack, a1 as Position, b as Reporter, y as ResolveIdFunction, R as ResolvedConfig, a8 as ResolvedCoverageOptions, c as RunMode, p as RuntimeContext, r as SnapshotData, u as SnapshotMatchOptions, v as SnapshotResult, t as SnapshotStateOptions, x as SnapshotSummary, s as SnapshotUpdateState, S as Suite, k as SuiteAPI, n as SuiteCollector, o as SuiteFactory, m as SuiteHooks, h as Task, e as TaskBase, f as TaskResult, T as TaskResultPack, d as TaskState, g as Test, j as TestAPI, q as TestContext, i as TestFunction, w as UncheckedSnapshot, U as UserConfig, a0 as UserConsoleLog, V as Vitest, W as WorkerContext, G as WorkerGlobalState, C as WorkerRPC } from './global-74489cc9.js';
+import { s as spyOn, f as fn, M as MaybeMockedDeep, a as MaybeMocked, b as MaybePartiallyMocked, c as MaybePartiallyMockedDeep, E as EnhancedSpy } from './index-5f09f4d0.js';
+export { E as EnhancedSpy, r as Mock, u as MockContext, q as MockInstance, v as Mocked, w as MockedClass, o as MockedFunction, p as MockedObject, S as SpyInstance, j as afterAll, l as afterEach, h as beforeAll, k as beforeEach, g as bench, n as createExpect, e as describe, m as expect, i as it, d as suite, t as test } from './index-5f09f4d0.js';
+import { D as DoneCallback, F as FakeTimerInstallOpts, a as File, T as TaskResultPack, R as ResolvedConfig, M as ModuleGraphData, b as Reporter } from './global-ea084c9f.js';
+export { L as AfterSuiteRunMeta, A as ApiConfig, Y as ArgumentsType, X as Arrayable, P as Awaitable, ae as BaseCoverageOptions, ak as BenchFunction, ai as Benchmark, al as BenchmarkAPI, aj as BenchmarkResult, ah as BenchmarkUserOptions, B as BuiltinEnvironment, C as CSSModuleScopeStrategy, a0 as Constructable, ag as CoverageC8Options, af as CoverageIstanbulOptions, ac as CoverageOptions, a9 as CoverageProvider, aa as CoverageProviderModule, ab as CoverageReporter, _ as DeepMerge, D as DoneCallback, a3 as Environment, E as EnvironmentOptions, a2 as EnvironmentReturn, a7 as ErrorWithDiff, a as File, n as HookCleanupCallback, H as HookListener, I as InlineConfig, J as JSDOMOptions, Z as MergeInsertions, a1 as ModuleCache, M as ModuleGraphData, $ as MutableArray, Q as Nullable, a8 as OnServerRestartHandler, a6 as ParsedStack, a5 as Position, b as Reporter, K as ResolveIdFunction, R as ResolvedConfig, ad as ResolvedCoverageOptions, d as RunMode, r as RuntimeContext, u as SnapshotData, x as SnapshotMatchOptions, y as SnapshotResult, w as SnapshotStateOptions, G as SnapshotSummary, v as SnapshotUpdateState, S as Suite, m as SuiteAPI, p as SuiteCollector, q as SuiteFactory, o as SuiteHooks, i as Task, f as TaskBase, g as TaskResult, T as TaskResultPack, e as TaskState, h as Test, l as TestAPI, s as TestContext, j as TestFunction, k as TestOptions, z as UncheckedSnapshot, U as UserConfig, a4 as UserConsoleLog, t as Vitest, V as VitestEnvironment, c as VitestRunMode, W as WorkerContext, O as WorkerGlobalState, N as WorkerRPC } from './global-ea084c9f.js';
 import { TransformResult } from 'vite';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
+export { Bench as BenchFactory, Options as BenchOptions, Task as BenchTask, TaskResult as BenchTaskResult } from 'tinybench';
 import 'tinyspy';
-import 'worker_threads';
 import 'fs';
+import 'worker_threads';
 
 /**
  * A simple wrapper for converting callback style to promise

package/dist/index.mjs

@@ -1,19 +1,19 @@
-export { c as createExpect, d as describe, b as expect, i as it, s as suite, t as test } from './chunk-runtime-chain.6e363ba2.mjs';
-export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, h as getRunningMode, f as isFirstRun, j as isWatchMode, e as runOnce, v as vi, g as vitest, w as withCallback } from './chunk-runtime-hooks.4789e99d.mjs';
+export { b as bench, c as createExpect, d as describe, e as expect, i as it, s as suite, t as test } from './chunk-runtime-chain.8bfc559b.mjs';
+export { a as afterAll, d as afterEach, b as beforeAll, c as beforeEach, h as getRunningMode, f as isFirstRun, j as isWatchMode, e as runOnce, v as vi, g as vitest, w as withCallback } from './chunk-runtime-hooks.c6b06bd8.mjs';
 import * as chai from 'chai';
 export { chai };
 export { assert, should } from 'chai';
 import 'util';
-import './chunk-mock-date.debe9954.mjs';
+import './chunk-mock-date.f63a5ff2.mjs';
 import 'path';
-import './vendor-picocolors.807856aa.mjs';
+import './chunk-constants.6196597b.mjs';
 import 'tty';
+import 'url';
 import 'local-pkg';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.29488183.mjs';
-import './chunk-utils-global.fa20c2f6.mjs';
+import './chunk-runtime-rpc.48bd94e3.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'fs';
-import './chunk-utils-source-map.2a082ffd.mjs';
+import './chunk-utils-source-map.a1647f5f.mjs';
 import './spy.mjs';
 import 'tinyspy';

package/dist/loader.mjs

@@ -1,15 +1,14 @@
 import { pathToFileURL } from 'url';
 import { readFile } from 'fs/promises';
-import { i as isNodeBuiltin, d as normalizeModuleId, h as hasCJSSyntax } from './chunk-vite-node-utils.d8e5ff7b.mjs';
-import './chunk-mock-date.debe9954.mjs';
-import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
+import { i as isNodeBuiltin, d as normalizeModuleId, h as hasCJSSyntax } from './chunk-vite-node-utils.8a9b3014.mjs';
+import { g as getWorkerState } from './chunk-mock-date.f63a5ff2.mjs';
+import './chunk-constants.6196597b.mjs';
+import 'tty';
+import 'path';
 import 'module';
 import 'fs';
-import 'path';
 import 'assert';
 import 'util';
-import './vendor-picocolors.807856aa.mjs';
-import 'tty';
 import 'local-pkg';
 
 var ModuleFormat = /* @__PURE__ */ ((ModuleFormat2) => {

package/dist/node.d.ts

@@ -1,10 +1,11 @@
-import { U as UserConfig, V as Vitest, ac as ModuleCacheMap, ad as ViteNodeRunnerOptions, ae as MockMap, af as ViteNodeRunner, ag as TestSequencer } from './global-74489cc9.js';
-export { ag as TestSequencer, ai as TestSequencerConstructor, V as Vitest, ah as startVitest } from './global-74489cc9.js';
+import { c as VitestRunMode, U as UserConfig, t as Vitest, am as ModuleCacheMap, an as ViteNodeRunnerOptions, ao as MockMap, ap as ViteNodeRunner, aq as TestSequencer } from './global-ea084c9f.js';
+export { aq as TestSequencer, as as TestSequencerConstructor, t as Vitest, ar as startVitest } from './global-ea084c9f.js';
 import { UserConfig as UserConfig$1, Plugin } from 'vite';
-import 'worker_threads';
+import 'tinybench';
 import 'fs';
+import 'worker_threads';
 
-declare function createVitest(options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
+declare function createVitest(mode: VitestRunMode, options: UserConfig, viteOverrides?: UserConfig$1): Promise<Vitest>;
 
 declare function VitestPlugin(options?: UserConfig, ctx?: Vitest): Promise<Plugin[]>;
 

package/dist/node.mjs

@@ -1,36 +1,37 @@
-export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.3a38c8af.mjs';
-export { V as VitestRunner } from './chunk-runtime-mocker.c91d29ce.mjs';
-import './chunk-mock-date.debe9954.mjs';
-import 'path';
-import './vendor-picocolors.807856aa.mjs';
+export { B as BaseSequencer, V as VitestPlugin, c as createVitest, s as startVitest } from './chunk-vite-node-externalize.3035bd5b.mjs';
+export { V as VitestRunner } from './chunk-runtime-mocker.d9690273.mjs';
+import './chunk-constants.6196597b.mjs';
 import 'tty';
+import 'url';
+import 'path';
+import './chunk-integrations-coverage.99c020eb.mjs';
 import 'local-pkg';
-import './chunk-integrations-coverage.d205bd87.mjs';
+import './chunk-env-node.ceb43f1c.mjs';
+import 'console';
+import './chunk-mock-date.f63a5ff2.mjs';
 import 'vite';
-import 'url';
 import 'process';
 import 'fs';
-import './chunk-constants.d3f8437b.mjs';
 import 'os';
 import 'util';
 import 'stream';
 import 'events';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-vite-node-client.d1ead698.mjs';
+import './chunk-vite-node-client.998e04d0.mjs';
 import 'module';
 import 'vm';
-import './chunk-vite-node-utils.d8e5ff7b.mjs';
+import './chunk-vite-node-utils.8a9b3014.mjs';
 import 'assert';
 import 'debug';
+import 'perf_hooks';
 import 'worker_threads';
 import 'tinypool';
-import 'perf_hooks';
-import './chunk-utils-source-map.2a082ffd.mjs';
+import './chunk-utils-source-map.a1647f5f.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'crypto';
-import './vendor-index.9d9196cc.mjs';
-import './vendor-index.29636037.mjs';
-import './chunk-magic-string.efe26975.mjs';
+import './vendor-index.13e3bda3.mjs';
+import './vendor-index.731a22f2.mjs';
+import './chunk-magic-string.56b2b543.mjs';
+import 'strip-literal';
 import 'readline';
 import './vendor-index.ae96af6e.mjs';
-import './chunk-utils-global.fa20c2f6.mjs';

package/dist/suite.mjs

@@ -1,16 +1,16 @@
 import 'util';
-import './chunk-mock-date.debe9954.mjs';
-export { e as clearCollectorContext, o as createSuiteHooks, f as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.6e363ba2.mjs';
-import './chunk-utils-global.fa20c2f6.mjs';
+import './chunk-mock-date.f63a5ff2.mjs';
+export { b as bench, f as clearCollectorContext, q as createSuiteHooks, h as defaultSuite, d as describe, g as getCurrentSuite, i as it, s as suite, t as test } from './chunk-runtime-chain.8bfc559b.mjs';
 import 'path';
-import './vendor-picocolors.807856aa.mjs';
+import './chunk-constants.6196597b.mjs';
 import 'tty';
+import 'url';
 import 'local-pkg';
 import 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.29488183.mjs';
+import './chunk-runtime-rpc.48bd94e3.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'fs';
-import './chunk-utils-source-map.2a082ffd.mjs';
+import './chunk-utils-source-map.a1647f5f.mjs';
 import './spy.mjs';
 import 'tinyspy';