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

rollup 2.39.1 → 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 (16) hide show

package/CHANGELOG.md +14 -0
package/dist/bin/rollup +2 -2
package/dist/es/rollup.browser.js +3 -3
package/dist/es/rollup.js +2 -2
package/dist/es/shared/rollup.js +258 -253
package/dist/es/shared/watch.js +448 -448
package/dist/loadConfigFile.js +2 -2
package/dist/rollup.browser.js +3 -3
package/dist/rollup.js +2 -2
package/dist/shared/index.js +442 -442
package/dist/shared/loadConfigFile.js +2 -2
package/dist/shared/mergeOptions.js +2 -2
package/dist/shared/rollup.js +258 -253
package/dist/shared/watch-cli.js +18 -18
package/dist/shared/watch.js +2 -2
package/package.json +1 -1

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

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.39.1
-	Tue, 23 Feb 2021 05:45:51 GMT - commit a8a56fc29978cef41dde28f8f14e3b29119768d5
+	Rollup.js v2.40.0
+	Fri, 26 Feb 2021 14:39:44 GMT - commit 0a0958ff926554abe9916178f56762ba71301ddd
 	https://github.com/rollup/rollup
@@ -17,7 +17,7 @@ import require$$1 from 'stream';
 import require$$2, { platform } from 'os';
 import 'crypto';
-var utils = {};
+var utils$8 = {};
 (function (exports) {
@@ -131,18 +131,18 @@ exports.flatten = (...args) => {
   flat(args);
   return result;
 };
-}(utils));
+}(utils$8));
-const utils$1 = utils;
+const utils$7 = utils$8;
-var stringify = (ast, options = {}) => {
+var stringify$4 = (ast, options = {}) => {
   let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils$1.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$1.isOpenOrClose(node)) {
+      if ((invalidBlock || invalidNode) && utils$7.isOpenOrClose(node)) {
         return '\\' + node.value;
       }
       return node.value;
@@ -170,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;
   }
@@ -187,9 +187,9 @@ var isNumber = function(num) {
  * Released under the MIT License.
  */
-const isNumber$1 = isNumber;
+const isNumber$1 = isNumber$2;
-const toRegexRange = (min, max, options) => {
+const toRegexRange$1 = (min, max, options) => {
   if (isNumber$1(min) === false) {
     throw new TypeError('toRegexRange: expected the first argument to be a number');
   }
@@ -213,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);
@@ -261,7 +261,7 @@ const toRegexRange = (min, max, options) => {
     state.result = `(?:${state.result})`;
   }
-  toRegexRange.cache[cacheKey] = state;
+  toRegexRange$1.cache[cacheKey] = state;
   return state.result;
 };
@@ -458,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>
@@ -474,10 +474,10 @@ var toRegexRange_1 = toRegexRange;
  * Licensed under the MIT License.
  */
-const util = require$$0$1;
-const toRegexRange$1 = toRegexRange_1;
+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);
@@ -487,7 +487,7 @@ const isValidValue = value => {
   return typeof value === 'number' || (typeof value === 'string' && value !== '');
 };
-const isNumber$2 = num => Number.isInteger(+num);
+const isNumber = num => Number.isInteger(+num);
 const zeros = input => {
   let value = `${input}`;
@@ -498,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;
   }
@@ -559,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);
@@ -575,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) => {
@@ -615,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) {
@@ -647,7 +647,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
 };
 const fillLetters = (start, end, step = 1, options = {}) => {
-  if ((!isNumber$2(start) && start.length > 1) || (!isNumber$2(end) && end.length > 1)) {
+  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
     return invalidRange(start, end, options);
   }
@@ -680,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];
   }
