vitest 3.2.4 → 4.0.0-beta.10

package/dist/chunks/{worker.d.1GmBbd7G.d.ts → worker.d.BDsXGkwh.d.ts}

@@ -1,7 +1,7 @@
-import { File, TestAnnotation, TaskResultPack, TaskEventPack, CancelReason, FileSpecification, Task } from '@vitest/runner';
-import { ViteNodeResolveId, ModuleCacheMap, ModuleExecutionInfo } from 'vite-node';
-import { a as SerializedConfig } from './config.d.D2ROskhv.js';
-import { T as TransformMode, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.cL3nLXbE.js';
+import { CancelReason, File, TestAnnotation, TaskResultPack, TaskEventPack, FileSpecification, Task } from '@vitest/runner';
+import { FetchFunctionOptions, FetchResult, EvaluatedModules } from 'vite/module-runner';
+import { a as SerializedConfig } from './config.d.B_LthbQq.js';
+import { F as FetchCachedFileSystemResult, R as ResolveFunctionResult, U as UserConsoleLog, A as AfterSuiteRunMeta, E as Environment } from './environment.d.BsToaxti.js';
 import { SnapshotResult } from '@vitest/snapshot';
 
 type ArgumentsType<T> = T extends (...args: infer A) => any ? A : never;
@@ -93,30 +93,23 @@ type BirpcReturn<RemoteFunctions, LocalFunctions = Record<string, never>> = {
     $functions: LocalFunctions;
     $close: (error?: Error) => void;
     $closed: boolean;
+    $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
 };
+type PendingCallHandler = (options: Pick<PromiseEntry, 'method' | 'reject'>) => void | Promise<void>;
+interface PromiseEntry {
+    resolve: (arg: any) => void;
+    reject: (error: any) => void;
+    method: string;
+    timeoutId?: ReturnType<typeof setTimeout>;
+}
+declare const setTimeout: typeof globalThis.setTimeout;
 
 interface RuntimeRPC {
-	fetch: (id: string, transformMode: TransformMode) => Promise<{
-		externalize?: string
-		id?: string
-	}>;
-	transform: (id: string, transformMode: TransformMode) => Promise<{
-		code?: string
+	fetch: (id: string, importer: string | undefined, environment: string, options?: FetchFunctionOptions) => Promise<FetchResult | FetchCachedFileSystemResult>;
+	resolve: (id: string, importer: string | undefined, environment: string) => Promise<ResolveFunctionResult | null>;
+	transform: (id: string) => Promise<{
+		code?: string;
 	}>;
-	resolveId: (id: string, importer: string | undefined, transformMode: TransformMode) => Promise<{
-		external?: boolean | "absolute" | "relative"
-		id: string
-		/** @deprecated */
-		meta?: Record<string, any> | null
-		/** @deprecated */
-		moduleSideEffects?: boolean | "no-treeshake" | null
-		/** @deprecated */
-		syntheticNamedExports?: boolean | string | null
-	} | null>;
-	/**
-	* @deprecated unused
-	*/
-	getSourceMap: (id: string, force?: boolean) => Promise<any>;
 	onUserConsoleLog: (log: UserConsoleLog) => void;
 	onUnhandledError: (err: unknown, type: string) => void;
 	onQueued: (file: File) => void;
@@ -133,12 +126,9 @@ interface RunnerRPC {
 	onCancel: (reason: CancelReason) => void;
 }
 
-/** @deprecated unused */
-type ResolveIdFunction = (id: string, importer?: string) => Promise<ViteNodeResolveId | null>;
 type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
 interface ContextTestEnvironment {
 	name: string;
-	transformMode?: TransformMode;
 	options: Record<string, any> | null;
 }
 type TestExecutionMethod = "run" | "collect";
@@ -159,18 +149,27 @@ interface WorkerGlobalState {
 	rpc: WorkerRPC;
 	current?: Task;
 	filepath?: string;
+	metaEnv: {
+		[key: string]: any;
+		BASE_URL: string;
+		MODE: string;
+		DEV: boolean;
+		PROD: boolean;
+		SSR: boolean;
+	};
 	environment: Environment;
 	environmentTeardownRun?: boolean;
 	onCancel: Promise<CancelReason>;
-	moduleCache: ModuleCacheMap;
-	moduleExecutionInfo?: ModuleExecutionInfo;
+	evaluatedModules: EvaluatedModules;
+	resolvingModules: Set<string>;
+	moduleExecutionInfo: Map<string, any>;
 	onCleanup: (listener: () => unknown) => void;
 	providedContext: Record<string, any>;
 	durations: {
-		environment: number
-		prepare: number
+		environment: number;
+		prepare: number;
 	};
 	onFilterStackTrace?: (trace: string) => string;
 }
 
-export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, BirpcReturn as a, WorkerRPC as b, RunnerRPC as c, ContextTestEnvironment as d, ResolveIdFunction as e };
+export type { BirpcOptions as B, ContextRPC as C, RuntimeRPC as R, TestExecutionMethod as T, WorkerGlobalState as W, BirpcReturn as a, RunnerRPC as b, ContextTestEnvironment as c };

package/dist/chunks/{worker.d.CKwWzBSj.d.ts → worker.d.BNcX_2mH.d.ts}

@@ -1,5 +1,5 @@
 import { MessagePort } from 'node:worker_threads';
-import { C as ContextRPC } from './worker.d.1GmBbd7G.js';
+import { C as ContextRPC } from './worker.d.BDsXGkwh.js';
 
 interface WorkerContext extends ContextRPC {
 	port: MessagePort;

package/dist/cli.js

@@ -1,25 +1,25 @@
-import { c as createCLI } from './chunks/cac.Cb-PYCCB.js';
+import { c as createCLI } from './chunks/cac.DCxo_nSu.js';
 import '@vitest/utils';
 import 'events';
 import 'pathe';
 import 'tinyrainbow';
-import './chunks/constants.DnKduX2e.js';
-import './chunks/index.VByaPkjc.js';
+import './chunks/constants.D_Q9UYh-.js';
+import './chunks/index.BIP7prJq.js';
+import 'node:fs';
+import 'node:fs/promises';
+import './chunks/typechecker.DB-fIMaH.js';
+import 'node:os';
 import 'node:perf_hooks';
-import '@vitest/runner/utils';
 import '@vitest/utils/source-map';
-import './chunks/env.D4Lgay0q.js';
-import 'std-env';
-import './chunks/typechecker.DRKU1-1g.js';
-import 'node:os';
 import 'tinyexec';
 import './path.js';
 import 'node:path';
 import 'node:url';
+import '@vitest/runner/utils';
 import 'vite';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
 import 'node:util';
-import 'node:fs';
-import 'node:fs/promises';
 import 'node:console';
 import 'node:stream';
 import 'node:module';

package/dist/config.cjs

@@ -4,55 +4,24 @@ var os = require('node:os');
 var stdEnv = require('std-env');
 var vite = require('vite');
 
-// if changed, update also jsdocs and docs
-const defaultBrowserPort = 63315;
-const extraInlineDeps = [
-	/^(?!.*node_modules).*\.mjs$/,
-	/^(?!.*node_modules).*\.cjs\.js$/,
-	/vite\w*\/dist\/client\/env.mjs/
-];
-
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
 const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
 (isNode || isDeno) && process.platform === "win32";
 (isNode || isDeno) && process.stdout?.isTTY && !stdEnv.isCI;
 
+// if changed, update also jsdocs and docs
+const defaultBrowserPort = 63315;
+
 const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
-const defaultExclude = [
-	"**/node_modules/**",
-	"**/dist/**",
-	"**/cypress/**",
-	"**/.{idea,git,cache,output,temp}/**",
-	"**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*"
-];
-const defaultCoverageExcludes = [
-	"coverage/**",
-	"dist/**",
-	"**/node_modules/**",
-	"**/[.]**",
-	"packages/*/test?(s)/**",
-	"**/*.d.ts",
-	"**/virtual:*",
-	"**/__x00__*",
-	"**/\0*",
-	"cypress/**",
-	"test?(s)/**",
-	"test?(-*).?(c|m)[jt]s?(x)",
-	"**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)",
-	"**/__tests__/**",
-	"**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*",
-	"**/vitest.{workspace,projects}.[jt]s?(on)",
-	"**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}"
-];
+const defaultExclude = ["**/node_modules/**", "**/.git/**"];
 // These are the generic defaults for coverage. Providers may also set some provider specific defaults.
 const coverageConfigDefaults = {
 	provider: "v8",
 	enabled: false,
-	all: true,
 	clean: true,
 	cleanOnRerun: true,
 	reportsDirectory: "./coverage",
-	exclude: defaultCoverageExcludes,
+	exclude: [],
 	reportOnFailure: false,
 	reporter: [
 		["text", {}],
@@ -60,22 +29,8 @@ const coverageConfigDefaults = {
 		["clover", {}],
 		["json", {}]
 	],
-	extension: [
-		".js",
-		".cjs",
-		".mjs",
-		".ts",
-		".mts",
-		".tsx",
-		".jsx",
-		".vue",
-		".svelte",
-		".marko",
-		".astro"
-	],
 	allowExternal: false,
 	excludeAfterRemap: false,
-	ignoreEmptyLines: true,
 	processingConcurrency: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
 };
 const fakeTimersDefaults = {
@@ -126,12 +81,6 @@ function defineConfig(config) {
 function defineProject(config) {
 	return config;
 }
-/**
-* @deprecated use the `projects` field in the root config instead
-*/
-function defineWorkspace(config) {
-	return config;
-}
 
 Object.defineProperty(exports, "mergeConfig", {
   enumerable: true,
@@ -144,5 +93,3 @@ exports.defaultExclude = defaultExclude;
 exports.defaultInclude = defaultInclude;
 exports.defineConfig = defineConfig;
 exports.defineProject = defineProject;
-exports.defineWorkspace = defineWorkspace;
-exports.extraInlineDeps = extraInlineDeps;

package/dist/config.d.ts

@@ -1,100 +1,101 @@
-import { UserConfig as UserConfig$1, ConfigEnv } from 'vite';
+import { HookHandler, ConfigEnv, UserConfig } from 'vite';
 export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
-import { c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport, b as TestProjectConfiguration } from './chunks/reporters.d.BFLkQcL6.js';
-export { f as TestProjectInlineConfiguration, g as WatcherTriggerPattern, W as WorkspaceProjectConfiguration } from './chunks/reporters.d.BFLkQcL6.js';
-import './chunks/vite.d.CMLlLIFP.js';
-import { F as FakeTimerInstallOpts } from './chunks/config.d.D2ROskhv.js';
+import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.BUWjmRYq.js';
+export { a as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.BUWjmRYq.js';
+import { V as VitestPluginContext } from './chunks/plugin.d.BMVSnsGV.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.B_LthbQq.js';
 import '@vitest/runner';
-import './chunks/environment.d.cL3nLXbE.js';
-import 'vitest/optional-types.js';
 import '@vitest/utils';
+import './chunks/environment.d.BsToaxti.js';
 import 'node:stream';
-import 'node:console';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
-import './chunks/worker.d.1GmBbd7G.js';
-import 'vite-node';
+import './chunks/browser.d.yFAklsD1.js';
+import './chunks/worker.d.BDsXGkwh.js';
+import 'vite/module-runner';
 import '@vitest/snapshot';
 import '@vitest/pretty-format';
 import '@vitest/utils/diff';
-import 'chai';
-import './chunks/benchmark.d.BwvBVTda.js';
+import '@vitest/expect';
+import 'vitest/optional-types.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
 import 'tinybench';
-import './chunks/coverage.d.S9RMNXIe.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
-import '@vitest/snapshot/environment';
+import 'node:console';
+
+type VitestInlineConfig = InlineConfig;
+declare module "vite" {
+	interface UserConfig {
+		/**
+		* Options for Vitest
+		*/
+		test?: VitestInlineConfig;
+	}
+	interface Plugin<A = any> {
+		configureVitest?: HookHandler<(context: VitestPluginContext) => void>;
+	}
+}
 
 declare const defaultBrowserPort = 63315;
-declare const extraInlineDeps: RegExp[];
 
 declare const defaultInclude: string[];
 declare const defaultExclude: string[];
-// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
 declare const coverageConfigDefaults: ResolvedCoverageOptions;
 declare const configDefaults: Readonly<{
-	allowOnly: boolean
-	isolate: boolean
-	watch: boolean
-	globals: boolean
-	environment: "node"
-	pool: "forks"
-	clearMocks: boolean
-	restoreMocks: boolean
-	mockReset: boolean
-	unstubGlobals: boolean
-	unstubEnvs: boolean
-	include: string[]
-	exclude: string[]
-	teardownTimeout: number
-	forceRerunTriggers: string[]
-	update: boolean
-	reporters: never[]
-	silent: boolean
-	hideSkippedTests: boolean
-	api: boolean
-	ui: boolean
-	uiBase: string
-	open: boolean
+	allowOnly: boolean;
+	isolate: boolean;
+	watch: boolean;
+	globals: boolean;
+	environment: "node";
+	pool: "forks";
+	clearMocks: boolean;
+	restoreMocks: boolean;
+	mockReset: boolean;
+	unstubGlobals: boolean;
+	unstubEnvs: boolean;
+	include: string[];
+	exclude: string[];
+	teardownTimeout: number;
+	forceRerunTriggers: string[];
+	update: boolean;
+	reporters: never[];
+	silent: boolean;
+	hideSkippedTests: boolean;
+	api: boolean;
+	ui: boolean;
+	uiBase: string;
+	open: boolean;
 	css: {
-		include: never[]
-	}
-	coverage: CoverageV8Options
-	fakeTimers: FakeTimerInstallOpts
-	maxConcurrency: number
-	dangerouslyIgnoreUnhandledErrors: boolean
+		include: never[];
+	};
+	coverage: CoverageV8Options;
+	fakeTimers: FakeTimerInstallOpts;
+	maxConcurrency: number;
+	dangerouslyIgnoreUnhandledErrors: boolean;
 	typecheck: {
-		checker: "tsc"
-		include: string[]
-		exclude: string[]
-	}
-	slowTestThreshold: number
-	disableConsoleIntercept: boolean
+		checker: "tsc";
+		include: string[];
+		exclude: string[];
+	};
+	slowTestThreshold: number;
+	disableConsoleIntercept: boolean;
 }>;
 
-/**
-* @deprecated Use `ViteUserConfig` instead
-*/
-type UserConfig = UserConfig$1;
-
-type UserConfigFnObject = (env: ConfigEnv) => UserConfig$1;
-type UserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig$1>;
-type UserConfigFn = (env: ConfigEnv) => UserConfig$1 | Promise<UserConfig$1>;
-type UserConfigExport = UserConfig$1 | Promise<UserConfig$1> | UserConfigFnObject | UserConfigFnPromise | UserConfigFn;
-declare function defineConfig(config: UserConfig$1): UserConfig$1;
-declare function defineConfig(config: Promise<UserConfig$1>): Promise<UserConfig$1>;
-declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
-declare function defineConfig(config: UserConfigExport): UserConfigExport;
+type ViteUserConfigFnObject = (env: ConfigEnv) => UserConfig;
+type ViteUserConfigFnPromise = (env: ConfigEnv) => Promise<UserConfig>;
+type ViteUserConfigFn = (env: ConfigEnv) => UserConfig | Promise<UserConfig>;
+type ViteUserConfigExport = UserConfig | Promise<UserConfig> | ViteUserConfigFnObject | ViteUserConfigFnPromise | ViteUserConfigFn;
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+declare function defineConfig(config: ViteUserConfigFnObject): ViteUserConfigFnObject;
+declare function defineConfig(config: ViteUserConfigExport): ViteUserConfigExport;
 declare function defineProject(config: UserWorkspaceConfig): UserWorkspaceConfig;
 declare function defineProject(config: Promise<UserWorkspaceConfig>): Promise<UserWorkspaceConfig>;
 declare function defineProject(config: UserProjectConfigFn): UserProjectConfigFn;
 declare function defineProject(config: UserProjectConfigExport): UserProjectConfigExport;
-/**
-* @deprecated use the `projects` field in the root config instead
-*/
-declare function defineWorkspace(config: TestProjectConfiguration[]): TestProjectConfiguration[];
 
-export { TestProjectConfiguration, UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject, defineWorkspace, extraInlineDeps };
-export type { UserConfig, UserConfigExport, UserConfigFn, UserConfigFnObject, UserConfigFnPromise };
+export { UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject };
+export type { ViteUserConfigExport, ViteUserConfigFn, ViteUserConfigFnObject, ViteUserConfigFnPromise };

package/dist/config.js

@@ -1,6 +1,6 @@
-export { d as defaultBrowserPort, e as extraInlineDeps } from './chunks/constants.DnKduX2e.js';
-export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.B7q_naMc.js';
+export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.CXFFjsi8.js';
 export { mergeConfig } from 'vite';
+export { d as defaultBrowserPort } from './chunks/constants.D_Q9UYh-.js';
 import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
@@ -11,11 +11,5 @@ function defineConfig(config) {
 function defineProject(config) {
 	return config;
 }
-/**
-* @deprecated use the `projects` field in the root config instead
-*/
-function defineWorkspace(config) {
-	return config;
-}
 
-export { defineConfig, defineProject, defineWorkspace };
+export { defineConfig, defineProject };

package/dist/coverage.d.ts

@@ -1,28 +1,27 @@
-import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, a as ReportContext } from './chunks/reporters.d.BFLkQcL6.js';
+import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, b as ReportContext } from './chunks/reporters.d.BUWjmRYq.js';
 import { TransformResult } from 'vite';
-import { A as AfterSuiteRunMeta } from './chunks/environment.d.cL3nLXbE.js';
+import { A as AfterSuiteRunMeta } from './chunks/environment.d.BsToaxti.js';
 import '@vitest/runner';
 import '@vitest/utils';
 import 'node:stream';
-import 'node:console';
 import '@vitest/mocker';
 import '@vitest/utils/source-map';
-import './chunks/worker.d.1GmBbd7G.js';
-import 'vite-node';
-import './chunks/config.d.D2ROskhv.js';
+import './chunks/browser.d.yFAklsD1.js';
+import './chunks/worker.d.BDsXGkwh.js';
+import 'vite/module-runner';
+import './chunks/config.d.B_LthbQq.js';
 import '@vitest/pretty-format';
 import '@vitest/snapshot';
-import '@vitest/snapshot/environment';
 import '@vitest/utils/diff';
-import 'chai';
-import './chunks/benchmark.d.BwvBVTda.js';
+import '@vitest/expect';
+import 'vitest/optional-types.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
 import '@vitest/runner/utils';
 import 'tinybench';
-import './chunks/coverage.d.S9RMNXIe.js';
-import 'vite-node/client';
+import './chunks/coverage.d.BZtK59WP.js';
 import '@vitest/snapshot/manager';
 import 'node:fs';
-import 'vitest/optional-types.js';
+import 'node:console';
 
 type Threshold = "lines" | "functions" | "statements" | "branches";
 interface ResolvedThreshold {
@@ -46,36 +45,44 @@ interface ResolvedThreshold {
 * "project-b": ...
 * ```
 */
-type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["transformMode"], {
-	[TestFilenames: string]: string
+type CoverageFiles = Map<NonNullable<AfterSuiteRunMeta["projectName"]> | symbol, Record<AfterSuiteRunMeta["environment"], {
+	[TestFilenames: string]: string;
 }>>;
 declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"istanbul" | "v8">> {
 	ctx: Vitest;
 	readonly name: "v8" | "istanbul";
 	version: string;
 	options: Options;
+	globCache: Map<string, boolean>;
 	coverageFiles: CoverageFiles;
 	pendingPromises: Promise<void>[];
 	coverageFilesDirectory: string;
+	roots: string[];
 	_initialize(ctx: Vitest): void;
+	/**
+	* Check if file matches `coverage.include` but not `coverage.exclude`
+	*/
+	isIncluded(_filename: string, root?: string): boolean;
+	private getUntestedFilesByRoot;
+	getUntestedFiles(testedFiles: string[]): Promise<string[]>;
 	createCoverageMap(): CoverageMap;
 	generateReports(_: CoverageMap, __: boolean | undefined): Promise<void>;
 	parseConfigModule(_: string): Promise<{
 		generate: () => {
-			code: string
-		}
+			code: string;
+		};
 	}>;
 	resolveOptions(): Options;
 	clean(clean?: boolean): Promise<void>;
-	onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void;
+	onAfterSuiteRun({ coverage, environment, projectName, testFiles }: AfterSuiteRunMeta): void;
 	readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
 		/** Callback invoked with a single coverage result */
-		onFileRead: (data: CoverageType) => void
+		onFileRead: (data: CoverageType) => void;
 		/** Callback invoked once all results of a project for specific transform mode are read */
-		onFinished: (project: Vitest["projects"][number], transformMode: AfterSuiteRunMeta["transformMode"]) => Promise<void>
+		onFinished: (project: Vitest["projects"][number], environment: string) => Promise<void>;
 		onDebug: ((...logs: any[]) => void) & {
-			enabled: boolean
-		}
+			enabled: boolean;
+		};
 	}): Promise<void>;
 	cleanAfterRun(): Promise<void>;
 	onTestFailure(): Promise<void>;
@@ -95,9 +102,9 @@ declare class BaseCoverageProvider<Options extends ResolvedCoverageOptions<"ista
 	* Check if current coverage is above configured thresholds and bump the thresholds if needed
 	*/
 	updateThresholds({ thresholds: allThresholds, onUpdate, configurationFile }: {
-		thresholds: ResolvedThreshold[]
-		configurationFile: unknown
-		onUpdate: () => void
+		thresholds: ResolvedThreshold[];
+		configurationFile: unknown;
+		onUpdate: () => void;
 	}): Promise<void>;
 	mergeReports(coverageMaps: unknown[]): Promise<void>;
 	hasTerminalReporter(reporters: ResolvedCoverageOptions["reporter"]): boolean;

package/dist/coverage.js

@@ -1,16 +1,17 @@
-export { B as BaseCoverageProvider } from './chunks/coverage.DL5VHqXY.js';
+export { B as BaseCoverageProvider } from './chunks/coverage.BCU-r2QL.js';
 import 'node:fs';
+import 'node:path';
+import '@vitest/utils';
 import 'pathe';
 import 'picomatch';
+import 'tinyglobby';
 import 'tinyrainbow';
-import './chunks/defaults.B7q_naMc.js';
+import './chunks/defaults.CXFFjsi8.js';
 import 'node:os';
 import './chunks/env.D4Lgay0q.js';
 import 'std-env';
 import 'node:crypto';
-import '@vitest/utils';
 import 'node:module';
-import 'node:path';
 import 'node:process';
 import 'node:fs/promises';
 import 'node:url';
@@ -18,17 +19,16 @@ import 'node:assert';
 import 'node:v8';
 import 'node:util';
 import 'vite';
-import './chunks/constants.DnKduX2e.js';
+import './chunks/constants.D_Q9UYh-.js';
 import 'node:tty';
 import 'node:events';
-import './chunks/index.B521nVV-.js';
+import './chunks/index.Bgo3tNWt.js';
 import 'tinypool';
-import './chunks/typechecker.DRKU1-1g.js';
+import './chunks/typechecker.DB-fIMaH.js';
 import 'node:perf_hooks';
 import '@vitest/utils/source-map';
 import 'tinyexec';
 import './path.js';
 import '@vitest/runner/utils';
 import 'node:worker_threads';
-import 'vite-node/utils';
-import './chunks/coverage.DVF1vEu8.js';
+import './chunks/coverage.D_JHT54q.js';

package/dist/environments.d.ts

@@ -1,26 +1,21 @@
-import { E as Environment } from './chunks/environment.d.cL3nLXbE.js';
-export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.cL3nLXbE.js';
-import 'vitest/optional-types.js';
+import { E as Environment } from './chunks/environment.d.BsToaxti.js';
+export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.BsToaxti.js';
 
 declare const environments: {
-	"node": Environment
-	"jsdom": Environment
-	"happy-dom": Environment
-	"edge-runtime": Environment
+	"node": Environment;
+	"jsdom": Environment;
+	"happy-dom": Environment;
+	"edge-runtime": Environment;
 };
 
 interface PopulateOptions {
-	// we bind functions such as addEventListener and others
-	// because they rely on `this` in happy-dom, and in jsdom it
-	// has a priority for getting implementation from symbols
-	// (global doesn't have these symbols, but window - does)
 	bindFunctions?: boolean;
 	additionalKeys?: string[];
 }
 declare function populateGlobal(global: any, win: any, options?: PopulateOptions): {
-	keys: Set<string>
-	skipKeys: string[]
-	originals: Map<string | symbol, any>
+	keys: Set<string>;
+	skipKeys: string[];
+	originals: Map<string | symbol, any>;
 };
 
 export { Environment, environments as builtinEnvironments, populateGlobal };

package/dist/environments.js

@@ -1,2 +1,2 @@
-export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.CmSc2RE5.js';
+export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.DIWhzsUh.js';
 import 'node:console';