@depup/vitest 4.0.18-depup.0

package/dist/chunks/worker.d.Dyxm8DEL.d.ts

@@ -0,0 +1,255 @@
+import { FileSpecification, Task, CancelReason } from '@vitest/runner';
+import { EvaluatedModules } from 'vite/module-runner';
+import { S as SerializedConfig } from './config.d.Cy95HiCx.js';
+import { E as Environment } from './environment.d.CrsxCzP1.js';
+import { R as RuntimeRPC, a as RunnerRPC } from './rpc.d.RH3apGEf.js';
+
+//#region src/messages.d.ts
+declare const TYPE_REQUEST: "q";
+interface RpcRequest {
+  /**
+   * Type
+   */
+  t: typeof TYPE_REQUEST;
+  /**
+   * ID
+   */
+  i?: string;
+  /**
+   * Method
+   */
+  m: string;
+  /**
+   * Arguments
+   */
+  a: any[];
+  /**
+   * Optional
+   */
+  o?: boolean;
+}
+//#endregion
+//#region src/utils.d.ts
+type ArgumentsType<T> = T extends ((...args: infer A) => any) ? A : never;
+type ReturnType<T> = T extends ((...args: any) => infer R) ? R : never;
+type Thenable<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/main.d.ts
+type PromisifyFn<T> = ReturnType<T> extends Promise<any> ? T : (...args: ArgumentsType<T>) => Promise<Awaited<ReturnType<T>>>;
+type BirpcResolver<This> = (this: This, name: string, resolved: (...args: unknown[]) => unknown) => Thenable<((...args: any[]) => any) | undefined>;
+interface ChannelOptions {
+  /**
+   * Function to post raw message
+   */
+  post: (data: any, ...extras: any[]) => Thenable<any>;
+  /**
+   * Listener to receive raw message
+   */
+  on: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
+  /**
+   * Clear the listener when `$close` is called
+   */
+  off?: (fn: (data: any, ...extras: any[]) => void) => Thenable<any>;
+  /**
+   * Custom function to serialize data
+   *
+   * by default it passes the data as-is
+   */
+  serialize?: (data: any) => any;
+  /**
+   * Custom function to deserialize data
+   *
+   * by default it passes the data as-is
+   */
+  deserialize?: (data: any) => any;
+  /**
+   * Call the methods with the RPC context or the original functions object
+   */
+  bind?: 'rpc' | 'functions';
+  /**
+   * Custom meta data to attached to the RPC instance's `$meta` property
+   */
+  meta?: any;
+}
+interface EventOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> {
+  /**
+   * Names of remote functions that do not need response.
+   */
+  eventNames?: (keyof RemoteFunctions)[];
+  /**
+   * Maximum timeout for waiting for response, in milliseconds.
+   *
+   * @default 60_000
+   */
+  timeout?: number;
+  /**
+   * Whether to proxy the remote functions.
+   *
+   * When `proxify` is false, calling the remote function
+   * with `rpc.$call('method', ...args)` instead of `rpc.method(...args)`
+   * explicitly is required.
+   *
+   * @default true
+   */
+  proxify?: Proxify;
+  /**
+   * Custom resolver to resolve function to be called
+   *
+   * For advanced use cases only
+   */
+  resolver?: BirpcResolver<BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>>;
+  /**
+   * Hook triggered before an event is sent to the remote
+   *
+   * @param req - Request parameters
+   * @param next - Function to continue the request
+   * @param resolve - Function to resolve the response directly
+   */
+  onRequest?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, req: RpcRequest, next: (req?: RpcRequest) => Promise<any>, resolve: (res: any) => void) => void | Promise<void>;
+  /**
+   * Custom error handler for errors occurred in local functions being called
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onFunctionError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName: string, args: any[]) => boolean | void;
+  /**
+   * Custom error handler for errors occurred during serialization or messsaging
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onGeneralError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, error: Error, functionName?: string, args?: any[]) => boolean | void;
+  /**
+   * Custom error handler for timeouts
+   *
+   * @returns `true` to prevent the error from being thrown
+   */
+  onTimeoutError?: (this: BirpcReturn<RemoteFunctions, LocalFunctions, Proxify>, functionName: string, args: any[]) => boolean | void;
+}
+type BirpcOptions<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = EventOptions<RemoteFunctions, LocalFunctions, Proxify> & ChannelOptions;
+type BirpcFn<T> = PromisifyFn<T> & {
+  /**
+   * Send event without asking for response
+   */
+  asEvent: (...args: ArgumentsType<T>) => Promise<void>;
+};
+interface BirpcReturnBuiltin<RemoteFunctions, LocalFunctions = Record<string, unknown>> {
+  /**
+   * Raw functions object
+   */
+  $functions: LocalFunctions;
+  /**
+   * Whether the RPC is closed
+   */
+  readonly $closed: boolean;
+  /**
+   * Custom meta data attached to the RPC instance
+   */
+  readonly $meta: any;
+  /**
+   * Close the RPC connection
+   */
+  $close: (error?: Error) => void;
+  /**
+   * Reject pending calls
+   */
+  $rejectPendingCalls: (handler?: PendingCallHandler) => Promise<void>[];
+  /**
+   * Call the remote function and wait for the result.
+   * An alternative to directly calling the function
+   */
+  $call: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]>>>;
+  /**
+   * Same as `$call`, but returns `undefined` if the function is not defined on the remote side.
+   */
+  $callOptional: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<Awaited<ReturnType<RemoteFunctions[K$1]> | undefined>>;
+  /**
+   * Send event without asking for response
+   */
+  $callEvent: <K$1 extends keyof RemoteFunctions>(method: K$1, ...args: ArgumentsType<RemoteFunctions[K$1]>) => Promise<void>;
+  /**
+   * Call the remote function with the raw options.
+   */
+  $callRaw: (options: {
+    method: string;
+    args: unknown[];
+    event?: boolean;
+    optional?: boolean;
+  }) => Promise<Awaited<ReturnType<any>>[]>;
+}
+type ProxifiedRemoteFunctions<RemoteFunctions extends object = Record<string, unknown>> = { [K in keyof RemoteFunctions]: BirpcFn<RemoteFunctions[K]> };
+type BirpcReturn<RemoteFunctions extends object = Record<string, unknown>, LocalFunctions extends object = Record<string, unknown>, Proxify extends boolean = true> = Proxify extends true ? ProxifiedRemoteFunctions<RemoteFunctions> & BirpcReturnBuiltin<RemoteFunctions, LocalFunctions> : BirpcReturnBuiltin<RemoteFunctions, LocalFunctions>;
+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;
+
+type WorkerRPC = BirpcReturn<RuntimeRPC, RunnerRPC>;
+interface ContextTestEnvironment {
+	name: string;
+	options: Record<string, any> | null;
+}
+interface WorkerTestEnvironment {
+	name: string;
+	options: Record<string, any> | null;
+}
+type TestExecutionMethod = "run" | "collect";
+interface WorkerExecuteContext {
+	files: FileSpecification[];
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+	environment: ContextTestEnvironment;
+	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
+	workerId: number;
+}
+interface ContextRPC {
+	pool: string;
+	config: SerializedConfig;
+	projectName: string;
+	environment: WorkerTestEnvironment;
+	rpc: WorkerRPC;
+	files: FileSpecification[];
+	providedContext: Record<string, any>;
+	invalidates?: string[];
+	/** Exposed to test runner as `VITEST_WORKER_ID`. Value is unique per each isolated worker. */
+	workerId: number;
+}
+interface WorkerSetupContext {
+	environment: WorkerTestEnvironment;
+	pool: string;
+	config: SerializedConfig;
+	projectName: string;
+	rpc: WorkerRPC;
+}
+interface WorkerGlobalState {
+	ctx: ContextRPC;
+	config: SerializedConfig;
+	rpc: WorkerRPC;
+	current?: Task;
+	filepath?: string;
+	metaEnv: {
+		[key: string]: any;
+		BASE_URL: string;
+		MODE: string;
+		DEV: boolean;
+		PROD: boolean;
+		SSR: boolean;
+	};
+	environment: Environment;
+	evaluatedModules: EvaluatedModules;
+	resolvingModules: Set<string>;
+	moduleExecutionInfo: Map<string, any>;
+	onCancel: (listener: (reason: CancelReason) => unknown) => void;
+	onCleanup: (listener: () => unknown) => void;
+	providedContext: Record<string, any>;
+	durations: {
+		environment: number;
+		prepare: number;
+	};
+	onFilterStackTrace?: (trace: string) => string;
+}
+
+export type { BirpcOptions as B, ContextRPC as C, TestExecutionMethod as T, WorkerGlobalState as W, WorkerSetupContext as a, BirpcReturn as b, ContextTestEnvironment as c, WorkerExecuteContext as d, WorkerTestEnvironment as e };

