vitest 0.21.1 → 0.23.0

package/dist/{global-60f880c6.d.ts → global-ea084c9f.d.ts}

@@ -1,5 +1,7 @@
-import { ViteDevServer, TransformResult, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
+import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
+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.
@@ -237,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;
@@ -297,17 +311,21 @@ interface FetchResult {
 }
 declare type HotContext = Omit<ViteHotContext, 'acceptDeps' | 'decline'>;
 declare type FetchFunction = (id: string) => Promise<FetchResult>;
-declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+declare type ResolveIdFunction$1 = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 declare type CreateHotContextFunction = (runner: ViteNodeRunner, url: string) => HotContext;
 interface ModuleCache$1 {
     promise?: Promise<any>;
     exports?: any;
     code?: string;
+    /**
+     * Module ids that imports this module
+     */
+    importers?: Set<string>;
 }
 interface ViteNodeRunnerOptions {
     root: string;
     fetchModule: FetchFunction;
-    resolveId?: ResolveIdFunction;
+    resolveId?: ResolveIdFunction$1;
     createHotContext?: CreateHotContextFunction;
     base?: string;
     moduleCache?: ModuleCacheMap;
@@ -363,8 +381,8 @@ declare class Debugger {
     clearDump(): Promise<void>;
     encodeId(id: string): string;
     recordExternalize(id: string, path: string): Promise<void>;
-    dumpFile(id: string, result: TransformResult | null): Promise<void>;
-    loadDump(id: string): Promise<TransformResult | null>;
+    dumpFile(id: string, result: TransformResult$1 | null): Promise<void>;
+    loadDump(id: string): Promise<TransformResult$1 | null>;
     writeInfo(): Promise<void>;
 }
 
@@ -374,6 +392,7 @@ declare class ViteNodeServer {
     private fetchPromiseMap;
     private transformPromiseMap;
     fetchCache: Map<string, {
+        duration?: number | undefined;
         timestamp: number;
         result: FetchResult;
     }>;
@@ -383,7 +402,7 @@ declare class ViteNodeServer {
     shouldExternalize(id: string): Promise<string | false>;
     resolveId(id: string, importer?: string): Promise<ViteNodeResolveId | null>;
     fetchModule(id: string): Promise<FetchResult>;
-    transformRequest(id: string): Promise<TransformResult | null | undefined>;
+    transformRequest(id: string): Promise<TransformResult$1 | null | undefined>;
     getTransformMode(id: string): "web" | "ssr";
     private _fetchModule;
     private _transformRequest;
@@ -483,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 {
@@ -508,6 +527,7 @@ declare class VitestCache {
 }
 
 declare class Vitest {
+    readonly mode: VitestRunMode;
     config: ResolvedConfig;
     configOverride: Partial<ResolvedConfig> | undefined;
     server: ViteDevServer;
@@ -515,6 +535,7 @@ declare class Vitest {
     snapshot: SnapshotManager;
     cache: VitestCache;
     reporters: Reporter[];
+    coverageProvider: CoverageProvider | null | undefined;
     logger: Logger;
     pool: WorkerPool | undefined;
     vitenode: ViteNodeServer;
@@ -525,9 +546,10 @@ 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>;
     getSerializableConfig(): ResolvedConfig;
     start(filters?: string[]): Promise<void>;
     private getTestDependencies;
@@ -535,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;
@@ -547,13 +570,15 @@ declare class Vitest {
     private handleFileChanged;
     close(): Promise<void>;
     exit(force?: boolean): Promise<void>;
-    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType<Reporter[T]>): Promise<void>;
+    report<T extends keyof Reporter>(name: T, ...args: ArgumentsType$1<Reporter[T]>): Promise<void>;
     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)>>;
+
 interface TestSequencer {
     /**
      * Slicing tests into shards. Will be run before `sort`.
@@ -587,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;
@@ -631,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;
@@ -643,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 {
@@ -679,21 +704,246 @@ 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;
 };
 declare type BuiltinReporters = keyof typeof ReportersMap;
 
+interface RollupError extends RollupLogProps {
+	parserError?: Error;
+	stack?: string;
+	watchFiles?: string[];
+}
+
+interface RollupWarning extends RollupLogProps {
+	chunkName?: string;
+	cycle?: string[];
+	exportName?: string;
+	exporter?: string;
+	guess?: string;
+	importer?: string;
+	missing?: string;
+	modules?: string[];
+	names?: string[];
+	reexporter?: string;
+	source?: string;
+	sources?: string[];
+}
+
+interface RollupLogProps {
+	code?: string;
+	frame?: string;
+	hook?: string;
+	id?: string;
+	loc?: {
+		column: number;
+		file?: string;
+		line: number;
+	};
+	message: string;
+	name?: string;
+	plugin?: string;
+	pluginCode?: string;
+	pos?: number;
+	url?: string;
+}
+
+interface ExistingRawSourceMap {
+	file?: string;
+	mappings: string;
+	names: string[];
+	sourceRoot?: string;
+	sources: string[];
+	sourcesContent?: string[];
+	version: number;
+}
+
+interface SourceMap {
+	file: string;
+	mappings: string;
+	names: string[];
+	sources: string[];
+	sourcesContent: string[];
+	version: number;
+	toString(): string;
+	toUrl(): string;
+}
+
+type SourceMapInput = ExistingRawSourceMap | string | null | { mappings: '' };
+
+type PartialNull<T> = {
+	[P in keyof T]: T[P] | null;
+};
+
+interface ModuleOptions {
+	meta: CustomPluginOptions;
+	moduleSideEffects: boolean | 'no-treeshake';
+	syntheticNamedExports: boolean | string;
+}
+
+interface SourceDescription extends Partial<PartialNull<ModuleOptions>> {
+	ast?: AcornNode;
+	code: string;
+	map?: SourceMapInput;
+}
+
+interface PluginCache {
+	delete(id: string): boolean;
+	get<T = any>(id: string): T;
+	has(id: string): boolean;
+	set<T = any>(id: string, value: T): void;
+}
+
+interface MinimalPluginContext {
+	meta: PluginContextMeta;
+}
+
+interface EmittedAsset {
+	fileName?: string;
+	name?: string;
+	source?: string | Uint8Array;
+	type: 'asset';
+}
+
+interface EmittedChunk {
+	fileName?: string;
+	id: string;
+	implicitlyLoadedAfterOneOf?: string[];
+	importer?: string;
+	name?: string;
+	preserveSignature?: PreserveEntrySignaturesOption;
+	type: 'chunk';
+}
+
+type EmittedFile = EmittedAsset | EmittedChunk;
+
+type EmitAsset = (name: string, source?: string | Uint8Array) => string;
+
+type EmitChunk = (id: string, options?: { name?: string }) => string;
+
+type EmitFile = (emittedFile: EmittedFile) => string;
+
+interface ModuleInfo extends ModuleOptions {
+	ast: AcornNode | null;
+	code: string | null;
+	dynamicImporters: readonly string[];
+	dynamicallyImportedIdResolutions: readonly ResolvedId[];
+	dynamicallyImportedIds: readonly string[];
+	hasDefaultExport: boolean | null;
+	/** @deprecated Use `moduleSideEffects` instead */
+	hasModuleSideEffects: boolean | 'no-treeshake';
+	id: string;
+	implicitlyLoadedAfterOneOf: readonly string[];
+	implicitlyLoadedBefore: readonly string[];
+	importedIdResolutions: readonly ResolvedId[];
+	importedIds: readonly string[];
+	importers: readonly string[];
+	isEntry: boolean;
+	isExternal: boolean;
+	isIncluded: boolean | null;
+}
+
+type GetModuleInfo = (moduleId: string) => ModuleInfo | null;
+
+interface CustomPluginOptions {
+	[plugin: string]: any;
+}
+
+interface PluginContext extends MinimalPluginContext {
+	addWatchFile: (id: string) => void;
+	cache: PluginCache;
+	/** @deprecated Use `this.emitFile` instead */
+	emitAsset: EmitAsset;
+	/** @deprecated Use `this.emitFile` instead */
+	emitChunk: EmitChunk;
+	emitFile: EmitFile;
+	error: (err: RollupError | string, pos?: number | { column: number; line: number }) => never;
+	/** @deprecated Use `this.getFileName` instead */
+	getAssetFileName: (assetReferenceId: string) => string;
+	/** @deprecated Use `this.getFileName` instead */
+	getChunkFileName: (chunkReferenceId: string) => string;
+	getFileName: (fileReferenceId: string) => string;
+	getModuleIds: () => IterableIterator<string>;
+	getModuleInfo: GetModuleInfo;
+	getWatchFiles: () => string[];
+	/** @deprecated Use `this.resolve` instead */
+	isExternal: IsExternal;
+	load: (
+		options: { id: string; resolveDependencies?: boolean } & Partial<PartialNull<ModuleOptions>>
+	) => Promise<ModuleInfo>;
+	/** @deprecated Use `this.getModuleIds` instead */
+	moduleIds: IterableIterator<string>;
+	parse: (input: string, options?: any) => AcornNode;
+	resolve: (
+		source: string,
+		importer?: string,
+		options?: { custom?: CustomPluginOptions; isEntry?: boolean; skipSelf?: boolean }
+	) => Promise<ResolvedId | null>;
+	/** @deprecated Use `this.resolve` instead */
+	resolveId: (source: string, importer?: string) => Promise<string | null>;
+	setAssetSource: (assetReferenceId: string, source: string | Uint8Array) => void;
+	warn: (warning: RollupWarning | string, pos?: number | { column: number; line: number }) => void;
+}
+
+interface PluginContextMeta {
+	rollupVersion: string;
+	watchMode: boolean;
+}
+
+interface ResolvedId extends ModuleOptions {
+	external: boolean | 'absolute';
+	id: string;
+}
+
+type IsExternal = (
+	source: string,
+	importer: string | undefined,
+	isResolved: boolean
+) => boolean;
+
+interface TransformPluginContext extends PluginContext {
+	getCombinedSourcemap: () => SourceMap;
+}
+
+type TransformResult = string | null | void | Partial<SourceDescription>;
+type PreserveEntrySignaturesOption = false | 'strict' | 'allow-extension' | 'exports-only';
+
+interface AcornNode {
+	end: number;
+	start: number;
+	type: string;
+}
+
 declare type Awaitable<T> = T | PromiseLike<T>;
 declare type Nullable<T> = T | null | undefined;
 declare type Arrayable<T> = T | Array<T>;
-declare type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+declare type ArgumentsType$1<T> = T extends (...args: infer U) => any ? U : never;
 declare type MergeInsertions<T> = T extends object ? {
     [K in keyof T]: MergeInsertions<T[K]>;
 } : T;
@@ -754,156 +1004,73 @@ interface ModuleGraphData {
     externalized: string[];
     inlined: string[];
 }
+declare type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
 
-declare type CoverageReporter = 'clover' | 'cobertura' | 'html-spa' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'none' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
-interface C8Options {
+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;
+declare type PromisifyFn<T> = ReturnType$1<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType$1<T>>>;
+declare type BirpcFn<T> = PromisifyFn<T> & {
     /**
-     * Enable coverage, pass `--coverage` to enable
-     *
-     * @default false
-     */
-    enabled?: boolean;
-    /**
-     * Directory to write coverage report to
+     * Send event without asking for response
      */
-    reportsDirectory?: string;
-    /**
-     * Clean coverage before running tests
-     *
-     * @default true
-     */
-    clean?: boolean;
-    /**
-     * Clean coverage report on watch rerun
-     *
-     * @default false
-     */
-    cleanOnRerun?: boolean;
+    asEvent(...args: ArgumentsType<T>): void;
+};
+declare type BirpcReturn<RemoteFunctions> = {
+    [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
+};
+
+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 {
     /**
-     * Check thresholds per file
+     * Include globs for benchmark test files
      *
-     * @default false
+     * @default ['**\/*.{bench,benchmark}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}']
      */
-    perFile?: boolean;
+    include?: string[];
     /**
-     * Allow files from outside of your cwd.
-     *
-     * @default false
+     * Exclude globs for benchmark test files
+     * @default ['node_modules', 'dist', '.idea', '.git', '.cache']
      */
-    allowExternal?: any;
+    exclude?: string[];
     /**
-     * Reporters
+     * Include globs for in-source test files
      *
-     * @default 'text'
+     * @default []
      */
-    reporter?: Arrayable<CoverageReporter>;
+    includeSource?: string[];
     /**
-     * Exclude coverage under /node_modules/
-     *
-     * @default true
+     * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
+     * and/or paths to custom reporters
      */
-    excludeNodeModules?: boolean;
-    exclude?: string[];
-    include?: string[];
-    skipFull?: boolean;
-    extension?: string | string[];
-    all?: boolean;
-    src?: string[];
-    100?: boolean;
-    lines?: number;
-    functions?: number;
-    branches?: number;
-    statements?: number;
+    reporters?: Arrayable<BenchmarkBuiltinReporters | Reporter>;
 }
-interface ResolvedC8Options extends Required<C8Options> {
-    tempDirectory: string;
+interface Benchmark extends TaskBase {
+    type: 'benchmark';
+    suite: Suite;
+    result?: TaskResult;
+    fails?: boolean;
+    options: Options;
 }
-
-interface JSDOMOptions {
-    /**
-     * The html content for the test.
-     *
-     * @default '<!DOCTYPE html>'
-     */
-    html?: string | Buffer | ArrayBufferLike;
-    /**
-     * referrer just affects the value read from document.referrer.
-     * It defaults to no referrer (which reflects as the empty string).
-     */
-    referrer?: string;
-    /**
-     * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
-     *
-     * @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
-     */
-    userAgent?: string;
-    /**
-     * url sets the value returned by window.location, document.URL, and document.documentURI,
-     * and affects things like resolution of relative URLs within the document
-     * and the same-origin restrictions and referrer used while fetching subresources.
-     *
-     * @default 'http://localhost:3000'.
-     */
-    url?: string;
-    /**
-     * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
-     * Values that are not "text/html" or an XML mime type will throw.
-     *
-     * @default 'text/html'.
-     */
-    contentType?: string;
-    /**
-     * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
-     * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
-     * to 5,000,000 code units per origin, as inspired by the HTML specification.
-     *
-     * @default 5_000_000
-     */
-    storageQuota?: number;
-    /**
-     * Enable console?
-     *
-     * @default false
-     */
-    console?: boolean;
-    /**
-     * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
-     * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
-     *
-     * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
-     * content.
-     *
-     * @default true
-     */
-    pretendToBeVisual?: boolean;
-    /**
-     * `includeNodeLocations` preserves the location info produced by the HTML parser,
-     * allowing you to retrieve it with the nodeLocation() method (described below).
-     *
-     * It defaults to false to give the best performance,
-     * and cannot be used with an XML content type since our XML parser does not support location info.
-     *
-     * @default false
-     */
-    includeNodeLocations?: boolean | undefined;
-    /**
-     * @default 'dangerously'
-     */
-    runScripts?: 'dangerously' | 'outside-only';
-    /**
-     * Enable CookieJar
-     *
-     * @default false
-     */
-    cookieJar?: boolean;
-    resources?: 'usable' | any;
+interface BenchmarkResult extends TaskResult$1 {
+    name: string;
+    rank: number;
 }
-
-declare type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
-    (...args: Args): R;
-} & {
-    [x in T]: ChainableFunction<T, Args, R, E>;
-} & E;
+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';
@@ -916,6 +1083,7 @@ interface TaskBase {
     suite?: Suite;
     file?: File;
     result?: TaskResult;
+    retry?: number;
     logs?: UserConsoleLog[];
 }
 interface TaskResult {
@@ -926,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;
@@ -945,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>> = {
@@ -967,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>;
@@ -1009,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;
@@ -1034,19 +1219,6 @@ interface TestContext {
     expect: Vi.ExpectStatic;
 }
 
-interface Reporter {
-    onInit?(ctx: Vitest): void;
-    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
-    onCollected?: (files?: File[]) => Awaitable<void>;
-    onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
-    onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
-    onTestRemoved?: (trigger?: string) => Awaitable<void>;
-    onWatcherStart?: () => Awaitable<void>;
-    onWatcherRerun?: (files: string[], trigger?: string) => Awaitable<void>;
-    onServerRestart?: () => Awaitable<void>;
-    onUserConsoleLog?: (log: UserConsoleLog) => Awaitable<void>;
-}
-
 declare type SnapshotData = Record<string, string>;
 declare type SnapshotUpdateState = 'all' | 'new' | 'none';
 interface SnapshotStateOptions {
@@ -1094,7 +1266,268 @@ interface SnapshotSummary {
     updated: number;
 }
 
+interface WorkerContext {
+    workerId: number;
+    port: MessagePort;
+    config: ResolvedConfig;
+    files: string[];
+    invalidates?: string[];
+}
+declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+interface AfterSuiteRunMeta {
+    coverage?: unknown;
+}
+interface WorkerRPC {
+    fetch: FetchFunction;
+    resolveId: ResolveIdFunction;
+    getSourceMap: (id: string, force?: boolean) => Promise<RawSourceMap | undefined>;
+    onFinished: (files: File[], errors?: unknown[]) => void;
+    onWorkerExit: (code?: number) => void;
+    onPathsCollected: (paths: string[]) => void;
+    onUserConsoleLog: (log: UserConsoleLog) => void;
+    onUnhandledRejection: (err: unknown) => void;
+    onCollected: (files: File[]) => void;
+    onAfterSuiteRun: (meta: AfterSuiteRunMeta) => void;
+    onTaskUpdate: (pack: TaskResultPack[]) => void;
+    snapshotSaved: (snapshot: SnapshotResult) => void;
+    resolveSnapshotPath: (testPath: string) => string;
+}
+interface WorkerGlobalState {
+    ctx: WorkerContext;
+    config: ResolvedConfig;
+    rpc: BirpcReturn<WorkerRPC>;
+    current?: Test;
+    filepath?: string;
+    moduleCache: ModuleCacheMap;
+    browserHashMap?: Map<string, string>;
+    mockMap: MockMap;
+}
+
+interface CoverageProvider {
+    name: string;
+    initialize(ctx: Vitest): Promise<void> | void;
+    resolveOptions(): ResolvedCoverageOptions;
+    clean(clean?: boolean): void | Promise<void>;
+    onBeforeFilesRun?(): void | Promise<void>;
+    onAfterSuiteRun(meta: AfterSuiteRunMeta): void | Promise<void>;
+    reportCoverage(): void | Promise<void>;
+    onFileTransform?(sourceCode: string, id: string, pluginCtx: TransformPluginContext): TransformResult | Promise<TransformResult>;
+}
+interface CoverageProviderModule {
+    /**
+     * Factory for creating a new coverage provider
+     */
+    getProvider(): CoverageProvider | Promise<CoverageProvider>;
+    /**
+     * Executed on after each run in the worker thread. Possible to return a payload passed to the provider
+     */
+    takeCoverage?(): unknown | Promise<unknown>;
+}
+declare type CoverageReporter = 'clover' | 'cobertura' | 'html-spa' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'none' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
+declare type CoverageOptions = BaseCoverageOptions & {
+    provider?: null | CoverageProviderModule;
+} | CoverageC8Options & {
+    provider?: 'c8';
+} | CoverageIstanbulOptions & {
+    provider?: 'istanbul';
+};
+declare type ResolvedCoverageOptions = {
+    tempDirectory: string;
+} & Required<CoverageOptions>;
+interface BaseCoverageOptions {
+    /**
+     * Enable coverage, pass `--coverage` to enable
+     *
+     * @default false
+     */
+    enabled?: boolean;
+    /**
+     * Clean coverage before running tests
+     *
+     * @default true
+     */
+    clean?: boolean;
+    /**
+     * Clean coverage report on watch rerun
+     *
+     * @default false
+     */
+    cleanOnRerun?: boolean;
+    /**
+     * Directory to write coverage report to
+     */
+    reportsDirectory?: string;
+    /**
+     * Reporters
+     *
+     * @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
+     */
+    exclude?: string[];
+    /**
+     * Do not show files with 100% statement, branch, and function coverage
+     */
+    skipFull?: boolean;
+    /**
+     * Check thresholds per file
+     *
+     * @default false
+     */
+    perFile?: boolean;
+    /**
+     * Threshold for lines
+     */
+    lines?: number;
+    /**
+     * Threshold for functions
+     */
+    functions?: number;
+    /**
+     * Threshold for branches
+     */
+    branches?: number;
+    /**
+     * Threshold for statements
+     */
+    statements?: number;
+    /**
+     * 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[];
+    watermarks?: {
+        statements?: [number, number];
+        functions?: [number, number];
+        branches?: [number, number];
+        lines?: [number, number];
+    };
+}
+interface CoverageC8Options extends BaseCoverageOptions {
+    /**
+     * Allow files from outside of your cwd.
+     *
+     * @default false
+     */
+    allowExternal?: any;
+    /**
+     * Exclude coverage under /node_modules/
+     *
+     * @default true
+     */
+    excludeNodeModules?: boolean;
+    src?: string[];
+    100?: boolean;
+}
+
+interface JSDOMOptions {
+    /**
+     * The html content for the test.
+     *
+     * @default '<!DOCTYPE html>'
+     */
+    html?: string | Buffer | ArrayBufferLike;
+    /**
+     * referrer just affects the value read from document.referrer.
+     * It defaults to no referrer (which reflects as the empty string).
+     */
+    referrer?: string;
+    /**
+     * userAgent affects the value read from navigator.userAgent, as well as the User-Agent header sent while fetching subresources.
+     *
+     * @default `Mozilla/5.0 (${process.platform}) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/${jsdomVersion}`
+     */
+    userAgent?: string;
+    /**
+     * url sets the value returned by window.location, document.URL, and document.documentURI,
+     * and affects things like resolution of relative URLs within the document
+     * and the same-origin restrictions and referrer used while fetching subresources.
+     *
+     * @default 'http://localhost:3000'.
+     */
+    url?: string;
+    /**
+     * contentType affects the value read from document.contentType, and how the document is parsed: as HTML or as XML.
+     * Values that are not "text/html" or an XML mime type will throw.
+     *
+     * @default 'text/html'.
+     */
+    contentType?: string;
+    /**
+     * The maximum size in code units for the separate storage areas used by localStorage and sessionStorage.
+     * Attempts to store data larger than this limit will cause a DOMException to be thrown. By default, it is set
+     * to 5,000,000 code units per origin, as inspired by the HTML specification.
+     *
+     * @default 5_000_000
+     */
+    storageQuota?: number;
+    /**
+     * Enable console?
+     *
+     * @default false
+     */
+    console?: boolean;
+    /**
+     * jsdom does not have the capability to render visual content, and will act like a headless browser by default.
+     * It provides hints to web pages through APIs such as document.hidden that their content is not visible.
+     *
+     * When the `pretendToBeVisual` option is set to `true`, jsdom will pretend that it is rendering and displaying
+     * content.
+     *
+     * @default true
+     */
+    pretendToBeVisual?: boolean;
+    /**
+     * `includeNodeLocations` preserves the location info produced by the HTML parser,
+     * allowing you to retrieve it with the nodeLocation() method (described below).
+     *
+     * It defaults to false to give the best performance,
+     * and cannot be used with an XML content type since our XML parser does not support location info.
+     *
+     * @default false
+     */
+    includeNodeLocations?: boolean | undefined;
+    /**
+     * @default 'dangerously'
+     */
+    runScripts?: 'dangerously' | 'outside-only';
+    /**
+     * Enable CookieJar
+     *
+     * @default false
+     */
+    cookieJar?: boolean;
+    resources?: 'usable' | any;
+}
+
+interface Reporter {
+    onInit?(ctx: Vitest): void;
+    onPathsCollected?: (paths?: string[]) => Awaitable<void>;
+    onCollected?: (files?: File[]) => Awaitable<void>;
+    onFinished?: (files?: File[], errors?: unknown[]) => Awaitable<void>;
+    onTaskUpdate?: (packs: TaskResultPack[]) => Awaitable<void>;
+    onTestRemoved?: (trigger?: string) => Awaitable<void>;
+    onWatcherStart?: () => Awaitable<void>;
+    onWatcherRerun?: (files: string[], trigger?: string) => 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 {
@@ -1102,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
      *
@@ -1179,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.
      */
@@ -1293,7 +1736,7 @@ interface InlineConfig {
     /**
      * Coverage options
      */
-    coverage?: C8Options;
+    coverage?: CoverageOptions;
     /**
      * run test names with the specified pattern
      */
@@ -1380,7 +1823,7 @@ interface InlineConfig {
      */
     allowOnly?: boolean;
     /**
-     * Show heap usage after each test. Usefull for debugging memory leaks.
+     * Show heap usage after each test. Useful for debugging memory leaks.
      */
     logHeapUsage?: boolean;
     /**
@@ -1402,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`.
@@ -1491,17 +1937,19 @@ 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[];
     testNamePattern?: RegExp;
     related?: string[];
-    coverage: ResolvedC8Options;
+    coverage: ResolvedCoverageOptions;
     snapshotOptions: SnapshotStateOptions;
     reporters: (Reporter | BuiltinReporters)[];
     defines: Record<string, any>;
     api?: ApiConfig;
+    benchmark?: Required<BenchmarkUserOptions>;
     shard?: {
         index: number;
         count: number;
@@ -1655,6 +2103,7 @@ interface MatcherState {
     isExpectingAssertions?: boolean;
     isExpectingAssertionsError?: Error | null;
     isNot: boolean;
+    environment: VitestEnvironment;
     promise: string;
     snapshotState: SnapshotState;
     suppressedErrors: Array<Error>;
@@ -1776,4 +2225,4 @@ declare global {
     }
 }
 
-export { CoverageReporter as $, ApiConfig as A, BuiltinEnvironment as B, ArgumentsType as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, MergeInsertions as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, DeepMerge as K, MutableArray as L, ModuleGraphData as M, Nullable as N, Constructable as O, ModuleCache as P, EnvironmentReturn as Q, ResolvedConfig as R, Suite as S, TaskResultPack as T, UserConfig as U, Vitest as V, Environment as W, UserConsoleLog as X, Position as Y, ParsedStack as Z, ErrorWithDiff as _, File as a, C8Options as a0, ResolvedC8Options as a1, ViteNodeResolveId as a2, FetchFunction as a3, RawSourceMap as a4, ModuleCacheMap as a5, ViteNodeRunnerOptions as a6, ViteNodeRunner as a7, TestSequencer as a8, startVitest as a9, TestSequencerConstructor as aa, 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, Awaitable as y, Arrayable 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 };