vitest 0.23.2 → 0.24.0

package/dist/{chunk-vite-node-externalize.f55c4577.mjs → chunk-vite-node-externalize.a2e9daf4.js}

@@ -1,7 +1,7 @@
-import { a as resolve, j as join, b as basename, d as dirname, c as distDir, e as rootDir, p as picocolors, i as isAbsolute, r as relative, f as configFiles, g as defaultPort, n as normalize, t as toNamespacedPath, E as EXIT_CODE_RESTART } from './chunk-constants.71e8a211.mjs';
-import { p as pLimit, g as getCoverageProvider, C as CoverageProviderMap } from './chunk-integrations-coverage.99c020eb.mjs';
-import { g as getEnvPackageName } from './chunk-env-node.ceb43f1c.mjs';
-import { A as AggregateErrorPonyfill, s as slash$2, o as isNode, p as relativePath, z as getTests, e as getFullName, x as hasFailed, B as hasFailedSnapshot, C as getSuites, j as notNullish, v as shuffle, t as toArray$1, n as noop$1, D as deepMerge, b as getCallLastIndex, E as ensurePackageInstalled, F as stdout } from './chunk-mock-date.2917be60.mjs';
+import { a as resolve, j as join, b as basename, d as dirname, c as distDir, e as rootDir, p as picocolors, i as isAbsolute, r as relative, f as configFiles, g as defaultPort, n as normalize, t as toNamespacedPath, E as EXIT_CODE_RESTART } from './chunk-constants.22640ce4.js';
+import { p as pLimit, g as getCoverageProvider, C as CoverageProviderMap } from './chunk-integrations-coverage.cca09977.js';
+import { g as getEnvPackageName } from './chunk-env-node.700b7e95.js';
+import { A as AggregateErrorPonyfill, s as slash$2, o as isNode, p as relativePath, z as getTests, e as getFullName, x as hasFailed, B as hasFailedSnapshot, C as getSuites, j as notNullish, v as shuffle, t as toArray$1, n as noop$1, D as deepMerge, b as getCallLastIndex, E as ensurePackageInstalled, F as stdout } from './chunk-mock-date.b1b404e8.js';
 import { loadConfigFromFile, normalizePath, createServer, mergeConfig } from 'vite';
 import path$a from 'path';
 import url, { fileURLToPath } from 'url';
@@ -11,25 +11,25 @@ import require$$0, { cpus, hostname } from 'os';
 import util$2 from 'util';
 import require$$0$1 from 'stream';
 import require$$2 from 'events';
-import { c as commonjsGlobal } from './vendor-_commonjsHelpers.4da45ef5.mjs';
-import { c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-client.da0a17ff.mjs';
+import { c as commonjsGlobal } from './vendor-_commonjsHelpers.addc3445.js';
+import { c as createBirpc, V as ViteNodeRunner } from './chunk-vite-node-client.4dd32c96.js';
 import { performance } from 'perf_hooks';
 import createDebug from 'debug';
-import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap } from './chunk-vite-node-utils.473cd0b2.mjs';
+import { i as isNodeBuiltin, a as isValidNodeImport, s as slash$1, t as toArray, b as toFilePath, w as withInlineSourcemap } from './chunk-vite-node-utils.c8c74a41.js';
 import { MessageChannel } from 'worker_threads';
 import { Tinypool } from 'tinypool';
