vitest 0.0.96 → 0.0.100

package/dist/{index-ece64e3c.js → index-113b8b23.js}

@@ -1,14 +1,16 @@
-import path$2, { isAbsolute, relative, dirname, basename, resolve } from 'path';
+import { c, g as getNames, s as slash$1, a as getTests, i as isAbsolute, r as relative, d as dirname, b as basename, f as getSuites, h as resolve, n as noop$1, t as toArray, j as hasFailed } from './utils-b780070b.js';
 import { createServer, mergeConfig } from 'vite';
+import path$a from 'path';
 import process$1 from 'process';
-import { promises } from 'fs';
-import fg from 'fast-glob';
-import require$$0 from 'util';
-import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as distDir, e as configFiles } from './constants-9cfa4d7b.js';
-import { c, g as getNames, s as slash, a as getTests, b as getSuites, n as noop, t as toArray, h as hasFailed } from './utils-576876dc.js';
+import fs$8, { promises } from 'fs';
+import require$$0 from 'os';
+import require$$0$1 from 'util';
+import require$$0$2 from 'stream';
+import require$$2 from 'events';
+import { d as defaultInclude, a as defaultExclude, b as defaultPort, c as distDir, e as configFiles } from './constants-3cbd9066.js';
 import { performance } from 'perf_hooks';
-import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, F as F_POINTER, d as F_DOWN, e as F_LONG_DASH, f as F_DOWN_RIGHT, g as F_DOT, h as F_CHECK, i as F_CROSS, j as cliTruncate, k as F_RIGHT, p as printError } from './error-81292c96.js';
-import { o as onetime, s as signalExit } from './index-5cc247ff.js';
+import { s as stringWidth, a as ansiStyles, b as stripAnsi, c as sliceAnsi, F as F_POINTER, d as F_DOWN, e as F_LONG_DASH, f as F_DOWN_RIGHT, g as F_DOT, h as F_CHECK, i as F_CROSS, j as cliTruncate, k as F_RIGHT, p as printError } from './error-34c1d9e5.js';
+import { o as onetime, s as signalExit } from './index-825cb54c.js';
 import { MessageChannel } from 'worker_threads';
 import { pathToFileURL } from 'url';
 import { Tinypool } from 'tinypool';
