vitest 2.2.0-beta.2 → 3.0.0-beta.1

package/dist/chunks/{cli-api.CB-jIbYQ.js → cli-api.BKUOv0Nc.js}

@@ -8,12 +8,12 @@ import { f as findUp, p as prompt } from './index.BJDntFik.js';
 import { searchForWorkspaceRoot, version, createServer, mergeConfig } from 'vite';
 import { A as API_PATH, c as configFiles, a as defaultBrowserPort, w as workspacesFiles, d as defaultPort } from './constants.fzPh7AOq.js';
 import { SnapshotManager } from '@vitest/snapshot/manager';
-import { i as isPackageExists, e as requireMicromatch, V as VitestCache, f as configDefaults, g as getFilePoolName, h as isBrowserEnabled, m as mm, b as resolveConfig, w as wildcardPatternToRegExp, j as createPool, a as resolveApiServerConfig, c as coverageConfigDefaults, s as stdout } from './resolveConfig.CLnvCvEs.js';
+import { e as groupBy, i as isPackageExists, f as requireMicromatch, V as VitestCache, h as configDefaults, g as getFilePoolName, j as isBrowserEnabled, m as mm, b as resolveConfig, w as wildcardPatternToRegExp, k as createPool, a as resolveApiServerConfig, c as coverageConfigDefaults, s as stdout } from './resolveConfig.3rGGWga5.js';
 import { ViteNodeRunner } from 'vite-node/client';
 import { ViteNodeServer } from 'vite-node/server';
-import { v as version$1 } from './cac.Cs06pOqp.js';
+import { v as version$1 } from './cac.CWCZimpS.js';
 import { c as createBirpc } from './index.68735LiX.js';
-import { s as stringify, p as parse, i as generateCodeFrame, R as ReportersMap, h as BenchmarkReportsMap, f as TestModule, g as TestSuite, e as TestCase, L as Logger, j as BlobReporter, r as readBlobs } from './index.bzFpKeaq.js';
+import { s as stringify, p as parse, i as generateCodeFrame, R as ReportersMap, h as BenchmarkReportsMap, f as TestModule, g as TestSuite, e as TestCase, L as Logger, j as BlobReporter, r as readBlobs } from './index.DKe7vK-G.js';
 import require$$0$2 from 'stream';
 import require$$0 from 'zlib';
 import require$$0$1 from 'buffer';
@@ -30,7 +30,7 @@ import { distDir, rootDir } from '../path.js';
 import { createRequire } from 'node:module';
 import url from 'node:url';
 import c from 'tinyrainbow';
-import { h as hash, i as isWindows } from './RandomSequencer.BPedXEug.js';
+import { h as hash, i as isWindows } from './RandomSequencer.gisBJ77r.js';
 import { isCI } from 'std-env';
 import { rm } from 'node:fs/promises';
 import nodeos__default, { tmpdir } from 'node:os';
@@ -5069,6 +5069,59 @@ class GitNotFoundError extends Error {
     super("Could not find Git root. Have you initialized git with `git init`?");
   }
 }