@@ -690,37 +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$2(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$2(start) && isNumber$2(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$2 = utils;
+const utils$6 = utils$8;
-const compile = (ast, options = {}) => {
+const compile$1 = (ast, options = {}) => {
   let walk = (node, parent = {}) => {
-    let invalidBlock = utils$2.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 ? '\\' : '';
@@ -750,7 +750,7 @@ const compile = (ast, options = {}) => {
     }
     if (node.nodes && node.ranges > 0) {
-      let args = utils$2.reduce(node.nodes);
+      let args = utils$6.reduce(node.nodes);
       let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
       if (range.length !== 0) {
@@ -769,11 +769,11 @@ const compile = (ast, options = {}) => {
   return walk(ast);
 };
-var compile_1 = compile;
+var compile_1 = compile$1;
-const fill$2 = fillRange;
-const stringify$2 = stringify;
-const utils$3 = utils;
+const fill = fillRange;
+const stringify$2 = stringify$4;
+const utils$5 = utils$8;
 const append = (queue = '', stash = '', enclose = false) => {
   let result = [];
@@ -783,7 +783,7 @@ const append = (queue = '', stash = '', enclose = false) => {
   if (!stash.length) return queue;
   if (!queue.length) {
-    return enclose ? utils$3.flatten(stash).map(ele => `{${ele}}`) : stash;
+    return enclose ? utils$5.flatten(stash).map(ele => `{${ele}}`) : stash;
   }
   for (let item of queue) {
@@ -798,10 +798,10 @@ const append = (queue = '', stash = '', enclose = false) => {
       }
     }
   }
-  return utils$3.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 = {}) => {
@@ -826,13 +826,13 @@ const expand = (ast, options = {}) => {
     }
     if (node.nodes && node.ranges > 0) {
-      let args = utils$3.reduce(node.nodes);
+      let args = utils$5.reduce(node.nodes);
-      if (utils$3.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 = fill$2(...args, options);
+      let range = fill(...args, options);
       if (range.length === 0) {
         range = stringify$2(node, options);
       }
@@ -842,7 +842,7 @@ const expand = (ast, options = {}) => {
       return;
     }
-    let enclose = utils$3.encloseBrace(node);
+    let enclose = utils$5.encloseBrace(node);
     let queue = node.queue;
     let block = node;
@@ -878,12 +878,12 @@ const expand = (ast, options = {}) => {
     return queue;
   };
-  return utils$3.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
@@ -939,41 +939,41 @@ var constants = {
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
 };
-const stringify$3 = stringify;
+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})`);
   }
@@ -1037,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;
     }
@@ -1046,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;
         }
@@ -1063,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) {
@@ -1080,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;
@@ -1132,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;
@@ -1157,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;
@@ -1178,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$3(block) }];
+        block.nodes = [open, { type: 'text', value: stringify$1(block) }];
       }
       push({ type: 'comma', value });
@@ -1194,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) {
@@ -1266,12 +1266,12 @@ const parse = (input, options = {}) => {
   return ast;
 };
-var parse_1 = parse;
+var parse_1$1 = parse$3;
-const stringify$4 = stringify;
-const compile$1 = compile_1;
-const expand$1 = expand_1;
-const parse$1 = parse_1;
+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.
@@ -1287,12 +1287,12 @@ const parse$1 = parse_1;
  * @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 {
@@ -1300,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) {
@@ -1323,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.
@@ -1339,11 +1339,11 @@ 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$4(braces.parse(input, options), options);
+    return stringify(braces$2.parse(input, options), options);
   }
-  return stringify$4(input, options);
+  return stringify(input, options);
 };
 /**
@@ -1361,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);
 };
 /**
@@ -1385,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) {
@@ -1421,25 +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 = require$$0$2;
+const path$2 = require$$0$2;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
@@ -1461,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,
@@ -1477,7 +1477,7 @@ const POSIX_CHARS = {
   NO_DOT_SLASH,
   NO_DOTS_SLASH,
   QMARK_NO_DOT,
-  STAR,
+  STAR: STAR$1,
   START_ANCHOR
 };
@@ -1505,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',
@@ -1522,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,
@@ -1592,7 +1592,7 @@ var constants$1 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
-  SEP: path.sep,
+  SEP: path$2.sep,
   /**
    * Create EXTGLOB_CHARS
@@ -1626,7 +1626,7 @@ const {
   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);
@@ -1683,24 +1683,24 @@ exports.wrapOutput = (input, state = {}, options = {}) => {
 };
 }(utils$4));
-const utils$5 = 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;
@@ -1728,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;
@@ -1770,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())) {
@@ -1786,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;
@@ -1803,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;
@@ -1815,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) {
@@ -1840,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;
       }
@@ -1856,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;
@@ -1869,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;
@@ -1902,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;
@@ -1910,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;
@@ -1929,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;
           }
@@ -1993,10 +1993,10 @@ const scan = (input, options) => {
   }
   if (opts.unescape === true) {
-    if (glob) glob = utils$5.removeBackslashes(glob);
+    if (glob) glob = utils$3.removeBackslashes(glob);
     if (base && backslashes === true) {
-      base = utils$5.removeBackslashes(base);
+      base = utils$3.removeBackslashes(base);
     }
   }
@@ -2063,18 +2063,18 @@ const scan = (input, options) => {
   return state;
 };
-var scan_1 = scan;
+var scan_1 = scan$1;
-const constants$2 = constants$1;
-const utils$6 = utils$4;
+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
@@ -2110,7 +2110,7 @@ const syntaxError = (type, char) => {
  * @return {Object}
  */
-const parse$2 = (input, options) => {
+const parse$1 = (input, options) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
@@ -2118,7 +2118,7 @@ const parse$2 = (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) {
@@ -2129,7 +2129,7 @@ const parse$2 = (input, options) => {
   const tokens = [bos];
   const capture = opts.capture ? '' : '?:';
-  const win32 = utils$6.isWindows(options);
+  const win32 = utils$2.isWindows(options);
   // create constants based on platform, for windows or posix
   const PLATFORM_CHARS = constants$2.globChars(win32);
@@ -2185,7 +2185,7 @@ const parse$2 = (input, options) => {
     tokens
   };
-  input = utils$6.removePrefix(input, state);
+  input = utils$2.removePrefix(input, state);
   len = input.length;
   const extglobs = [];
@@ -2365,7 +2365,7 @@ const parse$2 = (input, options) => {
       return state;
     }
-    state.output = utils$6.wrapOutput(output, state, options);
+    state.output = utils$2.wrapOutput(output, state, options);
     return state;
   }
@@ -2440,7 +2440,7 @@ const parse$2 = (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;
@@ -2478,7 +2478,7 @@ const parse$2 = (input, options) => {
      */
     if (state.quotes === 1 && value !== '"') {
-      value = utils$6.escapeRegex(value);
+      value = utils$2.escapeRegex(value);
       prev.value += value;
       append({ value });
       continue;
@@ -2568,11 +2568,11 @@ const parse$2 = (input, options) => {
       // when literal brackets are explicitly disabled
       // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$6.hasRegexChars(prevValue)) {
+      if (opts.literalBrackets === false || utils$2.hasRegexChars(prevValue)) {
         continue;
       }
-      const escaped = utils$6.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
@@ -2744,7 +2744,7 @@ const parse$2 = (input, options) => {
         const next = peek();
         let output = value;
-        if (next === '<' && !utils$6.supportsLookbehinds()) {
+        if (next === '<' && !utils$2.supportsLookbehinds()) {
           throw new Error('Node.js v10 or higher is required for regex lookbehinds');
         }
@@ -3004,19 +3004,19 @@ const parse$2 = (input, options) => {
   while (state.brackets > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$6.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$6.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$6.escapeLast(state.output, '{');
+    state.output = utils$2.escapeLast(state.output, '{');
     decrement('braces');
   }
@@ -3046,16 +3046,16 @@ const parse$2 = (input, options) => {
  * impact when none of the fast paths match.
  */
-parse$2.fastpaths = (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$6.isWindows(options);
+  const win32 = utils$2.isWindows(options);
   // create constants based on platform, for windows or posix
   const {
@@ -3123,7 +3123,7 @@ parse$2.fastpaths = (input, options) => {
     }
   };
-  const output = utils$6.removePrefix(input, state);
+  const output = utils$2.removePrefix(input, state);
   let source = create(output);
   if (source && opts.strictSlashes !== true) {
@@ -3133,14 +3133,14 @@ parse$2.fastpaths = (input, options) => {
   return source;
 };
-var parse_1$1 = parse$2;
+var parse_1 = parse$1;
 const path$1 = require$$0$2;
-const scan$1 = scan_1;
-const parse$3 = parse_1$1;
-const utils$7 = utils$4;
-const constants$3 = constants$1;
-const isObject$1 = val => val && typeof val === 'object' && !Array.isArray(val);
+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
@@ -3164,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);
@@ -3177,17 +3177,17 @@ 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');
   }
   const opts = options || {};
-  const posix = utils$7.isWindows(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;
@@ -3195,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') {
@@ -3249,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');
   }
@@ -3259,7 +3259,7 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
   }
   const opts = options || {};
-  const format = opts.format || (posix ? utils$7.toPosixSlashes : null);
+  const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
   let match = input === glob;
   let output = (match && format) ? format(input) : input;
@@ -3270,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);
     }
@@ -3293,8 +3293,8 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
-picomatch.matchBase = (input, glob, options, posix = utils$7.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+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));
 };
@@ -3315,7 +3315,7 @@ picomatch.matchBase = (input, glob, options, posix = utils$7.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
@@ -3331,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$3(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 });
 };
 /**
@@ -3363,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.
@@ -3382,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;
   }
@@ -3396,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;
   }
@@ -3404,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');
   }
@@ -3420,17 +3420,17 @@ picomatch.makeRe = (input, options, returnOutput = false, returnState = false) =
   }
   if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    output = parse$3.fastpaths(input, options);
+    output = parse.fastpaths(input, options);
   }
   if (output === undefined) {
-    parsed = parse$3(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);
 };
 /**
@@ -3450,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' : ''));
@@ -3465,20 +3465,20 @@ picomatch.toRegex = (source, options) => {
  * @return {Object}
  */
-picomatch.constants = constants$3;
+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$1 = require$$0$1;
+const util = require$$0$1;
 const braces$1 = braces_1;
-const picomatch$2 = picomatch$1;
-const utils$8 = utils$4;
+const picomatch$2 = picomatch$3;
+const utils = utils$4;
 const isEmptyString = val => typeof val === 'string' && (val === '' || val === './');
 /**
@@ -3662,7 +3662,7 @@ micromatch.not = (list, patterns, options = {}) => {
 micromatch.contains = (str, pattern, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util$1.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
   }
   if (Array.isArray(pattern)) {
@@ -3703,7 +3703,7 @@ micromatch.contains = (str, pattern, options) => {
  */
 micromatch.matchKeys = (obj, patterns, options) => {
-  if (!utils$8.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);
@@ -3808,7 +3808,7 @@ micromatch.every = (list, patterns, options) => {
 micromatch.all = (str, patterns, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util$1.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
   }
   return [].concat(patterns).every(p => picomatch$2(p, options)(str));
@@ -3834,9 +3834,9 @@ micromatch.all = (str, patterns, options) => {
  */
 micromatch.capture = (glob, input, options) => {
-  let posix = utils$8.isWindows(options);
+  let posix = utils.isWindows(options);
   let regex = picomatch$2.makeRe(String(glob), { ...options, capture: true });
-  let match = regex.exec(posix ? utils$8.toPosixSlashes(input) : input);
+  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
   if (match) {
     return match.slice(1).map(v => v === void 0 ? '' : v);
@@ -4144,16 +4144,16 @@ function mergeOutputOptions(config, overrides, warn) {
 var chokidar = {};
-const fs = fs$4;
+const fs$3 = fs$4;
 const { Readable } = require$$1;
-const sysPath = require$$0$2;
-const { promisify } = require$$0$1;
-const picomatch$3 = picomatch$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
@@ -4164,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';
@@ -4179,7 +4179,7 @@ const normalizeFilter = filter => {
   if (typeof filter === 'function') return filter;
   if (typeof filter === 'string') {
-    const glob = picomatch$3(filter.trim());
+    const glob = picomatch$1(filter.trim());
     return entry => glob(entry.basename);
   }
@@ -4188,10 +4188,10 @@ const normalizeFilter = filter => {
     const negative = [];
     for (const item of filter) {
       const trimmed = item.trim();
-      if (trimmed.charAt(0) === BANG) {
-        negative.push(picomatch$3(trimmed.slice(1)));
+      if (trimmed.charAt(0) === BANG$2) {
+        negative.push(picomatch$1(trimmed.slice(1)));
       } else {
-        positive.push(picomatch$3(trimmed));
+        positive.push(picomatch$1(trimmed));
       }
     }
@@ -4233,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;
@@ -4245,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 };
@@ -4306,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);
     }
@@ -4317,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);
@@ -4350,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}"`
             ));
@@ -4393,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;
@@ -4412,20 +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;
+var readdirp_1 = readdirp$1;
-var anymatch = {exports: {}};
+var anymatch$2 = {exports: {}};
 /*!
  * normalize-path <https://github.com/jonschlinkert/normalize-path>
@@ -4434,7 +4434,7 @@ var anymatch = {exports: {}};
  * 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');
   }
@@ -4463,10 +4463,10 @@ var normalizePath = function(path, stripTrailing) {
   return prefix + segs.join('/');
 };
-Object.defineProperty(anymatch.exports, "__esModule", { value: true });
+Object.defineProperty(anymatch$2.exports, "__esModule", { value: true });
-const picomatch$4 = picomatch$1;
-const normalizePath$1 = normalizePath;
+const picomatch = picomatch$3;
+const normalizePath$1 = normalizePath$2;
 /**
  * @typedef {(testString: string) => boolean} AnymatchFn
@@ -4475,7 +4475,7 @@ const normalizePath$1 = normalizePath;
  */
 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
@@ -4487,7 +4487,7 @@ const createPattern = (matcher, options) => {
     return matcher;
   }
   if (typeof matcher === 'string') {
-    const glob = picomatch$4(matcher, options);
+    const glob = picomatch(matcher, options);
     return (string) => matcher === string || glob(string);
   }
   if (matcher instanceof RegExp) {
@@ -4544,11 +4544,11 @@ const anymatch$1 = (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$4(item, opts));
+    .map(item => picomatch(item, opts));
   const patterns = mtchers.map(matcher => createPattern(matcher, opts));
   if (testString == null) {
@@ -4562,7 +4562,7 @@ const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
 };
 anymatch$1.default = anymatch$1;
-anymatch.exports = anymatch$1;
+anymatch$2.exports = anymatch$1;
 /*!
  * is-extglob <https://github.com/jonschlinkert/is-extglob>
@@ -4571,7 +4571,7 @@ anymatch.exports = anymatch$1;
  * Licensed under the MIT License.
  */
-var isExtglob = function isExtglob(str) {
+var isExtglob$1 = function isExtglob(str) {
   if (typeof str !== 'string' || str === '') {
     return false;
   }
@@ -4592,17 +4592,17 @@ var isExtglob = function isExtglob(str) {
  * Released under the MIT License.
  */
-var isExtglob$1 = isExtglob;
+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;
   }
-  if (isExtglob$1(str)) {
+  if (isExtglob(str)) {
     return true;
   }
@@ -4634,7 +4634,7 @@ var isGlob = function isGlob(str, options) {
   return false;
 };
-var isGlob$1 = isGlob;
+var isGlob$1 = isGlob$2;
 var pathPosixDirname = require$$0$2.posix.dirname;
 var isWin32 = require$$2.platform() === 'win32';
@@ -4649,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
@@ -4935,16 +4935,16 @@ var require$$0 = [
 	"zipx"
 ];
-var binaryExtensions = require$$0;
+var binaryExtensions$1 = require$$0;
-const path$2 = require$$0$2;
-const binaryExtensions$1 = binaryExtensions;
+const path = require$$0$2;
+const binaryExtensions = binaryExtensions$1;
-const extensions = new Set(binaryExtensions$1);
+const extensions = new Set(binaryExtensions);
-var isBinaryPath = filePath => extensions.has(path$2.extname(filePath).slice(1).toLowerCase());
+var isBinaryPath$1 = filePath => extensions.has(path.extname(filePath).slice(1).toLowerCase());
-var constants$4 = {};
+var constants = {};
 (function (exports) {
@@ -5009,40 +5009,40 @@ exports.IDENTITY_FN = val => val;
 exports.isWindows = platform === 'win32';
 exports.isMacos = platform === 'darwin';
 exports.isLinux = platform === 'linux';
-}(constants$4));
+}(constants));
-const fs$1 = fs$4;
-const sysPath$1 = require$$0$2;
-const { promisify: promisify$1 } = require$$0$1;
-const isBinaryPath$1 = isBinaryPath;
+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$4;
+  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$1.open);
-const stat$1 = promisify$1(fs$1.stat);
-const lstat$1 = promisify$1(fs$1.lstat);
-const close = promisify$1(fs$1.close);
-const fsrealpath = promisify$1(fs$1.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) => {
@@ -5122,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$1.resolve(path, evPath), KEY_LISTENERS, sysPath$1.join(path, evPath)
+        sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath)
       );
     }
   };
   try {
-    return fs$1.watch(path, options, handleEvent);
+    return fs$2.watch(path, options, handleEvent);
   } catch (error) {
     errHandler(error);
   }
@@ -5182,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);
@@ -5246,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$1.unwatchFile(fullPath);
+    fs$2.unwatchFile(fullPath);
     cont = undefined;
   }
@@ -5263,9 +5263,9 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
       listeners: listener,
       rawEmitters: rawEmitter,
       options,
-      watcher: fs$1.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) {
@@ -5284,7 +5284,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
     delFromSet(cont, KEY_RAW, rawEmitter);
     if (isEmptySet(cont.listeners)) {
       FsWatchFileInstances.delete(fullPath);
-      fs$1.unwatchFile(fullPath);
+      fs$2.unwatchFile(fullPath);
       cont.options = cont.watcher = undefined;
       Object.freeze(cont);
     }
@@ -5294,7 +5294,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 /**
  * @mixin
  */
-class NodeFsHandler {
+class NodeFsHandler$1 {
 /**
  * @param {import("../index").FSWatcher} fsW
@@ -5312,17 +5312,17 @@ constructor(fsW) {
  */
 _watchWithNodeFs(path, listener) {
   const opts = this.fsw.options;
-  const directory = sysPath$1.dirname(path);
-  const basename = sysPath$1.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$1.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) {
-    options.interval = opts.enableBinaryInterval && isBinaryPath$1(basename) ?
+    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
       opts.binaryInterval : opts.interval;
     closer = setFsWatchFileListener(path, absolutePath, options, {
       listener,
@@ -5349,8 +5349,8 @@ _handleFile(file, stats, initialAdd) {
   if (this.fsw.closed) {
     return;
   }
-  const dirname = sysPath$1.dirname(file);
-  const basename = sysPath$1.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;
@@ -5362,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);
@@ -5387,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;
     }
@@ -5397,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;
@@ -5427,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;
@@ -5448,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$1.join(directory, EMPTY_STR);
+  directory = sysPath$2.join(directory, EMPTY_STR$1);
   if (!wh.hasGlob) {
     throttler = this.fsw._throttle('readdir', directory, 1000);
@@ -5462,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$1.join(directory, item);
+    let path = sysPath$2.join(directory, item);
     current.add(item);
     if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
@@ -5486,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$1.join(dir, sysPath$1.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;
@@ -5512,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$1.resolve(directory, item)
+            fullPath: sysPath$2.resolve(directory, item)
           }));
       }).forEach((item) => {
         this.fsw._remove(directory, item);
@@ -5538,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$1.dirname(dir));
-  const tracked = parentDir.has(sysPath$1.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$1.basename(dir));
+  parentDir.add(sysPath$2.basename(dir));
   this.fsw._getWatchedDir(dir);
   let throttler;
   let closer;
@@ -5594,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$1.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);
@@ -5616,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$1.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$1.resolve(path), targetPath);
+        this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
       }
     } else {
       closer = this._handleFile(wh.watchPath, stats, initialAdd);
@@ -5644,15 +5644,15 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
 }
