npm - rollup - Versions diffs - 2.38.4 → 2.40.0 - Mend

rollup 2.38.4 → 2.40.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/CHANGELOG.md +54 -0
package/LICENSE.md +1 -1
package/dist/bin/rollup +18 -16
package/dist/es/rollup.browser.js +3 -3
package/dist/es/rollup.js +2 -2
package/dist/es/shared/rollup.js +437 -373
package/dist/es/shared/watch.js +480 -426
package/dist/loadConfigFile.js +2 -2
package/dist/rollup.browser.js +3 -3
package/dist/rollup.d.ts +2 -0
package/dist/rollup.js +2 -2
package/dist/shared/index.js +446 -397
package/dist/shared/loadConfigFile.js +8 -8
package/dist/shared/mergeOptions.js +4 -3
package/dist/shared/rollup.js +497 -434
package/dist/shared/watch-cli.js +34 -26
package/dist/shared/watch.js +29 -25
package/package.json +22 -18

package/dist/es/shared/watch.js CHANGED Viewed

@@ -1,23 +1,25 @@
 /*
   @license
-	Rollup.js v2.38.4
-	Tue, 02 Feb 2021 05:54:38 GMT - commit 991bb98fad1f3f76226bfe6243fd6cc45a19a39b
+	Rollup.js v2.40.0
+	Fri, 26 Feb 2021 14:39:44 GMT - commit 0a0958ff926554abe9916178f56762ba71301ddd
 	https://github.com/rollup/rollup
 	Released under the MIT License.
 */
-import sysPath, { sep, resolve } from 'path';
-import util from 'util';
-import { createCommonjsModule, defaultOnWarn, ensureArray as ensureArray$1, warnUnknownOptions, getAugmentedNamespace, fseventsImporter, rollupInternal } from './rollup.js';
-import require$$0$2 from 'events';
-import fs from 'fs';
-import require$$0$1 from 'stream';
-import require$$1$1, { platform } from 'os';
+import require$$0$2, { sep, resolve } from 'path';
+import require$$0$1 from 'util';
+import { defaultOnWarn, ensureArray as ensureArray$1, warnUnknownOptions, getAugmentedNamespace, fseventsImporter, rollupInternal } from './rollup.js';
+import require$$0$3 from 'events';
+import fs$4 from 'fs';
+import require$$1 from 'stream';
+import require$$2, { platform } from 'os';
 import 'crypto';