-import { c as stripAnsi, d as cliTruncate, p as parseStacktrace, i as interpretSourcePos, e as stringWidth, h as ansiStyles, j as sliceAnsi, s as stringify$5, u as unifiedDiff, b as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.2be5aa48.mjs';
-import { b as safeSetInterval, c as safeClearInterval, s as safeSetTimeout, a as safeClearTimeout } from './chunk-utils-timers.b48455ed.mjs';
+import { c as stripAnsi, d as cliTruncate, p as parseStacktrace, i as interpretSourcePos, e as stringWidth, h as ansiStyles, j as sliceAnsi, s as stringify$5, u as unifiedDiff, b as posToNumber, l as lineSplitRE } from './chunk-utils-source-map.175ffa40.js';
+import { b as safeSetInterval, c as safeClearInterval, s as safeSetTimeout, a as safeClearTimeout } from './chunk-utils-timers.ab764c0c.js';
 import { resolveModule } from 'local-pkg';
 import { createHash } from 'crypto';
-import { o as onetime } from './vendor-index.9d9196cc.mjs';
-import { s as signalExit } from './vendor-index.29636037.mjs';
-import MagicString from './chunk-magic-string.56b2b543.mjs';
+import { o as onetime } from './vendor-index.c902d578.js';
+import { s as signalExit } from './vendor-index.8919d83a.js';
+import MagicString from './chunk-magic-string.cacfbf9d.js';
 import { stripLiteral } from 'strip-literal';
 import require$$0$2 from 'readline';
-import { p as prompts } from './vendor-index.ae96af6e.mjs';
+import { p as prompts } from './vendor-index.9f20a9be.js';
 
-var version$1 = "0.23.2";
+var version$1 = "0.24.0";
 
 class EndError extends Error {
 	constructor(value) {
@@ -179,91 +179,91 @@ var utils$k = {};
 
 var array$1 = {};
 
-Object.defineProperty(array$1, "__esModule", { value: true });
-array$1.splitWhen = array$1.flatten = void 0;
-function flatten(items) {
-    return items.reduce((collection, item) => [].concat(collection, item), []);
-}
-array$1.flatten = flatten;
-function splitWhen(items, predicate) {
-    const result = [[]];
-    let groupIndex = 0;
-    for (const item of items) {
-        if (predicate(item)) {
-            groupIndex++;
-            result[groupIndex] = [];
-        }
-        else {
-            result[groupIndex].push(item);
-        }
-    }
-    return result;
-}
+Object.defineProperty(array$1, "__esModule", { value: true });
+array$1.splitWhen = array$1.flatten = void 0;
+function flatten(items) {
+    return items.reduce((collection, item) => [].concat(collection, item), []);
+}
+array$1.flatten = flatten;
+function splitWhen(items, predicate) {
+    const result = [[]];
+    let groupIndex = 0;
+    for (const item of items) {
+        if (predicate(item)) {
+            groupIndex++;
+            result[groupIndex] = [];
+        }
+        else {
+            result[groupIndex].push(item);
+        }
+    }
+    return result;
+}
 array$1.splitWhen = splitWhen;
 
 var errno$1 = {};
 
-Object.defineProperty(errno$1, "__esModule", { value: true });
-errno$1.isEnoentCodeError = void 0;
-function isEnoentCodeError(error) {
-    return error.code === 'ENOENT';
-}
+Object.defineProperty(errno$1, "__esModule", { value: true });
+errno$1.isEnoentCodeError = void 0;
+function isEnoentCodeError(error) {
+    return error.code === 'ENOENT';
+}
 errno$1.isEnoentCodeError = isEnoentCodeError;
 
 var fs$7 = {};
 
-Object.defineProperty(fs$7, "__esModule", { value: true });
-fs$7.createDirentFromStats = void 0;
-class DirentFromStats$1 {
-    constructor(name, stats) {
-        this.name = name;
-        this.isBlockDevice = stats.isBlockDevice.bind(stats);
-        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
-        this.isDirectory = stats.isDirectory.bind(stats);
-        this.isFIFO = stats.isFIFO.bind(stats);
-        this.isFile = stats.isFile.bind(stats);
-        this.isSocket = stats.isSocket.bind(stats);
-        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
-    }
-}
-function createDirentFromStats$1(name, stats) {
-    return new DirentFromStats$1(name, stats);
-}
+Object.defineProperty(fs$7, "__esModule", { value: true });
+fs$7.createDirentFromStats = void 0;
+class DirentFromStats$1 {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats$1(name, stats) {
+    return new DirentFromStats$1(name, stats);
+}
 fs$7.createDirentFromStats = createDirentFromStats$1;
 
 var path$9 = {};
 
-Object.defineProperty(path$9, "__esModule", { value: true });
-path$9.removeLeadingDotSegment = path$9.escape = path$9.makeAbsolute = path$9.unixify = void 0;
-const path$8 = path$a;
-const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
-const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
-/**
- * Designed to work only with simple paths: `dir\\file`.
- */
-function unixify(filepath) {
-    return filepath.replace(/\\/g, '/');
-}
-path$9.unixify = unixify;
-function makeAbsolute(cwd, filepath) {
-    return path$8.resolve(cwd, filepath);
-}
-path$9.makeAbsolute = makeAbsolute;
-function escape(pattern) {
-    return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
-}
-path$9.escape = escape;
-function removeLeadingDotSegment(entry) {
-    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
-    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
-    if (entry.charAt(0) === '.') {
-        const secondCharactery = entry.charAt(1);
-        if (secondCharactery === '/' || secondCharactery === '\\') {
-            return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
-        }
-    }
-    return entry;
-}
+Object.defineProperty(path$9, "__esModule", { value: true });
+path$9.removeLeadingDotSegment = path$9.escape = path$9.makeAbsolute = path$9.unixify = void 0;
+const path$8 = path$a;
+const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
+const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
+/**
+ * Designed to work only with simple paths: `dir\\file`.
+ */
+function unixify(filepath) {
+    return filepath.replace(/\\/g, '/');
+}
+path$9.unixify = unixify;
+function makeAbsolute(cwd, filepath) {
+    return path$8.resolve(cwd, filepath);
+}
+path$9.makeAbsolute = makeAbsolute;
+function escape(pattern) {
+    return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$9.escape = escape;
+function removeLeadingDotSegment(entry) {
+    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+    if (entry.charAt(0) === '.') {
+        const secondCharactery = entry.charAt(1);
+        if (secondCharactery === '/' || secondCharactery === '\\') {
+            return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+        }
+    }
+    return entry;
+}
 path$9.removeLeadingDotSegment = removeLeadingDotSegment;
 
 var pattern$1 = {};
@@ -4441,173 +4441,173 @@ 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$5 = path$a;
-const globParent = globParent$1;
-const micromatch = micromatch_1;
-const GLOBSTAR = '**';
-const ESCAPE_SYMBOL = '\\';
-const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
-const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
-const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
-const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
-const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
-function isStaticPattern(pattern, options = {}) {
-    return !isDynamicPattern(pattern, options);
-}
-pattern$1.isStaticPattern = isStaticPattern;
-function isDynamicPattern(pattern, options = {}) {
-    /**
-     * A special case with an empty string is necessary for matching patterns that start with a forward slash.
-     * An empty string cannot be a dynamic pattern.
-     * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
-     */
-    if (pattern === '') {
-        return false;
-    }
-    /**
-     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
-     * filepath directly (without read directory).
-     */
-    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
-        return true;
-    }
-    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
-        return true;
-    }
-    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
-        return true;
-    }
-    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
-        return true;
-    }
-    return false;
-}
-pattern$1.isDynamicPattern = isDynamicPattern;
-function hasBraceExpansion(pattern) {
-    const openingBraceIndex = pattern.indexOf('{');
-    if (openingBraceIndex === -1) {
-        return false;
-    }
-    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
-    if (closingBraceIndex === -1) {
-        return false;
-    }
-    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
-    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
-}
-function convertToPositivePattern(pattern) {
-    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
-}
-pattern$1.convertToPositivePattern = convertToPositivePattern;
-function convertToNegativePattern(pattern) {
-    return '!' + pattern;
-}
-pattern$1.convertToNegativePattern = convertToNegativePattern;
-function isNegativePattern(pattern) {
-    return pattern.startsWith('!') && pattern[1] !== '(';
-}
-pattern$1.isNegativePattern = isNegativePattern;
-function isPositivePattern(pattern) {
-    return !isNegativePattern(pattern);
-}
-pattern$1.isPositivePattern = isPositivePattern;
-function getNegativePatterns(patterns) {
-    return patterns.filter(isNegativePattern);
-}
-pattern$1.getNegativePatterns = getNegativePatterns;
-function getPositivePatterns$1(patterns) {
-    return patterns.filter(isPositivePattern);
-}
-pattern$1.getPositivePatterns = getPositivePatterns$1;
-/**
- * Returns patterns that can be applied inside the current directory.
- *
- * @example
- * // ['./*', '*', 'a/*']
- * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
- */
-function getPatternsInsideCurrentDirectory(patterns) {
-    return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
-}
-pattern$1.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
-/**
- * Returns patterns to be expanded relative to (outside) the current directory.
- *
- * @example
- * // ['../*', './../*']
- * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
- */
-function getPatternsOutsideCurrentDirectory(patterns) {
-    return patterns.filter(isPatternRelatedToParentDirectory);
-}
-pattern$1.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
-function isPatternRelatedToParentDirectory(pattern) {
-    return pattern.startsWith('..') || pattern.startsWith('./..');
-}
-pattern$1.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
-function getBaseDirectory(pattern) {
-    return globParent(pattern, { flipBackslashes: false });
-}
-pattern$1.getBaseDirectory = getBaseDirectory;
-function hasGlobStar(pattern) {
-    return pattern.includes(GLOBSTAR);
-}
-pattern$1.hasGlobStar = hasGlobStar;
-function endsWithSlashGlobStar(pattern) {
-    return pattern.endsWith('/' + GLOBSTAR);
-}
-pattern$1.endsWithSlashGlobStar = endsWithSlashGlobStar;
-function isAffectDepthOfReadingPattern(pattern) {
-    const basename = path$5.basename(pattern);
-    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
-}
-pattern$1.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
-function expandPatternsWithBraceExpansion(patterns) {
-    return patterns.reduce((collection, pattern) => {
-        return collection.concat(expandBraceExpansion(pattern));
-    }, []);
-}
-pattern$1.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
-function expandBraceExpansion(pattern) {
-    return micromatch.braces(pattern, {
-        expand: true,
-        nodupes: true
-    });
-}
-pattern$1.expandBraceExpansion = expandBraceExpansion;
-function getPatternParts(pattern, options) {
-    let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
-    /**
-     * The scan method returns an empty array in some cases.
-     * See micromatch/picomatch#58 for more details.
-     */
-    if (parts.length === 0) {
-        parts = [pattern];
-    }
-    /**
-     * The scan method does not return an empty part for the pattern with a forward slash.
-     * This is another part of micromatch/picomatch#58.
-     */
-    if (parts[0].startsWith('/')) {
-        parts[0] = parts[0].slice(1);
-        parts.unshift('');
-    }
-    return parts;
-}
-pattern$1.getPatternParts = getPatternParts;
-function makeRe(pattern, options) {
-    return micromatch.makeRe(pattern, options);
-}
-pattern$1.makeRe = makeRe;
-function convertPatternsToRe(patterns, options) {
-    return patterns.map((pattern) => makeRe(pattern, options));
-}
-pattern$1.convertPatternsToRe = convertPatternsToRe;
-function matchAny(entry, patternsRe) {
-    return patternsRe.some((patternRe) => patternRe.test(entry));
-}
+Object.defineProperty(pattern$1, "__esModule", { value: true });
+pattern$1.matchAny = pattern$1.convertPatternsToRe = pattern$1.makeRe = pattern$1.getPatternParts = pattern$1.expandBraceExpansion = pattern$1.expandPatternsWithBraceExpansion = pattern$1.isAffectDepthOfReadingPattern = pattern$1.endsWithSlashGlobStar = pattern$1.hasGlobStar = pattern$1.getBaseDirectory = pattern$1.isPatternRelatedToParentDirectory = pattern$1.getPatternsOutsideCurrentDirectory = pattern$1.getPatternsInsideCurrentDirectory = pattern$1.getPositivePatterns = pattern$1.getNegativePatterns = pattern$1.isPositivePattern = pattern$1.isNegativePattern = pattern$1.convertToNegativePattern = pattern$1.convertToPositivePattern = pattern$1.isDynamicPattern = pattern$1.isStaticPattern = void 0;
+const path$5 = path$a;
+const globParent = globParent$1;
+const micromatch = micromatch_1;
+const GLOBSTAR = '**';
+const ESCAPE_SYMBOL = '\\';
+const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
+const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
+const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
+const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
+function isStaticPattern(pattern, options = {}) {
+    return !isDynamicPattern(pattern, options);
+}
+pattern$1.isStaticPattern = isStaticPattern;
+function isDynamicPattern(pattern, options = {}) {
+    /**
+     * A special case with an empty string is necessary for matching patterns that start with a forward slash.
+     * An empty string cannot be a dynamic pattern.
+     * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
+     */
+    if (pattern === '') {
+        return false;
+    }
+    /**
+     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
+     * filepath directly (without read directory).
+     */
+    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+        return true;
+    }
+    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
+        return true;
+    }
+    return false;
+}
+pattern$1.isDynamicPattern = isDynamicPattern;
+function hasBraceExpansion(pattern) {
+    const openingBraceIndex = pattern.indexOf('{');
+    if (openingBraceIndex === -1) {
+        return false;
+    }
+    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
+    if (closingBraceIndex === -1) {
+        return false;
+    }
+    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+}
+function convertToPositivePattern(pattern) {
+    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+}
+pattern$1.convertToPositivePattern = convertToPositivePattern;
+function convertToNegativePattern(pattern) {
+    return '!' + pattern;
+}
+pattern$1.convertToNegativePattern = convertToNegativePattern;
+function isNegativePattern(pattern) {
+    return pattern.startsWith('!') && pattern[1] !== '(';
+}
+pattern$1.isNegativePattern = isNegativePattern;
+function isPositivePattern(pattern) {
+    return !isNegativePattern(pattern);
+}
+pattern$1.isPositivePattern = isPositivePattern;
+function getNegativePatterns(patterns) {
+    return patterns.filter(isNegativePattern);
+}
+pattern$1.getNegativePatterns = getNegativePatterns;
+function getPositivePatterns$1(patterns) {
+    return patterns.filter(isPositivePattern);
+}
+pattern$1.getPositivePatterns = getPositivePatterns$1;
+/**
+ * Returns patterns that can be applied inside the current directory.
+ *
+ * @example
+ * // ['./*', '*', 'a/*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsInsideCurrentDirectory(patterns) {
+    return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
+}
+pattern$1.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+/**
+ * Returns patterns to be expanded relative to (outside) the current directory.
+ *
+ * @example
+ * // ['../*', './../*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsOutsideCurrentDirectory(patterns) {
+    return patterns.filter(isPatternRelatedToParentDirectory);
+}
+pattern$1.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+function isPatternRelatedToParentDirectory(pattern) {
+    return pattern.startsWith('..') || pattern.startsWith('./..');
+}
+pattern$1.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+function getBaseDirectory(pattern) {
+    return globParent(pattern, { flipBackslashes: false });
+}
+pattern$1.getBaseDirectory = getBaseDirectory;
+function hasGlobStar(pattern) {
+    return pattern.includes(GLOBSTAR);
+}
+pattern$1.hasGlobStar = hasGlobStar;
+function endsWithSlashGlobStar(pattern) {
+    return pattern.endsWith('/' + GLOBSTAR);
+}
+pattern$1.endsWithSlashGlobStar = endsWithSlashGlobStar;
+function isAffectDepthOfReadingPattern(pattern) {
+    const basename = path$5.basename(pattern);
+    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+}
+pattern$1.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+function expandPatternsWithBraceExpansion(patterns) {
+    return patterns.reduce((collection, pattern) => {
+        return collection.concat(expandBraceExpansion(pattern));
+    }, []);
+}
+pattern$1.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+function expandBraceExpansion(pattern) {
+    return micromatch.braces(pattern, {
+        expand: true,
+        nodupes: true
+    });
+}
+pattern$1.expandBraceExpansion = expandBraceExpansion;
+function getPatternParts(pattern, options) {
+    let { parts } = micromatch.scan(pattern, Object.assign(Object.assign({}, options), { parts: true }));
+    /**
+     * The scan method returns an empty array in some cases.
+     * See micromatch/picomatch#58 for more details.
+     */
+    if (parts.length === 0) {
+        parts = [pattern];
+    }
+    /**
+     * The scan method does not return an empty part for the pattern with a forward slash.
+     * This is another part of micromatch/picomatch#58.
+     */
+    if (parts[0].startsWith('/')) {
+        parts[0] = parts[0].slice(1);
+        parts.unshift('');
+    }
+    return parts;
+}
+pattern$1.getPatternParts = getPatternParts;
+function makeRe(pattern, options) {
+    return micromatch.makeRe(pattern, options);
+}
+pattern$1.makeRe = makeRe;
+function convertPatternsToRe(patterns, options) {
+    return patterns.map((pattern) => makeRe(pattern, options));
+}
+pattern$1.convertPatternsToRe = convertPatternsToRe;
+function matchAny(entry, patternsRe) {
+    return patternsRe.some((patternRe) => patternRe.test(entry));
+}
 pattern$1.matchAny = matchAny;
 
 var stream$4 = {};
