vitest 0.21.0 → 0.22.1

package/dist/{chunk-defaults.8390340d.mjs → chunk-integrations-coverage.d205bd87.mjs}

@@ -1,7 +1,3 @@
-import { existsSync, promises } from 'fs';
-import { createRequire } from 'module';
-import _url from 'url';
-import { t as toArray, y as resolve } from './chunk-mock-date.ea3b3121.mjs';
 import { importModule } from 'local-pkg';
 
 /*
@@ -139,156 +135,31 @@ function pLimit(concurrency) {
 	return generator;
 }
 
-const defaultInclude = ["**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"];
-const defaultExclude = ["**/node_modules/**", "**/dist/**", "**/cypress/**", "**/.{idea,git,cache,output,temp}/**"];
-const defaultCoverageExcludes = [
-  "coverage/**",
-  "dist/**",
-  "packages/*/test{,s}/**",
-  "**/*.d.ts",
-  "cypress/**",
-  "test{,s}/**",
-  "test{,-*}.{js,cjs,mjs,ts,tsx,jsx}",
-  "**/*{.,-}test.{js,cjs,mjs,ts,tsx,jsx}",
-  "**/*{.,-}spec.{js,cjs,mjs,ts,tsx,jsx}",
-  "**/__tests__/**",
-  "**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress}.config.{js,cjs,mjs,ts}",
-  "**/.{eslint,mocha,prettier}rc.{js,cjs,yml}"
-];
-const coverageConfigDefaults = {
-  enabled: false,
-  clean: true,
-  cleanOnRerun: false,
-  reportsDirectory: "./coverage",
-  excludeNodeModules: true,
-  exclude: defaultCoverageExcludes,
-  reporter: ["text", "html", "clover"],
-  allowExternal: false,
-  extension: [".js", ".cjs", ".mjs", ".ts", ".tsx", ".jsx", ".vue", ".svelte"]
-};
-const fakeTimersDefaults = {
-  loopLimit: 1e4,
-  shouldClearNativeTimers: true,
-  toFake: [
-    "setTimeout",
-    "clearTimeout",
-    "setInterval",
-    "clearInterval",
-    "setImmediate",
-    "clearImmediate",
-    "Date"
-  ]
+const CoverageProviderMap = {
+  c8: "@vitest/coverage-c8",
+  istanbul: "@vitest/coverage-istanbul"
 };
-const config = {
-  allowOnly: !process.env.CI,
-  watch: !process.env.CI,
-  globals: false,
-  environment: "node",
-  threads: true,
-  clearMocks: false,
-  restoreMocks: false,
-  mockReset: false,
-  include: defaultInclude,
-  exclude: defaultExclude,
-  testTimeout: 5e3,
-  hookTimeout: 1e4,
-  teardownTimeout: 1e3,
-  isolate: true,
-  watchExclude: ["**/node_modules/**", "**/dist/**"],
-  forceRerunTriggers: [
-    "**/package.json/**",
-    "**/vitest.config.*/**",
-    "**/vite.config.*/**"
-  ],
-  update: false,
-  reporters: [],
-  silent: false,
-  api: false,
-  ui: false,
-  uiBase: "/__vitest__/",
-  open: true,
-  css: {
-    include: [/\.module\./]
-  },
-  coverage: coverageConfigDefaults,
-  fakeTimers: fakeTimersDefaults,
-  maxConcurrency: 5,
-  dangerouslyIgnoreUnhandledErrors: false
-};
-const configDefaults = Object.freeze(config);
-
-function resolveC8Options(options, root) {
-  const resolved = {
-    ...configDefaults.coverage,
-    ...options
-  };
-  resolved.reporter = toArray(resolved.reporter);
-  resolved.reportsDirectory = resolve(root, resolved.reportsDirectory);
-  resolved.tempDirectory = process.env.NODE_V8_COVERAGE || resolve(resolved.reportsDirectory, "tmp");
-  return resolved;
-}
-async function cleanCoverage(options, clean = true) {
-  if (clean && existsSync(options.reportsDirectory))
-    await promises.rm(options.reportsDirectory, { recursive: true, force: true });
-  if (!existsSync(options.tempDirectory))
-    await promises.mkdir(options.tempDirectory, { recursive: true });
+async function resolveCoverageProvider(provider) {
+  if (typeof provider === "string") {
+    const pkg = CoverageProviderMap[provider];
+    if (!pkg)
+      throw new Error(`Unknown coverage provider: ${provider}`);
+    return await importModule(pkg);
+  } else {
+    return provider;
+  }
 }
-const require = createRequire(import.meta.url);
-function takeCoverage() {
-  const v8 = require("v8");
-  if (v8.takeCoverage == null)
-    console.warn("[Vitest] takeCoverage is not available in this NodeJs version.\nCoverage could be incomplete. Update to NodeJs 14.18.");
-  else
-    v8.takeCoverage();
+async function getCoverageProvider(options) {
+  if ((options == null ? void 0 : options.enabled) && (options == null ? void 0 : options.provider)) {
+    const { getProvider } = await resolveCoverageProvider(options.provider);
+    return await getProvider();
+  }
+  return null;
 }
-async function reportCoverage(ctx) {
-  takeCoverage();
-  const createReport = require("c8/lib/report");
-  const report = createReport(ctx.config.coverage);
-  const sourceMapMeta = {};
-  await Promise.all(Array.from(ctx.vitenode.fetchCache.entries()).filter((i) => !i[0].includes("/node_modules/")).map(async ([file, { result }]) => {
-    const map = result.map;
-    if (!map)
-      return;
-    const url = _url.pathToFileURL(file).href;
-    let code;
-    try {
-      code = (await promises.readFile(file)).toString();
-    } catch {
-    }
-    const sources = [url];
-    sourceMapMeta[url] = {
-      source: result.code,
-      map: {
-        sourcesContent: code ? [code] : void 0,
-        ...map,
-        sources
-      }
-    };
-  }));
-  const offset = 224;
-  report._getSourceMap = (coverage) => {
-    const path = _url.pathToFileURL(coverage.url).href;
-    const data = sourceMapMeta[path];
-    if (!data)
-      return {};
-    return {
-      sourceMap: {
-        sourcemap: data.map
-      },
-      source: Array(offset).fill(".").join("") + data.source
-    };
-  };
-  await report.run();
-  if (ctx.config.coverage.enabled) {
-    if (ctx.config.coverage["100"]) {
-      ctx.config.coverage.lines = 100;
-      ctx.config.coverage.functions = 100;
-      ctx.config.coverage.branches = 100;
-      ctx.config.coverage.statements = 100;
-    }
-    const { checkCoverages } = require("c8/lib/commands/check-coverage");
-    await checkCoverages(ctx.config.coverage, report);
+async function takeCoverageInsideWorker(options) {
+  if (options.enabled && options.provider) {
+    const { takeCoverage } = await resolveCoverageProvider(options.provider);
+    return await (takeCoverage == null ? void 0 : takeCoverage());
   }
 }
 
@@ -677,4 +548,4 @@ const envPackageNames = {
   "edge-runtime": "@edge-runtime/vm"
 };
 
-export { cleanCoverage as a, reportCoverage as b, configDefaults as c, envPackageNames as d, environments as e, envs as f, pLimit as p, resolveC8Options as r, takeCoverage as t };
+export { CoverageProviderMap as C, envPackageNames as a, envs as b, environments as e, getCoverageProvider as g, pLimit as p, takeCoverageInsideWorker as t };

package/dist/{chunk-integrations-globals.a798d352.mjs → chunk-integrations-globals.60af7da3.mjs}

@@ -1,19 +1,19 @@
-import { g as globalApis } from './chunk-constants.9da1ef26.mjs';
-import { i as index } from './chunk-runtime-hooks.291644ec.mjs';
+import { k as globalApis } from './chunk-constants.71e8a211.mjs';
+import { i as index } from './chunk-runtime-hooks.5d7073db.mjs';
+import 'tty';
 import 'url';
-import './chunk-mock-date.ea3b3121.mjs';
 import 'path';
-import 'tty';
-import 'local-pkg';
-import './chunk-runtime-chain.44b4224d.mjs';
+import './chunk-runtime-chain.be610650.mjs';
 import 'util';
+import './chunk-mock-date.304e29b1.mjs';
+import 'local-pkg';
 import 'chai';
 import './vendor-_commonjsHelpers.4da45ef5.mjs';
-import './chunk-runtime-rpc.fc50dcc0.mjs';
+import './chunk-runtime-rpc.57586b73.mjs';
 import './chunk-utils-global.fa20c2f6.mjs';
 import './chunk-utils-timers.b48455ed.mjs';
 import 'fs';
-import './chunk-utils-source-map.d307e4ea.mjs';
+import './chunk-utils-source-map.bbf3ad19.mjs';
 import './spy.mjs';
 import 'tinyspy';
 

package/dist/{chunk-mock-date.ea3b3121.mjs → chunk-mock-date.304e29b1.mjs}

@@ -1,251 +1,7 @@
-import path, { relative as relative$1 } from 'path';
-import require$$0 from 'tty';
+import { relative } from 'path';
+import { r as relative$1, p as picocolors, E as EXIT_CODE_RESTART } from './chunk-constants.71e8a211.mjs';
 import { isPackageExists } from 'local-pkg';
 
-var picocolors = {exports: {}};
-
-let tty = require$$0;
-
-let isColorSupported =
-	!("NO_COLOR" in process.env || process.argv.includes("--no-color")) &&
-	("FORCE_COLOR" in process.env ||
-		process.argv.includes("--color") ||
-		process.platform === "win32" ||
-		(tty.isatty(1) && process.env.TERM !== "dumb") ||
-		"CI" in process.env);
-
-let formatter =
-	(open, close, replace = open) =>
-	input => {
-		let string = "" + input;
-		let index = string.indexOf(close, open.length);
-		return ~index
-			? open + replaceClose(string, close, replace, index) + close
-			: open + string + close
-	};
-
-let replaceClose = (string, close, replace, index) => {
-	let start = string.substring(0, index) + replace;
-	let end = string.substring(index + close.length);
-	let nextIndex = end.indexOf(close);
-	return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end
-};
-
-let createColors = (enabled = isColorSupported) => ({
-	isColorSupported: enabled,
-	reset: enabled ? s => `\x1b[0m${s}\x1b[0m` : String,
-	bold: enabled ? formatter("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m") : String,
-	dim: enabled ? formatter("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m") : String,
-	italic: enabled ? formatter("\x1b[3m", "\x1b[23m") : String,
-	underline: enabled ? formatter("\x1b[4m", "\x1b[24m") : String,
-	inverse: enabled ? formatter("\x1b[7m", "\x1b[27m") : String,
-	hidden: enabled ? formatter("\x1b[8m", "\x1b[28m") : String,
-	strikethrough: enabled ? formatter("\x1b[9m", "\x1b[29m") : String,
-	black: enabled ? formatter("\x1b[30m", "\x1b[39m") : String,
-	red: enabled ? formatter("\x1b[31m", "\x1b[39m") : String,
-	green: enabled ? formatter("\x1b[32m", "\x1b[39m") : String,
-	yellow: enabled ? formatter("\x1b[33m", "\x1b[39m") : String,
-	blue: enabled ? formatter("\x1b[34m", "\x1b[39m") : String,
-	magenta: enabled ? formatter("\x1b[35m", "\x1b[39m") : String,
-	cyan: enabled ? formatter("\x1b[36m", "\x1b[39m") : String,
-	white: enabled ? formatter("\x1b[37m", "\x1b[39m") : String,
-	gray: enabled ? formatter("\x1b[90m", "\x1b[39m") : String,
-	bgBlack: enabled ? formatter("\x1b[40m", "\x1b[49m") : String,
-	bgRed: enabled ? formatter("\x1b[41m", "\x1b[49m") : String,
-	bgGreen: enabled ? formatter("\x1b[42m", "\x1b[49m") : String,
-	bgYellow: enabled ? formatter("\x1b[43m", "\x1b[49m") : String,
-	bgBlue: enabled ? formatter("\x1b[44m", "\x1b[49m") : String,
-	bgMagenta: enabled ? formatter("\x1b[45m", "\x1b[49m") : String,
-	bgCyan: enabled ? formatter("\x1b[46m", "\x1b[49m") : String,
-	bgWhite: enabled ? formatter("\x1b[47m", "\x1b[49m") : String,
-});
-
-picocolors.exports = createColors();
-picocolors.exports.createColors = createColors;
-
-function normalizeWindowsPath(input = "") {
-  if (!input.includes("\\")) {
-    return input;
-  }
-  return input.replace(/\\/g, "/");
-}
-
-const _UNC_REGEX = /^[/][/]/;
-const _UNC_DRIVE_REGEX = /^[/][/]([.]{1,2}[/])?([a-zA-Z]):[/]/;
-const _IS_ABSOLUTE_RE = /^\/|^\\|^[a-zA-Z]:[/\\]/;
-const sep = "/";
-const delimiter = ":";
-const normalize = function(path2) {
-  if (path2.length === 0) {
-    return ".";
-  }
-  path2 = normalizeWindowsPath(path2);
-  const isUNCPath = path2.match(_UNC_REGEX);
-  const hasUNCDrive = isUNCPath && path2.match(_UNC_DRIVE_REGEX);
-  const isPathAbsolute = isAbsolute(path2);
-  const trailingSeparator = path2[path2.length - 1] === "/";
-  path2 = normalizeString(path2, !isPathAbsolute);
-  if (path2.length === 0) {
-    if (isPathAbsolute) {
-      return "/";
-    }
-    return trailingSeparator ? "./" : ".";
-  }
-  if (trailingSeparator) {
-    path2 += "/";
-  }
-  if (isUNCPath) {
-    if (hasUNCDrive) {
-      return `//./${path2}`;
-    }
-    return `//${path2}`;
-  }
-  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
-};
-const join = function(...args) {
-  if (args.length === 0) {
-    return ".";
-  }
-  let joined;
-  for (let i = 0; i < args.length; ++i) {
-    const arg = args[i];
-    if (arg.length > 0) {
-      if (joined === void 0) {
-        joined = arg;
-      } else {
-        joined += `/${arg}`;
-      }
-    }
-  }
-  if (joined === void 0) {
-    return ".";
-  }
-  return normalize(joined);
-};
-const resolve = function(...args) {
-  args = args.map((arg) => normalizeWindowsPath(arg));
-  let resolvedPath = "";
-  let resolvedAbsolute = false;
-  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-    const path2 = i >= 0 ? args[i] : process.cwd();
-    if (path2.length === 0) {
-      continue;
-    }
-    resolvedPath = `${path2}/${resolvedPath}`;
-    resolvedAbsolute = isAbsolute(path2);
-  }
-  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
-    return `/${resolvedPath}`;
-  }
-  return resolvedPath.length > 0 ? resolvedPath : ".";
-};
-function normalizeString(path2, allowAboveRoot) {
-  let res = "";
-  let lastSegmentLength = 0;
-  let lastSlash = -1;
-  let dots = 0;
-  let char = null;
-  for (let i = 0; i <= path2.length; ++i) {
-    if (i < path2.length) {
-      char = path2[i];
-    } else if (char === "/") {
-      break;
-    } else {
-      char = "/";
-    }
-    if (char === "/") {
-      if (lastSlash === i - 1 || dots === 1) ; else if (dots === 2) {
-        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
-          if (res.length > 2) {
-            const lastSlashIndex = res.lastIndexOf("/");
-            if (lastSlashIndex === -1) {
-              res = "";
-              lastSegmentLength = 0;
-            } else {
-              res = res.slice(0, lastSlashIndex);
-              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-            }
-            lastSlash = i;
-            dots = 0;
-            continue;
-          } else if (res.length !== 0) {
-            res = "";
-            lastSegmentLength = 0;
-            lastSlash = i;
-            dots = 0;
-            continue;
-          }
-        }
-        if (allowAboveRoot) {
-          res += res.length > 0 ? "/.." : "..";
-          lastSegmentLength = 2;
-        }
-      } else {
-        if (res.length > 0) {
-          res += `/${path2.slice(lastSlash + 1, i)}`;
-        } else {
-          res = path2.slice(lastSlash + 1, i);
-        }
-        lastSegmentLength = i - lastSlash - 1;
-      }
-      lastSlash = i;
-      dots = 0;
-    } else if (char === "." && dots !== -1) {
-      ++dots;
-    } else {
-      dots = -1;
-    }
-  }
-  return res;
-}
-const isAbsolute = function(p) {
-  return _IS_ABSOLUTE_RE.test(p);
-};
-const toNamespacedPath = function(p) {
-  return normalizeWindowsPath(p);
-};
-const extname = function(p) {
-  return path.posix.extname(normalizeWindowsPath(p));
-};
-const relative = function(from, to) {
-  return path.posix.relative(normalizeWindowsPath(from), normalizeWindowsPath(to));
-};
-const dirname = function(p) {
-  return path.posix.dirname(normalizeWindowsPath(p));
-};
-const format = function(p) {
-  return normalizeWindowsPath(path.posix.format(p));
-};
-const basename = function(p, ext) {
-  return path.posix.basename(normalizeWindowsPath(p), ext);
-};
-const parse = function(p) {
-  return path.posix.parse(normalizeWindowsPath(p));
-};
-
-const _path = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  sep: sep,
-  delimiter: delimiter,
-  normalize: normalize,
-  join: join,
-  resolve: resolve,
-  normalizeString: normalizeString,
-  isAbsolute: isAbsolute,
-  toNamespacedPath: toNamespacedPath,
-  extname: extname,
-  relative: relative,
-  dirname: dirname,
-  format: format,
-  basename: basename,
-  parse: parse
-});
-
-({
-  ..._path
-});
-
 const RealDate = Date;
 let now = null;
 class MockDate extends RealDate {
@@ -381,9 +137,9 @@ function deepMerge(target, ...sources) {
   const source = sources.shift();
   if (source === void 0)
     return target;
-  if (isMergableObject(target) && isMergableObject(source)) {
+  if (isMergeableObject(target) && isMergeableObject(source)) {
     Object.keys(source).forEach((key) => {
-      if (isMergableObject(source[key])) {
+      if (isMergeableObject(source[key])) {
         if (!target[key])
           target[key] = {};
         deepMerge(target[key], source[key]);
@@ -394,7 +150,7 @@ function deepMerge(target, ...sources) {
   }
   return deepMerge(target, ...sources);
 }
-function isMergableObject(item) {
+function isMergeableObject(item) {
   return isPlainObject(item) && !Array.isArray(item);
 }
 function assertTypes(value, name, types) {
@@ -459,7 +215,7 @@ var _a;
 const isNode = typeof process < "u" && typeof process.stdout < "u" && !((_a = process.versions) == null ? void 0 : _a.deno) && !globalThis.window;
 const isBrowser = typeof window !== "undefined";
 const isWindows = isNode && process.platform === "win32";
-const relativePath = isBrowser ? relative$1 : relative;
+const relativePath = isBrowser ? relative : relative$1;
 function partitionSuiteChildren(suite) {
   let tasksGroup = [];
   const tasksGroups = [];
@@ -500,18 +256,18 @@ async function ensurePackageInstalled(dependency, root) {
 `));
   if (!promptInstall)
     return false;
-  const prompts = await import('./vendor-index.de788b6a.mjs').then(function (n) { return n.i; });
+  const prompts = await import('./vendor-index.ae96af6e.mjs').then(function (n) { return n.i; });
   const { install } = await prompts.prompt({
     type: "confirm",
     name: "install",
     message: picocolors.exports.reset(`Do you want to install ${picocolors.exports.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.6c6dc0c2.mjs')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.3aa3eae6.mjs')).installPackage(dependency, { dev: true });
     process.stderr.write(picocolors.exports.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
-    process.exit(1);
+    process.exit(EXIT_CODE_RESTART);
     return true;
   }
   return false;
@@ -544,7 +300,7 @@ function getCallLastIndex(code) {
   }
   return null;
 }
-isNode ? relative : relative$1;
+isNode ? relative$1 : relative;
 class AggregateErrorPonyfill extends Error {
   constructor(errors, message = "") {
     super(message);
@@ -552,4 +308,4 @@ class AggregateErrorPonyfill extends Error {
   }
 }
 
-export { AggregateErrorPonyfill as A, isAbsolute as B, relative as C, getTests as D, hasFailedSnapshot as E, getSuites as F, normalize as G, deepMerge as H, toNamespacedPath as I, ensurePackageInstalled as J, stdout as K, extname as L, isWindows as M, mergeSlashes as N, getAllMockableProperties as O, RealDate as R, resetModules as a, getNames as b, assertTypes as c, dirname as d, getFullName as e, notNullish as f, getCallLastIndex as g, deepClone as h, isObject as i, join as j, getType as k, isNode as l, mockDate as m, noop as n, relativePath as o, picocolors as p, isBrowser as q, resetDate as r, slash as s, toArray as t, partitionSuiteChildren as u, shuffle as v, hasTests as w, hasFailed as x, resolve as y, basename as z };
+export { AggregateErrorPonyfill as A, stdout as B, isWindows as C, mergeSlashes as D, getAllMockableProperties as E, RealDate as R, resetModules as a, getNames as b, assertTypes as c, getFullName as d, notNullish as e, deepClone as f, getCallLastIndex as g, getType as h, isObject as i, isNode as j, relativePath as k, isBrowser as l, mockDate as m, noop as n, shuffle as o, partitionSuiteChildren as p, hasTests as q, resetDate as r, slash as s, toArray as t, hasFailed as u, getTests as v, hasFailedSnapshot as w, getSuites as x, deepMerge as y, ensurePackageInstalled as z };

package/dist/chunk-node-git.9a7e3153.mjs

@@ -0,0 +1,78 @@
+import { a as resolve } from './chunk-constants.71e8a211.mjs';
+import { e as execa } from './vendor-index.fbec8a81.mjs';
+import 'tty';
+import 'url';
+import 'path';
+import 'buffer';
+import 'child_process';
+import 'process';
+import './vendor-index.2ae8040a.mjs';
+import './vendor-_commonjsHelpers.4da45ef5.mjs';
+import 'fs';
+import 'stream';
+import 'util';
+import 'os';
+import './vendor-index.29636037.mjs';
+import 'assert';
+import 'events';
+
+class VitestGit {
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  async resolveFilesWithGitCommand(args) {
+    let result;
+    try {
+      result = await execa("git", args, { cwd: this.root });
+    } catch (e) {
+      e.message = e.stderr;
+      throw e;
+    }
+    return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
+  }
+  async findChangedFiles(options) {
+    const root = await this.getRoot(this.cwd);
+    if (!root)
+      return null;
+    this.root = root;
+    const changedSince = options.changedSince;
+    if (typeof changedSince === "string") {
+      const [committed, staged2, unstaged2] = await Promise.all([
+        this.getFilesSince(changedSince),
+        this.getStagedFiles(),
+        this.getUnstagedFiles()
+      ]);
+      return [...committed, ...staged2, ...unstaged2];
+    }
+    const [staged, unstaged] = await Promise.all([
+      this.getStagedFiles(),
+      this.getUnstagedFiles()
+    ]);
+    return [...staged, ...unstaged];
+  }
+  getFilesSince(hash) {
+    return this.resolveFilesWithGitCommand(["diff", "--name-only", `${hash}...HEAD`]);
+  }
+  getStagedFiles() {
+    return this.resolveFilesWithGitCommand(["diff", "--cached", "--name-only"]);
+  }
+  getUnstagedFiles() {
+    return this.resolveFilesWithGitCommand([
+      "ls-files",
+      "--other",
+      "--modified",
+      "--exclude-standard"
+    ]);
+  }
+  async getRoot(cwd) {
+    const options = ["rev-parse", "--show-cdup"];
+    try {
+      const result = await execa("git", options, { cwd });
+      return resolve(cwd, result.stdout);
+    } catch {
+      return null;
+    }
+  }
+}
+
+export { VitestGit };

package/dist/{chunk-runtime-chain.44b4224d.mjs → chunk-runtime-chain.be610650.mjs}

@@ -1,11 +1,12 @@
 import util$1 from 'util';
-import { i as isObject, j as join, d as dirname, g as getCallLastIndex, s as slash, b as getNames, c as assertTypes, p as picocolors, e as getFullName, n as noop } from './chunk-mock-date.ea3b3121.mjs';
+import { i as isObject, g as getCallLastIndex, s as slash, b as getNames, c as assertTypes, d as getFullName, n as noop } from './chunk-mock-date.304e29b1.mjs';
 import * as chai$2 from 'chai';
 import { expect, AssertionError, util } from 'chai';
 import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { r as rpc } from './chunk-runtime-rpc.fc50dcc0.mjs';
+import { r as rpc } from './chunk-runtime-rpc.57586b73.mjs';
 import fs, { promises } from 'fs';
-import { a as plugins_1, f as format_1, g as getOriginalPos, b as posToNumber, n as numberToPos, l as lineSplitRE, p as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.d307e4ea.mjs';
+import { j as join, d as dirname, p as picocolors } from './chunk-constants.71e8a211.mjs';
+import { a as plugins_1, f as format_1, g as getOriginalPos, b as posToNumber, n as numberToPos, l as lineSplitRE, p as parseStacktrace, u as unifiedDiff, s as stringify, m as matcherUtils } from './chunk-utils-source-map.bbf3ad19.mjs';
 import { g as getWorkerState } from './chunk-utils-global.fa20c2f6.mjs';
 import { isMockFunction } from './spy.mjs';
 import { s as safeSetTimeout, a as safeClearTimeout } from './chunk-utils-timers.b48455ed.mjs';