vitest 3.0.8 → 3.1.0-beta.1

package/dist/chunks/defaults.C2Ndd9wx.js

@@ -0,0 +1,119 @@
+import nodeos__default from 'node:os';
+import './env.D4Lgay0q.js';
+import { isCI } from 'std-env';
+
+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 benchmarkConfigDefaults = {
+  include: ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"],
+  exclude: defaultExclude,
+  includeSource: [],
+  reporters: ["default"],
+  includeSamples: false
+};
+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 coverageConfigDefaults = {
+  provider: "v8",
+  enabled: false,
+  all: true,
+  clean: true,
+  cleanOnRerun: true,
+  reportsDirectory: "./coverage",
+  exclude: defaultCoverageExcludes,
+  reportOnFailure: false,
+  reporter: [
+    ["text", {}],
+    ["html", {}],
+    ["clover", {}],
+    ["json", {}]
+  ],
+  extension: [
+    ".js",
+    ".cjs",
+    ".mjs",
+    ".ts",
+    ".mts",
+    ".tsx",
+    ".jsx",
+    ".vue",
+    ".svelte",
+    ".marko",
+    ".astro"
+  ],
+  allowExternal: false,
+  excludeAfterRemap: false,
+  ignoreEmptyLines: true,
+  processingConcurrency: Math.min(
+    20,
+    nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length
+  )
+};
+const fakeTimersDefaults = {
+  loopLimit: 1e4,
+  shouldClearNativeTimers: true
+};
+const configDefaults = Object.freeze({
+  allowOnly: !isCI,
+  isolate: true,
+  watch: !isCI,
+  globals: false,
+  environment: "node",
+  pool: "forks",
+  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: !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
+});
+
+export { coverageConfigDefaults as a, defaultInclude as b, configDefaults as c, defaultExclude as d, benchmarkConfigDefaults as e };

package/dist/chunks/env.D4Lgay0q.js

@@ -0,0 +1,8 @@
+import { isCI } from 'std-env';
+
+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;
+const isWindows = (isNode || isDeno) && process.platform === "win32";
+const isTTY = (isNode || isDeno) && process.stdout?.isTTY && !isCI;
+
+export { isWindows as a, isTTY as i };

package/dist/chunks/environment.d.C8UItCbf.d.ts

@@ -0,0 +1,170 @@
+type Awaitable<T> = T | PromiseLike<T>;
+type Nullable<T> = T | null | undefined;
+type Arrayable<T> = T | Array<T>;
+type ArgumentsType<T> = T extends (...args: infer U) => any ? U : never;
+type MutableArray<T extends readonly any[]> = { -readonly [k in keyof T] : T[k] };
+interface Constructable {
+	new (...args: any[]): any;
+}
+type TransformMode = "web" | "ssr";
+/** @deprecated not used */
+interface ModuleCache {
+	promise?: Promise<any>;
+	exports?: any;
+	code?: string;
+}
+interface AfterSuiteRunMeta {
+	coverage?: unknown;
+	testFiles: string[];
+	transformMode: TransformMode | "browser";
+	projectName?: string;
+}
+interface UserConsoleLog {
+	content: string;
+	origin?: string;
+	browser?: boolean;
+	type: "stdout" | "stderr";
+	taskId?: string;
+	time: number;
+	size: number;
+}
+interface ModuleGraphData {
+	graph: Record<string, string[]>;
+	externalized: string[];
+	inlined: string[];
+}
+interface ProvidedContext {}
+
+/**
+* Happy DOM options.
+*/
+interface HappyDOMOptions {
+	width?: number;
+	height?: number;
+	url?: string;
+	settings?: {
+		disableJavaScriptEvaluation?: boolean
+		disableJavaScriptFileLoading?: boolean
+		disableCSSFileLoading?: boolean
+		disableIframePageLoading?: boolean
+		disableComputedStyleRendering?: boolean
+		enableFileSystemHttpRequests?: boolean
+		navigator?: {
+			userAgent?: string
+		}
+		device?: {
+			prefersColorScheme?: string
+			mediaType?: string
+		}
+	};
+}
+
+interface JSDOMOptions {
+	/**
+	* The html content for the test.
+	*
+	* @default '<!DOCTYPE html>'
+	*/
+	html?: string | 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";
+}
+
+interface EnvironmentReturn {
+	teardown: (global: any) => Awaitable<void>;
+}
+interface VmEnvironmentReturn {
+	getVmContext: () => {
+		[key: string]: any
+	};
+	teardown: () => Awaitable<void>;
+}
+interface Environment {
+	name: string;
+	transformMode: "web" | "ssr";
+	setupVM?: (options: Record<string, any>) => Awaitable<VmEnvironmentReturn>;
+	setup: (global: any, options: Record<string, any>) => Awaitable<EnvironmentReturn>;
+}
+interface EnvironmentOptions {
+	/**
+	* jsdom options.
+	*/
+	jsdom?: JSDOMOptions;
+	happyDOM?: HappyDOMOptions;
+	[x: string]: unknown;
+}
+interface ResolvedTestEnvironment {
+	environment: Environment;
+	options: Record<string, any> | null;
+}
+
+export type { AfterSuiteRunMeta as A, Constructable as C, Environment as E, HappyDOMOptions as H, JSDOMOptions as J, ModuleGraphData as M, Nullable as N, ProvidedContext as P, ResolvedTestEnvironment as R, TransformMode as T, UserConsoleLog as U, VmEnvironmentReturn as V, EnvironmentReturn as a, Awaitable as b, Arrayable as c, ArgumentsType as d, MutableArray as e, EnvironmentOptions as f, ModuleCache as g };