@@ -4756,166 +4756,176 @@ function pauseStreams (streams, options) {
   return streams
 }
 
-Object.defineProperty(stream$4, "__esModule", { value: true });
-stream$4.merge = void 0;
-const merge2 = merge2_1;
-function merge(streams) {
-    const mergedStream = merge2(streams);
-    streams.forEach((stream) => {
-        stream.once('error', (error) => mergedStream.emit('error', error));
-    });
-    mergedStream.once('close', () => propagateCloseEventToSources(streams));
-    mergedStream.once('end', () => propagateCloseEventToSources(streams));
-    return mergedStream;
-}
-stream$4.merge = merge;
-function propagateCloseEventToSources(streams) {
-    streams.forEach((stream) => stream.emit('close'));
+Object.defineProperty(stream$4, "__esModule", { value: true });
+stream$4.merge = void 0;
+const merge2 = merge2_1;
+function merge(streams) {
+    const mergedStream = merge2(streams);
+    streams.forEach((stream) => {
+        stream.once('error', (error) => mergedStream.emit('error', error));
+    });
+    mergedStream.once('close', () => propagateCloseEventToSources(streams));
+    mergedStream.once('end', () => propagateCloseEventToSources(streams));
+    return mergedStream;
+}
+stream$4.merge = merge;
+function propagateCloseEventToSources(streams) {
+    streams.forEach((stream) => stream.emit('close'));
 }
 
 var string$1 = {};
 
-Object.defineProperty(string$1, "__esModule", { value: true });
-string$1.isEmpty = string$1.isString = void 0;
-function isString(input) {
-    return typeof input === 'string';
-}
-string$1.isString = isString;
-function isEmpty(input) {
-    return input === '';
-}
+Object.defineProperty(string$1, "__esModule", { value: true });
+string$1.isEmpty = string$1.isString = void 0;
+function isString(input) {
+    return typeof input === 'string';
+}
+string$1.isString = isString;
+function isEmpty(input) {
+    return input === '';
+}
 string$1.isEmpty = isEmpty;
 
-Object.defineProperty(utils$k, "__esModule", { value: true });
-utils$k.string = utils$k.stream = utils$k.pattern = utils$k.path = utils$k.fs = utils$k.errno = utils$k.array = void 0;
-const array = array$1;
-utils$k.array = array;
-const errno = errno$1;
-utils$k.errno = errno;
-const fs$6 = fs$7;
-utils$k.fs = fs$6;
-const path$4 = path$9;
-utils$k.path = path$4;
-const pattern = pattern$1;
-utils$k.pattern = pattern;
-const stream$3 = stream$4;
-utils$k.stream = stream$3;
-const string = string$1;
+Object.defineProperty(utils$k, "__esModule", { value: true });
+utils$k.string = utils$k.stream = utils$k.pattern = utils$k.path = utils$k.fs = utils$k.errno = utils$k.array = void 0;
+const array = array$1;
+utils$k.array = array;
+const errno = errno$1;
+utils$k.errno = errno;
+const fs$6 = fs$7;
+utils$k.fs = fs$6;
+const path$4 = path$9;
+utils$k.path = path$4;
+const pattern = pattern$1;
+utils$k.pattern = pattern;
+const stream$3 = stream$4;
+utils$k.stream = stream$3;
+const string = string$1;
 utils$k.string = string;
 
-Object.defineProperty(tasks, "__esModule", { value: true });
-tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
-const utils$a = utils$k;
-function generate(patterns, settings) {
-    const positivePatterns = getPositivePatterns(patterns);
-    const negativePatterns = getNegativePatternsAsPositive(patterns, settings.ignore);
-    const staticPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isStaticPattern(pattern, settings));
-    const dynamicPatterns = positivePatterns.filter((pattern) => utils$a.pattern.isDynamicPattern(pattern, settings));
-    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
-    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
-    return staticTasks.concat(dynamicTasks);
-}
-tasks.generate = generate;
-/**
- * Returns tasks grouped by basic pattern directories.
- *
- * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
- * This is necessary because directory traversal starts at the base directory and goes deeper.
- */
-function convertPatternsToTasks(positive, negative, dynamic) {
-    const tasks = [];
-    const patternsOutsideCurrentDirectory = utils$a.pattern.getPatternsOutsideCurrentDirectory(positive);
-    const patternsInsideCurrentDirectory = utils$a.pattern.getPatternsInsideCurrentDirectory(positive);
-    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
-    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-    /*
-     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
-     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
-     */
-    if ('.' in insideCurrentDirectoryGroup) {
-        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
-    }
-    else {
-        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
-    }
-    return tasks;
-}
-tasks.convertPatternsToTasks = convertPatternsToTasks;
-function getPositivePatterns(patterns) {
-    return utils$a.pattern.getPositivePatterns(patterns);
-}
-tasks.getPositivePatterns = getPositivePatterns;
-function getNegativePatternsAsPositive(patterns, ignore) {
-    const negative = utils$a.pattern.getNegativePatterns(patterns).concat(ignore);
-    const positive = negative.map(utils$a.pattern.convertToPositivePattern);
-    return positive;
-}
-tasks.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
-function groupPatternsByBaseDirectory(patterns) {
-    const group = {};
-    return patterns.reduce((collection, pattern) => {
-        const base = utils$a.pattern.getBaseDirectory(pattern);
-        if (base in collection) {
-            collection[base].push(pattern);
-        }
-        else {
-            collection[base] = [pattern];
-        }
-        return collection;
-    }, group);
-}
-tasks.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
-function convertPatternGroupsToTasks(positive, negative, dynamic) {
-    return Object.keys(positive).map((base) => {
-        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
-    });
-}
-tasks.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
-function convertPatternGroupToTask(base, positive, negative, dynamic) {
-    return {
-        dynamic,
-        positive,
-        negative,
-        base,
-        patterns: [].concat(positive, negative.map(utils$a.pattern.convertToNegativePattern))
-    };
-}
+Object.defineProperty(tasks, "__esModule", { value: true });
+tasks.convertPatternGroupToTask = tasks.convertPatternGroupsToTasks = tasks.groupPatternsByBaseDirectory = tasks.getNegativePatternsAsPositive = tasks.getPositivePatterns = tasks.convertPatternsToTasks = tasks.generate = void 0;
+const utils$a = utils$k;
+function generate(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))
+    };
+}
 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, '/');