package/dist/cli.js

@@ -0,0 +1,28 @@
+import { c as createCLI } from './chunks/cac.DVeoLl0M.js';
+import '@vitest/utils/helpers';
+import 'events';
+import 'pathe';
+import 'tinyrainbow';
+import './chunks/constants.D_Q9UYh-.js';
+import './chunks/index.M8mOzt4Y.js';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:perf_hooks';
+import '@vitest/runner/utils';
+import '@vitest/utils/source-map';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
+import 'node:util';
+import 'node:console';
+import 'node:stream';
+import '@vitest/utils/display';
+import 'node:os';
+import 'tinyexec';
+import './path.js';
+import 'node:path';
+import 'node:url';
+import 'vite';
+import '@vitest/utils/offset';
+import 'node:module';
+
+createCLI().parse();

package/dist/config.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var os = require('node:os');
+var stdEnv = require('std-env');
+var vite = require('vite');
+
+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/**", "**/.git/**"];
+// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
+const coverageConfigDefaults = {
+	provider: "v8",
+	enabled: false,
+	clean: true,
+	cleanOnRerun: true,
+	reportsDirectory: "./coverage",
+	exclude: [],
+	reportOnFailure: false,
+	reporter: [
+		["text", {}],
+		["html", {}],
+		["clover", {}],
+		["json", {}]
+	],
+	allowExternal: false,
+	excludeAfterRemap: false,
+	processingConcurrency: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
+};
+const fakeTimersDefaults = {
+	loopLimit: 1e4,
+	shouldClearNativeTimers: true
+};
+const configDefaults = Object.freeze({
+	allowOnly: !stdEnv.isCI,
+	isolate: true,
+	watch: !stdEnv.isCI && process.stdin.isTTY,
+	globals: false,
+	environment: "node",
+	clearMocks: false,
+	restoreMocks: false,
+	mockReset: false,
+	unstubGlobals: false,
+	unstubEnvs: false,
+	include: defaultInclude,
+	exclude: defaultExclude,
+	teardownTimeout: 1e4,
+	forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
+	update: false,
+	reporters: [],
+	silent: false,
+	hideSkippedTests: false,
+	api: false,
+	ui: false,
+	uiBase: "/__vitest__/",
+	open: !stdEnv.isCI,
+	css: { include: [] },
+	coverage: coverageConfigDefaults,
+	fakeTimers: fakeTimersDefaults,
+	maxConcurrency: 5,
+	dangerouslyIgnoreUnhandledErrors: false,
+	typecheck: {
+		checker: "tsc",
+		include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
+		exclude: defaultExclude
+	},
+	slowTestThreshold: 300,
+	disableConsoleIntercept: false
+});
+
+function defineConfig(config) {
+	return config;
+}
+function defineProject(config) {
+	return config;
+}
+
+Object.defineProperty(exports, "mergeConfig", {
+  enumerable: true,
+  get: function () { return vite.mergeConfig; }
+});
+exports.configDefaults = configDefaults;
+exports.coverageConfigDefaults = coverageConfigDefaults;
+exports.defaultBrowserPort = defaultBrowserPort;
+exports.defaultExclude = defaultExclude;
+exports.defaultInclude = defaultInclude;
+exports.defineConfig = defineConfig;
+exports.defineProject = defineProject;

package/dist/config.d.ts

@@ -0,0 +1,104 @@
+import { HookHandler, ConfigEnv, UserConfig } from 'vite';
+export { ConfigEnv, Plugin, UserConfig as ViteUserConfig, mergeConfig } from 'vite';
+import { I as InlineConfig, c as CoverageV8Options, R as ResolvedCoverageOptions, U as UserWorkspaceConfig, d as UserProjectConfigFn, e as UserProjectConfigExport } from './chunks/reporters.d.CWXNI2jG.js';
+export { b as TestProjectConfiguration, g as TestProjectInlineConfiguration, f as TestUserConfig, W as WatcherTriggerPattern } from './chunks/reporters.d.CWXNI2jG.js';
+import { V as VitestPluginContext } from './chunks/plugin.d.CtqpEehP.js';
+import { F as FakeTimerInstallOpts } from './chunks/config.d.Cy95HiCx.js';
+import '@vitest/runner';
+import '@vitest/utils';
+import './chunks/rpc.d.RH3apGEf.js';
+import '@vitest/snapshot';
+import 'vite/module-runner';
+import './chunks/traces.d.402V_yFI.js';
+import 'node:stream';
+import './chunks/browser.d.ChKACdzH.js';
+import './chunks/worker.d.Dyxm8DEL.js';
+import './chunks/environment.d.CrsxCzP1.js';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import 'vitest/browser';
+import '@vitest/pretty-format';
+import '@vitest/utils/diff';
+import '@vitest/expect';
+import 'vitest/optional-types.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import './chunks/coverage.d.BZtK59WP.js';
+import '@vitest/snapshot/manager';
+import 'node:console';
+import 'node:fs';
+
+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 defaultInclude: string[];
+declare const defaultExclude: string[];
+declare const coverageConfigDefaults: ResolvedCoverageOptions;
+declare const configDefaults: Readonly<{
+	allowOnly: boolean;
+	isolate: boolean;
+	watch: boolean;
+	globals: boolean;
+	environment: "node";
+	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;
+	typecheck: {
+		checker: "tsc";
+		include: string[];
+		exclude: string[];
+	};
+	slowTestThreshold: number;
+	disableConsoleIntercept: boolean;
+}>;
+
+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: ViteUserConfigFnPromise): ViteUserConfigFnPromise;
+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;
+
+export { UserProjectConfigExport, UserProjectConfigFn, UserWorkspaceConfig, configDefaults, coverageConfigDefaults, defaultBrowserPort, defaultExclude, defaultInclude, defineConfig, defineProject };
+export type { ViteUserConfigExport, ViteUserConfigFn, ViteUserConfigFnObject, ViteUserConfigFnPromise };

package/dist/config.js

@@ -0,0 +1,15 @@
+export { c as configDefaults, a as coverageConfigDefaults, d as defaultExclude, b as defaultInclude } from './chunks/defaults.BOqNVLsY.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';
+
+function defineConfig(config) {
+	return config;
+}
+function defineProject(config) {
+	return config;
+}
+
+export { defineConfig, defineProject };

package/dist/coverage.d.ts

@@ -0,0 +1,118 @@
+import { R as ResolvedCoverageOptions, V as Vitest, C as CoverageMap, a as ReportContext } from './chunks/reporters.d.CWXNI2jG.js';
+import { TransformResult } from 'vite';
+import { A as AfterSuiteRunMeta } from './chunks/rpc.d.RH3apGEf.js';
+import '@vitest/runner';
+import '@vitest/utils';
+import 'node:stream';
+import './chunks/browser.d.ChKACdzH.js';
+import './chunks/traces.d.402V_yFI.js';
+import './chunks/worker.d.Dyxm8DEL.js';
+import 'vite/module-runner';
+import './chunks/config.d.Cy95HiCx.js';
+import '@vitest/pretty-format';
+import '@vitest/snapshot';
+import '@vitest/utils/diff';
+import './chunks/environment.d.CrsxCzP1.js';
+import '@vitest/mocker';
+import '@vitest/utils/source-map';
+import 'vitest/browser';
+import '@vitest/expect';
+import 'vitest/optional-types.js';
+import './chunks/benchmark.d.DAaHLpsq.js';
+import '@vitest/runner/utils';
+import 'tinybench';
+import './chunks/coverage.d.BZtK59WP.js';
+import '@vitest/snapshot/manager';
+import 'node:console';
+import 'node:fs';
+
+type Threshold = "lines" | "functions" | "statements" | "branches";
+interface ResolvedThreshold {
+	coverageMap: CoverageMap;
+	name: string;
+	thresholds: Partial<Record<Threshold, number | undefined>>;
+}
+/**
+* Holds info about raw coverage results that are stored on file system:
+*
+* ```json
+* "project-a": {
+*   "web": {
+*     "tests/math.test.ts": "coverage-1.json",
+*     "tests/utils.test.ts": "coverage-2.json",
+* //                          ^^^^^^^^^^^^^^^ Raw coverage on file system
+*   },
+*   "ssr": { ... },
+*   "browser": { ... },
+* },
+* "project-b": ...
+* ```
+*/
+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;
+		};
+	}>;
+	resolveOptions(): Options;
+	clean(clean?: boolean): Promise<void>;
+	onAfterSuiteRun({ coverage, environment, projectName, testFiles }: AfterSuiteRunMeta): void;
+	readCoverageFiles<CoverageType>({ onFileRead, onFinished, onDebug }: {
+		/** Callback invoked with a single coverage result */
+		onFileRead: (data: CoverageType) => void;
+		/** Callback invoked once all results of a project for specific transform mode are read */
+		onFinished: (project: Vitest["projects"][number], environment: string) => Promise<void>;
+		onDebug: ((...logs: any[]) => void) & {
+			enabled: boolean;
+		};
+	}): Promise<void>;
+	cleanAfterRun(): Promise<void>;
+	onTestFailure(): Promise<void>;
+	reportCoverage(coverageMap: unknown, { allTestsRun }: ReportContext): Promise<void>;
+	reportThresholds(coverageMap: CoverageMap, allTestsRun: boolean | undefined): Promise<void>;
+	/**
+	* Constructs collected coverage and users' threshold options into separate sets
+	* where each threshold set holds their own coverage maps. Threshold set is either
+	* for specific files defined by glob pattern or global for all other files.
+	*/
+	private resolveThresholds;
+	/**
+	* Check collected coverage against configured thresholds. Sets exit code to 1 when thresholds not reached.
+	*/
+	private checkThresholds;
+	/**
+	* 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;
+	}): Promise<void>;
+	mergeReports(coverageMaps: unknown[]): Promise<void>;
+	hasTerminalReporter(reporters: ResolvedCoverageOptions["reporter"]): boolean;
+	toSlices<T>(array: T[], size: number): T[][];
+	createUncoveredFileTransformer(ctx: Vitest): (filename: string) => Promise<TransformResult | null | undefined>;
+}
+
+export { BaseCoverageProvider };

package/dist/coverage.js

@@ -0,0 +1,23 @@
+export { B as BaseCoverageProvider } from './chunks/coverage.AVPTjMgw.js';
+import 'node:fs';
+import 'node:path';
+import '@vitest/utils/helpers';
+import 'pathe';
+import 'picomatch';
+import 'tinyglobby';
+import 'tinyrainbow';
+import './chunks/defaults.BOqNVLsY.js';
+import 'node:os';
+import './chunks/env.D4Lgay0q.js';
+import 'std-env';
+import 'node:crypto';
+import 'node:url';
+import 'node:module';
+import 'node:process';
+import 'node:fs/promises';
+import 'node:assert';
+import 'node:v8';
+import 'node:util';
+import 'vite';
+import './chunks/constants.D_Q9UYh-.js';
+import './chunks/coverage.D_JHT54q.js';

package/dist/environments.d.ts

@@ -0,0 +1,22 @@
+import { E as Environment } from './chunks/environment.d.CrsxCzP1.js';
+export { a as EnvironmentReturn, V as VmEnvironmentReturn } from './chunks/environment.d.CrsxCzP1.js';
+import '@vitest/utils';
+
+declare const environments: {
+	"node": Environment;
+	"jsdom": Environment;
+	"happy-dom": Environment;
+	"edge-runtime": Environment;
+};
+
+interface PopulateOptions {
+	bindFunctions?: boolean;
+	additionalKeys?: string[];
+}
+declare function populateGlobal(global: any, win: any, options?: PopulateOptions): {
+	keys: Set<string>;
+	skipKeys: string[];
+	originals: Map<string | symbol, any>;
+};
+
+export { Environment, environments as builtinEnvironments, populateGlobal };

package/dist/environments.js

@@ -0,0 +1,3 @@
+export { e as builtinEnvironments, p as populateGlobal } from './chunks/index.CyBMJtT7.js';
+import 'node:url';
+import 'node:console';