+class LocationFilterFileNotFoundError extends Error {
+  code = "VITEST_LOCATION_FILTER_FILE_NOT_FOUND";
+  constructor(filename) {
+    super(`Couldn't find file ${filename}. Note when specifying the test location you have to specify the full test filename.`);
+  }
+}
+class IncludeTaskLocationDisabledError extends Error {
+  code = "VITEST_INCLUDE_TASK_LOCATION_DISABLED";
+  constructor() {
+    super("Recieved line number filters while `includeTaskLocation` option is disabled");
+  }
+}
+class RangeLocationFilterProvidedError extends Error {
+  code = "VITEST_RANGE_LOCATION_FILTER_PROVIDED";
+  constructor(filter) {
+    super(`Found "-" in location filter ${filter}.  Note that range location filters are not supported.  Consider specifying the exact line numbers of your tests.`);
+  }
+}
+
+function parseFilter(filter) {
+  const colonIndex = filter.lastIndexOf(":");
+  if (colonIndex === -1) {
+    return { filename: filter };
+  }
+  const [parsedFilename, lineNumber] = [
+    filter.substring(0, colonIndex),
+    filter.substring(colonIndex + 1)
+  ];
+  if (lineNumber.match(/^\d+$/)) {
+    return {
+      filename: parsedFilename,
+      lineNumber: Number.parseInt(lineNumber)
+    };
+  } else if (lineNumber.match(/^\d+-\d+$/)) {
+    throw new RangeLocationFilterProvidedError(filter);
+  } else {
+    return { filename: filter };
+  }
+}
+function groupFilters(filters) {
+  const groupedFilters_ = groupBy(filters, (f) => f.filename);
+  const groupedFilters = Object.fromEntries(
+    Object.entries(groupedFilters_).map((entry) => {
+      const [filename, filters2] = entry;
+      const testLocations = filters2.map((f) => f.lineNumber);
+      return [
+        filename,
+        testLocations.filter((l) => l !== void 0)
+      ];
+    })
+  );
+  return groupedFilters;
+}
 
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 class VitestPackageInstaller {
@@ -5111,7 +5164,7 @@ class VitestPackageInstaller {
     });
     if (install) {
       const packageName = version ? `${dependency}@${version}` : dependency;
-      await (await import('./index.CqYx2Nsr.js')).installPackage(packageName, { dev: true });
+      await (await import('./index.DQboAxJm.js')).installPackage(packageName, { dev: true });
       process.stderr.write(
         c.yellow(
           `
@@ -8703,7 +8756,7 @@ function requireJsTokens () {
 	// Copyright 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Simon Lydell
 	// License: MIT.
 	var HashbangComment, Identifier, JSXIdentifier, JSXPunctuator, JSXString, JSXText, KeywordsWithExpressionAfter, KeywordsWithNoLineTerminatorAfter, LineTerminatorSequence, MultiLineComment, Newline, NumericLiteral, Punctuator, RegularExpressionLiteral, SingleLineComment, StringLiteral, Template, TokensNotPrecedingObjectLiteral, TokensPrecedingExpression, WhiteSpace;
-	RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]|[^\/\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
+	RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/yu;
 	Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y;
 	Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/yu;
 	StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y;
@@ -9543,14 +9596,17 @@ class TestSpecification {
   project;
   moduleId;
   pool;
+  /** @private */
+  testLocations;
   // public readonly location: WorkspaceSpecLocation | undefined
-  constructor(project, moduleId, pool) {
+  constructor(project, moduleId, pool, testLocations) {
     this[0] = project;
     this[1] = moduleId;
     this[2] = { pool };
     this.project = project;
     this.moduleId = moduleId;
     this.pool = pool;
+    this.testLocations = testLocations;
   }
   toJSON() {
     return [
@@ -9623,10 +9679,12 @@ class TestProject {
   _provided = {};
   _config;
   _vite;
+  // "provide" is a property, not a method to keep the context when destructed in the global setup,
+  // making it a method would be a breaking change, and can be done in Vitest 3 at minimum
   /**
    * Provide a value to the test context. This value will be available to all tests with `inject`.
    */
-  provide(key, value) {
+  provide = (key, value) => {
     try {
       structuredClone(value);
     } catch (err) {
@@ -9638,7 +9696,7 @@ class TestProject {
       );
     }
     this._provided[key] = value;
-  }
+  };
   /**
    * Get the provided context. The project context is merged with the global context.
    */
@@ -9655,11 +9713,12 @@ class TestProject {
    * Creates a new test specification. Specifications describe how to run tests.
    * @param moduleId The file path
    */
-  createSpecification(moduleId, pool) {
+  createSpecification(moduleId, pool, testLocations) {
     return new TestSpecification(
       this,
       moduleId,
-      pool || getFilePoolName(this, moduleId)
+      pool || getFilePoolName(this, moduleId),
+      testLocations
     );
   }
   toJSON() {
@@ -9731,11 +9790,7 @@ class TestProject {
       this.config.globalSetup
     );
     for (const globalSetupFile of this._globalSetups) {
-      const teardown = await globalSetupFile.setup?.({
-        provide: (key, value) => this.provide(key, value),
-        config: this.config,
-        onTestsRerun: (cb) => this.vitest.onTestsRerun(cb)
-      });
+      const teardown = await globalSetupFile.setup?.(this);
       if (teardown == null || !!globalSetupFile.teardown) {
         continue;
       }
@@ -9747,6 +9802,9 @@ class TestProject {
       globalSetupFile.teardown = teardown;
     }
   }
+  onTestsRerun(cb) {
+    this.vitest.onTestsRerun(cb);
+  }
   /** @deprecated */
   teardownGlobalSetup() {
     return this._teardownGlobalSetup();
@@ -10053,18 +10111,15 @@ class TestProject {
 }
 async function initializeProject(workspacePath, ctx, options) {
   const project = new TestProject(workspacePath, ctx, options);
-  const { extends: extendsConfig, workspaceConfigPath, ...restOptions } = options;
-  const root = options.root || (typeof workspacePath === "number" ? void 0 : workspacePath.endsWith("/") ? workspacePath : dirname(workspacePath));
-  const configFile = extendsConfig ? resolve(dirname(workspaceConfigPath), extendsConfig) : typeof workspacePath === "number" || workspacePath.endsWith("/") ? false : workspacePath;
+  const { extends: extendsConfig, configFile, ...restOptions } = options;
   const config = {
     ...restOptions,
-    root,
     configFile,
     // this will make "mode": "test" | "benchmark" inside defineConfig
     mode: options.test?.mode || options.mode || ctx.config.mode,
     plugins: [
       ...options.plugins || [],
-      WorkspaceVitestPlugin(project, { ...options, root, workspacePath })
+      WorkspaceVitestPlugin(project, { ...options, workspacePath })
     ]
   };
   await createViteServer(config);
@@ -10387,35 +10442,41 @@ async function resolveWorkspace(vitest, cliOptions, workspaceConfigPath, workspa
   const projectPromises = [];
   const fileProjects = [...configFiles, ...nonConfigDirectories];
   const concurrent = limitConcurrency(nodeos__default.availableParallelism?.() || nodeos__default.cpus().length || 5);
-  for (const filepath of fileProjects) {
-    if (vitest.server.config.configFile === filepath) {
-      projectPromises.push(concurrent(() => vitest._createCoreProject()));
+  projectConfigs.forEach((options, index) => {
+    const configRoot = workspaceConfigPath ? dirname(workspaceConfigPath) : vitest.config.root;
+    const configFile = typeof options.extends === "string" ? resolve(configRoot, options.extends) : false;
+    const rootOptions = options.extends === true ? vitest._options : {};
+    const root = options.root ? resolve(configRoot, options.root) : vitest.config.root;
+    projectPromises.push(concurrent(() => initializeProject(
+      index,
+      vitest,
+      mergeConfig(rootOptions, { ...options, root, configFile })
+    )));
+  });
+  for (const path of fileProjects) {
+    if (vitest.server.config.configFile === path) {
+      projectPromises.push(Promise.resolve(vitest._createRootProject()));
       continue;
     }
+    const configFile = path.endsWith("/") ? false : path;
+    const root = path.endsWith("/") ? path : dirname(path);
     projectPromises.push(
       concurrent(() => initializeProject(
-        filepath,
+        path,
         vitest,
-        { workspaceConfigPath, test: cliOverrides }
+        { root, configFile, test: cliOverrides }
       ))
     );
   }
-  projectConfigs.forEach((options, index) => {
-    projectPromises.push(concurrent(() => initializeProject(
-      index,
-      vitest,
-      mergeConfig(options, { workspaceConfigPath, test: cliOverrides })
-    )));
-  });
   if (!projectPromises.length) {
-    return [await vitest._createCoreProject()];
+    return [vitest._createRootProject()];
   }
   const resolvedProjects = await Promise.all(projectPromises);
   const names = /* @__PURE__ */ new Set();
   for (const project of resolvedProjects) {
-    const name = project.getName();
+    const name = project.name;
     if (names.has(name)) {
-      const duplicate = resolvedProjects.find((p) => p.getName() === name && p !== project);
+      const duplicate = resolvedProjects.find((p) => p.name === name && p !== project);
       const filesError = fileProjects.length ? [
         "\n\nYour config matched these files:\n",
         fileProjects.map((p) => ` - ${relative(vitest.config.root, p)}`).join("\n"),
@@ -10439,14 +10500,15 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceD
   const workspaceConfigFiles = [];
   const workspaceGlobMatches = [];
   const nonConfigProjectDirectories = [];
-  const relativeWorkpaceConfigPath = relative(vitest.config.root, workspaceConfigPath);
   for (const definition of workspaceDefinition) {
     if (typeof definition === "string") {
       const stringOption = definition.replace("<rootDir>", vitest.config.root);
       if (!isDynamicPattern(stringOption)) {
         const file = resolve(vitest.config.root, stringOption);
         if (!existsSync(file)) {
-          throw new Error(`Workspace config file "${relativeWorkpaceConfigPath}" references a non-existing file or a directory: ${file}`);
+          const relativeWorkpaceConfigPath = workspaceConfigPath ? relative(vitest.config.root, workspaceConfigPath) : void 0;
+          const note = workspaceConfigPath ? `Workspace config file "${relativeWorkpaceConfigPath}"` : "Inline workspace";
+          throw new Error(`${note} references a non-existing file or a directory: ${file}`);
         }
         const stats = await promises.stat(file);
         if (stats.isFile()) {
@@ -10494,16 +10556,16 @@ async function resolveTestProjectConfigs(vitest, workspaceConfigPath, workspaceD
       ]
     };
     const workspacesFs = await fg.glob(workspaceGlobMatches, globOptions);
-    await Promise.all(workspacesFs.map(async (filepath) => {
-      if (filepath.endsWith("/")) {
-        const configFile = await resolveDirectoryConfig(filepath);
+    await Promise.all(workspacesFs.map(async (path) => {
+      if (path.endsWith("/")) {
+        const configFile = await resolveDirectoryConfig(path);
         if (configFile) {
           workspaceConfigFiles.push(configFile);
         } else {
-          nonConfigProjectDirectories.push(filepath);
+          nonConfigProjectDirectories.push(path);
         }
       } else {
-        workspaceConfigFiles.push(filepath);
+        workspaceConfigFiles.push(path);
       }
     }));
   }
@@ -10553,6 +10615,7 @@ class Vitest {
   restartsCount = 0;
   runner = void 0;
   packageInstaller;
+  /** TODO: rename to `_coreRootProject` */
   /** @internal */
   coreWorkspaceProject;
   /** @private */
@@ -10563,14 +10626,17 @@ class Vitest {
   _workspaceConfigPath;
   /** @deprecated use `_cachedSpecs` */
   projectTestFiles = this._cachedSpecs;
-  /** @private */
+  /** @internal */
   _browserLastPort = defaultBrowserPort;
+  /** @internal */
+  _options = {};
   _onRestartListeners = [];
   _onClose = [];
   _onSetServer = [];
   _onCancelListeners = [];
   _onUserTestsRerun = [];
   async setServer(options, server, cliOptions) {
+    this._options = options;
     this.unregisterWatcher?.();
     clearTimeout(this._rerunTimer);
     this.restartsCount += 1;
@@ -10616,7 +10682,7 @@ class Vitest {
       };
       server.watcher.on("change", async (file) => {
         file = normalize(file);
-        const isConfig = file === server.config.configFile || this.resolvedProjects.some((p) => p.server.config.configFile === file) || file === this._workspaceConfigPath;
+        const isConfig = file === server.config.configFile || this.resolvedProjects.some((p) => p.vite.config.configFile === file) || file === this._workspaceConfigPath;
         if (isConfig) {
           await Promise.all(this._onRestartListeners.map((fn) => fn("config")));
           this.report("onServerRestart", "config");
@@ -10637,7 +10703,7 @@ class Vitest {
     const filters = toArray(resolved.project).map((s) => wildcardPatternToRegExp(s));
     if (filters.length > 0) {
       this.projects = this.projects.filter(
-        (p) => filters.some((pattern) => pattern.test(p.getName()))
+        (p) => filters.some((pattern) => pattern.test(p.name))
       );
     }
     if (!this.coreWorkspaceProject) {
@@ -10654,7 +10720,7 @@ class Vitest {
   /**
    * @internal
    */
-  _createCoreProject() {
+  _createRootProject() {
     this.coreWorkspaceProject = TestProject._createBasicProject(this);
     return this.coreWorkspaceProject;
   }
@@ -10675,8 +10741,8 @@ class Vitest {
   getProjectByName(name = "") {
     return this.projects.find((p) => p.name === name) || this.coreWorkspaceProject || this.projects[0];
   }
-  async getWorkspaceConfigPath() {
-    if (this.config.workspace) {
+  async resolveWorkspaceConfigPath() {
+    if (typeof this.config.workspace === "string") {
       return this.config.workspace;
     }
     const configDir = this.server.config.configFile ? dirname(this.server.config.configFile) : this.config.root;
@@ -10690,10 +10756,18 @@ class Vitest {
     return join(configDir, workspaceConfigName);
   }
   async resolveWorkspace(cliOptions) {
-    const workspaceConfigPath = await this.getWorkspaceConfigPath();
+    if (Array.isArray(this.config.workspace)) {
+      return resolveWorkspace(
+        this,
+        cliOptions,
+        void 0,
+        this.config.workspace
+      );
+    }
+    const workspaceConfigPath = await this.resolveWorkspaceConfigPath();
     this._workspaceConfigPath = workspaceConfigPath;
     if (!workspaceConfigPath) {
-      return [this._createCoreProject()];
+      return [this._createRootProject()];
     }
     const workspaceModule = await this.runner.executeFile(workspaceConfigPath);
     if (!workspaceModule.default || !Array.isArray(workspaceModule.default)) {
@@ -10933,35 +11007,38 @@ class Vitest {
     this._onCancelListeners = [];
     this.isCancelling = false;
     this.runningPromise = (async () => {
-      if (!this.pool) {
-        this.pool = createPool(this);
-      }
-      const invalidates = Array.from(this.invalidates);
-      this.invalidates.clear();
-      this.snapshot.clear();
-      this.state.clearErrors();
-      if (!this.isFirstRun && this.config.coverage.cleanOnRerun) {
-        await this.coverageProvider?.clean();
-      }
-      await this.initializeGlobalSetup(specs);
       try {
-        await this.pool.runTests(specs, invalidates);
-      } catch (err) {
-        this.state.catchError(err, "Unhandled Error");
-      }
-      const files = this.state.getFiles();
-      if (hasFailed(files)) {
-        process.exitCode = 1;
+        if (!this.pool) {
+          this.pool = createPool(this);
+        }
+        const invalidates = Array.from(this.invalidates);
+        this.invalidates.clear();
+        this.snapshot.clear();
+        this.state.clearErrors();
+        if (!this.isFirstRun && this.config.coverage.cleanOnRerun) {
+          await this.coverageProvider?.clean();
+        }
+        await this.initializeGlobalSetup(specs);
+        try {
+          await this.pool.runTests(specs, invalidates);
+        } catch (err) {
+          this.state.catchError(err, "Unhandled Error");
+        }
+        const files = this.state.getFiles();
+        if (hasFailed(files)) {
+          process.exitCode = 1;
+        }
+        this.cache.results.updateResults(files);
+        await this.cache.results.writeToCache();
+      } finally {
+        const files = Array.from(new Set(specs.map((spec) => spec.moduleId)));
+        const errors = this.state.getUnhandledErrors();
+        const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
+        this.checkUnhandledErrors(errors);
+        await this.report("onFinished", this.state.getFiles(files), errors, coverage);
+        await this.reportCoverage(coverage, allTestsRun);
       }
-      this.cache.results.updateResults(files);
-      await this.cache.results.writeToCache();
-    })().finally(async () => {
-      const files = Array.from(new Set(specs.map((spec) => spec.moduleId)));
-      const errors = this.state.getUnhandledErrors();
-      const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun });
-      this.checkUnhandledErrors(errors);
-      await this.report("onFinished", this.state.getFiles(files), errors, coverage);
-      await this.reportCoverage(coverage, allTestsRun);
+    })().finally(() => {
       this.runningPromise = void 0;
       this.isFirstRun = false;
       this.config.changed = false;
@@ -10993,7 +11070,7 @@ class Vitest {
       if (hasFailed(files)) {
         process.exitCode = 1;
       }
-    })().finally(async () => {
+    })().finally(() => {
       this.runningPromise = void 0;
       this.config.changed = false;
       this.config.related = void 0;
@@ -11042,7 +11119,7 @@ class Vitest {
     } else {
       this.configOverride.project = pattern;
     }
-    this.projects = this.resolvedProjects.filter((p) => p.getName() === pattern);
+    this.projects = this.resolvedProjects.filter((p) => p.name === pattern);
     const files = (await this.globTestSpecs()).map((spec) => spec.moduleId);
     await this.rerunFiles(files, "change project filter", pattern === "");
   }
@@ -11354,19 +11431,41 @@ class Vitest {
   }
   async globTestSpecs(filters = []) {
     const files = [];
+    const dir = process.cwd();
+    const parsedFilters = filters.map((f) => parseFilter(f));
+    if (!this.config.includeTaskLocation && parsedFilters.some((f) => f.lineNumber !== void 0)) {
+      throw new IncludeTaskLocationDisabledError();
+    }
+    const testLocations = groupFilters(parsedFilters.map(
+      (f) => ({ ...f, filename: slash(resolve$1(dir, f.filename)) })
+    ));
+    const testLocHasMatch = {};
     await Promise.all(this.projects.map(async (project) => {
-      const { testFiles, typecheckTestFiles } = await project.globTestFiles(filters);
+      const { testFiles, typecheckTestFiles } = await project.globTestFiles(
+        parsedFilters.map((f) => f.filename)
+      );
       testFiles.forEach((file) => {
-        const spec = project.createSpecification(file);
+        const loc = testLocations[file];
+        testLocHasMatch[file] = true;
+        const spec = project.createSpecification(file, void 0, loc);
         this.ensureSpecCached(spec);
         files.push(spec);
       });
       typecheckTestFiles.forEach((file) => {
-        const spec = project.createSpecification(file, "typescript");
+        const loc = testLocations[file];
+        testLocHasMatch[file] = true;
+        const spec = project.createSpecification(file, "typescript", loc);
         this.ensureSpecCached(spec);
         files.push(spec);
       });
     }));
+    Object.entries(testLocations).forEach(([filepath, loc]) => {
+      if (loc.length !== 0 && !testLocHasMatch[filepath]) {
+        throw new LocationFilterFileNotFoundError(
+          relative(dir, filepath)
+        );
+      }
+    });
     return files;
   }
   /**
@@ -12013,6 +12112,10 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides, v
       ctx.logger.error(e.message);
       return ctx;
     }
+    if (e instanceof IncludeTaskLocationDisabledError || e instanceof RangeLocationFilterProvidedError || e instanceof LocationFilterFileNotFoundError) {
+      ctx.logger.printError(e, { verbose: false });
+      return ctx;
+    }
     process.exitCode = 1;
     ctx.logger.printError(e, { fullStack: true, type: "Unhandled Error" });
     ctx.logger.error("\n\n");

package/dist/chunks/{config.CPguQ7J1.d.ts → config.BTPBhmK5.d.ts}

@@ -33,7 +33,7 @@ interface FakeTimerInstallOpts {
     /**
      * An array with names of global methods and APIs to fake.
      * For instance, `vi.useFakeTimer({ toFake: ['setTimeout', 'performance'] })` will fake only `setTimeout()` and `performance.now()`
-     * @default ['setTimeout', 'clearTimeout', 'setImmediate', 'clearImmediate', 'setInterval', 'clearInterval', 'Date']
+     * @default everything available globally except `nextTick`
      */
     toFake?: FakeMethod[] | undefined;
 

package/dist/chunks/{creator.IIqd8RWT.js → creator.DcAcUhMD.js}

@@ -1,15 +1,12 @@
 import { existsSync, writeFileSync, readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve, dirname, relative } from 'node:path';
-import { detectPackageManager, installPackage } from './index.CqYx2Nsr.js';
+import { detectPackageManager, installPackage } from './index.DQboAxJm.js';
 import { p as prompt, f as findUp } from './index.BJDntFik.js';
 import { x } from 'tinyexec';
 import c from 'tinyrainbow';
 import { c as configFiles } from './constants.fzPh7AOq.js';
-import 'process';
 import 'node:process';
-import 'fs';
-import 'path';
 import 'node:url';
 import './_commonjsHelpers.BFTU3MAI.js';
 import 'readline';

package/dist/chunks/{globals.BCGEw6ON.js → globals.DJTzb7B3.js}

@@ -1,6 +1,6 @@
 import { g as globalApis } from './constants.fzPh7AOq.js';
-import { V as VitestIndex } from './index.DD5eTY2y.js';
-import './vi.BlPttogV.js';
+import { V as VitestIndex } from './index.BqHViJW9.js';
+import './vi.CZKezqeD.js';
 import '@vitest/expect';
 import '@vitest/runner';
 import '@vitest/runner/utils';

package/dist/chunks/{index.DD5eTY2y.js → index.BqHViJW9.js}

@@ -1,4 +1,4 @@
-import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.BlPttogV.js';
+import { c as createExpect, a as globalExpect, i as inject, v as vi, b as vitest } from './vi.CZKezqeD.js';
 import { i as isFirstRun, a as runOnce } from './run-once.2ogXb3JV.js';
 import { b as bench } from './benchmark.Cdu9hjj4.js';
 import { expectTypeOf } from 'expect-type';

package/dist/chunks/{index.BjjsHdBb.js → index.CkOJwybT.js}

@@ -3,7 +3,7 @@ import { resolve } from 'node:path';
 import { t as takeCoverageInsideWorker } from './coverage.BoMDb1ip.js';
 import { distDir } from '../path.js';
 import { r as rpc } from './rpc.C3q9uwRX.js';
-import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.BfGt8K-K.js';
+import { l as loadDiffConfig, a as loadSnapshotSerializers } from './setup-common.B5ClyS48.js';
 import { g as getWorkerState } from './utils.C8RiOc4B.js';
 
 function setupChaiConfig(config) {