-}
+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$6 = {};
+var async$7 = {};
 
-var stream$2 = {};
+var async$6 = {};
 
 var out$3 = {};
 
 var async$5 = {};
 
-Object.defineProperty(async$5, "__esModule", { value: true });
-async$5.read = void 0;
+var async$4 = {};
+
+var out$2 = {};
+
+var async$3 = {};
+
+var out$1 = {};
+
+var async$2 = {};
+
+Object.defineProperty(async$2, "__esModule", { value: true });
+async$2.read = void 0;
 function read$3(path, settings, callback) {
     settings.fs.lstat(path, (lstatError, lstat) => {
         if (lstatError !== null) {
@@ -4942,7 +4952,7 @@ function read$3(path, settings, callback) {
         });
     });
 }
-async$5.read = read$3;
+async$2.read = read$3;
 function callFailureCallback$2(callback, error) {
     callback(error);
 }
@@ -5014,25 +5024,25 @@ class Settings$2 {
 }
 settings$3.default = Settings$2;
 
-Object.defineProperty(out$3, "__esModule", { value: true });
-out$3.statSync = out$3.stat = out$3.Settings = void 0;
-const async$4 = async$5;
+Object.defineProperty(out$1, "__esModule", { value: true });
+out$1.statSync = out$1.stat = out$1.Settings = void 0;
+const async$1 = async$2;
 const sync$6 = sync$7;
 const settings_1$3 = settings$3;
-out$3.Settings = settings_1$3.default;
+out$1.Settings = settings_1$3.default;
 function stat(path, optionsOrSettingsOrCallback, callback) {
     if (typeof optionsOrSettingsOrCallback === 'function') {
-        async$4.read(path, getSettings$2(), optionsOrSettingsOrCallback);
+        async$1.read(path, getSettings$2(), optionsOrSettingsOrCallback);
         return;
     }
-    async$4.read(path, getSettings$2(optionsOrSettingsOrCallback), callback);
+    async$1.read(path, getSettings$2(optionsOrSettingsOrCallback), callback);
 }
-out$3.stat = stat;
+out$1.stat = stat;
 function statSync(path, optionsOrSettings) {
     const settings = getSettings$2(optionsOrSettings);
     return sync$6.read(path, settings);
 }
