rollup 2.38.4 → 2.40.0

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.38.4
-	Tue, 02 Feb 2021 05:54:38 GMT - commit 991bb98fad1f3f76226bfe6243fd6cc45a19a39b
+	Rollup.js v2.40.0
+	Fri, 26 Feb 2021 14:39:44 GMT - commit 0a0958ff926554abe9916178f56762ba71301ddd
 
 
 	https://github.com/rollup/rollup
@@ -11,14 +11,16 @@
 'use strict';
 
 var require$$0$2 = require('events');
-var fs = require('fs');
-var sysPath = require('path');
-var util = require('util');
-var require$$0$1 = require('stream');
+var fs$4 = require('fs');
+var path$3 = require('path');
+var require$$0$1 = require('util');
+var require$$1 = require('stream');
+var require$$2 = require('os');
 var rollup = require('./rollup.js');
-var require$$1$1 = require('os');
 
-var utils = rollup.createCommonjsModule(function (module, exports) {
+var utils$7 = {};
+
+(function (exports) {
 
 exports.isInteger = num => {
   if (typeof num === 'number') {
@@ -130,16 +132,18 @@ exports.flatten = (...args) => {
   flat(args);
   return result;
 };
-});
+}(utils$7));
+
+const utils$6 = utils$7;
 
-var stringify = (ast, options = {}) => {
+var stringify$4 = (ast, options = {}) => {
   let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+    let invalidBlock = options.escapeInvalid && utils$6.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let output = '';
 
     if (node.value) {
-      if ((invalidBlock || invalidNode) && utils.isOpenOrClose(node)) {
+      if ((invalidBlock || invalidNode) && utils$6.isOpenOrClose(node)) {
         return '\\' + node.value;
       }
       return node.value;
@@ -167,7 +171,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;
   }
@@ -184,10 +188,10 @@ var isNumber = function(num) {
  * Released under the MIT License.
  */
 
+const isNumber$1 = isNumber$2;
 
-
-const toRegexRange = (min, max, options) => {
-  if (isNumber(min) === false) {
+const toRegexRange$1 = (min, max, options) => {
+  if (isNumber$1(min) === false) {
     throw new TypeError('toRegexRange: expected the first argument to be a number');
   }
 
@@ -195,7 +199,7 @@ const toRegexRange = (min, max, options) => {
     return String(min);
   }
 
-  if (isNumber(max) === false) {
+  if (isNumber$1(max) === false) {
     throw new TypeError('toRegexRange: expected the second argument to be a number.');
   }
 
@@ -210,8 +214,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);
@@ -258,7 +262,7 @@ const toRegexRange = (min, max, options) => {
     state.result = `(?:${state.result})`;
   }
 
-  toRegexRange.cache[cacheKey] = state;
+  toRegexRange$1.cache[cacheKey] = state;
   return state.result;
 };
 
@@ -455,14 +459,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>
@@ -471,10 +475,10 @@ var toRegexRange_1 = toRegexRange;
  * Licensed under the MIT License.
  */
 
+const util = 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);
@@ -484,7 +488,7 @@ const isValidValue = value => {
   return typeof value === 'number' || (typeof value === 'string' && value !== '');
 };
 
-const isNumber$1 = num => Number.isInteger(+num);
+const isNumber = num => Number.isInteger(+num);
 
 const zeros = input => {
   let value = `${input}`;
@@ -495,7 +499,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;
   }
@@ -556,7 +560,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);
@@ -572,7 +576,7 @@ 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) => {
@@ -612,7 +616,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) {
@@ -644,7 +648,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
 };
 
 const fillLetters = (start, end, step = 1, options = {}) => {
-  if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
+  if ((!isNumber(start) && start.length > 1) || (!isNumber(end) && end.length > 1)) {
     return invalidRange(start, end, options);
   }
 
@@ -677,7 +681,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];
   }
@@ -687,34 +691,37 @@ const fill = (start, end, step, options = {}) => {
   }
 
   if (typeof step === 'function') {
-    return fill(start, end, 1, { transform: step });
+    return fill$2(start, end, 1, { transform: step });
   }
 
-  if (isObject(step)) {
-    return fill(start, end, 0, step);
+  if (isObject$1(step)) {
+    return fill$2(start, end, 0, step);
   }
 
   let opts = { ...options };
   if (opts.capture === true) opts.wrap = true;
   step = step || opts.step || 1;
 
-  if (!isNumber$1(step)) {
-    if (step != null && !isObject(step)) return invalidStep(step, opts);
-    return fill(start, end, 1, step);
+  if (!isNumber(step)) {
+    if (step != null && !isObject$1(step)) return invalidStep(step, opts);
+    return fill$2(start, end, 1, step);
   }
 
-  if (isNumber$1(start) && isNumber$1(end)) {
+  if (isNumber(start) && isNumber(end)) {
     return fillNumbers(start, end, step, opts);
   }
 
   return fillLetters(start, end, Math.max(Math.abs(step), 1), opts);
 };
 
-var fillRange = fill;
+var fillRange = fill$2;
+
+const fill$1 = fillRange;
+const utils$5 = utils$7;
 
-const compile = (ast, options = {}) => {
+const compile$1 = (ast, options = {}) => {
   let walk = (node, parent = {}) => {
-    let invalidBlock = utils.isInvalidBrace(parent);
+    let invalidBlock = utils$5.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let invalid = invalidBlock === true || invalidNode === true;
     let prefix = options.escapeInvalid === true ? '\\' : '';
@@ -744,8 +751,8 @@ const compile = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
-      let range = fillRange(...args, { ...options, wrap: false, toRegex: true });
+      let args = utils$5.reduce(node.nodes);
+      let range = fill$1(...args, { ...options, wrap: false, toRegex: true });
 
       if (range.length !== 0) {
         return args.length > 1 && range.length > 1 ? `(${range})` : range;
@@ -763,7 +770,11 @@ const compile = (ast, options = {}) => {
   return walk(ast);
 };
 
-var compile_1 = compile;
+var compile_1 = compile$1;
+
+const fill = fillRange;
+const stringify$2 = stringify$4;
+const utils$4 = utils$7;
 
 const append = (queue = '', stash = '', enclose = false) => {
   let result = [];
@@ -773,7 +784,7 @@ const append = (queue = '', stash = '', enclose = false) => {
 
   if (!stash.length) return queue;
   if (!queue.length) {
-    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+    return enclose ? utils$4.flatten(stash).map(ele => `{${ele}}`) : stash;
   }
 
   for (let item of queue) {
@@ -788,10 +799,10 @@ const append = (queue = '', stash = '', enclose = false) => {
       }
     }
   }
-  return utils.flatten(result);
+  return utils$4.flatten(result);
 };
 
-const expand = (ast, options = {}) => {
+const expand$1 = (ast, options = {}) => {
   let rangeLimit = options.rangeLimit === void 0 ? 1000 : options.rangeLimit;
 
   let walk = (node, parent = {}) => {
@@ -806,7 +817,7 @@ const expand = (ast, options = {}) => {
     }
 
     if (node.invalid || node.dollar) {
-      q.push(append(q.pop(), stringify(node, options)));
+      q.push(append(q.pop(), stringify$2(node, options)));
       return;
     }
 
@@ -816,15 +827,15 @@ const expand = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
+      let args = utils$4.reduce(node.nodes);
 
-      if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+      if (utils$4.exceedsLimit(...args, options.step, rangeLimit)) {
         throw new RangeError('expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.');
       }
 
-      let range = fillRange(...args, options);
+      let range = fill(...args, options);
       if (range.length === 0) {
-        range = stringify(node, options);
+        range = stringify$2(node, options);
       }
 
       q.push(append(q.pop(), range));
@@ -832,7 +843,7 @@ const expand = (ast, options = {}) => {
       return;
     }
 
-    let enclose = utils.encloseBrace(node);
+    let enclose = utils$4.encloseBrace(node);
     let queue = node.queue;
     let block = node;
 
@@ -868,12 +879,12 @@ const expand = (ast, options = {}) => {
     return queue;
   };
 
-  return utils.flatten(walk(ast));
+  return utils$4.flatten(walk(ast));
 };
 
-var expand_1 = expand;
+var expand_1 = expand$1;
 
-var constants = {
+var constants$4 = {
   MAX_LENGTH: 1024 * 64,
 
   // Digits
@@ -929,39 +940,41 @@ var constants = {
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
 };
 
+const stringify$1 = stringify$4;
+
 /**
  * Constants
  */
 
 const {
-  MAX_LENGTH,
+  MAX_LENGTH: MAX_LENGTH$1,
   CHAR_BACKSLASH, /* \ */
   CHAR_BACKTICK, /* ` */
-  CHAR_COMMA, /* , */
-  CHAR_DOT, /* . */
-  CHAR_LEFT_PARENTHESES, /* ( */
-  CHAR_RIGHT_PARENTHESES, /* ) */
-  CHAR_LEFT_CURLY_BRACE, /* { */
-  CHAR_RIGHT_CURLY_BRACE, /* } */
-  CHAR_LEFT_SQUARE_BRACKET, /* [ */
-  CHAR_RIGHT_SQUARE_BRACKET, /* ] */
+  CHAR_COMMA: CHAR_COMMA$1, /* , */
+  CHAR_DOT: CHAR_DOT$1, /* . */
+  CHAR_LEFT_PARENTHESES: CHAR_LEFT_PARENTHESES$1, /* ( */
+  CHAR_RIGHT_PARENTHESES: CHAR_RIGHT_PARENTHESES$1, /* ) */
+  CHAR_LEFT_CURLY_BRACE: CHAR_LEFT_CURLY_BRACE$1, /* { */
+  CHAR_RIGHT_CURLY_BRACE: CHAR_RIGHT_CURLY_BRACE$1, /* } */
+  CHAR_LEFT_SQUARE_BRACKET: CHAR_LEFT_SQUARE_BRACKET$1, /* [ */
+  CHAR_RIGHT_SQUARE_BRACKET: CHAR_RIGHT_SQUARE_BRACKET$1, /* ] */
   CHAR_DOUBLE_QUOTE, /* " */
   CHAR_SINGLE_QUOTE, /* ' */
   CHAR_NO_BREAK_SPACE,
   CHAR_ZERO_WIDTH_NOBREAK_SPACE
-} = constants;
+} = constants$4;
 
 /**
  * parse
  */
 
-const parse = (input, options = {}) => {
+const parse$3 = (input, options = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
 
   let opts = options || {};
-  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+  let max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
   if (input.length > max) {
     throw new SyntaxError(`Input length (${input.length}), exceeds max characters (${max})`);
   }
@@ -1025,7 +1038,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;
     }
@@ -1034,14 +1047,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;
         }
@@ -1051,7 +1064,7 @@ const parse = (input, options = {}) => {
           continue;
         }
 
-        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+        if (next === CHAR_RIGHT_SQUARE_BRACKET$1) {
           brackets--;
 
           if (brackets === 0) {
@@ -1068,14 +1081,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;
@@ -1120,7 +1133,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;
@@ -1145,7 +1158,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;
@@ -1166,11 +1179,11 @@ const parse = (input, options = {}) => {
      * Comma: ','
      */
 
-    if (value === CHAR_COMMA && depth > 0) {
+    if (value === CHAR_COMMA$1 && depth > 0) {
       if (block.ranges > 0) {
         block.ranges = 0;
         let open = block.nodes.shift();
-        block.nodes = [open, { type: 'text', value: stringify(block) }];
+        block.nodes = [open, { type: 'text', value: stringify$1(block) }];
       }
 
       push({ type: 'comma', value });
@@ -1182,7 +1195,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) {
@@ -1254,7 +1267,12 @@ const parse = (input, options = {}) => {
   return ast;
 };
 
-var parse_1 = parse;
+var parse_1$1 = parse$3;
+
+const stringify = stringify$4;
+const compile = compile_1;
+const expand = expand_1;
+const parse$2 = parse_1$1;
 
 /**
  * Expand the given pattern or create a regex-compatible string.
@@ -1270,12 +1288,12 @@ var parse_1 = parse;
  * @api public
  */
 
-const braces = (input, options = {}) => {
+const braces$1 = (input, options = {}) => {
   let output = [];
 
   if (Array.isArray(input)) {
     for (let pattern of input) {
-      let result = braces.create(pattern, options);
+      let result = braces$1.create(pattern, options);
       if (Array.isArray(result)) {
         output.push(...result);
       } else {
@@ -1283,7 +1301,7 @@ const braces = (input, options = {}) => {
       }
     }
   } else {
-    output = [].concat(braces.create(input, options));
+    output = [].concat(braces$1.create(input, options));
   }
 
   if (options && options.expand === true && options.nodupes === true) {
@@ -1306,7 +1324,7 @@ const braces = (input, options = {}) => {
  * @api public
  */
 
-braces.parse = (input, options = {}) => parse_1(input, options);
+braces$1.parse = (input, options = {}) => parse$2(input, options);
 
 /**
  * Creates a braces string from an AST, or an AST node.
@@ -1322,9 +1340,9 @@ braces.parse = (input, options = {}) => parse_1(input, options);
  * @api public
  */
 
-braces.stringify = (input, options = {}) => {
+braces$1.stringify = (input, options = {}) => {
   if (typeof input === 'string') {
-    return stringify(braces.parse(input, options), options);
+    return stringify(braces$1.parse(input, options), options);
   }
   return stringify(input, options);
 };
@@ -1344,11 +1362,11 @@ braces.stringify = (input, options = {}) => {
  * @api public
  */
 
-braces.compile = (input, options = {}) => {
+braces$1.compile = (input, options = {}) => {
   if (typeof input === 'string') {
-    input = braces.parse(input, options);
+    input = braces$1.parse(input, options);
   }
-  return compile_1(input, options);
+  return compile(input, options);
 };
 
 /**
@@ -1368,12 +1386,12 @@ braces.compile = (input, options = {}) => {
  * @api public
  */
 
-braces.expand = (input, options = {}) => {
+braces$1.expand = (input, options = {}) => {
   if (typeof input === 'string') {
-    input = braces.parse(input, options);
+    input = braces$1.parse(input, options);
   }
 
-  let result = expand_1(input, options);
+  let result = expand(input, options);
 
   // filter out empty strings if specified
   if (options.noempty === true) {
@@ -1404,22 +1422,25 @@ braces.expand = (input, options = {}) => {
  * @api public
  */
 
-braces.create = (input, options = {}) => {
+braces$1.create = (input, options = {}) => {
   if (input === '' || input.length < 3) {
     return [input];
   }
 
  return options.expand !== true
-    ? braces.compile(input, options)
-    : braces.expand(input, options);
+    ? braces$1.compile(input, options)
+    : braces$1.expand(input, options);
 };
 
 /**
  * Expose "braces"
  */
 
-var braces_1 = braces;
+var braces_1 = braces$1;
 
+var utils$3 = {};
+
+const path$2 = path$3;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -1441,7 +1462,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,
@@ -1457,7 +1478,7 @@ const POSIX_CHARS = {
   NO_DOT_SLASH,
   NO_DOTS_SLASH,
   QMARK_NO_DOT,
-  STAR,
+  STAR: STAR$1,
   START_ANCHOR
 };
 
@@ -1485,7 +1506,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',
@@ -1502,9 +1523,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,
@@ -1572,7 +1593,7 @@ var constants$1 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-  SEP: sysPath.sep,
+  SEP: path$2.sep,
 
   /**
    * Create EXTGLOB_CHARS
@@ -1597,16 +1618,16 @@ var constants$1 = {
   }
 };
 
-var utils$1 = rollup.createCommonjsModule(function (module, exports) {
-
+(function (exports) {
 
+const path = path$3;
 const win32 = process.platform === 'win32';
 const {
   REGEX_BACKSLASH,
   REGEX_REMOVE_BACKSLASH,
   REGEX_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_GLOBAL
-} = constants$1;
+} = constants$3;
 
 exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
@@ -1632,7 +1653,7 @@ exports.isWindows = options => {
   if (options && typeof options.windows === 'boolean') {
     return options.windows;
   }
-  return win32 === true || sysPath.sep === '\\';
+  return win32 === true || path.sep === '\\';
 };
 
 exports.escapeLast = (input, char, lastIdx) => {
@@ -1661,25 +1682,26 @@ exports.wrapOutput = (input, state = {}, options = {}) => {
   }
   return output;
 };
-});
+}(utils$3));
 
+const utils$2 = utils$3;
 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;
@@ -1707,7 +1729,7 @@ const depth = token => {
  * @api public
  */
 
-const scan = (input, options) => {
+const scan$1 = (input, options) => {
   const opts = options || {};
 
   const length = input.length - 1;
@@ -1749,13 +1771,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())) {
@@ -1765,12 +1787,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;
@@ -1782,7 +1804,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;
@@ -1794,7 +1816,7 @@ const scan = (input, options) => {
           break;
         }
 
-        if (code === CHAR_RIGHT_CURLY_BRACE$1) {
+        if (code === CHAR_RIGHT_CURLY_BRACE) {
           braces--;
 
           if (braces === 0) {
@@ -1819,7 +1841,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;
       }
@@ -1835,7 +1857,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;
@@ -1848,7 +1870,7 @@ const scan = (input, options) => {
               continue;
             }
 
-            if (code === CHAR_RIGHT_PARENTHESES$1) {
+            if (code === CHAR_RIGHT_PARENTHESES) {
               isGlob = token.isGlob = true;
               finished = true;
               break;
@@ -1881,7 +1903,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;
@@ -1889,7 +1911,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;
@@ -1908,18 +1930,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;
           }
@@ -1972,10 +1994,10 @@ const scan = (input, options) => {
   }
 
   if (opts.unescape === true) {
-    if (glob) glob = utils$1.removeBackslashes(glob);
+    if (glob) glob = utils$2.removeBackslashes(glob);
 
     if (base && backslashes === true) {
-      base = utils$1.removeBackslashes(base);
+      base = utils$2.removeBackslashes(base);
     }
   }
 
@@ -2042,19 +2064,22 @@ const scan = (input, options) => {
   return state;
 };
 
-var scan_1 = scan;
+var scan_1 = scan$1;
+
+const constants$2 = constants$3;
+const utils$1 = utils$3;
 
 /**
  * Constants
  */
 
 const {
-  MAX_LENGTH: MAX_LENGTH$1,
-  POSIX_REGEX_SOURCE: POSIX_REGEX_SOURCE$1,
+  MAX_LENGTH,
+  POSIX_REGEX_SOURCE,
   REGEX_NON_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_BACKREF,
   REPLACEMENTS
-} = constants$1;
+} = constants$2;
 
 /**
  * Helpers
@@ -2094,7 +2119,7 @@ const parse$1 = (input, options) => {
   input = REPLACEMENTS[input] || input;
 
   const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
 
   let len = input.length;
   if (len > max) {
@@ -2108,8 +2133,8 @@ const parse$1 = (input, options) => {
   const win32 = utils$1.isWindows(options);
 
   // create constants based on platform, for windows or posix
-  const PLATFORM_CHARS = constants$1.globChars(win32);
-  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
+  const PLATFORM_CHARS = constants$2.globChars(win32);
+  const EXTGLOB_CHARS = constants$2.extglobChars(PLATFORM_CHARS);
 
   const {
     DOT_LITERAL,
@@ -2416,7 +2441,7 @@ const parse$1 = (input, options) => {
             const idx = prev.value.lastIndexOf('[');
             const pre = prev.value.slice(0, idx);
             const rest = prev.value.slice(idx + 2);
-            const posix = POSIX_REGEX_SOURCE$1[rest];
+            const posix = POSIX_REGEX_SOURCE[rest];
             if (posix) {
               prev.value = pre + posix;
               state.backtrack = true;
@@ -3024,7 +3049,7 @@ const parse$1 = (input, options) => {
 
 parse$1.fastpaths = (input, options) => {
   const opts = { ...options };
-  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
+  const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
   const len = input.length;
   if (len > max) {
     throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
@@ -3044,7 +3069,7 @@ parse$1.fastpaths = (input, options) => {
     NO_DOTS_SLASH,
     STAR,
     START_ANCHOR
-  } = constants$1.globChars(win32);
+  } = constants$2.globChars(win32);
 
   const nodot = opts.dot ? NO_DOTS : NO_DOT;
   const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
@@ -3109,9 +3134,14 @@ parse$1.fastpaths = (input, options) => {
   return source;
 };
 
-var parse_1$1 = parse$1;
+var parse_1 = parse$1;
 
-const isObject$1 = val => val && typeof val === 'object' && !Array.isArray(val);
+const path$1 = path$3;
+const scan = scan_1;
+const parse = parse_1;
+const utils = utils$3;
+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
@@ -3135,9 +3165,9 @@ const isObject$1 = val => val && typeof val === 'object' && !Array.isArray(val);
  * @api public
  */
 
-const picomatch = (glob, options, returnState = false) => {
+const picomatch$3 = (glob, options, returnState = false) => {
   if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch(input, options, returnState));
+    const fns = glob.map(input => picomatch$3(input, options, returnState));
     const arrayMatcher = str => {
       for (const isMatch of fns) {
         const state = isMatch(str);
@@ -3148,17 +3178,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$1.isWindows(options);
+  const posix = utils.isWindows(options);
   const regex = isState
-    ? picomatch.compileRe(glob, options)
-    : picomatch.makeRe(glob, options, false, true);
+    ? picomatch$3.compileRe(glob, options)
+    : picomatch$3.makeRe(glob, options, false, true);
 
   const state = regex.state;
   delete regex.state;
@@ -3166,11 +3196,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$3(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$3.test(input, regex, options, { glob, posix });
     const result = { glob, state, regex, posix, input, output, match, isMatch };
 
     if (typeof opts.onResult === 'function') {
@@ -3220,7 +3250,7 @@ const picomatch = (glob, options, returnState = false) => {
  * @api public
  */
 
-picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+picomatch$3.test = (input, regex, options, { glob, posix } = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected input to be a string');
   }
@@ -3230,7 +3260,7 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
   }
 
   const opts = options || {};
-  const format = opts.format || (posix ? utils$1.toPosixSlashes : null);
+  const format = opts.format || (posix ? utils.toPosixSlashes : null);
   let match = input === glob;
   let output = (match && format) ? format(input) : input;
 
@@ -3241,7 +3271,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$3.matchBase(input, regex, options, posix);
     } else {
       match = regex.exec(output);
     }
@@ -3264,9 +3294,9 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(sysPath.basename(input));
+picomatch$3.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$3.makeRe(glob, options);
+  return regex.test(path$1.basename(input));
 };
 
 /**
@@ -3286,7 +3316,7 @@ picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options))
  * @api public
  */
 
-picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+picomatch$3.isMatch = (str, patterns, options) => picomatch$3(patterns, options)(str);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -3302,9 +3332,9 @@ picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str
  * @api public
  */
 
-picomatch.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
-  return parse_1$1(pattern, { ...options, fastpaths: false });
+picomatch$3.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$3.parse(p, options));
+  return parse(pattern, { ...options, fastpaths: false });
 };
 
 /**
@@ -3334,7 +3364,7 @@ picomatch.parse = (pattern, options) => {
  * @api public
  */
 
-picomatch.scan = (input, options) => scan_1(input, options);
+picomatch$3.scan = (input, options) => scan(input, options);
 
 /**
  * Create a regular expression from a parsed glob pattern.
@@ -3353,7 +3383,7 @@ picomatch.scan = (input, options) => scan_1(input, options);
  * @api public
  */
 
-picomatch.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
+picomatch$3.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
   if (returnOutput === true) {
     return parsed.output;
   }
@@ -3367,7 +3397,7 @@ picomatch.compileRe = (parsed, options, returnOutput = false, returnState = fals
     source = `^(?!${source}).*$`;
   }
 
-  const regex = picomatch.toRegex(source, options);
+  const regex = picomatch$3.toRegex(source, options);
   if (returnState === true) {
     regex.state = parsed;
   }
@@ -3375,7 +3405,7 @@ picomatch.compileRe = (parsed, options, returnOutput = false, returnState = fals
   return regex;
 };
 
-picomatch.makeRe = (input, options, returnOutput = false, returnState = false) => {
+picomatch$3.makeRe = (input, options, returnOutput = false, returnState = false) => {
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
@@ -3391,17 +3421,17 @@ picomatch.makeRe = (input, options, returnOutput = false, returnState = false) =
   }
 
   if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    output = parse_1$1.fastpaths(input, options);
+    output = parse.fastpaths(input, options);
   }
 
   if (output === undefined) {
-    parsed = parse_1$1(input, options);
+    parsed = parse(input, options);
     parsed.prefix = prefix + (parsed.prefix || '');
   } else {
     parsed.output = output;
   }
 
-  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+  return picomatch$3.compileRe(parsed, options, returnOutput, returnState);
 };
 
 /**
@@ -3421,7 +3451,7 @@ picomatch.makeRe = (input, options, returnOutput = false, returnState = false) =
  * @api public
  */
 
-picomatch.toRegex = (source, options) => {
+picomatch$3.toRegex = (source, options) => {
   try {
     const opts = options || {};
     return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
@@ -3436,25 +3466,28 @@ picomatch.toRegex = (source, options) => {
  * @return {Object}
  */
 
-picomatch.constants = constants$1;
+picomatch$3.constants = constants$1;
 
 /**
  * Expose "picomatch"
  */
 
-var picomatch_1 = picomatch;
+var picomatch_1 = picomatch$3;
 
-var picomatch$1 = picomatch_1;
+var picomatch$2 = picomatch_1;
 
-const { Readable } = require$$0$1;
+var chokidar = {};
 
-const { promisify } = util;
+const fs$3 = fs$4;
+const { Readable } = require$$1;
+const sysPath$3 = path$3;
+const { promisify: promisify$3 } = require$$0$1;
+const picomatch$1 = picomatch$2;
 
-
-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
@@ -3465,7 +3498,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';
@@ -3489,7 +3522,7 @@ const normalizeFilter = filter => {
     const negative = [];
     for (const item of filter) {
       const trimmed = item.trim();
-      if (trimmed.charAt(0) === BANG) {
+      if (trimmed.charAt(0) === BANG$2) {
         negative.push(picomatch$1(trimmed.slice(1)));
       } else {
         positive.push(picomatch$1(trimmed));
@@ -3534,9 +3567,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;
@@ -3546,8 +3579,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 };
 
@@ -3607,7 +3640,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);
     }
@@ -3618,8 +3651,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);
@@ -3651,14 +3684,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}"`
             ));
@@ -3694,7 +3727,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;
@@ -3713,18 +3746,20 @@ const readdirp = (root, options = {}) => {
 const readdirpPromise = (root, options = {}) => {
   return new Promise((resolve, reject) => {
     const files = [];
-    readdirp(root, options)
+    readdirp$1(root, options)
       .on('data', entry => files.push(entry))
       .on('end', () => resolve(files))
       .on('error', error => reject(error));
   });
 };
 
-readdirp.promise = readdirpPromise;
-readdirp.ReaddirpStream = ReaddirpStream;
-readdirp.default = readdirp;
+readdirp$1.promise = readdirpPromise;
+readdirp$1.ReaddirpStream = ReaddirpStream;
+readdirp$1.default = readdirp$1;
+
+var readdirp_1 = readdirp$1;
 
-var readdirp_1 = readdirp;
+var anymatch$2 = {exports: {}};
 
 /*!
  * normalize-path <https://github.com/jonschlinkert/normalize-path>
@@ -3732,7 +3767,8 @@ var readdirp_1 = readdirp;
  * Copyright (c) 2014-2018, Jon Schlinkert.
  * Released under the MIT License.
  */
-var normalizePath = function(path, stripTrailing) {
+
+var normalizePath$2 = function(path, stripTrailing) {
   if (typeof path !== 'string') {
     throw new TypeError('expected path to be a string');
   }
@@ -3761,6 +3797,11 @@ var normalizePath = function(path, stripTrailing) {
   return prefix + segs.join('/');
 };
 
+Object.defineProperty(anymatch$2.exports, "__esModule", { value: true });
+
+const picomatch = picomatch$2;
+const normalizePath$1 = normalizePath$2;
+
 /**
  * @typedef {(testString: string) => boolean} AnymatchFn
  * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
@@ -3768,7 +3809,7 @@ var normalizePath = function(path, stripTrailing) {
  */
 const BANG$1 = '!';
 const DEFAULT_OPTIONS = {returnIndex: false};
-const arrify = (item) => Array.isArray(item) ? item : [item];
+const arrify$1 = (item) => Array.isArray(item) ? item : [item];
 
 /**
  * @param {AnymatchPattern} matcher
@@ -3780,7 +3821,7 @@ const createPattern = (matcher, options) => {
     return matcher;
   }
   if (typeof matcher === 'string') {
-    const glob = picomatch$1(matcher, options);
+    const glob = picomatch(matcher, options);
     return (string) => matcher === string || glob(string);
   }
   if (matcher instanceof RegExp) {
@@ -3803,7 +3844,7 @@ const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
     throw new TypeError('anymatch: second argument must be a string: got ' +
       Object.prototype.toString.call(_path))
   }
-  const path = normalizePath(_path);
+  const path = normalizePath$1(_path);
 
   for (let index = 0; index < negPatterns.length; index++) {
     const nglob = negPatterns[index];
@@ -3829,7 +3870,7 @@ const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
  * @param {object} options
  * @returns {boolean|number|Function}
  */
-const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
+const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
   if (matchers == null) {
     throw new TypeError('anymatch: specify first argument');
   }
@@ -3837,11 +3878,11 @@ const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
   const returnIndex = opts.returnIndex || false;
 
   // Early cache for matchers.
-  const mtchers = arrify(matchers);
+  const mtchers = arrify$1(matchers);
   const negatedGlobs = mtchers
     .filter(item => typeof item === 'string' && item.charAt(0) === BANG$1)
     .map(item => item.slice(1))
-    .map(item => picomatch$1(item, opts));
+    .map(item => picomatch(item, opts));
   const patterns = mtchers.map(matcher => createPattern(matcher, opts));
 
   if (testString == null) {
@@ -3854,8 +3895,8 @@ const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
   return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
 };
 
-anymatch.default = anymatch;
-var anymatch_1 = anymatch;
+anymatch$1.default = anymatch$1;
+anymatch$2.exports = anymatch$1;
 
 /*!
  * is-extglob <https://github.com/jonschlinkert/is-extglob>
@@ -3863,7 +3904,8 @@ var anymatch_1 = anymatch;
  * Copyright (c) 2014-2016, Jon Schlinkert.
  * Licensed under the MIT License.
  */
-var isExtglob = function isExtglob(str) {
+
+var isExtglob$1 = function isExtglob(str) {
   if (typeof str !== 'string' || str === '') {
     return false;
   }
@@ -3884,11 +3926,12 @@ var isExtglob = function isExtglob(str) {
  * Released under the MIT License.
  */
 
+var isExtglob = isExtglob$1;
 var chars = { '{': '}', '(': ')', '[': ']'};
 var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
 var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
 
-var isGlob = function isGlob(str, options) {
+var isGlob$2 = function isGlob(str, options) {
   if (typeof str !== 'string' || str === '') {
     return false;
   }
@@ -3925,8 +3968,9 @@ var isGlob = function isGlob(str, options) {
   return false;
 };
 
-var pathPosixDirname = sysPath.posix.dirname;
-var isWin32 = require$$1$1.platform() === 'win32';
+var isGlob$1 = isGlob$2;
+var pathPosixDirname = path$3.posix.dirname;
+var isWin32 = require$$2.platform() === 'win32';
 
 var slash = '/';
 var backslash = /\\/g;
@@ -3939,7 +3983,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
@@ -3958,7 +4002,7 @@ var globParent = function globParent(str, opts) {
   // remove path parts that are globby
   do {
     str = pathPosixDirname(str);
-  } while (isGlob(str) || globby.test(str));
+  } while (isGlob$1(str) || globby.test(str));
 
   // remove escape chars and return result
   return str.replace(escaped, '$1');
@@ -4225,15 +4269,20 @@ var require$$0 = [
 	"zipx"
 ];
 
-var binaryExtensions = require$$0;
+var binaryExtensions$1 = require$$0;
+
+const path = path$3;
+const binaryExtensions = binaryExtensions$1;
 
 const extensions = new Set(binaryExtensions);
 
-var isBinaryPath = filePath => extensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var isBinaryPath$1 = filePath => extensions.has(path.extname(filePath).slice(1).toLowerCase());
 
-var constants$2 = rollup.createCommonjsModule(function (module, exports) {
+var constants = {};
 
-const {sep} = sysPath;
+(function (exports) {
+
+const {sep} = path$3;
 const {platform} = process;
 
 exports.EV_ALL = 'all';
@@ -4294,38 +4343,40 @@ exports.IDENTITY_FN = val => val;
 exports.isWindows = platform === 'win32';
 exports.isMacos = platform === 'darwin';
 exports.isLinux = platform === 'linux';
-});
-
-const { promisify: promisify$1 } = util;
+}(constants));
 
+const fs$2 = fs$4;
+const sysPath$2 = path$3;
+const { promisify: promisify$2 } = require$$0$1;
+const isBinaryPath = isBinaryPath$1;
 const {
-  isWindows,
+  isWindows: isWindows$1,
   isLinux,
-  EMPTY_FN,
-  EMPTY_STR,
+  EMPTY_FN: EMPTY_FN$2,
+  EMPTY_STR: EMPTY_STR$1,
   KEY_LISTENERS,
   KEY_ERR,
   KEY_RAW,
   HANDLER_KEYS,
-  EV_CHANGE,
-  EV_ADD,
-  EV_ADD_DIR,
-  EV_ERROR,
-  STR_DATA,
-  STR_END,
-  BRACE_START,
-  STAR: STAR$1
-} = constants$2;
+  EV_CHANGE: EV_CHANGE$2,
+  EV_ADD: EV_ADD$2,
+  EV_ADD_DIR: EV_ADD_DIR$2,
+  EV_ERROR: EV_ERROR$2,
+  STR_DATA: STR_DATA$1,
+  STR_END: STR_END$2,
+  BRACE_START: BRACE_START$1,
+  STAR
+} = constants;
 
 const THROTTLE_MODE_WATCH = 'watch';
 
-const open = promisify$1(fs.open);
-const stat$1 = promisify$1(fs.stat);
-const lstat$1 = promisify$1(fs.lstat);
-const close = promisify$1(fs.close);
-const fsrealpath = promisify$1(fs.realpath);
+const open = promisify$2(fs$2.open);
+const stat$2 = promisify$2(fs$2.stat);
+const lstat$1 = promisify$2(fs$2.lstat);
+const close = promisify$2(fs$2.close);
+const fsrealpath = promisify$2(fs$2.realpath);
 
-const statMethods = { lstat: lstat$1, stat: stat$1 };
+const statMethods$1 = { lstat: lstat$1, stat: stat$2 };
 
 // TODO: emit errors properly. Example: EMFILE on Macos.
 const foreach = (val, fn) => {
@@ -4405,12 +4456,12 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     // case the file's watcher misses it (and rely on throttling to de-dupe)
     if (evPath && path !== evPath) {
       fsWatchBroadcast(
-        sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)
+        sysPath$2.resolve(path, evPath), KEY_LISTENERS, sysPath$2.join(path, evPath)
       );
     }
   };
   try {
-    return fs.watch(path, options, handleEvent);
+    return fs$2.watch(path, options, handleEvent);
   } catch (error) {
     errHandler(error);
   }
@@ -4465,11 +4516,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);
@@ -4529,7 +4580,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 
   const copts = cont && cont.options;
   if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    fs.unwatchFile(fullPath);
+    fs$2.unwatchFile(fullPath);
     cont = undefined;
   }
 
@@ -4546,9 +4597,9 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
       listeners: listener,
       rawEmitters: rawEmitter,
       options,
-      watcher: fs.watchFile(fullPath, options, (curr, prev) => {
+      watcher: fs$2.watchFile(fullPath, options, (curr, prev) => {
         foreach(cont.rawEmitters, (rawEmitter) => {
-          rawEmitter(EV_CHANGE, fullPath, {curr, prev});
+          rawEmitter(EV_CHANGE$2, fullPath, {curr, prev});
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
@@ -4567,7 +4618,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
     delFromSet(cont, KEY_RAW, rawEmitter);
     if (isEmptySet(cont.listeners)) {
       FsWatchFileInstances.delete(fullPath);
-      fs.unwatchFile(fullPath);
+      fs$2.unwatchFile(fullPath);
       cont.options = cont.watcher = undefined;
       Object.freeze(cont);
     }
@@ -4577,7 +4628,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 /**
  * @mixin
  */
-class NodeFsHandler {
+class NodeFsHandler$1 {
 
 /**
  * @param {import("../index").FSWatcher} fsW
@@ -4595,13 +4646,13 @@ constructor(fsW) {
  */
 _watchWithNodeFs(path, listener) {
   const opts = this.fsw.options;
-  const directory = sysPath.dirname(path);
-  const basename = sysPath.basename(path);
+  const directory = sysPath$2.dirname(path);
+  const basename = sysPath$2.basename(path);
   const parent = this.fsw._getWatchedDir(directory);
   parent.add(basename);
-  const absolutePath = sysPath.resolve(path);
+  const absolutePath = sysPath$2.resolve(path);
   const options = {persistent: opts.persistent};
-  if (!listener) listener = EMPTY_FN;
+  if (!listener) listener = EMPTY_FN$2;
 
   let closer;
   if (opts.usePolling) {
@@ -4632,8 +4683,8 @@ _handleFile(file, stats, initialAdd) {
   if (this.fsw.closed) {
     return;
   }
-  const dirname = sysPath.dirname(file);
-  const basename = sysPath.basename(file);
+  const dirname = sysPath$2.dirname(file);
+  const basename = sysPath$2.basename(file);
   const parent = this.fsw._getWatchedDir(dirname);
   // stats is always present
   let prevStats = stats;
@@ -4645,13 +4696,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);
@@ -4670,7 +4721,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;
     }
@@ -4680,8 +4731,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;
@@ -4710,12 +4761,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;
@@ -4731,7 +4782,7 @@ async _handleSymlink(entry, directory, path, item) {
 
 _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
   // Normalize the directory name on Windows
-  directory = sysPath.join(directory, EMPTY_STR);
+  directory = sysPath$2.join(directory, EMPTY_STR$1);
 
   if (!wh.hasGlob) {
     throttler = this.fsw._throttle('readdir', directory, 1000);
@@ -4745,13 +4796,13 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
     fileFilter: entry => wh.filterPath(entry),
     directoryFilter: entry => wh.filterDir(entry),
     depth: 0
-  }).on(STR_DATA, async (entry) => {
+  }).on(STR_DATA$1, async (entry) => {
     if (this.fsw.closed) {
       stream = undefined;
       return;
     }
     const item = entry.path;
-    let path = sysPath.join(directory, item);
+    let path = sysPath$2.join(directory, item);
     current.add(item);
 
     if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
@@ -4769,14 +4820,14 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
       this.fsw._incrReadyCount();
 
       // ensure relativeness of path is preserved in case of watcher reuse
-      path = sysPath.join(dir, sysPath.relative(dir, path));
+      path = sysPath$2.join(dir, sysPath$2.relative(dir, path));
 
       this._addToNodeFs(path, initialAdd, wh, depth + 1);
     }
-  }).on(EV_ERROR, this._boundHandleError);
+  }).on(EV_ERROR$2, this._boundHandleError);
 
   return new Promise(resolve =>
-    stream.once(STR_END, () => {
+    stream.once(STR_END$2, () => {
       if (this.fsw.closed) {
         stream = undefined;
         return;
@@ -4795,7 +4846,7 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
           // a path may have been filtered out of this readdir, but
           // shouldn't be removed because it matches a different glob
           (!wh.hasGlob || wh.filterPath({
-            fullPath: sysPath.resolve(directory, item)
+            fullPath: sysPath$2.resolve(directory, item)
           }));
       }).forEach((item) => {
         this.fsw._remove(directory, item);
@@ -4821,14 +4872,14 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
  * @returns {Promise<Function>} closer for the watcher instance.
  */
 async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-  const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-  const tracked = parentDir.has(sysPath.basename(dir));
+  const parentDir = this.fsw._getWatchedDir(sysPath$2.dirname(dir));
+  const tracked = parentDir.has(sysPath$2.basename(dir));
   if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
-    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
+    if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR$2, dir, stats);
   }
 
   // ensure dir is tracked (harmless if redundant)
-  parentDir.add(sysPath.basename(dir));
+  parentDir.add(sysPath$2.basename(dir));
   this.fsw._getWatchedDir(dir);
   let throttler;
   let closer;
@@ -4877,17 +4928,17 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
 
   // evaluate what is at the path we're being asked to watch
   try {
-    const stats = await statMethods[wh.statMethod](wh.watchPath);
+    const stats = await statMethods$1[wh.statMethod](wh.watchPath);
     if (this.fsw.closed) return;
     if (this.fsw._isIgnored(wh.watchPath, stats)) {
       ready();
       return false;
     }
 
-    const follow = this.fsw.options.followSymlinks && !path.includes(STAR$1) && !path.includes(BRACE_START);
+    const follow = this.fsw.options.followSymlinks && !path.includes(STAR) && !path.includes(BRACE_START$1);
     let closer;
     if (stats.isDirectory()) {
-      const absPath = sysPath.resolve(path);
+      const absPath = sysPath$2.resolve(path);
       const targetPath = follow ? await fsrealpath(path) : path;
       if (this.fsw.closed) return;
       closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -4899,15 +4950,15 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
     } else if (stats.isSymbolicLink()) {
       const targetPath = follow ? await fsrealpath(path) : path;
       if (this.fsw.closed) return;
-      const parent = sysPath.dirname(wh.watchPath);
+      const parent = sysPath$2.dirname(wh.watchPath);
       this.fsw._getWatchedDir(parent).add(wh.watchPath);
-      this.fsw._emit(EV_ADD, wh.watchPath, stats);
+      this.fsw._emit(EV_ADD$2, wh.watchPath, stats);
       closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
       if (this.fsw.closed) return;
 
       // preserve this symlink's target path
       if (targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+        this.fsw._symlinkPaths.set(sysPath$2.resolve(path), targetPath);
       }
     } else {
       closer = this._handleFile(wh.watchPath, stats, initialAdd);
@@ -4927,15 +4978,19 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
 
 }
 
-var nodefsHandler = NodeFsHandler;
+var nodefsHandler = NodeFsHandler$1;
+
+var fseventsHandler = {exports: {}};
 
-var require$$1 = /*@__PURE__*/rollup.getAugmentedNamespace(rollup.fseventsImporter);
+var require$$3 = /*@__PURE__*/rollup.getAugmentedNamespace(rollup.fseventsImporter);
 
-const { promisify: promisify$2 } = util;
+const fs$1 = fs$4;
+const sysPath$1 = path$3;
+const { promisify: promisify$1 } = require$$0$1;
 
 let fsevents;
 try {
-  fsevents = require$$1.getFsEvents();
+  fsevents = require$$3.getFsEvents();
 } catch (error) {
   if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error);
 }
@@ -4956,9 +5011,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,
@@ -4973,18 +5028,18 @@ const {
   ROOT_GLOBSTAR,
   DIR_SUFFIX,
   DOT_SLASH,
-  FUNCTION_TYPE,
+  FUNCTION_TYPE: FUNCTION_TYPE$1,
   EMPTY_FN: EMPTY_FN$1,
   IDENTITY_FN
-} = constants$2;
+} = constants;
 
 const Depth = (value) => isNaN(value) ? {} : {depth: value};
 
-const stat$2 = promisify$2(fs.stat);
-const lstat$2 = promisify$2(fs.lstat);
-const realpath$1 = promisify$2(fs.realpath);
+const stat$1 = promisify$1(fs$1.stat);
+const lstat = promisify$1(fs$1.lstat);
+const realpath = promisify$1(fs$1.realpath);
 
-const statMethods$1 = { stat: stat$2, lstat: lstat$2 };
+const statMethods = { stat: stat$1, lstat };
 
 /**
  * @typedef {String} Path
@@ -5033,8 +5088,8 @@ const createFSEventsInstance = (path, callback) => {
  * @returns {Function} closer
  */
 function setFSEventsListener(path, realPath, listener, rawEmitter) {
-  let watchPath = sysPath.extname(path) ? sysPath.dirname(path) : path;
-  const parentPath = sysPath.dirname(watchPath);
+  let watchPath = sysPath$1.extname(path) ? sysPath$1.dirname(path) : path;
+  const parentPath = sysPath$1.dirname(watchPath);
   let cont = FSEventsWatchers.get(watchPath);
 
   // If we've accumulated a substantial number of paths that
@@ -5045,14 +5100,14 @@ function setFSEventsListener(path, realPath, listener, rawEmitter) {
     watchPath = parentPath;
   }
 
-  const resolvedPath = sysPath.resolve(path);
+  const resolvedPath = sysPath$1.resolve(path);
   const hasSymlink = resolvedPath !== realPath;
 
   const filteredListener = (fullPath, flags, info) => {
     if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath);
     if (
       fullPath === resolvedPath ||
-      !fullPath.indexOf(resolvedPath + sysPath.sep)
+      !fullPath.indexOf(resolvedPath + sysPath$1.sep)
     ) listener(fullPath, flags, info);
   };
 
@@ -5060,7 +5115,7 @@ function setFSEventsListener(path, realPath, listener, rawEmitter) {
   // modifies `watchPath` to the parent path when it finds a match
   let watchedParent = false;
   for (const watchedPath of FSEventsWatchers.keys()) {
-    if (realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep) === 0) {
+    if (realPath.indexOf(sysPath$1.resolve(watchedPath) + sysPath$1.sep) === 0) {
       watchPath = watchedPath;
       cont = FSEventsWatchers.get(watchPath);
       watchedParent = true;
@@ -5125,7 +5180,7 @@ const canUse = () => fsevents && FSEventsWatchers.size < 128;
 // determines subdirectory traversal levels from root to path
 const calcDepth = (path, root) => {
   let i = 0;
-  while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++;
+  while (!path.indexOf(root) && (path = sysPath$1.dirname(path)) !== root) i++;
   return i;
 };
 
@@ -5140,7 +5195,7 @@ const sameTypes = (info, stats) => (
 /**
  * @mixin
  */
-class FsEventsHandler {
+class FsEventsHandler$1 {
 
 /**
  * @param {import('../index').FSWatcher} fsw
@@ -5169,18 +5224,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);
     }
   }
 }
@@ -5188,7 +5243,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)) {
@@ -5236,30 +5291,30 @@ _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
       opts.depth !== undefined &&
       calcDepth(fullPath, realPath) > opts.depth
     ) return;
-    const path = transform(sysPath.join(
-      watchPath, sysPath.relative(watchPath, fullPath)
+    const path = transform(sysPath$1.join(
+      watchPath, sysPath$1.relative(watchPath, fullPath)
     ));
     if (globFilter && !globFilter(path)) return;
     // ensure directories are tracked
-    const parent = sysPath.dirname(path);
-    const item = sysPath.basename(path);
+    const parent = sysPath$1.dirname(path);
+    const item = sysPath$1.basename(path);
     const watchedDir = this.fsw._getWatchedDir(
       info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
     );
 
     // correct for wrong events emitted
     if (wrongEventFlags.has(flags) || info.event === FSEVENT_UNKNOWN) {
-      if (typeof opts.ignored === FUNCTION_TYPE) {
+      if (typeof opts.ignored === FUNCTION_TYPE$1) {
         let stats;
         try {
-          stats = await stat$2(path);
+          stats = await stat$1(path);
         } catch (error) {}
         if (this.fsw.closed) return;
         if (this.checkIgnored(path, stats)) return;
         if (sameTypes(info, stats)) {
           this.addOrChange(path, fullPath, realPath, parent, watchedDir, item, info, opts);
         } else {
-          this.handleEvent(EV_UNLINK, path, fullPath, realPath, parent, watchedDir, item, info, opts);
+          this.handleEvent(EV_UNLINK$1, path, fullPath, realPath, parent, watchedDir, item, info, opts);
         }
       } else {
         this.checkExists(path, fullPath, realPath, parent, watchedDir, item, info, opts);
@@ -5303,7 +5358,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();
@@ -5318,7 +5373,7 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
       if (linkTarget && linkTarget !== DOT_SLASH) {
         aliasedPath = path.replace(linkTarget, linkPath);
       } else if (path !== DOT_SLASH) {
-        aliasedPath = sysPath.join(linkPath, path);
+        aliasedPath = sysPath$1.join(linkPath, path);
       }
       return transform(aliasedPath);
     }, false, curDepth);
@@ -5337,8 +5392,8 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
 emitAdd(newPath, stats, processPath, opts, forceAdd) {
   const pp = processPath(newPath);
   const isDir = stats.isDirectory();
-  const dirObj = this.fsw._getWatchedDir(sysPath.dirname(pp));
-  const base = sysPath.basename(pp);
+  const dirObj = this.fsw._getWatchedDir(sysPath$1.dirname(pp));
+  const base = sysPath$1.basename(pp);
 
   // ensure empty dirs get tracked
   if (isDir) this.fsw._getWatchedDir(pp);
@@ -5354,7 +5409,7 @@ initWatch(realPath, path, wh, processPath) {
   if (this.fsw.closed) return;
   const closer = this._watchWithFsEvents(
     wh.watchPath,
-    sysPath.resolve(realPath || wh.watchPath),
+    sysPath$1.resolve(realPath || wh.watchPath),
     processPath,
     wh.globFilter
   );
@@ -5374,13 +5429,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;
@@ -5397,21 +5452,21 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
         fileFilter: entry => wh.filterPath(entry),
         directoryFilter: entry => wh.filterDir(entry),
         ...Depth(opts.depth - (priorDepth || 0))
-      }).on(STR_DATA$1, (entry) => {
+      }).on(STR_DATA, (entry) => {
         // need to check filterPath on dirs b/c filterDir is less restrictive
         if (this.fsw.closed) {
           return;
         }
         if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
 
-        const joinedPath = sysPath.join(wh.watchPath, entry.path);
+        const joinedPath = sysPath$1.join(wh.watchPath, entry.path);
         const {fullPath} = entry;
 
         if (wh.followSymlinks && entry.stats.isSymbolicLink()) {
           // preserve the current depth here since it can't be derived from
           // real paths past the symlink
           const curDepth = opts.depth === undefined ?
-            undefined : calcDepth(joinedPath, sysPath.resolve(wh.watchPath)) + 1;
+            undefined : calcDepth(joinedPath, sysPath$1.resolve(wh.watchPath)) + 1;
 
           this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
         } else {
@@ -5433,13 +5488,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);
     }
@@ -5448,36 +5503,35 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
 
 }
 
-var fseventsHandler = FsEventsHandler;
-var canUse_1 = canUse;
-fseventsHandler.canUse = canUse_1;
+fseventsHandler.exports = FsEventsHandler$1;
+fseventsHandler.exports.canUse = canUse;
 
 const { EventEmitter } = require$$0$2;
-
-
-const { promisify: promisify$3 } = util;
-
-const anymatch$1 = anymatch_1.default;
-
-
-
-
-
-
-
+const fs = fs$4;
+const sysPath = path$3;
+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,
@@ -5487,24 +5541,24 @@ const {
 
   SLASH,
   SLASH_SLASH,
-  BRACE_START: BRACE_START$1,
-  BANG: BANG$2,
+  BRACE_START,
+  BANG,
   ONE_DOT,
   TWO_DOTS,
   GLOBSTAR,
   SLASH_GLOBSTAR,
   ANYMATCH_OPTS,
   STRING_TYPE,
-  FUNCTION_TYPE: FUNCTION_TYPE$1,
-  EMPTY_STR: EMPTY_STR$1,
-  EMPTY_FN: EMPTY_FN$2,
+  FUNCTION_TYPE,
+  EMPTY_STR,
+  EMPTY_FN,
 
-  isWindows: isWindows$1,
+  isWindows,
   isMacos
-} = constants$2;
+} = constants;
 
-const stat$3 = promisify$3(fs.stat);
-const readdir$1 = promisify$3(fs.readdir);
+const stat = promisify(fs.stat);
+const readdir = promisify(fs.readdir);
 
 /**
  * @typedef {String} Path
@@ -5526,7 +5580,7 @@ const readdir$1 = promisify$3(fs.readdir);
  * @property {Function} filterDir
  */
 
-const arrify$1 = (value = []) => Array.isArray(value) ? value : [value];
+const arrify = (value = []) => Array.isArray(value) ? value : [value];
 const flatten = (list, result = []) => {
   list.forEach(item => {
     if (Array.isArray(item)) {
@@ -5542,7 +5596,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}`);
   }
@@ -5570,7 +5624,7 @@ const toUnix = (string) => {
 // TODO: this is not equal to path-normalize module - investigate why
 const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
 
-const normalizeIgnored = (cwd = EMPTY_STR$1) => (path) => {
+const normalizeIgnored = (cwd = EMPTY_STR) => (path) => {
   if (typeof path !== STRING_TYPE) return path;
   return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
 };
@@ -5579,8 +5633,8 @@ const getAbsolutePath = (path, cwd) => {
   if (sysPath.isAbsolute(path)) {
     return path;
   }
-  if (path.startsWith(BANG$2)) {
-    return BANG$2 + sysPath.join(cwd, path.slice(1));
+  if (path.startsWith(BANG)) {
+    return BANG + sysPath.join(cwd, path.slice(1));
   }
   return sysPath.join(cwd, path);
 };
@@ -5618,7 +5672,7 @@ class DirEntry {
 
     const dir = this.path;
     try {
-      await readdir$1(dir);
+      await readdir(dir);
     } catch (err) {
       if (this._removeWatcher) {
         this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
@@ -5655,14 +5709,14 @@ const STAT_METHOD_L = 'lstat';
 class WatchHelper {
   constructor(path, watchPath, follow, fsw) {
     this.fsw = fsw;
-    this.path = path = path.replace(REPLACER_RE, EMPTY_STR$1);
+    this.path = path = path.replace(REPLACER_RE, EMPTY_STR);
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath.resolve(watchPath);
     this.hasGlob = watchPath !== path;
     /** @type {object|boolean} */
-    if (path === EMPTY_STR$1) this.hasGlob = false;
+    if (path === EMPTY_STR) this.hasGlob = false;
     this.globSymlink = this.hasGlob && follow ? undefined : false;
-    this.globFilter = this.hasGlob ? anymatch$1(path, undefined, ANYMATCH_OPTS) : false;
+    this.globFilter = this.hasGlob ? anymatch(path, undefined, ANYMATCH_OPTS) : false;
     this.dirParts = this.getDirParts(path);
     this.dirParts.forEach((parts) => {
       if (parts.length > 1) parts.pop();
@@ -5696,7 +5750,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) &&
@@ -5706,7 +5760,7 @@ class WatchHelper {
   getDirParts(path) {
     if (!this.hasGlob) return [];
     const parts = [];
-    const expandedPath = path.includes(BRACE_START$1) ? braces_1.expand(path) : [path];
+    const expandedPath = path.includes(BRACE_START) ? braces.expand(path) : [path];
     expandedPath.forEach((path) => {
       parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
     });
@@ -5720,7 +5774,7 @@ class WatchHelper {
       this.unmatchedGlob = !this.dirParts.some((parts) => {
         return parts.every((part, i) => {
           if (part === GLOBSTAR) globstar = true;
-          return globstar || !entryParts[0][i] || anymatch$1(part, entryParts[0][i], ANYMATCH_OPTS);
+          return globstar || !entryParts[0][i] || anymatch(part, entryParts[0][i], ANYMATCH_OPTS);
         });
       });
     }
@@ -5773,7 +5827,7 @@ constructor(_opts) {
   if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
 
   // If we can't use fsevents, ensure the options reflect it's disabled.
-  const canUseFsEvents = fseventsHandler.canUse();
+  const canUseFsEvents = FsEventsHandler.canUse();
   if (!canUseFsEvents) opts.useFsEvents = false;
 
   // Use polling on Mac if not using fsevents.
@@ -5815,13 +5869,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));
@@ -5833,9 +5887,9 @@ constructor(_opts) {
 
   // Initialize with proper watcher.
   if (opts.useFsEvents) {
-    this._fsEventsHandler = new fseventsHandler(this);
+    this._fsEventsHandler = new FsEventsHandler(this);
   } else {
-    this._nodeFsHandler = new nodefsHandler(this);
+    this._nodeFsHandler = new NodeFsHandler(this);
   }
 
   // You’re frozen when your heart’s not open.
@@ -5869,7 +5923,7 @@ add(paths_, _origAdd, _internal) {
 
   // set aside negated glob strings
   paths = paths.filter((path) => {
-    if (path.startsWith(BANG$2)) {
+    if (path.startsWith(BANG)) {
       this._ignoredPaths.add(path.slice(1));
       return false;
     }
@@ -5984,7 +6038,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
@@ -6004,7 +6058,7 @@ async _emit(event, path, val1, val2, val3) {
   if (this.closed) return;
 
   const opts = this.options;
-  if (isWindows$1) path = sysPath.normalize(path);
+  if (isWindows) path = sysPath.normalize(path);
   if (opts.cwd) path = sysPath.relative(opts.cwd, path);
   /** @type Array<any> */
   const args = [event, path];
@@ -6020,7 +6074,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) => {
@@ -6031,16 +6085,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) {
@@ -6058,18 +6112,18 @@ async _emit(event, path, val1, val2, val3) {
     return this;
   }
 
-  if (event === EV_CHANGE$2) {
-    const isThrottled = !this._throttle(EV_CHANGE$2, path, 50);
+  if (event === EV_CHANGE) {
+    const isThrottled = !this._throttle(EV_CHANGE, path, 50);
     if (isThrottled) return this;
   }
 
   if (opts.alwaysStat && val1 === undefined &&
-    (event === EV_ADD$2 || event === EV_ADD_DIR$2 || event === EV_CHANGE$2)
+    (event === EV_ADD || event === EV_ADD_DIR || event === EV_CHANGE)
   ) {
     const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
     let stats;
     try {
-      stats = await stat$3(fullPath);
+      stats = await stat(fullPath);
     } catch (err) {}
     // Suppress event when fs_stat fails, to avoid sending undefined 'stat'
     if (!stats || this.closed) return;
@@ -6090,7 +6144,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;
 }
@@ -6215,11 +6269,11 @@ _isIgnored(path, stats) {
     const ign = this.options.ignored;
 
     const ignored = ign && ign.map(normalizeIgnored(cwd));
-    const paths = arrify$1(ignored)
+    const paths = arrify(ignored)
       .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
       .map((path) => path + SLASH_GLOBSTAR);
     const list = this._getGlobIgnored().map(normalizeIgnored(cwd)).concat(ignored, paths);
-    this._userIgnored = anymatch$1(list, undefined, ANYMATCH_OPTS);
+    this._userIgnored = anymatch(list, undefined, ANYMATCH_OPTS);
   }
 
   return this._userIgnored([path, stats]);
@@ -6330,14 +6384,14 @@ _remove(directory, item, isDirectory) {
   if (this.options.cwd) relPath = sysPath.relative(this.options.cwd, path);
   if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
     const event = this._pendingWrites.get(relPath).cancelWait();
-    if (event === EV_ADD$2) return;
+    if (event === EV_ADD) return;
   }
 
   // The Entry will either be a directory that just got removed
   // or a bogus entry to a file, in either case we have to remove it
   this._watched.delete(path);
   this._watched.delete(fullPath);
-  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK$1;
+  const eventName = isDirectory ? EV_UNLINK_DIR : EV_UNLINK;
   if (wasTracked && !this._isIgnored(path)) this._emit(eventName, path);
 
   // Avoid conflicts if we later create another file with the same name
@@ -6385,12 +6439,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;
@@ -6402,7 +6456,7 @@ _readdirp(root, opts) {
 }
 
 // Export FSWatcher class
-var FSWatcher_1 = FSWatcher;
+chokidar.FSWatcher = FSWatcher;
 
 /**
  * Instantiates watcher with paths to be tracked.
@@ -6416,15 +6470,10 @@ const watch = (paths, options) => {
   return watcher;
 };
 
-var watch_1 = watch;
-
-var chokidar = {
-	FSWatcher: FSWatcher_1,
-	watch: watch_1
-};
+chokidar.watch = watch;
 
 exports.braces_1 = braces_1;
 exports.chokidar = chokidar;
-exports.picomatch = picomatch$1;
-exports.utils = utils$1;
+exports.picomatch = picomatch$2;
+exports.utils = utils$3;
 //# sourceMappingURL=index.js.map