package/dist/chunks/global.d.Cg2sEPIm.d.ts

@@ -0,0 +1,127 @@
+import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
+import { Plugin } from '@vitest/pretty-format';
+import { SnapshotState } from '@vitest/snapshot';
+import { B as BenchmarkResult } from './benchmark.d.BwvBVTda.js';
+import { U as UserConsoleLog } from './environment.d.C8UItCbf.js';
+
+type RawErrsMap = Map<string, TscErrorInfo[]>;
+interface TscErrorInfo {
+	filePath: string;
+	errCode: number;
+	errMsg: string;
+	line: number;
+	column: number;
+}
+interface CollectLineNumbers {
+	target: number;
+	next: number;
+	prev?: number;
+}
+type CollectLines = { [key in keyof CollectLineNumbers] : string };
+interface RootAndTarget {
+	root: string;
+	targetAbsPath: string;
+}
+type Context = RootAndTarget & {
+	rawErrsMap: RawErrsMap
+	openedDirs: Set<string>
+	lastActivePath?: string
+};
+
+declare global {
+	namespace Chai {
+		interface Assertion {
+			containSubset: (expected: any) => Assertion;
+		}
+		interface Assert {
+			containSubset: (val: any, exp: any, msg?: string) => void;
+		}
+	}
+}
+interface SnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, message?: string): void;
+	(message?: string): void;
+}
+interface InlineSnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(properties: Partial<U>, snapshot?: string, message?: string): void;
+	(message?: string): void;
+}
+declare module "@vitest/expect" {
+	interface MatcherState {
+		environment: string;
+		snapshotState: SnapshotState;
+	}
+	interface ExpectPollOptions {
+		interval?: number;
+		timeout?: number;
+		message?: string;
+	}
+	interface ExpectStatic {
+		unreachable: (message?: string) => never;
+		soft: <T>(actual: T, message?: string) => Assertion<T>;
+		poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+		addEqualityTesters: (testers: Array<Tester>) => void;
+		assertions: (expected: number) => void;
+		hasAssertions: () => void;
+		addSnapshotSerializer: (plugin: Plugin) => void;
+	}
+	interface Assertion<T> {
+		matchSnapshot: SnapshotMatcher<T>;
+		toMatchSnapshot: SnapshotMatcher<T>;
+		toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+		/**
+		* Checks that an error thrown by a function matches a previously recorded snapshot.
+		*
+		* @param message - Optional custom error message.
+		*
+		* @example
+		* expect(functionWithError).toThrowErrorMatchingSnapshot();
+		*/
+		toThrowErrorMatchingSnapshot: (message?: string) => void;
+		/**
+		* Checks that an error thrown by a function matches an inline snapshot within the test file.
+		* Useful for keeping snapshots close to the test code.
+		*
+		* @param snapshot - Optional inline snapshot string to match.
+		* @param message - Optional custom error message.
+		*
+		* @example
+		* const throwError = () => { throw new Error('Error occurred') };
+		* expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+		*/
+		toThrowErrorMatchingInlineSnapshot: (snapshot?: string, message?: string) => void;
+		/**
+		* Compares the received value to a snapshot saved in a specified file.
+		* Useful for cases where snapshot content is large or needs to be shared across tests.
+		*
+		* @param filepath - Path to the snapshot file.
+		* @param message - Optional custom error message.
+		*
+		* @example
+		* await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+		*/
+		toMatchFileSnapshot: (filepath: string, message?: string) => Promise<void>;
+	}
+}
+declare module "@vitest/runner" {
+	interface TestContext {
+		expect: ExpectStatic;
+	}
+	interface TaskMeta {
+		typecheck?: boolean;
+		benchmark?: boolean;
+		failScreenshotPath?: string;
+	}
+	interface File {
+		prepareDuration?: number;
+		environmentLoad?: number;
+	}
+	interface TaskBase {
+		logs?: UserConsoleLog[];
+	}
+	interface TaskResult {
+		benchmark?: BenchmarkResult;
+	}
+}
+
+export type { CollectLineNumbers as C, RawErrsMap as R, TscErrorInfo as T, CollectLines as a, RootAndTarget as b, Context as c };