-out$3.statSync = statSync;
+out$1.statSync = statSync;
 function getSettings$2(settingsOrOptions = {}) {
     if (settingsOrOptions instanceof settings_1$3.default) {
         return settingsOrOptions;
@@ -5040,16 +5050,6 @@ function getSettings$2(settingsOrOptions = {}) {
     return new settings_1$3.default(settingsOrOptions);
 }
 
-var out$2 = {};
-
-var async$3 = {};
-
-var async$2 = {};
-
-var out$1 = {};
-
-var async$1 = {};
-
 /*! queue-microtask. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 
 let promise;
@@ -5176,9 +5176,9 @@ function joinPathSegments$1(a, b, separator) {
 }
 common$6.joinPathSegments = joinPathSegments$1;
 
-Object.defineProperty(async$1, "__esModule", { value: true });
-async$1.readdir = async$1.readdirWithFileTypes = async$1.read = void 0;
-const fsStat$5 = out$3;
+Object.defineProperty(async$3, "__esModule", { value: true });
+async$3.readdir = async$3.readdirWithFileTypes = async$3.read = void 0;
+const fsStat$5 = out$1;
 const rpl = runParallel_1;
 const constants_1$1 = constants;
 const utils$8 = utils$9;
@@ -5190,7 +5190,7 @@ function read$1(directory, settings, callback) {
     }
     readdir$1(directory, settings, callback);
 }
-async$1.read = read$1;
+async$3.read = read$1;
 function readdirWithFileTypes$1(directory, settings, callback) {
     settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
         if (readdirError !== null) {
@@ -5216,7 +5216,7 @@ function readdirWithFileTypes$1(directory, settings, callback) {
         });
     });
 }
-async$1.readdirWithFileTypes = readdirWithFileTypes$1;
+async$3.readdirWithFileTypes = readdirWithFileTypes$1;
 function makeRplTaskEntry(entry, settings) {
     return (done) => {
         if (!entry.dirent.isSymbolicLink()) {
@@ -5272,7 +5272,7 @@ function readdir$1(directory, settings, callback) {
         });
     });
 }
-async$1.readdir = readdir$1;
+async$3.readdir = readdir$1;
 function callFailureCallback$1(callback, error) {
     callback(error);
 }
@@ -5284,7 +5284,7 @@ var sync$5 = {};
 
 Object.defineProperty(sync$5, "__esModule", { value: true });
 sync$5.readdir = sync$5.readdirWithFileTypes = sync$5.read = void 0;
-const fsStat$4 = out$3;
+const fsStat$4 = out$1;
 const constants_1 = constants;
 const utils$7 = utils$9;
 const common$4 = common$6;
@@ -5363,7 +5363,7 @@ var fs$1 = {};
 
 Object.defineProperty(settings$2, "__esModule", { value: true });
 const path$3 = path$a;
-const fsStat$3 = out$3;
+const fsStat$3 = out$1;
 const fs = fs$1;
 class Settings$1 {
     constructor(_options = {}) {
@@ -5385,12 +5385,12 @@ class Settings$1 {
 }
 settings$2.default = Settings$1;
 
-Object.defineProperty(out$1, "__esModule", { value: true });
-out$1.Settings = out$1.scandirSync = out$1.scandir = void 0;
-const async = async$1;
+Object.defineProperty(out$2, "__esModule", { value: true });
+out$2.Settings = out$2.scandirSync = out$2.scandir = void 0;
+const async = async$3;
 const sync$4 = sync$5;
 const settings_1$2 = settings$2;
-out$1.Settings = settings_1$2.default;
+out$2.Settings = settings_1$2.default;
 function scandir(path, optionsOrSettingsOrCallback, callback) {
     if (typeof optionsOrSettingsOrCallback === 'function') {
         async.read(path, getSettings$1(), optionsOrSettingsOrCallback);
@@ -5398,12 +5398,12 @@ function scandir(path, optionsOrSettingsOrCallback, callback) {
     }
     async.read(path, getSettings$1(optionsOrSettingsOrCallback), callback);
 }
-out$1.scandir = scandir;
+out$2.scandir = scandir;
 function scandirSync(path, optionsOrSettings) {
     const settings = getSettings$1(optionsOrSettings);
     return sync$4.read(path, settings);
 }
-out$1.scandirSync = scandirSync;
+out$2.scandirSync = scandirSync;
 function getSettings$1(settingsOrOptions = {}) {
     if (settingsOrOptions instanceof settings_1$2.default) {
         return settingsOrOptions;
@@ -5773,13 +5773,13 @@ class Reader$1 {
 }
 reader$1.default = Reader$1;
 
-Object.defineProperty(async$2, "__esModule", { value: true });
+Object.defineProperty(async$4, "__esModule", { value: true });
 const events_1 = require$$2;
-const fsScandir$2 = out$1;
+const fsScandir$2 = out$2;
 const fastq = queue.exports;
 const common$1 = common$3;
-const reader_1$3 = reader$1;
-class AsyncReader extends reader_1$3.default {
+const reader_1$4 = reader$1;
+class AsyncReader extends reader_1$4.default {
     constructor(_root, _settings) {
         super(_root, _settings);
         this._settings = _settings;
@@ -5868,15 +5868,15 @@ class AsyncReader extends reader_1$3.default {
         this._emitter.emit('entry', entry);
     }
 }
-async$2.default = AsyncReader;
+async$4.default = AsyncReader;
 
-Object.defineProperty(async$3, "__esModule", { value: true });
-const async_1$3 = async$2;
+Object.defineProperty(async$5, "__esModule", { value: true });
+const async_1$4 = async$4;
 class AsyncProvider {
     constructor(_root, _settings) {
         this._root = _root;
         this._settings = _settings;
-        this._reader = new async_1$3.default(this._root, this._settings);
+        this._reader = new async_1$4.default(this._root, this._settings);
         this._storage = [];
     }
     read(callback) {
@@ -5892,7 +5892,7 @@ class AsyncProvider {
         this._reader.read();
     }
 }
-async$3.default = AsyncProvider;
+async$5.default = AsyncProvider;
 function callFailureCallback(callback, error) {
     callback(error);
 }
@@ -5900,16 +5900,16 @@ function callSuccessCallback(callback, entries) {
     callback(null, entries);
 }
 
-var stream$1 = {};
+var stream$2 = {};
 
-Object.defineProperty(stream$1, "__esModule", { value: true });
+Object.defineProperty(stream$2, "__esModule", { value: true });
 const stream_1$5 = require$$0$1;
-const async_1$2 = async$2;
+const async_1$3 = async$4;
 class StreamProvider {
     constructor(_root, _settings) {
         this._root = _root;
         this._settings = _settings;
-        this._reader = new async_1$2.default(this._root, this._settings);
+        this._reader = new async_1$3.default(this._root, this._settings);
         this._stream = new stream_1$5.Readable({
             objectMode: true,
             read: () => { },
@@ -5934,17 +5934,17 @@ class StreamProvider {
         return this._stream;
     }
 }
-stream$1.default = StreamProvider;
+stream$2.default = StreamProvider;
 
 var sync$3 = {};
 
 var sync$2 = {};
 
 Object.defineProperty(sync$2, "__esModule", { value: true });
-const fsScandir$1 = out$1;
+const fsScandir$1 = out$2;
 const common = common$3;
-const reader_1$2 = reader$1;
-class SyncReader extends reader_1$2.default {
+const reader_1$3 = reader$1;
+class SyncReader extends reader_1$3.default {
     constructor() {
         super(...arguments);
         this._scandir = fsScandir$1.scandirSync;
@@ -6017,7 +6017,7 @@ var settings$1 = {};
 
 Object.defineProperty(settings$1, "__esModule", { value: true });
 const path$2 = path$a;
-const fsScandir = out$1;
+const fsScandir = out$2;
 class Settings {
     constructor(_options = {}) {
         this._options = _options;
@@ -6041,33 +6041,33 @@ class Settings {
 }
 settings$1.default = Settings;
 
-Object.defineProperty(out$2, "__esModule", { value: true });
-out$2.Settings = out$2.walkStream = out$2.walkSync = out$2.walk = void 0;
-const async_1$1 = async$3;
-const stream_1$4 = stream$1;
+Object.defineProperty(out$3, "__esModule", { value: true });
+out$3.Settings = out$3.walkStream = out$3.walkSync = out$3.walk = void 0;
+const async_1$2 = async$5;
+const stream_1$4 = stream$2;
 const sync_1$2 = sync$3;
 const settings_1$1 = settings$1;
-out$2.Settings = settings_1$1.default;
+out$3.Settings = settings_1$1.default;
 function walk(directory, optionsOrSettingsOrCallback, callback) {
     if (typeof optionsOrSettingsOrCallback === 'function') {
-        new async_1$1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+        new async_1$2.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
         return;
     }
-    new async_1$1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+    new async_1$2.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
 }
-out$2.walk = walk;
+out$3.walk = walk;
 function walkSync(directory, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
     const provider = new sync_1$2.default(directory, settings);
     return provider.read();
 }
-out$2.walkSync = walkSync;
+out$3.walkSync = walkSync;
 function walkStream(directory, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
     const provider = new stream_1$4.default(directory, settings);
     return provider.read();
 }
-out$2.walkStream = walkStream;
+out$3.walkStream = walkStream;
 function getSettings(settingsOrOptions = {}) {
     if (settingsOrOptions instanceof settings_1$1.default) {
         return settingsOrOptions;
@@ -6077,93 +6077,130 @@ function getSettings(settingsOrOptions = {}) {
 
 var reader = {};
 
-Object.defineProperty(reader, "__esModule", { value: true });
-const path$1 = path$a;
-const fsStat$2 = out$3;
-const utils$6 = utils$k;
-class Reader {
-    constructor(_settings) {
-        this._settings = _settings;
-        this._fsStatSettings = new fsStat$2.Settings({
-            followSymbolicLink: this._settings.followSymbolicLinks,
-            fs: this._settings.fs,
-            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
-        });
-    }
-    _getFullEntryPath(filepath) {
-        return path$1.resolve(this._settings.cwd, filepath);
-    }
-    _makeEntry(stats, pattern) {
-        const entry = {
-            name: pattern,
-            path: pattern,
-            dirent: utils$6.fs.createDirentFromStats(pattern, stats)
-        };
-        if (this._settings.stats) {
-            entry.stats = stats;
-        }
-        return entry;
-    }
-    _isFatalError(error) {
-        return !utils$6.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
-    }
-}
+Object.defineProperty(reader, "__esModule", { value: true });
+const path$1 = path$a;
+const fsStat$2 = out$1;
+const utils$6 = utils$k;
+class Reader {
+    constructor(_settings) {
+        this._settings = _settings;
+        this._fsStatSettings = new fsStat$2.Settings({
+            followSymbolicLink: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+        });
+    }
+    _getFullEntryPath(filepath) {
+        return path$1.resolve(this._settings.cwd, filepath);
+    }
+    _makeEntry(stats, pattern) {
+        const entry = {
+            name: pattern,
+            path: pattern,
+            dirent: utils$6.fs.createDirentFromStats(pattern, stats)
+        };
+        if (this._settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    }
+    _isFatalError(error) {
+        return !utils$6.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+    }
+}
 reader.default = Reader;
 
-Object.defineProperty(stream$2, "__esModule", { value: true });
-const stream_1$3 = require$$0$1;
-const fsStat$1 = out$3;
-const fsWalk$1 = out$2;
-const reader_1$1 = reader;
-class ReaderStream extends reader_1$1.default {
-    constructor() {
-        super(...arguments);
-        this._walkStream = fsWalk$1.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;
+var stream$1 = {};
+
+Object.defineProperty(stream$1, "__esModule", { value: true });
+const stream_1$3 = require$$0$1;
+const fsStat$1 = out$1;
+const fsWalk$2 = out$3;
+const reader_1$2 = reader;
+class ReaderStream extends reader_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._walkStream = fsWalk$2.walkStream;
+        this._stat = fsStat$1.stat;
+    }
+    dynamic(root, options) {
+        return this._walkStream(root, options);
+    }
+    static(patterns, options) {
+        const filepaths = patterns.map(this._getFullEntryPath, this);
+        const stream = new stream_1$3.PassThrough({ objectMode: true });
+        stream._write = (index, _enc, done) => {
+            return this._getEntry(filepaths[index], patterns[index], options)
+                .then((entry) => {
+                if (entry !== null && options.entryFilter(entry)) {
+                    stream.push(entry);
+                }
+                if (index === filepaths.length - 1) {
+                    stream.end();
+                }
+                done();
+            })
+                .catch(done);
+        };
+        for (let i = 0; i < filepaths.length; i++) {
+            stream.write(i);
+        }
+        return stream;
+    }
+    _getEntry(filepath, pattern, options) {
+        return this._getStat(filepath)
+            .then((stats) => this._makeEntry(stats, pattern))
+            .catch((error) => {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        });
+    }
+    _getStat(filepath) {
+        return new Promise((resolve, reject) => {
+            this._stat(filepath, this._fsStatSettings, (error, stats) => {
+                return error === null ? resolve(stats) : reject(error);
+            });
+        });
+    }
+}
+stream$1.default = ReaderStream;
+
+Object.defineProperty(async$6, "__esModule", { value: true });
+const fsWalk$1 = out$3;
+const reader_1$1 = reader;
+const stream_1$2 = stream$1;
+class ReaderAsync extends reader_1$1.default {
+    constructor() {
+        super(...arguments);
+        this._walkAsync = fsWalk$1.walk;
+        this._readerStream = new stream_1$2.default(this._settings);
+    }
+    dynamic(root, options) {
+        return new Promise((resolve, reject) => {
+            this._walkAsync(root, options, (error, entries) => {
+                if (error === null) {
+                    resolve(entries);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async static(patterns, options) {
+        const entries = [];
+        const stream = this._readerStream.static(patterns, options);
+        // After #235, replace it with an asynchronous iterator.
+        return new Promise((resolve, reject) => {
+            stream.once('error', reject);
+            stream.on('data', (entry) => entries.push(entry));
+            stream.once('end', () => resolve(entries));
+        });
+    }
+}
+async$6.default = ReaderAsync;
 
 var provider = {};
 
@@ -6173,569 +6210,568 @@ 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() {
+        /**
+         * 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));
+    }
+}
 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 isMatched = this._isMatchToPatterns(filepath, positiveRe) && !this._isMatchToPatterns(entry.path, negativeRe);
-        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);
-    }
-    /**
-     * First, just trying to apply patterns to the path.
-     * Second, trying to apply patterns to the path with final slash.
-     */
-    _isMatchToPatterns(entryPath, patternsRe) {
-        const filepath = utils$3.path.removeLeadingDotSegment(entryPath);
-        return utils$3.pattern.matchAny(filepath, patternsRe) || utils$3.pattern.matchAny(filepath + '/', patternsRe);
-    }
-}
+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;
+    }
+}
 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 = path$a;
