vitest 0.32.4 → 0.34.0

package/dist/{vendor-cli-api.cb31e1db.js → vendor-node.00226ab1.js}

@@ -1,37 +1,37 @@
-import { resolve as resolve$2, relative, isAbsolute, dirname, basename, normalize, join, extname, toNamespacedPath } from 'pathe';
-import { E as EXIT_CODE_RESTART, c as configFiles, d as defaultPort, a as defaultBrowserPort, w as workspacesFiles, C as CONFIG_NAMES } from './vendor-constants.538d9b49.js';
-import { g as getCoverageProvider, C as CoverageProviderMap } from './vendor-coverage.2e41927a.js';
-import { g as getEnvPackageName } from './vendor-environments.75f2b63d.js';
-import url, { fileURLToPath, pathToFileURL } from 'node:url';
-import c from 'picocolors';
-import { isPackageExists, resolveModule } from 'local-pkg';
-import { a as isNode, b as relativePath, c as removeUndefinedValues, d as isWindows } from './vendor-index.23ac4e13.js';
-import { isCI } from 'std-env';
+import { resolve, relative, isAbsolute, dirname, basename, normalize, join, extname, toNamespacedPath } from 'pathe';
 import { loadConfigFromFile, createServer, version as version$2, mergeConfig } from 'vite';
 import path$a from 'node:path';
+import url, { fileURLToPath, pathToFileURL } from 'node:url';
 import process$1 from 'node:process';
 import fs$8, { promises, existsSync, readFileSync } from 'node:fs';
+import { E as EXIT_CODE_RESTART, c as configFiles, d as defaultPort, a as defaultBrowserPort, w as workspacesFiles, C as CONFIG_NAMES } from './vendor-constants.538d9b49.js';
 import { g as getDefaultExportFromCjs, c as commonjsGlobal } from './vendor-_commonjsHelpers.7d1333e8.js';
-import f$1 from 'path';
 import require$$0 from 'os';
+import f$1 from 'path';
 import require$$2 from 'util';
 import require$$0$1 from 'stream';
 import require$$2$1 from 'events';
 import $ from 'fs';
+import c from 'picocolors';
 import { slash as slash$2, normalizeRequestId, cleanUrl } from 'vite-node/utils';
 import { ViteNodeRunner } from 'vite-node/client';
 import { SnapshotManager } from '@vitest/snapshot/manager';
 import { ViteNodeServer } from 'vite-node/server';
+import { a as isNode, r as relativePath, b as removeUndefinedValues, c as isWindows } from './vendor-index.087d1af7.js';
+import { g as getCoverageProvider, C as CoverageProviderMap } from './vendor-coverage.78040316.js';
 import { d as distDir, r as rootDir } from './vendor-paths.84fc7a99.js';
 import v8 from 'node:v8';
 import { fork } from 'node:child_process';
-import { a as groupBy, b as getEnvironmentTransformMode, c as createBirpc, A as AggregateErrorPonyfill, s as slash$1, t as toArray, i as isPrimitive, d as deepMerge, n as noop$1, e as stdout } from './vendor-index.cc463d9e.js';
+import { c as createBirpc } from './vendor-index.b271ebe4.js';
+import { g as groupBy, A as AggregateErrorPonyfill, s as slash$1, t as toArray, i as isPrimitive, d as deepMerge, n as noop$1, a as stdout } from './vendor-base.9c08bbd0.js';
 import { MessageChannel } from 'node:worker_threads';
-import { cpus, hostname } from 'node:os';
+import { cpus, hostname, totalmem } from 'node:os';
 import Tinypool from 'tinypool';
-import { createDefer, getSafeTimers, notNullish, parseErrorStacktrace, shuffle, stringify as stringify$5, positionToOffset, lineSplitRE } from '@vitest/utils';
+import { createDefer, getSafeTimers, notNullish, shuffle, inspect, positionToOffset, lineSplitRE } from '@vitest/utils';
+import { isPackageExists, resolveModule } from 'local-pkg';
+import { isCI } from 'std-env';
 import { performance } from 'node:perf_hooks';
-import { g as getFullName, h as hasFailedSnapshot } from './vendor-tasks.f9d75aed.js';
+import { g as getFullName, h as hasFailedSnapshot, p as parseErrorStacktrace, T as TraceMap, b as generatedPositionFor } from './vendor-source-map.e6c1997b.js';
 import { getTests, hasFailed, getSuites, generateHash, calculateSuiteHash, someTasksAreOnly, interpretTaskModes, getTasks } from '@vitest/runner/utils';
 import { createRequire, builtinModules } from 'node:module';
 import { createHash } from 'node:crypto';
@@ -42,6 +42,7 @@ import { parse as parse$4 } from 'acorn';
 import { ancestor, simple, findNodeAround } from 'acorn-walk';
 import MagicString from 'magic-string';
 import { stripLiteral } from 'strip-literal';
+import { g as getEnvPackageName } from './vendor-environments.443ecd82.js';
 import readline from 'node:readline';
 import require$$0$2 from 'readline';
 
@@ -60,15 +61,13 @@ function _mergeNamespaces(n, m) {
   return Object.freeze(n);
 }
 
-var version$1 = "0.32.4";
+var version$1 = "0.34.0";
 
 const __dirname$1 = url.fileURLToPath(new URL(".", import.meta.url));
-async function ensurePackageInstalled(dependency, root, errorMessage) {
+async function ensurePackageInstalled(dependency, root) {
   if (isPackageExists(dependency, { paths: [root, __dirname$1] }))
     return true;
   const promptInstall = !isCI && process.stdout.isTTY;
-  if (errorMessage)
-    process.stderr.write(c.red(errorMessage));
   process.stderr.write(c.red(`${c.inverse(c.red(" MISSING DEP "))} Can not find dependency '${dependency}'
 
 `));
@@ -81,7 +80,7 @@ async function ensurePackageInstalled(dependency, root, errorMessage) {
     message: c.reset(`Do you want to install ${c.green(dependency)}?`)
   });
   if (install) {
-    await (await import('./chunk-install-pkg.3fc886f2.js')).installPackage(dependency, { dev: true });
+    await (await import('./chunk-install-pkg.dd70081b.js')).installPackage(dependency, { dev: true });
     process.stderr.write(c.yellow(`
 Package ${dependency} installed, re-run the command to start.
 `));
@@ -374,92 +373,127 @@ var utils$k = {};
 
 var array$1 = {};
 
-Object.defineProperty(array$1, "__esModule", { value: true });
-array$1.splitWhen = array$1.flatten = void 0;
-function flatten(items) {
-    return items.reduce((collection, item) => [].concat(collection, item), []);
-}
-array$1.flatten = flatten;
-function splitWhen(items, predicate) {
-    const result = [[]];
-    let groupIndex = 0;
-    for (const item of items) {
-        if (predicate(item)) {
-            groupIndex++;
-            result[groupIndex] = [];
-        }
-        else {
-            result[groupIndex].push(item);
-        }
-    }
-    return result;
-}
+Object.defineProperty(array$1, "__esModule", { value: true });
+array$1.splitWhen = array$1.flatten = void 0;
+function flatten(items) {
+    return items.reduce((collection, item) => [].concat(collection, item), []);
+}
+array$1.flatten = flatten;
+function splitWhen(items, predicate) {
+    const result = [[]];
+    let groupIndex = 0;
+    for (const item of items) {
+        if (predicate(item)) {
+            groupIndex++;
+            result[groupIndex] = [];
+        }
+        else {
+            result[groupIndex].push(item);
+        }
+    }
+    return result;
+}
 array$1.splitWhen = splitWhen;
 
 var errno$1 = {};
 
-Object.defineProperty(errno$1, "__esModule", { value: true });
-errno$1.isEnoentCodeError = void 0;
-function isEnoentCodeError(error) {
-    return error.code === 'ENOENT';
-}
+Object.defineProperty(errno$1, "__esModule", { value: true });
+errno$1.isEnoentCodeError = void 0;
+function isEnoentCodeError(error) {
+    return error.code === 'ENOENT';
+}
 errno$1.isEnoentCodeError = isEnoentCodeError;
 
 var fs$7 = {};
 
-Object.defineProperty(fs$7, "__esModule", { value: true });
-fs$7.createDirentFromStats = void 0;
-let DirentFromStats$1 = class DirentFromStats {
-    constructor(name, stats) {
-        this.name = name;
-        this.isBlockDevice = stats.isBlockDevice.bind(stats);
-        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
-        this.isDirectory = stats.isDirectory.bind(stats);
-        this.isFIFO = stats.isFIFO.bind(stats);
-        this.isFile = stats.isFile.bind(stats);
-        this.isSocket = stats.isSocket.bind(stats);
-        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
-    }
-};
-function createDirentFromStats$1(name, stats) {
-    return new DirentFromStats$1(name, stats);
-}
+Object.defineProperty(fs$7, "__esModule", { value: true });
+fs$7.createDirentFromStats = void 0;
+let DirentFromStats$1 = class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+};
+function createDirentFromStats$1(name, stats) {
+    return new DirentFromStats$1(name, stats);
+}
 fs$7.createDirentFromStats = createDirentFromStats$1;
 
 var path$9 = {};
 
-Object.defineProperty(path$9, "__esModule", { value: true });
-path$9.removeLeadingDotSegment = path$9.escape = path$9.makeAbsolute = path$9.unixify = void 0;
-const path$8 = f$1;
-const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
-const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
-/**
- * Designed to work only with simple paths: `dir\\file`.
- */
-function unixify(filepath) {
-    return filepath.replace(/\\/g, '/');
-}
-path$9.unixify = unixify;
-function makeAbsolute(cwd, filepath) {
-    return path$8.resolve(cwd, filepath);
-}
-path$9.makeAbsolute = makeAbsolute;
-function escape(pattern) {
-    return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
-}
-path$9.escape = escape;
-function removeLeadingDotSegment(entry) {
-    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
-    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
-    if (entry.charAt(0) === '.') {
-        const secondCharactery = entry.charAt(1);
-        if (secondCharactery === '/' || secondCharactery === '\\') {
-            return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
-        }
-    }
-    return entry;
-}
+Object.defineProperty(path$9, "__esModule", { value: true });
+path$9.convertPosixPathToPattern = path$9.convertWindowsPathToPattern = path$9.convertPathToPattern = path$9.escapePosixPath = path$9.escapeWindowsPath = path$9.escape = path$9.removeLeadingDotSegment = path$9.makeAbsolute = path$9.unixify = void 0;
+const os = require$$0;
+const path$8 = f$1;
+const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
+const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
+/**
+ * All non-escaped special characters.
+ * Posix: ()*?[\]{|}, !+@ before (, ! at the beginning, \\ before non-special characters.
+ * Windows: (){}, !+@ before (, ! at the beginning.
+ */
+const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
+const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([(){}]|^!|[!+@](?=\())/g;
+/**
+ * The device path (\\.\ or \\?\).
+ * https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
+ */
+const DOS_DEVICE_PATH_RE = /^\\\\([.?])/;
+/**
+ * All backslashes except those escaping special characters.
+ * Windows: !()+@{}
+ * https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+ */
+const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@{}])/g;
+/**
+ * Designed to work only with simple paths: `dir\\file`.
+ */
+function unixify(filepath) {
+    return filepath.replace(/\\/g, '/');
+}
+path$9.unixify = unixify;
+function makeAbsolute(cwd, filepath) {
+    return path$8.resolve(cwd, filepath);
+}
+path$9.makeAbsolute = makeAbsolute;
+function removeLeadingDotSegment(entry) {
+    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+    if (entry.charAt(0) === '.') {
+        const secondCharactery = entry.charAt(1);
+        if (secondCharactery === '/' || secondCharactery === '\\') {
+            return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+        }
+    }
+    return entry;
+}
 path$9.removeLeadingDotSegment = removeLeadingDotSegment;