package/dist/chunks/{globals.CydvVTgC.js → globals.BEpDe-k3.js}

@@ -1,6 +1,6 @@
-import { g as globalApis } from './constants.fzPh7AOq.js';
-import { V as VitestIndex } from './index.CNRemkXW.js';
-import './vi.B5EKKJdE.js';
+import { g as globalApis } from './constants.DTYd6dNH.js';
+import { V as VitestIndex } from './index.D7Ny8f_s.js';
+import './vi.nSCvwQ7l.js';
 import '@vitest/expect';
 import '@vitest/runner';
 import '@vitest/runner/utils';
@@ -14,7 +14,7 @@ import '@vitest/spy';
 import '@vitest/utils/source-map';
 import './date.W2xKR2qe.js';
 import './run-once.2ogXb3JV.js';
-import './benchmark.Cdu9hjj4.js';
+import './benchmark.DL72EVN-.js';
 import 'expect-type';
 
 function registerApiGlobally() {

package/dist/chunks/{index.CNRemkXW.js → index.D7Ny8f_s.js}

@@ -1,6 +1,6 @@
-import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.B5EKKJdE.js';
+import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.nSCvwQ7l.js';
 import { i as isFirstRun, a as runOnce } from './run-once.2ogXb3JV.js';
-import { b as bench } from './benchmark.Cdu9hjj4.js';
+import { b as bench } from './benchmark.DL72EVN-.js';
 import { expectTypeOf } from 'expect-type';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, suite, test } from '@vitest/runner';
 import * as chai from 'chai';

package/dist/chunks/{index.B7vJpkTD.js → index.DOyx6FYJ.js}

@@ -8,7 +8,8 @@ import { stripVTControlCharacters } from 'node:util';
 import { positionToOffset, lineSplitRE, isPrimitive, inspect, toArray, notNullish } from '@vitest/utils';
 import { performance as performance$1 } from 'node:perf_hooks';
 import { parseErrorStacktrace, parseStacktrace } from '@vitest/utils/source-map';
-import { T as TypeCheckError, g as getOutputFile, i as isTTY, h as hasFailedSnapshot } from './typechecker.cZ0LjdSi.js';
+import { i as isTTY } from './env.D4Lgay0q.js';
+import { T as TypeCheckError, g as getOutputFile, h as hasFailedSnapshot } from './typechecker.BlF3eHsb.js';
 import { mkdir, writeFile, readdir, stat, readFile } from 'node:fs/promises';
 import { Console } from 'node:console';
 import { Writable } from 'node:stream';