-const deep_1 = deep;
-const entry_1 = entry$1;
-const error_1 = error;
-const entry_2 = entry;
-class Provider {
-    constructor(_settings) {
-        this._settings = _settings;
-        this.errorFilter = new error_1.default(this._settings);
-        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
-        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
-        this.entryTransformer = new entry_2.default(this._settings);
-    }
-    _getRootDirectory(task) {
-        return path.resolve(this._settings.cwd, task.base);
-    }
-    _getReaderOptions(task) {
-        const basePath = task.base === '.' ? '' : task.base;
-        return {
-            basePath,
-            pathSegmentSeparator: '/',
-            concurrency: this._settings.concurrency,
-            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
-            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
-            errorFilter: this.errorFilter.getFilter(),
-            followSymbolicLinks: this._settings.followSymbolicLinks,
-            fs: this._settings.fs,
-            stats: this._settings.stats,
-            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
-            transform: this.entryTransformer.getTransformer()
-        };
-    }
-    _getMicromatchOptions() {
-        return {
-            dot: this._settings.dot,
-            matchBase: this._settings.baseNameMatch,
-            nobrace: !this._settings.braceExpansion,
-            nocase: !this._settings.caseSensitiveMatch,
-            noext: !this._settings.extglob,
-            noglobstar: !this._settings.globstar,
-            posix: true,
-            strictSlashes: false
-        };
-    }
-}
+Object.defineProperty(provider, "__esModule", { value: true });
+const path = path$a;
+const deep_1 = deep;
+const entry_1 = entry$1;
+const error_1 = error;
+const entry_2 = entry;
+class Provider {
+    constructor(_settings) {
+        this._settings = _settings;
+        this.errorFilter = new error_1.default(this._settings);
+        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+        this.entryTransformer = new entry_2.default(this._settings);
+    }
+    _getRootDirectory(task) {
+        return path.resolve(this._settings.cwd, task.base);
+    }
+    _getReaderOptions(task) {
+        const basePath = task.base === '.' ? '' : task.base;
+        return {
+            basePath,
+            pathSegmentSeparator: '/',
+            concurrency: this._settings.concurrency,
+            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+            errorFilter: this.errorFilter.getFilter(),
+            followSymbolicLinks: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            stats: this._settings.stats,
+            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+            transform: this.entryTransformer.getTransformer()
+        };
+    }
+    _getMicromatchOptions() {
+        return {
+            dot: this._settings.dot,
+            matchBase: this._settings.baseNameMatch,
+            nobrace: !this._settings.braceExpansion,
+            nocase: !this._settings.caseSensitiveMatch,
+            noext: !this._settings.extglob,
+            noglobstar: !this._settings.globstar,
+            posix: true,
+            strictSlashes: false
+        };
+    }
+}
 provider.default = Provider;
 
-Object.defineProperty(async$6, "__esModule", { value: true });
-const stream_1$2 = stream$2;
-const provider_1$2 = provider;
-class ProviderAsync extends provider_1$2.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new stream_1$2.default(this._settings);
-    }
-    read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = [];
-        return new Promise((resolve, reject) => {
-            const stream = this.api(root, task, options);
-            stream.once('error', reject);
-            stream.on('data', (entry) => entries.push(options.transform(entry)));
-            stream.once('end', () => resolve(entries));
-        });
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
-async$6.default = ProviderAsync;
+Object.defineProperty(async$7, "__esModule", { value: true });
+const async_1$1 = async$6;
+const provider_1$2 = provider;
+class ProviderAsync extends provider_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new async_1$1.default(this._settings);
+    }
+    async read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = await this.api(root, task, options);
+        return entries.map((entry) => options.transform(entry));
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+async$7.default = ProviderAsync;
 
 var stream = {};
 
-Object.defineProperty(stream, "__esModule", { value: true });
-const stream_1$1 = require$$0$1;
-const stream_2 = stream$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, "__esModule", { value: true });
+const stream_1$1 = require$$0$1;
+const stream_2 = stream$1;
+const provider_1$1 = provider;
+class ProviderStream extends provider_1$1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new stream_2.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const source = this.api(root, task, options);
+        const destination = new stream_1$1.Readable({ objectMode: true, read: () => { } });
+        source
+            .once('error', (error) => destination.emit('error', error))
+            .on('data', (entry) => destination.emit('data', options.transform(entry)))
+            .once('end', () => destination.emit('end'));
+        destination
+            .once('close', () => source.destroy());
+        return destination;
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
 stream.default = ProviderStream;
 
 var sync$1 = {};
 
 var sync = {};
 