-var utils = createCommonjsModule(function (module, exports) {
+var utils$8 = {};
+(function (exports) {
 exports.isInteger = num => {
   if (typeof num === 'number') {
@@ -129,16 +131,18 @@ exports.flatten = (...args) => {
   flat(args);
   return result;
 };
-});
+}(utils$8));
+const utils$7 = utils$8;
-var stringify = (ast, options = {}) => {
+var stringify$4 = (ast, options = {}) => {
   let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+    let invalidBlock = options.escapeInvalid && utils$7.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let output = '';
     if (node.value) {
-      if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+      if ((invalidBlock || invalidNode) && utils$7.isOpenOrClose(node)) {
         return '\\' + node.value;
       }
       return node.value;
@@ -166,7 +170,7 @@ var stringify = (ast, options = {}) => {
  * Released under the MIT License.
  */
-var isNumber = function(num) {
+var isNumber$2 = function(num) {
   if (typeof num === 'number') {
     return num - num === 0;
   }
@@ -183,10 +187,10 @@ var isNumber = function(num) {
  * Released under the MIT License.
  */
+const isNumber$1 = isNumber$2;
-const toRegexRange = (min, max, options) => {
-  if (isNumber(min) === false) {
+const toRegexRange$1 = (min, max, options) => {
+  if (isNumber$1(min) === false) {
     throw new TypeError('toRegexRange: expected the first argument to be a number');
   }
@@ -194,7 +198,7 @@ const toRegexRange = (min, max, options) => {
     return String(min);
   }
-  if (isNumber(max) === false) {
+  if (isNumber$1(max) === false) {
     throw new TypeError('toRegexRange: expected the second argument to be a number.');
   }
@@ -209,8 +213,8 @@ const toRegexRange = (min, max, options) => {
   let wrap = String(opts.wrap);
   let cacheKey = min + ':' + max + '=' + relax + shorthand + capture + wrap;
-  if (toRegexRange.cache.hasOwnProperty(cacheKey)) {
-    return toRegexRange.cache[cacheKey].result;
+  if (toRegexRange$1.cache.hasOwnProperty(cacheKey)) {
+    return toRegexRange$1.cache[cacheKey].result;
   }
   let a = Math.min(min, max);
@@ -257,7 +261,7 @@ const toRegexRange = (min, max, options) => {
     state.result = `(?:${state.result})`;
   }
-  toRegexRange.cache[cacheKey] = state;
+  toRegexRange$1.cache[cacheKey] = state;
   return state.result;
 };
@@ -454,14 +458,14 @@ function padZeros(value, tok, options) {
  * Cache
  */
-toRegexRange.cache = {};
-toRegexRange.clearCache = () => (toRegexRange.cache = {});
+toRegexRange$1.cache = {};
+toRegexRange$1.clearCache = () => (toRegexRange$1.cache = {});
 /**
  * Expose `toRegexRange`
  */
-var toRegexRange_1 = toRegexRange;
+var toRegexRange_1 = toRegexRange$1;
 /*!
  * fill-range <https://github.com/jonschlinkert/fill-range>
@@ -470,10 +474,10 @@ var toRegexRange_1 = toRegexRange;
  * Licensed under the MIT License.
  */
+const util$1 = require$$0$1;
+const toRegexRange = toRegexRange_1;
-const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+const isObject$1 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 const transform = toNumber => {
   return value => toNumber === true ? Number(value) : String(value);
@@ -483,7 +487,7 @@ const isValidValue = value => {
   return typeof value === 'number' || (typeof value === 'string' && value !== '');
 };
-const isNumber$1 = num => Number.isInteger(+num);
+const isNumber = num => Number.isInteger(+num);
 const zeros = input => {
   let value = `${input}`;
@@ -494,7 +498,7 @@ const zeros = input => {
   return index > 0;
 };
-const stringify$1 = (start, end, options) => {
+const stringify$3 = (start, end, options) => {
   if (typeof start === 'string' || typeof end === 'string') {
     return true;
   }
@@ -555,7 +559,7 @@ const toSequence = (parts, options) => {
 const toRange = (a, b, isNumbers, options) => {
   if (isNumbers) {
-    return toRegexRange_1(a, b, { wrap: false, ...options });
+    return toRegexRange(a, b, { wrap: false, ...options });
   }
   let start = String.fromCharCode(a);
@@ -571,11 +575,11 @@ const toRegex = (start, end, options) => {
     let prefix = options.capture ? '' : '?:';
     return wrap ? `(${prefix}${start.join('|')})` : start.join('|');
   }
-  return toRegexRange_1(start, end, options);
+  return toRegexRange(start, end, options);
 };
 const rangeError = (...args) => {
-  return new RangeError('Invalid range arguments: ' + util.inspect(...args));
+  return new RangeError('Invalid range arguments: ' + util$1.inspect(...args));
 };
 const invalidRange = (start, end, options) => {
@@ -611,7 +615,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
   let padded = zeros(startString) || zeros(endString) || zeros(stepString);
   let maxLen = padded ? Math.max(startString.length, endString.length, stepString.length) : 0;
-  let toNumber = padded === false && stringify$1(start, end, options) === false;
+  let toNumber = padded === false && stringify$3(start, end, options) === false;
   let format = options.transform || transform(toNumber);
   if (options.toRegex && step === 1) {
@@ -643,7 +647,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
 };
 const fillLetters = (start, end, step = 1, options = {}) => {
-  if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
+  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
     return invalidRange(start, end, options);
   }
@@ -676,7 +680,7 @@ const fillLetters = (start, end, step = 1, options = {}) => {
   return range;
 };
-const fill = (start, end, step, options = {}) => {
+const fill$2 = (start, end, step, options = {}) => {
   if (end == null && isValidValue(start)) {
     return [start];
   }
@@ -686,34 +690,37 @@ const fill = (start, end, step, options = {}) => {
   }
   if (typeof step === 'function') {
-    return fill(start, end, 1, { transform: step });
+    return fill$2(start, end, 1, { transform: step });
   }
-  if (isObject(step)) {
-    return fill(start, end, 0, step);
+  if (isObject$1(step)) {
+    return fill$2(start, end, 0, step);
   }
   let opts = { ...options };
   if (opts.capture === true) opts.wrap = true;
   step = step || opts.step || 1;
-  if (!isNumber$1(step)) {
-    if (step != null && !isObject(step)) return invalidStep(step, opts);
-    return fill(start, end, 1, step);
+  if (!isNumber(step)) {
+    if (step != null && !isObject$1(step)) return invalidStep(step, opts);
+    return fill$2(start, end, 1, step);
   }
-  if (isNumber$1(start) && isNumber$1(end)) {
+  if (isNumber(start) && isNumber(end)) {
     return fillNumbers(start, end, step, opts);
   }
   return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
 };
-var fillRange = fill;
+var fillRange = fill$2;
+const fill$1 = fillRange;
+const utils$6 = utils$8;
-const compile = (ast, options = {}) => {
+const compile$1 = (ast, options = {}) => {
   let walk = (node, parent = {}) => {
-    let invalidBlock = utils.isInvalidBrace(parent);
+    let invalidBlock = utils$6.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let invalid = invalidBlock === true || invalidNode === true;
     let prefix = options.escapeInvalid === true ? '\\' : '';
@@ -743,8 +750,8 @@ const compile = (ast, options = {}) => {
     }
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
-      let range = fillRange(...args, { ...options, wrap: false, toRegex: true });
+      let args = utils$6.reduce(node.nodes);
+      let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
       if (range.length !== 0) {
         return args.length > 1 && range.length > 1 ? `(${range})` : range;
@@ -762,7 +769,11 @@ const compile = (ast, options = {}) => {
   return walk(ast);
 };
-var compile_1 = compile;
+var compile_1 = compile$1;
+const fill = fillRange;
+const stringify$2 = stringify$4;
+const utils$5 = utils$8;
 const append = (queue = '', stash = '', enclose = false) => {
   let result = [];
@@ -772,7 +783,7 @@ const append = (queue = '', stash = '', enclose = false) => {
   if (!stash.length) return queue;
   if (!queue.length) {
-    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+    return enclose ? utils$5.flatten(stash).map(ele => `{${ele}}`) : stash;
   }
   for (let item of queue) {
@@ -787,10 +798,10 @@ const append = (queue = '', stash = '', enclose = false) => {
       }
     }
   }
-  return utils.flatten(result);
+  return utils$5.flatten(result);
 };
-const expand = (ast, options = {}) => {
+const expand$1 = (ast, options = {}) => {
   let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
   let walk = (node, parent = {}) => {
@@ -805,7 +816,7 @@ const expand = (ast, options = {}) => {
     }
     if (node.invalid || node.dollar) {
-      q.push(append(q.pop(), stringify(node, options)));
+      q.push(append(q.pop(), stringify$2(node, options)));
       return;
     }
@@ -815,15 +826,15 @@ const expand = (ast, options = {}) => {
     }
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
+      let args = utils$5.reduce(node.nodes);
-      if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+      if (utils$5.exceedsLimit(...args, options.step, rangeLimit)) {
         throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
       }
-      let range = fillRange(...args, options);
+      let range = fill(...args, options);
       if (range.length === 0) {
-        range = stringify(node, options);
+        range = stringify$2(node, options);
       }
       q.push(append(q.pop(), range));
@@ -831,7 +842,7 @@ const expand = (ast, options = {}) => {
       return;
     }
-    let enclose = utils.encloseBrace(node);
+    let enclose = utils$5.encloseBrace(node);
     let queue = node.queue;
     let block = node;
@@ -867,12 +878,12 @@ const expand = (ast, options = {}) => {
     return queue;
   };
-  return utils.flatten(walk(ast));
+  return utils$5.flatten(walk(ast));
 };
-var expand_1 = expand;
+var expand_1 = expand$1;
-var constants = {
+var constants$4 = {
   MAX_LENGTH: 1024 * 64,
   // Digits
@@ -928,39 +939,41 @@ var constants = {
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
 };
+const stringify$1 = stringify$4;
 /**
  * Constants
  */
 const {
-  MAX_LENGTH,
+  MAX_LENGTH: MAX_LENGTH$1,
   CHAR_BACKSLASH, /* \ */
   CHAR_BACKTICK, /* ` */
-  CHAR_COMMA, /* , */
-  CHAR_DOT, /* . */
-  CHAR_LEFT_PARENTHESES, /* ( */
-  CHAR_RIGHT_PARENTHESES, /* ) */
-  CHAR_LEFT_CURLY_BRACE, /* { */
-  CHAR_RIGHT_CURLY_BRACE, /* } */
-  CHAR_LEFT_SQUARE_BRACKET, /* [ */
-  CHAR_RIGHT_SQUARE_BRACKET, /* ] */
+  CHAR_COMMA: CHAR_COMMA$1, /* , */
+  CHAR_DOT: CHAR_DOT$1, /* . */
+  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */
+  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */
+  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */
+  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */
+  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */
+  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, /* ] */
   CHAR_DOUBLE_QUOTE, /* " */
   CHAR_SINGLE_QUOTE, /* ' */
   CHAR_NO_BREAK_SPACE,
   CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = constants;
+} = constants$4;
 /**
  * parse
  */
-const parse = (input, options = {}) => {
+const parse$3 = (input, options = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
   let opts = options || {};
-  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
   if (input.length > max) {
     throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
   }
@@ -1024,7 +1037,7 @@ const parse = (input, options = {}) => {
      * Right square bracket (literal): ']'
      */
-    if (value === CHAR_RIGHT_SQUARE_BRACKET) {
+    if (value === CHAR_RIGHT_SQUARE_BRACKET$1) {
       push({ type: 'text', value: '\\' + value });
       continue;
     }
@@ -1033,14 +1046,14 @@ const parse = (input, options = {}) => {
      * Left square bracket: '['
      */
-    if (value === CHAR_LEFT_SQUARE_BRACKET) {
+    if (value === CHAR_LEFT_SQUARE_BRACKET$1) {
       brackets++;
       let next;
       while (index < length && (next = advance())) {
         value += next;
-        if (next === CHAR_LEFT_SQUARE_BRACKET) {
+        if (next === CHAR_LEFT_SQUARE_BRACKET$1) {
           brackets++;
           continue;
         }
@@ -1050,7 +1063,7 @@ const parse = (input, options = {}) => {
           continue;
         }
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
           brackets--;
           if (brackets === 0) {
@@ -1067,14 +1080,14 @@ const parse = (input, options = {}) => {
      * Parentheses
      */
-    if (value === CHAR_LEFT_PARENTHESES) {
+    if (value === CHAR_LEFT_PARENTHESES$1) {
       block = push({ type: 'paren', nodes: [] });
       stack.push(block);
       push({ type: 'text', value });
       continue;
     }
-    if (value === CHAR_RIGHT_PARENTHESES) {
+    if (value === CHAR_RIGHT_PARENTHESES$1) {
       if (block.type !== 'paren') {
         push({ type: 'text', value });
         continue;
@@ -1119,7 +1132,7 @@ const parse = (input, options = {}) => {
      * Left curly brace: '{'
      */
-    if (value === CHAR_LEFT_CURLY_BRACE) {
+    if (value === CHAR_LEFT_CURLY_BRACE$1) {
       depth++;
       let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
@@ -1144,7 +1157,7 @@ const parse = (input, options = {}) => {
      * Right curly brace: '}'
      */
-    if (value === CHAR_RIGHT_CURLY_BRACE) {
+    if (value === CHAR_RIGHT_CURLY_BRACE$1) {
       if (block.type !== 'brace') {
         push({ type: 'text', value });
         continue;
@@ -1165,11 +1178,11 @@ const parse = (input, options = {}) => {
      * Comma: ','
      */
-    if (value === CHAR_COMMA && depth > 0) {
+    if (value === CHAR_COMMA$1 && depth > 0) {
       if (block.ranges > 0) {
         block.ranges = 0;
         let open = block.nodes.shift();
-        block.nodes = [open, { type: 'text', value: stringify(block) }];
+        block.nodes = [open, { type: 'text', value: stringify$1(block) }];
       }
       push({ type: 'comma', value });
@@ -1181,7 +1194,7 @@ const parse = (input, options = {}) => {
      * Dot: '.'
      */
-    if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
+    if (value === CHAR_DOT$1 && depth > 0 && block.commas === 0) {
       let siblings = block.nodes;
       if (depth === 0 || siblings.length === 0) {
@@ -1253,7 +1266,12 @@ const parse = (input, options = {}) => {
   return ast;
 };
-var parse_1 = parse;
+var parse_1$1 = parse$3;
+const stringify = stringify$4;
+const compile = compile_1;
+const expand = expand_1;
+const parse$2 = parse_1$1;
 /**
  * Expand the given pattern or create a regex-compatible string.
@@ -1269,12 +1287,12 @@ var parse_1 = parse;
  * @api public
  */
-const braces = (input, options = {}) => {
+const braces$2 = (input, options = {}) => {
   let output = [];
   if (Array.isArray(input)) {
     for (let pattern of input) {
-      let result = braces.create(pattern, options);
+      let result = braces$2.create(pattern, options);
       if (Array.isArray(result)) {
         output.push(...result);
       } else {
@@ -1282,7 +1300,7 @@ const braces = (input, options = {}) => {
       }
     }
   } else {
-    output = [].concat(braces.create(input, options));
+    output = [].concat(braces$2.create(input, options));
   }
   if (options && options.expand === true && options.nodupes === true) {
@@ -1305,7 +1323,7 @@ const braces = (input, options = {}) => {
  * @api public
  */
-braces.parse = (input, options = {}) => parse_1(input, options);
+braces$2.parse = (input, options = {}) => parse$2(input, options);
 /**
  * Creates a braces string from an AST, or an AST node.
@@ -1321,9 +1339,9 @@ braces.parse = (input, options = {}) => parse_1(input, options);
  * @api public
  */
-braces.stringify = (input, options = {}) => {
+braces$2.stringify = (input, options = {}) => {
   if (typeof input === 'string') {
-    return stringify(braces.parse(input, options), options);
+    return stringify(braces$2.parse(input, options), options);
   }
   return stringify(input, options);
 };
@@ -1343,11 +1361,11 @@ braces.stringify = (input, options = {}) => {
  * @api public
  */
-braces.compile = (input, options = {}) => {
+braces$2.compile = (input, options = {}) => {
   if (typeof input === 'string') {
-    input = braces.parse(input, options);
+    input = braces$2.parse(input, options);
   }
-  return compile_1(input, options);
+  return compile(input, options);
 };
 /**
@@ -1367,12 +1385,12 @@ braces.compile = (input, options = {}) => {
  * @api public
  */
-braces.expand = (input, options = {}) => {
+braces$2.expand = (input, options = {}) => {
   if (typeof input === 'string') {
-    input = braces.parse(input, options);
+    input = braces$2.parse(input, options);
   }
-  let result = expand_1(input, options);
+  let result = expand(input, options);
   // filter out empty strings if specified
   if (options.noempty === true) {
@@ -1403,22 +1421,25 @@ braces.expand = (input, options = {}) => {
  * @api public
  */
-braces.create = (input, options = {}) => {
+braces$2.create = (input, options = {}) => {
   if (input === '' || input.length < 3) {
     return [input];
   }
  return options.expand !== true
-    ? braces.compile(input, options)
-    : braces.expand(input, options);
+    ? braces$2.compile(input, options)
+    : braces$2.expand(input, options);
 };
 /**
  * Expose "braces"
  */
-var braces_1 = braces;
+var braces_1 = braces$2;
+var utils$4 = {};
+const path$2 = require$$0$2;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
@@ -1440,7 +1461,7 @@ const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
 const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
 const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
 const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
-const STAR = `${QMARK}*?`;
+const STAR$1 = `${QMARK}*?`;
 const POSIX_CHARS = {
   DOT_LITERAL,
@@ -1456,7 +1477,7 @@ const POSIX_CHARS = {
   NO_DOT_SLASH,
   NO_DOTS_SLASH,
   QMARK_NO_DOT,
-  STAR,
+  STAR: STAR$1,
   START_ANCHOR
 };
@@ -1484,7 +1505,7 @@ const WINDOWS_CHARS = {
  * POSIX Bracket Regex
  */
-const POSIX_REGEX_SOURCE = {
+const POSIX_REGEX_SOURCE$1 = {
   alnum: 'a-zA-Z0-9',
   alpha: 'a-zA-Z',
   ascii: '\\x00-\\x7F',
@@ -1501,9 +1522,9 @@ const POSIX_REGEX_SOURCE = {
   xdigit: 'A-Fa-f0-9'
 };
-var constants$1 = {
+var constants$3 = {
   MAX_LENGTH: 1024 * 64,
-  POSIX_REGEX_SOURCE,
+  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
   // regular expressions
   REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
@@ -1571,7 +1592,7 @@ var constants$1 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
-  SEP: sysPath.sep,
+  SEP: path$2.sep,
   /**
    * Create EXTGLOB_CHARS
@@ -1596,16 +1617,16 @@ var constants$1 = {
   }
 };
-var utils$1 = createCommonjsModule(function (module, exports) {
+(function (exports) {
+const path = require$$0$2;
 const win32 = process.platform === 'win32';
 const {
   REGEX_BACKSLASH,
   REGEX_REMOVE_BACKSLASH,
   REGEX_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_GLOBAL
-} = constants$1;
+} = constants$3;
 exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
@@ -1631,7 +1652,7 @@ exports.isWindows = options => {
   if (options && typeof options.windows === 'boolean') {
     return options.windows;
   }
-  return win32 === true || sysPath.sep === '\\';
+  return win32 === true || path.sep === '\\';
 };
 exports.escapeLast = (input, char, lastIdx) => {
@@ -1660,25 +1681,26 @@ exports.wrapOutput = (input, state = {}, options = {}) => {
   }
   return output;
 };
-});
+}(utils$4));
+const utils$3 = utils$4;
 const {
   CHAR_ASTERISK,             /* * */
   CHAR_AT,                   /* @ */
   CHAR_BACKWARD_SLASH,       /* \ */
-  CHAR_COMMA: CHAR_COMMA$1,                /* , */
-  CHAR_DOT: CHAR_DOT$1,                  /* . */
+  CHAR_COMMA,                /* , */
+  CHAR_DOT,                  /* . */
   CHAR_EXCLAMATION_MARK,     /* ! */
   CHAR_FORWARD_SLASH,        /* / */
-  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1,     /* { */
-  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1,     /* ( */
-  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1,  /* [ */
+  CHAR_LEFT_CURLY_BRACE,     /* { */
+  CHAR_LEFT_PARENTHESES,     /* ( */
+  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
   CHAR_PLUS,                 /* + */
   CHAR_QUESTION_MARK,        /* ? */
-  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1,    /* } */
-  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1,    /* ) */
-  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1  /* ] */
-} = constants$1;
+  CHAR_RIGHT_CURLY_BRACE,    /* } */
+  CHAR_RIGHT_PARENTHESES,    /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+} = constants$3;
 const isPathSeparator = code => {
   return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
@@ -1706,7 +1728,7 @@ const depth = token => {
  * @api public
  */
-const scan = (input, options) => {
+const scan$1 = (input, options) => {
   const opts = options || {};
   const length = input.length - 1;
@@ -1748,13 +1770,13 @@ const scan = (input, options) => {
       backslashes = token.backslashes = true;
       code = advance();
-      if (code === CHAR_LEFT_CURLY_BRACE$1) {
+      if (code === CHAR_LEFT_CURLY_BRACE) {
         braceEscaped = true;
       }
       continue;
     }
-    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE$1) {
+    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
       braces++;
       while (eos() !== true && (code = advance())) {
@@ -1764,12 +1786,12 @@ const scan = (input, options) => {
           continue;
         }
-        if (code === CHAR_LEFT_CURLY_BRACE$1) {
+        if (code === CHAR_LEFT_CURLY_BRACE) {
           braces++;
           continue;
         }
-        if (braceEscaped !== true && code === CHAR_DOT$1 && (code = advance()) === CHAR_DOT$1) {
+        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
           isBrace = token.isBrace = true;
           isGlob = token.isGlob = true;
           finished = true;
@@ -1781,7 +1803,7 @@ const scan = (input, options) => {
           break;
         }
-        if (braceEscaped !== true && code === CHAR_COMMA$1) {
+        if (braceEscaped !== true && code === CHAR_COMMA) {
           isBrace = token.isBrace = true;
           isGlob = token.isGlob = true;
           finished = true;
@@ -1793,7 +1815,7 @@ const scan = (input, options) => {
           break;
         }
-        if (code === CHAR_RIGHT_CURLY_BRACE$1) {
+        if (code === CHAR_RIGHT_CURLY_BRACE) {
           braces--;
           if (braces === 0) {
@@ -1818,7 +1840,7 @@ const scan = (input, options) => {
       token = { value: '', depth: 0, isGlob: false };
       if (finished === true) continue;
-      if (prev === CHAR_DOT$1 && index === (start + 1)) {
+      if (prev === CHAR_DOT && index === (start + 1)) {
         start += 2;
         continue;
       }
@@ -1834,7 +1856,7 @@ const scan = (input, options) => {
         || code === CHAR_QUESTION_MARK
         || code === CHAR_EXCLAMATION_MARK;
-      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES$1) {
+      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
         isGlob = token.isGlob = true;
         isExtglob = token.isExtglob = true;
         finished = true;
@@ -1847,7 +1869,7 @@ const scan = (input, options) => {
               continue;
             }
-            if (code === CHAR_RIGHT_PARENTHESES$1) {
+            if (code === CHAR_RIGHT_PARENTHESES) {
               isGlob = token.isGlob = true;
               finished = true;
               break;
@@ -1880,7 +1902,7 @@ const scan = (input, options) => {
       break;
     }
-    if (code === CHAR_LEFT_SQUARE_BRACKET$1) {
+    if (code === CHAR_LEFT_SQUARE_BRACKET) {
       while (eos() !== true && (next = advance())) {
         if (next === CHAR_BACKWARD_SLASH) {
           backslashes = token.backslashes = true;
@@ -1888,7 +1910,7 @@ const scan = (input, options) => {
           continue;
         }
-        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
+        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
           isBracket = token.isBracket = true;
           isGlob = token.isGlob = true;
           finished = true;
@@ -1907,18 +1929,18 @@ const scan = (input, options) => {
       continue;
     }
-    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES$1) {
+    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
       isGlob = token.isGlob = true;
       if (scanToEnd === true) {
         while (eos() !== true && (code = advance())) {
-          if (code === CHAR_LEFT_PARENTHESES$1) {
+          if (code === CHAR_LEFT_PARENTHESES) {
             backslashes = token.backslashes = true;
             code = advance();
             continue;
           }
-          if (code === CHAR_RIGHT_PARENTHESES$1) {
+          if (code === CHAR_RIGHT_PARENTHESES) {
             finished = true;
             break;
           }
@@ -1971,10 +1993,10 @@ const scan = (input, options) => {
   }
   if (opts.unescape === true) {
-    if (glob) glob = utils$1.removeBackslashes(glob);
+    if (glob) glob = utils$3.removeBackslashes(glob);
     if (base && backslashes === true) {
-      base = utils$1.removeBackslashes(base);
+      base = utils$3.removeBackslashes(base);
     }
   }
@@ -2041,19 +2063,22 @@ const scan = (input, options) => {
   return state;
 };
-var scan_1 = scan;
+var scan_1 = scan$1;
+const constants$2 = constants$3;
+const utils$2 = utils$4;
 /**
  * Constants
  */
 const {
-  MAX_LENGTH: MAX_LENGTH$1,
-  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+  MAX_LENGTH,
+  POSIX_REGEX_SOURCE,
   REGEX_NON_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_BACKREF,
   REPLACEMENTS
-} = constants$1;
+} = constants$2;
 /**
  * Helpers
@@ -2093,7 +2118,7 @@ const parse$1 = (input, options) => {
   input = REPLACEMENTS[input] || input;
   const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
   let len = input.length;
   if (len > max) {
@@ -2104,11 +2129,11 @@ const parse$1 = (input, options) => {
   const tokens = [bos];
   const capture = opts.capture ? '' : '?:';
-  const win32 = utils$1.isWindows(options);
+  const win32 = utils$2.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,
@@ -2160,7 +2185,7 @@ const parse$1 = (input, options) => {
     tokens
   };
-  input = utils$1.removePrefix(input, state);
+  input = utils$2.removePrefix(input, state);
   len = input.length;
   const extglobs = [];
@@ -2340,7 +2365,7 @@ const parse$1 = (input, options) => {
       return state;
     }
-    state.output = utils$1.wrapOutput(output, state, options);
+    state.output = utils$2.wrapOutput(output, state, options);
     return state;
   }
@@ -2415,7 +2440,7 @@ const parse$1 = (input, options) => {
             const idx = prev.value.lastIndexOf('[');
             const pre = prev.value.slice(0, idx);
             const rest = prev.value.slice(idx + 2);
-            const posix = POSIX_REGEX_SOURCE$1[rest];
+            const posix = POSIX_REGEX_SOURCE[rest];
             if (posix) {
               prev.value = pre + posix;
               state.backtrack = true;
@@ -2453,7 +2478,7 @@ const parse$1 = (input, options) => {
      */
     if (state.quotes === 1 && value !== '"') {
-      value = utils$1.escapeRegex(value);
+      value = utils$2.escapeRegex(value);
       prev.value += value;
       append({ value });
       continue;
@@ -2543,11 +2568,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$1.hasRegexChars(prevValue)) {
+      if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) {
         continue;
       }
-      const escaped = utils$1.escapeRegex(prev.value);
+      const escaped = utils$2.escapeRegex(prev.value);
       state.output = state.output.slice(0, -prev.value.length);
       // when literal brackets are explicitly enabled
@@ -2719,7 +2744,7 @@ const parse$1 = (input, options) => {
         const next = peek();
         let output = value;
-        if (next === '<' && !utils$1.supportsLookbehinds()) {
+        if (next === '<' && !utils$2.supportsLookbehinds()) {
           throw new Error('Node.js v10 or higher is required for regex lookbehinds');
         }
@@ -2979,19 +3004,19 @@ const parse$1 = (input, options) => {
   while (state.brackets > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$1.escapeLast(state.output, '[');
+    state.output = utils$2.escapeLast(state.output, '[');
     decrement('brackets');
   }
   while (state.parens > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
-    state.output = utils$1.escapeLast(state.output, '(');
+    state.output = utils$2.escapeLast(state.output, '(');
     decrement('parens');
   }
   while (state.braces > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
-    state.output = utils$1.escapeLast(state.output, '{');
+    state.output = utils$2.escapeLast(state.output, '{');
     decrement('braces');
   }
@@ -3023,14 +3048,14 @@ const parse$1 = (input, options) => {
 parse$1.fastpaths = (input, options) => {
   const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
   const len = input.length;
   if (len > max) {
     throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
   }
   input = REPLACEMENTS[input] || input;
-  const win32 = utils$1.isWindows(options);
+  const win32 = utils$2.isWindows(options);
   // create constants based on platform, for windows or posix
   const {
@@ -3043,7 +3068,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;
@@ -3098,7 +3123,7 @@ parse$1.fastpaths = (input, options) => {
     }
   };
-  const output = utils$1.removePrefix(input, state);
+  const output = utils$2.removePrefix(input, state);
   let source = create(output);
   if (source && opts.strictSlashes !== true) {
@@ -3108,9 +3133,14 @@ parse$1.fastpaths = (input, options) => {
   return source;
 };
-var parse_1$1 = parse$1;
+var parse_1 = parse$1;
-const isObject$1 = val => val && typeof val === 'object' && !Array.isArray(val);
+const path$1 = require$$0$2;
+const scan = scan_1;
+const parse = parse_1;
+const utils$1 = utils$4;
+const constants$1 = constants$3;
+const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
 /**
  * Creates a matcher function from one or more glob patterns. The
@@ -3134,9 +3164,9 @@ const isObject$1 = val => val && typeof val === 'object' && !Array.isArray(val);
  * @api public
  */
-const picomatch = (glob, options, returnState = false) => {
+const picomatch$4 = (glob, options, returnState = false) => {
   if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch(input, options, returnState));
+    const fns = glob.map(input => picomatch$4(input, options, returnState));
     const arrayMatcher = str => {
       for (const isMatch of fns) {
         const state = isMatch(str);
@@ -3147,7 +3177,7 @@ const picomatch = (glob, options, returnState = false) => {
     return arrayMatcher;
   }
-  const isState = isObject$1(glob) && glob.tokens && glob.input;
+  const isState = isObject(glob) && glob.tokens && glob.input;
   if (glob === '' || (typeof glob !== 'string' && !isState)) {
     throw new TypeError('Expected pattern to be a non-empty string');
@@ -3156,8 +3186,8 @@ const picomatch = (glob, options, returnState = false) => {
   const opts = options || {};
   const posix = utils$1.isWindows(options);
   const regex = isState
-    ? picomatch.compileRe(glob, options)
-    : picomatch.makeRe(glob, options, false, true);
+    ? picomatch$4.compileRe(glob, options)
+    : picomatch$4.makeRe(glob, options, false, true);
   const state = regex.state;
   delete regex.state;
@@ -3165,11 +3195,11 @@ const picomatch = (glob, options, returnState = false) => {
   let isIgnored = () => false;
   if (opts.ignore) {
     const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+    isIgnored = picomatch$4(opts.ignore, ignoreOpts, returnState);
   }
   const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+    const { isMatch, match, output } = picomatch$4.test(input, regex, options, { glob, posix });
     const result = { glob, state, regex, posix, input, output, match, isMatch };
     if (typeof opts.onResult === 'function') {
@@ -3219,7 +3249,7 @@ const picomatch = (glob, options, returnState = false) => {
  * @api public
  */
-picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+picomatch$4.test = (input, regex, options, { glob, posix } = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected input to be a string');
   }
@@ -3240,7 +3270,7 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
   if (match === false || opts.capture === true) {
     if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch.matchBase(input, regex, options, posix);
+      match = picomatch$4.matchBase(input, regex, options, posix);
     } else {
       match = regex.exec(output);
     }
@@ -3263,9 +3293,9 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
-picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(sysPath.basename(input));
+picomatch$4.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$4.makeRe(glob, options);
+  return regex.test(path$1.basename(input));
 };
 /**
@@ -3285,7 +3315,7 @@ picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options))
  * @api public
  */
-picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+picomatch$4.isMatch = (str, patterns, options) => picomatch$4(patterns, options)(str);
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -3301,9 +3331,9 @@ picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str
  * @api public
  */
-picomatch.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
-  return parse_1$1(pattern, { ...options, fastpaths: false });
+picomatch$4.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$4.parse(p, options));
+  return parse(pattern, { ...options, fastpaths: false });
 };
 /**
@@ -3333,7 +3363,7 @@ picomatch.parse = (pattern, options) => {
  * @api public
  */
-picomatch.scan = (input, options) => scan_1(input, options);
+picomatch$4.scan = (input, options) => scan(input, options);
 /**
  * Create a regular expression from a parsed glob pattern.
@@ -3352,7 +3382,7 @@ picomatch.scan = (input, options) => scan_1(input, options);
  * @api public
  */
-picomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
+picomatch$4.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
   if (returnOutput === true) {
     return parsed.output;
   }
@@ -3366,7 +3396,7 @@ picomatch.compileRe = (parsed, options, returnOutput = false, returnState = fals
     source = `^(?!${source}).*$`;
   }
-  const regex = picomatch.toRegex(source, options);
+  const regex = picomatch$4.toRegex(source, options);
   if (returnState === true) {
     regex.state = parsed;
   }
@@ -3374,7 +3404,7 @@ picomatch.compileRe = (parsed, options, returnOutput = false, returnState = fals
   return regex;
 };
-picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {
+picomatch$4.makeRe = (input, options, returnOutput = false, returnState = false) => {
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
@@ -3390,17 +3420,17 @@ picomatch.makeRe = (input, options, returnOutput = false, returnState = false) =
   }
   if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    output = parse_1$1.fastpaths(input, options);
+    output = parse.fastpaths(input, options);
   }
   if (output === undefined) {
-    parsed = parse_1$1(input, options);
+    parsed = parse(input, options);
     parsed.prefix = prefix + (parsed.prefix || '');
   } else {
     parsed.output = output;
   }
-  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+  return picomatch$4.compileRe(parsed, options, returnOutput, returnState);
 };
 /**
@@ -3420,7 +3450,7 @@ picomatch.makeRe = (input, options, returnOutput = false, returnState = false) =
  * @api public
  */
-picomatch.toRegex = (source, options) => {
+picomatch$4.toRegex = (source, options) => {
   try {
     const opts = options || {};
     return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
@@ -3435,16 +3465,20 @@ picomatch.toRegex = (source, options) => {
  * @return {Object}
  */
-picomatch.constants = constants$1;
+picomatch$4.constants = constants$1;
 /**
  * Expose "picomatch"
  */
-var picomatch_1 = picomatch;
+var picomatch_1 = picomatch$4;
-var picomatch$1 = picomatch_1;
+var picomatch$3 = picomatch_1;
+const util = require$$0$1;
+const braces$1 = braces_1;
+const picomatch$2 = picomatch$3;
+const utils = utils$4;
 const isEmptyString = val => typeof val === 'string' && (val === '' || val === './');
 /**
@@ -3482,7 +3516,7 @@ const micromatch = (list, patterns, options) => {
   };
   for (let i = 0; i < patterns.length; i++) {
-    let isMatch = picomatch$1(String(patterns[i]), { ...options, onResult }, true);
+    let isMatch = picomatch$2(String(patterns[i]), { ...options, onResult }, true);
     let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
     if (negated) negatives++;
@@ -3542,7 +3576,7 @@ micromatch.match = micromatch;
  * @api public
  */
-micromatch.matcher = (pattern, options) => picomatch$1(pattern, options);
+micromatch.matcher = (pattern, options) => picomatch$2(pattern, options);
 /**
  * Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -3561,7 +3595,7 @@ micromatch.matcher = (pattern, options) => picomatch$1(pattern, options);
  * @api public
  */
-micromatch.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
+micromatch.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
 /**
  * Backwards compatibility
@@ -3669,7 +3703,7 @@ micromatch.contains = (str, pattern, options) => {
  */
 micromatch.matchKeys = (obj, patterns, options) => {
-  if (!utils$1.isObject(obj)) {
+  if (!utils.isObject(obj)) {
     throw new TypeError('Expected the first argument to be an object');
   }
   let keys = micromatch(Object.keys(obj), patterns, options);
@@ -3701,7 +3735,7 @@ micromatch.some = (list, patterns, options) => {
   let items = [].concat(list);
   for (let pattern of [].concat(patterns)) {
-    let isMatch = picomatch$1(String(pattern), options);
+    let isMatch = picomatch$2(String(pattern), options);
     if (items.some(item => isMatch(item))) {
       return true;
     }
@@ -3737,7 +3771,7 @@ micromatch.every = (list, patterns, options) => {
   let items = [].concat(list);
   for (let pattern of [].concat(patterns)) {
-    let isMatch = picomatch$1(String(pattern), options);
+    let isMatch = picomatch$2(String(pattern), options);
     if (!items.every(item => isMatch(item))) {
       return false;
     }
@@ -3777,7 +3811,7 @@ micromatch.all = (str, patterns, options) => {
     throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
   }
-  return [].concat(patterns).every(p => picomatch$1(p, options)(str));
+  return [].concat(patterns).every(p => picomatch$2(p, options)(str));
 };
 /**
@@ -3800,9 +3834,9 @@ micromatch.all = (str, patterns, options) => {
  */
 micromatch.capture = (glob, input, options) => {
-  let posix = utils$1.isWindows(options);
-  let regex = picomatch$1.makeRe(String(glob), { ...options, capture: true });
-  let match = regex.exec(posix ? utils$1.toPosixSlashes(input) : input);
+  let posix = utils.isWindows(options);
+  let regex = picomatch$2.makeRe(String(glob), { ...options, capture: true });
+  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
   if (match) {
     return match.slice(1).map(v => v === void 0 ? '' : v);
@@ -3825,7 +3859,7 @@ micromatch.capture = (glob, input, options) => {
  * @api public
  */
-micromatch.makeRe = (...args) => picomatch$1.makeRe(...args);
+micromatch.makeRe = (...args) => picomatch$2.makeRe(...args);
 /**
  * Scan a glob pattern to separate the pattern into segments. Used
@@ -3841,7 +3875,7 @@ micromatch.makeRe = (...args) => picomatch$1.makeRe(...args);
  * @api public
  */
-micromatch.scan = (...args) => picomatch$1.scan(...args);
+micromatch.scan = (...args) => picomatch$2.scan(...args);
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -3860,8 +3894,8 @@ micromatch.scan = (...args) => picomatch$1.scan(...args);
 micromatch.parse = (patterns, options) => {
   let res = [];
   for (let pattern of [].concat(patterns || [])) {
-    for (let str of braces_1(String(pattern), options)) {
-      res.push(picomatch$1.parse(str, options));
+    for (let str of braces$1(String(pattern), options)) {
+      res.push(picomatch$2.parse(str, options));
     }
   }
   return res;
@@ -3889,7 +3923,7 @@ micromatch.braces = (pattern, options) => {
   if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
     return [pattern];
   }
-  return braces_1(pattern, options);
+  return braces$1(pattern, options);
 };
 /**
@@ -4101,21 +4135,25 @@ function mergeOutputOptions(config, overrides, warn) {
         sourcemapFile: getOption('sourcemapFile'),
         sourcemapPathTransform: getOption('sourcemapPathTransform'),
         strict: getOption('strict'),
-        systemNullSetters: getOption('systemNullSetters')
+        systemNullSetters: getOption('systemNullSetters'),
+        validate: getOption('validate')
     };
     warnUnknownOptions(config, Object.keys(outputOptions), 'output options', warn);
     return outputOptions;
 }
-const { Readable } = require$$0$1;
-const { promisify } = util;
+var chokidar = {};
+const fs$3 = fs$4;
+const { Readable } = require$$1;
+const sysPath$3 = require$$0$2;
+const { promisify: promisify$3 } = require$$0$1;
+const picomatch$1 = picomatch$3;
-const readdir = promisify(fs.readdir);
-const stat = promisify(fs.stat);
-const lstat = promisify(fs.lstat);
-const realpath = promisify(fs.realpath);
+const readdir$1 = promisify$3(fs$3.readdir);
+const stat$3 = promisify$3(fs$3.stat);
+const lstat$2 = promisify$3(fs$3.lstat);
+const realpath$1 = promisify$3(fs$3.realpath);
 /**
  * @typedef {Object} EntryInfo
@@ -4126,7 +4164,7 @@ const realpath = promisify(fs.realpath);
  * @property {String} basename
  */
-const BANG = '!';
+const BANG$2 = '!';
 const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP']);
 const FILE_TYPE = 'files';
 const DIR_TYPE = 'directories';
@@ -4150,7 +4188,7 @@ const normalizeFilter = filter => {
     const negative = [];
     for (const item of filter) {
       const trimmed = item.trim();
-      if (trimmed.charAt(0) === BANG) {
+      if (trimmed.charAt(0) === BANG$2) {
         negative.push(picomatch$1(trimmed.slice(1)));
       } else {
         positive.push(picomatch$1(trimmed));
@@ -4195,9 +4233,9 @@ class ReaddirpStream extends Readable {
     this._fileFilter = normalizeFilter(opts.fileFilter);
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
-    const statMethod = opts.lstat ? lstat : stat;
+    const statMethod = opts.lstat ? lstat$2 : stat$3;
     // Use bigint stats if it's windows and stat() supports options (node 10+).
-    if (process.platform === 'win32' && stat.length === 3) {
+    if (process.platform === 'win32' && stat$3.length === 3) {
       this._stat = path => statMethod(path, { bigint: true });
     } else {
       this._stat = statMethod;
@@ -4207,8 +4245,8 @@ class ReaddirpStream extends Readable {
     this._wantsDir = [DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
     this._wantsFile = [FILE_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE].includes(type);
     this._wantsEverything = type === EVERYTHING_TYPE;
-    this._root = sysPath.resolve(root);
-    this._isDirent = ('Dirent' in fs) && !opts.alwaysStat;
+    this._root = sysPath$3.resolve(root);
+    this._isDirent = ('Dirent' in fs$3) && !opts.alwaysStat;
     this._statsProp = this._isDirent ? 'dirent' : 'stats';
     this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
@@ -4268,7 +4306,7 @@ class ReaddirpStream extends Readable {
   async _exploreDir(path, depth) {
     let files;
     try {
-      files = await readdir(path, this._rdOptions);
+      files = await readdir$1(path, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
@@ -4279,8 +4317,8 @@ class ReaddirpStream extends Readable {
     let entry;
     try {
       const basename = this._isDirent ? dirent.name : dirent;
-      const fullPath = sysPath.resolve(sysPath.join(path, basename));
-      entry = {path: sysPath.relative(this._root, fullPath), fullPath, basename};
+      const fullPath = sysPath$3.resolve(sysPath$3.join(path, basename));
+      entry = {path: sysPath$3.relative(this._root, fullPath), fullPath, basename};
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -4312,14 +4350,14 @@ class ReaddirpStream extends Readable {
     if (stats && stats.isSymbolicLink()) {
       const full = entry.fullPath;
       try {
-        const entryRealPath = await realpath(full);
-        const entryRealPathStats = await lstat(entryRealPath);
+        const entryRealPath = await realpath$1(full);
+        const entryRealPathStats = await lstat$2(entryRealPath);
         if (entryRealPathStats.isFile()) {
           return 'file';
         }
         if (entryRealPathStats.isDirectory()) {
           const len = entryRealPath.length;
-          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath.sep) {
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath$3.sep) {
             return this._onError(new Error(
               `Circular symlink detected: "${full}" points to "${entryRealPath}"`
             ));
@@ -4355,7 +4393,7 @@ class ReaddirpStream extends Readable {
  * @param {String} root Root directory
  * @param {ReaddirpArguments=} options Options to specify root (start directory), filters and recursion depth
  */
-const readdirp = (root, options = {}) => {
+const readdirp$1 = (root, options = {}) => {
   let type = options.entryType || options.type;
   if (type === 'both') type = FILE_DIR_TYPE; // backwards-compatibility
   if (type) options.type = type;
@@ -4374,18 +4412,20 @@ const readdirp = (root, options = {}) => {
 const readdirpPromise = (root, options = {}) => {
   return new Promise((resolve, reject) => {
     const files = [];
-    readdirp(root, options)
+    readdirp$1(root, options)
       .on('data', entry => files.push(entry))
       .on('end', () => resolve(files))
       .on('error', error => reject(error));
   });
 };
-readdirp.promise = readdirpPromise;
-readdirp.ReaddirpStream = ReaddirpStream;
-readdirp.default = readdirp;
+readdirp$1.promise = readdirpPromise;
+readdirp$1.ReaddirpStream = ReaddirpStream;
+readdirp$1.default = readdirp$1;
+var readdirp_1 = readdirp$1;
-var readdirp_1 = readdirp;
+var anymatch$2 = {exports: {}};
 /*!
  * normalize-path <https://github.com/jonschlinkert/normalize-path>
@@ -4393,7 +4433,8 @@ var readdirp_1 = readdirp;
  * Copyright (c) 2014-2018, Jon Schlinkert.
  * Released under the MIT License.
  */
-var normalizePath = function(path, stripTrailing) {
+var normalizePath$2 = function(path, stripTrailing) {
   if (typeof path !== 'string') {
     throw new TypeError('expected path to be a string');
   }
@@ -4422,6 +4463,11 @@ var normalizePath = function(path, stripTrailing) {
   return prefix + segs.join('/');
 };
+Object.defineProperty(anymatch$2.exports, "__esModule", { value: true });
+const picomatch = picomatch$3;
+const normalizePath$1 = normalizePath$2;
 /**
  * @typedef {(testString: string) => boolean} AnymatchFn
  * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
@@ -4429,7 +4475,7 @@ var normalizePath = function(path, stripTrailing) {
  */
 const BANG$1 = '!';
 const DEFAULT_OPTIONS = {returnIndex: false};
-const arrify = (item) => Array.isArray(item) ? item : [item];
+const arrify$1 = (item) => Array.isArray(item) ? item : [item];
 /**
  * @param {AnymatchPattern} matcher
@@ -4441,7 +4487,7 @@ const createPattern = (matcher, options) => {
     return matcher;
   }
   if (typeof matcher === 'string') {
-    const glob = picomatch$1(matcher, options);
+    const glob = picomatch(matcher, options);
     return (string) => matcher === string || glob(string);
   }
   if (matcher instanceof RegExp) {
@@ -4464,7 +4510,7 @@ const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
     throw new TypeError('anymatch: second argument must be a string: got ' +
       Object.prototype.toString.call(_path))
   }
-  const path = normalizePath(_path);
+  const path = normalizePath$1(_path);
   for (let index = 0; index < negPatterns.length; index++) {
     const nglob = negPatterns[index];
@@ -4490,7 +4536,7 @@ const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
  * @param {object} options
  * @returns {boolean|number|Function}
  */
-const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
+const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
   if (matchers == null) {
     throw new TypeError('anymatch: specify first argument');
   }
@@ -4498,11 +4544,11 @@ const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
   const returnIndex = opts.returnIndex || false;
   // Early cache for matchers.
-  const mtchers = arrify(matchers);
+  const mtchers = arrify$1(matchers);
   const negatedGlobs = mtchers
     .filter(item => typeof item === 'string' && item.charAt(0) === BANG$1)
     .map(item => item.slice(1))
-    .map(item => picomatch$1(item, opts));
+    .map(item => picomatch(item, opts));
   const patterns = mtchers.map(matcher => createPattern(matcher, opts));
   if (testString == null) {
@@ -4515,8 +4561,8 @@ const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
   return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
 };
-anymatch.default = anymatch;
-var anymatch_1 = anymatch;
+anymatch$1.default = anymatch$1;
+anymatch$2.exports = anymatch$1;
 /*!
  * is-extglob <https://github.com/jonschlinkert/is-extglob>
@@ -4524,7 +4570,8 @@ var anymatch_1 = anymatch;
  * Copyright (c) 2014-2016, Jon Schlinkert.
  * Licensed under the MIT License.
  */
-var isExtglob = function isExtglob(str) {
+var isExtglob$1 = function isExtglob(str) {
   if (typeof str !== 'string' || str === '') {
     return false;
   }
@@ -4545,11 +4592,12 @@ var isExtglob = function isExtglob(str) {
  * Released under the MIT License.
  */
+var isExtglob = isExtglob$1;
 var chars = { '{': '}', '(': ')', '[': ']'};
 var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
 var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
-var isGlob = function isGlob(str, options) {
+var isGlob$2 = function isGlob(str, options) {
   if (typeof str !== 'string' || str === '') {
     return false;
   }
@@ -4586,8 +4634,9 @@ var isGlob = function isGlob(str, options) {
   return false;
 };
-var pathPosixDirname = sysPath.posix.dirname;
-var isWin32 = require$$1$1.platform() === 'win32';
+var isGlob$1 = isGlob$2;
+var pathPosixDirname = require$$0$2.posix.dirname;
+var isWin32 = require$$2.platform() === 'win32';
 var slash = '/';
 var backslash = /\\/g;
@@ -4600,7 +4649,7 @@ var escaped = /\\([\!\*\?\|\[\]\(\)\{\}])/g;
  * @param {Object} opts
  * @param {boolean} [opts.flipBackslashes=true]
  */
-var globParent = function globParent(str, opts) {
+var globParent$1 = function globParent(str, opts) {
   var options = Object.assign({ flipBackslashes: true }, opts);
   // flip windows path separators
@@ -4619,7 +4668,7 @@ var globParent = function globParent(str, opts) {
   // remove path parts that are globby
   do {
     str = pathPosixDirname(str);
-  } while (isGlob(str) || globby.test(str));
+  } while (isGlob$1(str) || globby.test(str));
   // remove escape chars and return result
   return str.replace(escaped, '$1');
@@ -4886,15 +4935,20 @@ var require$$0 = [
 	"zipx"
 ];
-var binaryExtensions = require$$0;
+var binaryExtensions$1 = require$$0;
+const path = require$$0$2;
+const binaryExtensions = binaryExtensions$1;
 const extensions = new Set(binaryExtensions);
-var isBinaryPath = filePath => extensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var isBinaryPath$1 = filePath => extensions.has(path.extname(filePath).slice(1).toLowerCase());
-var constants$2 = createCommonjsModule(function (module, exports) {
+var constants = {};
-const {sep} = sysPath;
+(function (exports) {
+const {sep} = require$$0$2;
 const {platform} = process;
 exports.EV_ALL = 'all';
@@ -4955,38 +5009,40 @@ exports.IDENTITY_FN = val => val;
 exports.isWindows = platform === 'win32';
 exports.isMacos = platform === 'darwin';
 exports.isLinux = platform === 'linux';
-});
-const { promisify: promisify$1 } = util;
+}(constants));
+const fs$2 = fs$4;
+const sysPath$2 = require$$0$2;
+const { promisify: promisify$2 } = require$$0$1;
+const isBinaryPath = isBinaryPath$1;
 const {
-  isWindows,
+  isWindows: isWindows$1,
   isLinux,
-  EMPTY_FN,
-  EMPTY_STR,
+  EMPTY_FN: EMPTY_FN$2,
+  EMPTY_STR: EMPTY_STR$1,
   KEY_LISTENERS,
   KEY_ERR,
   KEY_RAW,
   HANDLER_KEYS,
-  EV_CHANGE,
-  EV_ADD,
-  EV_ADD_DIR,
-  EV_ERROR,
-  STR_DATA,
-  STR_END,
-  BRACE_START,
-  STAR: STAR$1
-} = constants$2;
+  EV_CHANGE: EV_CHANGE$2,
+  EV_ADD: EV_ADD$2,
+  EV_ADD_DIR: EV_ADD_DIR$2,
+  EV_ERROR: EV_ERROR$2,
+  STR_DATA: STR_DATA$1,
+  STR_END: STR_END$2,
+  BRACE_START: BRACE_START$1,
+  STAR
+} = constants;
 const THROTTLE_MODE_WATCH = 'watch';
-const open = promisify$1(fs.open);
-const stat$1 = promisify$1(fs.stat);
-const lstat$1 = promisify$1(fs.lstat);
-const close = promisify$1(fs.close);
-const fsrealpath = promisify$1(fs.realpath);
+const open = promisify$2(fs$2.open);
+const stat$2 = promisify$2(fs$2.stat);
+const lstat$1 = promisify$2(fs$2.lstat);
+const close = promisify$2(fs$2.close);
+const fsrealpath = promisify$2(fs$2.realpath);
-const statMethods = { lstat: lstat$1, stat: stat$1 };
+const statMethods$1 = { lstat: lstat$1, stat: stat$2 };
 // TODO: emit errors properly. Example: EMFILE on Macos.
 const foreach = (val, fn) => {
@@ -5066,12 +5122,12 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     // case the file's watcher misses it (and rely on throttling to de-dupe)
     if (evPath && path !== evPath) {
       fsWatchBroadcast(
-        sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)
+        sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath)
       );
     }
   };
   try {
-    return fs.watch(path, options, handleEvent);
+    return fs$2.watch(path, options, handleEvent);
   } catch (error) {
     errHandler(error);
   }
@@ -5126,11 +5182,11 @@ const setFsWatchListener = (path, fullPath, options, handlers) => {
       fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
     );
     if (!watcher) return;
-    watcher.on(EV_ERROR, async (error) => {
+    watcher.on(EV_ERROR$2, async (error) => {
       const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
       cont.watcherUnusable = true; // documented since Node 10.4.1
       // Workaround for https://github.com/joyent/node/issues/4337
-      if (isWindows && error.code === 'EPERM') {
+      if (isWindows$1 && error.code === 'EPERM') {
         try {
           const fd = await open(path, 'r');
           await close(fd);
@@ -5190,7 +5246,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
   const copts = cont && cont.options;
   if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    fs.unwatchFile(fullPath);
+    fs$2.unwatchFile(fullPath);
     cont = undefined;
   }
@@ -5207,9 +5263,9 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
       listeners: listener,
       rawEmitters: rawEmitter,
       options,
-      watcher: fs.watchFile(fullPath, options, (curr, prev) => {
+      watcher: fs$2.watchFile(fullPath, options, (curr, prev) => {
         foreach(cont.rawEmitters, (rawEmitter) => {
-          rawEmitter(EV_CHANGE, fullPath, {curr, prev});
+          rawEmitter(EV_CHANGE$2, fullPath, {curr, prev});
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
@@ -5228,7 +5284,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
     delFromSet(cont, KEY_RAW, rawEmitter);
     if (isEmptySet(cont.listeners)) {
       FsWatchFileInstances.delete(fullPath);
-      fs.unwatchFile(fullPath);
+      fs$2.unwatchFile(fullPath);
       cont.options = cont.watcher = undefined;
       Object.freeze(cont);
     }
@@ -5238,7 +5294,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 /**
  * @mixin
  */
-class NodeFsHandler {
+class NodeFsHandler$1 {
 /**
  * @param {import("../index").FSWatcher} fsW
@@ -5256,13 +5312,13 @@ constructor(fsW) {
  */
 _watchWithNodeFs(path, listener) {
   const opts = this.fsw.options;
-  const directory = sysPath.dirname(path);
-  const basename = sysPath.basename(path);
+  const directory = sysPath$2.dirname(path);
+  const basename = sysPath$2.basename(path);
   const parent = this.fsw._getWatchedDir(directory);
   parent.add(basename);
-  const absolutePath = sysPath.resolve(path);
+  const absolutePath = sysPath$2.resolve(path);
   const options = {persistent: opts.persistent};
-  if (!listener) listener = EMPTY_FN;
+  if (!listener) listener = EMPTY_FN$2;
   let closer;
   if (opts.usePolling) {
@@ -5293,8 +5349,8 @@ _handleFile(file, stats, initialAdd) {
   if (this.fsw.closed) {
     return;
   }
-  const dirname = sysPath.dirname(file);
-  const basename = sysPath.basename(file);
+  const dirname = sysPath$2.dirname(file);
+  const basename = sysPath$2.basename(file);
   const parent = this.fsw._getWatchedDir(dirname);
   // stats is always present
   let prevStats = stats;
@@ -5306,13 +5362,13 @@ _handleFile(file, stats, initialAdd) {
     if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
     if (!newStats || newStats.mtimeMs === 0) {
       try {
-        const newStats = await stat$1(file);
+        const newStats = await stat$2(file);
         if (this.fsw.closed) return;
         // Check that change event was not fired because of changed only accessTime.
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-          this.fsw._emit(EV_CHANGE, file, newStats);
+          this.fsw._emit(EV_CHANGE$2, file, newStats);
         }
         if (isLinux && prevStats.ino !== newStats.ino) {
           this.fsw._closeFile(path);
@@ -5331,7 +5387,7 @@ _handleFile(file, stats, initialAdd) {
       const at = newStats.atimeMs;
       const mt = newStats.mtimeMs;
       if (!at || at <= mt || mt !== prevStats.mtimeMs) {
-        this.fsw._emit(EV_CHANGE, file, newStats);
+        this.fsw._emit(EV_CHANGE$2, file, newStats);
       }
       prevStats = newStats;
     }
@@ -5341,8 +5397,8 @@ _handleFile(file, stats, initialAdd) {
   // emit an add event if we're supposed to
   if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
-    if (!this.fsw._throttle(EV_ADD, file, 0)) return;
-    this.fsw._emit(EV_ADD, file, stats);
+    if (!this.fsw._throttle(EV_ADD$2, file, 0)) return;
+    this.fsw._emit(EV_ADD$2, file, stats);
   }
   return closer;
@@ -5371,12 +5427,12 @@ async _handleSymlink(entry, directory, path, item) {
     if (dir.has(item)) {
       if (this.fsw._symlinkPaths.get(full) !== linkPath) {
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV_CHANGE, path, entry.stats);
+        this.fsw._emit(EV_CHANGE$2, path, entry.stats);
       }
     } else {
       dir.add(item);
       this.fsw._symlinkPaths.set(full, linkPath);
-      this.fsw._emit(EV_ADD, path, entry.stats);
+      this.fsw._emit(EV_ADD$2, path, entry.stats);
     }
     this.fsw._emitReady();
     return true;
@@ -5392,7 +5448,7 @@ async _handleSymlink(entry, directory, path, item) {
 _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
   // Normalize the directory name on Windows
-  directory = sysPath.join(directory, EMPTY_STR);
+  directory = sysPath$2.join(directory, EMPTY_STR$1);
   if (!wh.hasGlob) {
     throttler = this.fsw._throttle('readdir', directory, 1000);
@@ -5406,13 +5462,13 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
     fileFilter: entry => wh.filterPath(entry),
     directoryFilter: entry => wh.filterDir(entry),
     depth: 0
-  }).on(STR_DATA, async (entry) => {
+  }).on(STR_DATA$1, async (entry) => {
     if (this.fsw.closed) {
       stream = undefined;
       return;
     }
     const item = entry.path;
-    let path = sysPath.join(directory, item);
+    let path = sysPath$2.join(directory, item);
     current.add(item);
     if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
@@ -5430,14 +5486,14 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
       this.fsw._incrReadyCount();
       // ensure relativeness of path is preserved in case of watcher reuse
-      path = sysPath.join(dir, sysPath.relative(dir, path));
+      path = sysPath$2.join(dir, sysPath$2.relative(dir, path));
       this._addToNodeFs(path, initialAdd, wh, depth + 1);
     }
-  }).on(EV_ERROR, this._boundHandleError);
+  }).on(EV_ERROR$2, this._boundHandleError);
   return new Promise(resolve =>
-    stream.once(STR_END, () => {
+    stream.once(STR_END$2, () => {
       if (this.fsw.closed) {
         stream = undefined;
         return;
@@ -5456,7 +5512,7 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
           // a path may have been filtered out of this readdir, but
           // shouldn't be removed because it matches a different glob
           (!wh.hasGlob || wh.filterPath({
-            fullPath: sysPath.resolve(directory, item)
+            fullPath: sysPath$2.resolve(directory, item)
           }));
       }).forEach((item) => {
         this.fsw._remove(directory, item);
@@ -5482,14 +5538,14 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
  * @returns {Promise<Function>} closer for the watcher instance.
  */
 async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-  const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-  const tracked = parentDir.has(sysPath.basename(dir));
+  const parentDir = this.fsw._getWatchedDir(sysPath$2.dirname(dir));
+  const tracked = parentDir.has(sysPath$2.basename(dir));
   if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
+    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR$2, dir, stats);
   }
   // ensure dir is tracked (harmless if redundant)
-  parentDir.add(sysPath.basename(dir));
+  parentDir.add(sysPath$2.basename(dir));
   this.fsw._getWatchedDir(dir);
   let throttler;
   let closer;
@@ -5538,17 +5594,17 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
   // evaluate what is at the path we're being asked to watch
   try {
-    const stats = await statMethods[wh.statMethod](wh.watchPath);
+    const stats = await statMethods$1[wh.statMethod](wh.watchPath);
     if (this.fsw.closed) return;
     if (this.fsw._isIgnored(wh.watchPath, stats)) {
       ready();
       return false;
     }
-    const follow = this.fsw.options.followSymlinks && !path.includes(STAR$1) && !path.includes(BRACE_START);
+    const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START$1);
     let closer;
     if (stats.isDirectory()) {
-      const absPath = sysPath.resolve(path);
+      const absPath = sysPath$2.resolve(path);
       const targetPath = follow ? await fsrealpath(path) : path;
       if (this.fsw.closed) return;
       closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5560,15 +5616,15 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
     } else if (stats.isSymbolicLink()) {
       const targetPath = follow ? await fsrealpath(path) : path;
       if (this.fsw.closed) return;
-      const parent = sysPath.dirname(wh.watchPath);
+      const parent = sysPath$2.dirname(wh.watchPath);
       this.fsw._getWatchedDir(parent).add(wh.watchPath);
-      this.fsw._emit(EV_ADD, wh.watchPath, stats);
+      this.fsw._emit(EV_ADD$2, wh.watchPath, stats);
       closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
       if (this.fsw.closed) return;
       // preserve this symlink's target path
       if (targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+        this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
       }
     } else {
       closer = this._handleFile(wh.watchPath, stats, initialAdd);
@@ -5588,15 +5644,19 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
 }
-var nodefsHandler = NodeFsHandler;
+var nodefsHandler = NodeFsHandler$1;
+var fseventsHandler = {exports: {}};
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(fseventsImporter);
+var require$$3 = /*@__PURE__*/getAugmentedNamespace(fseventsImporter);
-const { promisify: promisify$2 } = util;
+const fs$1 = fs$4;
+const sysPath$1 = require$$0$2;
+const { promisify: promisify$1 } = require$$0$1;
 let fsevents;
 try {
-  fsevents = require$$1.getFsEvents();
+  fsevents = require$$3.getFsEvents();
 } catch (error) {
   if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
 }
@@ -5617,9 +5677,9 @@ const {
   EV_ADD: EV_ADD$1,
   EV_CHANGE: EV_CHANGE$1,
   EV_ADD_DIR: EV_ADD_DIR$1,
-  EV_UNLINK,
+  EV_UNLINK: EV_UNLINK$1,
   EV_ERROR: EV_ERROR$1,
-  STR_DATA: STR_DATA$1,
+  STR_DATA,
   STR_END: STR_END$1,
   FSEVENT_CREATED,
   FSEVENT_MODIFIED,
@@ -5634,18 +5694,18 @@ const {
   ROOT_GLOBSTAR,
   DIR_SUFFIX,
   DOT_SLASH,
-  FUNCTION_TYPE,
+  FUNCTION_TYPE: FUNCTION_TYPE$1,
   EMPTY_FN: EMPTY_FN$1,
   IDENTITY_FN
-} = constants$2;
+} = constants;
 const Depth = (value) => isNaN(value) ? {} : {depth: value};
-const stat$2 = promisify$2(fs.stat);
-const lstat$2 = promisify$2(fs.lstat);
-const realpath$1 = promisify$2(fs.realpath);
+const stat$1 = promisify$1(fs$1.stat);
+const lstat = promisify$1(fs$1.lstat);
+const realpath = promisify$1(fs$1.realpath);
-const statMethods$1 = { stat: stat$2, lstat: lstat$2 };
+const statMethods = { stat: stat$1, lstat };
 /**
  * @typedef {String} Path
@@ -5694,8 +5754,8 @@ const createFSEventsInstance = (path, callback) => {
  * @returns {Function} closer
  */
 function setFSEventsListener(path, realPath, listener, rawEmitter) {
-  let watchPath = sysPath.extname(path) ? sysPath.dirname(path) : path;
-  const parentPath = sysPath.dirname(watchPath);
+  let watchPath = sysPath$1.extname(path) ? sysPath$1.dirname(path) : path;
+  const parentPath = sysPath$1.dirname(watchPath);
   let cont = FSEventsWatchers.get(watchPath);
   // If we've accumulated a substantial number of paths that
@@ -5706,14 +5766,14 @@ function setFSEventsListener(path, realPath, listener, rawEmitter) {
     watchPath = parentPath;
   }
-  const resolvedPath = sysPath.resolve(path);
+  const resolvedPath = sysPath$1.resolve(path);
   const hasSymlink = resolvedPath !== realPath;
   const filteredListener = (fullPath, flags, info) => {
     if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
     if (
       fullPath === resolvedPath ||
-      !fullPath.indexOf(resolvedPath + sysPath.sep)
+      !fullPath.indexOf(resolvedPath + sysPath$1.sep)
     ) listener(fullPath, flags, info);
   };
@@ -5721,7 +5781,7 @@ function setFSEventsListener(path, realPath, listener, rawEmitter) {
   // modifies `watchPath` to the parent path when it finds a match
   let watchedParent = false;
   for (const watchedPath of FSEventsWatchers.keys()) {
-    if (realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep) === 0) {
+    if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
       watchPath = watchedPath;
       cont = FSEventsWatchers.get(watchPath);
       watchedParent = true;
@@ -5786,7 +5846,7 @@ const canUse = () => fsevents && FSEventsWatchers.size < 128;
 // determines subdirectory traversal levels from root to path
 const calcDepth = (path, root) => {
   let i = 0;
-  while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++;
+  while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
   return i;
 };
@@ -5801,7 +5861,7 @@ const sameTypes = (info, stats) => (
 /**
  * @mixin
  */
-class FsEventsHandler {
+class FsEventsHandler$1 {
 /**
  * @param {import('../index').FSWatcher} fsw
@@ -5830,18 +5890,18 @@ addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
 async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts) {
   try {
-    const stats = await stat$2(path);
+    const stats = await stat$1(path);
     if (this.fsw.closed) return;
     if (sameTypes(info, stats)) {
       this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
     } else {
-      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
     }
   } catch (error) {
     if (error.code === 'EACCES') {
       this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
     } else {
-      this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+      this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
     }
   }
 }
@@ -5849,7 +5909,7 @@ async checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts
 handleEvent(event, path, fullPath, realPath, parent, watchedDir, item, info, opts) {
   if (this.fsw.closed || this.checkIgnored(path)) return;
-  if (event === EV_UNLINK) {
+  if (event === EV_UNLINK$1) {
     const isDirectory = info.type === FSEVENT_TYPE_DIRECTORY;
     // suppress unlink events on never before seen files
     if (isDirectory || watchedDir.has(item)) {
@@ -5897,30 +5957,30 @@ _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
       opts.depth !== undefined &&
       calcDepth(fullPath, realPath) > opts.depth
     ) return;
-    const path = transform(sysPath.join(
-      watchPath, sysPath.relative(watchPath, fullPath)
+    const path = transform(sysPath$1.join(
+      watchPath, sysPath$1.relative(watchPath, fullPath)
     ));
     if (globFilter && !globFilter(path)) return;
     // ensure directories are tracked
-    const parent = sysPath.dirname(path);
-    const item = sysPath.basename(path);
+    const parent = sysPath$1.dirname(path);
+    const item = sysPath$1.basename(path);
     const watchedDir = this.fsw._getWatchedDir(
       info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
     );
     // correct for wrong events emitted
     if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
-      if (typeof opts.ignored === FUNCTION_TYPE) {
+      if (typeof opts.ignored === FUNCTION_TYPE$1) {
         let stats;
         try {
-          stats = await stat$2(path);
+          stats = await stat$1(path);
         } catch (error) {}
         if (this.fsw.closed) return;
         if (this.checkIgnored(path, stats)) return;
         if (sameTypes(info, stats)) {
           this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
         } else {
-          this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+          this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
         }
       } else {
         this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
@@ -5964,7 +6024,7 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
   this.fsw._incrReadyCount();
   try {
-    const linkTarget = await realpath$1(linkPath);
+    const linkTarget = await realpath(linkPath);
     if (this.fsw.closed) return;
     if (this.fsw._isIgnored(linkTarget)) {
       return this.fsw._emitReady();
@@ -5979,7 +6039,7 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
       if (linkTarget && linkTarget !== DOT_SLASH) {
         aliasedPath = path.replace(linkTarget, linkPath);
       } else if (path !== DOT_SLASH) {
-        aliasedPath = sysPath.join(linkPath, path);
+        aliasedPath = sysPath$1.join(linkPath, path);
       }
       return transform(aliasedPath);
     }, false, curDepth);
@@ -5998,8 +6058,8 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
 emitAdd(newPath, stats, processPath, opts, forceAdd) {
   const pp = processPath(newPath);
   const isDir = stats.isDirectory();
-  const dirObj = this.fsw._getWatchedDir(sysPath.dirname(pp));
-  const base = sysPath.basename(pp);
+  const dirObj = this.fsw._getWatchedDir(sysPath$1.dirname(pp));
+  const base = sysPath$1.basename(pp);
   // ensure empty dirs get tracked
   if (isDir) this.fsw._getWatchedDir(pp);
@@ -6015,7 +6075,7 @@ initWatch(realPath, path, wh, processPath) {
   if (this.fsw.closed) return;
   const closer = this._watchWithFsEvents(
     wh.watchPath,
-    sysPath.resolve(realPath || wh.watchPath),
+    sysPath$1.resolve(realPath || wh.watchPath),
     processPath,
     wh.globFilter
   );
@@ -6035,13 +6095,13 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
     return;
   }
   const opts = this.fsw.options;
-  const processPath = typeof transform === FUNCTION_TYPE ? transform : IDENTITY_FN;
+  const processPath = typeof transform === FUNCTION_TYPE$1 ? transform : IDENTITY_FN;
   const wh = this.fsw._getWatchHelpers(path);
   // evaluate what is at the path we're being asked to watch
   try {
-    const stats = await statMethods$1[wh.statMethod](wh.watchPath);
+    const stats = await statMethods[wh.statMethod](wh.watchPath);
     if (this.fsw.closed) return;
     if (this.fsw._isIgnored(wh.watchPath, stats)) {
       throw null;
@@ -6058,21 +6118,21 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
         fileFilter: entry => wh.filterPath(entry),
         directoryFilter: entry => wh.filterDir(entry),
         ...Depth(opts.depth - (priorDepth || 0))
-      }).on(STR_DATA$1, (entry) => {
+      }).on(STR_DATA, (entry) => {
         // need to check filterPath on dirs b/c filterDir is less restrictive
         if (this.fsw.closed) {
           return;
         }
         if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
-        const joinedPath = sysPath.join(wh.watchPath, entry.path);
+        const joinedPath = sysPath$1.join(wh.watchPath, entry.path);
         const {fullPath} = entry;
         if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
           // preserve the current depth here since it can't be derived from
           // real paths past the symlink
           const curDepth = opts.depth === undefined ?
-            undefined : calcDepth(joinedPath, sysPath.resolve(wh.watchPath)) + 1;
+            undefined : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
           this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
         } else {
@@ -6094,13 +6154,13 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
   }
   if (opts.persistent && forceAdd !== true) {
-    if (typeof transform === FUNCTION_TYPE) {
+    if (typeof transform === FUNCTION_TYPE$1) {
       // realpath has already been resolved
       this.initWatch(undefined, path, wh, processPath);
     } else {
       let realPath;
       try {
-        realPath = await realpath$1(wh.watchPath);
+        realPath = await realpath(wh.watchPath);
       } catch (e) {}
       this.initWatch(realPath, path, wh, processPath);
     }
@@ -6109,36 +6169,35 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
 }
-var fseventsHandler = FsEventsHandler;
-var canUse_1 = canUse;
-fseventsHandler.canUse = canUse_1;
-const { EventEmitter } = require$$0$2;
-const { promisify: promisify$3 } = util;
-const anymatch$1 = anymatch_1.default;
+fseventsHandler.exports = FsEventsHandler$1;
+fseventsHandler.exports.canUse = canUse;
+const { EventEmitter } = require$$0$3;
+const fs = fs$4;
+const sysPath = require$$0$2;
+const { promisify } = require$$0$1;
+const readdirp = readdirp_1;
+const anymatch = anymatch$2.exports.default;
+const globParent = globParent$1;
+const isGlob = isGlob$2;
+const braces = braces_1;
+const normalizePath = normalizePath$2;
+const NodeFsHandler = nodefsHandler;
+const FsEventsHandler = fseventsHandler.exports;
 const {
   EV_ALL,
   EV_READY,
-  EV_ADD: EV_ADD$2,
-  EV_CHANGE: EV_CHANGE$2,
-  EV_UNLINK: EV_UNLINK$1,
-  EV_ADD_DIR: EV_ADD_DIR$2,
+  EV_ADD,
+  EV_CHANGE,
+  EV_UNLINK,
+  EV_ADD_DIR,
   EV_UNLINK_DIR,
   EV_RAW,
-  EV_ERROR: EV_ERROR$2,
+  EV_ERROR,
   STR_CLOSE,
-  STR_END: STR_END$2,
+  STR_END,
   BACK_SLASH_RE,
   DOUBLE_SLASH_RE,
@@ -6148,24 +6207,24 @@ const {
   SLASH,
   SLASH_SLASH,
-  BRACE_START: BRACE_START$1,
-  BANG: BANG$2,
+  BRACE_START,
+  BANG,
   ONE_DOT,
   TWO_DOTS,
   GLOBSTAR,
   SLASH_GLOBSTAR,
   ANYMATCH_OPTS,
   STRING_TYPE,
-  FUNCTION_TYPE: FUNCTION_TYPE$1,
-  EMPTY_STR: EMPTY_STR$1,
-  EMPTY_FN: EMPTY_FN$2,
+  FUNCTION_TYPE,
+  EMPTY_STR,
+  EMPTY_FN,
-  isWindows: isWindows$1,
+  isWindows,
   isMacos
-} = constants$2;
+} = constants;
-const stat$3 = promisify$3(fs.stat);
-const readdir$1 = promisify$3(fs.readdir);
+const stat = promisify(fs.stat);
+const readdir = promisify(fs.readdir);
 /**
  * @typedef {String} Path
@@ -6187,7 +6246,7 @@ const readdir$1 = promisify$3(fs.readdir);
  * @property {Function} filterDir
  */
-const arrify$1 = (value = []) => Array.isArray(value) ? value : [value];
+const arrify = (value = []) => Array.isArray(value) ? value : [value];
 const flatten = (list, result = []) => {
   list.forEach(item => {
     if (Array.isArray(item)) {
@@ -6203,7 +6262,7 @@ const unifyPaths = (paths_) => {
   /**
    * @type {Array<String>}
    */
-  const paths = flatten(arrify$1(paths_));
+  const paths = flatten(arrify(paths_));
   if (!paths.every(p => typeof p === STRING_TYPE)) {
     throw new TypeError(`Non-string provided as watch path: ${paths}`);
   }
@@ -6231,7 +6290,7 @@ const toUnix = (string) => {
 // TODO: this is not equal to path-normalize module - investigate why
 const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
-const normalizeIgnored = (cwd = EMPTY_STR$1) => (path) => {
+const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
   if (typeof path !== STRING_TYPE) return path;
   return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
 };
@@ -6240,8 +6299,8 @@ const getAbsolutePath = (path, cwd) => {
   if (sysPath.isAbsolute(path)) {
     return path;
   }
-  if (path.startsWith(BANG$2)) {
-    return BANG$2 + sysPath.join(cwd, path.slice(1));
+  if (path.startsWith(BANG)) {
+    return BANG + sysPath.join(cwd, path.slice(1));
   }
   return sysPath.join(cwd, path);
 };
@@ -6279,7 +6338,7 @@ class DirEntry {
     const dir = this.path;
     try {
-      await readdir$1(dir);
+      await readdir(dir);
     } catch (err) {
       if (this._removeWatcher) {
         this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
@@ -6316,14 +6375,14 @@ const STAT_METHOD_L = 'lstat';
 class WatchHelper {
   constructor(path, watchPath, follow, fsw) {
     this.fsw = fsw;
-    this.path = path = path.replace(REPLACER_RE, EMPTY_STR$1);
+    this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath.resolve(watchPath);
     this.hasGlob = watchPath !== path;
     /** @type {object|boolean} */
-    if (path === EMPTY_STR$1) this.hasGlob = false;
+    if (path === EMPTY_STR) this.hasGlob = false;
     this.globSymlink = this.hasGlob && follow ? undefined : false;
-    this.globFilter = this.hasGlob ? anymatch$1(path, undefined, ANYMATCH_OPTS) : false;
+    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
     this.dirParts = this.getDirParts(path);
     this.dirParts.forEach((parts) => {
       if (parts.length > 1) parts.pop();
@@ -6357,7 +6416,7 @@ class WatchHelper {
     const {stats} = entry;
     if (stats && stats.isSymbolicLink()) return this.filterDir(entry);
     const resolvedPath = this.entryPath(entry);
-    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE$1 ?
+    const matchesGlob = this.hasGlob && typeof this.globFilter === FUNCTION_TYPE ?
       this.globFilter(resolvedPath) : true;
     return matchesGlob &&
       this.fsw._isntIgnored(resolvedPath, stats) &&
@@ -6367,7 +6426,7 @@ class WatchHelper {
   getDirParts(path) {
     if (!this.hasGlob) return [];
     const parts = [];
-    const expandedPath = path.includes(BRACE_START$1) ? braces_1.expand(path) : [path];
+    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
     expandedPath.forEach((path) => {
       parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
     });
@@ -6381,7 +6440,7 @@ class WatchHelper {
       this.unmatchedGlob = !this.dirParts.some((parts) => {
         return parts.every((part, i) => {
           if (part === GLOBSTAR) globstar = true;
-          return globstar || !entryParts[0][i] || anymatch$1(part, entryParts[0][i], ANYMATCH_OPTS);
+          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
         });
       });
     }
@@ -6434,7 +6493,7 @@ constructor(_opts) {
   if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
   // If we can't use fsevents, ensure the options reflect it's disabled.
-  const canUseFsEvents = fseventsHandler.canUse();
+  const canUseFsEvents = FsEventsHandler.canUse();
   if (!canUseFsEvents) opts.useFsEvents = false;
   // Use polling on Mac if not using fsevents.
@@ -6476,13 +6535,13 @@ constructor(_opts) {
     if (!awf.pollInterval) awf.pollInterval = 100;
     this._pendingWrites = new Map();
   }
-  if (opts.ignored) opts.ignored = arrify$1(opts.ignored);
+  if (opts.ignored) opts.ignored = arrify(opts.ignored);
   let readyCalls = 0;
   this._emitReady = () => {
     readyCalls++;
     if (readyCalls >= this._readyCount) {
-      this._emitReady = EMPTY_FN$2;
+      this._emitReady = EMPTY_FN;
       this._readyEmitted = true;
       // use process.nextTick to allow time for listener to be bound
       process.nextTick(() => this.emit(EV_READY));
@@ -6494,9 +6553,9 @@ constructor(_opts) {
   // Initialize with proper watcher.
   if (opts.useFsEvents) {
-    this._fsEventsHandler = new fseventsHandler(this);
+    this._fsEventsHandler = new FsEventsHandler(this);
   } else {
-    this._nodeFsHandler = new nodefsHandler(this);
+    this._nodeFsHandler = new NodeFsHandler(this);
   }
   // You’re frozen when your heart’s not open.
@@ -6530,7 +6589,7 @@ add(paths_, _origAdd, _internal) {
   // set aside negated glob strings
   paths = paths.filter((path) => {
-    if (path.startsWith(BANG$2)) {
+    if (path.startsWith(BANG)) {
       this._ignoredPaths.add(path.slice(1));
       return false;
     }
@@ -6645,7 +6704,7 @@ getWatched() {
 emitWithAll(event, args) {
   this.emit(...args);
-  if (event !== EV_ERROR$2) this.emit(EV_ALL, ...args);
+  if (event !== EV_ERROR) this.emit(EV_ALL, ...args);
 }
 // Common helpers
@@ -6665,7 +6724,7 @@ async _emit(event, path, val1, val2, val3) {
   if (this.closed) return;
   const opts = this.options;
-  if (isWindows$1) path = sysPath.normalize(path);
+  if (isWindows) path = sysPath.normalize(path);
   if (opts.cwd) path = sysPath.relative(opts.cwd, path);
   /** @type Array<any> */
   const args = [event, path];
@@ -6681,7 +6740,7 @@ async _emit(event, path, val1, val2, val3) {
   }
   if (opts.atomic) {
-    if (event === EV_UNLINK$1) {
+    if (event === EV_UNLINK) {
       this._pendingUnlinks.set(path, args);
       setTimeout(() => {
         this._pendingUnlinks.forEach((entry, path) => {
@@ -6692,16 +6751,16 @@ async _emit(event, path, val1, val2, val3) {
       }, typeof opts.atomic === 'number' ? opts.atomic : 100);
       return this;
     }
-    if (event === EV_ADD$2 && this._pendingUnlinks.has(path)) {
-      event = args[0] = EV_CHANGE$2;
+    if (event === EV_ADD && this._pendingUnlinks.has(path)) {
+      event = args[0] = EV_CHANGE;
       this._pendingUnlinks.delete(path);
     }
   }
-  if (awf && (event === EV_ADD$2 || event === EV_CHANGE$2) && this._readyEmitted) {
+  if (awf && (event === EV_ADD || event === EV_CHANGE) && this._readyEmitted) {
     const awfEmit = (err, stats) => {
       if (err) {
-        event = args[0] = EV_ERROR$2;
+        event = args[0] = EV_ERROR;
         args[1] = err;
         this.emitWithAll(event, args);
       } else if (stats) {
@@ -6719,18 +6778,18 @@ async _emit(event, path, val1, val2, val3) {
     return this;
   }
-  if (event === EV_CHANGE$2) {
-    const isThrottled = !this._throttle(EV_CHANGE$2, path, 50);
+  if (event === EV_CHANGE) {
+    const isThrottled = !this._throttle(EV_CHANGE, path, 50);
     if (isThrottled) return this;
   }
   if (opts.alwaysStat && val1 === undefined &&
-    (event === EV_ADD$2 || event === EV_ADD_DIR$2 || event === EV_CHANGE$2)
+    (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
   ) {
     const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
     let stats;
     try {
-      stats = await stat$3(fullPath);
+      stats = await stat(fullPath);
     } catch (err) {}
     // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
     if (!stats || this.closed) return;
@@ -6751,7 +6810,7 @@ _handleError(error) {
   if (error && code !== 'ENOENT' && code !== 'ENOTDIR' &&
     (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))
   ) {
-    this.emit(EV_ERROR$2, error);
+    this.emit(EV_ERROR, error);
   }
   return error || this.closed;
 }
@@ -6876,11 +6935,11 @@ _isIgnored(path, stats) {
     const ign = this.options.ignored;
     const ignored = ign && ign.map(normalizeIgnored(cwd));
-    const paths = arrify$1(ignored)
+    const paths = arrify(ignored)
       .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
       .map((path) => path + SLASH_GLOBSTAR);
     const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
-    this._userIgnored = anymatch$1(list, undefined, ANYMATCH_OPTS);
+    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
   }
   return this._userIgnored([path, stats]);
@@ -6991,14 +7050,14 @@ _remove(directory, item, isDirectory) {
   if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
   if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
     const event = this._pendingWrites.get(relPath).cancelWait();
-    if (event === EV_ADD$2) return;
+    if (event === EV_ADD) return;
   }
   // The Entry will either be a directory that just got removed
   // or a bogus entry to a file, in either case we have to remove it
   this._watched.delete(path);
   this._watched.delete(fullPath);
-  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK$1;
+  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
   if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
   // Avoid conflicts if we later create another file with the same name
@@ -7046,12 +7105,12 @@ _addPathCloser(path, closer) {
 _readdirp(root, opts) {
   if (this.closed) return;
   const options = {type: EV_ALL, alwaysStat: true, lstat: true, ...opts};
-  let stream = readdirp_1(root, options);
+  let stream = readdirp(root, options);
   this._streams.add(stream);
   stream.once(STR_CLOSE, () => {
     stream = undefined;
   });
-  stream.once(STR_END$2, () => {
+  stream.once(STR_END, () => {
     if (stream) {
       this._streams.delete(stream);
       stream = undefined;
@@ -7063,7 +7122,7 @@ _readdirp(root, opts) {
 }
 // Export FSWatcher class
-var FSWatcher_1 = FSWatcher;
+chokidar.FSWatcher = FSWatcher;
 /**
  * Instantiates watcher with paths to be tracked.
@@ -7077,12 +7136,7 @@ const watch = (paths, options) => {
   return watcher;
 };
-var watch_1 = watch;
-var chokidar = {
-	FSWatcher: FSWatcher_1,
-	watch: watch_1
-};
+chokidar.watch = watch;
 class FileWatcher {
     constructor(task, chokidarOptions) {