-var nodefsHandler = NodeFsHandler;
+var nodefsHandler = NodeFsHandler$1;
 var fseventsHandler = {exports: {}};
 var require$$3 = /*@__PURE__*/getAugmentedNamespace(fseventsImporter);
-const fs$2 = fs$4;
-const sysPath$2 = require$$0$2;
-const { promisify: promisify$2 } = require$$0$1;
+const fs$1 = fs$4;
+const sysPath$1 = require$$0$2;
+const { promisify: promisify$1 } = require$$0$1;
 let fsevents;
 try {
@@ -5677,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,
@@ -5694,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$4;
+} = constants;
 const Depth = (value) => isNaN(value) ? {} : {depth: value};
-const stat$2 = promisify$2(fs$2.stat);
-const lstat$2 = promisify$2(fs$2.lstat);
-const realpath$1 = promisify$2(fs$2.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
@@ -5754,8 +5754,8 @@ const createFSEventsInstance = (path, callback) => {
  * @returns {Function} closer
  */
 function setFSEventsListener(path, realPath, listener, rawEmitter) {
-  let watchPath = sysPath$2.extname(path) ? sysPath$2.dirname(path) : path;
-  const parentPath = sysPath$2.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
@@ -5766,14 +5766,14 @@ function setFSEventsListener(path, realPath, listener, rawEmitter) {
     watchPath = parentPath;
   }
-  const resolvedPath = sysPath$2.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$2.sep)
+      !fullPath.indexOf(resolvedPath + sysPath$1.sep)
     ) listener(fullPath, flags, info);
   };