-Object.defineProperty(sync, "__esModule", { value: true });
-const fsStat = out$3;
-const fsWalk = out$2;
-const reader_1 = reader;
-class ReaderSync extends reader_1.default {
-    constructor() {
-        super(...arguments);
-        this._walkSync = fsWalk.walkSync;
-        this._statSync = fsStat.statSync;
-    }
-    dynamic(root, options) {
-        return this._walkSync(root, options);
-    }
-    static(patterns, options) {
-        const entries = [];
-        for (const pattern of patterns) {
-            const filepath = this._getFullEntryPath(pattern);
-            const entry = this._getEntry(filepath, pattern, options);
-            if (entry === null || !options.entryFilter(entry)) {
-                continue;
-            }
-            entries.push(entry);
-        }
-        return entries;
-    }
-    _getEntry(filepath, pattern, options) {
-        try {
-            const stats = this._getStat(filepath);
-            return this._makeEntry(stats, pattern);
-        }
-        catch (error) {
-            if (options.errorFilter(error)) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    _getStat(filepath) {
-        return this._statSync(filepath, this._fsStatSettings);
-    }
-}
+Object.defineProperty(sync, "__esModule", { value: true });
+const fsStat = out$1;
+const fsWalk = out$3;
+const reader_1 = reader;
+class ReaderSync extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._walkSync = fsWalk.walkSync;
+        this._statSync = fsStat.statSync;
+    }
+    dynamic(root, options) {
+        return this._walkSync(root, options);
+    }
+    static(patterns, options) {
+        const entries = [];
+        for (const pattern of patterns) {
+            const filepath = this._getFullEntryPath(pattern);
+            const entry = this._getEntry(filepath, pattern, options);
+            if (entry === null || !options.entryFilter(entry)) {
+                continue;
+            }
+            entries.push(entry);
+        }
+        return entries;
+    }
+    _getEntry(filepath, pattern, options) {
+        try {
+            const stats = this._getStat(filepath);
+            return this._makeEntry(stats, pattern);
+        }
+        catch (error) {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    _getStat(filepath) {
+        return this._statSync(filepath, this._fsStatSettings);
+    }
+}
 sync.default = ReaderSync;
 
-Object.defineProperty(sync$1, "__esModule", { value: true });
-const sync_1$1 = sync;
-const provider_1 = provider;
-class ProviderSync extends provider_1.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new sync_1$1.default(this._settings);
-    }
-    read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = this.api(root, task, options);
-        return entries.map(options.transform);
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
+Object.defineProperty(sync$1, "__esModule", { value: true });
+const sync_1$1 = sync;
+const provider_1 = provider;
+class ProviderSync extends provider_1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new sync_1$1.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = this.api(root, task, options);
+        return entries.map(options.transform);
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
 sync$1.default = ProviderSync;
 
 var settings = {};
 
 (function (exports) {
-	Object.defineProperty(exports, "__esModule", { value: true });
-	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
-	const fs = fs$8;
-	const os = require$$0;
-	/**
-	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
-	 * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
-	 */
-	const CPU_COUNT = Math.max(os.cpus().length, 1);
-	exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
-	    lstat: fs.lstat,
-	    lstatSync: fs.lstatSync,
-	    stat: fs.stat,
-	    statSync: fs.statSync,
-	    readdir: fs.readdir,
-	    readdirSync: fs.readdirSync
-	};
-	class Settings {
-	    constructor(_options = {}) {
-	        this._options = _options;
-	        this.absolute = this._getValue(this._options.absolute, false);
-	        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
-	        this.braceExpansion = this._getValue(this._options.braceExpansion, true);
-	        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
-	        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
-	        this.cwd = this._getValue(this._options.cwd, process.cwd());
-	        this.deep = this._getValue(this._options.deep, Infinity);
-	        this.dot = this._getValue(this._options.dot, false);
-	        this.extglob = this._getValue(this._options.extglob, true);
-	        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
-	        this.fs = this._getFileSystemMethods(this._options.fs);
-	        this.globstar = this._getValue(this._options.globstar, true);
-	        this.ignore = this._getValue(this._options.ignore, []);
-	        this.markDirectories = this._getValue(this._options.markDirectories, false);
-	        this.objectMode = this._getValue(this._options.objectMode, false);
-	        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
-	        this.onlyFiles = this._getValue(this._options.onlyFiles, true);
-	        this.stats = this._getValue(this._options.stats, false);
-	        this.suppressErrors = this._getValue(this._options.suppressErrors, false);
-	        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
-	        this.unique = this._getValue(this._options.unique, true);
-	        if (this.onlyDirectories) {
-	            this.onlyFiles = false;
-	        }
-	        if (this.stats) {
-	            this.objectMode = true;
-	        }
-	    }
-	    _getValue(option, value) {
-	        return option === undefined ? value : option;
-	    }
-	    _getFileSystemMethods(methods = {}) {
-	        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
-	    }
-	}
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+	const fs = fs$8;
+	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$6;
-const stream_1 = stream;
-const sync_1 = sync$1;
-const settings_1 = settings;
-const utils = utils$k;
-async function FastGlob(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, async_1.default, options);
-    const result = await Promise.all(works);
-    return utils.array.flatten(result);
-}
-// https://github.com/typescript-eslint/typescript-eslint/issues/60
-// eslint-disable-next-line no-redeclare
-(function (FastGlob) {
-    function sync(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, sync_1.default, options);
-        return utils.array.flatten(works);
-    }
-    FastGlob.sync = sync;
-    function stream(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, stream_1.default, options);
-        /**
-         * The stream returned by the provider cannot work with an asynchronous iterator.
-         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
-         * This affects performance (+25%). I don't see best solution right now.
-         */
-        return utils.stream.merge(works);
-    }
-    FastGlob.stream = stream;
-    function generateTasks(source, options) {
-        assertPatternsInput(source);
-        const patterns = patternManager.transform([].concat(source));
-        const settings = new settings_1.default(options);
-        return taskManager.generate(patterns, settings);
-    }
-    FastGlob.generateTasks = generateTasks;
-    function isDynamicPattern(source, options) {
-        assertPatternsInput(source);
-        const settings = new settings_1.default(options);
-        return utils.pattern.isDynamicPattern(source, settings);
-    }
-    FastGlob.isDynamicPattern = isDynamicPattern;
-    function escapePath(source) {
-        assertPatternsInput(source);
-        return utils.path.escape(source);
-    }
-    FastGlob.escapePath = escapePath;
-})(FastGlob || (FastGlob = {}));
-function getWorks(source, _Provider, options) {
-    const patterns = patternManager.transform([].concat(source));
-    const settings = new settings_1.default(options);
-    const tasks = taskManager.generate(patterns, settings);
-    const provider = new _Provider(settings);
-    return tasks.map(provider.read, provider);
-}
-function assertPatternsInput(input) {
-    const source = [].concat(input);
-    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
-    if (!isValidSource) {
-        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
-    }
-}
+const taskManager = tasks;
+const patternManager = patterns;
+const async_1 = async$7;
+const stream_1 = stream;
+const sync_1 = sync$1;
+const settings_1 = settings;
+const utils = utils$k;
+async function FastGlob(source, options) {
+    assertPatternsInput(source);
+    const works = getWorks(source, async_1.default, options);
+    const result = await Promise.all(works);
+    return utils.array.flatten(result);
+}
+// https://github.com/typescript-eslint/typescript-eslint/issues/60
+// eslint-disable-next-line no-redeclare
+(function (FastGlob) {
+    function sync(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, sync_1.default, options);
+        return utils.array.flatten(works);
+    }
+    FastGlob.sync = sync;
+    function stream(source, options) {
+        assertPatternsInput(source);
+        const works = getWorks(source, stream_1.default, options);
+        /**
+         * The stream returned by the provider cannot work with an asynchronous iterator.
+         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+         * This affects performance (+25%). I don't see best solution right now.
+         */
+        return utils.stream.merge(works);
+    }
+    FastGlob.stream = stream;
+    function generateTasks(source, options) {
+        assertPatternsInput(source);
+        const patterns = patternManager.transform([].concat(source));
+        const settings = new settings_1.default(options);
+        return taskManager.generate(patterns, settings);
+    }
+    FastGlob.generateTasks = generateTasks;
+    function isDynamicPattern(source, options) {
+        assertPatternsInput(source);
+        const settings = new settings_1.default(options);
+        return utils.pattern.isDynamicPattern(source, settings);
+    }
+    FastGlob.isDynamicPattern = isDynamicPattern;
+    function escapePath(source) {
+        assertPatternsInput(source);
+        return utils.path.escape(source);
+    }
+    FastGlob.escapePath = escapePath;
+})(FastGlob || (FastGlob = {}));
+function getWorks(source, _Provider, options) {
+    const patterns = patternManager.transform([].concat(source));
+    const settings = new settings_1.default(options);
+    const tasks = taskManager.generate(patterns, settings);
+    const provider = new _Provider(settings);
+    return tasks.map(provider.read, provider);
+}
+function assertPatternsInput(input) {
+    const source = [].concat(input);
+    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
+    if (!isValidSource) {
+        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
+    }
+}
 var out = FastGlob;
 
 const ESM_EXT_RE = /\.(es|esm|esm-browser|esm-bundler|es6|module)\.js$/;