@@ -226,7 +228,7 @@ async function locatePath(
 
 	return pLocate(paths, async path_ => {
 		try {
-			const stat = await statFunction(path$2.resolve(cwd, path_));
+			const stat = await statFunction(path$a.resolve(cwd, path_));
 			return matchType(type, stat);
 		} catch {
 			return false;
@@ -237,9 +239,9 @@ async function locatePath(
 const findUpStop = Symbol('findUpStop');
 
 async function findUpMultiple(name, options = {}) {
-	let directory = path$2.resolve(options.cwd || '');
-	const {root} = path$2.parse(directory);
-	const stopAt = path$2.resolve(directory, options.stopAt || root);
+	let directory = path$a.resolve(options.cwd || '');
+	const {root} = path$a.parse(directory);
+	const stopAt = path$a.resolve(directory, options.stopAt || root);
 	const limit = options.limit || Number.POSITIVE_INFINITY;
 	const paths = [name].flat();
 
@@ -267,14 +269,14 @@ async function findUpMultiple(name, options = {}) {
 		}
 
 		if (foundPath) {
-			matches.push(path$2.resolve(directory, foundPath));
+			matches.push(path$a.resolve(directory, foundPath));
 		}
 
 		if (directory === stopAt || matches.length >= limit) {
 			break;
 		}
 
-		directory = path$2.dirname(directory);
+		directory = path$a.dirname(directory);
 	}
 
 	return matches;
@@ -285,7 +287,315 @@ async function findUp(name, options = {}) {
 	return matches[0];
 }
 
-var utils$8 = {};
+var tasks = {};
+
+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;
+}
+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';
+}
+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);
+}
+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;
+}
+path$9.removeLeadingDotSegment = removeLeadingDotSegment;
+
+var pattern$1 = {};
+
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var isExtglob$1 = function isExtglob(str) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
+  }
+
+  var match;
+  while ((match = /(\\).|([@?!+*]\(.*\))/g.exec(str))) {
+    if (match[2]) return true;
+    str = str.slice(match.index + match[0].length);
+  }
+
+  return false;
+};
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+var isExtglob = isExtglob$1;
+var chars = { '{': '}', '(': ')', '[': ']'};
+var strictCheck = function(str) {
+  if (str[0] === '!') {
+    return true;
+  }
+  var index = 0;
+  var pipeIndex = -2;
+  var closeSquareIndex = -2;
+  var closeCurlyIndex = -2;
+  var closeParenIndex = -2;
+  var backSlashIndex = -2;
+  while (index < str.length) {
+    if (str[index] === '*') {
+      return true;
+    }
+
+    if (str[index + 1] === '?' && /[\].+)]/.test(str[index])) {
+      return true;
+    }
+
+    if (closeSquareIndex !== -1 && str[index] === '[' && str[index + 1] !== ']') {
+      if (closeSquareIndex < index) {
+        closeSquareIndex = str.indexOf(']', index);
+      }
+      if (closeSquareIndex > index) {
+        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+          return true;
+        }
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeSquareIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (closeCurlyIndex !== -1 && str[index] === '{' && str[index + 1] !== '}') {
+      closeCurlyIndex = str.indexOf('}', index);
+      if (closeCurlyIndex > index) {
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeCurlyIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (closeParenIndex !== -1 && str[index] === '(' && str[index + 1] === '?' && /[:!=]/.test(str[index + 2]) && str[index + 3] !== ')') {
+      closeParenIndex = str.indexOf(')', index);
+      if (closeParenIndex > index) {
+        backSlashIndex = str.indexOf('\\', index);
+        if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+          return true;
+        }
+      }
+    }
+
+    if (pipeIndex !== -1 && str[index] === '(' && str[index + 1] !== '|') {
+      if (pipeIndex < index) {
+        pipeIndex = str.indexOf('|', index);
+      }
+      if (pipeIndex !== -1 && str[pipeIndex + 1] !== ')') {
+        closeParenIndex = str.indexOf(')', pipeIndex);
+        if (closeParenIndex > pipeIndex) {
+          backSlashIndex = str.indexOf('\\', pipeIndex);
+          if (backSlashIndex === -1 || backSlashIndex > closeParenIndex) {
+            return true;
+          }
+        }
+      }
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var relaxedCheck = function(str) {
+  if (str[0] === '!') {
+    return true;
+  }
+  var index = 0;
+  while (index < str.length) {
+    if (/[*?{}()[\]]/.test(str[index])) {
+      return true;
+    }
+
+    if (str[index] === '\\') {
+      var open = str[index + 1];
+      index += 2;
+      var close = chars[open];
+
+      if (close) {
+        var n = str.indexOf(close, index);
+        if (n !== -1) {
+          index = n + 1;
+        }
+      }
+
+      if (str[index] === '!') {
+        return true;
+      }
+    } else {
+      index++;
+    }
+  }
+  return false;
+};
+
+var isGlob$1 = function isGlob(str, options) {
+  if (typeof str !== 'string' || str === '') {
+    return false;
+  }
+
+  if (isExtglob(str)) {
+    return true;
+  }
+
+  var check = strictCheck;
+
+  // optionally relax check
+  if (options && options.strict === false) {
+    check = relaxedCheck;
+  }
+
+  return check(str);
+};
+
+var isGlob = isGlob$1;
+var pathPosixDirname = path$a.posix.dirname;
+var isWin32 = require$$0.platform() === 'win32';
+
+var slash = '/';
+var backslash = /\\/g;
+var enclosure = /[\{\[].*[\}\]]$/;
+var globby = /(^|[^\\])([\{\[]|\([^\)]+$)/;
+var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
+
+/**
+ * @param {string} str
+ * @param {Object} opts
+ * @param {boolean} [opts.flipBackslashes=true]
+ * @returns {string}
+ */
+var globParent$1 = function globParent(str, opts) {
+  var options = Object.assign({ flipBackslashes: true }, opts);
+
+  // flip windows path separators
+  if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) {
+    str = str.replace(backslash, slash);
+  }
+
+  // special case for strings ending in enclosure containing path separator
+  if (enclosure.test(str)) {
+    str += slash;
+  }
+
+  // preserves full path in case of trailing path separator
+  str += 'a';
+
+  // remove path parts that are globby
+  do {
+    str = pathPosixDirname(str);
+  } while (isGlob(str) || globby.test(str));
+
+  // remove escape chars and return result
+  return str.replace(escaped, '$1');
+};
+
+var utils$j = {};
 
 (function (exports) {
 
@@ -399,18 +709,18 @@ exports.flatten = (...args) => {
   flat(args);
   return result;
 };
-}(utils$8));
+}(utils$j));
 
-const utils$7 = utils$8;
+const utils$i = utils$j;
 
 var stringify$4 = (ast, options = {}) => {
   let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils$7.isInvalidBrace(parent);
+    let invalidBlock = options.escapeInvalid && utils$i.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let output = '';
 
     if (node.value) {
-      if ((invalidBlock || invalidNode) && utils$7.isOpenOrClose(node)) {
+      if ((invalidBlock || invalidNode) && utils$i.isOpenOrClose(node)) {
         return '\\' + node.value;
       }
       return node.value;
@@ -742,7 +1052,7 @@ var toRegexRange_1 = toRegexRange$1;
  * Licensed under the MIT License.
  */
 
-const util$1 = require$$0;
+const util$1 = require$$0$1;
 const toRegexRange = toRegexRange_1;
 
 const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
@@ -984,11 +1294,11 @@ const fill$2 = (start, end, step, options = {}) => {
 var fillRange = fill$2;
 
 const fill$1 = fillRange;
-const utils$6 = utils$8;
+const utils$h = utils$j;
 
 const compile$1 = (ast, options = {}) => {
   let walk = (node, parent = {}) => {
-    let invalidBlock = utils$6.isInvalidBrace(parent);
+    let invalidBlock = utils$h.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let invalid = invalidBlock === true || invalidNode === true;
     let prefix = options.escapeInvalid === true ? '\\' : '';
@@ -1018,7 +1328,7 @@ const compile$1 = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils$6.reduce(node.nodes);
+      let args = utils$h.reduce(node.nodes);
       let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
 
       if (range.length !== 0) {
@@ -1041,7 +1351,7 @@ var compile_1 = compile$1;
 
 const fill = fillRange;
 const stringify$2 = stringify$4;
-const utils$5 = utils$8;
+const utils$g = utils$j;
 
 const append = (queue = '', stash = '', enclose = false) => {
   let result = [];
@@ -1051,7 +1361,7 @@ const append = (queue = '', stash = '', enclose = false) => {
 
   if (!stash.length) return queue;
   if (!queue.length) {
-    return enclose ? utils$5.flatten(stash).map(ele => `{${ele}}`) : stash;
+    return enclose ? utils$g.flatten(stash).map(ele => `{${ele}}`) : stash;
   }
 
   for (let item of queue) {
@@ -1066,7 +1376,7 @@ const append = (queue = '', stash = '', enclose = false) => {
       }
     }
   }
-  return utils$5.flatten(result);
+  return utils$g.flatten(result);
 };
 
 const expand$1 = (ast, options = {}) => {
@@ -1094,9 +1404,9 @@ const expand$1 = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils$5.reduce(node.nodes);
+      let args = utils$g.reduce(node.nodes);
 
-      if (utils$5.exceedsLimit(...args, options.step, rangeLimit)) {
+      if (utils$g.exceedsLimit(...args, options.step, rangeLimit)) {
         throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
       }
 
@@ -1110,7 +1420,7 @@ const expand$1 = (ast, options = {}) => {
       return;
     }
 
-    let enclose = utils$5.encloseBrace(node);
+    let enclose = utils$g.encloseBrace(node);
     let queue = node.queue;
     let block = node;
 
@@ -1146,12 +1456,12 @@ const expand$1 = (ast, options = {}) => {
     return queue;
   };
 
-  return utils$5.flatten(walk(ast));
+  return utils$g.flatten(walk(ast));
 };
 
 var expand_1 = expand$1;
 
-var constants$3 = {
+var constants$4 = {
   MAX_LENGTH: 1024 * 64,
 
   // Digits
@@ -1229,7 +1539,7 @@ const {
   CHAR_SINGLE_QUOTE, /* ' */
   CHAR_NO_BREAK_SPACE,
   CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = constants$3;
+} = constants$4;
 
 /**
  * parse
@@ -1705,9 +2015,9 @@ braces$1.create = (input, options = {}) => {
 
 var braces_1 = braces$1;
 
-var utils$4 = {};
+var utils$f = {};
 
-const path$1 = path$2;
+const path$7 = path$a;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -1790,7 +2100,7 @@ const POSIX_REGEX_SOURCE$1 = {
   xdigit: 'A-Fa-f0-9'
 };
 
-var constants$2 = {
+var constants$3 = {
   MAX_LENGTH: 1024 * 64,
   POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
 
@@ -1860,7 +2170,7 @@ var constants$2 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-  SEP: path$1.sep,
+  SEP: path$7.sep,
 
   /**
    * Create EXTGLOB_CHARS
@@ -1887,14 +2197,14 @@ var constants$2 = {
 
 (function (exports) {
 
-const path = path$2;
+const path = path$a;
 const win32 = process.platform === 'win32';
 const {
   REGEX_BACKSLASH,
   REGEX_REMOVE_BACKSLASH,
   REGEX_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_GLOBAL
-} = constants$2;
+} = constants$3;
 
 exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
@@ -1949,9 +2259,9 @@ exports.wrapOutput = (input, state = {}, options = {}) => {
   }
   return output;
 };
-}(utils$4));
+}(utils$f));
 
-const utils$3 = utils$4;
+const utils$e = utils$f;
 const {
   CHAR_ASTERISK,             /* * */
   CHAR_AT,                   /* @ */
@@ -1968,7 +2278,7 @@ const {
   CHAR_RIGHT_CURLY_BRACE,    /* } */
   CHAR_RIGHT_PARENTHESES,    /* ) */
   CHAR_RIGHT_SQUARE_BRACKET  /* ] */
-} = constants$2;
+} = constants$3;
 
 const isPathSeparator = code => {
   return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
@@ -2268,10 +2578,10 @@ const scan$1 = (input, options) => {
   }
 
   if (opts.unescape === true) {
-    if (glob) glob = utils$3.removeBackslashes(glob);
+    if (glob) glob = utils$e.removeBackslashes(glob);
 
     if (base && backslashes === true) {
-      base = utils$3.removeBackslashes(base);
+      base = utils$e.removeBackslashes(base);
     }
   }
 
@@ -2341,8 +2651,8 @@ const scan$1 = (input, options) => {
 
 var scan_1 = scan$1;
 
-const constants$1 = constants$2;
-const utils$2 = utils$4;
+const constants$2 = constants$3;
+const utils$d = utils$f;
 
 /**
  * Constants
@@ -2354,7 +2664,7 @@ const {
   REGEX_NON_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_BACKREF,
   REPLACEMENTS
-} = constants$1;
+} = constants$2;
 
 /**
  * Helpers
@@ -2372,7 +2682,7 @@ const expandRange = (args, options) => {
     /* eslint-disable-next-line no-new */
     new RegExp(value);
   } catch (ex) {
-    return args.map(v => utils$2.escapeRegex(v)).join('..');
+    return args.map(v => utils$d.escapeRegex(v)).join('..');
   }
 
   return value;
@@ -2412,11 +2722,11 @@ const parse$1 = (input, options) => {
   const tokens = [bos];
 
   const capture = opts.capture ? '' : '?:';
-  const win32 = utils$2.isWindows(options);
+  const win32 = utils$d.isWindows(options);
 
   // create constants based on platform, for windows or posix
-  const PLATFORM_CHARS = constants$1.globChars(win32);
-  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
+  const PLATFORM_CHARS = constants$2.globChars(win32);
+  const EXTGLOB_CHARS = constants$2.extglobChars(PLATFORM_CHARS);
 
   const {
     DOT_LITERAL,
@@ -2468,7 +2778,7 @@ const parse$1 = (input, options) => {
     tokens
   };
 
-  input = utils$2.removePrefix(input, state);
+  input = utils$d.removePrefix(input, state);
   len = input.length;
 
   const extglobs = [];
@@ -2654,7 +2964,7 @@ const parse$1 = (input, options) => {
       return state;
     }
 
-    state.output = utils$2.wrapOutput(output, state, options);
+    state.output = utils$d.wrapOutput(output, state, options);
     return state;
   }
 
@@ -2767,7 +3077,7 @@ const parse$1 = (input, options) => {
      */
 
     if (state.quotes === 1 && value !== '"') {
-      value = utils$2.escapeRegex(value);
+      value = utils$d.escapeRegex(value);
       prev.value += value;
       append({ value });
       continue;
@@ -2857,11 +3167,11 @@ const parse$1 = (input, options) => {
 
       // when literal brackets are explicitly disabled
       // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) {
+      if (opts.literalBrackets === false || utils$d.hasRegexChars(prevValue)) {
         continue;
       }
 
-      const escaped = utils$2.escapeRegex(prev.value);
+      const escaped = utils$d.escapeRegex(prev.value);
       state.output = state.output.slice(0, -prev.value.length);
 
       // when literal brackets are explicitly enabled
@@ -3033,7 +3343,7 @@ const parse$1 = (input, options) => {
         const next = peek();
         let output = value;
 
-        if (next === '<' && !utils$2.supportsLookbehinds()) {
+        if (next === '<' && !utils$d.supportsLookbehinds()) {
           throw new Error('Node.js v10 or higher is required for regex lookbehinds');
         }
 
@@ -3293,19 +3603,19 @@ const parse$1 = (input, options) => {
 
   while (state.brackets > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$2.escapeLast(state.output, '[');
+    state.output = utils$d.escapeLast(state.output, '[');
     decrement('brackets');
   }
 
   while (state.parens > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
-    state.output = utils$2.escapeLast(state.output, '(');
+    state.output = utils$d.escapeLast(state.output, '(');
     decrement('parens');
   }
 
   while (state.braces > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
-    state.output = utils$2.escapeLast(state.output, '{');
+    state.output = utils$d.escapeLast(state.output, '{');
     decrement('braces');
   }
 
@@ -3344,7 +3654,7 @@ parse$1.fastpaths = (input, options) => {
   }
 
   input = REPLACEMENTS[input] || input;
-  const win32 = utils$2.isWindows(options);
+  const win32 = utils$d.isWindows(options);
 
   // create constants based on platform, for windows or posix
   const {
@@ -3357,7 +3667,7 @@ parse$1.fastpaths = (input, options) => {
     NO_DOTS_SLASH,
     STAR,
     START_ANCHOR
-  } = constants$1.globChars(win32);
+  } = constants$2.globChars(win32);
 
   const nodot = opts.dot ? NO_DOTS : NO_DOT;
   const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
@@ -3412,7 +3722,7 @@ parse$1.fastpaths = (input, options) => {
     }
   };
 
-  const output = utils$2.removePrefix(input, state);
+  const output = utils$d.removePrefix(input, state);
   let source = create(output);
 
   if (source && opts.strictSlashes !== true) {
@@ -3424,11 +3734,11 @@ parse$1.fastpaths = (input, options) => {
 
 var parse_1 = parse$1;
 
-const path = path$2;
+const path$6 = path$a;
 const scan = scan_1;
 const parse = parse_1;
-const utils$1 = utils$4;
-const constants = constants$2;
+const utils$c = utils$f;
+const constants$1 = constants$3;
 const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
 
 /**
@@ -3473,7 +3783,7 @@ const picomatch$2 = (glob, options, returnState = false) => {
   }
 
   const opts = options || {};
-  const posix = utils$1.isWindows(options);
+  const posix = utils$c.isWindows(options);
   const regex = isState
     ? picomatch$2.compileRe(glob, options)
     : picomatch$2.makeRe(glob, options, false, true);
@@ -3548,7 +3858,7 @@ picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
   }
 
   const opts = options || {};
-  const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
+  const format = opts.format || (posix ? utils$c.toPosixSlashes : null);
   let match = input === glob;
   let output = (match && format) ? format(input) : input;
 
@@ -3582,9 +3892,9 @@ picomatch$2.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch$2.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {
+picomatch$2.matchBase = (input, glob, options, posix = utils$c.isWindows(options)) => {
   const regex = glob instanceof RegExp ? glob : picomatch$2.makeRe(glob, options);
-  return regex.test(path.basename(input));
+  return regex.test(path$6.basename(input));
 };
 
 /**
@@ -3757,7 +4067,7 @@ picomatch$2.toRegex = (source, options) => {
  * @return {Object}
  */
 
-picomatch$2.constants = constants;
+picomatch$2.constants = constants$1;
 
 /**
  * Expose "picomatch"
@@ -3767,10 +4077,10 @@ var picomatch_1 = picomatch$2;
 
 var picomatch$1 = picomatch_1;
 
-const util = require$$0;
+const util = require$$0$1;
 const braces = braces_1;
 const picomatch = picomatch$1;
-const utils = utils$4;
+const utils$b = utils$f;
 const isEmptyString = val => val === '' || val === './';
 
 /**
@@ -3791,7 +4101,7 @@ const isEmptyString = val => val === '' || val === './';
  * @api public
  */
 
-const micromatch = (list, patterns, options) => {
+const micromatch$1 = (list, patterns, options) => {
   patterns = [].concat(patterns);
   list = [].concat(list);
 
@@ -3847,7 +4157,7 @@ const micromatch = (list, patterns, options) => {
  * Backwards compatibility
  */
 
-micromatch.match = micromatch;
+micromatch$1.match = micromatch$1;
 
 /**
  * Returns a matcher function from the given glob `pattern` and `options`.
@@ -3868,7 +4178,7 @@ micromatch.match = micromatch;
  * @api public
  */
 
-micromatch.matcher = (pattern, options) => picomatch(pattern, options);
+micromatch$1.matcher = (pattern, options) => picomatch(pattern, options);
 
 /**
  * Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -3887,13 +4197,13 @@ micromatch.matcher = (pattern, options) => picomatch(pattern, options);
  * @api public
  */
 
-micromatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+micromatch$1.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
 
 /**
  * Backwards compatibility
  */
 
-micromatch.any = micromatch.isMatch;
+micromatch$1.any = micromatch$1.isMatch;
 
 /**
  * Returns a list of strings that _**do not match any**_ of the given `patterns`.
@@ -3912,7 +4222,7 @@ micromatch.any = micromatch.isMatch;
  * @api public
  */
 
-micromatch.not = (list, patterns, options = {}) => {
+micromatch$1.not = (list, patterns, options = {}) => {
   patterns = [].concat(patterns).map(String);
   let result = new Set();
   let items = [];
@@ -3922,7 +4232,7 @@ micromatch.not = (list, patterns, options = {}) => {
     items.push(state.output);
   };
 
-  let matches = micromatch(list, patterns, { ...options, onResult });
+  let matches = micromatch$1(list, patterns, { ...options, onResult });
 
   for (let item of items) {
     if (!matches.includes(item)) {
@@ -3952,13 +4262,13 @@ micromatch.not = (list, patterns, options = {}) => {
  * @api public
  */
 
-micromatch.contains = (str, pattern, options) => {
+micromatch$1.contains = (str, pattern, options) => {
   if (typeof str !== 'string') {
     throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
   }
 
   if (Array.isArray(pattern)) {
-    return pattern.some(p => micromatch.contains(str, p, options));
+    return pattern.some(p => micromatch$1.contains(str, p, options));
   }
 
   if (typeof pattern === 'string') {
@@ -3971,7 +4281,7 @@ micromatch.contains = (str, pattern, options) => {
     }
   }
 
-  return micromatch.isMatch(str, pattern, { ...options, contains: true });
+  return micromatch$1.isMatch(str, pattern, { ...options, contains: true });
 };
 
 /**
@@ -3994,11 +4304,11 @@ micromatch.contains = (str, pattern, options) => {
  * @api public
  */
 
-micromatch.matchKeys = (obj, patterns, options) => {
-  if (!utils.isObject(obj)) {
+micromatch$1.matchKeys = (obj, patterns, options) => {
+  if (!utils$b.isObject(obj)) {
     throw new TypeError('Expected the first argument to be an object');
   }
-  let keys = micromatch(Object.keys(obj), patterns, options);
+  let keys = micromatch$1(Object.keys(obj), patterns, options);
   let res = {};
   for (let key of keys) res[key] = obj[key];
   return res;
@@ -4023,7 +4333,7 @@ micromatch.matchKeys = (obj, patterns, options) => {
  * @api public
  */
 
-micromatch.some = (list, patterns, options) => {
+micromatch$1.some = (list, patterns, options) => {
   let items = [].concat(list);
 
   for (let pattern of [].concat(patterns)) {
@@ -4059,7 +4369,7 @@ micromatch.some = (list, patterns, options) => {
  * @api public
  */
 
-micromatch.every = (list, patterns, options) => {
+micromatch$1.every = (list, patterns, options) => {
   let items = [].concat(list);
 
   for (let pattern of [].concat(patterns)) {
@@ -4098,7 +4408,7 @@ micromatch.every = (list, patterns, options) => {
  * @api public
  */
 
-micromatch.all = (str, patterns, options) => {
+micromatch$1.all = (str, patterns, options) => {
   if (typeof str !== 'string') {
     throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
   }
@@ -4125,10 +4435,10 @@ micromatch.all = (str, patterns, options) => {
  * @api public
  */
 
-micromatch.capture = (glob, input, options) => {
-  let posix = utils.isWindows(options);
+micromatch$1.capture = (glob, input, options) => {
+  let posix = utils$b.isWindows(options);
   let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
-  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
+  let match = regex.exec(posix ? utils$b.toPosixSlashes(input) : input);
 
   if (match) {
     return match.slice(1).map(v => v === void 0 ? '' : v);
@@ -4151,7 +4461,7 @@ micromatch.capture = (glob, input, options) => {
  * @api public
  */
 
-micromatch.makeRe = (...args) => picomatch.makeRe(...args);
+micromatch$1.makeRe = (...args) => picomatch.makeRe(...args);
 
 /**
  * Scan a glob pattern to separate the pattern into segments. Used
@@ -4167,7 +4477,7 @@ micromatch.makeRe = (...args) => picomatch.makeRe(...args);
  * @api public
  */
 
-micromatch.scan = (...args) => picomatch.scan(...args);
+micromatch$1.scan = (...args) => picomatch.scan(...args);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -4183,7 +4493,7 @@ micromatch.scan = (...args) => picomatch.scan(...args);
  * @api public
  */
 
-micromatch.parse = (patterns, options) => {
+micromatch$1.parse = (patterns, options) => {
   let res = [];
   for (let pattern of [].concat(patterns || [])) {
     for (let str of braces(String(pattern), options)) {
@@ -4210,7 +4520,7 @@ micromatch.parse = (patterns, options) => {
  * @api public
  */
 
-micromatch.braces = (pattern, options) => {
+micromatch$1.braces = (pattern, options) => {
   if (typeof pattern !== 'string') throw new TypeError('Expected a string');
   if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
     return [pattern];
@@ -4222,16 +4532,2168 @@ micromatch.braces = (pattern, options) => {
  * Expand braces
  */
 
-micromatch.braceExpand = (pattern, options) => {
+micromatch$1.braceExpand = (pattern, options) => {
   if (typeof pattern !== 'string') throw new TypeError('Expected a string');
-  return micromatch.braces(pattern, { ...options, expand: true });
+  return micromatch$1.braces(pattern, { ...options, expand: true });
 };
 
 /**
  * Expose micromatch
  */
 
-var micromatch_1 = micromatch;
+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_EXPANSIONS_SYMBOLS_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 && BRACE_EXPANSIONS_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    return false;
+}
+pattern$1.isDynamicPattern = isDynamicPattern;
+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 = {};
+
+/*
+ * merge2
+ * https://github.com/teambition/merge2
+ *
+ * Copyright (c) 2014-2020 Teambition
+ * Licensed under the MIT license.
+ */
+const Stream = require$$0$2;
+const PassThrough = Stream.PassThrough;
+const slice = Array.prototype.slice;
+
+var merge2_1 = merge2$1;
+
+function merge2$1 () {
+  const streamsQueue = [];
+  const args = slice.call(arguments);
+  let merging = false;
+  let options = args[args.length - 1];
+
+  if (options && !Array.isArray(options) && options.pipe == null) {
+    args.pop();
+  } else {
+    options = {};
+  }
+
+  const doEnd = options.end !== false;
+  const doPipeError = options.pipeError === true;
+  if (options.objectMode == null) {
+    options.objectMode = true;
+  }
+  if (options.highWaterMark == null) {
+    options.highWaterMark = 64 * 1024;
+  }
+  const mergedStream = PassThrough(options);
+
+  function addStream () {
+    for (let i = 0, len = arguments.length; i < len; i++) {
+      streamsQueue.push(pauseStreams(arguments[i], options));
+    }
+    mergeStream();
+    return this
+  }
+
+  function mergeStream () {
+    if (merging) {
+      return
+    }
+    merging = true;
+
+    let streams = streamsQueue.shift();
+    if (!streams) {
+      process.nextTick(endStream);
+      return
+    }
+    if (!Array.isArray(streams)) {
+      streams = [streams];
+    }
+
+    let pipesCount = streams.length + 1;
+
+    function next () {
+      if (--pipesCount > 0) {
+        return
+      }
+      merging = false;
+      mergeStream();
+    }
+
+    function pipe (stream) {
+      function onend () {
+        stream.removeListener('merge2UnpipeEnd', onend);
+        stream.removeListener('end', onend);
+        if (doPipeError) {
+          stream.removeListener('error', onerror);
+        }
+        next();
+      }
+      function onerror (err) {
+        mergedStream.emit('error', err);
+      }
+      // skip ended stream
+      if (stream._readableState.endEmitted) {
+        return next()
+      }
+
+      stream.on('merge2UnpipeEnd', onend);
+      stream.on('end', onend);
+
+      if (doPipeError) {
+        stream.on('error', onerror);
+      }
+
+      stream.pipe(mergedStream, { end: false });
+      // compatible for old stream
+      stream.resume();
+    }
+
+    for (let i = 0; i < streams.length; i++) {
+      pipe(streams[i]);
+    }
+
+    next();
+  }
+
+  function endStream () {
+    merging = false;
+    // emit 'queueDrain' when all streams merged.
+    mergedStream.emit('queueDrain');
+    if (doEnd) {
+      mergedStream.end();
+    }
+  }
+
+  mergedStream.setMaxListeners(0);
+  mergedStream.add = addStream;
+  mergedStream.on('unpipe', function (stream) {
+    stream.emit('merge2UnpipeEnd');
+  });
+
+  if (args.length) {
+    addStream.apply(null, args);
+  }
+  return mergedStream
+}
+
+// check and pause streams for pipe.
+function pauseStreams (streams, options) {
+  if (!Array.isArray(streams)) {
+    // Backwards-compat with old-style streams
+    if (!streams._readableState && streams.pipe) {
+      streams = streams.pipe(PassThrough(options));
+    }
+    if (!streams._readableState || !streams.pause || !streams.pipe) {
+      throw new Error('Only readable stream can be merged.')
+    }
+    streams.pause();
+  } else {
+    for (let i = 0, len = streams.length; i < len; i++) {
+      streams[i] = pauseStreams(streams[i], 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'));
+}
+
+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 === '';
+}
+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;
+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))
+    };
+}
+tasks.convertPatternGroupToTask = convertPatternGroupToTask;
+
+var async$6 = {};
+
+var stream$2 = {};
+
+var out$3 = {};
+
+var async$5 = {};
+
+Object.defineProperty(async$5, "__esModule", { value: true });
+async$5.read = void 0;
+function read$3(path, settings, callback) {
+    settings.fs.lstat(path, (lstatError, lstat) => {
+        if (lstatError !== null) {
+            return callFailureCallback$2(callback, lstatError);
+        }
+        if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+            return callSuccessCallback$2(callback, lstat);
+        }
+        settings.fs.stat(path, (statError, stat) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    return callFailureCallback$2(callback, statError);
+                }
+                return callSuccessCallback$2(callback, lstat);
+            }
+            if (settings.markSymbolicLink) {
+                stat.isSymbolicLink = () => true;
+            }
+            callSuccessCallback$2(callback, stat);
+        });
+    });
+}
+async$5.read = read$3;
+function callFailureCallback$2(callback, error) {
+    callback(error);
+}
+function callSuccessCallback$2(callback, result) {
+    callback(null, result);
+}
+
+var sync$7 = {};
+
+Object.defineProperty(sync$7, "__esModule", { value: true });
+sync$7.read = void 0;
+function read$2(path, settings) {
+    const lstat = settings.fs.lstatSync(path);
+    if (!lstat.isSymbolicLink() || !settings.followSymbolicLink) {
+        return lstat;
+    }
+    try {
+        const stat = settings.fs.statSync(path);
+        if (settings.markSymbolicLink) {
+            stat.isSymbolicLink = () => true;
+        }
+        return stat;
+    }
+    catch (error) {
+        if (!settings.throwErrorOnBrokenSymbolicLink) {
+            return lstat;
+        }
+        throw error;
+    }
+}
+sync$7.read = read$2;
+
+var settings$3 = {};
+
+var fs$5 = {};
+
+(function (exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+const fs = fs$8;
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;
+}(fs$5));
+
+Object.defineProperty(settings$3, "__esModule", { value: true });
+const fs$4 = fs$5;
+class Settings$2 {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLink = this._getValue(this._options.followSymbolicLink, true);
+        this.fs = fs$4.createFileSystemAdapter(this._options.fs);
+        this.markSymbolicLink = this._getValue(this._options.markSymbolicLink, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+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;
+const sync$6 = sync$7;
+const settings_1$3 = settings$3;
+out$3.Settings = settings_1$3.default;
+function stat(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return async$4.read(path, getSettings$2(), optionsOrSettingsOrCallback);
+    }
+    async$4.read(path, getSettings$2(optionsOrSettingsOrCallback), callback);
+}
+out$3.stat = stat;
+function statSync(path, optionsOrSettings) {
+    const settings = getSettings$2(optionsOrSettings);
+    return sync$6.read(path, settings);
+}
+out$3.statSync = statSync;
+function getSettings$2(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$3.default) {
+        return 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;
+
+var queueMicrotask_1 = typeof queueMicrotask === 'function'
+  ? queueMicrotask.bind(globalThis)
+  // reuse resolved promise, and allocate it lazily
+  : cb => (promise || (promise = Promise.resolve()))
+    .then(cb)
+    .catch(err => setTimeout(() => { throw err }, 0));
+
+/*! run-parallel. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+var runParallel_1 = runParallel;
+
+const queueMicrotask$1 = queueMicrotask_1;
+
+function runParallel (tasks, cb) {
+  let results, pending, keys;
+  let isSync = true;
+
+  if (Array.isArray(tasks)) {
+    results = [];
+    pending = tasks.length;
+  } else {
+    keys = Object.keys(tasks);
+    results = {};
+    pending = keys.length;
+  }
+
+  function done (err) {
+    function end () {
+      if (cb) cb(err, results);
+      cb = null;
+    }
+    if (isSync) queueMicrotask$1(end);
+    else end();
+  }
+
+  function each (i, err, result) {
+    results[i] = result;
+    if (--pending === 0 || err) {
+      done(err);
+    }
+  }
+
+  if (!pending) {
+    // empty
+    done(null);
+  } else if (keys) {
+    // object
+    keys.forEach(function (key) {
+      tasks[key](function (err, result) { each(key, err, result); });
+    });
+  } else {
+    // array
+    tasks.forEach(function (task, i) {
+      task(function (err, result) { each(i, err, result); });
+    });
+  }
+
+  isSync = false;
+}
+
+var constants = {};
+
+Object.defineProperty(constants, "__esModule", { value: true });
+constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = void 0;
+const NODE_PROCESS_VERSION_PARTS = process.versions.node.split('.');
+const MAJOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[0], 10);
+const MINOR_VERSION = parseInt(NODE_PROCESS_VERSION_PARTS[1], 10);
+const SUPPORTED_MAJOR_VERSION = 10;
+const SUPPORTED_MINOR_VERSION = 10;
+const IS_MATCHED_BY_MAJOR = MAJOR_VERSION > SUPPORTED_MAJOR_VERSION;
+const IS_MATCHED_BY_MAJOR_AND_MINOR = MAJOR_VERSION === SUPPORTED_MAJOR_VERSION && MINOR_VERSION >= SUPPORTED_MINOR_VERSION;
+/**
+ * IS `true` for Node.js 10.10 and greater.
+ */
+constants.IS_SUPPORT_READDIR_WITH_FILE_TYPES = IS_MATCHED_BY_MAJOR || IS_MATCHED_BY_MAJOR_AND_MINOR;
+
+var utils$9 = {};
+
+var fs$3 = {};
+
+Object.defineProperty(fs$3, "__esModule", { value: true });
+fs$3.createDirentFromStats = void 0;
+class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}
+fs$3.createDirentFromStats = createDirentFromStats;
+
+Object.defineProperty(utils$9, "__esModule", { value: true });
+utils$9.fs = void 0;
+const fs$2 = fs$3;
+utils$9.fs = fs$2;
+
+var common$6 = {};
+
+Object.defineProperty(common$6, "__esModule", { value: true });
+common$6.joinPathSegments = void 0;
+function joinPathSegments$1(a, b, separator) {
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
+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;
+const rpl = runParallel_1;
+const constants_1$1 = constants;
+const utils$8 = utils$9;
+const common$5 = common$6;
+function read$1(directory, settings, callback) {
+    if (!settings.stats && constants_1$1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes$1(directory, settings, callback);
+    }
+    return readdir$1(directory, settings, callback);
+}
+async$1.read = read$1;
+function readdirWithFileTypes$1(directory, settings, callback) {
+    settings.fs.readdir(directory, { withFileTypes: true }, (readdirError, dirents) => {
+        if (readdirError !== null) {
+            return callFailureCallback$1(callback, readdirError);
+        }
+        const entries = dirents.map((dirent) => ({
+            dirent,
+            name: dirent.name,
+            path: common$5.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        }));
+        if (!settings.followSymbolicLinks) {
+            return callSuccessCallback$1(callback, entries);
+        }
+        const tasks = entries.map((entry) => makeRplTaskEntry(entry, settings));
+        rpl(tasks, (rplError, rplEntries) => {
+            if (rplError !== null) {
+                return callFailureCallback$1(callback, rplError);
+            }
+            callSuccessCallback$1(callback, rplEntries);
+        });
+    });
+}
+async$1.readdirWithFileTypes = readdirWithFileTypes$1;
+function makeRplTaskEntry(entry, settings) {
+    return (done) => {
+        if (!entry.dirent.isSymbolicLink()) {
+            return done(null, entry);
+        }
+        settings.fs.stat(entry.path, (statError, stats) => {
+            if (statError !== null) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    return done(statError);
+                }
+                return done(null, entry);
+            }
+            entry.dirent = utils$8.fs.createDirentFromStats(entry.name, stats);
+            return done(null, entry);
+        });
+    };
+}
+function readdir$1(directory, settings, callback) {
+    settings.fs.readdir(directory, (readdirError, names) => {
+        if (readdirError !== null) {
+            return callFailureCallback$1(callback, readdirError);
+        }
+        const filepaths = names.map((name) => common$5.joinPathSegments(directory, name, settings.pathSegmentSeparator));
+        const tasks = filepaths.map((filepath) => {
+            return (done) => fsStat$5.stat(filepath, settings.fsStatSettings, done);
+        });
+        rpl(tasks, (rplError, results) => {
+            if (rplError !== null) {
+                return callFailureCallback$1(callback, rplError);
+            }
+            const entries = [];
+            names.forEach((name, index) => {
+                const stats = results[index];
+                const entry = {
+                    name,
+                    path: filepaths[index],
+                    dirent: utils$8.fs.createDirentFromStats(name, stats)
+                };
+                if (settings.stats) {
+                    entry.stats = stats;
+                }
+                entries.push(entry);
+            });
+            callSuccessCallback$1(callback, entries);
+        });
+    });
+}
+async$1.readdir = readdir$1;
+function callFailureCallback$1(callback, error) {
+    callback(error);
+}
+function callSuccessCallback$1(callback, result) {
+    callback(null, result);
+}
+
+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 constants_1 = constants;
+const utils$7 = utils$9;
+const common$4 = common$6;
+function read(directory, settings) {
+    if (!settings.stats && constants_1.IS_SUPPORT_READDIR_WITH_FILE_TYPES) {
+        return readdirWithFileTypes(directory, settings);
+    }
+    return readdir(directory, settings);
+}
+sync$5.read = read;
+function readdirWithFileTypes(directory, settings) {
+    const dirents = settings.fs.readdirSync(directory, { withFileTypes: true });
+    return dirents.map((dirent) => {
+        const entry = {
+            dirent,
+            name: dirent.name,
+            path: common$4.joinPathSegments(directory, dirent.name, settings.pathSegmentSeparator)
+        };
+        if (entry.dirent.isSymbolicLink() && settings.followSymbolicLinks) {
+            try {
+                const stats = settings.fs.statSync(entry.path);
+                entry.dirent = utils$7.fs.createDirentFromStats(entry.name, stats);
+            }
+            catch (error) {
+                if (settings.throwErrorOnBrokenSymbolicLink) {
+                    throw error;
+                }
+            }
+        }
+        return entry;
+    });
+}
+sync$5.readdirWithFileTypes = readdirWithFileTypes;
+function readdir(directory, settings) {
+    const names = settings.fs.readdirSync(directory);
+    return names.map((name) => {
+        const entryPath = common$4.joinPathSegments(directory, name, settings.pathSegmentSeparator);
+        const stats = fsStat$4.statSync(entryPath, settings.fsStatSettings);
+        const entry = {
+            name,
+            path: entryPath,
+            dirent: utils$7.fs.createDirentFromStats(name, stats)
+        };
+        if (settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    });
+}
+sync$5.readdir = readdir;
+
+var settings$2 = {};
+
+var fs$1 = {};
+
+(function (exports) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFileSystemAdapter = exports.FILE_SYSTEM_ADAPTER = void 0;
+const fs = fs$8;
+exports.FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    stat: fs.stat,
+    lstatSync: fs.lstatSync,
+    statSync: fs.statSync,
+    readdir: fs.readdir,
+    readdirSync: fs.readdirSync
+};
+function createFileSystemAdapter(fsMethods) {
+    if (fsMethods === undefined) {
+        return exports.FILE_SYSTEM_ADAPTER;
+    }
+    return Object.assign(Object.assign({}, exports.FILE_SYSTEM_ADAPTER), fsMethods);
+}
+exports.createFileSystemAdapter = createFileSystemAdapter;
+}(fs$1));
+
+Object.defineProperty(settings$2, "__esModule", { value: true });
+const path$3 = path$a;
+const fsStat$3 = out$3;
+const fs = fs$1;
+class Settings$1 {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, false);
+        this.fs = fs.createFileSystemAdapter(this._options.fs);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$3.sep);
+        this.stats = this._getValue(this._options.stats, false);
+        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, true);
+        this.fsStatSettings = new fsStat$3.Settings({
+            followSymbolicLink: this.followSymbolicLinks,
+            fs: this.fs,
+            throwErrorOnBrokenSymbolicLink: this.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+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;
+const sync$4 = sync$5;
+const settings_1$2 = settings$2;
+out$1.Settings = settings_1$2.default;
+function scandir(path, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return async.read(path, getSettings$1(), optionsOrSettingsOrCallback);
+    }
+    async.read(path, getSettings$1(optionsOrSettingsOrCallback), callback);
+}
+out$1.scandir = scandir;
+function scandirSync(path, optionsOrSettings) {
+    const settings = getSettings$1(optionsOrSettings);
+    return sync$4.read(path, settings);
+}
+out$1.scandirSync = scandirSync;
+function getSettings$1(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$2.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$2.default(settingsOrOptions);
+}
+
+function reusify$1 (Constructor) {
+  var head = new Constructor();
+  var tail = head;
+
+  function get () {
+    var current = head;
+
+    if (current.next) {
+      head = current.next;
+    } else {
+      head = new Constructor();
+      tail = head;
+    }
+
+    current.next = null;
+
+    return current
+  }
+
+  function release (obj) {
+    tail.next = obj;
+    tail = obj;
+  }
+
+  return {
+    get: get,
+    release: release
+  }
+}
+
+var reusify_1 = reusify$1;
+
+var reusify = reusify_1;
+
+function fastqueue (context, worker, concurrency) {
+  if (typeof context === 'function') {
+    concurrency = worker;
+    worker = context;
+    context = null;
+  }
+
+  if (concurrency < 1) {
+    throw new Error('fastqueue concurrency must be greater than 1')
+  }
+
+  var cache = reusify(Task);
+  var queueHead = null;
+  var queueTail = null;
+  var _running = 0;
+  var errorHandler = null;
+
+  var self = {
+    push: push,
+    drain: noop,
+    saturated: noop,
+    pause: pause,
+    paused: false,
+    concurrency: concurrency,
+    running: running,
+    resume: resume,
+    idle: idle,
+    length: length,
+    getQueue: getQueue,
+    unshift: unshift,
+    empty: noop,
+    kill: kill,
+    killAndDrain: killAndDrain,
+    error: error
+  };
+
+  return self
+
+  function running () {
+    return _running
+  }
+
+  function pause () {
+    self.paused = true;
+  }
+
+  function length () {
+    var current = queueHead;
+    var counter = 0;
+
+    while (current) {
+      current = current.next;
+      counter++;
+    }
+
+    return counter
+  }
+
+  function getQueue () {
+    var current = queueHead;
+    var tasks = [];
+
+    while (current) {
+      tasks.push(current.value);
+      current = current.next;
+    }
+
+    return tasks
+  }
+
+  function resume () {
+    if (!self.paused) return
+    self.paused = false;
+    for (var i = 0; i < self.concurrency; i++) {
+      _running++;
+      release();
+    }
+  }
+
+  function idle () {
+    return _running === 0 && self.length() === 0
+  }
+
+  function push (value, done) {
+    var current = cache.get();
+
+    current.context = context;
+    current.release = release;
+    current.value = value;
+    current.callback = done || noop;
+    current.errorHandler = errorHandler;
+
+    if (_running === self.concurrency || self.paused) {
+      if (queueTail) {
+        queueTail.next = current;
+        queueTail = current;
+      } else {
+        queueHead = current;
+        queueTail = current;
+        self.saturated();
+      }
+    } else {
+      _running++;
+      worker.call(context, current.value, current.worked);
+    }
+  }
+
+  function unshift (value, done) {
+    var current = cache.get();
+
+    current.context = context;
+    current.release = release;
+    current.value = value;
+    current.callback = done || noop;
+
+    if (_running === self.concurrency || self.paused) {
+      if (queueHead) {
+        current.next = queueHead;
+        queueHead = current;
+      } else {
+        queueHead = current;
+        queueTail = current;
+        self.saturated();
+      }
+    } else {
+      _running++;
+      worker.call(context, current.value, current.worked);
+    }
+  }
+
+  function release (holder) {
+    if (holder) {
+      cache.release(holder);
+    }
+    var next = queueHead;
+    if (next) {
+      if (!self.paused) {
+        if (queueTail === queueHead) {
+          queueTail = null;
+        }
+        queueHead = next.next;
+        next.next = null;
+        worker.call(context, next.value, next.worked);
+        if (queueTail === null) {
+          self.empty();
+        }
+      } else {
+        _running--;
+      }
+    } else if (--_running === 0) {
+      self.drain();
+    }
+  }
+
+  function kill () {
+    queueHead = null;
+    queueTail = null;
+    self.drain = noop;
+  }
+
+  function killAndDrain () {
+    queueHead = null;
+    queueTail = null;
+    self.drain();
+    self.drain = noop;
+  }
+
+  function error (handler) {
+    errorHandler = handler;
+  }
+}
+
+function noop () {}
+
+function Task () {
+  this.value = null;
+  this.callback = noop;
+  this.next = null;
+  this.release = noop;
+  this.context = null;
+  this.errorHandler = null;
+
+  var self = this;
+
+  this.worked = function worked (err, result) {
+    var callback = self.callback;
+    var errorHandler = self.errorHandler;
+    var val = self.value;
+    self.value = null;
+    self.callback = noop;
+    if (self.errorHandler) {
+      errorHandler(err, val);
+    }
+    callback.call(self.context, err, result);
+    self.release(self);
+  };
+}
+
+var queue = fastqueue;
+
+var common$3 = {};
+
+Object.defineProperty(common$3, "__esModule", { value: true });
+common$3.joinPathSegments = common$3.replacePathSegmentSeparator = common$3.isAppliedFilter = common$3.isFatalError = void 0;
+function isFatalError(settings, error) {
+    if (settings.errorFilter === null) {
+        return true;
+    }
+    return !settings.errorFilter(error);
+}
+common$3.isFatalError = isFatalError;
+function isAppliedFilter(filter, value) {
+    return filter === null || filter(value);
+}
+common$3.isAppliedFilter = isAppliedFilter;
+function replacePathSegmentSeparator(filepath, separator) {
+    return filepath.split(/[/\\]/).join(separator);
+}
+common$3.replacePathSegmentSeparator = replacePathSegmentSeparator;
+function joinPathSegments(a, b, separator) {
+    if (a === '') {
+        return b;
+    }
+    /**
+     * The correct handling of cases when the first segment is a root (`/`, `C:/`) or UNC path (`//?/C:/`).
+     */
+    if (a.endsWith(separator)) {
+        return a + b;
+    }
+    return a + separator + b;
+}
+common$3.joinPathSegments = joinPathSegments;
+
+var reader$1 = {};
+
+Object.defineProperty(reader$1, "__esModule", { value: true });
+const common$2 = common$3;
+class Reader$1 {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._root = common$2.replacePathSegmentSeparator(_root, _settings.pathSegmentSeparator);
+    }
+}
+reader$1.default = Reader$1;
+
+Object.defineProperty(async$2, "__esModule", { value: true });
+const events_1 = require$$2;
+const fsScandir$2 = out$1;
+const fastq = queue;
+const common$1 = common$3;
+const reader_1$3 = reader$1;
+class AsyncReader extends reader_1$3.default {
+    constructor(_root, _settings) {
+        super(_root, _settings);
+        this._settings = _settings;
+        this._scandir = fsScandir$2.scandir;
+        this._emitter = new events_1.EventEmitter();
+        this._queue = fastq(this._worker.bind(this), this._settings.concurrency);
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        this._queue.drain = () => {
+            if (!this._isFatalError) {
+                this._emitter.emit('end');
+            }
+        };
+    }
+    read() {
+        this._isFatalError = false;
+        this._isDestroyed = false;
+        setImmediate(() => {
+            this._pushToQueue(this._root, this._settings.basePath);
+        });
+        return this._emitter;
+    }
+    get isDestroyed() {
+        return this._isDestroyed;
+    }
+    destroy() {
+        if (this._isDestroyed) {
+            throw new Error('The reader is already destroyed');
+        }
+        this._isDestroyed = true;
+        this._queue.killAndDrain();
+    }
+    onEntry(callback) {
+        this._emitter.on('entry', callback);
+    }
+    onError(callback) {
+        this._emitter.once('error', callback);
+    }
+    onEnd(callback) {
+        this._emitter.once('end', callback);
+    }
+    _pushToQueue(directory, base) {
+        const queueItem = { directory, base };
+        this._queue.push(queueItem, (error) => {
+            if (error !== null) {
+                this._handleError(error);
+            }
+        });
+    }
+    _worker(item, done) {
+        this._scandir(item.directory, this._settings.fsScandirSettings, (error, entries) => {
+            if (error !== null) {
+                return done(error, undefined);
+            }
+            for (const entry of entries) {
+                this._handleEntry(entry, item.base);
+            }
+            done(null, undefined);
+        });
+    }
+    _handleError(error) {
+        if (this._isDestroyed || !common$1.isFatalError(this._settings, error)) {
+            return;
+        }
+        this._isFatalError = true;
+        this._isDestroyed = true;
+        this._emitter.emit('error', error);
+    }
+    _handleEntry(entry, base) {
+        if (this._isDestroyed || this._isFatalError) {
+            return;
+        }
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common$1.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common$1.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._emitEntry(entry);
+        }
+        if (entry.dirent.isDirectory() && common$1.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, entry.path);
+        }
+    }
+    _emitEntry(entry) {
+        this._emitter.emit('entry', entry);
+    }
+}
+async$2.default = AsyncReader;
+
+Object.defineProperty(async$3, "__esModule", { value: true });
+const async_1$3 = async$2;
+class AsyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1$3.default(this._root, this._settings);
+        this._storage = new Set();
+    }
+    read(callback) {
+        this._reader.onError((error) => {
+            callFailureCallback(callback, error);
+        });
+        this._reader.onEntry((entry) => {
+            this._storage.add(entry);
+        });
+        this._reader.onEnd(() => {
+            callSuccessCallback(callback, [...this._storage]);
+        });
+        this._reader.read();
+    }
+}
+async$3.default = AsyncProvider;
+function callFailureCallback(callback, error) {
+    callback(error);
+}
+function callSuccessCallback(callback, entries) {
+    callback(null, entries);
+}
+
+var stream$1 = {};
+
+Object.defineProperty(stream$1, "__esModule", { value: true });
+const stream_1$5 = require$$0$2;
+const async_1$2 = async$2;
+class StreamProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new async_1$2.default(this._root, this._settings);
+        this._stream = new stream_1$5.Readable({
+            objectMode: true,
+            read: () => { },
+            destroy: () => {
+                if (!this._reader.isDestroyed) {
+                    this._reader.destroy();
+                }
+            }
+        });
+    }
+    read() {
+        this._reader.onError((error) => {
+            this._stream.emit('error', error);
+        });
+        this._reader.onEntry((entry) => {
+            this._stream.push(entry);
+        });
+        this._reader.onEnd(() => {
+            this._stream.push(null);
+        });
+        this._reader.read();
+        return this._stream;
+    }
+}
+stream$1.default = StreamProvider;
+
+var sync$3 = {};
+
+var sync$2 = {};
+
+Object.defineProperty(sync$2, "__esModule", { value: true });
+const fsScandir$1 = out$1;
+const common = common$3;
+const reader_1$2 = reader$1;
+class SyncReader extends reader_1$2.default {
+    constructor() {
+        super(...arguments);
+        this._scandir = fsScandir$1.scandirSync;
+        this._storage = new Set();
+        this._queue = new Set();
+    }
+    read() {
+        this._pushToQueue(this._root, this._settings.basePath);
+        this._handleQueue();
+        return [...this._storage];
+    }
+    _pushToQueue(directory, base) {
+        this._queue.add({ directory, base });
+    }
+    _handleQueue() {
+        for (const item of this._queue.values()) {
+            this._handleDirectory(item.directory, item.base);
+        }
+    }
+    _handleDirectory(directory, base) {
+        try {
+            const entries = this._scandir(directory, this._settings.fsScandirSettings);
+            for (const entry of entries) {
+                this._handleEntry(entry, base);
+            }
+        }
+        catch (error) {
+            this._handleError(error);
+        }
+    }
+    _handleError(error) {
+        if (!common.isFatalError(this._settings, error)) {
+            return;
+        }
+        throw error;
+    }
+    _handleEntry(entry, base) {
+        const fullpath = entry.path;
+        if (base !== undefined) {
+            entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
+        }
+        if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
+            this._pushToStorage(entry);
+        }
+        if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
+            this._pushToQueue(fullpath, entry.path);
+        }
+    }
+    _pushToStorage(entry) {
+        this._storage.add(entry);
+    }
+}
+sync$2.default = SyncReader;
+
+Object.defineProperty(sync$3, "__esModule", { value: true });
+const sync_1$3 = sync$2;
+class SyncProvider {
+    constructor(_root, _settings) {
+        this._root = _root;
+        this._settings = _settings;
+        this._reader = new sync_1$3.default(this._root, this._settings);
+    }
+    read() {
+        return this._reader.read();
+    }
+}
+sync$3.default = SyncProvider;
+
+var settings$1 = {};
+
+Object.defineProperty(settings$1, "__esModule", { value: true });
+const path$2 = path$a;
+const fsScandir = out$1;
+class Settings {
+    constructor(_options = {}) {
+        this._options = _options;
+        this.basePath = this._getValue(this._options.basePath, undefined);
+        this.concurrency = this._getValue(this._options.concurrency, Infinity);
+        this.deepFilter = this._getValue(this._options.deepFilter, null);
+        this.entryFilter = this._getValue(this._options.entryFilter, null);
+        this.errorFilter = this._getValue(this._options.errorFilter, null);
+        this.pathSegmentSeparator = this._getValue(this._options.pathSegmentSeparator, path$2.sep);
+        this.fsScandirSettings = new fsScandir.Settings({
+            followSymbolicLinks: this._options.followSymbolicLinks,
+            fs: this._options.fs,
+            pathSegmentSeparator: this._options.pathSegmentSeparator,
+            stats: this._options.stats,
+            throwErrorOnBrokenSymbolicLink: this._options.throwErrorOnBrokenSymbolicLink
+        });
+    }
+    _getValue(option, value) {
+        return option !== null && option !== void 0 ? option : value;
+    }
+}
+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;
+const sync_1$2 = sync$3;
+const settings_1$1 = settings$1;
+out$2.Settings = settings_1$1.default;
+function walk(directory, optionsOrSettingsOrCallback, callback) {
+    if (typeof optionsOrSettingsOrCallback === 'function') {
+        return new async_1$1.default(directory, getSettings()).read(optionsOrSettingsOrCallback);
+    }
+    new async_1$1.default(directory, getSettings(optionsOrSettingsOrCallback)).read(callback);
+}
+out$2.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;
+function walkStream(directory, optionsOrSettings) {
+    const settings = getSettings(optionsOrSettings);
+    const provider = new stream_1$4.default(directory, settings);
+    return provider.read();
+}
+out$2.walkStream = walkStream;
+function getSettings(settingsOrOptions = {}) {
+    if (settingsOrOptions instanceof settings_1$1.default) {
+        return settingsOrOptions;
+    }
+    return new settings_1$1.default(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;
+    }
+}
+reader.default = Reader;
+
+Object.defineProperty(stream$2, "__esModule", { value: true });
+const stream_1$3 = require$$0$2;
+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 provider = {};
+
+var deep = {};
+
+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));
+    }
+}
+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;
+    }
+}
+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);
+    }
+}
+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);
+    }
+    _isMatchToPatterns(entryPath, patternsRe) {
+        const filepath = utils$3.path.removeLeadingDotSegment(entryPath);
+        return utils$3.pattern.matchAny(filepath, patternsRe);
+    }
+}
+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;
+    }
+}
+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 });
+    }
+}
+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
+        };
+    }
+}
+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;
+
+var stream = {};
+
+Object.defineProperty(stream, "__esModule", { value: true });
+const stream_1$1 = require$$0$2;
+const stream_2 = stream$2;
+const provider_1$1 = provider;
+class ProviderStream extends provider_1$1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new stream_2.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const source = this.api(root, task, options);
+        const destination = new stream_1$1.Readable({ objectMode: true, read: () => { } });
+        source
+            .once('error', (error) => destination.emit('error', error))
+            .on('data', (entry) => destination.emit('data', options.transform(entry)))
+            .once('end', () => destination.emit('end'));
+        destination
+            .once('close', () => source.destroy());
+        return destination;
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+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);
+    }
+}
+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);
+    }
+}
+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);
+    }
+}
+exports.default = Settings;
+}(settings));
+
+const taskManager = tasks;
+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 = [].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 = [].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;
 
 class SnapshotManager {
   constructor(config) {
@@ -4805,7 +7267,7 @@ function formatTestPath(root, path) {
   const dir = dirname(path);
   const ext = ((_a = path.match(/(\.(spec|test)\.[cm]?[tj]sx?)$/)) == null ? void 0 : _a[0]) || "";
   const base = basename(path, ext);
-  return slash(c.dim(`${dir}/`) + c.bold(base)) + c.dim(ext);
+  return slash$1(c.dim(`${dir}/`) + c.bold(base)) + c.dim(ext);
 }
 function renderSnapshotSummary(rootDir, snapshots) {
   const summary = [];
@@ -4968,7 +7430,6 @@ class ConsoleReporter {
     this.ctx = ctx;
     this.start = 0;
     this.end = 0;
-    this.console = globalThis.console;
     this.isFirstWatchRun = true;
     const mode = ctx.config.watch ? c.yellow(" DEV ") : c.cyan(" RUN ");
     this.log(`
@@ -4979,12 +7440,12 @@ ${c.inverse(c.bold(mode))} ${c.gray(this.ctx.config.root)}
   log(...args) {
     if (this.ctx.config.silent)
       return;
-    this.console.log(...args);
+    this.ctx.console.log(...args);
   }
   error(...args) {
     if (this.ctx.config.silent)
       return;
-    this.console.error(...args);
+    this.ctx.console.error(...args);
   }
   relative(path) {
     return relative(this.ctx.config.root, path);
@@ -5092,9 +7553,11 @@ ${c.bold(c.inverse(c.green(" PASS ")))}${c.green(" Waiting for file changes...")
   async onWatcherRerun(files, trigger) {
     await this.stopListRender();
     this.watchFilters = files;
-    this.console.clear();
-    this.log(c.blue("Re-running tests...") + c.dim(` [ ${this.relative(trigger)} ]
+    if (!this.ctx.config.silent) {
+      this.ctx.console.clear();
+      this.log(c.blue("Re-running tests...") + c.dim(` [ ${this.relative(trigger)} ]
 `));
+    }
   }
   async stopListRender() {
     var _a;
@@ -5183,6 +7646,9 @@ function resolveConfig(options, viteConfig) {
   resolved.interpretDefault = resolved.interpretDefault ?? true;
   resolved.include = resolved.include ?? defaultInclude;
   resolved.exclude = resolved.exclude ?? defaultExclude;
+  resolved.testTimeout = resolved.testTimeout ?? 5e3;
+  resolved.hookTimeout = resolved.hookTimeout ?? 1e4;
+  resolved.watchIgnore = resolved.watchIgnore ?? [/\/node_modules\//, /\/dist\//];
   const CI = !!process.env.CI;
   const UPDATE_SNAPSHOT = resolved.update || process.env.UPDATE_SNAPSHOT;
   resolved.snapshotOptions = {
@@ -5230,7 +7696,7 @@ function createPool(ctx) {
   else
     return createFakePool(ctx);
 }
-const workerPath = new URL("./dist/worker.js", pathToFileURL(distDir)).href;
+const workerPath = pathToFileURL(resolve(distDir, "./worker.js")).href;
 function createFakePool(ctx) {
   const runWithFiles = (name) => {
     return async (files, invalidates) => {
@@ -5345,7 +7811,7 @@ class Vitest {
     this.isFirstRun = true;
     this.restartsCount = 0;
     this._onRestartListeners = [];
-    this.unregisterWatcher = noop;
+    this.unregisterWatcher = noop$1;
     this.console = globalThis.console;
   }
   setServer(options, server) {
@@ -5361,7 +7827,7 @@ class Vitest {
     this.state = new StateManager();
     this.snapshot = new SnapshotManager(resolved);
     this.reporters = toArray(resolved.reporters);
-    if (!this.reporters.length)
+    if (!this.reporters.length && !this.config.silent)
       this.reporters.push(new ConsoleReporter(this));
     if (this.config.watch)
       this.registerWatcher();
@@ -5409,7 +7875,9 @@ class Vitest {
       if (this.restartsCount !== currentCount)
         return;
       this.isFirstRun = false;
+      this.snapshot.clear();
       const files = Array.from(this.changedTests);
+      this.changedTests.clear();
       await this.report("onWatcherRerun", files, triggerId);
       await this.runFiles(files);
       await this.report("onWatcherStart");
@@ -5417,13 +7885,13 @@ class Vitest {
   }
   registerWatcher() {
     const onChange = (id) => {
-      id = slash(id);
+      id = slash$1(id);
       this.handleFileChanged(id);
       if (this.changedTests.size)
         this.scheduleRerun(id);
     };
     const onUnlink = (id) => {
-      id = slash(id);
+      id = slash$1(id);
       this.invalidates.add(id);
       if (id in this.state.filesMap) {
         delete this.state.filesMap[id];
@@ -5431,7 +7899,7 @@ class Vitest {
       }
     };
     const onAdd = (id) => {
-      id = slash(id);
+      id = slash$1(id);
       if (this.isTargetFile(id)) {
         this.changedTests.add(id);
         this.scheduleRerun(id);
@@ -5445,24 +7913,24 @@ class Vitest {
       watcher.off("change", onChange);
       watcher.off("unlink", onUnlink);
       watcher.off("add", onAdd);
-      this.unregisterWatcher = noop;
+      this.unregisterWatcher = noop$1;
     };
   }
   handleFileChanged(id) {
-    if (this.changedTests.has(id) || this.invalidates.has(id) || id.includes("/node_modules/") || id.includes("/vitest/dist/"))
+    if (this.changedTests.has(id) || this.invalidates.has(id) || this.config.watchIgnore.some((i) => id.match(i)))
+      return;
+    const mod = this.server.moduleGraph.getModuleById(id);
+    if (!mod)
       return;
     this.invalidates.add(id);
     if (id in this.state.filesMap) {
       this.changedTests.add(id);
       return;
     }
-    const mod = this.server.moduleGraph.getModuleById(id);
-    if (mod) {
-      mod.importers.forEach((i) => {
-        if (i.id)
-          this.handleFileChanged(i.id);
-      });
-    }
+    mod.importers.forEach((i) => {
+      if (i.id)
+        this.handleFileChanged(i.id);
+    });
   }
   async close() {
     var _a;
@@ -5476,7 +7944,7 @@ class Vitest {
     }));
   }
   async globTestFiles(filters) {
-    let files = await fg(this.config.include, {
+    let files = await out(this.config.include, {
       absolute: true,
       cwd: this.config.root,
       ignore: this.config.exclude
@@ -5513,7 +7981,7 @@ async function createVitest(options, viteOverrides = {}) {
           ctx.setServer(options, server2);
           haveStarted = true;
           if (options.api)
-            server2.middlewares.use((await import('./middleware-bf0f818d.js')).default(ctx));
+            server2.middlewares.use((await import('./middleware-991dfa87.js')).default(ctx));
         }
       }
     ],