+path$9.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
+function escapeWindowsPath(pattern) {
+    return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$9.escapeWindowsPath = escapeWindowsPath;
+function escapePosixPath(pattern) {
+    return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$9.escapePosixPath = escapePosixPath;
+path$9.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
+function convertWindowsPathToPattern(filepath) {
+    return escapeWindowsPath(filepath)
+        .replace(DOS_DEVICE_PATH_RE, '//$1')
+        .replace(WINDOWS_BACKSLASHES_RE, '/');
+}
+path$9.convertWindowsPathToPattern = convertWindowsPathToPattern;
+function convertPosixPathToPattern(filepath) {
+    return escapePosixPath(filepath);
+}
+path$9.convertPosixPathToPattern = convertPosixPathToPattern;
 
 var pattern$1 = {};
 
@@ -492,7 +526,7 @@ var isExtglob$1 = function isExtglob(str) {
  */
 
 var isExtglob = isExtglob$1;
-var chars$1 = { '{': '}', '(': ')', '[': ']'};
+var chars = { '{': '}', '(': ')', '[': ']'};
 var strictCheck = function(str) {
   if (str[0] === '!') {
     return true;
@@ -565,7 +599,7 @@ var strictCheck = function(str) {
     if (str[index] === '\\') {
       var open = str[index + 1];
       index += 2;
-      var close = chars$1[open];
+      var close = chars[open];
 
       if (close) {
         var n = str.indexOf(close, index);
@@ -597,7 +631,7 @@ var relaxedCheck = function(str) {
     if (str[index] === '\\') {
       var open = str[index + 1];
       index += 2;
-      var close = chars$1[open];
+      var close = chars[open];
 
       if (close) {
         var n = str.indexOf(close, index);
@@ -1138,7 +1172,7 @@ const toRegexRange = toRegexRange_1;
 
 const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 
-const transform$1 = toNumber => {
+const transform = toNumber => {
   return value => toNumber === true ? Number(value) : String(value);
 };
 
@@ -1275,7 +1309,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
   let padded = zeros(startString) || zeros(endString) || zeros(stepString);
   let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
   let toNumber = padded === false && stringify$3(start, end, options) === false;
-  let format = options.transform || transform$1(toNumber);
+  let format = options.transform || transform(toNumber);
 
   if (options.toRegex && step === 1) {
     return toRange(toMaxLen(start, maxLen), toMaxLen(end, maxLen), true, options);
@@ -4633,174 +4667,193 @@ var micromatch_1 = micromatch$1;
 
 var mm = /*@__PURE__*/getDefaultExportFromCjs(micromatch_1);
 
-Object.defineProperty(pattern$1, "__esModule", { value: true });
-pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
-const path$5 = f$1;
-const globParent = globParent$1;
-const micromatch = micromatch_1;
-const GLOBSTAR = '**';
-const ESCAPE_SYMBOL = '\\';
-const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
-const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
-const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
-const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
-const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
-function isStaticPattern(pattern, options = {}) {
-    return !isDynamicPattern(pattern, options);
-}
-pattern$1.isStaticPattern = isStaticPattern;
-function isDynamicPattern(pattern, options = {}) {
-    /**
-     * A special case with an empty string is necessary for matching patterns that start with a forward slash.
-     * An empty string cannot be a dynamic pattern.
-     * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
-     */
-    if (pattern === '') {
-        return false;
-    }
-    /**
-     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
-     * filepath directly (without read directory).
-     */
-    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
-        return true;
-    }
-    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
-        return true;
-    }
-    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
-        return true;
-    }
-    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
-        return true;
-    }
-    return false;
-}
-pattern$1.isDynamicPattern = isDynamicPattern;
-function hasBraceExpansion(pattern) {
-    const openingBraceIndex = pattern.indexOf('{');
-    if (openingBraceIndex === -1) {
-        return false;
-    }
-    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
-    if (closingBraceIndex === -1) {
-        return false;
-    }
-    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
-    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
-}
-function convertToPositivePattern(pattern) {
-    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
-}
-pattern$1.convertToPositivePattern = convertToPositivePattern;
-function convertToNegativePattern(pattern) {
-    return '!' + pattern;
-}
-pattern$1.convertToNegativePattern = convertToNegativePattern;
-function isNegativePattern(pattern) {
-    return pattern.startsWith('!') && pattern[1] !== '(';
-}
-pattern$1.isNegativePattern = isNegativePattern;
-function isPositivePattern(pattern) {
-    return !isNegativePattern(pattern);
-}
-pattern$1.isPositivePattern = isPositivePattern;
-function getNegativePatterns(patterns) {
-    return patterns.filter(isNegativePattern);
-}
-pattern$1.getNegativePatterns = getNegativePatterns;
-function getPositivePatterns$1(patterns) {
-    return patterns.filter(isPositivePattern);
-}
-pattern$1.getPositivePatterns = getPositivePatterns$1;
-/**
- * Returns patterns that can be applied inside the current directory.
- *
- * @example
- * // ['./*', '*', 'a/*']
- * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
- */
-function getPatternsInsideCurrentDirectory(patterns) {
-    return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
-}
-pattern$1.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
-/**
- * Returns patterns to be expanded relative to (outside) the current directory.
- *
- * @example
- * // ['../*', './../*']
- * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
- */
-function getPatternsOutsideCurrentDirectory(patterns) {
-    return patterns.filter(isPatternRelatedToParentDirectory);
-}
-pattern$1.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
-function isPatternRelatedToParentDirectory(pattern) {
-    return pattern.startsWith('..') || pattern.startsWith('./..');
-}
-pattern$1.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
-function getBaseDirectory(pattern) {
-    return globParent(pattern, { flipBackslashes: false });
-}
-pattern$1.getBaseDirectory = getBaseDirectory;
-function hasGlobStar(pattern) {
-    return pattern.includes(GLOBSTAR);
-}
-pattern$1.hasGlobStar = hasGlobStar;
-function endsWithSlashGlobStar(pattern) {
-    return pattern.endsWith('/' + GLOBSTAR);
-}
-pattern$1.endsWithSlashGlobStar = endsWithSlashGlobStar;
-function isAffectDepthOfReadingPattern(pattern) {
-    const basename = path$5.basename(pattern);
-    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
-}
-pattern$1.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
-function expandPatternsWithBraceExpansion(patterns) {
-    return patterns.reduce((collection, pattern) => {
-        return collection.concat(expandBraceExpansion(pattern));
-    }, []);
-}
-pattern$1.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
-function expandBraceExpansion(pattern) {
-    return micromatch.braces(pattern, {
-        expand: true,
-        nodupes: true
-    });
-}
-pattern$1.expandBraceExpansion = expandBraceExpansion;
-function getPatternParts(pattern, options) {
-    let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
-    /**
-     * The scan method returns an empty array in some cases.
-     * See micromatch/picomatch#58 for more details.
-     */
-    if (parts.length === 0) {
-        parts = [pattern];
-    }
-    /**
-     * The scan method does not return an empty part for the pattern with a forward slash.
-     * This is another part of micromatch/picomatch#58.
-     */
-    if (parts[0].startsWith('/')) {
-        parts[0] = parts[0].slice(1);
-        parts.unshift('');
-    }
-    return parts;
-}
-pattern$1.getPatternParts = getPatternParts;
-function makeRe(pattern, options) {
-    return micromatch.makeRe(pattern, options);
-}
-pattern$1.makeRe = makeRe;
-function convertPatternsToRe(patterns, options) {
-    return patterns.map((pattern) => makeRe(pattern, options));
-}
-pattern$1.convertPatternsToRe = convertPatternsToRe;
-function matchAny(entry, patternsRe) {
-    return patternsRe.some((patternRe) => patternRe.test(entry));
-}
+Object.defineProperty(pattern$1, "__esModule", { value: true });
+pattern$1.removeDuplicateSlashes = pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
+const path$5 = f$1;
+const globParent = globParent$1;
+const micromatch = micromatch_1;
+const GLOBSTAR = '**';
+const ESCAPE_SYMBOL = '\\';
+const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
+const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
+const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
+const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
+/**
+ * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
+ * The latter is due to the presence of the device path at the beginning of the UNC path.
+ */
+const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+function isStaticPattern(pattern, options = {}) {
+    return !isDynamicPattern(pattern, options);
+}
+pattern$1.isStaticPattern = isStaticPattern;
+function isDynamicPattern(pattern, options = {}) {
+    /**
+     * A special case with an empty string is necessary for matching patterns that start with a forward slash.
+     * An empty string cannot be a dynamic pattern.
+     * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
+     */
+    if (pattern === '') {
+        return false;
+    }
+    /**
+     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
+     * filepath directly (without read directory).
+     */
+    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+        return true;
+    }
+    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
+        return true;
+    }
+    return false;
+}
+pattern$1.isDynamicPattern = isDynamicPattern;
+function hasBraceExpansion(pattern) {
+    const openingBraceIndex = pattern.indexOf('{');
+    if (openingBraceIndex === -1) {
+        return false;
+    }
+    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
+    if (closingBraceIndex === -1) {
+        return false;
+    }
+    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+}
+function convertToPositivePattern(pattern) {
+    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+}
+pattern$1.convertToPositivePattern = convertToPositivePattern;
+function convertToNegativePattern(pattern) {
+    return '!' + pattern;
+}
+pattern$1.convertToNegativePattern = convertToNegativePattern;
+function isNegativePattern(pattern) {
+    return pattern.startsWith('!') && pattern[1] !== '(';
+}
+pattern$1.isNegativePattern = isNegativePattern;
+function isPositivePattern(pattern) {
+    return !isNegativePattern(pattern);
+}
+pattern$1.isPositivePattern = isPositivePattern;
+function getNegativePatterns(patterns) {
+    return patterns.filter(isNegativePattern);
+}
+pattern$1.getNegativePatterns = getNegativePatterns;
+function getPositivePatterns$1(patterns) {
+    return patterns.filter(isPositivePattern);
+}
+pattern$1.getPositivePatterns = getPositivePatterns$1;
+/**
+ * Returns patterns that can be applied inside the current directory.
+ *
+ * @example
+ * // ['./*', '*', 'a/*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsInsideCurrentDirectory(patterns) {
+    return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
+}
+pattern$1.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+/**
+ * Returns patterns to be expanded relative to (outside) the current directory.
+ *
+ * @example
+ * // ['../*', './../*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsOutsideCurrentDirectory(patterns) {
+    return patterns.filter(isPatternRelatedToParentDirectory);
+}
+pattern$1.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+function isPatternRelatedToParentDirectory(pattern) {
+    return pattern.startsWith('..') || pattern.startsWith('./..');
+}
+pattern$1.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+function getBaseDirectory(pattern) {
+    return globParent(pattern, { flipBackslashes: false });
+}
+pattern$1.getBaseDirectory = getBaseDirectory;
+function hasGlobStar(pattern) {
+    return pattern.includes(GLOBSTAR);
+}
+pattern$1.hasGlobStar = hasGlobStar;
+function endsWithSlashGlobStar(pattern) {
+    return pattern.endsWith('/' + GLOBSTAR);
+}
+pattern$1.endsWithSlashGlobStar = endsWithSlashGlobStar;
+function isAffectDepthOfReadingPattern(pattern) {
+    const basename = path$5.basename(pattern);
+    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+}
+pattern$1.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+function expandPatternsWithBraceExpansion(patterns) {
+    return patterns.reduce((collection, pattern) => {
+        return collection.concat(expandBraceExpansion(pattern));
+    }, []);
+}
+pattern$1.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+function expandBraceExpansion(pattern) {
+    const patterns = micromatch.braces(pattern, { expand: true, nodupes: true });
+    /**
+     * Sort the patterns by length so that the same depth patterns are processed side by side.
+     * `a/{b,}/{c,}/*` – `['a///*', 'a/b//*', 'a//c/*', 'a/b/c/*']`
+     */
+    patterns.sort((a, b) => a.length - b.length);
+    /**
+     * Micromatch can return an empty string in the case of patterns like `{a,}`.
+     */
+    return patterns.filter((pattern) => pattern !== '');
+}
+pattern$1.expandBraceExpansion = expandBraceExpansion;
+function getPatternParts(pattern, options) {
+    let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
+    /**
+     * The scan method returns an empty array in some cases.
+     * See micromatch/picomatch#58 for more details.
+     */
+    if (parts.length === 0) {
+        parts = [pattern];
+    }
+    /**
+     * The scan method does not return an empty part for the pattern with a forward slash.
+     * This is another part of micromatch/picomatch#58.
+     */
+    if (parts[0].startsWith('/')) {
+        parts[0] = parts[0].slice(1);
+        parts.unshift('');
+    }
+    return parts;
+}
+pattern$1.getPatternParts = getPatternParts;
+function makeRe(pattern, options) {
+    return micromatch.makeRe(pattern, options);
+}
+pattern$1.makeRe = makeRe;
+function convertPatternsToRe(patterns, options) {
+    return patterns.map((pattern) => makeRe(pattern, options));
+}
+pattern$1.convertPatternsToRe = convertPatternsToRe;
+function matchAny(entry, patternsRe) {
+    return patternsRe.some((patternRe) => patternRe.test(entry));
+}
 pattern$1.matchAny = matchAny;
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+function removeDuplicateSlashes(pattern) {
+    return pattern.replace(DOUBLE_SLASH_RE, '/');
+}
+pattern$1.removeDuplicateSlashes = removeDuplicateSlashes;
 
 var stream$4 = {};
 
@@ -4948,156 +5001,163 @@ function pauseStreams (streams, options) {
   return streams
 }
 
-Object.defineProperty(stream$4, "__esModule", { value: true });
-stream$4.merge = void 0;
-const merge2 = merge2_1;
-function merge(streams) {
-    const mergedStream = merge2(streams);
-    streams.forEach((stream) => {
-        stream.once('error', (error) => mergedStream.emit('error', error));
-    });
-    mergedStream.once('close', () => propagateCloseEventToSources(streams));
-    mergedStream.once('end', () => propagateCloseEventToSources(streams));
-    return mergedStream;
-}
-stream$4.merge = merge;
-function propagateCloseEventToSources(streams) {
-    streams.forEach((stream) => stream.emit('close'));
+Object.defineProperty(stream$4, "__esModule", { value: true });
+stream$4.merge = void 0;
+const merge2 = merge2_1;
+function merge(streams) {
+    const mergedStream = merge2(streams);
+    streams.forEach((stream) => {
+        stream.once('error', (error) => mergedStream.emit('error', error));
+    });
+    mergedStream.once('close', () => propagateCloseEventToSources(streams));
+    mergedStream.once('end', () => propagateCloseEventToSources(streams));
+    return mergedStream;
+}
+stream$4.merge = merge;
+function propagateCloseEventToSources(streams) {
+    streams.forEach((stream) => stream.emit('close'));
 }
 
 var string$1 = {};
 
-Object.defineProperty(string$1, "__esModule", { value: true });
-string$1.isEmpty = string$1.isString = void 0;
-function isString(input) {
-    return typeof input === 'string';
-}
-string$1.isString = isString;
-function isEmpty(input) {
-    return input === '';
-}
+Object.defineProperty(string$1, "__esModule", { value: true });
+string$1.isEmpty = string$1.isString = void 0;
+function isString(input) {
+    return typeof input === 'string';
+}
+string$1.isString = isString;
+function isEmpty(input) {
+    return input === '';
+}
 string$1.isEmpty = isEmpty;
 
-Object.defineProperty(utils$k, "__esModule", { value: true });
-utils$k.string = utils$k.stream = utils$k.pattern = utils$k.path = utils$k.fs = utils$k.errno = utils$k.array = void 0;
-const array = array$1;
-utils$k.array = array;
-const errno = errno$1;
-utils$k.errno = errno;
-const fs$6 = fs$7;
-utils$k.fs = fs$6;
-const path$4 = path$9;
-utils$k.path = path$4;
-const pattern = pattern$1;
-utils$k.pattern = pattern;
-const stream$3 = stream$4;
-utils$k.stream = stream$3;
-const string = string$1;
+Object.defineProperty(utils$k, "__esModule", { value: true });
+utils$k.string = utils$k.stream = utils$k.pattern = utils$k.path = utils$k.fs = utils$k.errno = utils$k.array = void 0;
+const array = array$1;
+utils$k.array = array;
+const errno = errno$1;
+utils$k.errno = errno;
+const fs$6 = fs$7;
+utils$k.fs = fs$6;
+const path$4 = path$9;
+utils$k.path = path$4;
+const pattern = pattern$1;
+utils$k.pattern = pattern;
+const stream$3 = stream$4;
+utils$k.stream = stream$3;
+const string = string$1;
 utils$k.string = string;
 
-Object.defineProperty(tasks, "__esModule", { value: true });
-tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
-const utils$a = utils$k;
-function generate(patterns, settings) {
-    const positivePatterns = getPositivePatterns(patterns);
-    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
-    const staticPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isStaticPattern(pattern, settings));
-    const dynamicPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isDynamicPattern(pattern, settings));
-    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
-    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
-    return staticTasks.concat(dynamicTasks);
-}
-tasks.generate = generate;
-/**
- * Returns tasks grouped by basic pattern directories.
- *
- * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
- * This is necessary because directory traversal starts at the base directory and goes deeper.
- */
-function convertPatternsToTasks(positive, negative, dynamic) {
-    const tasks = [];
-    const patternsOutsideCurrentDirectory = utils$a.pattern.getPatternsOutsideCurrentDirectory(positive);
-    const patternsInsideCurrentDirectory = utils$a.pattern.getPatternsInsideCurrentDirectory(positive);
-    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
-    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-    /*
-     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
-     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
-     */
-    if ('.' in insideCurrentDirectoryGroup) {
-        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
-    }
-    else {
-        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
-    }
-    return tasks;
-}
-tasks.convertPatternsToTasks = convertPatternsToTasks;
-function getPositivePatterns(patterns) {
-    return utils$a.pattern.getPositivePatterns(patterns);
-}
-tasks.getPositivePatterns = getPositivePatterns;
-function getNegativePatternsAsPositive(patterns, ignore) {
-    const negative = utils$a.pattern.getNegativePatterns(patterns).concat(ignore);
-    const positive = negative.map(utils$a.pattern.convertToPositivePattern);
-    return positive;
-}
-tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
-function groupPatternsByBaseDirectory(patterns) {
-    const group = {};
-    return patterns.reduce((collection, pattern) => {
-        const base = utils$a.pattern.getBaseDirectory(pattern);
-        if (base in collection) {
-            collection[base].push(pattern);
-        }
-        else {
-            collection[base] = [pattern];
-        }
-        return collection;
-    }, group);
-}
-tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
-function convertPatternGroupsToTasks(positive, negative, dynamic) {
-    return Object.keys(positive).map((base) => {
-        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
-    });
-}
-tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
-function convertPatternGroupToTask(base, positive, negative, dynamic) {
-    return {
-        dynamic,
-        positive,
-        negative,
-        base,
-        patterns: [].concat(positive, negative.map(utils$a.pattern.convertToNegativePattern))
-    };
-}
+Object.defineProperty(tasks, "__esModule", { value: true });
+tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
+const utils$a = utils$k;
+function generate(input, settings) {
+    const patterns = processPatterns(input, settings);
+    const ignore = processPatterns(settings.ignore, settings);
+    const positivePatterns = getPositivePatterns(patterns);
+    const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
+    const staticPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isStaticPattern(pattern, settings));
+    const dynamicPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isDynamicPattern(pattern, settings));
+    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
+    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
+    return staticTasks.concat(dynamicTasks);
+}
+tasks.generate = generate;
+function processPatterns(input, settings) {
+    let patterns = input;
+    /**
+     * The original pattern like `{,*,**,a/*}` can lead to problems checking the depth when matching entry
+     * and some problems with the micromatch package (see fast-glob issues: #365, #394).
+     *
+     * To solve this problem, we expand all patterns containing brace expansion. This can lead to a slight slowdown
+     * in matching in the case of a large set of patterns after expansion.
+     */
+    if (settings.braceExpansion) {
+        patterns = utils$a.pattern.expandPatternsWithBraceExpansion(patterns);
+    }
+    /**
+     * If the `baseNameMatch` option is enabled, we must add globstar to patterns, so that they can be used
+     * at any nesting level.
+     *
+     * We do this here, because otherwise we have to complicate the filtering logic. For example, we need to change
+     * the pattern in the filter before creating a regular expression. There is no need to change the patterns
+     * in the application. Only on the input.
+     */
+    if (settings.baseNameMatch) {
+        patterns = patterns.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`);
+    }
+    /**
+     * This method also removes duplicate slashes that may have been in the pattern or formed as a result of expansion.
+     */
+    return patterns.map((pattern) => utils$a.pattern.removeDuplicateSlashes(pattern));
+}
+/**
+ * Returns tasks grouped by basic pattern directories.
+ *
+ * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
+ * This is necessary because directory traversal starts at the base directory and goes deeper.
+ */
+function convertPatternsToTasks(positive, negative, dynamic) {
+    const tasks = [];
+    const patternsOutsideCurrentDirectory = utils$a.pattern.getPatternsOutsideCurrentDirectory(positive);
+    const patternsInsideCurrentDirectory = utils$a.pattern.getPatternsInsideCurrentDirectory(positive);
+    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
+    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
+    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
+    /*
+     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
+     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
+     */
+    if ('.' in insideCurrentDirectoryGroup) {
+        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
+    }
+    else {
+        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
+    }
+    return tasks;
+}
+tasks.convertPatternsToTasks = convertPatternsToTasks;
+function getPositivePatterns(patterns) {
+    return utils$a.pattern.getPositivePatterns(patterns);
+}
+tasks.getPositivePatterns = getPositivePatterns;
+function getNegativePatternsAsPositive(patterns, ignore) {
+    const negative = utils$a.pattern.getNegativePatterns(patterns).concat(ignore);
+    const positive = negative.map(utils$a.pattern.convertToPositivePattern);
+    return positive;
+}
+tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
+function groupPatternsByBaseDirectory(patterns) {
+    const group = {};
+    return patterns.reduce((collection, pattern) => {
+        const base = utils$a.pattern.getBaseDirectory(pattern);
+        if (base in collection) {
+            collection[base].push(pattern);
+        }
+        else {
+            collection[base] = [pattern];
+        }
+        return collection;
+    }, group);
+}
+tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
+function convertPatternGroupsToTasks(positive, negative, dynamic) {
+    return Object.keys(positive).map((base) => {
+        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
+    });
+}
+tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
+function convertPatternGroupToTask(base, positive, negative, dynamic) {
+    return {
+        dynamic,
+        positive,
+        negative,
+        base,
+        patterns: [].concat(positive, negative.map(utils$a.pattern.convertToNegativePattern))
+    };
+}
 tasks.convertPatternGroupToTask = convertPatternGroupToTask;
 
-var patterns = {};
-
-Object.defineProperty(patterns, "__esModule", { value: true });
-patterns.removeDuplicateSlashes = patterns.transform = void 0;
-/**
- * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
- * The latter is due to the presence of the device path at the beginning of the UNC path.
- * @todo rewrite to negative lookbehind with the next major release.
- */
-const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
-function transform(patterns) {
-    return patterns.map((pattern) => removeDuplicateSlashes(pattern));
-}
-patterns.transform = transform;
-/**
- * This package only works with forward slashes as a path separator.
- * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
- */
-function removeDuplicateSlashes(pattern) {
-    return pattern.replace(DOUBLE_SLASH_RE, '/');
-}
-patterns.removeDuplicateSlashes = removeDuplicateSlashes;
-
 var async$7 = {};
 
 var async$6 = {};
@@ -6271,129 +6331,129 @@ function getSettings(settingsOrOptions = {}) {
 
 var reader = {};
 
-Object.defineProperty(reader, "__esModule", { value: true });
-const path$1 = f$1;
-const fsStat$2 = out$1;
-const utils$6 = utils$k;
-class Reader {
-    constructor(_settings) {
-        this._settings = _settings;
-        this._fsStatSettings = new fsStat$2.Settings({
-            followSymbolicLink: this._settings.followSymbolicLinks,
-            fs: this._settings.fs,
-            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
-        });
-    }
-    _getFullEntryPath(filepath) {
-        return path$1.resolve(this._settings.cwd, filepath);
-    }
-    _makeEntry(stats, pattern) {
-        const entry = {
-            name: pattern,
-            path: pattern,
-            dirent: utils$6.fs.createDirentFromStats(pattern, stats)
-        };
-        if (this._settings.stats) {
-            entry.stats = stats;
-        }
-        return entry;
-    }
-    _isFatalError(error) {
-        return !utils$6.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
-    }
-}
+Object.defineProperty(reader, "__esModule", { value: true });
+const path$1 = f$1;
+const fsStat$2 = out$1;
+const utils$6 = utils$k;
+class Reader {
+    constructor(_settings) {
+        this._settings = _settings;
+        this._fsStatSettings = new fsStat$2.Settings({
+            followSymbolicLink: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+        });
+    }
+    _getFullEntryPath(filepath) {
+        return path$1.resolve(this._settings.cwd, filepath);
+    }
+    _makeEntry(stats, pattern) {
+        const entry = {
+            name: pattern,
+            path: pattern,
+            dirent: utils$6.fs.createDirentFromStats(pattern, stats)
+        };
+        if (this._settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    }
+    _isFatalError(error) {
+        return !utils$6.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+    }
+}
 reader.default = Reader;
 
 var stream$1 = {};
 
-Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$3 = require$$0$1;
-const fsStat$1 = out$1;
-const fsWalk$2 = out$3;
-const reader_1$2 = reader;
-class ReaderStream extends reader_1$2.default {
-    constructor() {
-        super(...arguments);
-        this._walkStream = fsWalk$2.walkStream;
-        this._stat = fsStat$1.stat;
-    }
-    dynamic(root, options) {
-        return this._walkStream(root, options);
-    }
-    static(patterns, options) {
-        const filepaths = patterns.map(this._getFullEntryPath, this);
-        const stream = new stream_1$3.PassThrough({ objectMode: true });
-        stream._write = (index, _enc, done) => {
-            return this._getEntry(filepaths[index], patterns[index], options)
-                .then((entry) => {
-                if (entry !== null && options.entryFilter(entry)) {
-                    stream.push(entry);
-                }
-                if (index === filepaths.length - 1) {
-                    stream.end();
-                }
-                done();
-            })
-                .catch(done);
-        };
-        for (let i = 0; i < filepaths.length; i++) {
-            stream.write(i);
-        }
-        return stream;
-    }
-    _getEntry(filepath, pattern, options) {
-        return this._getStat(filepath)
-            .then((stats) => this._makeEntry(stats, pattern))
-            .catch((error) => {
-            if (options.errorFilter(error)) {
-                return null;
-            }
-            throw error;
-        });
-    }
-    _getStat(filepath) {
-        return new Promise((resolve, reject) => {
-            this._stat(filepath, this._fsStatSettings, (error, stats) => {
-                return error === null ? resolve(stats) : reject(error);
-            });
-        });
-    }
-}
+Object.defineProperty(stream$1, "__esModule", { value: true });
+const stream_1$3 = require$$0$1;
+const fsStat$1 = out$1;
+const fsWalk$2 = out$3;
+const reader_1$2 = reader;
+class ReaderStream extends reader_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._walkStream = fsWalk$2.walkStream;
+        this._stat = fsStat$1.stat;
+    }
+    dynamic(root, options) {
+        return this._walkStream(root, options);
+    }
+    static(patterns, options) {
+        const filepaths = patterns.map(this._getFullEntryPath, this);
+        const stream = new stream_1$3.PassThrough({ objectMode: true });
+        stream._write = (index, _enc, done) => {
+            return this._getEntry(filepaths[index], patterns[index], options)
+                .then((entry) => {
+                if (entry !== null && options.entryFilter(entry)) {
+                    stream.push(entry);
+                }
+                if (index === filepaths.length - 1) {
+                    stream.end();
+                }
+                done();
+            })
+                .catch(done);
+        };
+        for (let i = 0; i < filepaths.length; i++) {
+            stream.write(i);
+        }
+        return stream;
+    }
+    _getEntry(filepath, pattern, options) {
+        return this._getStat(filepath)
+            .then((stats) => this._makeEntry(stats, pattern))
+            .catch((error) => {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        });
+    }
+    _getStat(filepath) {
+        return new Promise((resolve, reject) => {
+            this._stat(filepath, this._fsStatSettings, (error, stats) => {
+                return error === null ? resolve(stats) : reject(error);
+            });
+        });
+    }
+}
 stream$1.default = ReaderStream;
 
-Object.defineProperty(async$6, "__esModule", { value: true });
-const fsWalk$1 = out$3;
-const reader_1$1 = reader;
-const stream_1$2 = stream$1;
-class ReaderAsync extends reader_1$1.default {
-    constructor() {
-        super(...arguments);
-        this._walkAsync = fsWalk$1.walk;
-        this._readerStream = new stream_1$2.default(this._settings);
-    }
-    dynamic(root, options) {
-        return new Promise((resolve, reject) => {
-            this._walkAsync(root, options, (error, entries) => {
-                if (error === null) {
-                    resolve(entries);
-                }
-                else {
-                    reject(error);
-                }
-            });
-        });
-    }
-    async static(patterns, options) {
-        const entries = [];
-        const stream = this._readerStream.static(patterns, options);
-        // After #235, replace it with an asynchronous iterator.
-        return new Promise((resolve, reject) => {
-            stream.once('error', reject);
-            stream.on('data', (entry) => entries.push(entry));
-            stream.once('end', () => resolve(entries));
-        });
-    }
-}
+Object.defineProperty(async$6, "__esModule", { value: true });
+const fsWalk$1 = out$3;
+const reader_1$1 = reader;
+const stream_1$2 = stream$1;
+class ReaderAsync extends reader_1$1.default {
+    constructor() {
+        super(...arguments);
+        this._walkAsync = fsWalk$1.walk;
+        this._readerStream = new stream_1$2.default(this._settings);
+    }
+    dynamic(root, options) {
+        return new Promise((resolve, reject) => {
+            this._walkAsync(root, options, (error, entries) => {
+                if (error === null) {
+                    resolve(entries);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async static(patterns, options) {
+        const entries = [];
+        const stream = this._readerStream.static(patterns, options);
+        // After #235, replace it with an asynchronous iterator.
+        return new Promise((resolve, reject) => {
+            stream.once('error', reject);
+            stream.on('data', (entry) => entries.push(entry));
+            stream.once('end', () => resolve(entries));
+        });
+    }
+}
 async$6.default = ReaderAsync;
 
 var provider = {};
@@ -6404,568 +6464,594 @@ var partial = {};
 
 var matcher = {};
 
-Object.defineProperty(matcher, "__esModule", { value: true });
-const utils$5 = utils$k;
-class Matcher {
-    constructor(_patterns, _settings, _micromatchOptions) {
-        this._patterns = _patterns;
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-        this._storage = [];
-        this._fillStorage();
-    }
-    _fillStorage() {
-        /**
-         * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).
-         * So, before expand patterns with brace expansion into separated patterns.
-         */
-        const patterns = utils$5.pattern.expandPatternsWithBraceExpansion(this._patterns);
-        for (const pattern of patterns) {
-            const segments = this._getPatternSegments(pattern);
-            const sections = this._splitSegmentsIntoSections(segments);
-            this._storage.push({
-                complete: sections.length <= 1,
-                pattern,
-                segments,
-                sections
-            });
-        }
-    }
-    _getPatternSegments(pattern) {
-        const parts = utils$5.pattern.getPatternParts(pattern, this._micromatchOptions);
-        return parts.map((part) => {
-            const dynamic = utils$5.pattern.isDynamicPattern(part, this._settings);
-            if (!dynamic) {
-                return {
-                    dynamic: false,
-                    pattern: part
-                };
-            }
-            return {
-                dynamic: true,
-                pattern: part,
-                patternRe: utils$5.pattern.makeRe(part, this._micromatchOptions)
-            };
-        });
-    }
-    _splitSegmentsIntoSections(segments) {
-        return utils$5.array.splitWhen(segments, (segment) => segment.dynamic && utils$5.pattern.hasGlobStar(segment.pattern));
-    }
-}
+Object.defineProperty(matcher, "__esModule", { value: true });
+const utils$5 = utils$k;
+class Matcher {
+    constructor(_patterns, _settings, _micromatchOptions) {
+        this._patterns = _patterns;
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+        this._storage = [];
+        this._fillStorage();
+    }
+    _fillStorage() {
+        for (const pattern of this._patterns) {
+            const segments = this._getPatternSegments(pattern);
+            const sections = this._splitSegmentsIntoSections(segments);
+            this._storage.push({
+                complete: sections.length <= 1,
+                pattern,
+                segments,
+                sections
+            });
+        }
+    }
+    _getPatternSegments(pattern) {
+        const parts = utils$5.pattern.getPatternParts(pattern, this._micromatchOptions);
+        return parts.map((part) => {
+            const dynamic = utils$5.pattern.isDynamicPattern(part, this._settings);
+            if (!dynamic) {
+                return {
+                    dynamic: false,
+                    pattern: part
+                };
+            }
+            return {
+                dynamic: true,
+                pattern: part,
+                patternRe: utils$5.pattern.makeRe(part, this._micromatchOptions)
+            };
+        });
+    }
+    _splitSegmentsIntoSections(segments) {
+        return utils$5.array.splitWhen(segments, (segment) => segment.dynamic && utils$5.pattern.hasGlobStar(segment.pattern));
+    }
+}
 matcher.default = Matcher;
 
-Object.defineProperty(partial, "__esModule", { value: true });
-const matcher_1 = matcher;
-class PartialMatcher extends matcher_1.default {
-    match(filepath) {
-        const parts = filepath.split('/');
-        const levels = parts.length;
-        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
-        for (const pattern of patterns) {
-            const section = pattern.sections[0];
-            /**
-             * In this case, the pattern has a globstar and we must read all directories unconditionally,
-             * but only if the level has reached the end of the first group.
-             *
-             * fixtures/{a,b}/**
-             *  ^ true/false  ^ always true
-            */
-            if (!pattern.complete && levels > section.length) {
-                return true;
-            }
-            const match = parts.every((part, index) => {
-                const segment = pattern.segments[index];
-                if (segment.dynamic && segment.patternRe.test(part)) {
-                    return true;
-                }
-                if (!segment.dynamic && segment.pattern === part) {
-                    return true;
-                }
-                return false;
-            });
-            if (match) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
+Object.defineProperty(partial, "__esModule", { value: true });
+const matcher_1 = matcher;
+class PartialMatcher extends matcher_1.default {
+    match(filepath) {
+        const parts = filepath.split('/');
+        const levels = parts.length;
+        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+        for (const pattern of patterns) {
+            const section = pattern.sections[0];
+            /**
+             * In this case, the pattern has a globstar and we must read all directories unconditionally,
+             * but only if the level has reached the end of the first group.
+             *
+             * fixtures/{a,b}/**
+             *  ^ true/false  ^ always true
+            */
+            if (!pattern.complete && levels > section.length) {
+                return true;
+            }
+            const match = parts.every((part, index) => {
+                const segment = pattern.segments[index];
+                if (segment.dynamic && segment.patternRe.test(part)) {
+                    return true;
+                }
+                if (!segment.dynamic && segment.pattern === part) {
+                    return true;
+                }
+                return false;
+            });
+            if (match) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
 partial.default = PartialMatcher;
 
-Object.defineProperty(deep, "__esModule", { value: true });
-const utils$4 = utils$k;
-const partial_1 = partial;
-class DeepFilter {
-    constructor(_settings, _micromatchOptions) {
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-    }
-    getFilter(basePath, positive, negative) {
-        const matcher = this._getMatcher(positive);
-        const negativeRe = this._getNegativePatternsRe(negative);
-        return (entry) => this._filter(basePath, entry, matcher, negativeRe);
-    }
-    _getMatcher(patterns) {
-        return new partial_1.default(patterns, this._settings, this._micromatchOptions);
-    }
-    _getNegativePatternsRe(patterns) {
-        const affectDepthOfReadingPatterns = patterns.filter(utils$4.pattern.isAffectDepthOfReadingPattern);
-        return utils$4.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
-    }
-    _filter(basePath, entry, matcher, negativeRe) {
-        if (this._isSkippedByDeep(basePath, entry.path)) {
-            return false;
-        }
-        if (this._isSkippedSymbolicLink(entry)) {
-            return false;
-        }
-        const filepath = utils$4.path.removeLeadingDotSegment(entry.path);
-        if (this._isSkippedByPositivePatterns(filepath, matcher)) {
-            return false;
-        }
-        return this._isSkippedByNegativePatterns(filepath, negativeRe);
-    }
-    _isSkippedByDeep(basePath, entryPath) {
-        /**
-         * Avoid unnecessary depth calculations when it doesn't matter.
-         */
-        if (this._settings.deep === Infinity) {
-            return false;
-        }
-        return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
-    }
-    _getEntryLevel(basePath, entryPath) {
-        const entryPathDepth = entryPath.split('/').length;
-        if (basePath === '') {
-            return entryPathDepth;
-        }
-        const basePathDepth = basePath.split('/').length;
-        return entryPathDepth - basePathDepth;
-    }
-    _isSkippedSymbolicLink(entry) {
-        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
-    }
-    _isSkippedByPositivePatterns(entryPath, matcher) {
-        return !this._settings.baseNameMatch && !matcher.match(entryPath);
-    }
-    _isSkippedByNegativePatterns(entryPath, patternsRe) {
-        return !utils$4.pattern.matchAny(entryPath, patternsRe);
-    }
-}
+Object.defineProperty(deep, "__esModule", { value: true });
+const utils$4 = utils$k;
+const partial_1 = partial;
+class DeepFilter {
+    constructor(_settings, _micromatchOptions) {
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+    }
+    getFilter(basePath, positive, negative) {
+        const matcher = this._getMatcher(positive);
+        const negativeRe = this._getNegativePatternsRe(negative);
+        return (entry) => this._filter(basePath, entry, matcher, negativeRe);
+    }
+    _getMatcher(patterns) {
+        return new partial_1.default(patterns, this._settings, this._micromatchOptions);
+    }
+    _getNegativePatternsRe(patterns) {
+        const affectDepthOfReadingPatterns = patterns.filter(utils$4.pattern.isAffectDepthOfReadingPattern);
+        return utils$4.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
+    }
+    _filter(basePath, entry, matcher, negativeRe) {
+        if (this._isSkippedByDeep(basePath, entry.path)) {
+            return false;
+        }
+        if (this._isSkippedSymbolicLink(entry)) {
+            return false;
+        }
+        const filepath = utils$4.path.removeLeadingDotSegment(entry.path);
+        if (this._isSkippedByPositivePatterns(filepath, matcher)) {
+            return false;
+        }
+        return this._isSkippedByNegativePatterns(filepath, negativeRe);
+    }
+    _isSkippedByDeep(basePath, entryPath) {
+        /**
+         * Avoid unnecessary depth calculations when it doesn't matter.
+         */
+        if (this._settings.deep === Infinity) {
+            return false;
+        }
+        return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
+    }
+    _getEntryLevel(basePath, entryPath) {
+        const entryPathDepth = entryPath.split('/').length;
+        if (basePath === '') {
+            return entryPathDepth;
+        }
+        const basePathDepth = basePath.split('/').length;
+        return entryPathDepth - basePathDepth;
+    }
+    _isSkippedSymbolicLink(entry) {
+        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
+    }
+    _isSkippedByPositivePatterns(entryPath, matcher) {
+        return !this._settings.baseNameMatch && !matcher.match(entryPath);
+    }
+    _isSkippedByNegativePatterns(entryPath, patternsRe) {
+        return !utils$4.pattern.matchAny(entryPath, patternsRe);
+    }
+}
 deep.default = DeepFilter;
 
 var entry$1 = {};
 
-Object.defineProperty(entry$1, "__esModule", { value: true });
-const utils$3 = utils$k;
-class EntryFilter {
-    constructor(_settings, _micromatchOptions) {
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-        this.index = new Map();
-    }
-    getFilter(positive, negative) {
-        const positiveRe = utils$3.pattern.convertPatternsToRe(positive, this._micromatchOptions);
-        const negativeRe = utils$3.pattern.convertPatternsToRe(negative, this._micromatchOptions);
-        return (entry) => this._filter(entry, positiveRe, negativeRe);
-    }
-    _filter(entry, positiveRe, negativeRe) {
-        if (this._settings.unique && this._isDuplicateEntry(entry)) {
-            return false;
-        }
-        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
-            return false;
-        }
-        if (this._isSkippedByAbsoluteNegativePatterns(entry.path, negativeRe)) {
-            return false;
-        }
-        const filepath = this._settings.baseNameMatch ? entry.name : entry.path;
-        const isDirectory = entry.dirent.isDirectory();
-        const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(entry.path, negativeRe, isDirectory);
-        if (this._settings.unique && isMatched) {
-            this._createIndexRecord(entry);
-        }
-        return isMatched;
-    }
-    _isDuplicateEntry(entry) {
-        return this.index.has(entry.path);
-    }
-    _createIndexRecord(entry) {
-        this.index.set(entry.path, undefined);
-    }
-    _onlyFileFilter(entry) {
-        return this._settings.onlyFiles && !entry.dirent.isFile();
-    }
-    _onlyDirectoryFilter(entry) {
-        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
-    }
-    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
-        if (!this._settings.absolute) {
-            return false;
-        }
-        const fullpath = utils$3.path.makeAbsolute(this._settings.cwd, entryPath);
-        return utils$3.pattern.matchAny(fullpath, patternsRe);
-    }
-    _isMatchToPatterns(entryPath, patternsRe, isDirectory) {
-        const filepath = utils$3.path.removeLeadingDotSegment(entryPath);
-        // Trying to match files and directories by patterns.
-        const isMatched = utils$3.pattern.matchAny(filepath, patternsRe);
-        // A pattern with a trailling slash can be used for directory matching.
-        // To apply such pattern, we need to add a tralling slash to the path.
-        if (!isMatched && isDirectory) {
-            return utils$3.pattern.matchAny(filepath + '/', patternsRe);
-        }
-        return isMatched;
-    }
-}
+Object.defineProperty(entry$1, "__esModule", { value: true });
+const utils$3 = utils$k;
+class EntryFilter {
+    constructor(_settings, _micromatchOptions) {
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+        this.index = new Map();
+    }
+    getFilter(positive, negative) {
+        const positiveRe = utils$3.pattern.convertPatternsToRe(positive, this._micromatchOptions);
+        const negativeRe = utils$3.pattern.convertPatternsToRe(negative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }));
+        return (entry) => this._filter(entry, positiveRe, negativeRe);
+    }
+    _filter(entry, positiveRe, negativeRe) {
+        const filepath = utils$3.path.removeLeadingDotSegment(entry.path);
+        if (this._settings.unique && this._isDuplicateEntry(filepath)) {
+            return false;
+        }
+        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
+            return false;
+        }
+        if (this._isSkippedByAbsoluteNegativePatterns(filepath, negativeRe)) {
+            return false;
+        }
+        const isDirectory = entry.dirent.isDirectory();
+        const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(filepath, negativeRe, isDirectory);
+        if (this._settings.unique && isMatched) {
+            this._createIndexRecord(filepath);
+        }
+        return isMatched;
+    }
+    _isDuplicateEntry(filepath) {
+        return this.index.has(filepath);
+    }
+    _createIndexRecord(filepath) {
+        this.index.set(filepath, undefined);
+    }
+    _onlyFileFilter(entry) {
+        return this._settings.onlyFiles && !entry.dirent.isFile();
+    }
+    _onlyDirectoryFilter(entry) {
+        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
+    }
+    _isSkippedByAbsoluteNegativePatterns(entryPath, patternsRe) {
+        if (!this._settings.absolute) {
+            return false;
+        }
+        const fullpath = utils$3.path.makeAbsolute(this._settings.cwd, entryPath);
+        return utils$3.pattern.matchAny(fullpath, patternsRe);
+    }
+    _isMatchToPatterns(filepath, patternsRe, isDirectory) {
+        // Trying to match files and directories by patterns.
+        const isMatched = utils$3.pattern.matchAny(filepath, patternsRe);
+        // A pattern with a trailling slash can be used for directory matching.
+        // To apply such pattern, we need to add a tralling slash to the path.
+        if (!isMatched && isDirectory) {
+            return utils$3.pattern.matchAny(filepath + '/', patternsRe);
+        }
+        return isMatched;
+    }
+}
 entry$1.default = EntryFilter;
 
 var error = {};
 
-Object.defineProperty(error, "__esModule", { value: true });
-const utils$2 = utils$k;
-class ErrorFilter {
-    constructor(_settings) {
-        this._settings = _settings;
-    }
-    getFilter() {
-        return (error) => this._isNonFatalError(error);
-    }
-    _isNonFatalError(error) {
-        return utils$2.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
-    }
-}
+Object.defineProperty(error, "__esModule", { value: true });
+const utils$2 = utils$k;
+class ErrorFilter {
+    constructor(_settings) {
+        this._settings = _settings;
+    }
+    getFilter() {
+        return (error) => this._isNonFatalError(error);
+    }
+    _isNonFatalError(error) {
+        return utils$2.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+    }
+}
 error.default = ErrorFilter;
 
 var entry = {};
 
-Object.defineProperty(entry, "__esModule", { value: true });
-const utils$1 = utils$k;
-class EntryTransformer {
-    constructor(_settings) {
-        this._settings = _settings;
-    }
-    getTransformer() {
-        return (entry) => this._transform(entry);
-    }
-    _transform(entry) {
-        let filepath = entry.path;
-        if (this._settings.absolute) {
-            filepath = utils$1.path.makeAbsolute(this._settings.cwd, filepath);
-            filepath = utils$1.path.unixify(filepath);
-        }
-        if (this._settings.markDirectories && entry.dirent.isDirectory()) {
-            filepath += '/';
-        }
-        if (!this._settings.objectMode) {
-            return filepath;
-        }
-        return Object.assign(Object.assign({}, entry), { path: filepath });
-    }
-}
+Object.defineProperty(entry, "__esModule", { value: true });
+const utils$1 = utils$k;
+class EntryTransformer {
+    constructor(_settings) {
+        this._settings = _settings;
+    }
+    getTransformer() {
+        return (entry) => this._transform(entry);
+    }
+    _transform(entry) {
+        let filepath = entry.path;
+        if (this._settings.absolute) {
+            filepath = utils$1.path.makeAbsolute(this._settings.cwd, filepath);
+            filepath = utils$1.path.unixify(filepath);
+        }
+        if (this._settings.markDirectories && entry.dirent.isDirectory()) {
+            filepath += '/';
+        }
+        if (!this._settings.objectMode) {
+            return filepath;
+        }
+        return Object.assign(Object.assign({}, entry), { path: filepath });
+    }
+}
 entry.default = EntryTransformer;
 
-Object.defineProperty(provider, "__esModule", { value: true });
-const path = f$1;
-const deep_1 = deep;
-const entry_1 = entry$1;
-const error_1 = error;
-const entry_2 = entry;
-class Provider {
-    constructor(_settings) {
-        this._settings = _settings;
-        this.errorFilter = new error_1.default(this._settings);
-        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
-        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
-        this.entryTransformer = new entry_2.default(this._settings);
-    }
-    _getRootDirectory(task) {
-        return path.resolve(this._settings.cwd, task.base);
-    }
-    _getReaderOptions(task) {
-        const basePath = task.base === '.' ? '' : task.base;
-        return {
-            basePath,
-            pathSegmentSeparator: '/',
-            concurrency: this._settings.concurrency,
-            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
-            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
-            errorFilter: this.errorFilter.getFilter(),
-            followSymbolicLinks: this._settings.followSymbolicLinks,
-            fs: this._settings.fs,
-            stats: this._settings.stats,
-            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
-            transform: this.entryTransformer.getTransformer()
-        };
-    }
-    _getMicromatchOptions() {
-        return {
-            dot: this._settings.dot,
-            matchBase: this._settings.baseNameMatch,
-            nobrace: !this._settings.braceExpansion,
-            nocase: !this._settings.caseSensitiveMatch,
-            noext: !this._settings.extglob,
-            noglobstar: !this._settings.globstar,
-            posix: true,
-            strictSlashes: false
-        };
-    }
-}
+Object.defineProperty(provider, "__esModule", { value: true });
+const path = f$1;
+const deep_1 = deep;
+const entry_1 = entry$1;
+const error_1 = error;
+const entry_2 = entry;
+class Provider {
+    constructor(_settings) {
+        this._settings = _settings;
+        this.errorFilter = new error_1.default(this._settings);
+        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+        this.entryTransformer = new entry_2.default(this._settings);
+    }
+    _getRootDirectory(task) {
+        return path.resolve(this._settings.cwd, task.base);
+    }
+    _getReaderOptions(task) {
+        const basePath = task.base === '.' ? '' : task.base;
+        return {
+            basePath,
+            pathSegmentSeparator: '/',
+            concurrency: this._settings.concurrency,
+            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+            errorFilter: this.errorFilter.getFilter(),
+            followSymbolicLinks: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            stats: this._settings.stats,
+            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+            transform: this.entryTransformer.getTransformer()
+        };
+    }
+    _getMicromatchOptions() {
+        return {
+            dot: this._settings.dot,
+            matchBase: this._settings.baseNameMatch,
+            nobrace: !this._settings.braceExpansion,
+            nocase: !this._settings.caseSensitiveMatch,
+            noext: !this._settings.extglob,
+            noglobstar: !this._settings.globstar,
+            posix: true,
+            strictSlashes: false
+        };
+    }
+}
 provider.default = Provider;
 
-Object.defineProperty(async$7, "__esModule", { value: true });
-const async_1$1 = async$6;
-const provider_1$2 = provider;
-class ProviderAsync extends provider_1$2.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new async_1$1.default(this._settings);
-    }
-    async read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = await this.api(root, task, options);
-        return entries.map((entry) => options.transform(entry));
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
+Object.defineProperty(async$7, "__esModule", { value: true });
+const async_1$1 = async$6;
+const provider_1$2 = provider;
+class ProviderAsync extends provider_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new async_1$1.default(this._settings);
+    }
+    async read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = await this.api(root, task, options);
+        return entries.map((entry) => options.transform(entry));
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
 async$7.default = ProviderAsync;
 
 var stream = {};
 
-Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0$1;
-const stream_2 = stream$1;
-const provider_1$1 = provider;
-class ProviderStream extends provider_1$1.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new stream_2.default(this._settings);
-    }
-    read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const source = this.api(root, task, options);
-        const destination = new stream_1$1.Readable({ objectMode: true, read: () => { } });
-        source
-            .once('error', (error) => destination.emit('error', error))
-            .on('data', (entry) => destination.emit('data', options.transform(entry)))
-            .once('end', () => destination.emit('end'));
-        destination
-            .once('close', () => source.destroy());
-        return destination;
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
+Object.defineProperty(stream, "__esModule", { value: true });
+const stream_1$1 = require$$0$1;
+const stream_2 = stream$1;
+const provider_1$1 = provider;
+class ProviderStream extends provider_1$1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new stream_2.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const source = this.api(root, task, options);
+        const destination = new stream_1$1.Readable({ objectMode: true, read: () => { } });
+        source
+            .once('error', (error) => destination.emit('error', error))
+            .on('data', (entry) => destination.emit('data', options.transform(entry)))
+            .once('end', () => destination.emit('end'));
+        destination
+            .once('close', () => source.destroy());
+        return destination;
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
 stream.default = ProviderStream;
 
 var sync$1 = {};
 
 var sync = {};
 
-Object.defineProperty(sync, "__esModule", { value: true });
-const fsStat = out$1;
-const fsWalk = out$3;
-const reader_1 = reader;
-class ReaderSync extends reader_1.default {
-    constructor() {
-        super(...arguments);
-        this._walkSync = fsWalk.walkSync;
-        this._statSync = fsStat.statSync;
-    }
-    dynamic(root, options) {
-        return this._walkSync(root, options);
-    }
-    static(patterns, options) {
-        const entries = [];
-        for (const pattern of patterns) {
-            const filepath = this._getFullEntryPath(pattern);
-            const entry = this._getEntry(filepath, pattern, options);
-            if (entry === null || !options.entryFilter(entry)) {
-                continue;
-            }
-            entries.push(entry);
-        }
-        return entries;
-    }
-    _getEntry(filepath, pattern, options) {
-        try {
-            const stats = this._getStat(filepath);
-            return this._makeEntry(stats, pattern);
-        }
-        catch (error) {
-            if (options.errorFilter(error)) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    _getStat(filepath) {
-        return this._statSync(filepath, this._fsStatSettings);
-    }
-}
+Object.defineProperty(sync, "__esModule", { value: true });
+const fsStat = out$1;
+const fsWalk = out$3;
+const reader_1 = reader;
+class ReaderSync extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._walkSync = fsWalk.walkSync;
+        this._statSync = fsStat.statSync;
+    }
+    dynamic(root, options) {
+        return this._walkSync(root, options);
+    }
+    static(patterns, options) {
+        const entries = [];
+        for (const pattern of patterns) {
+            const filepath = this._getFullEntryPath(pattern);
+            const entry = this._getEntry(filepath, pattern, options);
+            if (entry === null || !options.entryFilter(entry)) {
+                continue;
+            }
+            entries.push(entry);
+        }
+        return entries;
+    }
+    _getEntry(filepath, pattern, options) {
+        try {
+            const stats = this._getStat(filepath);
+            return this._makeEntry(stats, pattern);
+        }
+        catch (error) {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    _getStat(filepath) {
+        return this._statSync(filepath, this._fsStatSettings);
+    }
+}
 sync.default = ReaderSync;
 
-Object.defineProperty(sync$1, "__esModule", { value: true });
-const sync_1$1 = sync;
-const provider_1 = provider;
-class ProviderSync extends provider_1.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new sync_1$1.default(this._settings);
-    }
-    read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = this.api(root, task, options);
-        return entries.map(options.transform);
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
+Object.defineProperty(sync$1, "__esModule", { value: true });
+const sync_1$1 = sync;
+const provider_1 = provider;
+class ProviderSync extends provider_1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new sync_1$1.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = this.api(root, task, options);
+        return entries.map(options.transform);
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
 sync$1.default = ProviderSync;
 
 var settings = {};
 
 (function (exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-	const fs = $;
-	const os = require$$0;
-	/**
-	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
-	 * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
-	 */
-	const CPU_COUNT = Math.max(os.cpus().length, 1);
-	exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
-	    lstat: fs.lstat,
-	    lstatSync: fs.lstatSync,
-	    stat: fs.stat,
-	    statSync: fs.statSync,
-	    readdir: fs.readdir,
-	    readdirSync: fs.readdirSync
-	};
-	class Settings {
-	    constructor(_options = {}) {
-	        this._options = _options;
-	        this.absolute = this._getValue(this._options.absolute, false);
-	        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
-	        this.braceExpansion = this._getValue(this._options.braceExpansion, true);
-	        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
-	        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
-	        this.cwd = this._getValue(this._options.cwd, process.cwd());
-	        this.deep = this._getValue(this._options.deep, Infinity);
-	        this.dot = this._getValue(this._options.dot, false);
-	        this.extglob = this._getValue(this._options.extglob, true);
-	        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
-	        this.fs = this._getFileSystemMethods(this._options.fs);
-	        this.globstar = this._getValue(this._options.globstar, true);
-	        this.ignore = this._getValue(this._options.ignore, []);
-	        this.markDirectories = this._getValue(this._options.markDirectories, false);
-	        this.objectMode = this._getValue(this._options.objectMode, false);
-	        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
-	        this.onlyFiles = this._getValue(this._options.onlyFiles, true);
-	        this.stats = this._getValue(this._options.stats, false);
-	        this.suppressErrors = this._getValue(this._options.suppressErrors, false);
-	        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
-	        this.unique = this._getValue(this._options.unique, true);
-	        if (this.onlyDirectories) {
-	            this.onlyFiles = false;
-	        }
-	        if (this.stats) {
-	            this.objectMode = true;
-	        }
-	    }
-	    _getValue(option, value) {
-	        return option === undefined ? value : option;
-	    }
-	    _getFileSystemMethods(methods = {}) {
-	        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
-	    }
-	}
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+	const fs = $;
+	const os = require$$0;
+	/**
+	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
+	 * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
+	 */
+	const CPU_COUNT = Math.max(os.cpus().length, 1);
+	exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+	    lstat: fs.lstat,
+	    lstatSync: fs.lstatSync,
+	    stat: fs.stat,
+	    statSync: fs.statSync,
+	    readdir: fs.readdir,
+	    readdirSync: fs.readdirSync
+	};
+	class Settings {
+	    constructor(_options = {}) {
+	        this._options = _options;
+	        this.absolute = this._getValue(this._options.absolute, false);
+	        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+	        this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+	        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+	        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
+	        this.cwd = this._getValue(this._options.cwd, process.cwd());
+	        this.deep = this._getValue(this._options.deep, Infinity);
+	        this.dot = this._getValue(this._options.dot, false);
+	        this.extglob = this._getValue(this._options.extglob, true);
+	        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+	        this.fs = this._getFileSystemMethods(this._options.fs);
+	        this.globstar = this._getValue(this._options.globstar, true);
+	        this.ignore = this._getValue(this._options.ignore, []);
+	        this.markDirectories = this._getValue(this._options.markDirectories, false);
+	        this.objectMode = this._getValue(this._options.objectMode, false);
+	        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+	        this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+	        this.stats = this._getValue(this._options.stats, false);
+	        this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+	        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+	        this.unique = this._getValue(this._options.unique, true);
+	        if (this.onlyDirectories) {
+	            this.onlyFiles = false;
+	        }
+	        if (this.stats) {
+	            this.objectMode = true;
+	        }
+	    }
+	    _getValue(option, value) {
+	        return option === undefined ? value : option;
+	    }
+	    _getFileSystemMethods(methods = {}) {
+	        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
+	    }
+	}
 	exports.default = Settings; 
 } (settings));
 
-const taskManager = tasks;
-const patternManager = patterns;
-const async_1 = async$7;
-const stream_1 = stream;
-const sync_1 = sync$1;
-const settings_1 = settings;
-const utils = utils$k;
-async function FastGlob(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, async_1.default, options);
-    const result = await Promise.all(works);
-    return utils.array.flatten(result);
-}
-// https://github.com/typescript-eslint/typescript-eslint/issues/60
-// eslint-disable-next-line no-redeclare
-(function (FastGlob) {
-    function sync(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, sync_1.default, options);
-        return utils.array.flatten(works);
-    }
-    FastGlob.sync = sync;
-    function stream(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, stream_1.default, options);
-        /**
-         * The stream returned by the provider cannot work with an asynchronous iterator.
-         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
-         * This affects performance (+25%). I don't see best solution right now.
-         */
-        return utils.stream.merge(works);
-    }
-    FastGlob.stream = stream;
-    function generateTasks(source, options) {
-        assertPatternsInput(source);
-        const patterns = patternManager.transform([].concat(source));
-        const settings = new settings_1.default(options);
-        return taskManager.generate(patterns, settings);
-    }
-    FastGlob.generateTasks = generateTasks;
-    function isDynamicPattern(source, options) {
-        assertPatternsInput(source);
-        const settings = new settings_1.default(options);
-        return utils.pattern.isDynamicPattern(source, settings);
-    }
-    FastGlob.isDynamicPattern = isDynamicPattern;
-    function escapePath(source) {
-        assertPatternsInput(source);
-        return utils.path.escape(source);
-    }
-    FastGlob.escapePath = escapePath;
-})(FastGlob || (FastGlob = {}));
-function getWorks(source, _Provider, options) {
-    const patterns = patternManager.transform([].concat(source));
-    const settings = new settings_1.default(options);
-    const tasks = taskManager.generate(patterns, settings);
-    const provider = new _Provider(settings);
-    return tasks.map(provider.read, provider);
-}
-function assertPatternsInput(input) {
-    const source = [].concat(input);
-    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
-    if (!isValidSource) {
-        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
-    }
-}
+const taskManager = tasks;
+const async_1 = async$7;
+const stream_1 = stream;
+const sync_1 = sync$1;
+const settings_1 = settings;
+const utils = utils$k;
+async function FastGlob(source, options) {
+    assertPatternsInput(source);
+    const works = getWorks(source, async_1.default, options);
+    const result = await Promise.all(works);
+    return utils.array.flatten(result);
+}
+// https://github.com/typescript-eslint/typescript-eslint/issues/60
+// eslint-disable-next-line no-redeclare
+(function (FastGlob) {
+    FastGlob.glob = FastGlob;
+    FastGlob.globSync = sync;
+    FastGlob.globStream = stream;
+    FastGlob.async = FastGlob;
+    function sync(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, sync_1.default, options);
+        return utils.array.flatten(works);
+    }
+    FastGlob.sync = sync;
+    function stream(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, stream_1.default, options);
+        /**
+         * The stream returned by the provider cannot work with an asynchronous iterator.
+         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+         * This affects performance (+25%). I don't see best solution right now.
+         */
+        return utils.stream.merge(works);
+    }
+    FastGlob.stream = stream;
+    function generateTasks(source, options) {
+        assertPatternsInput(source);
+        const patterns = [].concat(source);
+        const settings = new settings_1.default(options);
+        return taskManager.generate(patterns, settings);
+    }
+    FastGlob.generateTasks = generateTasks;
+    function isDynamicPattern(source, options) {
+        assertPatternsInput(source);
+        const settings = new settings_1.default(options);
+        return utils.pattern.isDynamicPattern(source, settings);
+    }
+    FastGlob.isDynamicPattern = isDynamicPattern;
+    function escapePath(source) {
+        assertPatternsInput(source);
+        return utils.path.escape(source);
+    }
+    FastGlob.escapePath = escapePath;
+    function convertPathToPattern(source) {
+        assertPatternsInput(source);
+        return utils.path.convertPathToPattern(source);
+    }
+    FastGlob.convertPathToPattern = convertPathToPattern;
+    (function (posix) {
+        function escapePath(source) {
+            assertPatternsInput(source);
+            return utils.path.escapePosixPath(source);
+        }
+        posix.escapePath = escapePath;
+        function convertPathToPattern(source) {
+            assertPatternsInput(source);
+            return utils.path.convertPosixPathToPattern(source);
+        }
+        posix.convertPathToPattern = convertPathToPattern;
+    })(FastGlob.posix || (FastGlob.posix = {}));
+    (function (win32) {
+        function escapePath(source) {
+            assertPatternsInput(source);
+            return utils.path.escapeWindowsPath(source);
+        }
+        win32.escapePath = escapePath;
+        function convertPathToPattern(source) {
+            assertPatternsInput(source);
+            return utils.path.convertWindowsPathToPattern(source);
+        }
+        win32.convertPathToPattern = convertPathToPattern;
+    })(FastGlob.win32 || (FastGlob.win32 = {}));
+})(FastGlob || (FastGlob = {}));
+function getWorks(source, _Provider, options) {
+    const patterns = [].concat(source);
+    const settings = new settings_1.default(options);
+    const tasks = taskManager.generate(patterns, settings);
+    const provider = new _Provider(settings);
+    return tasks.map(provider.read, provider);
+}
+function assertPatternsInput(input) {
+    const source = [].concat(input);
+    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+    if (!isValidSource) {
+        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+    }
+}
 var out = FastGlob;
 
 var fg = /*@__PURE__*/getDefaultExportFromCjs(out);
@@ -6976,6 +7062,13 @@ const envsOrder = [
   "happy-dom",
   "edge-runtime"
 ];
+function getTransformMode(patterns, filename) {
+  if (patterns.web && mm.isMatch(filename, patterns.web))
+    return "web";
+  if (patterns.ssr && mm.isMatch(filename, patterns.ssr))
+    return "ssr";
+  return void 0;
+}
 async function groupFilesByEnv(files) {
   const filesWithEnv = await Promise.all(files.map(async ([project, file]) => {
     var _a, _b;
@@ -6990,12 +7083,14 @@ async function groupFilesByEnv(files) {
       }
     }
     env || (env = project.config.environment || "node");
+    const transformMode = getTransformMode(project.config.testTransformMode, file);
     const envOptions = JSON.parse(((_b = code.match(/@(?:vitest|jest)-environment-options\s+?(.+)/)) == null ? void 0 : _b[1]) || "null");
     return {
       file,
       project,
       environment: {
         name: env,
+        transformMode,
         options: envOptions ? { [env]: envOptions } : null
       }
     };
@@ -7007,7 +7102,7 @@ function createMethodsRPC(project) {
   const ctx = project.ctx;
   return {
     async onWorkerExit(error, code) {
-      await ctx.logger.printError(error, false, "Unexpected Exit");
+      await ctx.logger.printError(error, { type: "Unexpected Exit" });
       process.exit(code || 1);
     },
     snapshotSaved(snapshot) {
@@ -7025,12 +7120,10 @@ function createMethodsRPC(project) {
       const r = await project.vitenode.transformRequest(id);
       return r == null ? void 0 : r.map;
     },
-    fetch(id, environment) {
-      const transformMode = getEnvironmentTransformMode(project.config, environment);
+    fetch(id, transformMode) {
       return project.vitenode.fetchModule(id, transformMode);
     },
-    resolveId(id, importer, environment) {
-      const transformMode = getEnvironmentTransformMode(project.config, environment);
+    resolveId(id, importer, transformMode) {
       return project.vitenode.resolveId(id, importer, transformMode);
     },
     onPathsCollected(paths) {
@@ -7068,7 +7161,7 @@ function createMethodsRPC(project) {
   };
 }
 
-const childPath = fileURLToPath(pathToFileURL(resolve$2(distDir, "./child.js")).href);
+const childPath = fileURLToPath(pathToFileURL(resolve(distDir, "./child.js")).href);
 function setupChildProcessChannel(project, fork2) {
   const rpc = createBirpc(
     createMethodsRPC(project),
@@ -7115,6 +7208,8 @@ function createChildProcessPool(ctx, { execArgv, env }) {
     const child = fork(childPath, [], {
       execArgv,
       env
+      // TODO: investigate
+      // serialization: 'advanced',
     });
     children.add(child);
     setupChildProcessChannel(project, child);
@@ -7145,7 +7240,7 @@ function createChildProcessPool(ctx, { execArgv, env }) {
       const files = filesByEnv[env2];
       if (!(files == null ? void 0 : files.length))
         continue;
-      const filesByOptions = groupBy(files, ({ project, environment }) => project.getName() + JSON.stringify(environment.options));
+      const filesByOptions = groupBy(files, ({ project, environment }) => project.getName() + JSON.stringify(environment.options) + environment.transformMode);
       for (const option in filesByOptions) {
         const files2 = filesByOptions[option];
         if (files2 == null ? void 0 : files2.length) {
@@ -7167,8 +7262,8 @@ function createChildProcessPool(ctx, { execArgv, env }) {
   };
 }
 
-const workerPath = pathToFileURL(resolve$2(distDir, "./worker.js")).href;
-function createWorkerChannel(project) {
+const workerPath$1 = pathToFileURL(resolve(distDir, "./worker.js")).href;
+function createWorkerChannel$1(project) {
   const channel = new MessageChannel();
   const port = channel.port2;
   const workerPort = channel.port1;
@@ -7192,7 +7287,7 @@ function createThreadsPool(ctx, { execArgv, env }) {
   const maxThreads = ctx.config.maxThreads ?? threadsCount;
   const minThreads = ctx.config.minThreads ?? threadsCount;
   const options = {
-    filename: workerPath,
+    filename: workerPath$1,
     // TODO: investigate further
     // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
     useAtomics: ctx.config.useAtomics ?? false,
@@ -7216,7 +7311,7 @@ function createThreadsPool(ctx, { execArgv, env }) {
     let id = 0;
     async function runFiles(project, config, files, environment, invalidates = []) {
       ctx.state.clearFiles(project, files);
-      const { workerPort, port } = createWorkerChannel(project);
+      const { workerPort, port } = createWorkerChannel$1(project);
       const workerId = ++id;
       const data = {
         port: workerPort,
@@ -7266,8 +7361,18 @@ function createThreadsPool(ctx, { execArgv, env }) {
       const multipleThreads = specs.filter(([project]) => !project.config.singleThread);
       if (multipleThreads.length) {
         const filesByEnv = await groupFilesByEnv(multipleThreads);
-        const promises = Object.values(filesByEnv).flat();
-        const results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)));
+        const files = Object.values(filesByEnv).flat();
+        const results = [];
+        if (ctx.config.isolate) {
+          results.push(...await Promise.allSettled(files.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+        } else {
+          const grouped = groupBy(files, ({ project, environment }) => project.getName() + environment.name + JSON.stringify(environment.options));
+          for (const group of Object.values(grouped)) {
+            results.push(...await Promise.allSettled(group.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates))));
+            await new Promise((resolve2) => pool.queueSize === 0 ? resolve2() : pool.once("drain", resolve2));
+            await pool.recycleWorkers();
+          }
+        }
         const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
         if (errors.length > 0)
           throw new AggregateErrorPonyfill(errors, "Errors occurred while running tests. For more information, see serialized error.");
@@ -7282,11 +7387,11 @@ function createThreadsPool(ctx, { execArgv, env }) {
           if (!(files == null ? void 0 : files.length))
             continue;
           const filesByOptions = groupBy(files, ({ project, environment }) => project.getName() + JSON.stringify(environment.options));
-          const promises = Object.values(filesByOptions).map(async (files2) => {
+          for (const files2 of Object.values(filesByOptions)) {
+            await pool.recycleWorkers();
             const filenames = files2.map((f) => f.file);
             await runFiles(files2[0].project, getConfig(files2[0].project), filenames, files2[0].environment, invalidates);
-          });
-          await Promise.all(promises);
+          }
         }
       }
     };
@@ -7345,45 +7450,158 @@ function createBrowserPool(ctx) {
         await provider.openPage(url.toString());
         await waitForTest(provider, path);
       }
-    } else {
-      const url = new URL("/", origin);
-      url.searchParams.set("id", "no-isolate");
-      paths.forEach((path) => url.searchParams.append("path", path));
-      await provider.openPage(url.toString());
-      await waitForTest(provider, "no-isolate");
-    }
-  };
-  const runWorkspaceTests = async (specs) => {
-    const groupedFiles = /* @__PURE__ */ new Map();
-    for (const [project, file] of specs) {
-      const files = groupedFiles.get(project) || [];
-      files.push(file);
-      groupedFiles.set(project, files);
+    } else {
+      const url = new URL("/", origin);
+      url.searchParams.set("id", "no-isolate");
+      paths.forEach((path) => url.searchParams.append("path", path));
+      await provider.openPage(url.toString());
+      await waitForTest(provider, "no-isolate");
+    }
+  };
+  const runWorkspaceTests = async (specs) => {
+    const groupedFiles = /* @__PURE__ */ new Map();
+    for (const [project, file] of specs) {
+      const files = groupedFiles.get(project) || [];
+      files.push(file);
+      groupedFiles.set(project, files);
+    }
+    for (const [project, files] of groupedFiles.entries())
+      await runTests(project, files);
+  };
+  return {
+    async close() {
+      ctx.state.browserTestPromises.clear();
+      await Promise.all([...providers].map((provider) => provider.close()));
+      providers.clear();
+    },
+    runTests: runWorkspaceTests
+  };
+}
+
+const workerPath = pathToFileURL(resolve(distDir, "./vm.js")).href;
+const suppressLoaderWarningsPath$1 = resolve(rootDir, "./suppress-warnings.cjs");
+function createWorkerChannel(project) {
+  const channel = new MessageChannel();
+  const port = channel.port2;
+  const workerPort = channel.port1;
+  const rpc = createBirpc(
+    createMethodsRPC(project),
+    {
+      eventNames: ["onCancel"],
+      post(v) {
+        port.postMessage(v);
+      },
+      on(fn) {
+        port.on("message", fn);
+      }
+    }
+  );
+  project.ctx.onCancel((reason) => rpc.onCancel(reason));
+  return { workerPort, port };
+}
+function createVmThreadsPool(ctx, { execArgv, env }) {
+  const threadsCount = ctx.config.watch ? Math.max(Math.floor(cpus().length / 2), 1) : Math.max(cpus().length - 1, 1);
+  const maxThreads = ctx.config.maxThreads ?? threadsCount;
+  const minThreads = ctx.config.minThreads ?? threadsCount;
+  const options = {
+    filename: workerPath,
+    // TODO: investigate further
+    // It seems atomics introduced V8 Fatal Error https://github.com/vitest-dev/vitest/issues/1191
+    useAtomics: ctx.config.useAtomics ?? false,
+    maxThreads,
+    minThreads,
+    env,
+    execArgv: [
+      "--experimental-import-meta-resolve",
+      "--experimental-vm-modules",
+      "--require",
+      suppressLoaderWarningsPath$1,
+      ...execArgv
+    ],
+    terminateTimeout: ctx.config.teardownTimeout
+  };
+  if (ctx.config.singleThread) {
+    options.concurrentTasksPerWorker = 1;
+    options.maxThreads = 1;
+    options.minThreads = 1;
+  }
+  const pool = new Tinypool(options);
+  const runWithFiles = (name) => {
+    let id = 0;
+    async function runFiles(project, config, files, environment, invalidates = []) {
+      ctx.state.clearFiles(project, files);
+      const { workerPort, port } = createWorkerChannel(project);
+      const workerId = ++id;
+      const data = {
+        port: workerPort,
+        config,
+        files,
+        invalidates,
+        environment,
+        workerId
+      };
+      try {
+        await pool.run(data, { transferList: [workerPort], name });
+      } catch (error) {
+        if (error instanceof Error && /Failed to terminate worker/.test(error.message))
+          ctx.state.addProcessTimeoutCause(`Failed to terminate worker while running ${files.join(", ")}.`);
+        else if (ctx.isCancelling && error instanceof Error && /The task has been cancelled/.test(error.message))
+          ctx.state.cancelFiles(files, ctx.config.root);
+        else
+          throw error;
+      } finally {
+        port.close();
+        workerPort.close();
+      }
     }
-    for (const [project, files] of groupedFiles.entries())
-      await runTests(project, files);
+    const Sequencer = ctx.config.sequence.sequencer;
+    const sequencer = new Sequencer(ctx);
+    return async (specs, invalidates) => {
+      const configs = /* @__PURE__ */ new Map();
+      const getConfig = (project) => {
+        if (configs.has(project))
+          return configs.get(project);
+        const config = project.getSerializableConfig();
+        configs.set(project, config);
+        return config;
+      };
+      const { shard } = ctx.config;
+      if (shard)
+        specs = await sequencer.shard(specs);
+      specs = await sequencer.sort(specs);
+      const filesByEnv = await groupFilesByEnv(specs);
+      const promises = Object.values(filesByEnv).flat();
+      const results = await Promise.allSettled(promises.map(({ file, environment, project }) => runFiles(project, getConfig(project), [file], environment, invalidates)));
+      const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+      if (errors.length > 0)
+        throw new AggregateErrorPonyfill(errors, "Errors occurred while running tests. For more information, see serialized error.");
+    };
   };
   return {
-    async close() {
-      ctx.state.browserTestPromises.clear();
-      await Promise.all([...providers].map((provider) => provider.close()));
-      providers.clear();
-    },
-    runTests: runWorkspaceTests
+    runTests: runWithFiles("run"),
+    close: async () => {
+      var _a;
+      const nodeVersion = Number((_a = process.version.match(/v(\d+)\.(\d+)/)) == null ? void 0 : _a[0].slice(1));
+      if (nodeVersion >= 16.17)
+        await pool.destroy();
+    }
   };
 }
 
-const loaderPath = pathToFileURL(resolve$2(distDir, "./loader.js")).href;
-const suppressLoaderWarningsPath = resolve$2(rootDir, "./suppress-warnings.cjs");
+const loaderPath = pathToFileURL(resolve(distDir, "./loader.js")).href;
+const suppressLoaderWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
 function createPool(ctx) {
   const pools = {
     child_process: null,
     threads: null,
-    browser: null
+    browser: null,
+    experimentalVmThreads: null
   };
   function getDefaultPoolName(project) {
     if (project.config.browser.enabled)
       return "browser";
+    if (project.config.experimentalVmThreads)
+      return "experimentalVmThreads";
     if (project.config.threads)
       return "threads";
     return "child_process";
@@ -7409,7 +7627,8 @@ function createPool(ctx) {
         "--require",
         suppressLoaderWarningsPath,
         "--experimental-loader",
-        loaderPath
+        loaderPath,
+        ...conditions
       ] : [
         ...execArgv,
         ...conditions
@@ -7426,10 +7645,13 @@ function createPool(ctx) {
     const filesByPool = {
       child_process: [],
       threads: [],
-      browser: []
+      browser: [],
+      experimentalVmThreads: []
     };
     for (const spec of files) {
       const pool = getPoolName(spec);
+      if (!(pool in filesByPool))
+        throw new Error(`Unknown pool name "${pool}" for ${spec[1]}. Available pools: ${Object.keys(filesByPool).join(", ")}`);
       filesByPool[pool].push(spec);
     }
     await Promise.all(Object.entries(filesByPool).map(([pool, files2]) => {
@@ -7439,6 +7661,10 @@ function createPool(ctx) {
         pools.browser ?? (pools.browser = createBrowserPool(ctx));
         return pools.browser.runTests(files2, invalidate);
       }
+      if (pool === "experimentalVmThreads") {
+        pools.experimentalVmThreads ?? (pools.experimentalVmThreads = createVmThreadsPool(ctx, options));
+        return pools.experimentalVmThreads.runTests(files2, invalidate);
+      }
       if (pool === "threads") {
         pools.threads ?? (pools.threads = createThreadsPool(ctx, options));
         return pools.threads.runTests(files2, invalidate);
@@ -7950,8 +8176,13 @@ ${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
     for (const task of tasks) {
       (_b = (_a2 = task.result) == null ? void 0 : _a2.errors) == null ? void 0 : _b.forEach((error) => {
         const errorItem = (error == null ? void 0 : error.stackStr) && errorsQueue.find((i) => {
-          var _a3;
-          return ((_a3 = i[0]) == null ? void 0 : _a3.stackStr) === error.stackStr;
+          var _a3, _b2, _c2, _d;
+          const hasStr = ((_a3 = i[0]) == null ? void 0 : _a3.stackStr) === error.stackStr;
+          if (!hasStr)
+            return false;
+          const currentProjectName = (task == null ? void 0 : task.projectName) || ((_b2 = task.file) == null ? void 0 : _b2.projectName);
+          const projectName = ((_c2 = i[1][0]) == null ? void 0 : _c2.projectName) || ((_d = i[1][0].file) == null ? void 0 : _d.projectName);
+          return projectName === currentProjectName;
         });
         if (errorItem)
           errorItem[1].push(task);
@@ -7968,7 +8199,8 @@ ${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
           name = `${name} ${c.dim(`[ ${this.relative(filepath)} ]`)}`;
         this.ctx.logger.error(`${c.red(c.bold(c.inverse(" FAIL ")))} ${formatProjectName(projectName)}${name}`);
       }
-      await this.ctx.logger.printError(error);
+      const project = this.ctx.getProjectByTaskId(tasks2[0].id);
+      await this.ctx.logger.printError(error, { project });
       errorDivider();
       await Promise.resolve();
     }
@@ -7976,7 +8208,7 @@ ${c.cyan(c.inverse(c.bold(" BENCH ")))} ${c.cyan("Summary")}
   registerUnhandledRejection() {
     process.on("unhandledRejection", async (err) => {
       process.exitCode = 1;
-      await this.ctx.logger.printError(err, true, "Unhandled Rejection");
+      await this.ctx.logger.printError(err, { fullStack: true, type: "Unhandled Rejection" });
       this.ctx.logger.error("\n\n");
       process.exit(1);
     });
@@ -9328,7 +9560,7 @@ let JsonReporter$1 = class JsonReporter {
   async writeReport(report) {
     const outputFile = getOutputFile(this.ctx.config, "json");
     if (outputFile) {
-      const reportFile = resolve$2(this.ctx.config.root, outputFile);
+      const reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(reportFile);
       if (!existsSync(outputDirectory))
         await promises.mkdir(outputDirectory, { recursive: true });
@@ -9343,7 +9575,10 @@ let JsonReporter$1 = class JsonReporter {
     const error = (_b = (_a = test.result) == null ? void 0 : _a.errors) == null ? void 0 : _b[0];
     if (!error)
       return;
-    const stack = parseErrorStacktrace(error);
+    const project = this.ctx.getProjectByTaskId(test.id);
+    const stack = parseErrorStacktrace(error, {
+      getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+    });
     const frame = stack[0];
     if (!frame)
       return;
@@ -9442,10 +9677,13 @@ class TapReporter {
         this.logger.log("}");
       } else {
         this.logger.log(`${ok} ${id} - ${tapString(task.name)}${comment}`);
+        const project = this.ctx.getProjectByTaskId(task.id);
         if (((_b = task.result) == null ? void 0 : _b.state) === "fail" && task.result.errors) {
           this.logger.indent();
           task.result.errors.forEach((error) => {
-            const stacks = parseErrorStacktrace(error);
+            const stacks = parseErrorStacktrace(error, {
+              getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+            });
             const stack = stacks[0];
             this.logger.log("---");
             this.logger.log("error:");
@@ -9519,7 +9757,7 @@ class JUnitReporter {
     this.ctx = ctx;
     const outputFile = getOutputFile(this.ctx.config, "junit");
     if (outputFile) {
-      this.reportFile = resolve$2(this.ctx.config.root, outputFile);
+      this.reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(this.reportFile);
       if (!existsSync(outputDirectory))
         await promises.mkdir(outputDirectory, { recursive: true });
@@ -9551,11 +9789,14 @@ class JUnitReporter {
     this.logger.unindent();
     await this.logger.log(`</${name}>`);
   }
-  async writeErrorDetails(error) {
+  async writeErrorDetails(task, error) {
     const errorName = error.name ?? error.nameStr ?? "Unknown Error";
     const errorDetails = `${errorName}: ${error.message}`;
     await this.baseLog(escapeXML(errorDetails));
-    const stack = parseErrorStacktrace(error);
+    const project = this.ctx.getProjectByTaskId(task.id);
+    const stack = parseErrorStacktrace(error, {
+      getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+    });
     for (const frame of stack) {
       const path = relative(this.ctx.config.root, frame.file);
       await this.baseLog(escapeXML(` ${F_POINTER} ${[frame.method, `${path}:${frame.line}:${frame.column}`].filter(Boolean).join(" ")}`));
@@ -9578,7 +9819,7 @@ class JUnitReporter {
   async writeTasks(tasks, filename) {
     for (const task of tasks) {
       await this.writeElement("testcase", {
-        classname: filename,
+        classname: process.env.VITEST_JUNIT_CLASSNAME ?? filename,
         name: task.name,
         time: getDuration(task)
       }, async () => {
@@ -9596,7 +9837,7 @@ class JUnitReporter {
             }, async () => {
               if (!error)
                 return;
-              await this.writeErrorDetails(error);
+              await this.writeErrorDetails(task, error);
             });
           }
         }
@@ -9748,7 +9989,7 @@ class JsonReporter {
   async writeReport(report) {
     const outputFile = getOutputFile(this.ctx.config.benchmark, "json");
     if (outputFile) {
-      const reportFile = resolve$2(this.ctx.config.root, outputFile);
+      const reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(reportFile);
       if (!existsSync(outputDirectory))
         await promises.mkdir(outputDirectory, { recursive: true });
@@ -10047,7 +10288,6 @@ function isAggregateError(err) {
 class StateManager {
   filesMap = /* @__PURE__ */ new Map();
   pathsSet = /* @__PURE__ */ new Set();
-  collectingPromise = void 0;
   browserTestPromises = /* @__PURE__ */ new Map();
   idMap = /* @__PURE__ */ new Map();
   taskFileMap = /* @__PURE__ */ new WeakMap();
@@ -10105,7 +10345,9 @@ class StateManager {
       this.updateId(file);
     });
   }
-  clearFiles(project, paths = []) {
+  // this file is reused by ws-client, and shoult not rely on heavy dependencies like workspace
+  clearFiles(_project, paths = []) {
+    const project = _project;
     paths.forEach((path) => {
       const files = this.filesMap.get(path);
       if (!files)
@@ -10167,7 +10409,7 @@ class StateManager {
   }
 }
 
-const defaultInclude = ["**/__tests__/**/*.?(c|m)[jt]s?(x)", "**/?(*.){test,spec}.?(c|m)[jt]s?(x)"];
+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}.config.*"];
 const benchmarkConfigDefaults = {
   include: ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"],
@@ -10180,6 +10422,9 @@ const defaultCoverageExcludes = [
   "dist/**",
   "packages/*/test?(s)/**",
   "**/*.d.ts",
+  "**/virtual:*",
+  "**/__x00__*",
+  "**/\0*",
   "cypress/**",
   "test?(s)/**",
   "test?(-*).?(c|m)[jt]s?(x)",
@@ -10195,10 +10440,8 @@ const coverageConfigDefaults = {
   cleanOnRerun: true,
   reportsDirectory: "./coverage",
   exclude: defaultCoverageExcludes,
-  reportOnFailure: true,
+  reportOnFailure: false,
   reporter: [["text", {}], ["html", {}], ["clover", {}], ["json", {}]],
-  // default extensions used by c8, plus '.vue' and '.svelte'
-  // see https://github.com/istanbuljs/schema/blob/master/default-extension.js
   extension: [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts", ".tsx", ".jsx", ".vue", ".svelte"]
 };
 const fakeTimersDefaults = {
@@ -10251,13 +10494,73 @@ const config = {
   dangerouslyIgnoreUnhandledErrors: false,
   typecheck: {
     checker: "tsc",
-    include: ["**/?(*.){test,spec}-d.?(c|m)[jt]s?(x)"],
+    include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
     exclude: defaultExclude
   },
   slowTestThreshold: 300
 };
 const configDefaults = Object.freeze(config);
 
+function getDefaultThreadsCount(config) {
+  return config.watch ? Math.max(Math.floor(cpus().length / 2), 1) : Math.max(cpus().length - 1, 1);
+}
+function getWorkerMemoryLimit(config) {
+  if (config.experimentalVmWorkerMemoryLimit)
+    return config.experimentalVmWorkerMemoryLimit;
+  return 1 / (config.maxThreads ?? getDefaultThreadsCount(config));
+}
+function stringToBytes(input, percentageReference) {
+  if (input === null || input === void 0)
+    return input;
+  if (typeof input === "string") {
+    if (Number.isNaN(Number.parseFloat(input.slice(-1)))) {
+      let [, numericString, trailingChars] = input.match(/(.*?)([^0-9.-]+)$/i) || [];
+      if (trailingChars && numericString) {
+        const numericValue = Number.parseFloat(numericString);
+        trailingChars = trailingChars.toLowerCase();
+        switch (trailingChars) {
+          case "%":
+            input = numericValue / 100;
+            break;
+          case "kb":
+          case "k":
+            return numericValue * 1e3;
+          case "kib":
+            return numericValue * 1024;
+          case "mb":
+          case "m":
+            return numericValue * 1e3 * 1e3;
+          case "mib":
+            return numericValue * 1024 * 1024;
+          case "gb":
+          case "g":
+            return numericValue * 1e3 * 1e3 * 1e3;
+          case "gib":
+            return numericValue * 1024 * 1024 * 1024;
+        }
+      }
+    } else {
+      input = Number.parseFloat(input);
+    }
+  }
+  if (typeof input === "number") {
+    if (input <= 1 && input > 0) {
+      if (percentageReference) {
+        return Math.floor(input * percentageReference);
+      } else {
+        throw new Error(
+          "For a percentage based memory limit a percentageReference must be supplied"
+        );
+      }
+    } else if (input > 1) {
+      return Math.floor(input);
+    } else {
+      throw new Error('Unexpected numerical input for "experimentalVmWorkerMemoryLimit"');
+    }
+  }
+  return null;
+}
+
 class FilesStatsCache {
   cache = /* @__PURE__ */ new Map();
   getStats(key) {
@@ -10296,7 +10599,7 @@ class ResultsCache {
   setConfig(root, config) {
     this.root = root;
     if (config)
-      this.cachePath = resolve$2(config.dir, "results.json");
+      this.cachePath = resolve(config.dir, "results.json");
   }
   getResults(key) {
     return this.cache.get(key);
@@ -10363,12 +10666,12 @@ class VitestCache {
     return this.stats.getStats(key);
   }
   static resolveCacheDir(root, dir) {
-    return resolve$2(root, slash$1(dir || "node_modules/.vitest"));
+    return resolve(root, slash$1(dir || "node_modules/.vitest"));
   }
   static async clearCache(options) {
     var _a, _b;
-    const root = resolve$2(options.root || process.cwd());
-    const configPath = options.config === false ? false : options.config ? resolve$2(root, options.config) : await findUp(configFiles, { cwd: root });
+    const root = resolve(options.root || process.cwd());
+    const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
     const config = configPath ? (_a = await loadConfigFromFile({ command: "serve", mode: "test" }, configPath)) == null ? void 0 : _a.config : void 0;
     const cache = (_b = config == null ? void 0 : config.test) == null ? void 0 : _b.cache;
     if (cache === false)
@@ -10396,7 +10699,7 @@ class BaseSequencer {
     const shardStart = shardSize * (index - 1);
     const shardEnd = shardSize * index;
     return [...files].map((spec) => {
-      const fullPath = resolve$2(slash$2(config.root), slash$2(spec[1]));
+      const fullPath = resolve(slash$2(config.root), slash$2(spec[1]));
       const specPath = fullPath == null ? void 0 : fullPath.slice(config.root.length);
       return {
         spec,
@@ -10470,7 +10773,7 @@ function resolveApiServerConfig(options) {
   return api;
 }
 function resolveConfig(mode, options, viteConfig) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
   if (options.dom) {
     if (((_a = viteConfig.test) == null ? void 0 : _a.environment) != null && viteConfig.test.environment !== "happy-dom") {
       console.warn(
@@ -10510,21 +10813,12 @@ function resolveConfig(mode, options, viteConfig) {
       throw new Error(`You cannot use ${inspectOption} without "threads: false" or "singleThread: true"`);
     }
   }
-  if (resolved.coverage.provider === "c8" && resolved.coverage.enabled && isBrowserEnabled(resolved))
-    throw new Error("@vitest/coverage-c8 does not work with --browser. Use @vitest/coverage-istanbul instead");
+  if (resolved.coverage.provider === "c8")
+    throw new Error('"coverage.provider: c8" is not supported anymore. Use "coverage.provider: v8" instead');
   if (resolved.coverage.provider === "v8" && resolved.coverage.enabled && isBrowserEnabled(resolved))
     throw new Error("@vitest/coverage-v8 does not work with --browser. Use @vitest/coverage-istanbul instead");
-  resolved.deps = resolved.deps || {};
-  if (resolved.deps.inline !== true) {
-    const ssrOptions = viteConfig.ssr;
-    if ((ssrOptions == null ? void 0 : ssrOptions.noExternal) === true && resolved.deps.inline == null) {
-      resolved.deps.inline = true;
-    } else {
-      (_b = resolved.deps).inline ?? (_b.inline = []);
-      resolved.deps.inline.push(...extraInlineDeps);
-    }
-  }
-  (_c = resolved.deps).moduleDirectories ?? (_c.moduleDirectories = ["/node_modules/"]);
+  resolved.deps ?? (resolved.deps = {});
+  (_b = resolved.deps).moduleDirectories ?? (_b.moduleDirectories = []);
   resolved.deps.moduleDirectories = resolved.deps.moduleDirectories.map((dir) => {
     if (!dir.startsWith("/"))
       dir = `/${dir}`;
@@ -10532,10 +10826,49 @@ function resolveConfig(mode, options, viteConfig) {
       dir += "/";
     return normalize(dir);
   });
+  if (!resolved.deps.moduleDirectories.includes("/node_modules/"))
+    resolved.deps.moduleDirectories.push("/node_modules/");
+  resolved.server ?? (resolved.server = {});
+  (_c = resolved.server).deps ?? (_c.deps = {});
+  const deprecatedDepsOptions = ["inline", "external", "fallbackCJS"];
+  deprecatedDepsOptions.forEach((option) => {
+    if (resolved.deps[option] === void 0)
+      return;
+    if (option === "fallbackCJS") {
+      console.warn(c.yellow(`${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. Use "server.deps.${option}" instead`));
+    } else {
+      const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
+      console.warn(
+        c.yellow(
+          `${c.inverse(c.yellow(" Vitest "))} "deps.${option}" is deprecated. If you rely on vite-node directly, use "server.deps.${option}" instead. Otherwise, consider using "deps.optimizer.${transformMode}.${option === "external" ? "exclude" : "include"}"`
+        )
+      );
+    }
+    if (resolved.server.deps[option] === void 0)
+      resolved.server.deps[option] = resolved.deps[option];
+  });
+  if (resolved.server.deps.inline !== true) {
+    const ssrOptions = viteConfig.ssr;
+    if ((ssrOptions == null ? void 0 : ssrOptions.noExternal) === true && resolved.server.deps.inline == null) {
+      resolved.server.deps.inline = true;
+    } else {
+      (_d = resolved.server.deps).inline ?? (_d.inline = []);
+      resolved.server.deps.inline.push(...extraInlineDeps);
+    }
+  }
+  (_e = resolved.server.deps).moduleDirectories ?? (_e.moduleDirectories = []);
+  resolved.server.deps.moduleDirectories.push(...resolved.deps.moduleDirectories);
   if (resolved.runner) {
-    resolved.runner = resolveModule(resolved.runner, { paths: [resolved.root] }) ?? resolve$2(resolved.root, resolved.runner);
+    resolved.runner = resolveModule(resolved.runner, { paths: [resolved.root] }) ?? resolve(resolved.root, resolved.runner);
+  }
+  if (resolved.deps.registerNodeLoader) {
+    const transformMode = resolved.environment === "happy-dom" || resolved.environment === "jsdom" ? "web" : "ssr";
+    console.warn(
+      c.yellow(
+        `${c.inverse(c.yellow(" Vitest "))} "deps.registerNodeLoader" is deprecated.If you rely on aliases inside external packages, use "deps.optimizer.${transformMode}.include" instead.`
+      )
+    );
   }
-  (_d = resolved.deps).registerNodeLoader ?? (_d.registerNodeLoader = false);
   resolved.testNamePattern = resolved.testNamePattern ? resolved.testNamePattern instanceof RegExp ? resolved.testNamePattern : new RegExp(resolved.testNamePattern) : void 0;
   const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
   resolved.snapshotOptions = {
@@ -10545,6 +10878,10 @@ function resolveConfig(mode, options, viteConfig) {
     // resolved inside the worker
     snapshotEnvironment: null
   };
+  resolved.experimentalVmWorkerMemoryLimit = stringToBytes(
+    getWorkerMemoryLimit(resolved),
+    totalmem()
+  );
   if (options.resolveSnapshotPath)
     delete resolved.resolveSnapshotPath;
   if (process.env.VITEST_MAX_THREADS)
@@ -10574,7 +10911,7 @@ function resolveConfig(mode, options, viteConfig) {
   }
   resolved.setupFiles = toArray(resolved.setupFiles || []).map(
     (file) => normalize(
-      resolveModule(file, { paths: [resolved.root] }) ?? resolve$2(resolved.root, file)
+      resolveModule(file, { paths: [resolved.root] }) ?? resolve(resolved.root, file)
     )
   );
   resolved.coverage.exclude.push(...resolved.setupFiles.map((file) => relative(resolved.root, file)));
@@ -10584,11 +10921,11 @@ function resolveConfig(mode, options, viteConfig) {
   ];
   resolved.api = resolveApiServerConfig(options);
   if (options.related)
-    resolved.related = toArray(options.related).map((file) => resolve$2(resolved.root, file));
+    resolved.related = toArray(options.related).map((file) => resolve(resolved.root, file));
   if (mode !== "benchmark") {
     const cliReporters = toArray(resolved.reporter || []).map((reporter) => {
       if (/^\.\.?\//.test(reporter))
-        return resolve$2(process.cwd(), reporter);
+        return resolve(process.cwd(), reporter);
       return reporter;
     });
     const reporters = cliReporters.length ? cliReporters : resolved.reporters;
@@ -10600,35 +10937,36 @@ function resolveConfig(mode, options, viteConfig) {
     resolved.passWithNoTests ?? (resolved.passWithNoTests = true);
   resolved.css ?? (resolved.css = {});
   if (typeof resolved.css === "object") {
-    (_e = resolved.css).modules ?? (_e.modules = {});
-    (_f = resolved.css.modules).classNameStrategy ?? (_f.classNameStrategy = "stable");
+    (_f = resolved.css).modules ?? (_f.modules = {});
+    (_g = resolved.css.modules).classNameStrategy ?? (_g.classNameStrategy = "stable");
   }
   resolved.cache ?? (resolved.cache = { dir: "" });
   if (resolved.cache)
     resolved.cache.dir = VitestCache.resolveCacheDir(resolved.root, resolved.cache.dir);
   resolved.sequence ?? (resolved.sequence = {});
-  if (!((_g = resolved.sequence) == null ? void 0 : _g.sequencer)) {
+  if (!((_h = resolved.sequence) == null ? void 0 : _h.sequencer)) {
     resolved.sequence.sequencer = resolved.sequence.shuffle ? RandomSequencer : BaseSequencer;
   }
-  (_h = resolved.sequence).hooks ?? (_h.hooks = "parallel");
+  (_i = resolved.sequence).hooks ?? (_i.hooks = "parallel");
   if (resolved.sequence.sequencer === RandomSequencer)
-    (_i = resolved.sequence).seed ?? (_i.seed = Date.now());
+    (_j = resolved.sequence).seed ?? (_j.seed = Date.now());
   resolved.typecheck = {
     ...configDefaults.typecheck,
     ...resolved.typecheck
   };
-  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve$2(resolved.root, i[0]), i[1]]);
+  resolved.environmentMatchGlobs = (resolved.environmentMatchGlobs || []).map((i) => [resolve(resolved.root, i[0]), i[1]]);
   if (mode === "typecheck") {
     resolved.include = resolved.typecheck.include;
     resolved.exclude = resolved.typecheck.exclude;
   }
   resolved.browser ?? (resolved.browser = {});
-  (_j = resolved.browser).enabled ?? (_j.enabled = false);
-  (_k = resolved.browser).headless ?? (_k.headless = isCI);
-  (_l = resolved.browser).slowHijackESM ?? (_l.slowHijackESM = true);
+  (_k = resolved.browser).enabled ?? (_k.enabled = false);
+  (_l = resolved.browser).headless ?? (_l.headless = isCI);
+  (_m = resolved.browser).slowHijackESM ?? (_m.slowHijackESM = true);
   resolved.browser.api = resolveApiServerConfig(resolved.browser) || {
     port: defaultBrowserPort
   };
+  resolved.testTransformMode ?? (resolved.testTransformMode = {});
   return resolved;
 }
 function isBrowserEnabled(config) {
@@ -10638,7 +10976,7 @@ function isBrowserEnabled(config) {
   return ((_b = config.poolMatchGlobs) == null ? void 0 : _b.length) && config.poolMatchGlobs.some(([, pool]) => pool === "browser");
 }
 
-const ESC = '\u001B[';
+const ESC$1 = '\u001B[';
 const OSC = '\u001B]';
 const BEL = '\u0007';
 const SEP = ';';
@@ -10652,10 +10990,10 @@ ansiEscapes.cursorTo = (x, y) => {
 	}
 
 	if (typeof y !== 'number') {
-		return ESC + (x + 1) + 'G';
+		return ESC$1 + (x + 1) + 'G';
 	}
 
-	return ESC + (y + 1) + ';' + (x + 1) + 'H';
+	return ESC$1 + (y + 1) + ';' + (x + 1) + 'H';
 };
 
 ansiEscapes.cursorMove = (x, y) => {
@@ -10666,33 +11004,33 @@ ansiEscapes.cursorMove = (x, y) => {
 	let returnValue = '';
 
 	if (x < 0) {
-		returnValue += ESC + (-x) + 'D';
+		returnValue += ESC$1 + (-x) + 'D';
 	} else if (x > 0) {
-		returnValue += ESC + x + 'C';
+		returnValue += ESC$1 + x + 'C';
 	}
 
 	if (y < 0) {
-		returnValue += ESC + (-y) + 'A';
+		returnValue += ESC$1 + (-y) + 'A';
 	} else if (y > 0) {
-		returnValue += ESC + y + 'B';
+		returnValue += ESC$1 + y + 'B';
 	}
 
 	return returnValue;
 };
 
-ansiEscapes.cursorUp = (count = 1) => ESC + count + 'A';
-ansiEscapes.cursorDown = (count = 1) => ESC + count + 'B';
-ansiEscapes.cursorForward = (count = 1) => ESC + count + 'C';
-ansiEscapes.cursorBackward = (count = 1) => ESC + count + 'D';
+ansiEscapes.cursorUp = (count = 1) => ESC$1 + count + 'A';
+ansiEscapes.cursorDown = (count = 1) => ESC$1 + count + 'B';
+ansiEscapes.cursorForward = (count = 1) => ESC$1 + count + 'C';
+ansiEscapes.cursorBackward = (count = 1) => ESC$1 + count + 'D';
 
-ansiEscapes.cursorLeft = ESC + 'G';
-ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC + 's';
-ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC + 'u';
-ansiEscapes.cursorGetPosition = ESC + '6n';
-ansiEscapes.cursorNextLine = ESC + 'E';
-ansiEscapes.cursorPrevLine = ESC + 'F';
-ansiEscapes.cursorHide = ESC + '?25l';
-ansiEscapes.cursorShow = ESC + '?25h';
+ansiEscapes.cursorLeft = ESC$1 + 'G';
+ansiEscapes.cursorSavePosition = isTerminalApp ? '\u001B7' : ESC$1 + 's';
+ansiEscapes.cursorRestorePosition = isTerminalApp ? '\u001B8' : ESC$1 + 'u';
+ansiEscapes.cursorGetPosition = ESC$1 + '6n';
+ansiEscapes.cursorNextLine = ESC$1 + 'E';
+ansiEscapes.cursorPrevLine = ESC$1 + 'F';
+ansiEscapes.cursorHide = ESC$1 + '?25l';
+ansiEscapes.cursorShow = ESC$1 + '?25h';
 
 ansiEscapes.eraseLines = count => {
 	let clear = '';
@@ -10708,24 +11046,24 @@ ansiEscapes.eraseLines = count => {
 	return clear;
 };
 
-ansiEscapes.eraseEndLine = ESC + 'K';
-ansiEscapes.eraseStartLine = ESC + '1K';
-ansiEscapes.eraseLine = ESC + '2K';
-ansiEscapes.eraseDown = ESC + 'J';
-ansiEscapes.eraseUp = ESC + '1J';
-ansiEscapes.eraseScreen = ESC + '2J';
-ansiEscapes.scrollUp = ESC + 'S';
-ansiEscapes.scrollDown = ESC + 'T';
+ansiEscapes.eraseEndLine = ESC$1 + 'K';
+ansiEscapes.eraseStartLine = ESC$1 + '1K';
+ansiEscapes.eraseLine = ESC$1 + '2K';
+ansiEscapes.eraseDown = ESC$1 + 'J';
+ansiEscapes.eraseUp = ESC$1 + '1J';
+ansiEscapes.eraseScreen = ESC$1 + '2J';
+ansiEscapes.scrollUp = ESC$1 + 'S';
+ansiEscapes.scrollDown = ESC$1 + 'T';
 
 ansiEscapes.clearScreen = '\u001Bc';
 
 ansiEscapes.clearTerminal = process.platform === 'win32' ?
-	`${ansiEscapes.eraseScreen}${ESC}0f` :
+	`${ansiEscapes.eraseScreen}${ESC$1}0f` :
 	// 1. Erases the screen (Only done in case `2` is not supported)
 	// 2. Erases the whole screen including scrollback buffer
 	// 3. Moves cursor to the top-left position
 	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
-	`${ansiEscapes.eraseScreen}${ESC}3J${ESC}H`;
+	`${ansiEscapes.eraseScreen}${ESC$1}3J${ESC$1}H`;
 
 ansiEscapes.beep = BEL;
 
@@ -11189,633 +11527,7 @@ createLogUpdate(process$1.stdout);
 
 createLogUpdate(process$1.stderr);
 
-var version = "0.32.4";
-
-const comma = ','.charCodeAt(0);
-const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-const intToChar = new Uint8Array(64); // 64 possible chars.
-const charToInt = new Uint8Array(128); // z is 122 in ASCII
-for (let i = 0; i < chars.length; i++) {
-    const c = chars.charCodeAt(i);
-    intToChar[i] = c;
-    charToInt[c] = i;
-}
-function decode(mappings) {
-    const state = new Int32Array(5);
-    const decoded = [];
-    let index = 0;
-    do {
-        const semi = indexOf(mappings, index);
-        const line = [];
-        let sorted = true;
-        let lastCol = 0;
-        state[0] = 0;
-        for (let i = index; i < semi; i++) {
-            let seg;
-            i = decodeInteger(mappings, i, state, 0); // genColumn
-            const col = state[0];
-            if (col < lastCol)
-                sorted = false;
-            lastCol = col;
-            if (hasMoreVlq(mappings, i, semi)) {
-                i = decodeInteger(mappings, i, state, 1); // sourcesIndex
-                i = decodeInteger(mappings, i, state, 2); // sourceLine
-                i = decodeInteger(mappings, i, state, 3); // sourceColumn
-                if (hasMoreVlq(mappings, i, semi)) {
-                    i = decodeInteger(mappings, i, state, 4); // namesIndex
-                    seg = [col, state[1], state[2], state[3], state[4]];
-                }
-                else {
-                    seg = [col, state[1], state[2], state[3]];
-                }
-            }
-            else {
-                seg = [col];
-            }
-            line.push(seg);
-        }
-        if (!sorted)
-            sort(line);
-        decoded.push(line);
-        index = semi + 1;
-    } while (index <= mappings.length);
-    return decoded;
-}
-function indexOf(mappings, index) {
-    const idx = mappings.indexOf(';', index);
-    return idx === -1 ? mappings.length : idx;
-}
-function decodeInteger(mappings, pos, state, j) {
-    let value = 0;
-    let shift = 0;
-    let integer = 0;
-    do {
-        const c = mappings.charCodeAt(pos++);
-        integer = charToInt[c];
-        value |= (integer & 31) << shift;
-        shift += 5;
-    } while (integer & 32);
-    const shouldNegate = value & 1;
-    value >>>= 1;
-    if (shouldNegate) {
-        value = -0x80000000 | -value;
-    }
-    state[j] += value;
-    return pos;
-}
-function hasMoreVlq(mappings, i, length) {
-    if (i >= length)
-        return false;
-    return mappings.charCodeAt(i) !== comma;
-}
-function sort(line) {
-    line.sort(sortComparator$1);
-}
-function sortComparator$1(a, b) {
-    return a[0] - b[0];
-}
-
-// Matches the scheme of a URL, eg "http://"
-const schemeRegex = /^[\w+.-]+:\/\//;
-/**
- * Matches the parts of a URL:
- * 1. Scheme, including ":", guaranteed.
- * 2. User/password, including "@", optional.
- * 3. Host, guaranteed.
- * 4. Port, including ":", optional.
- * 5. Path, including "/", optional.
- * 6. Query, including "?", optional.
- * 7. Hash, including "#", optional.
- */
-const urlRegex = /^([\w+.-]+:)\/\/([^@/#?]*@)?([^:/#?]*)(:\d+)?(\/[^#?]*)?(\?[^#]*)?(#.*)?/;
-/**
- * File URLs are weird. They dont' need the regular `//` in the scheme, they may or may not start
- * with a leading `/`, they can have a domain (but only if they don't start with a Windows drive).
- *
- * 1. Host, optional.
- * 2. Path, which may include "/", guaranteed.
- * 3. Query, including "?", optional.
- * 4. Hash, including "#", optional.
- */
-const fileRegex = /^file:(?:\/\/((?![a-z]:)[^/#?]*)?)?(\/?[^#?]*)(\?[^#]*)?(#.*)?/i;
-var UrlType;
-(function (UrlType) {
-    UrlType[UrlType["Empty"] = 1] = "Empty";
-    UrlType[UrlType["Hash"] = 2] = "Hash";
-    UrlType[UrlType["Query"] = 3] = "Query";
-    UrlType[UrlType["RelativePath"] = 4] = "RelativePath";
-    UrlType[UrlType["AbsolutePath"] = 5] = "AbsolutePath";
-    UrlType[UrlType["SchemeRelative"] = 6] = "SchemeRelative";
-    UrlType[UrlType["Absolute"] = 7] = "Absolute";
-})(UrlType || (UrlType = {}));
-function isAbsoluteUrl(input) {
-    return schemeRegex.test(input);
-}
-function isSchemeRelativeUrl(input) {
-    return input.startsWith('//');
-}
-function isAbsolutePath(input) {
-    return input.startsWith('/');
-}
-function isFileUrl(input) {
-    return input.startsWith('file:');
-}
-function isRelative(input) {
-    return /^[.?#]/.test(input);
-}
-function parseAbsoluteUrl(input) {
-    const match = urlRegex.exec(input);
-    return makeUrl(match[1], match[2] || '', match[3], match[4] || '', match[5] || '/', match[6] || '', match[7] || '');
-}
-function parseFileUrl(input) {
-    const match = fileRegex.exec(input);
-    const path = match[2];
-    return makeUrl('file:', '', match[1] || '', '', isAbsolutePath(path) ? path : '/' + path, match[3] || '', match[4] || '');
-}
-function makeUrl(scheme, user, host, port, path, query, hash) {
-    return {
-        scheme,
-        user,
-        host,
-        port,
-        path,
-        query,
-        hash,
-        type: UrlType.Absolute,
-    };
-}
-function parseUrl(input) {
-    if (isSchemeRelativeUrl(input)) {
-        const url = parseAbsoluteUrl('http:' + input);
-        url.scheme = '';
-        url.type = UrlType.SchemeRelative;
-        return url;
-    }
-    if (isAbsolutePath(input)) {
-        const url = parseAbsoluteUrl('http://foo.com' + input);
-        url.scheme = '';
-        url.host = '';
-        url.type = UrlType.AbsolutePath;
-        return url;
-    }
-    if (isFileUrl(input))
-        return parseFileUrl(input);
-    if (isAbsoluteUrl(input))
-        return parseAbsoluteUrl(input);
-    const url = parseAbsoluteUrl('http://foo.com/' + input);
-    url.scheme = '';
-    url.host = '';
-    url.type = input
-        ? input.startsWith('?')
-            ? UrlType.Query
-            : input.startsWith('#')
-                ? UrlType.Hash
-                : UrlType.RelativePath
-        : UrlType.Empty;
-    return url;
-}
-function stripPathFilename(path) {
-    // If a path ends with a parent directory "..", then it's a relative path with excess parent
-    // paths. It's not a file, so we can't strip it.
-    if (path.endsWith('/..'))
-        return path;
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
-function mergePaths(url, base) {
-    normalizePath(base, base.type);
-    // If the path is just a "/", then it was an empty path to begin with (remember, we're a relative
-    // path).
-    if (url.path === '/') {
-        url.path = base.path;
-    }
-    else {
-        // Resolution happens relative to the base path's directory, not the file.
-        url.path = stripPathFilename(base.path) + url.path;
-    }
-}
-/**
- * The path can have empty directories "//", unneeded parents "foo/..", or current directory
- * "foo/.". We need to normalize to a standard representation.
- */
-function normalizePath(url, type) {
-    const rel = type <= UrlType.RelativePath;
-    const pieces = url.path.split('/');
-    // We need to preserve the first piece always, so that we output a leading slash. The item at
-    // pieces[0] is an empty string.
-    let pointer = 1;
-    // Positive is the number of real directories we've output, used for popping a parent directory.
-    // Eg, "foo/bar/.." will have a positive 2, and we can decrement to be left with just "foo".
-    let positive = 0;
-    // We need to keep a trailing slash if we encounter an empty directory (eg, splitting "foo/" will
-    // generate `["foo", ""]` pieces). And, if we pop a parent directory. But once we encounter a
-    // real directory, we won't need to append, unless the other conditions happen again.
-    let addTrailingSlash = false;
-    for (let i = 1; i < pieces.length; i++) {
-        const piece = pieces[i];
-        // An empty directory, could be a trailing slash, or just a double "//" in the path.
-        if (!piece) {
-            addTrailingSlash = true;
-            continue;
-        }
-        // If we encounter a real directory, then we don't need to append anymore.
-        addTrailingSlash = false;
-        // A current directory, which we can always drop.
-        if (piece === '.')
-            continue;
-        // A parent directory, we need to see if there are any real directories we can pop. Else, we
-        // have an excess of parents, and we'll need to keep the "..".
-        if (piece === '..') {
-            if (positive) {
-                addTrailingSlash = true;
-                positive--;
-                pointer--;
-            }
-            else if (rel) {
-                // If we're in a relativePath, then we need to keep the excess parents. Else, in an absolute
-                // URL, protocol relative URL, or an absolute path, we don't need to keep excess.
-                pieces[pointer++] = piece;
-            }
-            continue;
-        }
-        // We've encountered a real directory. Move it to the next insertion pointer, which accounts for
-        // any popped or dropped directories.
-        pieces[pointer++] = piece;
-        positive++;
-    }
-    let path = '';
-    for (let i = 1; i < pointer; i++) {
-        path += '/' + pieces[i];
-    }
-    if (!path || (addTrailingSlash && !path.endsWith('/..'))) {
-        path += '/';
-    }
-    url.path = path;
-}
-/**
- * Attempts to resolve `input` URL/path relative to `base`.
- */
-function resolve$1(input, base) {
-    if (!input && !base)
-        return '';
-    const url = parseUrl(input);
-    let inputType = url.type;
-    if (base && inputType !== UrlType.Absolute) {
-        const baseUrl = parseUrl(base);
-        const baseType = baseUrl.type;
-        switch (inputType) {
-            case UrlType.Empty:
-                url.hash = baseUrl.hash;
-            // fall through
-            case UrlType.Hash:
-                url.query = baseUrl.query;
-            // fall through
-            case UrlType.Query:
-            case UrlType.RelativePath:
-                mergePaths(url, baseUrl);
-            // fall through
-            case UrlType.AbsolutePath:
-                // The host, user, and port are joined, you can't copy one without the others.
-                url.user = baseUrl.user;
-                url.host = baseUrl.host;
-                url.port = baseUrl.port;
-            // fall through
-            case UrlType.SchemeRelative:
-                // The input doesn't have a schema at least, so we need to copy at least that over.
-                url.scheme = baseUrl.scheme;
-        }
-        if (baseType > inputType)
-            inputType = baseType;
-    }
-    normalizePath(url, inputType);
-    const queryHash = url.query + url.hash;
-    switch (inputType) {
-        // This is impossible, because of the empty checks at the start of the function.
-        // case UrlType.Empty:
-        case UrlType.Hash:
-        case UrlType.Query:
-            return queryHash;
-        case UrlType.RelativePath: {
-            // The first char is always a "/", and we need it to be relative.
-            const path = url.path.slice(1);
-            if (!path)
-                return queryHash || '.';
-            if (isRelative(base || input) && !isRelative(path)) {
-                // If base started with a leading ".", or there is no base and input started with a ".",
-                // then we need to ensure that the relative path starts with a ".". We don't know if
-                // relative starts with a "..", though, so check before prepending.
-                return './' + path + queryHash;
-            }
-            return path + queryHash;
-        }
-        case UrlType.AbsolutePath:
-            return url.path + queryHash;
-        default:
-            return url.scheme + '//' + url.user + url.host + url.port + url.path + queryHash;
-    }
-}
-
-function resolve(input, base) {
-    // The base is always treated as a directory, if it's not empty.
-    // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
-    // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
-    if (base && !base.endsWith('/'))
-        base += '/';
-    return resolve$1(input, base);
-}
-
-/**
- * Removes everything after the last "/", but leaves the slash.
- */
-function stripFilename(path) {
-    if (!path)
-        return '';
-    const index = path.lastIndexOf('/');
-    return path.slice(0, index + 1);
-}
-
-const COLUMN = 0;
-const SOURCES_INDEX = 1;
-const SOURCE_LINE = 2;
-const SOURCE_COLUMN = 3;
-const REV_GENERATED_LINE = 1;
-const REV_GENERATED_COLUMN = 2;
-
-function maybeSort(mappings, owned) {
-    const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
-    if (unsortedIndex === mappings.length)
-        return mappings;
-    // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
-    // not, we do not want to modify the consumer's input array.
-    if (!owned)
-        mappings = mappings.slice();
-    for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
-        mappings[i] = sortSegments(mappings[i], owned);
-    }
-    return mappings;
-}
-function nextUnsortedSegmentLine(mappings, start) {
-    for (let i = start; i < mappings.length; i++) {
-        if (!isSorted(mappings[i]))
-            return i;
-    }
-    return mappings.length;
-}
-function isSorted(line) {
-    for (let j = 1; j < line.length; j++) {
-        if (line[j][COLUMN] < line[j - 1][COLUMN]) {
-            return false;
-        }
-    }
-    return true;
-}
-function sortSegments(line, owned) {
-    if (!owned)
-        line = line.slice();
-    return line.sort(sortComparator);
-}
-function sortComparator(a, b) {
-    return a[COLUMN] - b[COLUMN];
-}
-
-let found = false;
-/**
- * A binary search implementation that returns the index if a match is found.
- * If no match is found, then the left-index (the index associated with the item that comes just
- * before the desired index) is returned. To maintain proper sort order, a splice would happen at
- * the next index:
- *
- * ```js
- * const array = [1, 3];
- * const needle = 2;
- * const index = binarySearch(array, needle, (item, needle) => item - needle);
- *
- * assert.equal(index, 0);
- * array.splice(index + 1, 0, needle);
- * assert.deepEqual(array, [1, 2, 3]);
- * ```
- */
-function binarySearch(haystack, needle, low, high) {
-    while (low <= high) {
-        const mid = low + ((high - low) >> 1);
-        const cmp = haystack[mid][COLUMN] - needle;
-        if (cmp === 0) {
-            found = true;
-            return mid;
-        }
-        if (cmp < 0) {
-            low = mid + 1;
-        }
-        else {
-            high = mid - 1;
-        }
-    }
-    found = false;
-    return low - 1;
-}
-function upperBound(haystack, needle, index) {
-    for (let i = index + 1; i < haystack.length; index = i++) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
-}
-function lowerBound(haystack, needle, index) {
-    for (let i = index - 1; i >= 0; index = i--) {
-        if (haystack[i][COLUMN] !== needle)
-            break;
-    }
-    return index;
-}
-function memoizedState() {
-    return {
-        lastKey: -1,
-        lastNeedle: -1,
-        lastIndex: -1,
-    };
-}
-/**
- * This overly complicated beast is just to record the last tested line/column and the resulting
- * index, allowing us to skip a few tests if mappings are monotonically increasing.
- */
-function memoizedBinarySearch(haystack, needle, state, key) {
-    const { lastKey, lastNeedle, lastIndex } = state;
-    let low = 0;
-    let high = haystack.length - 1;
-    if (key === lastKey) {
-        if (needle === lastNeedle) {
-            found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
-            return lastIndex;
-        }
-        if (needle >= lastNeedle) {
-            // lastIndex may be -1 if the previous needle was not found.
-            low = lastIndex === -1 ? 0 : lastIndex;
-        }
-        else {
-            high = lastIndex;
-        }
-    }
-    state.lastKey = key;
-    state.lastNeedle = needle;
-    return (state.lastIndex = binarySearch(haystack, needle, low, high));
-}
-
-// Rebuilds the original source files, with mappings that are ordered by source line/column instead
-// of generated line/column.
-function buildBySources(decoded, memos) {
-    const sources = memos.map(buildNullArray);
-    for (let i = 0; i < decoded.length; i++) {
-        const line = decoded[i];
-        for (let j = 0; j < line.length; j++) {
-            const seg = line[j];
-            if (seg.length === 1)
-                continue;
-            const sourceIndex = seg[SOURCES_INDEX];
-            const sourceLine = seg[SOURCE_LINE];
-            const sourceColumn = seg[SOURCE_COLUMN];
-            const originalSource = sources[sourceIndex];
-            const originalLine = (originalSource[sourceLine] || (originalSource[sourceLine] = []));
-            const memo = memos[sourceIndex];
-            // The binary search either found a match, or it found the left-index just before where the
-            // segment should go. Either way, we want to insert after that. And there may be multiple
-            // generated segments associated with an original location, so there may need to move several
-            // indexes before we find where we need to insert.
-            const index = upperBound(originalLine, sourceColumn, memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine));
-            insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
-        }
-    }
-    return sources;
-}
-function insert(array, index, value) {
-    for (let i = array.length; i > index; i--) {
-        array[i] = array[i - 1];
-    }
-    array[index] = value;
-}
-// Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
-// a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
-// Numeric properties on objects are magically sorted in ascending order by the engine regardless of
-// the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
-// order when iterating with for-in.
-function buildNullArray() {
-    return { __proto__: null };
-}
-
-const LINE_GTR_ZERO = '`line` must be greater than 0 (lines start at line 1)';
-const COL_GTR_EQ_ZERO = '`column` must be greater than or equal to 0 (columns start at column 0)';
-const LEAST_UPPER_BOUND = -1;
-const GREATEST_LOWER_BOUND = 1;
-/**
- * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
- */
-let decodedMappings;
-/**
- * Finds the generated line/column position of the provided source/line/column source position.
- */
-let generatedPositionFor;
-class TraceMap {
-    constructor(map, mapUrl) {
-        const isString = typeof map === 'string';
-        if (!isString && map._decodedMemo)
-            return map;
-        const parsed = (isString ? JSON.parse(map) : map);
-        const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
-        this.version = version;
-        this.file = file;
-        this.names = names;
-        this.sourceRoot = sourceRoot;
-        this.sources = sources;
-        this.sourcesContent = sourcesContent;
-        const from = resolve(sourceRoot || '', stripFilename(mapUrl));
-        this.resolvedSources = sources.map((s) => resolve(s || '', from));
-        const { mappings } = parsed;
-        if (typeof mappings === 'string') {
-            this._encoded = mappings;
-            this._decoded = undefined;
-        }
-        else {
-            this._encoded = undefined;
-            this._decoded = maybeSort(mappings, isString);
-        }
-        this._decodedMemo = memoizedState();
-        this._bySources = undefined;
-        this._bySourceMemos = undefined;
-    }
-}
-(() => {
-    decodedMappings = (map) => {
-        return (map._decoded || (map._decoded = decode(map._encoded)));
-    };
-    generatedPositionFor = (map, { source, line, column, bias }) => {
-        return generatedPosition(map, source, line, column, bias || GREATEST_LOWER_BOUND, false);
-    };
-    function generatedPosition(map, source, line, column, bias, all) {
-        line--;
-        if (line < 0)
-            throw new Error(LINE_GTR_ZERO);
-        if (column < 0)
-            throw new Error(COL_GTR_EQ_ZERO);
-        const { sources, resolvedSources } = map;
-        let sourceIndex = sources.indexOf(source);
-        if (sourceIndex === -1)
-            sourceIndex = resolvedSources.indexOf(source);
-        if (sourceIndex === -1)
-            return all ? [] : GMapping(null, null);
-        const generated = (map._bySources || (map._bySources = buildBySources(decodedMappings(map), (map._bySourceMemos = sources.map(memoizedState)))));
-        const segments = generated[sourceIndex][line];
-        if (segments == null)
-            return all ? [] : GMapping(null, null);
-        const memo = map._bySourceMemos[sourceIndex];
-        if (all)
-            return sliceGeneratedPositions(segments, memo, line, column, bias);
-        const index = traceSegmentInternal(segments, memo, line, column, bias);
-        if (index === -1)
-            return GMapping(null, null);
-        const segment = segments[index];
-        return GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]);
-    }
-})();
-function GMapping(line, column) {
-    return { line, column };
-}
-function traceSegmentInternal(segments, memo, line, column, bias) {
-    let index = memoizedBinarySearch(segments, column, memo, line);
-    if (found) {
-        index = (bias === LEAST_UPPER_BOUND ? upperBound : lowerBound)(segments, column, index);
-    }
-    else if (bias === LEAST_UPPER_BOUND)
-        index++;
-    if (index === -1 || index === segments.length)
-        return -1;
-    return index;
-}
-function sliceGeneratedPositions(segments, memo, line, column, bias) {
-    let min = traceSegmentInternal(segments, memo, line, column, GREATEST_LOWER_BOUND);
-    // We ignored the bias when tracing the segment so that we're guarnateed to find the first (in
-    // insertion order) segment that matched. Even if we did respect the bias when tracing, we would
-    // still need to call `lowerBound()` to find the first segment, which is slower than just looking
-    // for the GREATEST_LOWER_BOUND to begin with. The only difference that matters for us is when the
-    // binary search didn't match, in which case GREATEST_LOWER_BOUND just needs to increment to
-    // match LEAST_UPPER_BOUND.
-    if (!found && bias === LEAST_UPPER_BOUND)
-        min++;
-    if (min === -1 || min === segments.length)
-        return [];
-    // We may have found the segment that started at an earlier column. If this is the case, then we
-    // need to slice all generated segments that match _that_ column, because all such segments span
-    // to our desired column.
-    const matchedColumn = found ? column : segments[min][COLUMN];
-    // The binary search is not guaranteed to find the lower bound when a match wasn't found.
-    if (!found)
-        min = lowerBound(segments, matchedColumn, min);
-    const max = upperBound(segments, matchedColumn, min);
-    const result = [];
-    for (; min <= max; min++) {
-        const segment = segments[min];
-        result.push(GMapping(segment[REV_GENERATED_LINE] + 1, segment[REV_GENERATED_COLUMN]));
-    }
-    return result;
-}
+var version = "0.34.0";
 
 const A=r=>r!==null&&typeof r=="object",a=(r,t)=>Object.assign(new Error(`[${r}]: ${t}`),{code:r}),_$1="ERR_INVALID_PACKAGE_CONFIG",E="ERR_INVALID_PACKAGE_TARGET",I="ERR_PACKAGE_PATH_NOT_EXPORTED",R$1=/^\d+$/,O=/^(\.{1,2}|node_modules)$/i,w=/\/|\\/;var h=(r=>(r.Export="exports",r.Import="imports",r))(h||{});const f=(r,t,e,o,c)=>{if(t==null)return [];if(typeof t=="string"){const[n,...i]=t.split(w);if(n===".."||i.some(l=>O.test(l)))throw a(E,`Invalid "${r}" target "${t}" defined in the package config`);return [c?t.replace(/\*/g,c):t]}if(Array.isArray(t))return t.flatMap(n=>f(r,n,e,o,c));if(A(t)){for(const n of Object.keys(t)){if(R$1.test(n))throw a(_$1,"Cannot contain numeric property keys");if(n==="default"||o.includes(n))return f(r,t[n],e,o,c)}return []}throw a(E,`Invalid "${r}" target "${t}"`)},s="*",m=(r,t)=>{const e=r.indexOf(s),o=t.indexOf(s);return e===o?t.length>r.length:o>e};function d$1(r,t){if(!t.includes(s)&&r.hasOwnProperty(t))return [t];let e,o;for(const c of Object.keys(r))if(c.includes(s)){const[n,i,l]=c.split(s);if(l===void 0&&t.startsWith(n)&&t.endsWith(i)){const g=t.slice(n.length,-i.length||void 0);g&&(!e||m(e,c))&&(e=c,o=g);}}return [e,o]}const p=r=>Object.keys(r).reduce((t,e)=>{const o=e===""||e[0]!==".";if(t===void 0||t===o)return o;throw a(_$1,'"exports" cannot contain some keys starting with "." and some not')},void 0),u=/^\w+:/,v=(r,t,e)=>{if(!r)throw new Error('"exports" is required');t=t===""?".":`./${t}`,(typeof r=="string"||Array.isArray(r)||A(r)&&p(r))&&(r={".":r});const[o,c]=d$1(r,t),n=f(h.Export,r[o],t,e,c);if(n.length===0)throw a(I,t==="."?'No "exports" main defined':`Package subpath '${t}' is not defined by "exports"`);for(const i of n)if(!i.startsWith("./")&&!u.test(i))throw a(E,`Invalid "exports" target "${i}" defined in the package config`);return n};
 
@@ -11860,7 +11572,7 @@ async function makeTscErrorInfo(errInfo) {
 }
 async function getTsconfig(root, config) {
   const configName = config.tsconfig ? basename(config.tsconfig) : void 0;
-  const configSearchPath = config.tsconfig ? dirname(resolve$2(root, config.tsconfig)) : root;
+  const configSearchPath = config.tsconfig ? dirname(resolve(root, config.tsconfig)) : root;
   const tsconfig = Te(configSearchPath, configName);
   if (!tsconfig)
     throw new Error("no tsconfig.json found");
@@ -12183,7 +11895,7 @@ class Typechecker {
     const errorsMap = await getRawErrsMapFromTsCompile(output);
     const typesErrors = /* @__PURE__ */ new Map();
     errorsMap.forEach((errors, path) => {
-      const filepath = resolve$2(this.ctx.config.root, path);
+      const filepath = resolve(this.ctx.config.root, path);
       const suiteErrors = errors.map((info) => {
         const limit = Error.stackTraceLimit;
         Error.stackTraceLimit = 0;
@@ -12292,8 +12004,9 @@ class Typechecker {
   }
 }
 
-async function printError(error, ctx, options = {}) {
+async function printError(error, project, options) {
   const { showCodeFrame = true, fullStack = false, type } = options;
+  const logger = options.logger;
   let e = error;
   if (isPrimitive(e)) {
     e = {
@@ -12308,25 +12021,31 @@ async function printError(error, ctx, options = {}) {
       stack: error2.stack
     };
   }
-  if (!ctx.config)
-    return printErrorMessage(e, ctx.logger);
-  const stacks = parseErrorStacktrace(e, fullStack ? [] : void 0);
+  if (!project)
+    return printErrorMessage(e, logger);
+  const parserOptions = {
+    // only browser stack traces require remapping
+    getSourceMap: (file) => project.getBrowserSourceMapModuleById(file)
+  };
+  if (fullStack)
+    parserOptions.ignoreStackEntries = [];
+  const stacks = parseErrorStacktrace(e, parserOptions);
   const nearest = error instanceof TypeCheckError ? error.stacks[0] : stacks.find(
-    (stack) => ctx.getModuleProjects(stack.file).length && existsSync(stack.file)
+    (stack) => project.getModuleById(stack.file) && existsSync(stack.file)
   );
   const errorProperties = getErrorProperties(e);
   if (type)
-    printErrorType(type, ctx);
-  printErrorMessage(e, ctx.logger);
+    printErrorType(type, project.ctx);
+  printErrorMessage(e, logger);
   if (e.diff)
-    displayDiff(e.diff, ctx.logger.console);
+    displayDiff(e.diff, logger.console);
   if (e.frame) {
-    ctx.logger.error(c.yellow(e.frame));
+    logger.error(c.yellow(e.frame));
   } else {
-    printStack(ctx, stacks, nearest, errorProperties, (s) => {
+    printStack(project, stacks, nearest, errorProperties, (s) => {
       if (showCodeFrame && s === nearest && nearest) {
         const sourceCode = readFileSync(nearest.file, "utf-8");
-        ctx.logger.error(generateCodeFrame(sourceCode, 4, s.line, s.column));
+        logger.error(generateCodeFrame(sourceCode, 4, s.line, s.column));
       }
     });
   }
@@ -12334,20 +12053,20 @@ async function printError(error, ctx, options = {}) {
   const testName = e.VITEST_TEST_NAME;
   const afterEnvTeardown = e.VITEST_AFTER_ENV_TEARDOWN;
   if (testPath)
-    ctx.logger.error(c.red(`This error originated in "${c.bold(testPath)}" test file. It doesn't mean the error was thrown inside the file itself, but while it was running.`));
+    logger.error(c.red(`This error originated in "${c.bold(testPath)}" test file. It doesn't mean the error was thrown inside the file itself, but while it was running.`));
   if (testName) {
-    ctx.logger.error(c.red(`The latest test that might've caused the error is "${c.bold(testName)}". It might mean one of the following:
+    logger.error(c.red(`The latest test that might've caused the error is "${c.bold(testName)}". It might mean one of the following:
 - The error was thrown, while Vitest was running this test.
 - This was the last recorded test before the error was thrown, if error originated after test finished its execution.`));
   }
   if (afterEnvTeardown) {
-    ctx.logger.error(c.red("This error was caught after test environment was torn down. Make sure to cancel any running tasks before test finishes:\n- cancel timeouts using clearTimeout and clearInterval\n- wait for promises to resolve using the await keyword"));
+    logger.error(c.red("This error was caught after test environment was torn down. Make sure to cancel any running tasks before test finishes:\n- cancel timeouts using clearTimeout and clearInterval\n- wait for promises to resolve using the await keyword"));
   }
   if (typeof e.cause === "object" && e.cause && "name" in e.cause) {
     e.cause.name = `Caused by: ${e.cause.name}`;
-    await printError(e.cause, ctx, { fullStack, showCodeFrame: false });
+    await printError(e.cause, project, { fullStack, showCodeFrame: false, logger: options.logger });
   }
-  handleImportOutsideModuleError(e.stack || e.stackStr || "", ctx);
+  handleImportOutsideModuleError(e.stack || e.stackStr || "", logger);
 }
 function printErrorType(type, ctx) {
   ctx.logger.error(`
@@ -12384,7 +12103,7 @@ const esmErrors = [
   "Cannot use import statement outside a module",
   "Unexpected token 'export'"
 ];
-function handleImportOutsideModuleError(stack, ctx) {
+function handleImportOutsideModuleError(stack, logger) {
   if (!esmErrors.some((e) => stack.includes(e)))
     return;
   const path = normalize(stack.split("\n")[0].trim());
@@ -12394,9 +12113,9 @@ function handleImportOutsideModuleError(stack, ctx) {
   else
     name = name.split("/")[0];
   if (name)
-    printModuleWarningForPackage(ctx.logger, path, name);
+    printModuleWarningForPackage(logger, path, name);
   else
-    printModuleWarningForSourceCode(ctx.logger, path);
+    printModuleWarningForSourceCode(logger, path);
 }
 function printModuleWarningForPackage(logger, path, name) {
   logger.error(c.yellow(
@@ -12429,17 +12148,21 @@ ${diff}
 }
 function printErrorMessage(error, logger) {
   const errorName = error.name || error.nameStr || "Unknown Error";
+  if (!error.message) {
+    logger.error(error);
+    return;
+  }
   if (error.message.length > 5e3) {
     logger.error(`${c.red(c.bold(errorName))}: ${error.message}`);
   } else {
     logger.error(c.red(`${c.bold(errorName)}: ${error.message}`));
   }
 }
-function printStack(ctx, stack, highlight, errorProperties, onStack) {
-  const logger = ctx.logger;
+function printStack(project, stack, highlight, errorProperties, onStack) {
+  const logger = project.ctx.logger;
   for (const frame of stack) {
     const color = frame === highlight ? c.cyan : c.gray;
-    const path = relative(ctx.config.root, frame.file);
+    const path = relative(project.config.root, frame.file);
     logger.error(color(` ${c.dim(F_POINTER)} ${[frame.method, `${path}:${c.dim(`${frame.line}:${frame.column}`)}`].filter(Boolean).join(" ")}`));
     onStack == null ? void 0 : onStack(frame);
   }
@@ -12448,7 +12171,7 @@ function printStack(ctx, stack, highlight, errorProperties, onStack) {
   const hasProperties = Object.keys(errorProperties).length > 0;
   if (hasProperties) {
     logger.error(c.red(c.dim(divider())));
-    const propertiesString = stringify$5(errorProperties, 10, { printBasicPrototype: false });
+    const propertiesString = inspect(errorProperties);
     logger.error(c.red(c.bold("Serialized Error:")), c.gray(propertiesString));
   }
 }
@@ -12493,6 +12216,11 @@ function generateCodeFrame(source, indent = 0, lineNumber, columnNumber, range =
   return res.join("\n");
 }
 
+const ESC = "\x1B[";
+const ERASE_DOWN = `${ESC}J`;
+const ERASE_SCROLLBACK = `${ESC}3J`;
+const CURSOR_TO_START = `${ESC}1;1H`;
+const CLEAR_SCREEN = "\x1Bc";
 class Logger {
   constructor(ctx, console = globalThis.console) {
     this.ctx = ctx;
@@ -12519,7 +12247,7 @@ class Logger {
       this.console.log(message);
       return;
     }
-    this.console.log(`\x1Bc${message}`);
+    this.console.log(`${ERASE_SCROLLBACK}${CLEAR_SCREEN}${message}`);
   }
   clearScreen(message, force = false) {
     if (this.ctx.server.config.clearScreen === false) {
@@ -12535,16 +12263,20 @@ class Logger {
       return;
     const log = this._clearScreenPending;
     this._clearScreenPending = void 0;
-    this.console.log(`\x1B[1;1H\x1B[J${log}`);
+    this.console.log(`${CURSOR_TO_START}${ERASE_DOWN}${log}`);
   }
-  printError(err, fullStack = false, type) {
-    return printError(err, this.ctx, {
+  printError(err, options = {}) {
+    const { fullStack = false, type } = options;
+    const project = options.project ?? this.ctx.getCoreWorkspaceProject() ?? this.ctx.projects[0];
+    return printError(err, project, {
       fullStack,
       type,
-      showCodeFrame: true
+      showCodeFrame: true,
+      logger: this
     });
   }
   printNoTestFound(filters) {
+    var _a;
     const config = this.ctx.config;
     const comma = c.dim(", ");
     if (filters == null ? void 0 : filters.length)
@@ -12555,12 +12287,17 @@ class Logger {
       this.console.error(c.dim("exclude:  ") + c.yellow(config.exclude.join(comma)));
     if (config.watchExclude)
       this.console.error(c.dim("watch exclude:  ") + c.yellow(config.watchExclude.join(comma)));
-    if (config.passWithNoTests)
-      this.log(`No ${config.mode} files found, exiting with code 0
+    if (config.watch && (config.changed || ((_a = config.related) == null ? void 0 : _a.length))) {
+      this.log(`No affected ${config.mode} files found
 `);
-    else
-      this.error(c.red(`
+    } else {
+      if (config.passWithNoTests)
+        this.log(`No ${config.mode} files found, exiting with code 0
+`);
+      else
+        this.error(c.red(`
 No ${config.mode} files found, exiting with code 1`));
+    }
   }
   printBanner() {
     var _a, _b;
@@ -12595,7 +12332,7 @@ This might cause false positive tests. Resolve unhandled errors to make sure you
     this.log(c.red(divider(c.bold(c.inverse(" Unhandled Errors ")))));
     this.log(errorMessage);
     await Promise.all(errors.map(async (err) => {
-      await this.printError(err, true, err.type || "Unhandled Error");
+      await this.printError(err, { fullStack: true, type: err.type || "Unhandled Error" });
     }));
     this.log(c.red(divider()));
   }
@@ -12607,7 +12344,7 @@ Vitest found ${errors.length} error${errors.length > 1 ? "s" : ""} not related t
     this.log(c.red(divider(c.bold(c.inverse(" Source Errors ")))));
     this.log(errorMessage);
     await Promise.all(errors.map(async (err) => {
-      await this.printError(err, true);
+      await this.printError(err, { fullStack: true });
     }));
     this.log(c.red(divider()));
   }
@@ -12766,7 +12503,7 @@ function MocksPlugin() {
 async function createBrowserServer(project, options) {
   const root = project.config.root;
   await ensurePackageInstalled("@vitest/browser", root);
-  const configPath = options.config === false ? false : options.config ? resolve$2(root, options.config) : await findUp(configFiles, { cwd: root });
+  const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
   const server = await createServer({
     logLevel: "error",
     mode: project.config.mode,
@@ -12804,7 +12541,7 @@ async function createBrowserServer(project, options) {
   });
   await server.listen();
   await server.watcher.close();
-  (await import('./chunk-api-setup.8f785c4a.js')).setup(project, server);
+  (await import('./chunk-api-setup.644415c3.js')).setup(project, server);
   return server;
 }
 
@@ -13007,21 +12744,29 @@ function CSSEnablerPlugin(ctx) {
   ];
 }
 
-function EnvReplacerPlugin() {
+function SsrReplacerPlugin() {
   return {
     name: "vitest:env-replacer",
     enforce: "pre",
     transform(code, id) {
-      if (!/\bimport\.meta\.env\b/g.test(code))
+      if (!/\bimport\.meta\.env\b/.test(code) && !/\bimport\.meta\.url\b/.test(code))
         return null;
       let s = null;
-      const envs = stripLiteral(code).matchAll(/\bimport\.meta\.env\b/g);
+      const cleanCode = stripLiteral(code);
+      const envs = cleanCode.matchAll(/\bimport\.meta\.env\b/g);
       for (const env of envs) {
         s || (s = new MagicString(code));
         const startIndex = env.index;
         const endIndex = startIndex + env[0].length;
         s.overwrite(startIndex, endIndex, "process.env");
       }
+      const urls = cleanCode.matchAll(/\bimport\.meta\.url\b/g);
+      for (const env of urls) {
+        s || (s = new MagicString(code));
+        const startIndex = env.index;
+        const endIndex = startIndex + env[0].length;
+        s.overwrite(startIndex, endIndex, "__vite_ssr_import_meta__.url");
+      }
       if (s) {
         return {
           code: s.toString(),
@@ -13105,14 +12850,17 @@ ${c.red(divider(c.bold(c.inverse(" Error during global setup "))))}`);
   };
 }
 
-function resolveOptimizerConfig(testOptionc, viteOptions, testConfig) {
+function resolveOptimizerConfig(_testOptions, viteOptions, testConfig) {
   var _a;
+  const testOptions = _testOptions || {};
   const newConfig = {};
   const [major, minor] = version$2.split(".").map(Number);
   const allowed = major >= 5 || major === 4 && minor >= 3;
-  if (!allowed && (testOptionc == null ? void 0 : testOptionc.enabled) === true)
+  if (!allowed && (testOptions == null ? void 0 : testOptions.enabled) === true)
     console.warn(`Vitest: "deps.optimizer" is only available in Vite >= 4.3.0, current Vite version: ${version$2}`);
-  if (!allowed || (testOptionc == null ? void 0 : testOptionc.enabled) !== true) {
+  else
+    testOptions.enabled ?? (testOptions.enabled = true);
+  if (!allowed || (testOptions == null ? void 0 : testOptions.enabled) !== true) {
     newConfig.cacheDir = void 0;
     newConfig.optimizeDeps = {
       // experimental in Vite >2.9.2, entries remains to help with older versions
@@ -13124,12 +12872,12 @@ function resolveOptimizerConfig(testOptionc, viteOptions, testConfig) {
     newConfig.cacheDir = cacheDir ?? "node_modules/.vitest";
     newConfig.optimizeDeps = {
       ...viteOptions,
-      ...testOptionc,
+      ...testOptions,
       noDiscovery: true,
       disabled: false,
       entries: [],
-      exclude: ["vitest", ...builtinModules, ...testOptionc.exclude || (viteOptions == null ? void 0 : viteOptions.exclude) || []],
-      include: (testOptionc.include || (viteOptions == null ? void 0 : viteOptions.include) || []).filter((n) => n !== "vitest")
+      exclude: ["vitest", ...builtinModules, ...testOptions.exclude || (viteOptions == null ? void 0 : viteOptions.exclude) || []],
+      include: (testOptions.include || (viteOptions == null ? void 0 : viteOptions.include) || []).filter((n) => n !== "vitest")
     };
   }
   return newConfig;
@@ -13247,8 +12995,8 @@ function WorkspaceVitestPlugin(project, options) {
             };
           }
         }
-        const webOptimizer = resolveOptimizerConfig((_e = (_d = testConfig.deps) == null ? void 0 : _d.experimentalOptimizer) == null ? void 0 : _e.web, viteConfig.optimizeDeps, testConfig);
-        const ssrOptimizer = resolveOptimizerConfig((_g = (_f = testConfig.deps) == null ? void 0 : _f.experimentalOptimizer) == null ? void 0 : _g.ssr, (_h = viteConfig.ssr) == null ? void 0 : _h.optimizeDeps, testConfig);
+        const webOptimizer = resolveOptimizerConfig((_e = (_d = testConfig.deps) == null ? void 0 : _d.optimizer) == null ? void 0 : _e.web, viteConfig.optimizeDeps, testConfig);
+        const ssrOptimizer = resolveOptimizerConfig((_g = (_f = testConfig.deps) == null ? void 0 : _f.optimizer) == null ? void 0 : _g.ssr, (_h = viteConfig.ssr) == null ? void 0 : _h.optimizeDeps, testConfig);
         config.cacheDir = webOptimizer.cacheDir || ssrOptimizer.cacheDir || config.cacheDir;
         config.optimizeDeps = webOptimizer.optimizeDeps;
         config.ssr = {
@@ -13265,13 +13013,13 @@ function WorkspaceVitestPlugin(project, options) {
           );
           await project.setServer(options2, server);
         } catch (err) {
-          await project.ctx.logger.printError(err, true);
+          await project.ctx.logger.printError(err, { fullStack: true });
           process.exit(1);
         }
         await server.watcher.close();
       }
     },
-    EnvReplacerPlugin(),
+    SsrReplacerPlugin(),
     ...CSSEnablerPlugin(project),
     CoverageTransform(project.ctx),
     GlobalSetupPlugin(project, project.ctx.logger),
@@ -13283,7 +13031,7 @@ function WorkspaceVitestPlugin(project, options) {
 async function initializeProject(workspacePath, ctx, options) {
   var _a, _b, _c, _d, _e, _f, _g;
   const project = new WorkspaceProject(workspacePath, ctx);
-  const configFile = options.extends ? resolve$2(dirname(options.workspaceConfigPath), options.extends) : typeof workspacePath === "number" || workspacePath.endsWith("/") ? false : workspacePath;
+  const configFile = options.extends ? resolve(dirname(options.workspaceConfigPath), options.extends) : typeof workspacePath === "number" || workspacePath.endsWith("/") ? false : workspacePath;
   const root = options.root || (typeof workspacePath === "number" ? void 0 : dirname(workspacePath));
   const config = {
     ...options,
@@ -13298,7 +13046,7 @@ async function initializeProject(workspacePath, ctx, options) {
     ]
   };
   const server = await createServer(config);
-  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = project.config.deps) == null ? void 0 : _b.experimentalOptimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = project.config.deps) == null ? void 0 : _e.experimentalOptimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
+  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = project.config.deps) == null ? void 0 : _b.optimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = project.config.deps) == null ? void 0 : _e.optimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
     await server.listen();
   else
     await server.pluginContainer.buildStart({});
@@ -13314,16 +13062,30 @@ class WorkspaceProject {
   server;
   vitenode;
   runner;
-  browser = void 0;
+  browser;
   typechecker;
   closingPromise;
   browserProvider;
+  testFilesList = [];
   getName() {
     return this.config.name || "";
   }
   isCore() {
     return this.ctx.getCoreWorkspaceProject() === this;
   }
+  getModuleById(id) {
+    var _a;
+    return this.server.moduleGraph.getModuleById(id) || ((_a = this.browser) == null ? void 0 : _a.moduleGraph.getModuleById(id));
+  }
+  getSourceMapModuleById(id) {
+    var _a, _b;
+    const mod = this.server.moduleGraph.getModuleById(id);
+    return ((_a = mod == null ? void 0 : mod.ssrTransformResult) == null ? void 0 : _a.map) || ((_b = mod == null ? void 0 : mod.transformResult) == null ? void 0 : _b.map);
+  }
+  getBrowserSourceMapModuleById(id) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.browser) == null ? void 0 : _a.moduleGraph.getModuleById(id)) == null ? void 0 : _b.transformResult) == null ? void 0 : _c.map;
+  }
   get reporters() {
     return this.ctx.reporters;
   }
@@ -13347,8 +13109,12 @@ class WorkspaceProject {
         }
       }));
     }
+    this.testFilesList = testFiles;
     return testFiles;
   }
+  isTestFile(id) {
+    return this.testFilesList.includes(id);
+  }
   async globFiles(include, exclude, cwd) {
     const globOptions = {
       absolute: true,
@@ -13485,10 +13251,10 @@ class WorkspaceProject {
           ...this.config.deps,
           optimizer: {
             web: {
-              enabled: ((_c = (_b = (_a = this.config.deps) == null ? void 0 : _a.experimentalOptimizer) == null ? void 0 : _b.web) == null ? void 0 : _c.enabled) ?? false
+              enabled: ((_c = (_b = (_a = this.config.deps) == null ? void 0 : _a.optimizer) == null ? void 0 : _b.web) == null ? void 0 : _c.enabled) ?? false
             },
             ssr: {
-              enabled: ((_f = (_e = (_d = this.config.deps) == null ? void 0 : _d.experimentalOptimizer) == null ? void 0 : _e.ssr) == null ? void 0 : _f.enabled) ?? false
+              enabled: ((_f = (_e = (_d = this.config.deps) == null ? void 0 : _d.optimizer) == null ? void 0 : _e.ssr) == null ? void 0 : _f.enabled) ?? false
             }
           }
         },
@@ -13590,7 +13356,7 @@ class Vitest {
     this.snapshot = new SnapshotManager({ ...resolved.snapshotOptions });
     if (this.config.watch && this.mode !== "typecheck")
       this.registerWatcher();
-    this.vitenode = new ViteNodeServer(server, this.config);
+    this.vitenode = new ViteNodeServer(server, this.config.server);
     const node = this.vitenode;
     this.runner = new ViteNodeRunner({
       root: server.config.root,
@@ -13640,6 +13406,12 @@ class Vitest {
   getCoreWorkspaceProject() {
     return this.coreWorkspace || null;
   }
+  getProjectByTaskId(taskId) {
+    var _a;
+    const task = this.state.idMap.get(taskId);
+    const projectName = task.projectName || ((_a = task == null ? void 0 : task.file) == null ? void 0 : _a.projectName);
+    return this.projects.find((p) => p.getName() === projectName) || this.getCoreWorkspaceProject() || this.projects[0];
+  }
   async resolveWorkspace(options, cliOptions) {
     const configDir = this.server.config.configFile ? dirname(this.server.config.configFile) : this.config.root;
     const rootFiles = await promises.readdir(configDir);
@@ -13739,7 +13511,7 @@ class Vitest {
     return Promise.all(this.projects.map((project) => project.typecheck(filters)));
   }
   async start(filters) {
-    var _a;
+    var _a, _b;
     if (this.mode === "typecheck") {
       await this.typecheck(filters);
       return;
@@ -13755,32 +13527,40 @@ class Vitest {
       await this.globTestFiles(filters)
     );
     if (!files.length) {
-      const exitCode = this.config.passWithNoTests ? 0 : 1;
       await this.reportCoverage(true);
       this.logger.printNoTestFound(filters);
-      process.exit(exitCode);
+      if (!this.config.watch || !(this.config.changed || ((_b = this.config.related) == null ? void 0 : _b.length))) {
+        const exitCode = this.config.passWithNoTests ? 0 : 1;
+        process.exit(exitCode);
+      }
+    }
+    this.config.changed = false;
+    this.config.related = void 0;
+    if (files.length) {
+      await this.cache.stats.populateStats(this.config.root, files);
+      await this.runFiles(files);
     }
-    await this.cache.stats.populateStats(this.config.root, files);
-    await this.runFiles(files);
     await this.reportCoverage(true);
     if (this.config.watch)
       await this.report("onWatcherStart");
   }
-  async getTestDependencies(filepath) {
-    const deps = /* @__PURE__ */ new Set();
+  async getTestDependencies(filepath, deps = /* @__PURE__ */ new Set()) {
     const addImports = async ([project, filepath2]) => {
-      const transformed = await project.vitenode.transformRequest(filepath2);
+      if (deps.has(filepath2))
+        return;
+      const mod = project.server.moduleGraph.getModuleById(filepath2);
+      const transformed = (mod == null ? void 0 : mod.ssrTransformResult) || await project.vitenode.transformRequest(filepath2);
       if (!transformed)
         return;
       const dependencies = [...transformed.deps || [], ...transformed.dynamicDeps || []];
-      for (const dep of dependencies) {
+      await Promise.all(dependencies.map(async (dep) => {
         const path = await this.server.pluginContainer.resolveId(dep, filepath2, { ssr: true });
         const fsPath = path && !path.external && path.id.split("?")[0];
         if (fsPath && !fsPath.includes("node_modules") && !deps.has(fsPath) && existsSync(fsPath)) {
           deps.add(fsPath);
           await addImports([project, fsPath]);
         }
-      }
+      }));
     };
     await addImports(filepath);
     return deps;
@@ -13804,7 +13584,7 @@ class Vitest {
     const forceRerunTriggers = this.config.forceRerunTriggers;
     if (forceRerunTriggers.length && mm(related, forceRerunTriggers).length)
       return specs;
-    if (!related.length)
+    if (!this.config.watch && !related.length)
       return [];
     const testGraphs = await Promise.all(
       specs.map(async (spec) => {
@@ -13940,8 +13720,7 @@ class Vitest {
   }
   getModuleProjects(id) {
     return this.projects.filter((project) => {
-      var _a, _b, _c;
-      return project.server.moduleGraph.getModuleById(id) || ((_a = project.browser) == null ? void 0 : _a.moduleGraph.getModuleById(id)) || ((_c = (_b = project.browser) == null ? void 0 : _b.moduleGraph.getModulesByFile(id)) == null ? void 0 : _c.size);
+      return project.getModuleById(id);
     });
   }
   unregisterWatcher = noop$1;
@@ -14008,13 +13787,14 @@ class Vitest {
       return [];
     if (mm.isMatch(id, this.config.forceRerunTriggers)) {
       this.state.getFilepaths().forEach((file) => this.changedTests.add(file));
-      return [];
+      return [id];
     }
     const projects = this.getModuleProjects(id);
     if (!projects.length)
       return [];
     const files = [];
-    for (const { server, browser } of projects) {
+    for (const project of projects) {
+      const { server, browser } = project;
       const mod = server.moduleGraph.getModuleById(id) || (browser == null ? void 0 : browser.moduleGraph.getModuleById(id));
       if (!mod) {
         const mods = browser == null ? void 0 : browser.moduleGraph.getModulesByFile(id);
@@ -14031,7 +13811,7 @@ class Vitest {
       }
       id = normalizeRequestId(id, server.config.base);
       this.invalidates.add(id);
-      if (this.state.filesMap.has(id)) {
+      if (this.state.filesMap.has(id) || project.isTestFile(id)) {
         this.changedTests.add(id);
         files.push(id);
         continue;
@@ -14196,6 +13976,10 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
             preTransformRequests: false
           }
         };
+        if (process.platform === "darwin" && process.env.VITE_TEST_WATCHER_DEBUG) {
+          config.server.watch.useFsEvents = false;
+          config.server.watch.usePolling = false;
+        }
         const classNameStrategy = typeof testConfig.css !== "boolean" && ((_c = (_b = testConfig.css) == null ? void 0 : _b.modules) == null ? void 0 : _c.classNameStrategy) || "stable";
         if (classNameStrategy !== "scoped") {
           config.css ?? (config.css = {});
@@ -14207,8 +13991,8 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
             };
           }
         }
-        const webOptimizer = resolveOptimizerConfig((_f = (_e = testConfig.deps) == null ? void 0 : _e.experimentalOptimizer) == null ? void 0 : _f.web, viteConfig.optimizeDeps, testConfig);
-        const ssrOptimizer = resolveOptimizerConfig((_h = (_g = testConfig.deps) == null ? void 0 : _g.experimentalOptimizer) == null ? void 0 : _h.ssr, (_i = viteConfig.ssr) == null ? void 0 : _i.optimizeDeps, testConfig);
+        const webOptimizer = resolveOptimizerConfig((_f = (_e = testConfig.deps) == null ? void 0 : _e.optimizer) == null ? void 0 : _f.web, viteConfig.optimizeDeps, testConfig);
+        const ssrOptimizer = resolveOptimizerConfig((_h = (_g = testConfig.deps) == null ? void 0 : _g.optimizer) == null ? void 0 : _h.ssr, (_i = viteConfig.ssr) == null ? void 0 : _i.optimizeDeps, testConfig);
         config.cacheDir = webOptimizer.cacheDir || ssrOptimizer.cacheDir || config.cacheDir;
         config.optimizeDeps = webOptimizer.optimizeDeps;
         config.ssr = {
@@ -14245,19 +14029,24 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
         }
       },
       async configureServer(server) {
+        if (options.watch && process.env.VITE_TEST_WATCHER_DEBUG) {
+          server.watcher.on("ready", () => {
+            console.log("[debug] watcher is ready");
+          });
+        }
         try {
           await ctx.setServer(options, server, userConfig);
           if (options.api && options.watch)
-            (await import('./chunk-api-setup.8f785c4a.js')).setup(ctx);
+            (await import('./chunk-api-setup.644415c3.js')).setup(ctx);
         } catch (err) {
-          await ctx.logger.printError(err, true);
+          await ctx.logger.printError(err, { fullStack: true });
           process.exit(1);
         }
         if (!options.watch)
           await server.watcher.close();
       }
     },
-    EnvReplacerPlugin(),
+    SsrReplacerPlugin(),
     GlobalSetupPlugin(ctx, ctx.logger),
     ...CSSEnablerPlugin(ctx),
     CoverageTransform(ctx),
@@ -14270,8 +14059,8 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
 async function createVitest(mode, options, viteOverrides = {}) {
   var _a, _b, _c, _d, _e, _f, _g;
   const ctx = new Vitest(mode);
-  const root = resolve$2(options.root || process.cwd());
-  const configPath = options.config === false ? false : options.config ? resolve$2(root, options.config) : await findUp(configFiles, { cwd: root });
+  const root = resolve(options.root || process.cwd());
+  const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : await findUp(configFiles, { cwd: root });
   const config = {
     logLevel: "error",
     configFile: configPath,
@@ -14280,7 +14069,7 @@ async function createVitest(mode, options, viteOverrides = {}) {
     plugins: await VitestPlugin(options, ctx)
   };
   const server = await createServer(mergeConfig(config, mergeConfig(viteOverrides, { root: options.root })));
-  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = ctx.config.deps) == null ? void 0 : _b.experimentalOptimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = ctx.config.deps) == null ? void 0 : _e.experimentalOptimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
+  if (((_a = ctx.config.api) == null ? void 0 : _a.port) || ((_d = (_c = (_b = ctx.config.deps) == null ? void 0 : _b.optimizer) == null ? void 0 : _c.web) == null ? void 0 : _d.enabled) || ((_g = (_f = (_e = ctx.config.deps) == null ? void 0 : _e.optimizer) == null ? void 0 : _f.ssr) == null ? void 0 : _g.enabled))
     await server.listen();
   else
     await server.pluginContainer.buildStart({});
@@ -20674,13 +20463,13 @@ function registerConsoleShortcuts(ctx) {
 }
 
 async function startVitest(mode, cliFilters = [], options = {}, viteOverrides) {
-  var _a, _b, _c, _d;
+  var _a;
   process.env.TEST = "true";
   process.env.VITEST = "true";
   (_a = process.env).NODE_ENV ?? (_a.NODE_ENV = options.mode || "test");
   if (options.run)
     options.watch = false;
-  const root = resolve$2(options.root || process.cwd());
+  const root = resolve(options.root || process.cwd());
   if (!await ensurePackageInstalled("vite", root)) {
     process.exitCode = 1;
     return;
@@ -20693,14 +20482,14 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides) {
     options.browser = { enabled: true, name: options.browser };
   if (typeof options.browser === "object" && !("enabled" in options.browser))
     options.browser.enabled = true;
+  if ("threads" in options && options.experimentalVmThreads)
+    throw new Error('Cannot use both "threads" (or "no-threads") and "experimentalVmThreads" at the same time.');
   const ctx = await createVitest(mode, options, viteOverrides);
   if (mode === "test" && ctx.config.coverage.enabled) {
     const provider = ctx.config.coverage.provider || "v8";
     const requiredPackages = CoverageProviderMap[provider];
     if (requiredPackages) {
-      const defaultProviderInfo = 'Default coverage provider has changed from "c8" to "v8". New package is required to be installed. To use the old deprecated coverage provider use "--coverage.provider c8" option.\nSee https://github.com/vitest-dev/vitest/pull/3339 for more information.\n\n';
-      const isUsingDefaultProvider = ((_c = (_b = ctx.server.config.test) == null ? void 0 : _b.coverage) == null ? void 0 : _c.provider) === void 0 && ((_d = options.coverage) == null ? void 0 : _d.provider) === void 0;
-      if (!await ensurePackageInstalled(requiredPackages, root, isUsingDefaultProvider ? defaultProviderInfo : void 0)) {
+      if (!await ensurePackageInstalled(requiredPackages, root)) {
         process.exitCode = 1;
         return ctx;
       }
@@ -20726,7 +20515,7 @@ async function startVitest(mode, cliFilters = [], options = {}, viteOverrides) {
     await ctx.start(cliFilters);
   } catch (e) {
     process.exitCode = 1;
-    await ctx.logger.printError(e, true, "Unhandled Error");
+    await ctx.logger.printError(e, { fullStack: true, type: "Unhandled Error" });
     ctx.logger.error("\n\n");
     return ctx;
   }