@@ -6853,7 +6889,7 @@ class ViteNodeServer {
       }, options.debug ?? {});
     }
     if (options.debug)
-      import('./chunk-vite-node-debug.536c4c5b.mjs').then((r) => this.debugger = new r.Debugger(server.config.root, options.debug));
+      import('./chunk-vite-node-debug.77d9dcea.js').then((r) => this.debugger = new r.Debugger(server.config.root, options.debug));
   }
   shouldExternalize(id) {
     return shouldExternalize(id, this.options.deps, this.externalizeCache);
@@ -7019,8 +7055,8 @@ function addSnapshotResult(summary, result) {
   summary.total += result.added + result.matched + result.unmatched + result.updated;
 }
 
-const workerPath = url.pathToFileURL(resolve(distDir, "./worker.mjs")).href;
-const loaderPath = url.pathToFileURL(resolve(distDir, "./loader.mjs")).href;
+const workerPath = url.pathToFileURL(resolve(distDir, "./worker.js")).href;
+const loaderPath = url.pathToFileURL(resolve(distDir, "./loader.js")).href;
 const suppressLoaderWarningsPath = resolve(rootDir, "./suppress-warnings.cjs");
 function createPool(ctx) {
   var _a, _b, _c;
@@ -7899,8 +7935,8 @@ class DotReporter extends BaseReporter {
   }
 }
 
-const getOutputFile = ({ config }, reporter) => {
-  if (!config.outputFile)
+const getOutputFile = (config, reporter) => {
+  if (!(config == null ? void 0 : config.outputFile))
     return;
   if (typeof config.outputFile === "string")
     return config.outputFile;
@@ -8019,7 +8055,7 @@ class JsonReporter$1 {
     await this.logTasks(files);
   }
   async writeReport(report) {
-    const outputFile = getOutputFile(this.ctx, "json");
+    const outputFile = getOutputFile(this.ctx.config, "json");
     if (outputFile) {
       const reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(reportFile);
@@ -8194,7 +8230,7 @@ function getDuration(task) {
 class JUnitReporter {
   async onInit(ctx) {
     this.ctx = ctx;
-    const outputFile = getOutputFile(this.ctx, "junit");
+    const outputFile = getOutputFile(this.ctx.config, "junit");
     if (outputFile) {
       this.reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(this.reportFile);
@@ -8355,7 +8391,7 @@ class JsonReporter {
     const tests = getTests(files);
     const numTotalTests = tests.length;
     const testResults = {};
-    const outputFile = getOutputFile(this.ctx, "json");
+    const outputFile = getOutputFile(this.ctx.config.benchmark, "json");
     for (const file of files) {
       const tests2 = getTests([file]);
       for (const test of tests2) {
@@ -8384,7 +8420,7 @@ class JsonReporter {
     await this.logTasks(files);
   }
   async writeReport(report) {
-    const outputFile = getOutputFile(this.ctx, "json");
+    const outputFile = getOutputFile(this.ctx.config.benchmark, "json");
     if (outputFile) {
       const reportFile = resolve(this.ctx.config.root, outputFile);
       const outputDirectory = dirname(reportFile);
@@ -8898,6 +8934,16 @@ function resolveConfig(mode, options, viteConfig) {
     resolved.include = resolved.benchmark.include;
     resolved.exclude = resolved.benchmark.exclude;
     resolved.includeSource = resolved.benchmark.includeSource;
+    const reporters = Array.from(/* @__PURE__ */ new Set([
+      ...toArray$1(resolved.benchmark.reporters),
+      ...toArray$1(options.reporter)
+    ])).filter(Boolean);
+    if (reporters.length)
+      resolved.benchmark.reporters = reporters;
+    else
+      resolved.benchmark.reporters = ["default"];
+    if (options.outputFile)
+      resolved.benchmark.outputFile = options.outputFile;
   }
   resolved.setupFiles = toArray$1(resolved.setupFiles || []).map(
     (file) => normalize(
@@ -8907,10 +8953,12 @@ function resolveConfig(mode, options, viteConfig) {
   resolved.api = resolveApiConfig(options);
   if (options.related)
     resolved.related = toArray$1(options.related).map((file) => resolve(resolved.root, file));
-  resolved.reporters = Array.from(/* @__PURE__ */ new Set([
-    ...toArray$1(resolved.reporters),
-    ...toArray$1(resolved.reporter)
-  ])).filter(Boolean);
+  if (mode !== "benchmark") {
+    resolved.reporters = Array.from(/* @__PURE__ */ new Set([
+      ...toArray$1(resolved.reporters),
+      ...toArray$1(resolved.reporter)
+    ])).filter(Boolean);
+  }
   if (!resolved.reporters.length)
     resolved.reporters.push("default");
   if (resolved.changed)
@@ -9416,7 +9464,7 @@ createLogUpdate(process$1.stdout);
 
 createLogUpdate(process$1.stderr);
 
-var version = "0.23.2";
+var version = "0.24.0";
 
 function fileFromParsedStack(stack) {
   var _a, _b;
@@ -9433,6 +9481,13 @@ async function printError(error, ctx, options = {}) {
       stack: error
     };
   }
+  if (!e) {
+    const error2 = new Error("unknown error");
+    e = {
+      message: e ?? error2.message,
+      stack: error2.stack
+    };
+  }
   const stacks = parseStacktrace(e, fullStack);
   await interpretSourcePos(stacks, ctx);
   const nearest = stacks.find(
@@ -9831,7 +9886,7 @@ class Vitest {
   }
   async filterTestsBySource(tests) {
     if (this.config.changed && !this.config.related) {
-      const { VitestGit } = await import('./chunk-node-git.a44b4872.mjs');
+      const { VitestGit } = await import('./chunk-node-git.6d82fb34.js');
       const vitestGit = new VitestGit(this.config.root);
       const related2 = await vitestGit.findChangedFiles({
         changedSince: this.config.changed
@@ -9850,15 +9905,15 @@ class Vitest {
       return tests;
     if (!related.length)
       return [];
-    const testDeps = await Promise.all(
+    const testGraphs = await Promise.all(
       tests.map(async (filepath) => {
         const deps = await this.getTestDependencies(filepath);
         return [filepath, deps];
       })
     );
     const runningTests = [];
-    for (const [filepath, deps] of testDeps) {
-      if (deps.size && related.some((path) => path === filepath || deps.has(path)))
+    for (const [filepath, deps] of testGraphs) {
+      if (related.some((path) => path === filepath || deps.has(path)))
         runningTests.push(filepath);
     }
     return runningTests;
@@ -10502,7 +10557,7 @@ async function VitestPlugin(options = {}, ctx = new Vitest("test")) {
         try {
           await ctx.setServer(options, server);
           if (options.api && options.watch)
-            (await import('./chunk-api-setup.11cfd513.mjs')).setup(ctx);
+            (await import('./chunk-api-setup.33222ae9.js')).setup(ctx);
         } catch (err) {
           ctx.logger.printError(err, true);
           process.exit(1);