vite-plugin-vue-devtools 0.4.9 → 0.4.11

package/dist/index.mjs

@@ -6,19 +6,19 @@ import Inspect from 'vite-plugin-inspect';
 import VueInspector from 'vite-plugin-vue-inspector';
 import { createBirpcGroup, cachedMap } from 'birpc';
 import fs$9 from 'node:fs/promises';
-import require$$0 from 'path';
-import require$$2 from 'os';
-import require$$0$1 from 'util';
-import require$$0$2 from 'stream';
-import require$$2$1 from 'events';
-import require$$0$3 from 'fs';
+import require$$0 from 'os';
+import require$$0$1 from 'path';
+import require$$0$2 from 'util';
+import require$$0$3 from 'stream';
+import require$$2 from 'events';
+import require$$0$4 from 'fs';
 import fs$1$1, { promises, createWriteStream, createReadStream } from 'node:fs';
 import require$$0$7 from 'readline';
 import { Buffer as Buffer$1 } from 'node:buffer';
 import childProcess, { ChildProcess } from 'node:child_process';
 import process$2 from 'node:process';
 import require$$0$2$1 from 'child_process';
-import os$1, { constants as constants$5 } from 'node:os';
+import os$1$1, { constants as constants$5 } from 'node:os';
 import require$$0$3$1 from 'assert';
 import require$$0$5 from 'buffer';
 import { debuglog } from 'node:util';
@@ -75,92 +75,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$8 = {};
 
-Object.defineProperty(fs$8, "__esModule", { value: true });
-fs$8.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$8, "__esModule", { value: true });
+fs$8.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$8.createDirentFromStats = createDirentFromStats$1;
 
 var path$c = {};
 