@@ -5781,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$2.resolve(watchedPath) + sysPath$2.sep) === 0) {
+    if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
       watchPath = watchedPath;
       cont = FSEventsWatchers.get(watchPath);
       watchedParent = true;
@@ -5846,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$2.dirname(path)) !== root) i++;
+  while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
   return i;
 };
@@ -5861,7 +5861,7 @@ const sameTypes = (info, stats) => (
 /**
  * @mixin
  */
-class FsEventsHandler {
+class FsEventsHandler$1 {
 /**
  * @param {import('../index').FSWatcher} fsw
@@ -5890,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);
     }
   }
 }
@@ -5909,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)) {
@@ -5957,30 +5957,30 @@ _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
       opts.depth !== undefined &&
       calcDepth(fullPath, realPath) > opts.depth
     ) return;
-    const path = transform(sysPath$2.join(
-      watchPath, sysPath$2.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$2.dirname(path);
-    const item = sysPath$2.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);
@@ -6024,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();
@@ -6039,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$2.join(linkPath, path);
+        aliasedPath = sysPath$1.join(linkPath, path);
       }
       return transform(aliasedPath);
     }, false, curDepth);
@@ -6058,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$2.dirname(pp));
-  const base = sysPath$2.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);
@@ -6075,7 +6075,7 @@ initWatch(realPath, path, wh, processPath) {
   if (this.fsw.closed) return;
   const closer = this._watchWithFsEvents(
     wh.watchPath,
-    sysPath$2.resolve(realPath || wh.watchPath),
+    sysPath$1.resolve(realPath || wh.watchPath),
     processPath,
     wh.globFilter
   );
@@ -6095,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;
@@ -6118,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$2.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$2.resolve(wh.watchPath)) + 1;
+            undefined : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
           this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
         } else {
@@ -6154,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);
     }
@@ -6169,35 +6169,35 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
 }
-fseventsHandler.exports = FsEventsHandler;
+fseventsHandler.exports = FsEventsHandler$1;
 fseventsHandler.exports.canUse = canUse;
 const { EventEmitter } = require$$0$3;
-const fs$3 = fs$4;
-const sysPath$3 = require$$0$2;
-const { promisify: promisify$3 } = require$$0$1;
-const readdirp$1 = readdirp_1;
-const anymatch$2 = anymatch.exports.default;
-const globParent$1 = globParent;
-const isGlob$2 = isGlob;
-const braces$2 = braces_1;
-const normalizePath$2 = normalizePath;
-const NodeFsHandler$1 = nodefsHandler;
-const FsEventsHandler$1 = fseventsHandler.exports;
+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,
@@ -6207,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$4;
+} = constants;
-const stat$3 = promisify$3(fs$3.stat);
-const readdir$1 = promisify$3(fs$3.readdir);
+const stat = promisify(fs.stat);
+const readdir = promisify(fs.readdir);
 /**
  * @typedef {String} Path
@@ -6246,7 +6246,7 @@ const readdir$1 = promisify$3(fs$3.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)) {
@@ -6262,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}`);
   }
@@ -6288,21 +6288,21 @@ const toUnix = (string) => {
 // Our version of upath.normalize
 // TODO: this is not equal to path-normalize module - investigate why
-const normalizePathToUnix = (path) => toUnix(sysPath$3.normalize(toUnix(path)));
+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$3.isAbsolute(path) ? path : sysPath$3.join(cwd, path));
+  return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
 };
 const getAbsolutePath = (path, cwd) => {
-  if (sysPath$3.isAbsolute(path)) {
+  if (sysPath.isAbsolute(path)) {
     return path;
   }
-  if (path.startsWith(BANG$2)) {
-    return BANG$2 + sysPath$3.join(cwd, path.slice(1));
+  if (path.startsWith(BANG)) {
+    return BANG + sysPath.join(cwd, path.slice(1));
   }
-  return sysPath$3.join(cwd, path);
+  return sysPath.join(cwd, path);
 };
 const undef = (opts, key) => opts[key] === undefined;
@@ -6338,10 +6338,10 @@ class DirEntry {
     const dir = this.path;
     try {
-      await readdir$1(dir);
+      await readdir(dir);
     } catch (err) {
       if (this._removeWatcher) {
-        this._removeWatcher(sysPath$3.dirname(dir), sysPath$3.basename(dir));
+        this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
       }
     }
   }
@@ -6375,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$3.resolve(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$2(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();
@@ -6407,8 +6407,8 @@ class WatchHelper {
   }
   entryPath(entry) {
-    return sysPath$3.join(this.watchPath,
-      sysPath$3.relative(this.watchPath, this.checkGlobSymlink(entry))
+    return sysPath.join(this.watchPath,
+      sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
     );
   }
@@ -6416,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) &&
@@ -6426,9 +6426,9 @@ class WatchHelper {
   getDirParts(path) {
     if (!this.hasGlob) return [];
     const parts = [];
-    const expandedPath = path.includes(BRACE_START$1) ? braces$2.expand(path) : [path];
+    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
     expandedPath.forEach((path) => {
-      parts.push(sysPath$3.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+      parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
     });
     return parts;
   }
@@ -6440,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$2(part, entryParts[0][i], ANYMATCH_OPTS);
+          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
         });
       });
     }
@@ -6493,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$1.canUse();
+  const canUseFsEvents = FsEventsHandler.canUse();
   if (!canUseFsEvents) opts.useFsEvents = false;
   // Use polling on Mac if not using fsevents.
@@ -6535,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));
@@ -6553,9 +6553,9 @@ constructor(_opts) {
   // Initialize with proper watcher.
   if (opts.useFsEvents) {
-    this._fsEventsHandler = new FsEventsHandler$1(this);
+    this._fsEventsHandler = new FsEventsHandler(this);
   } else {
-    this._nodeFsHandler = new NodeFsHandler$1(this);
+    this._nodeFsHandler = new NodeFsHandler(this);
   }
   // You’re frozen when your heart’s not open.
@@ -6580,16 +6580,16 @@ add(paths_, _origAdd, _internal) {
       const absPath = getAbsolutePath(path, cwd);
       // Check `path` instead of `absPath` because the cwd portion can't be a glob
-      if (disableGlobbing || !isGlob$2(path)) {
+      if (disableGlobbing || !isGlob(path)) {
         return absPath;
       }
-      return normalizePath$2(absPath);
+      return normalizePath(absPath);
     });
   }
   // 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;
     }
@@ -6621,7 +6621,7 @@ add(paths_, _origAdd, _internal) {
     ).then(results => {
       if (this.closed) return;
       results.filter(item => item).forEach(item => {
-        this.add(sysPath$3.dirname(item), sysPath$3.basename(_origAdd || item));
+        this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
       });
     });
   }
@@ -6641,9 +6641,9 @@ unwatch(paths_) {
   paths.forEach((path) => {
     // convert to absolute path unless relative path already matches
-    if (!sysPath$3.isAbsolute(path) && !this._closers.has(path)) {
-      if (cwd) path = sysPath$3.join(cwd, path);
-      path = sysPath$3.resolve(path);
+    if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+      if (cwd) path = sysPath.join(cwd, path);
+      path = sysPath.resolve(path);
     }
     this._closePath(path);
@@ -6696,7 +6696,7 @@ close() {
 getWatched() {
   const watchList = {};
   this._watched.forEach((entry, dir) => {
-    const key = this.options.cwd ? sysPath$3.relative(this.options.cwd, dir) : dir;
+    const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
     watchList[key || ONE_DOT] = entry.getChildren().sort();
   });
   return watchList;
@@ -6704,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
@@ -6724,8 +6724,8 @@ async _emit(event, path, val1, val2, val3) {
   if (this.closed) return;
   const opts = this.options;
-  if (isWindows$1) path = sysPath$3.normalize(path);
-  if (opts.cwd) path = sysPath$3.relative(opts.cwd, path);
+  if (isWindows) path = sysPath.normalize(path);
+  if (opts.cwd) path = sysPath.relative(opts.cwd, path);
   /** @type Array<any> */
   const args = [event, path];
   if (val3 !== undefined) args.push(val1, val2, val3);
@@ -6740,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) => {
@@ -6751,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) {
@@ -6778,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$3.join(opts.cwd, path) : path;
+    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;
@@ -6810,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;
 }
@@ -6868,14 +6868,14 @@ _awaitWriteFinish(path, threshold, event, awfEmit) {
   let timeoutHandler;
   let fullPath = path;
-  if (this.options.cwd && !sysPath$3.isAbsolute(path)) {
-    fullPath = sysPath$3.join(this.options.cwd, path);
+  if (this.options.cwd && !sysPath.isAbsolute(path)) {
+    fullPath = sysPath.join(this.options.cwd, path);
   }
   const now = new Date();
   const awaitWriteFinish = (prevStat) => {
-    fs$3.stat(fullPath, (err, curStat) => {
+    fs.stat(fullPath, (err, curStat) => {
       if (err || !this._pendingWrites.has(path)) {
         if (err && err.code !== 'ENOENT') awfEmit(err);
         return;
@@ -6935,11 +6935,11 @@ _isIgnored(path, stats) {
     const ign = this.options.ignored;
     const ignored = ign && ign.map(normalizeIgnored(cwd));
-    const paths = arrify$1(ignored)
-      .filter((path) => typeof path === STRING_TYPE && !isGlob$2(path))
+    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$2(list, undefined, ANYMATCH_OPTS);
+    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
   }
   return this._userIgnored([path, stats]);
@@ -6956,7 +6956,7 @@ _isntIgnored(path, stat) {
  * @returns {WatchHelper} object containing helpers for this path
  */
 _getWatchHelpers(path, depth) {
-  const watchPath = depth || this.options.disableGlobbing || !isGlob$2(path) ? path : globParent$1(path);
+  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
   const follow = this.options.followSymlinks;
   return new WatchHelper(path, watchPath, follow, this);
@@ -6972,7 +6972,7 @@ _getWatchHelpers(path, depth) {
  */
 _getWatchedDir(directory) {
   if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
-  const dir = sysPath$3.resolve(directory);
+  const dir = sysPath.resolve(directory);
   if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
   return this._watched.get(dir);
 }
@@ -7008,8 +7008,8 @@ _remove(directory, item, isDirectory) {
   // if what is being deleted is a directory, get that directory's paths
   // for recursive deleting and cleaning of watched object
   // if it is not a directory, nestedDirectoryChildren will be empty array
-  const path = sysPath$3.join(directory, item);
-  const fullPath = sysPath$3.resolve(path);
+  const path = sysPath.join(directory, item);
+  const fullPath = sysPath.resolve(path);
   isDirectory = isDirectory != null
     ? isDirectory
     : this._watched.has(path) || this._watched.has(fullPath);
@@ -7047,17 +7047,17 @@ _remove(directory, item, isDirectory) {
   // If we wait for this file to be fully written, cancel the wait.
   let relPath = path;
-  if (this.options.cwd) relPath = sysPath$3.relative(this.options.cwd, path);
+  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
@@ -7072,8 +7072,8 @@ _remove(directory, item, isDirectory) {
  */
 _closePath(path) {
   this._closeFile(path);
-  const dir = sysPath$3.dirname(path);
-  this._getWatchedDir(dir).remove(sysPath$3.basename(path));
+  const dir = sysPath.dirname(path);
+  this._getWatchedDir(dir).remove(sysPath.basename(path));
 }
 /**
@@ -7105,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;