vitest 0.25.7 → 0.26.0

package/dist/{types-c441ef31.d.ts → types-56bcd6c3.d.ts}

@@ -1,5 +1,8 @@
-import { ViteDevServer, TransformResult as TransformResult$1, UserConfig as UserConfig$1, CommonServerOptions, AliasOptions } from 'vite';
+import { UserConfig as UserConfig$1, ViteDevServer, CommonServerOptions, AliasOptions } from 'vite';
 import { Task as Task$1, TaskResult as TaskResult$1, Bench, Options } from 'tinybench';
+import { ViteNodeRunner } from 'vite-node/client';
+import { ViteNodeServer } from 'vite-node/server';
+import { RawSourceMap, ViteNodeResolveId, FetchFunction, ModuleCacheMap } from 'vite-node';
 import { Stats } from 'fs';
 import { MessagePort } from 'worker_threads';
 
@@ -156,276 +159,6 @@ interface FakeTimerInstallOpts {
     shouldClearNativeTimers?: boolean | undefined;
 }
 
-interface UpdatePayload {
-  type: 'update'
-  updates: Update[]
-}
-
-interface Update {
-  type: 'js-update' | 'css-update'
-  path: string
-  acceptedPath: string
-  timestamp: number
-  /**
-   * @experimental internal
-   */
-  explicitImportRequired?: boolean | undefined
-}
-
-interface PrunePayload {
-  type: 'prune'
-  paths: string[]
-}
-
-interface FullReloadPayload {
-  type: 'full-reload'
-  path?: string
-}
-
-interface ErrorPayload {
-  type: 'error'
-  err: {
-    [name: string]: any
-    message: string
-    stack: string
-    id?: string
-    frame?: string
-    plugin?: string
-    pluginCode?: string
-    loc?: {
-      file?: string
-      line: number
-      column: number
-    }
-  }
-}
-
-interface CustomEventMap {
-  'vite:beforeUpdate': UpdatePayload
-  'vite:afterUpdate': UpdatePayload
-  'vite:beforePrune': PrunePayload
-  'vite:beforeFullReload': FullReloadPayload
-  'vite:error': ErrorPayload
-  'vite:invalidate': InvalidatePayload
-}
-
-interface InvalidatePayload {
-  path: string
-  message: string | undefined
-}
-
-type InferCustomEventPayload<T extends string> =
-  T extends keyof CustomEventMap ? CustomEventMap[T] : any
-
-type ModuleNamespace = Record<string, any> & {
-  [Symbol.toStringTag]: 'Module'
-}
-
-interface ViteHotContext {
-  readonly data: any
-
-  accept(): void
-  accept(cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(dep: string, cb: (mod: ModuleNamespace | undefined) => void): void
-  accept(
-    deps: readonly string[],
-    cb: (mods: Array<ModuleNamespace | undefined>) => void,
-  ): void
-
-  acceptExports(
-    exportNames: string | readonly string[],
-    cb?: (mod: ModuleNamespace | undefined) => void,
-  ): void
-
-  dispose(cb: (data: any) => void): void
-  prune(cb: (data: any) => void): void
-  invalidate(message?: string): void
-
-  on<T extends string>(
-    event: T,
-    cb: (payload: InferCustomEventPayload<T>) => void,
-  ): void
-  send<T extends string>(event: T, data?: InferCustomEventPayload<T>): void
-}
-declare class ModuleCacheMap extends Map<string, ModuleCache$1> {
-    normalizePath(fsPath: string): string;
-    /**
-     * 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>;
-    /**
-     * Return parsed source map based on inlined source map of the module
-     */
-    getSourceMap(id: string): RawSourceMap | null;
-}
-declare class ViteNodeRunner {
-    options: ViteNodeRunnerOptions;
-    root: string;
-    debug: boolean;
-    /**
-     * Holds the cache of modules
-     * Keys of the map are filepaths, or plain package names
-     */
-    moduleCache: ModuleCacheMap;
-    constructor(options: ViteNodeRunnerOptions);
-    executeFile(file: string): Promise<any>;
-    executeId(id: string): Promise<any>;
-    getSourceMap(id: string): RawSourceMap | null;
-    /** @internal */
-    cachedRequest(rawId: string, callstack: string[]): Promise<any>;
-    /** @internal */
-    directRequest(id: string, fsPath: string, _callstack: string[]): Promise<any>;
-    prepareContext(context: Record<string, any>): Record<string, any>;
-    shouldResolveId(dep: string): boolean;
-    /**
-     * Define if a module should be interop-ed
-     * This function mostly for the ability to override by subclass
-     */
-    shouldInterop(path: string, mod: any): boolean;
-    /**
-     * Import a module and interop it
-     */
-    interopedImport(path: string): Promise<any>;
-    hasNestedDefault(target: any): any;
-}
-interface DepsHandlingOptions {
-    external?: (string | RegExp)[];
-    inline?: (string | RegExp)[] | true;
-    /**
-     * Try to guess the CJS version of a package when it's invalid ESM
-     * @default false
-     */
-    fallbackCJS?: boolean;
-}
-interface StartOfSourceMap {
-    file?: string;
-    sourceRoot?: string;
-}
-interface RawSourceMap extends StartOfSourceMap {
-    version: string;
-    sources: string[];
-    names: string[];
-    sourcesContent?: string[];
-    mappings: string;
-}
-interface FetchResult {
-    code?: string;
-    externalize?: string;
-    map?: RawSourceMap;
-}
-declare type HotContext = Omit<ViteHotContext, 'acceptDeps' | 'decline'>;
-declare type FetchFunction = (id: string) => Promise<FetchResult>;
-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;
-    evaluated?: boolean;
-    code?: string;
-    map?: RawSourceMap;
-    /**
-     * Module ids that imports this module
-     */
-    importers?: Set<string>;
-}
-interface ViteNodeRunnerOptions {
-    root: string;
-    fetchModule: FetchFunction;
-    resolveId?: ResolveIdFunction$1;
-    createHotContext?: CreateHotContextFunction;
-    base?: string;
-    moduleCache?: ModuleCacheMap;
-    interopDefault?: boolean;
-    requestStubs?: Record<string, any>;
-    debug?: boolean;
-}
-interface ViteNodeResolveId {
-    external?: boolean | 'absolute' | 'relative';
-    id: string;
-    meta?: Record<string, any> | null;
-    moduleSideEffects?: boolean | 'no-treeshake' | null;
-    syntheticNamedExports?: boolean | string | null;
-}
-interface ViteNodeServerOptions {
-    /**
-     * Inject inline sourcemap to modules
-     * @default 'inline'
-     */
-    sourcemap?: 'inline' | boolean;
-    /**
-     * Deps handling
-     */
-    deps?: DepsHandlingOptions;
-    /**
-     * Transform method for modules
-     */
-    transformMode?: {
-        ssr?: RegExp[];
-        web?: RegExp[];
-    };
-    debug?: DebuggerOptions;
-}
-interface DebuggerOptions {
-    /**
-     * Dump the transformed module to filesystem
-     * Passing a string will dump to the specified path
-     */
-    dumpModules?: boolean | string;
-    /**
-     * Read dumpped module from filesystem whenever exists.
-     * Useful for debugging by modifying the dump result from the filesystem.
-     */
-    loadDumppedModules?: boolean;
-}
-
-declare class Debugger {
-    options: DebuggerOptions;
-    dumpDir: string | undefined;
-    initPromise: Promise<void> | undefined;
-    externalizeMap: Map<string, string>;
-    constructor(root: string, options: DebuggerOptions);
-    clearDump(): Promise<void>;
-    encodeId(id: string): string;
-    recordExternalize(id: string, path: string): Promise<void>;
-    dumpFile(id: string, result: TransformResult$1 | null): Promise<void>;
-    loadDump(id: string): Promise<TransformResult$1 | null>;
-    writeInfo(): Promise<void>;
-}
-
-declare class ViteNodeServer {
-    server: ViteDevServer;
-    options: ViteNodeServerOptions;
-    private fetchPromiseMap;
-    private transformPromiseMap;
-    fetchCache: Map<string, {
-        duration?: number | undefined;
-        timestamp: number;
-        result: FetchResult;
-    }>;
-    externalizeCache: Map<string, Promise<string | false>>;
-    debugger?: Debugger;
-    constructor(server: ViteDevServer, options?: ViteNodeServerOptions);
-    shouldExternalize(id: string): Promise<string | false>;
-    resolveId(id: string, importer?: string): Promise<ViteNodeResolveId | null>;
-    getSourceMap(source: string): RawSourceMap | null;
-    fetchModule(id: string): Promise<FetchResult>;
-    transformRequest(id: string): Promise<TransformResult$1 | null | undefined>;
-    getTransformMode(id: string): "web" | "ssr";
-    private _fetchModule;
-    private _transformRequest;
-}
-
 declare class SnapshotManager {
     options: SnapshotStateOptions;
     summary: SnapshotSummary;
@@ -470,7 +203,7 @@ interface ErrorsCache {
     files: File[];
     sourceErrors: TypeCheckError[];
 }
-declare type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
+type Callback<Args extends Array<any> = []> = (...args: Args) => Awaitable<void>;
 declare class Typechecker {
     protected ctx: Vitest;
     protected files: string[];
@@ -503,7 +236,7 @@ declare class Typechecker {
     getTestFiles(): File[];
 }
 
-declare type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
+type RunWithFiles = (files: string[], invalidates?: string[]) => Promise<void>;
 interface WorkerPool {
     runTests: RunWithFiles;
     close: () => Promise<void>;
@@ -596,7 +329,7 @@ interface CliOptions extends UserConfig {
  */
 declare function startVitest(mode: VitestRunMode, cliFilters: string[], options: CliOptions, viteOverrides?: UserConfig$1): Promise<Vitest | undefined>;
 
-declare type FileStatsCache = Pick<Stats, 'size'>;
+type FileStatsCache = Pick<Stats, 'size'>;
 declare class FilesStatsCache {
     cache: Map<string, FileStatsCache>;
     getStats(fsPath: string): FileStatsCache | undefined;
@@ -676,7 +409,7 @@ declare class Vitest {
     onAfterSetServer(fn: OnServerRestartHandler): void;
 }
 
-declare type MockMap = Map<string, Record<string, string | null | (() => unknown)>>;
+type MockMap = Map<string, Record<string, string | null | (() => unknown)>>;
 
 interface TestSequencer {
     /**
@@ -852,7 +585,7 @@ declare const BenchmarkReportsMap: {
     verbose: typeof VerboseReporter;
     json: typeof JsonReporter;
 };
-declare type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
+type BenchmarkBuiltinReporters = keyof typeof BenchmarkReportsMap;
 
 declare const ReportersMap: {
     default: typeof DefaultReporter;
@@ -863,7 +596,7 @@ declare const ReportersMap: {
     'tap-flat': typeof TapFlatReporter;
     junit: typeof JUnitReporter;
 };
-declare type BuiltinReporters = keyof typeof ReportersMap;
+type BuiltinReporters = keyof typeof ReportersMap;
 
 interface RollupError extends RollupLogProps {
 	parserError?: Error;
@@ -1070,17 +803,17 @@ interface AcornNode {
 	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$1<T> = T extends (...args: infer U) => any ? U : never;
-declare type MergeInsertions<T> = T extends object ? {
+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 MergeInsertions<T> = T extends object ? {
     [K in keyof T]: MergeInsertions<T[K]>;
 } : T;
-declare type DeepMerge<F, S> = MergeInsertions<{
+type DeepMerge<F, S> = MergeInsertions<{
     [K in keyof F | keyof S]: K extends keyof S & keyof F ? DeepMerge<F[K], S[K]> : K extends keyof S ? S[K] : K extends keyof F ? F[K] : never;
 }>;
-declare type MutableArray<T extends readonly any[]> = {
+type MutableArray<T extends readonly any[]> = {
     -readonly [k in keyof T]: T[k];
 };
 interface Constructable {
@@ -1135,7 +868,7 @@ interface ModuleGraphData {
     externalized: string[];
     inlined: string[];
 }
-declare type OnServerRestartHandler = (reason?: string) => Promise<void> | void;
+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;
@@ -1150,7 +883,7 @@ declare type BirpcReturn<RemoteFunctions> = {
     [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]>;
 };
 
-declare type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
+type ChainableFunction<T extends string, Args extends any[], R = any, E = {}> = {
     (...args: Args): R;
 } & {
     [x in T]: ChainableFunction<T, Args, R, E>;
@@ -1198,8 +931,8 @@ interface BenchmarkResult extends TaskResult$1 {
     name: string;
     rank: number;
 }
-declare type BenchFunction = (this: Bench) => Promise<void> | void;
-declare type BenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', [
+type BenchFunction = (this: Bench) => Promise<void> | void;
+type BenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', [
     name: string,
     fn?: BenchFunction,
     options?: Options
@@ -1208,8 +941,8 @@ declare type BenchmarkAPI = ChainableFunction<'skip' | 'only' | 'todo', [
     runIf(condition: any): BenchmarkAPI;
 };
 
-declare type RunMode = 'run' | 'skip' | 'only' | 'todo';
-declare type TaskState = RunMode | 'pass' | 'fail';
+type RunMode = 'run' | 'skip' | 'only' | 'todo';
+type TaskState = RunMode | 'pass' | 'fail';
 interface TaskBase {
     id: string;
     name: string;
@@ -1233,7 +966,7 @@ interface TaskResult {
     benchmark?: BenchmarkResult;
     retryCount?: number;
 }
-declare type TaskResultPack = [id: string, result: TaskResult | undefined];
+type TaskResultPack = [id: string, result: TaskResult | undefined];
 interface Suite extends TaskBase {
     type: 'suite';
     tasks: Task[];
@@ -1256,10 +989,10 @@ interface Test<ExtraContext = {}> extends TaskBase {
 interface TypeCheck extends TaskBase {
     type: 'typecheck';
 }
-declare type Task = Test | Suite | File | Benchmark | TypeCheck;
-declare type DoneCallback = (error?: any) => void;
-declare type TestFunction<ExtraContext = {}> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
-declare type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
+type Task = Test | Suite | File | Benchmark | TypeCheck;
+type DoneCallback = (error?: any) => void;
+type TestFunction<ExtraContext = {}> = (context: TestContext & ExtraContext) => Awaitable<any> | void;
+type ExtractEachCallbackArgs<T extends ReadonlyArray<any>> = {
     1: [T[0]];
     2: [T[0], T[1]];
     3: [T[0], T[1], T[2]];
@@ -1283,7 +1016,7 @@ interface TestEachFunction {
     <T>(cases: ReadonlyArray<T>): (name: string, fn: (...args: T[]) => Awaitable<void>, options?: number | TestOptions) => void;
     (...args: [TemplateStringsArray, ...any]): (name: string, fn: (...args: any[]) => Awaitable<void>, options?: number | TestOptions) => void;
 }
-declare type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
+type ChainableTestAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'fails', [
     name: string,
     fn?: TestFunction<ExtraContext>,
     options?: number | TestOptions
@@ -1304,12 +1037,12 @@ interface TestOptions {
      */
     retry?: number;
 }
-declare type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
+type TestAPI<ExtraContext = {}> = ChainableTestAPI<ExtraContext> & {
     each: TestEachFunction;
     skipIf(condition: any): ChainableTestAPI<ExtraContext>;
     runIf(condition: any): ChainableTestAPI<ExtraContext>;
 };
-declare type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
+type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurrent' | 'only' | 'skip' | 'todo' | 'shuffle', [
     name: string,
     factory?: SuiteFactory<ExtraContext>,
     options?: number | TestOptions
@@ -1317,13 +1050,13 @@ declare type ChainableSuiteAPI<ExtraContext = {}> = ChainableFunction<'concurren
     each: TestEachFunction;
     <T extends ExtraContext>(name: string, factory?: SuiteFactory<T>): SuiteCollector<T>;
 }>;
-declare type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
+type SuiteAPI<ExtraContext = {}> = ChainableSuiteAPI<ExtraContext> & {
     each: SuiteEachFunction;
     skipIf(condition: any): ChainableSuiteAPI<ExtraContext>;
     runIf(condition: any): ChainableSuiteAPI<ExtraContext>;
 };
-declare type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
-declare type HookCleanupCallback = (() => Awaitable<unknown>) | void;
+type HookListener<T extends any[], Return = void> = (...args: T) => Awaitable<Return>;
+type HookCleanupCallback = (() => Awaitable<unknown>) | void;
 interface SuiteHooks<ExtraContext = {}> {
     beforeAll: HookListener<[Suite | File], HookCleanupCallback>[];
     afterAll: HookListener<[Suite | File]>[];
@@ -1341,7 +1074,7 @@ interface SuiteCollector<ExtraContext = {}> {
     clear: () => void;
     on: <T extends keyof SuiteHooks<ExtraContext>>(name: T, ...fn: SuiteHooks<ExtraContext>[T]) => void;
 }
-declare type SuiteFactory<ExtraContext = {}> = (test: (name: string, fn: TestFunction<ExtraContext>) => void) => Awaitable<void>;
+type SuiteFactory<ExtraContext = {}> = (test: (name: string, fn: TestFunction<ExtraContext>) => void) => Awaitable<void>;
 interface RuntimeContext {
     tasks: (SuiteCollector | Test)[];
     currentSuite: SuiteCollector | null;
@@ -1360,10 +1093,10 @@ interface TestContext {
      */
     onTestFailed: (fn: OnTestFailedHandler) => void;
 }
-declare type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
+type OnTestFailedHandler = (result: TaskResult) => Awaitable<void>;
 
-declare type SnapshotData = Record<string, string>;
-declare type SnapshotUpdateState = 'all' | 'new' | 'none';
+type SnapshotData = Record<string, string>;
+type SnapshotUpdateState = 'all' | 'new' | 'none';
 interface SnapshotStateOptions {
     updateSnapshot: SnapshotUpdateState;
     expand?: boolean;
@@ -1416,7 +1149,7 @@ interface WorkerContext {
     files: string[];
     invalidates?: string[];
 }
-declare type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
+type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 interface AfterSuiteRunMeta {
     coverage?: unknown;
 }
@@ -1466,15 +1199,15 @@ interface CoverageProviderModule {
      */
     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 & {
+type CoverageReporter = 'clover' | 'cobertura' | 'html-spa' | 'html' | 'json-summary' | 'json' | 'lcov' | 'lcovonly' | 'none' | 'teamcity' | 'text-lcov' | 'text-summary' | 'text';
+type CoverageOptions = BaseCoverageOptions & {
     provider?: null | CoverageProviderModule;
 } | CoverageC8Options & {
     provider?: 'c8';
 } | CoverageIstanbulOptions & {
     provider?: 'istanbul';
 };
-declare type ResolvedCoverageOptions = {
+type ResolvedCoverageOptions = {
     tempDirectory: string;
 } & Required<CoverageOptions>;
 interface BaseCoverageOptions {
@@ -1706,11 +1439,11 @@ interface Reporter {
     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 SequenceHooks = 'stack' | 'list' | 'parallel';
-declare type ApiConfig = Pick<CommonServerOptions, 'port' | 'strictPort' | 'host'>;
+type BuiltinEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime';
+type VitestEnvironment = BuiltinEnvironment | (string & Record<never, never>);
+type CSSModuleScopeStrategy = 'stable' | 'scoped' | 'non-scoped';
+type SequenceHooks = 'stack' | 'list' | 'parallel';
+type ApiConfig = Pick<CommonServerOptions, 'port' | 'strictPort' | 'host'>;
 
 interface EnvironmentOptions {
     /**
@@ -1719,7 +1452,7 @@ interface EnvironmentOptions {
     jsdom?: JSDOMOptions;
     [x: string]: unknown;
 }
-declare type VitestRunMode = 'test' | 'benchmark' | 'typecheck';
+type VitestRunMode = 'test' | 'benchmark' | 'typecheck';
 interface InlineConfig {
     /**
      * Benchmark options.
@@ -1833,7 +1566,7 @@ interface InlineConfig {
      * Custom reporter for output. Can contain one or more built-in report names, reporter instances,
      * and/or paths to custom reporters
      */
-    reporters?: Arrayable<BuiltinReporters | Reporter | Omit<string, BuiltinReporters>>;
+    reporters?: Arrayable<BuiltinReporters | 'html' | Reporter | Omit<string, BuiltinReporters>>;
     /**
      * diff output length
      */
@@ -1938,6 +1671,16 @@ interface InlineConfig {
      * @default false
      */
     restoreMocks?: boolean;
+    /**
+     * Will restore all global stubs to their original values before each test
+     * @default false
+     */
+    unstubGlobals?: boolean;
+    /**
+     * Will restore all env stubs to their original values before each test
+     * @default false
+     */
+    unstubEnvs?: boolean;
     /**
      * Serve API options.
      *
@@ -2190,13 +1933,13 @@ interface ResolvedConfig extends Omit<Required<UserConfig>, 'config' | 'filters'
     };
     typecheck: TypecheckConfig;
 }
-declare type RuntimeConfig = Pick<UserConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency'> & {
+type RuntimeConfig = Pick<UserConfig, 'allowOnly' | 'testTimeout' | 'hookTimeout' | 'clearMocks' | 'mockReset' | 'restoreMocks' | 'fakeTimers' | 'maxConcurrency'> & {
     sequence?: {
         hooks?: SequenceHooks;
     };
 };
 
-declare type VitestInlineConfig = InlineConfig;
+type VitestInlineConfig = InlineConfig;
 declare module 'vite' {
     interface UserConfig {
         /**
@@ -2206,7 +1949,7 @@ declare module 'vite' {
     }
 }
 
-declare type Formatter = (input: string | number | null | undefined) => string;
+type Formatter = (input: string | number | null | undefined) => string;
 
 interface MatcherHintOptions {
     comment?: string;
@@ -2322,7 +2065,7 @@ declare class SnapshotState {
     pack(): Promise<SnapshotResult>;
 }
 
-declare type Tester = (a: any, b: any) => boolean | undefined;
+type Tester = (a: any, b: any) => boolean | undefined;
 interface MatcherState {
     assertionCalls: number;
     currentTestName?: string;
@@ -2351,14 +2094,14 @@ interface SyncExpectationResult {
     actual?: any;
     expected?: any;
 }
-declare type AsyncExpectationResult = Promise<SyncExpectationResult>;
-declare type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
+type AsyncExpectationResult = Promise<SyncExpectationResult>;
+type ExpectationResult = SyncExpectationResult | AsyncExpectationResult;
 interface RawMatcherFn<T extends MatcherState = MatcherState> {
     (this: T, received: any, expected: any, options?: any): ExpectationResult;
 }
-declare type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
+type MatchersObject<T extends MatcherState = MatcherState> = Record<string, RawMatcherFn<T>>;
 
-declare type Promisify<O> = {
+type Promisify<O> = {
     [K in keyof O]: O[K] extends (...args: infer A) => infer R ? O extends R ? Promisify<O[K]> : (...args: A) => Promise<R> : O[K];
 };
 declare global {
@@ -2457,7 +2200,7 @@ declare global {
     }
 }
 
-declare type RawErrsMap = Map<string, TscErrorInfo[]>;
+type RawErrsMap = Map<string, TscErrorInfo[]>;
 interface TscErrorInfo {
     filePath: string;
     errCode: number;
@@ -2470,17 +2213,17 @@ interface CollectLineNumbers {
     next: number;
     prev?: number;
 }
-declare type CollectLines = {
+type CollectLines = {
     [key in keyof CollectLineNumbers]: string;
 };
 interface RootAndTarget {
     root: string;
     targetAbsPath: string;
 }
-declare type Context = RootAndTarget & {
+type Context = RootAndTarget & {
     rawErrsMap: RawErrsMap;
     openedDirs: Set<string>;
     lastActivePath?: string;
 };
 
-export { WorkerContext as $, ApiConfig as A, BuiltinEnvironment as B, CollectLineNumbers as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, SuiteFactory as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, RuntimeContext as K, TestContext as L, ModuleGraphData as M, Vitest as N, OnTestFailedHandler as O, SnapshotData as P, SnapshotUpdateState as Q, RuntimeConfig as R, SequenceHooks as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, SnapshotStateOptions as W, SnapshotMatchOptions as X, SnapshotResult as Y, UncheckedSnapshot as Z, SnapshotSummary as _, File as a, ResolveIdFunction as a0, AfterSuiteRunMeta as a1, WorkerRPC as a2, WorkerGlobalState as a3, Awaitable as a4, Nullable as a5, Arrayable as a6, ArgumentsType$1 as a7, MergeInsertions as a8, DeepMerge as a9, ViteNodeRunner as aA, TestSequencer as aB, startVitest as aC, TestSequencerConstructor as aD, MutableArray as aa, Constructable as ab, ModuleCache as ac, EnvironmentReturn as ad, Environment as ae, UserConsoleLog as af, Position as ag, ParsedStack as ah, ErrorWithDiff as ai, OnServerRestartHandler as aj, CoverageProvider as ak, CoverageProviderModule as al, CoverageReporter as am, CoverageOptions as an, ResolvedCoverageOptions as ao, BaseCoverageOptions as ap, CoverageIstanbulOptions as aq, CoverageC8Options as ar, BenchmarkUserOptions as as, Benchmark as at, BenchmarkResult as au, BenchFunction as av, BenchmarkAPI as aw, ModuleCacheMap as ax, ViteNodeRunnerOptions as ay, MockMap as az, ResolvedConfig as b, Reporter as c, RawErrsMap as d, TscErrorInfo as e, CollectLines as f, RootAndTarget as g, Context as h, CSSModuleScopeStrategy as i, VitestRunMode as j, TypecheckConfig as k, RunMode as l, TaskState as m, TaskBase as n, TaskResult as o, Suite as p, Test as q, TypeCheck as r, Task as s, TestFunction as t, TestOptions as u, TestAPI as v, SuiteAPI as w, HookCleanupCallback as x, SuiteHooks as y, SuiteCollector as z };
+export { WorkerContext as $, ApiConfig as A, BuiltinEnvironment as B, CollectLineNumbers as C, DoneCallback as D, EnvironmentOptions as E, FakeTimerInstallOpts as F, SuiteFactory as G, HookListener as H, InlineConfig as I, JSDOMOptions as J, RuntimeContext as K, TestContext as L, ModuleGraphData as M, Vitest as N, OnTestFailedHandler as O, SnapshotData as P, SnapshotUpdateState as Q, RuntimeConfig as R, SequenceHooks as S, TaskResultPack as T, UserConfig as U, VitestEnvironment as V, SnapshotStateOptions as W, SnapshotMatchOptions as X, SnapshotResult as Y, UncheckedSnapshot as Z, SnapshotSummary as _, File as a, ResolveIdFunction as a0, AfterSuiteRunMeta as a1, WorkerRPC as a2, WorkerGlobalState as a3, Awaitable as a4, Nullable as a5, Arrayable as a6, ArgumentsType$1 as a7, MergeInsertions as a8, DeepMerge as a9, TestSequencerConstructor as aA, MutableArray as aa, Constructable as ab, ModuleCache as ac, EnvironmentReturn as ad, Environment as ae, UserConsoleLog as af, Position as ag, ParsedStack as ah, ErrorWithDiff as ai, OnServerRestartHandler as aj, CoverageProvider as ak, CoverageProviderModule as al, CoverageReporter as am, CoverageOptions as an, ResolvedCoverageOptions as ao, BaseCoverageOptions as ap, CoverageIstanbulOptions as aq, CoverageC8Options as ar, BenchmarkUserOptions as as, Benchmark as at, BenchmarkResult as au, BenchFunction as av, BenchmarkAPI as aw, MockMap as ax, TestSequencer as ay, startVitest as az, ResolvedConfig as b, Reporter as c, RawErrsMap as d, TscErrorInfo as e, CollectLines as f, RootAndTarget as g, Context as h, CSSModuleScopeStrategy as i, VitestRunMode as j, TypecheckConfig as k, RunMode as l, TaskState as m, TaskBase as n, TaskResult as o, Suite as p, Test as q, TypeCheck as r, Task as s, TestFunction as t, TestOptions as u, TestAPI as v, SuiteAPI as w, HookCleanupCallback as x, SuiteHooks as y, SuiteCollector as z };