@@ -299,6 +300,9 @@ const skipErrorProperties = /* @__PURE__ */ new Set([
   "actual",
   "expected",
   "diffOptions",
+  "sourceURL",
+  "column",
+  "line",
   "VITEST_TEST_NAME",
   "VITEST_TEST_PATH",
   "VITEST_AFTER_ENV_TEARDOWN",
@@ -626,6 +630,28 @@ class BaseReporter {
       this.reportSummary(files, errors);
     }
   }
+  onTestCaseResult(testCase) {
+    if (testCase.result().state === "failed") {
+      this.logFailedTask(testCase.task);
+    }
+  }
+  onTestSuiteResult(testSuite) {
+    if (testSuite.state() === "failed") {
+      this.logFailedTask(testSuite.task);
+    }
+  }
+  onTestModuleEnd(testModule) {
+    if (testModule.state() === "failed") {
+      this.logFailedTask(testModule.task);
+    }
+  }
+  logFailedTask(task) {
+    if (this.ctx.config.silent === "passed-only") {
+      for (const log of task.logs || []) {
+        this.onUserConsoleLog(log, "failed");
+      }
+    }
+  }
   onTaskUpdate(packs) {
     for (const pack of packs) {
       const task = this.ctx.state.idMap.get(pack[0]);
@@ -672,7 +698,7 @@ class BaseReporter {
       for (const test of tests) {
         const { duration, retryCount, repeatCount } = test.result || {};
         const padding = this.getTestIndentation(test);
-        let suffix2 = "";
+        let suffix2 = this.getDurationPrefix(test);
         if (retryCount != null && retryCount > 0) {
           suffix2 += c.yellow(` (retry x${retryCount})`);
         }
@@ -680,7 +706,7 @@ class BaseReporter {
           suffix2 += c.yellow(` (repeat x${repeatCount})`);
         }
         if (test.result?.state === "fail") {
-          this.log(c.red(` ${padding}${taskFail} ${this.getTestName(test, c.dim(" > "))}${this.getDurationPrefix(test)}`) + suffix2);
+          this.log(c.red(` ${padding}${taskFail} ${this.getTestName(test, c.dim(" > "))}`) + suffix2);
           test.result?.errors?.forEach((error) => {
             const message = this.formatShortError(error);
             if (message) {
@@ -688,9 +714,7 @@ class BaseReporter {
             }
           });
         } else if (duration && duration > this.ctx.config.slowTestThreshold) {
-          this.log(
-            ` ${padding}${c.yellow(c.dim(F_CHECK))} ${this.getTestName(test, c.dim(" > "))} ${c.yellow(Math.round(duration) + c.dim("ms"))}${suffix2}`
-          );
+          this.log(` ${padding}${c.yellow(c.dim(F_CHECK))} ${this.getTestName(test, c.dim(" > "))} ${suffix2}`);
         } else if (this.ctx.config.hideSkippedTests && (test.mode === "skip" || test.result?.state === "skip")) ; else if (test.result?.state === "skip" && test.result.note) {
           this.log(` ${padding}${getStateSymbol(test)} ${this.getTestName(test)}${c.dim(c.gray(` [${test.result.note}]`))}`);
         } else if (this.renderSucceed || failed.length > 0) {
@@ -714,7 +738,7 @@ class BaseReporter {
     if (!task.result?.duration) {
       return "";
     }
-    const color = task.result.duration > this.ctx.config.slowTestThreshold ? c.yellow : c.gray;
+    const color = task.result.duration > this.ctx.config.slowTestThreshold ? c.yellow : c.green;
     return color(` ${Math.round(task.result.duration)}${c.dim("ms")}`);
   }
   onWatcherStart(files = this.ctx.state.getFiles(), errors = this.ctx.state.getUnhandledErrors()) {
@@ -766,8 +790,8 @@ class BaseReporter {
     this._timeStart = formatTimeString(/* @__PURE__ */ new Date());
     this.start = performance$1.now();
   }
-  onUserConsoleLog(log) {
-    if (!this.shouldLog(log)) {
+  onUserConsoleLog(log, taskState) {
+    if (!this.shouldLog(log, taskState)) {
       return;
     }
     const output = log.type === "stdout" ? this.ctx.logger.outputStream : this.ctx.logger.errorStream;
@@ -805,8 +829,11 @@ class BaseReporter {
     this.log(c.yellow("Test removed...") + (trigger ? c.dim(` [ ${this.relative(trigger)} ]
 `) : ""));
   }
-  shouldLog(log) {
-    if (this.ctx.config.silent) {
+  shouldLog(log, taskState) {
+    if (this.ctx.config.silent === true) {
+      return false;
+    }
+    if (this.ctx.config.silent === "passed-only" && taskState !== "failed") {
       return false;
     }
     const shouldLog = this.ctx.config.onConsoleLog?.(log.content, log.type);
@@ -1429,12 +1456,14 @@ class DefaultReporter extends BaseReporter {
     this.summary?.onTestModuleCollected(module);
   }
   onTestModuleEnd(module) {
+    super.onTestModuleEnd(module);
     this.summary?.onTestModuleEnd(module);
   }
   onTestCaseReady(test) {
     this.summary?.onTestCaseReady(test);
   }
   onTestCaseResult(test) {
+    super.onTestCaseResult(test);
     this.summary?.onTestCaseResult(test);
   }
   onHookStart(hook) {
@@ -1508,11 +1537,13 @@ class DotReporter extends BaseReporter {
     this.renderer?.schedule();
   }
   onTestCaseResult(test) {
+    super.onTestCaseResult(test);
     this.finishedTests.add(test.id);
     this.tests.set(test.id, test.result().state || "skipped");
     this.renderer?.schedule();
   }
-  onTestModuleEnd() {
+  onTestModuleEnd(testModule) {
+    super.onTestModuleEnd(testModule);
     if (!this.isTTY) {
       return;
     }
@@ -2005,6 +2036,7 @@ class JUnitReporter {
           mode: "run",
           result: file.result,
           meta: {},
+          timeout: 0,
           // NOTE: not used in JUnitReporter
           context: null,
           suite: null,
@@ -2184,15 +2216,12 @@ class VerboseReporter extends DefaultReporter {
     if (task.type !== "test" || !task.result?.state || task.result?.state === "run" || task.result?.state === "queued") {
       return;
     }
-    const duration = task.result.duration;
     let title = ` ${getStateSymbol(task)} `;
     if (task.file.projectName) {
       title += formatProjectName(task.file.projectName);
     }
     title += getFullName(task, c.dim(" > "));
-    if (duration != null && duration > this.ctx.config.slowTestThreshold) {
-      title += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
-    }
+    title += super.getDurationPrefix(task);
     if (this.ctx.config.logHeapUsage && task.result.heap != null) {
       title += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);
     }
@@ -2373,8 +2402,9 @@ ${padding}`;
     if (task.mode === "skip" || task.mode === "todo") {
       suffix += c.dim(c.gray(" [skipped]"));
     }
-    if (duration != null && duration > options.slowTestThreshold) {
-      suffix += c.yellow(` ${Math.round(duration)}${c.dim("ms")}`);
+    if (duration != null) {
+      const color = duration > options.slowTestThreshold ? c.yellow : c.green;
+      suffix += color(` ${Math.round(duration)}${c.dim("ms")}`);
     }
     if (options.showHeap && task.result?.heap != null) {
       suffix += c.magenta(` ${Math.floor(task.result.heap / 1024 / 1024)} MB heap used`);

package/dist/chunks/{index.BmFgJtkv.js → index.uXkkC4xl.js}

@@ -1,9 +1,8 @@
 import * as chai from 'chai';
 import { resolve } from 'node:path';
-import { t as takeCoverageInsideWorker } from './coverage.DnNIv-kJ.js';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.CPvtqi8q.js';
 import { distDir } from '../path.js';
 import { r as rpc } from './rpc.TVf73xOu.js';
-import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.Uaw6Zgv9.js';
 import { g as getWorkerState } from './utils.C8RiOc4B.js';
 
 function setupChaiConfig(config) {

package/dist/chunks/{mocker.cRtM890J.d.ts → mocker.d.BE_2ls6u.d.ts}

@@ -4,14 +4,14 @@ type Promisable<T> = T | Promise<T>;
 type MockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M = M>() => Promise<T>) => Promisable<Partial<M>>;
 type MockFactory = () => any;
 interface MockOptions {
-    spy?: boolean;
+	spy?: boolean;
 }
 interface PendingSuiteMock {
-    id: string;
-    importer: string;
-    action: 'mock' | 'unmock';
-    type?: MockedModuleType;
-    factory?: MockFactory;
+	id: string;
+	importer: string;
+	action: "mock" | "unmock";
+	type?: MockedModuleType;
+	factory?: MockFactory;
 }
 
 export type { MockFactoryWithHelper as M, PendingSuiteMock as P, MockOptions as a, MockFactory as b };