-Object.defineProperty(path$c, "__esModule", { value: true });
-path$c.removeLeadingDotSegment = path$c.escape = path$c.makeAbsolute = path$c.unixify = void 0;
-const path$b = require$$0;
-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$c.unixify = unixify;
-function makeAbsolute(cwd, filepath) {
-    return path$b.resolve(cwd, filepath);
-}
-path$c.makeAbsolute = makeAbsolute;
-function escape$1(pattern) {
-    return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
-}
-path$c.escape = escape$1;
-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$c, "__esModule", { value: true });
+path$c.convertPosixPathToPattern = path$c.convertWindowsPathToPattern = path$c.convertPathToPattern = path$c.escapePosixPath = path$c.escapeWindowsPath = path$c.escape = path$c.removeLeadingDotSegment = path$c.makeAbsolute = path$c.unixify = void 0;
+const os$1 = require$$0;
+const path$b = require$$0$1;
+const IS_WINDOWS_PLATFORM = os$1.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$c.unixify = unixify;
+function makeAbsolute(cwd, filepath) {
+    return path$b.resolve(cwd, filepath);
+}
+path$c.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$c.removeLeadingDotSegment = removeLeadingDotSegment;
+path$c.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
+function escapeWindowsPath(pattern) {
+    return pattern.replace(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$c.escapeWindowsPath = escapeWindowsPath;
+function escapePosixPath(pattern) {
+    return pattern.replace(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$c.escapePosixPath = escapePosixPath;
+path$c.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
+function convertWindowsPathToPattern(filepath) {
+    return escapeWindowsPath(filepath)
+        .replace(DOS_DEVICE_PATH_RE, '//$1')
+        .replace(WINDOWS_BACKSLASHES_RE, '/');
+}
+path$c.convertWindowsPathToPattern = convertWindowsPathToPattern;
+function convertPosixPathToPattern(filepath) {
+    return escapePosixPath(filepath);
+}
+path$c.convertPosixPathToPattern = convertPosixPathToPattern;
 
 var pattern$1 = {};
 
@@ -337,8 +372,8 @@ var isGlob$1 = function isGlob(str, options) {
 };
 
 var isGlob = isGlob$1;
-var pathPosixDirname = require$$0.posix.dirname;
-var isWin32 = require$$2.platform() === 'win32';
+var pathPosixDirname = require$$0$1.posix.dirname;
+var isWin32 = require$$0.platform() === 'win32';
 
 var slash = '/';
 var backslash = /\\/g;
@@ -834,12 +869,12 @@ var toRegexRange_1 = toRegexRange$1;
  * Licensed under the MIT License.
  */
 
-const util$2 = require$$0$1;
+const util$2 = require$$0$2;
 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);
 };
 
@@ -976,7 +1011,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);
@@ -1799,7 +1834,7 @@ var braces_1 = braces$1;
 
 var utils$f = {};
 
-const path$a = require$$0;
+const path$a = require$$0$1;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -1979,7 +2014,7 @@ var constants$3 = {
 
 (function (exports) {
 
-	const path = require$$0;
+	const path = require$$0$1;
 	const win32 = process.platform === 'win32';
 	const {
 	  REGEX_BACKSLASH,
@@ -3523,7 +3558,7 @@ parse$3.fastpaths = (input, options) => {
 
 var parse_1$1 = parse$3;
 
-const path$9 = require$$0;
+const path$9 = require$$0$1;
 const scan = scan_1;
 const parse$2 = parse_1$1;
 const utils$c = utils$f;
@@ -3866,7 +3901,7 @@ var picomatch_1 = picomatch$2;
 
 var picomatch$1 = picomatch_1;
 
-const util$1 = require$$0$1;
+const util$1 = require$$0$2;
 const braces = braces_1;
 const picomatch = picomatch$1;
 const utils$b = utils$f;
@@ -4332,174 +4367,193 @@ micromatch$1.braceExpand = (pattern, options) => {
 
 var micromatch_1 = 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$8 = require$$0;
-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$8.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$8 = require$$0$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$8.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$5 = {};
 
@@ -4510,7 +4564,7 @@ var stream$5 = {};
  * Copyright (c) 2014-2020 Teambition
  * Licensed under the MIT license.
  */
-const Stream = require$$0$2;
+const Stream = require$$0$3;
 const PassThrough$1 = Stream.PassThrough;
 const slice = Array.prototype.slice;
 
@@ -4647,156 +4701,163 @@ function pauseStreams (streams, options) {
   return streams
 }
 
-Object.defineProperty(stream$5, "__esModule", { value: true });
-stream$5.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$5.merge = merge;
-function propagateCloseEventToSources(streams) {
-    streams.forEach((stream) => stream.emit('close'));
+Object.defineProperty(stream$5, "__esModule", { value: true });
+stream$5.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$5.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$7 = fs$8;
-utils$k.fs = fs$7;
-const path$7 = path$c;
-utils$k.path = path$7;
-const pattern = pattern$1;
-utils$k.pattern = pattern;
-const stream$4 = stream$5;
-utils$k.stream = stream$4;
-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$7 = fs$8;
+utils$k.fs = fs$7;
+const path$7 = path$c;
+utils$k.path = path$7;
+const pattern = pattern$1;
+utils$k.pattern = pattern;
+const stream$4 = stream$5;
+utils$k.stream = stream$4;
+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 = {};
@@ -4883,7 +4944,7 @@ var fs$6 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$3;
+	const fs = require$$0$4;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -5234,7 +5295,7 @@ var fs$2 = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$3;
+	const fs = require$$0$4;
 	exports.FILE_SYSTEM_ADAPTER = {
 	    lstat: fs.lstat,
 	    stat: fs.stat,
@@ -5253,7 +5314,7 @@ var fs$2 = {};
 } (fs$2));
 
 Object.defineProperty(settings$2, "__esModule", { value: true });
-const path$6 = require$$0;
+const path$6 = require$$0$1;
 const fsStat$3 = out$1;
 const fs$1 = fs$2;
 let Settings$1 = class Settings {
@@ -5673,7 +5734,7 @@ let Reader$1 = class Reader {
 reader$1.default = Reader$1;
 
 Object.defineProperty(async$4, "__esModule", { value: true });
-const events_1 = require$$2$1;
+const events_1 = require$$2;
 const fsScandir$2 = out$2;
 const fastq = queueExports;
 const common$1 = common$3;
@@ -5802,7 +5863,7 @@ function callSuccessCallback(callback, entries) {
 var stream$3 = {};
 
 Object.defineProperty(stream$3, "__esModule", { value: true });
-const stream_1$5 = require$$0$2;
+const stream_1$5 = require$$0$3;
 const async_1$3 = async$4;
 class StreamProvider {
     constructor(_root, _settings) {
@@ -5915,7 +5976,7 @@ sync$4.default = SyncProvider;
 var settings$1 = {};
 
 Object.defineProperty(settings$1, "__esModule", { value: true });
-const path$5 = require$$0;
+const path$5 = require$$0$1;
 const fsScandir = out$2;
 class Settings {
     constructor(_options = {}) {
@@ -5976,129 +6037,129 @@ function getSettings(settingsOrOptions = {}) {
 
 var reader = {};
 
-Object.defineProperty(reader, "__esModule", { value: true });
-const path$4 = require$$0;
-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$4.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$4 = require$$0$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$4.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$2 = {};
 
-Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$3 = require$$0$2;
-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$2, "__esModule", { value: true });
+const stream_1$3 = require$$0$3;
+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$2.default = ReaderStream;
 
-Object.defineProperty(async$6, "__esModule", { value: true });
-const fsWalk$1 = out$3;
-const reader_1$1 = reader;
-const stream_1$2 = stream$2;
-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$2;
+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 = {};
@@ -6109,568 +6170,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$3 = require$$0;
-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$3.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$3 = require$$0$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$3.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$1 = {};
 
-Object.defineProperty(stream$1, "__esModule", { value: true });
-const stream_1$1 = require$$0$2;
-const stream_2 = stream$2;
-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$1, "__esModule", { value: true });
+const stream_1$1 = require$$0$3;
+const stream_2 = stream$2;
+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$1.default = ProviderStream;
 
 var sync$2 = {};
 
 var sync$1 = {};
 
-Object.defineProperty(sync$1, "__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$1, "__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$1.default = ReaderSync;
 
-Object.defineProperty(sync$2, "__esModule", { value: true });
-const sync_1$1 = sync$1;
-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$2, "__esModule", { value: true });
+const sync_1$1 = sync$1;
+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$2.default = ProviderSync;
 
 var settings = {};
 
 (function (exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-	const fs = require$$0$3;
-	const os = require$$2;
-	/**
-	 * 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 = require$$0$4;
+	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$1;
-const sync_1 = sync$2;
-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$1;
+const sync_1 = sync$2;
+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;
 
 const fg = /*@__PURE__*/getDefaultExportFromCjs$1(out);
@@ -7555,18 +7642,14 @@ async function getTextAssetContent(filepath, limit = 300) {
 async function getPackages(root) {
   const pkgPath = resolve(root, "package.json");
   const data = JSON.parse(await promises.readFile(pkgPath, "utf-8").catch(() => "{}"));
-  const categorizedPackages = {};
   const packages = {};
   for (const type of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
-    if (!data[type])
+    const dep = data[type];
+    if (!dep)
       continue;
-    categorizedPackages[type] = data[type];
-  }
-  for (const type in categorizedPackages) {
-    for (const name in categorizedPackages[type]) {
-      const version = categorizedPackages[type][name];
-      packages[name] = {
-        version,
+    for (const depName in dep) {
+      packages[depName] = {
+        version: dep[depName],
         type
       };
     }
@@ -7576,12 +7659,14 @@ async function getPackages(root) {
   };
 }
 
-const npmRun = (agent) => (args) => {
-  if (args.length > 1)
-    return `${agent} run ${args[0]} -- ${args.slice(1).join(" ")}`;
-  else
-    return `${agent} run ${args[0]}`;
-};
+function npmRun(agent) {
+  return (args) => {
+    if (args.length > 1)
+      return `${agent} run ${args[0]} -- ${args.slice(1).join(" ")}`;
+    else
+      return `${agent} run ${args[0]}`;
+  };
+}
 const yarn = {
   "agent": "yarn {0}",
   "run": "yarn run {0}",
@@ -7676,10 +7761,6 @@ function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
 
-/* istanbul ignore next */
-typeof process !== 'undefined' &&
-  process.platform === 'win32' ? '\r\n' : '\n';
-
 /*
 How it works:
 `this.#head` is an instance of `Node` which keeps track of its current value and nests another instance of `Node` that keeps the value that comes after it. When a value is provided to `.enqueue()`, the code needs to iterate through `this.#head`, going deeper and deeper to find the last value. However, iterating through every single item is slow. This problem is solved by saving a reference to the last value as `this.#tail` so that it can reference it to add a new value.
@@ -7961,11 +8042,7 @@ process.env.NI_CONFIG_FILE;
 const home = process.platform === "win32" ? process.env.USERPROFILE : process.env.HOME;
 path$3$1.join(home || "~/", ".nirc");
 
-var crossSpawnExports = {};
-var crossSpawn = {
-  get exports(){ return crossSpawnExports; },
-  set exports(v){ crossSpawnExports = v; },
-};
+var crossSpawn$1 = {exports: {}};
 
 var windows;
 var hasRequiredWindows;
@@ -7976,7 +8053,7 @@ function requireWindows () {
 	windows = isexe;
 	isexe.sync = sync;
 
-	var fs = require$$0$3;
+	var fs = require$$0$4;
 
 	function checkPathExt (path, options) {
 	  var pathext = options.pathExt !== undefined ?
@@ -8027,7 +8104,7 @@ function requireMode () {
 	mode = isexe;
 	isexe.sync = sync;
 
-	var fs = require$$0$3;
+	var fs = require$$0$4;
 
 	function isexe (path, options, cb) {
 	  fs.stat(path, function (er, stat) {
@@ -8129,7 +8206,7 @@ const isWindows$1 = process.platform === 'win32' ||
     process.env.OSTYPE === 'cygwin' ||
     process.env.OSTYPE === 'msys';
 
-const path$2 = require$$0;
+const path$2 = require$$0$1;
 const COLON = isWindows$1 ? ';' : ':';
 const isexe$1 = isexe_1;
 
@@ -8167,7 +8244,7 @@ const getPathInfo$1 = (cmd, opt) => {
   }
 };
 
-const which$2 = (cmd, opt, cb) => {
+const which$3 = (cmd, opt, cb) => {
   if (typeof opt === 'function') {
     cb = opt;
     opt = {};
@@ -8248,14 +8325,10 @@ const whichSync$1 = (cmd, opt) => {
   throw getNotFoundError$1(cmd)
 };
 
-var which_1 = which$2;
-which$2.sync = whichSync$1;
+var which_1 = which$3;
+which$3.sync = whichSync$1;
 
-var pathKeyExports = {};
-var pathKey$2 = {
-  get exports(){ return pathKeyExports; },
-  set exports(v){ pathKeyExports = v; },
-};
+var pathKey$2 = {exports: {}};
 
 const pathKey$1 = (options = {}) => {
 	const environment = options.env || process.env;
@@ -8270,10 +8343,12 @@ const pathKey$1 = (options = {}) => {
 
 pathKey$2.exports = pathKey$1;
 // TODO: Remove this for the next major release
-pathKeyExports.default = pathKey$1;
+pathKey$2.exports.default = pathKey$1;
+
+var pathKeyExports = pathKey$2.exports;
 
-const path$1 = require$$0;
-const which$1 = which_1;
+const path$1 = require$$0$1;
+const which$2 = which_1;
 const getPathKey = pathKeyExports;
 
 function resolveCommandAttempt(parsed, withoutPathExt) {
@@ -8296,7 +8371,7 @@ function resolveCommandAttempt(parsed, withoutPathExt) {
     let resolved;
 
     try {
-        resolved = which$1.sync(parsed.command, {
+        resolved = which$2.sync(parsed.command, {
             path: env[getPathKey({ env })],
             pathExt: withoutPathExt ? path$1.delimiter : undefined,
         });
@@ -8390,7 +8465,7 @@ var shebangCommand$1 = (string = '') => {
 	return argument ? `${binary} ${argument}` : binary;
 };
 
-const fs = require$$0$3;
+const fs = require$$0$4;
 const shebangCommand = shebangCommand$1;
 
 function readShebang$1(command) {
@@ -8412,7 +8487,7 @@ function readShebang$1(command) {
 
 var readShebang_1 = readShebang$1;
 
-const path = require$$0;
+const path = require$$0$1;
 const resolveCommand = resolveCommand_1;
 const escape = _escape;
 const readShebang = readShebang_1;
@@ -8591,12 +8666,15 @@ function spawnSync(command, args, options) {
     return result;
 }
 
-crossSpawn.exports = spawn;
-crossSpawnExports.spawn = spawn;
-crossSpawnExports.sync = spawnSync;
+crossSpawn$1.exports = spawn;
+crossSpawn$1.exports.spawn = spawn;
+crossSpawn$1.exports.sync = spawnSync;
 
-crossSpawnExports._parse = parse;
-crossSpawnExports._enoent = enoent;
+crossSpawn$1.exports._parse = parse;
+crossSpawn$1.exports._enoent = enoent;
+
+var crossSpawnExports = crossSpawn$1.exports;
+const crossSpawn = /*@__PURE__*/getDefaultExportFromCjs(crossSpawnExports);
 
 function stripFinalNewline(input) {
 	const LF = typeof input === 'string' ? '\n' : '\n'.charCodeAt();
@@ -9265,22 +9343,14 @@ const normalizeStdio = options => {
 	return Array.from({length}, (value, index) => stdio[index]);
 };
 
-var signalExitExports = {};
-var signalExit = {
-  get exports(){ return signalExitExports; },
-  set exports(v){ signalExitExports = v; },
-};
+var signalExit = {exports: {}};
 
-var signalsExports = {};
-var signals$1 = {
-  get exports(){ return signalsExports; },
-  set exports(v){ signalsExports = v; },
-};
+var signals$1 = {exports: {}};
 
 var hasRequiredSignals;
 
 function requireSignals () {
-	if (hasRequiredSignals) return signalsExports;
+	if (hasRequiredSignals) return signals$1.exports;
 	hasRequiredSignals = 1;
 	(function (module) {
 		// This is not the set of all possible signals.
@@ -9335,9 +9405,9 @@ function requireSignals () {
 		    'SIGSTKFLT',
 		    'SIGUNUSED'
 		  );
-		}
-} (signals$1));
-	return signalsExports;
+		} 
+	} (signals$1));
+	return signals$1.exports;
 }
 
 // Note: since nyc uses this module to output coverage, any lines
@@ -9369,7 +9439,7 @@ if (!processOk(process$1)) {
   var signals = requireSignals();
   var isWin = /^win/i.test(process$1.platform);
 
-  var EE = require$$2$1;
+  var EE = require$$2;
   /* istanbul ignore if */
   if (typeof EE !== 'function') {
     EE = EE.EventEmitter;
@@ -9436,7 +9506,7 @@ if (!processOk(process$1)) {
     process$1.reallyExit = originalProcessReallyExit;
     emitter.count -= 1;
   };
-  signalExitExports.unload = unload;
+  signalExit.exports.unload = unload;
 
   var emit = function emit (event, code, signal) {
     /* istanbul ignore if */
@@ -9477,7 +9547,7 @@ if (!processOk(process$1)) {
     };
   });
 
-  signalExitExports.signals = function () {
+  signalExit.exports.signals = function () {
     return signals
   };
 
@@ -9507,7 +9577,7 @@ if (!processOk(process$1)) {
     process$1.emit = processEmit;
     process$1.reallyExit = processReallyExit;
   };
-  signalExitExports.load = load;
+  signalExit.exports.load = load;
 
   var originalProcessReallyExit = process$1.reallyExit;
   var processReallyExit = function processReallyExit (code) {
@@ -9543,6 +9613,9 @@ if (!processOk(process$1)) {
   };
 }
 
+var signalExitExports = signalExit.exports;
+const onExit = /*@__PURE__*/getDefaultExportFromCjs(signalExitExports);
+
 const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
 
 // Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
@@ -9573,7 +9646,7 @@ const setKillTimeout = (kill, signal, options, killResult) => {
 
 const shouldForceKill = (signal, {forceKillAfterTimeout}, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
 
-const isSigterm = signal => signal === os$1.constants.signals.SIGTERM
+const isSigterm = signal => signal === os$1$1.constants.signals.SIGTERM
 		|| (typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM');
 
 const getForceKillAfterTimeout = ({forceKillAfterTimeout = true}) => {
@@ -9634,7 +9707,7 @@ const setExitHandler = async (spawned, {cleanup, detached}, timedPromise) => {
 		return timedPromise;
 	}
 
-	const removeExitHandler = signalExitExports(() => {
+	const removeExitHandler = onExit(() => {
 		spawned.kill();
 	});
 
@@ -9695,13 +9768,9 @@ const addPipeMethods = spawned => {
 	}
 };
 
-var getStreamExports = {};
-var getStream$1 = {
-  get exports(){ return getStreamExports; },
-  set exports(v){ getStreamExports = v; },
-};
+var getStream$2 = {exports: {}};
 
-const {PassThrough: PassThroughStream} = require$$0$2;
+const {PassThrough: PassThroughStream} = require$$0$3;
 
 var bufferStream$1 = options => {
 	options = {...options};
@@ -9754,8 +9823,8 @@ var bufferStream$1 = options => {
 };
 
 const {constants: BufferConstants} = require$$0$5;
-const stream = require$$0$2;
-const {promisify} = require$$0$1;
+const stream = require$$0$3;
+const {promisify} = require$$0$2;
 const bufferStream = bufferStream$1;
 
 const streamPipelinePromisified = promisify(stream.pipeline);
@@ -9809,12 +9878,15 @@ async function getStream(inputStream, options) {
 	return stream.getBufferedValue();
 }
 
-getStream$1.exports = getStream;
-getStreamExports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
-getStreamExports.array = (stream, options) => getStream(stream, {...options, array: true});
-getStreamExports.MaxBufferError = MaxBufferError;
+getStream$2.exports = getStream;
+getStream$2.exports.buffer = (stream, options) => getStream(stream, {...options, encoding: 'buffer'});
+getStream$2.exports.array = (stream, options) => getStream(stream, {...options, array: true});
+getStream$2.exports.MaxBufferError = MaxBufferError;
+
+var getStreamExports = getStream$2.exports;
+const getStream$1 = /*@__PURE__*/getDefaultExportFromCjs(getStreamExports);
 
-const { PassThrough } = require$$0$2;
+const { PassThrough } = require$$0$3;
 
 var mergeStream = function (/*streams...*/) {
   var sources = [];
@@ -9854,6 +9926,8 @@ var mergeStream = function (/*streams...*/) {
   }
 };
 
+const mergeStream$1 = /*@__PURE__*/getDefaultExportFromCjs(mergeStream);
+
 const validateInputOptions = input => {
 	if (input !== undefined) {
 		throw new TypeError('The `input` and `inputFile` options cannot be both set.');
@@ -9890,7 +9964,7 @@ const makeAllStream = (spawned, {all}) => {
 		return;
 	}
 
-	const mixed = mergeStream();
+	const mixed = mergeStream$1();
 
 	if (spawned.stdout) {
 		mixed.add(spawned.stdout);
@@ -9925,10 +9999,10 @@ const getStreamPromise = (stream, {encoding, buffer, maxBuffer}) => {
 	}
 
 	if (encoding) {
-		return getStreamExports(stream, {encoding, maxBuffer});
+		return getStream$1(stream, {encoding, maxBuffer});
 	}
 
-	return getStreamExports.buffer(stream, {maxBuffer});
+	return getStream$1.buffer(stream, {maxBuffer});
 };
 
 // Retrieve result of child process: exit code, signal, error, streams (stdout/stderr/all)
@@ -10058,7 +10132,7 @@ const getEnv = ({env: envOption, extendEnv, preferLocal, localDir, execPath}) =>
 };
 
 const handleArguments = (file, args, options = {}) => {
-	const parsed = crossSpawnExports._parse(file, args, options);
+	const parsed = crossSpawn._parse(file, args, options);
 	file = parsed.command;
 	args = parsed.args;
 	options = parsed.options;
@@ -10365,7 +10439,7 @@ var hasFlag$2 = (flag, argv = process.argv) => {
 	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
 };
 
-const os = require$$2;
+const os = require$$0;
 const tty = require$$1;
 const hasFlag$1 = hasFlag$2;
 
@@ -10595,8 +10669,10 @@ var supportsHyperlinks = {
 	stderr: supportsHyperlink(process.stderr)
 };
 
+const supportsHyperlinks$1 = /*@__PURE__*/getDefaultExportFromCjs(supportsHyperlinks);
+
 function terminalLink(text, url, {target = 'stdout', ...options} = {}) {
-	if (!supportsHyperlinks[target]) {
+	if (!supportsHyperlinks$1[target]) {
 		// If the fallback has been explicitly disabled, don't modify the text itself.
 		if (options.fallback === false) {
 			return text;
@@ -10608,17 +10684,11 @@ function terminalLink(text, url, {target = 'stdout', ...options} = {}) {
 	return ansiEscapes.link(text, url);
 }
 
-terminalLink.isSupported = supportsHyperlinks.stdout;
+terminalLink.isSupported = supportsHyperlinks$1.stdout;
 terminalLink.stderr = (text, url, options = {}) => terminalLink(text, url, {target: 'stderr', ...options});
-terminalLink.stderr.isSupported = supportsHyperlinks.stderr;
-
-var promptsExports = {};
-var prompts$3 = {
-  get exports(){ return promptsExports; },
-  set exports(v){ promptsExports = v; },
-};
+terminalLink.stderr.isSupported = supportsHyperlinks$1.stderr;
 
-var prompts$2 = {};
+var prompts$3 = {};
 
 let FORCE_COLOR$1, NODE_DISABLE_COLORS$1, NO_COLOR$1, TERM$1, isTTY$1=true;
 if (typeof process !== 'undefined') {
@@ -11004,7 +11074,7 @@ var util = {
 
 const readline = require$$0$7;
 const { action } = util;
-const EventEmitter = require$$2$1;
+const EventEmitter = require$$2;
 const { beep, cursor: cursor$9 } = src;
 const color$9 = kleur;
 
@@ -13304,10 +13374,10 @@ var elements = {
 	  args.suggest = args.suggest || byTitle;
 	  args.choices = [].concat(args.choices || []);
 	  return toPrompt('AutocompletePrompt', args);
-	};
-} (prompts$2));
+	}; 
+} (prompts$3));
 
-const prompts$1 = prompts$2;
+const prompts$2 = prompts$3;
 
 const passOn = ['suggest', 'format', 'onState', 'validate', 'onRender', 'type'];
 const noop = () => {};
@@ -13358,7 +13428,7 @@ async function prompt(questions=[], { onSubmit=noop, onCancel=noop }={}) {
     // update vars in case they changed
     ({ name, type } = question);
 
-    if (prompts$1[type] === void 0) {
+    if (prompts$2[type] === void 0) {
       throw new Error(`prompt type (${type}) is not defined`);
     }
 
@@ -13372,7 +13442,7 @@ async function prompt(questions=[], { onSubmit=noop, onCancel=noop }={}) {
 
     try {
       // Get the injected answer if there is one or prompt the user
-      answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts$1[type](question);
+      answer = prompt._injected ? getInjectedAnswer(prompt._injected, question.initial) : await prompts$2[type](question);
       answers[name] = answer = await getFormattedAnswer(question, answer, true);
       quit = await onSubmit(question, answer, answers);
     } catch (err) {
@@ -13402,16 +13472,14 @@ function override(answers) {
   prompt._override = Object.assign({}, answers);
 }
 
-var lib$1 = Object.assign(prompt, { prompt, prompts: prompts$1, inject, override });
+var lib$1 = Object.assign(prompt, { prompt, prompts: prompts$2, inject, override });
 
-(function (module) {
-	module.exports = lib$1;
-} (prompts$3));
+var prompts = lib$1;
 
-const prompts = /*@__PURE__*/getDefaultExportFromCjs(promptsExports);
+const prompts$1 = /*@__PURE__*/getDefaultExportFromCjs(prompts);
 
 const isexe = isexe_1;
-const { join, delimiter, sep, posix } = require$$0;
+const { join, delimiter, sep, posix } = require$$0$1;
 
 const isWindows = process.platform === 'win32';
 
@@ -13441,8 +13509,13 @@ const getPathInfo = (cmd, {
   ];
 
   if (isWindows) {
-    const pathExtExe = optPathExt || ['.EXE', '.CMD', '.BAT', '.COM'].join(optDelimiter);
-    const pathExt = pathExtExe.split(optDelimiter);
+    const pathExtExe = optPathExt ||
+      ['.EXE', '.CMD', '.BAT', '.COM'].join(optDelimiter);
+    const pathExt = pathExtExe.split(optDelimiter).reduce((acc, item) => {
+      acc.push(item);
+      acc.push(item.toLowerCase());
+      return acc
+    }, []);
     if (cmd.includes('.') && pathExt[0] !== '') {
       pathExt.unshift('');
     }
@@ -13521,15 +13594,17 @@ const whichSync = (cmd, opt = {}) => {
 var lib = which;
 which.sync = whichSync;
 
-join$2(os$1.tmpdir(), "antfu-ni");
+const which$1 = /*@__PURE__*/getDefaultExportFromCjs(lib);
+
+join$2(os$1$1.tmpdir(), "antfu-ni");
 function exclude(arr, v) {
   return arr.slice().filter((item) => item !== v);
 }
 function cmdExists(cmd) {
-  return lib.sync(cmd, { nothrow: true }) !== null;
+  return which$1.sync(cmd, { nothrow: true }) !== null;
 }
 
-async function detect({ autoInstall, cwd } = {}) {
+async function detect({ autoInstall, programmatic, cwd } = {}) {
   let agent = null;
   let version = null;
   const lockPath = await findUp(Object.keys(LOCKS), { cwd });
@@ -13544,13 +13619,13 @@ async function detect({ autoInstall, cwd } = {}) {
       if (typeof pkg.packageManager === "string") {
         const [name, ver] = pkg.packageManager.split("@");
         version = ver;
-        if (name === "yarn" && parseInt(ver) > 1)
+        if (name === "yarn" && Number.parseInt(ver) > 1)
           agent = "yarn@berry";
-        else if (name === "pnpm" && parseInt(ver) < 7)
+        else if (name === "pnpm" && Number.parseInt(ver) < 7)
           agent = "pnpm@6";
         else if (name in AGENTS)
           agent = name;
-        else
+        else if (!programmatic)
           console.warn("[ni] Unknown packageManager:", pkg.packageManager);
       }
     } catch {
@@ -13558,14 +13633,14 @@ async function detect({ autoInstall, cwd } = {}) {
   }
   if (!agent && lockPath)
     agent = LOCKS[path$3$1.basename(lockPath)];
-  if (agent && !cmdExists(agent.split("@")[0])) {
+  if (agent && !cmdExists(agent.split("@")[0]) && !programmatic) {
     if (!autoInstall) {
       console.warn(`[ni] Detected ${agent} but it doesn't seem to be installed.
 `);
       if (process.env.CI)
         process.exit(1);
       const link = terminalLink(agent, INSTALL_PAGE[agent]);
-      const { tryInstall } = await prompts({
+      const { tryInstall } = await prompts$1({
         name: "tryInstall",
         type: "confirm",
         message: `Would you like to globally install ${link}?`
@@ -13723,7 +13798,8 @@ function VitePluginVueDevTools(options = { appendTo: "" }) {
           else if (type === "exit")
             rpc.onTerminalExit({ data });
         }
-      })
+      }),
+      root: () => config.root
     });
   }
   const plugin = {