rollup 2.38.3 → 2.39.1

package/dist/es/shared/watch.js

@@ -1,23 +1,25 @@
 /*
   @license
-	Rollup.js v2.38.3
-	Mon, 01 Feb 2021 06:15:21 GMT - commit 683cf48a5278987f08ff3958074c49a80b1ae3eb
+	Rollup.js v2.39.1
+	Tue, 23 Feb 2021 05:45:51 GMT - commit a8a56fc29978cef41dde28f8f14e3b29119768d5
 
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
-import sysPath, { sep, resolve } from 'path';
-import util from 'util';
-import { createCommonjsModule, defaultOnWarn, ensureArray as ensureArray$1, warnUnknownOptions, getAugmentedNamespace, fseventsImporter, rollupInternal } from './rollup.js';
-import require$$0$2 from 'events';
-import fs from 'fs';
-import require$$0$1 from 'stream';
-import require$$1$1, { platform } from 'os';
+import require$$0$2, { sep, resolve } from 'path';
+import require$$0$1 from 'util';
+import { defaultOnWarn, ensureArray as ensureArray$1, warnUnknownOptions, getAugmentedNamespace, fseventsImporter, rollupInternal } from './rollup.js';
+import require$$0$3 from 'events';
+import fs$4 from 'fs';
+import require$$1 from 'stream';
+import require$$2, { platform } from 'os';
 import 'crypto';
 
-var utils = createCommonjsModule(function (module, exports) {
+var utils = {};
+
+(function (exports) {
 
 exports.isInteger = num => {
   if (typeof num === 'number') {
@@ -129,16 +131,18 @@ exports.flatten = (...args) => {
   flat(args);
   return result;
 };
-});
+}(utils));
+
+const utils$1 = utils;
 
 var stringify = (ast, options = {}) => {
   let stringify = (node, parent = {}) => {
-    let invalidBlock = options.escapeInvalid && utils.isInvalidBrace(parent);
+    let invalidBlock = options.escapeInvalid && utils$1.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$1.isOpenOrClose(node)) {
         return '\\' + node.value;
       }
       return node.value;
@@ -183,10 +187,10 @@ var isNumber = function(num) {
  * Released under the MIT License.
  */
 
-
+const isNumber$1 = isNumber;
 
 const toRegexRange = (min, max, options) => {
-  if (isNumber(min) === false) {
+  if (isNumber$1(min) === false) {
     throw new TypeError('toRegexRange: expected the first argument to be a number');
   }
 
@@ -194,7 +198,7 @@ const toRegexRange = (min, max, options) => {
     return String(min);
   }
 
-  if (isNumber(max) === false) {
+  if (isNumber$1(max) === false) {
     throw new TypeError('toRegexRange: expected the second argument to be a number.');
   }
 
@@ -470,8 +474,8 @@ var toRegexRange_1 = toRegexRange;
  * Licensed under the MIT License.
  */
 
-
-
+const util = require$$0$1;
+const toRegexRange$1 = toRegexRange_1;
 
 const isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 
@@ -483,7 +487,7 @@ const isValidValue = value => {
   return typeof value === 'number' || (typeof value === 'string' && value !== '');
 };
 
-const isNumber$1 = num => Number.isInteger(+num);
+const isNumber$2 = num => Number.isInteger(+num);
 
 const zeros = input => {
   let value = `${input}`;
@@ -555,7 +559,7 @@ const toSequence = (parts, options) => {
 
 const toRange = (a, b, isNumbers, options) => {
   if (isNumbers) {
-    return toRegexRange_1(a, b, { wrap: false, ...options });
+    return toRegexRange$1(a, b, { wrap: false, ...options });
   }
 
   let start = String.fromCharCode(a);
@@ -571,7 +575,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$1(start, end, options);
 };
 
 const rangeError = (...args) => {
@@ -643,7 +647,7 @@ const fillNumbers = (start, end, step = 1, options = {}) => {
 };
 
 const fillLetters = (start, end, step = 1, options = {}) => {
-  if ((!isNumber$1(start) && start.length > 1) || (!isNumber$1(end) && end.length > 1)) {
+  if ((!isNumber$2(start) && start.length > 1) || (!isNumber$2(end) && end.length > 1)) {
     return invalidRange(start, end, options);
   }
 
@@ -697,12 +701,12 @@ const fill = (start, end, step, options = {}) => {
   if (opts.capture === true) opts.wrap = true;
   step = step || opts.step || 1;
 
-  if (!isNumber$1(step)) {
+  if (!isNumber$2(step)) {
     if (step != null && !isObject(step)) return invalidStep(step, opts);
     return fill(start, end, 1, step);
   }
 
-  if (isNumber$1(start) && isNumber$1(end)) {
+  if (isNumber$2(start) && isNumber$2(end)) {
     return fillNumbers(start, end, step, opts);
   }
 
@@ -711,9 +715,12 @@ const fill = (start, end, step, options = {}) => {
 
 var fillRange = fill;
 
+const fill$1 = fillRange;
+const utils$2 = utils;
+
 const compile = (ast, options = {}) => {
   let walk = (node, parent = {}) => {
-    let invalidBlock = utils.isInvalidBrace(parent);
+    let invalidBlock = utils$2.isInvalidBrace(parent);
     let invalidNode = node.invalid === true && options.escapeInvalid === true;
     let invalid = invalidBlock === true || invalidNode === true;
     let prefix = options.escapeInvalid === true ? '\\' : '';
@@ -743,8 +750,8 @@ const compile = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
-      let range = fillRange(...args, { ...options, wrap: false, toRegex: true });
+      let args = utils$2.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;
@@ -764,6 +771,10 @@ const compile = (ast, options = {}) => {
 
 var compile_1 = compile;
 
+const fill$2 = fillRange;
+const stringify$2 = stringify;
+const utils$3 = utils;
+
 const append = (queue = '', stash = '', enclose = false) => {
   let result = [];
 
@@ -772,7 +783,7 @@ const append = (queue = '', stash = '', enclose = false) => {
 
   if (!stash.length) return queue;
   if (!queue.length) {
-    return enclose ? utils.flatten(stash).map(ele => `{${ele}}`) : stash;
+    return enclose ? utils$3.flatten(stash).map(ele => `{${ele}}`) : stash;
   }
 
   for (let item of queue) {
@@ -787,7 +798,7 @@ const append = (queue = '', stash = '', enclose = false) => {
       }
     }
   }
-  return utils.flatten(result);
+  return utils$3.flatten(result);
 };
 
 const expand = (ast, options = {}) => {
@@ -805,7 +816,7 @@ const expand = (ast, options = {}) => {
     }
 
     if (node.invalid || node.dollar) {
-      q.push(append(q.pop(), stringify(node, options)));
+      q.push(append(q.pop(), stringify$2(node, options)));
       return;
     }
 
@@ -815,15 +826,15 @@ const expand = (ast, options = {}) => {
     }
 
     if (node.nodes && node.ranges > 0) {
-      let args = utils.reduce(node.nodes);
+      let args = utils$3.reduce(node.nodes);
 
-      if (utils.exceedsLimit(...args, options.step, rangeLimit)) {
+      if (utils$3.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$2(...args, options);
       if (range.length === 0) {
-        range = stringify(node, options);
+        range = stringify$2(node, options);
       }
 
       q.push(append(q.pop(), range));
@@ -831,7 +842,7 @@ const expand = (ast, options = {}) => {
       return;
     }
 
-    let enclose = utils.encloseBrace(node);
+    let enclose = utils$3.encloseBrace(node);
     let queue = node.queue;
     let block = node;
 
@@ -867,7 +878,7 @@ const expand = (ast, options = {}) => {
     return queue;
   };
 
-  return utils.flatten(walk(ast));
+  return utils$3.flatten(walk(ast));
 };
 
 var expand_1 = expand;
@@ -928,6 +939,8 @@ var constants = {
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: '\uFEFF' /* \uFEFF */
 };
 
+const stringify$3 = stringify;
+
 /**
  * Constants
  */
@@ -1169,7 +1182,7 @@ const parse = (input, options = {}) => {
       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$3(block) }];
       }
 
       push({ type: 'comma', value });
@@ -1255,6 +1268,11 @@ const parse = (input, options = {}) => {
 
 var parse_1 = parse;
 
+const stringify$4 = stringify;
+const compile$1 = compile_1;
+const expand$1 = expand_1;
+const parse$1 = parse_1;
+
 /**
  * Expand the given pattern or create a regex-compatible string.
  *
@@ -1305,7 +1323,7 @@ const braces = (input, options = {}) => {
  * @api public
  */
 
-braces.parse = (input, options = {}) => parse_1(input, options);
+braces.parse = (input, options = {}) => parse$1(input, options);
 
 /**
  * Creates a braces string from an AST, or an AST node.
@@ -1323,9 +1341,9 @@ braces.parse = (input, options = {}) => parse_1(input, options);
 
 braces.stringify = (input, options = {}) => {
   if (typeof input === 'string') {
-    return stringify(braces.parse(input, options), options);
+    return stringify$4(braces.parse(input, options), options);
   }
-  return stringify(input, options);
+  return stringify$4(input, options);
 };
 
 /**
@@ -1347,7 +1365,7 @@ braces.compile = (input, options = {}) => {
   if (typeof input === 'string') {
     input = braces.parse(input, options);
   }
-  return compile_1(input, options);
+  return compile$1(input, options);
 };
 
 /**
@@ -1372,7 +1390,7 @@ braces.expand = (input, options = {}) => {
     input = braces.parse(input, options);
   }
 
-  let result = expand_1(input, options);
+  let result = expand$1(input, options);
 
   // filter out empty strings if specified
   if (options.noempty === true) {
@@ -1419,6 +1437,9 @@ braces.create = (input, options = {}) => {
 
 var braces_1 = braces;
 
+var utils$4 = {};
+
+const path = require$$0$2;
 const WIN_SLASH = '\\\\/';
 const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
 
@@ -1571,7 +1592,7 @@ var constants$1 = {
   CHAR_VERTICAL_LINE: 124, /* | */
   CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
 
-  SEP: sysPath.sep,
+  SEP: path.sep,
 
   /**
    * Create EXTGLOB_CHARS
@@ -1596,9 +1617,9 @@ var constants$1 = {
   }
 };
 
-var utils$1 = createCommonjsModule(function (module, exports) {
-
+(function (exports) {
 
+const path = require$$0$2;
 const win32 = process.platform === 'win32';
 const {
   REGEX_BACKSLASH,
@@ -1631,7 +1652,7 @@ exports.isWindows = options => {
   if (options && typeof options.windows === 'boolean') {
     return options.windows;
   }
-  return win32 === true || sysPath.sep === '\\';
+  return win32 === true || path.sep === '\\';
 };
 
 exports.escapeLast = (input, char, lastIdx) => {
@@ -1660,8 +1681,9 @@ exports.wrapOutput = (input, state = {}, options = {}) => {
   }
   return output;
 };
-});
+}(utils$4));
 
+const utils$5 = utils$4;
 const {
   CHAR_ASTERISK,             /* * */
   CHAR_AT,                   /* @ */
@@ -1971,10 +1993,10 @@ const scan = (input, options) => {
   }
 
   if (opts.unescape === true) {
-    if (glob) glob = utils$1.removeBackslashes(glob);
+    if (glob) glob = utils$5.removeBackslashes(glob);
 
     if (base && backslashes === true) {
-      base = utils$1.removeBackslashes(base);
+      base = utils$5.removeBackslashes(base);
     }
   }
 
@@ -2043,6 +2065,9 @@ const scan = (input, options) => {
 
 var scan_1 = scan;
 
+const constants$2 = constants$1;
+const utils$6 = utils$4;
+
 /**
  * Constants
  */
@@ -2053,7 +2078,7 @@ const {
   REGEX_NON_SPECIAL_CHARS,
   REGEX_SPECIAL_CHARS_BACKREF,
   REPLACEMENTS
-} = constants$1;
+} = constants$2;
 
 /**
  * Helpers
@@ -2085,7 +2110,7 @@ const syntaxError = (type, char) => {
  * @return {Object}
  */
 
-const parse$1 = (input, options) => {
+const parse$2 = (input, options) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected a string');
   }
@@ -2104,11 +2129,11 @@ const parse$1 = (input, options) => {
   const tokens = [bos];
 
   const capture = opts.capture ? '' : '?:';
-  const win32 = utils$1.isWindows(options);
+  const win32 = utils$6.isWindows(options);
 
   // create constants based on platform, for windows or posix
-  const PLATFORM_CHARS = constants$1.globChars(win32);
-  const EXTGLOB_CHARS = constants$1.extglobChars(PLATFORM_CHARS);
+  const PLATFORM_CHARS = constants$2.globChars(win32);
+  const EXTGLOB_CHARS = constants$2.extglobChars(PLATFORM_CHARS);
 
   const {
     DOT_LITERAL,
@@ -2160,7 +2185,7 @@ const parse$1 = (input, options) => {
     tokens
   };
 
-  input = utils$1.removePrefix(input, state);
+  input = utils$6.removePrefix(input, state);
   len = input.length;
 
   const extglobs = [];
@@ -2340,7 +2365,7 @@ const parse$1 = (input, options) => {
       return state;
     }
 
-    state.output = utils$1.wrapOutput(output, state, options);
+    state.output = utils$6.wrapOutput(output, state, options);
     return state;
   }
 
@@ -2453,7 +2478,7 @@ const parse$1 = (input, options) => {
      */
 
     if (state.quotes === 1 && value !== '"') {
-      value = utils$1.escapeRegex(value);
+      value = utils$6.escapeRegex(value);
       prev.value += value;
       append({ value });
       continue;
@@ -2543,11 +2568,11 @@ const parse$1 = (input, options) => {
 
       // when literal brackets are explicitly disabled
       // assume we should match with a regex character class
-      if (opts.literalBrackets === false || utils$1.hasRegexChars(prevValue)) {
+      if (opts.literalBrackets === false || utils$6.hasRegexChars(prevValue)) {
         continue;
       }
 
-      const escaped = utils$1.escapeRegex(prev.value);
+      const escaped = utils$6.escapeRegex(prev.value);
       state.output = state.output.slice(0, -prev.value.length);
 
       // when literal brackets are explicitly enabled
@@ -2719,7 +2744,7 @@ const parse$1 = (input, options) => {
         const next = peek();
         let output = value;
 
-        if (next === '<' && !utils$1.supportsLookbehinds()) {
+        if (next === '<' && !utils$6.supportsLookbehinds()) {
           throw new Error('Node.js v10 or higher is required for regex lookbehinds');
         }
 
@@ -2979,19 +3004,19 @@ const parse$1 = (input, options) => {
 
   while (state.brackets > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ']'));
-    state.output = utils$1.escapeLast(state.output, '[');
+    state.output = utils$6.escapeLast(state.output, '[');
     decrement('brackets');
   }
 
   while (state.parens > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', ')'));
-    state.output = utils$1.escapeLast(state.output, '(');
+    state.output = utils$6.escapeLast(state.output, '(');
     decrement('parens');
   }
 
   while (state.braces > 0) {
     if (opts.strictBrackets === true) throw new SyntaxError(syntaxError('closing', '}'));
-    state.output = utils$1.escapeLast(state.output, '{');
+    state.output = utils$6.escapeLast(state.output, '{');
     decrement('braces');
   }
 
@@ -3021,7 +3046,7 @@ const parse$1 = (input, options) => {
  * impact when none of the fast paths match.
  */
 
-parse$1.fastpaths = (input, options) => {
+parse$2.fastpaths = (input, options) => {
   const opts = { ...options };
   const max = typeof opts.maxLength === 'number' ? Math.min(MAX_LENGTH$1, opts.maxLength) : MAX_LENGTH$1;
   const len = input.length;
@@ -3030,7 +3055,7 @@ parse$1.fastpaths = (input, options) => {
   }
 
   input = REPLACEMENTS[input] || input;
-  const win32 = utils$1.isWindows(options);
+  const win32 = utils$6.isWindows(options);
 
   // create constants based on platform, for windows or posix
   const {
@@ -3043,7 +3068,7 @@ parse$1.fastpaths = (input, options) => {
     NO_DOTS_SLASH,
     STAR,
     START_ANCHOR
-  } = constants$1.globChars(win32);
+  } = constants$2.globChars(win32);
 
   const nodot = opts.dot ? NO_DOTS : NO_DOT;
   const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
@@ -3098,7 +3123,7 @@ parse$1.fastpaths = (input, options) => {
     }
   };
 
-  const output = utils$1.removePrefix(input, state);
+  const output = utils$6.removePrefix(input, state);
   let source = create(output);
 
   if (source && opts.strictSlashes !== true) {
@@ -3108,8 +3133,13 @@ parse$1.fastpaths = (input, options) => {
   return source;
 };
 
-var parse_1$1 = parse$1;
+var parse_1$1 = parse$2;
 
+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);
 
 /**
@@ -3154,7 +3184,7 @@ const picomatch = (glob, options, returnState = false) => {
   }
 
   const opts = options || {};
-  const posix = utils$1.isWindows(options);
+  const posix = utils$7.isWindows(options);
   const regex = isState
     ? picomatch.compileRe(glob, options)
     : picomatch.makeRe(glob, options, false, true);
@@ -3229,7 +3259,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$7.toPosixSlashes : null);
   let match = input === glob;
   let output = (match && format) ? format(input) : input;
 
@@ -3263,9 +3293,9 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch.matchBase = (input, glob, options, posix = utils$1.isWindows(options)) => {
+picomatch.matchBase = (input, glob, options, posix = utils$7.isWindows(options)) => {
   const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
-  return regex.test(sysPath.basename(input));
+  return regex.test(path$1.basename(input));
 };
 
 /**
@@ -3303,7 +3333,7 @@ picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str
 
 picomatch.parse = (pattern, options) => {
   if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
-  return parse_1$1(pattern, { ...options, fastpaths: false });
+  return parse$3(pattern, { ...options, fastpaths: false });
 };
 
 /**
@@ -3333,7 +3363,7 @@ picomatch.parse = (pattern, options) => {
  * @api public
  */
 
-picomatch.scan = (input, options) => scan_1(input, options);
+picomatch.scan = (input, options) => scan$1(input, options);
 
 /**
  * Create a regular expression from a parsed glob pattern.
@@ -3390,11 +3420,11 @@ 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$3.fastpaths(input, options);
   }
 
   if (output === undefined) {
-    parsed = parse_1$1(input, options);
+    parsed = parse$3(input, options);
     parsed.prefix = prefix + (parsed.prefix || '');
   } else {
     parsed.output = output;
@@ -3435,7 +3465,7 @@ picomatch.toRegex = (source, options) => {
  * @return {Object}
  */
 
-picomatch.constants = constants$1;
+picomatch.constants = constants$3;
 
 /**
  * Expose "picomatch"
@@ -3445,6 +3475,10 @@ var picomatch_1 = picomatch;
 
 var picomatch$1 = picomatch_1;
 
+const util$1 = require$$0$1;
+const braces$1 = braces_1;
+const picomatch$2 = picomatch$1;
+const utils$8 = utils$4;
 const isEmptyString = val => typeof val === 'string' && (val === '' || val === './');
 
 /**
@@ -3482,7 +3516,7 @@ const micromatch = (list, patterns, options) => {
   };
 
   for (let i = 0; i < patterns.length; i++) {
-    let isMatch = picomatch$1(String(patterns[i]), { ...options, onResult }, true);
+    let isMatch = picomatch$2(String(patterns[i]), { ...options, onResult }, true);
     let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
     if (negated) negatives++;
 
@@ -3542,7 +3576,7 @@ micromatch.match = micromatch;
  * @api public
  */
 
-micromatch.matcher = (pattern, options) => picomatch$1(pattern, options);
+micromatch.matcher = (pattern, options) => picomatch$2(pattern, options);
 
 /**
  * Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -3561,7 +3595,7 @@ micromatch.matcher = (pattern, options) => picomatch$1(pattern, options);
  * @api public
  */
 
-micromatch.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
+micromatch.isMatch = (str, patterns, options) => picomatch$2(patterns, options)(str);
 
 /**
  * Backwards compatibility
@@ -3628,7 +3662,7 @@ micromatch.not = (list, patterns, options = {}) => {
 
 micromatch.contains = (str, pattern, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util$1.inspect(str)}"`);
   }
 
   if (Array.isArray(pattern)) {
@@ -3669,7 +3703,7 @@ micromatch.contains = (str, pattern, options) => {
  */
 
 micromatch.matchKeys = (obj, patterns, options) => {
-  if (!utils$1.isObject(obj)) {
+  if (!utils$8.isObject(obj)) {
     throw new TypeError('Expected the first argument to be an object');
   }
   let keys = micromatch(Object.keys(obj), patterns, options);
@@ -3701,7 +3735,7 @@ micromatch.some = (list, patterns, options) => {
   let items = [].concat(list);
 
   for (let pattern of [].concat(patterns)) {
-    let isMatch = picomatch$1(String(pattern), options);
+    let isMatch = picomatch$2(String(pattern), options);
     if (items.some(item => isMatch(item))) {
       return true;
     }
@@ -3737,7 +3771,7 @@ micromatch.every = (list, patterns, options) => {
   let items = [].concat(list);
 
   for (let pattern of [].concat(patterns)) {
-    let isMatch = picomatch$1(String(pattern), options);
+    let isMatch = picomatch$2(String(pattern), options);
     if (!items.every(item => isMatch(item))) {
       return false;
     }
@@ -3774,10 +3808,10 @@ micromatch.every = (list, patterns, options) => {
 
 micromatch.all = (str, patterns, options) => {
   if (typeof str !== 'string') {
-    throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
+    throw new TypeError(`Expected a string: "${util$1.inspect(str)}"`);
   }
 
-  return [].concat(patterns).every(p => picomatch$1(p, options)(str));
+  return [].concat(patterns).every(p => picomatch$2(p, options)(str));
 };
 
 /**
@@ -3800,9 +3834,9 @@ micromatch.all = (str, patterns, options) => {
  */
 
 micromatch.capture = (glob, input, options) => {
-  let posix = utils$1.isWindows(options);
-  let regex = picomatch$1.makeRe(String(glob), { ...options, capture: true });
-  let match = regex.exec(posix ? utils$1.toPosixSlashes(input) : input);
+  let posix = utils$8.isWindows(options);
+  let regex = picomatch$2.makeRe(String(glob), { ...options, capture: true });
+  let match = regex.exec(posix ? utils$8.toPosixSlashes(input) : input);
 
   if (match) {
     return match.slice(1).map(v => v === void 0 ? '' : v);
@@ -3825,7 +3859,7 @@ micromatch.capture = (glob, input, options) => {
  * @api public
  */
 
-micromatch.makeRe = (...args) => picomatch$1.makeRe(...args);
+micromatch.makeRe = (...args) => picomatch$2.makeRe(...args);
 
 /**
  * Scan a glob pattern to separate the pattern into segments. Used
@@ -3841,7 +3875,7 @@ micromatch.makeRe = (...args) => picomatch$1.makeRe(...args);
  * @api public
  */
 
-micromatch.scan = (...args) => picomatch$1.scan(...args);
+micromatch.scan = (...args) => picomatch$2.scan(...args);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -3860,8 +3894,8 @@ micromatch.scan = (...args) => picomatch$1.scan(...args);
 micromatch.parse = (patterns, options) => {
   let res = [];
   for (let pattern of [].concat(patterns || [])) {
-    for (let str of braces_1(String(pattern), options)) {
-      res.push(picomatch$1.parse(str, options));
+    for (let str of braces$1(String(pattern), options)) {
+      res.push(picomatch$2.parse(str, options));
     }
   }
   return res;
@@ -3889,7 +3923,7 @@ micromatch.braces = (pattern, options) => {
   if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
     return [pattern];
   }
-  return braces_1(pattern, options);
+  return braces$1(pattern, options);
 };
 
 /**
@@ -4101,16 +4135,20 @@ function mergeOutputOptions(config, overrides, warn) {
         sourcemapFile: getOption('sourcemapFile'),
         sourcemapPathTransform: getOption('sourcemapPathTransform'),
         strict: getOption('strict'),
-        systemNullSetters: getOption('systemNullSetters')
+        systemNullSetters: getOption('systemNullSetters'),
+        validate: getOption('validate')
     };
     warnUnknownOptions(config, Object.keys(outputOptions), 'output options', warn);
     return outputOptions;
 }
 
-const { Readable } = require$$0$1;
-
-const { promisify } = util;
+var chokidar = {};
 
+const fs = fs$4;
+const { Readable } = require$$1;
+const sysPath = require$$0$2;
+const { promisify } = require$$0$1;
+const picomatch$3 = picomatch$1;
 
 const readdir = promisify(fs.readdir);
 const stat = promisify(fs.stat);
@@ -4141,7 +4179,7 @@ const normalizeFilter = filter => {
   if (typeof filter === 'function') return filter;
 
   if (typeof filter === 'string') {
-    const glob = picomatch$1(filter.trim());
+    const glob = picomatch$3(filter.trim());
     return entry => glob(entry.basename);
   }
 
@@ -4151,9 +4189,9 @@ const normalizeFilter = filter => {
     for (const item of filter) {
       const trimmed = item.trim();
       if (trimmed.charAt(0) === BANG) {
-        negative.push(picomatch$1(trimmed.slice(1)));
+        negative.push(picomatch$3(trimmed.slice(1)));
       } else {
-        positive.push(picomatch$1(trimmed));
+        positive.push(picomatch$3(trimmed));
       }
     }
 
@@ -4387,12 +4425,15 @@ readdirp.default = readdirp;
 
 var readdirp_1 = readdirp;
 
+var anymatch = {exports: {}};
+
 /*!
  * normalize-path <https://github.com/jonschlinkert/normalize-path>
  *
  * Copyright (c) 2014-2018, Jon Schlinkert.
  * Released under the MIT License.
  */
+
 var normalizePath = function(path, stripTrailing) {
   if (typeof path !== 'string') {
     throw new TypeError('expected path to be a string');
@@ -4422,6 +4463,11 @@ var normalizePath = function(path, stripTrailing) {
   return prefix + segs.join('/');
 };
 
+Object.defineProperty(anymatch.exports, "__esModule", { value: true });
+
+const picomatch$4 = picomatch$1;
+const normalizePath$1 = normalizePath;
+
 /**
  * @typedef {(testString: string) => boolean} AnymatchFn
  * @typedef {string|RegExp|AnymatchFn} AnymatchPattern
@@ -4441,7 +4487,7 @@ const createPattern = (matcher, options) => {
     return matcher;
   }
   if (typeof matcher === 'string') {
-    const glob = picomatch$1(matcher, options);
+    const glob = picomatch$4(matcher, options);
     return (string) => matcher === string || glob(string);
   }
   if (matcher instanceof RegExp) {
@@ -4464,7 +4510,7 @@ const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
     throw new TypeError('anymatch: second argument must be a string: got ' +
       Object.prototype.toString.call(_path))
   }
-  const path = normalizePath(_path);
+  const path = normalizePath$1(_path);
 
   for (let index = 0; index < negPatterns.length; index++) {
     const nglob = negPatterns[index];
@@ -4490,7 +4536,7 @@ const matchPatterns = (patterns, negPatterns, args, returnIndex) => {
  * @param {object} options
  * @returns {boolean|number|Function}
  */
-const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
+const anymatch$1 = (matchers, testString, options = DEFAULT_OPTIONS) => {
   if (matchers == null) {
     throw new TypeError('anymatch: specify first argument');
   }
@@ -4502,7 +4548,7 @@ const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
   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$4(item, opts));
   const patterns = mtchers.map(matcher => createPattern(matcher, opts));
 
   if (testString == null) {
@@ -4515,8 +4561,8 @@ const anymatch = (matchers, testString, options = DEFAULT_OPTIONS) => {
   return matchPatterns(patterns, negatedGlobs, testString, returnIndex);
 };
 
-anymatch.default = anymatch;
-var anymatch_1 = anymatch;
+anymatch$1.default = anymatch$1;
+anymatch.exports = anymatch$1;
 
 /*!
  * is-extglob <https://github.com/jonschlinkert/is-extglob>
@@ -4524,6 +4570,7 @@ var anymatch_1 = anymatch;
  * Copyright (c) 2014-2016, Jon Schlinkert.
  * Licensed under the MIT License.
  */
+
 var isExtglob = function isExtglob(str) {
   if (typeof str !== 'string' || str === '') {
     return false;
@@ -4545,6 +4592,7 @@ var isExtglob = function isExtglob(str) {
  * Released under the MIT License.
  */
 
+var isExtglob$1 = isExtglob;
 var chars = { '{': '}', '(': ')', '[': ']'};
 var strictRegex = /\\(.)|(^!|\*|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/;
 var relaxedRegex = /\\(.)|(^!|[*?{}()[\]]|\(\?)/;
@@ -4554,7 +4602,7 @@ var isGlob = function isGlob(str, options) {
     return false;
   }
 
-  if (isExtglob(str)) {
+  if (isExtglob$1(str)) {
     return true;
   }
 
@@ -4586,8 +4634,9 @@ var isGlob = function isGlob(str, options) {
   return false;
 };
 
-var pathPosixDirname = sysPath.posix.dirname;
-var isWin32 = require$$1$1.platform() === 'win32';
+var isGlob$1 = isGlob;
+var pathPosixDirname = require$$0$2.posix.dirname;
+var isWin32 = require$$2.platform() === 'win32';
 
 var slash = '/';
 var backslash = /\\/g;
@@ -4619,7 +4668,7 @@ var globParent = function globParent(str, opts) {
   // remove path parts that are globby
   do {
     str = pathPosixDirname(str);
-  } while (isGlob(str) || globby.test(str));
+  } while (isGlob$1(str) || globby.test(str));
 
   // remove escape chars and return result
   return str.replace(escaped, '$1');
@@ -4888,13 +4937,18 @@ var require$$0 = [
 
 var binaryExtensions = require$$0;
 
-const extensions = new Set(binaryExtensions);
+const path$2 = require$$0$2;
+const binaryExtensions$1 = binaryExtensions;
 
-var isBinaryPath = filePath => extensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+const extensions = new Set(binaryExtensions$1);
 
-var constants$2 = createCommonjsModule(function (module, exports) {
+var isBinaryPath = filePath => extensions.has(path$2.extname(filePath).slice(1).toLowerCase());
 
-const {sep} = sysPath;
+var constants$4 = {};
+
+(function (exports) {
+
+const {sep} = require$$0$2;
 const {platform} = process;
 
 exports.EV_ALL = 'all';
@@ -4955,10 +5009,12 @@ exports.IDENTITY_FN = val => val;
 exports.isWindows = platform === 'win32';
 exports.isMacos = platform === 'darwin';
 exports.isLinux = platform === 'linux';
-});
-
-const { promisify: promisify$1 } = util;
+}(constants$4));
 
+const fs$1 = fs$4;
+const sysPath$1 = require$$0$2;
+const { promisify: promisify$1 } = require$$0$1;
+const isBinaryPath$1 = isBinaryPath;
 const {
   isWindows,
   isLinux,
@@ -4976,15 +5032,15 @@ const {
   STR_END,
   BRACE_START,
   STAR: STAR$1
-} = constants$2;
+} = constants$4;
 
 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$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 statMethods = { lstat: lstat$1, stat: stat$1 };
 
@@ -5066,12 +5122,12 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
     // case the file's watcher misses it (and rely on throttling to de-dupe)
     if (evPath && path !== evPath) {
       fsWatchBroadcast(
-        sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath)
+        sysPath$1.resolve(path, evPath), KEY_LISTENERS, sysPath$1.join(path, evPath)
       );
     }
   };
   try {
-    return fs.watch(path, options, handleEvent);
+    return fs$1.watch(path, options, handleEvent);
   } catch (error) {
     errHandler(error);
   }
@@ -5190,7 +5246,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
 
   const copts = cont && cont.options;
   if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-    fs.unwatchFile(fullPath);
+    fs$1.unwatchFile(fullPath);
     cont = undefined;
   }
 
@@ -5207,7 +5263,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
       listeners: listener,
       rawEmitters: rawEmitter,
       options,
-      watcher: fs.watchFile(fullPath, options, (curr, prev) => {
+      watcher: fs$1.watchFile(fullPath, options, (curr, prev) => {
         foreach(cont.rawEmitters, (rawEmitter) => {
           rawEmitter(EV_CHANGE, fullPath, {curr, prev});
         });
@@ -5228,7 +5284,7 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
     delFromSet(cont, KEY_RAW, rawEmitter);
     if (isEmptySet(cont.listeners)) {
       FsWatchFileInstances.delete(fullPath);
-      fs.unwatchFile(fullPath);
+      fs$1.unwatchFile(fullPath);
       cont.options = cont.watcher = undefined;
       Object.freeze(cont);
     }
@@ -5256,17 +5312,17 @@ constructor(fsW) {
  */
 _watchWithNodeFs(path, listener) {
   const opts = this.fsw.options;
-  const directory = sysPath.dirname(path);
-  const basename = sysPath.basename(path);
+  const directory = sysPath$1.dirname(path);
+  const basename = sysPath$1.basename(path);
   const parent = this.fsw._getWatchedDir(directory);
   parent.add(basename);
-  const absolutePath = sysPath.resolve(path);
+  const absolutePath = sysPath$1.resolve(path);
   const options = {persistent: opts.persistent};
   if (!listener) listener = EMPTY_FN;
 
   let closer;
   if (opts.usePolling) {
-    options.interval = opts.enableBinaryInterval && isBinaryPath(basename) ?
+    options.interval = opts.enableBinaryInterval && isBinaryPath$1(basename) ?
       opts.binaryInterval : opts.interval;
     closer = setFsWatchFileListener(path, absolutePath, options, {
       listener,
@@ -5293,8 +5349,8 @@ _handleFile(file, stats, initialAdd) {
   if (this.fsw.closed) {
     return;
   }
-  const dirname = sysPath.dirname(file);
-  const basename = sysPath.basename(file);
+  const dirname = sysPath$1.dirname(file);
+  const basename = sysPath$1.basename(file);
   const parent = this.fsw._getWatchedDir(dirname);
   // stats is always present
   let prevStats = stats;
@@ -5392,7 +5448,7 @@ async _handleSymlink(entry, directory, path, item) {
 
 _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
   // Normalize the directory name on Windows
-  directory = sysPath.join(directory, EMPTY_STR);
+  directory = sysPath$1.join(directory, EMPTY_STR);
 
   if (!wh.hasGlob) {
     throttler = this.fsw._throttle('readdir', directory, 1000);
@@ -5412,7 +5468,7 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
       return;
     }
     const item = entry.path;
-    let path = sysPath.join(directory, item);
+    let path = sysPath$1.join(directory, item);
     current.add(item);
 
     if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path, item)) {
@@ -5430,7 +5486,7 @@ _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$1.join(dir, sysPath$1.relative(dir, path));
 
       this._addToNodeFs(path, initialAdd, wh, depth + 1);
     }
@@ -5456,7 +5512,7 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
           // a path may have been filtered out of this readdir, but
           // shouldn't be removed because it matches a different glob
           (!wh.hasGlob || wh.filterPath({
-            fullPath: sysPath.resolve(directory, item)
+            fullPath: sysPath$1.resolve(directory, item)
           }));
       }).forEach((item) => {
         this.fsw._remove(directory, item);
@@ -5482,14 +5538,14 @@ _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
  * @returns {Promise<Function>} closer for the watcher instance.
  */
 async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-  const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-  const tracked = parentDir.has(sysPath.basename(dir));
+  const parentDir = this.fsw._getWatchedDir(sysPath$1.dirname(dir));
+  const tracked = parentDir.has(sysPath$1.basename(dir));
   if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
     if (!wh.hasGlob || wh.globFilter(dir)) this.fsw._emit(EV_ADD_DIR, dir, stats);
   }
 
   // ensure dir is tracked (harmless if redundant)
-  parentDir.add(sysPath.basename(dir));
+  parentDir.add(sysPath$1.basename(dir));
   this.fsw._getWatchedDir(dir);
   let throttler;
   let closer;
@@ -5548,7 +5604,7 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
     const follow = this.fsw.options.followSymlinks && !path.includes(STAR$1) && !path.includes(BRACE_START);
     let closer;
     if (stats.isDirectory()) {
-      const absPath = sysPath.resolve(path);
+      const absPath = sysPath$1.resolve(path);
       const targetPath = follow ? await fsrealpath(path) : path;
       if (this.fsw.closed) return;
       closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5560,7 +5616,7 @@ 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$1.dirname(wh.watchPath);
       this.fsw._getWatchedDir(parent).add(wh.watchPath);
       this.fsw._emit(EV_ADD, wh.watchPath, stats);
       closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
@@ -5568,7 +5624,7 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
 
       // preserve this symlink's target path
       if (targetPath !== undefined) {
-        this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+        this.fsw._symlinkPaths.set(sysPath$1.resolve(path), targetPath);
       }
     } else {
       closer = this._handleFile(wh.watchPath, stats, initialAdd);
@@ -5590,13 +5646,17 @@ async _addToNodeFs(path, initialAdd, priorWh, depth, target) {
 
 var nodefsHandler = NodeFsHandler;
 
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(fseventsImporter);
+var fseventsHandler = {exports: {}};
+
+var require$$3 = /*@__PURE__*/getAugmentedNamespace(fseventsImporter);
 
-const { promisify: promisify$2 } = util;
+const fs$2 = fs$4;
+const sysPath$2 = require$$0$2;
+const { promisify: promisify$2 } = 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);
 }
@@ -5637,13 +5697,13 @@ const {
   FUNCTION_TYPE,
   EMPTY_FN: EMPTY_FN$1,
   IDENTITY_FN
-} = constants$2;
+} = constants$4;
 
 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$2 = promisify$2(fs$2.stat);
+const lstat$2 = promisify$2(fs$2.lstat);
+const realpath$1 = promisify$2(fs$2.realpath);
 
 const statMethods$1 = { stat: stat$2, lstat: lstat$2 };
 
@@ -5694,8 +5754,8 @@ const createFSEventsInstance = (path, callback) => {
  * @returns {Function} closer
  */
 function setFSEventsListener(path, realPath, listener, rawEmitter) {
-  let watchPath = sysPath.extname(path) ? sysPath.dirname(path) : path;
-  const parentPath = sysPath.dirname(watchPath);
+  let watchPath = sysPath$2.extname(path) ? sysPath$2.dirname(path) : path;
+  const parentPath = sysPath$2.dirname(watchPath);
   let cont = FSEventsWatchers.get(watchPath);
 
   // If we've accumulated a substantial number of paths that
@@ -5706,14 +5766,14 @@ function setFSEventsListener(path, realPath, listener, rawEmitter) {
     watchPath = parentPath;
   }
 
-  const resolvedPath = sysPath.resolve(path);
+  const resolvedPath = sysPath$2.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$2.sep)
     ) listener(fullPath, flags, info);
   };
 
@@ -5721,7 +5781,7 @@ function setFSEventsListener(path, realPath, listener, rawEmitter) {
   // modifies `watchPath` to the parent path when it finds a match
   let watchedParent = false;
   for (const watchedPath of FSEventsWatchers.keys()) {
-    if (realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep) === 0) {
+    if (realPath.indexOf(sysPath$2.resolve(watchedPath) + sysPath$2.sep) === 0) {
       watchPath = watchedPath;
       cont = FSEventsWatchers.get(watchPath);
       watchedParent = true;
@@ -5786,7 +5846,7 @@ const canUse = () => fsevents && FSEventsWatchers.size < 128;
 // determines subdirectory traversal levels from root to path
 const calcDepth = (path, root) => {
   let i = 0;
-  while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++;
+  while (!path.indexOf(root) && (path = sysPath$2.dirname(path)) !== root) i++;
   return i;
 };
 
@@ -5897,13 +5957,13 @@ _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$2.join(
+      watchPath, sysPath$2.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$2.dirname(path);
+    const item = sysPath$2.basename(path);
     const watchedDir = this.fsw._getWatchedDir(
       info.type === FSEVENT_TYPE_DIRECTORY ? path : parent
     );
@@ -5979,7 +6039,7 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
       if (linkTarget && linkTarget !== DOT_SLASH) {
         aliasedPath = path.replace(linkTarget, linkPath);
       } else if (path !== DOT_SLASH) {
-        aliasedPath = sysPath.join(linkPath, path);
+        aliasedPath = sysPath$2.join(linkPath, path);
       }
       return transform(aliasedPath);
     }, false, curDepth);
@@ -5998,8 +6058,8 @@ async _handleFsEventsSymlink(linkPath, fullPath, transform, curDepth) {
 emitAdd(newPath, stats, processPath, opts, forceAdd) {
   const pp = processPath(newPath);
   const isDir = stats.isDirectory();
-  const dirObj = this.fsw._getWatchedDir(sysPath.dirname(pp));
-  const base = sysPath.basename(pp);
+  const dirObj = this.fsw._getWatchedDir(sysPath$2.dirname(pp));
+  const base = sysPath$2.basename(pp);
 
   // ensure empty dirs get tracked
   if (isDir) this.fsw._getWatchedDir(pp);
@@ -6015,7 +6075,7 @@ initWatch(realPath, path, wh, processPath) {
   if (this.fsw.closed) return;
   const closer = this._watchWithFsEvents(
     wh.watchPath,
-    sysPath.resolve(realPath || wh.watchPath),
+    sysPath$2.resolve(realPath || wh.watchPath),
     processPath,
     wh.globFilter
   );
@@ -6065,14 +6125,14 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
         }
         if (entry.stats.isDirectory() && !wh.filterPath(entry)) return;
 
-        const joinedPath = sysPath.join(wh.watchPath, entry.path);
+        const joinedPath = sysPath$2.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$2.resolve(wh.watchPath)) + 1;
 
           this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth);
         } else {
@@ -6109,23 +6169,22 @@ async _addToFsEvents(path, transform, forceAdd, priorDepth) {
 
 }
 
-var fseventsHandler = FsEventsHandler;
-var canUse_1 = canUse;
-fseventsHandler.canUse = canUse_1;
-
-const { EventEmitter } = require$$0$2;
-
-
-const { promisify: promisify$3 } = util;
-
-const anymatch$1 = anymatch_1.default;
-
-
-
-
-
-
-
+fseventsHandler.exports = FsEventsHandler;
+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 {
   EV_ALL,
   EV_READY,
@@ -6162,10 +6221,10 @@ const {
 
   isWindows: isWindows$1,
   isMacos
-} = constants$2;
+} = constants$4;
 
-const stat$3 = promisify$3(fs.stat);
-const readdir$1 = promisify$3(fs.readdir);
+const stat$3 = promisify$3(fs$3.stat);
+const readdir$1 = promisify$3(fs$3.readdir);
 
 /**
  * @typedef {String} Path
@@ -6229,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.normalize(toUnix(path)));
+const normalizePathToUnix = (path) => toUnix(sysPath$3.normalize(toUnix(path)));
 
 const normalizeIgnored = (cwd = EMPTY_STR$1) => (path) => {
   if (typeof path !== STRING_TYPE) return path;
-  return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+  return normalizePathToUnix(sysPath$3.isAbsolute(path) ? path : sysPath$3.join(cwd, path));
 };
 
 const getAbsolutePath = (path, cwd) => {
-  if (sysPath.isAbsolute(path)) {
+  if (sysPath$3.isAbsolute(path)) {
     return path;
   }
   if (path.startsWith(BANG$2)) {
-    return BANG$2 + sysPath.join(cwd, path.slice(1));
+    return BANG$2 + sysPath$3.join(cwd, path.slice(1));
   }
-  return sysPath.join(cwd, path);
+  return sysPath$3.join(cwd, path);
 };
 
 const undef = (opts, key) => opts[key] === undefined;
@@ -6282,7 +6341,7 @@ class DirEntry {
       await readdir$1(dir);
     } catch (err) {
       if (this._removeWatcher) {
-        this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+        this._removeWatcher(sysPath$3.dirname(dir), sysPath$3.basename(dir));
       }
     }
   }
@@ -6318,12 +6377,12 @@ class WatchHelper {
     this.fsw = fsw;
     this.path = path = path.replace(REPLACER_RE, EMPTY_STR$1);
     this.watchPath = watchPath;
-    this.fullWatchPath = sysPath.resolve(watchPath);
+    this.fullWatchPath = sysPath$3.resolve(watchPath);
     this.hasGlob = watchPath !== path;
     /** @type {object|boolean} */
     if (path === EMPTY_STR$1) 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$2(path, undefined, ANYMATCH_OPTS) : false;
     this.dirParts = this.getDirParts(path);
     this.dirParts.forEach((parts) => {
       if (parts.length > 1) parts.pop();
@@ -6348,8 +6407,8 @@ class WatchHelper {
   }
 
   entryPath(entry) {
-    return sysPath.join(this.watchPath,
-      sysPath.relative(this.watchPath, this.checkGlobSymlink(entry))
+    return sysPath$3.join(this.watchPath,
+      sysPath$3.relative(this.watchPath, this.checkGlobSymlink(entry))
     );
   }
 
@@ -6367,9 +6426,9 @@ 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$1) ? braces$2.expand(path) : [path];
     expandedPath.forEach((path) => {
-      parts.push(sysPath.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
+      parts.push(sysPath$3.relative(this.watchPath, path).split(SLASH_OR_BACK_SLASH_RE));
     });
     return parts;
   }
@@ -6381,7 +6440,7 @@ class WatchHelper {
       this.unmatchedGlob = !this.dirParts.some((parts) => {
         return parts.every((part, i) => {
           if (part === GLOBSTAR) globstar = true;
-          return globstar || !entryParts[0][i] || anymatch$1(part, entryParts[0][i], ANYMATCH_OPTS);
+          return globstar || !entryParts[0][i] || anymatch$2(part, entryParts[0][i], ANYMATCH_OPTS);
         });
       });
     }
@@ -6434,7 +6493,7 @@ constructor(_opts) {
   if (undef(opts, 'useFsEvents')) opts.useFsEvents = !opts.usePolling;
 
   // If we can't use fsevents, ensure the options reflect it's disabled.
-  const canUseFsEvents = fseventsHandler.canUse();
+  const canUseFsEvents = FsEventsHandler$1.canUse();
   if (!canUseFsEvents) opts.useFsEvents = false;
 
   // Use polling on Mac if not using fsevents.
@@ -6494,9 +6553,9 @@ constructor(_opts) {
 
   // Initialize with proper watcher.
   if (opts.useFsEvents) {
-    this._fsEventsHandler = new fseventsHandler(this);
+    this._fsEventsHandler = new FsEventsHandler$1(this);
   } else {
-    this._nodeFsHandler = new nodefsHandler(this);
+    this._nodeFsHandler = new NodeFsHandler$1(this);
   }
 
   // You’re frozen when your heart’s not open.
@@ -6521,10 +6580,10 @@ 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(path)) {
+      if (disableGlobbing || !isGlob$2(path)) {
         return absPath;
       }
-      return normalizePath(absPath);
+      return normalizePath$2(absPath);
     });
   }
 
@@ -6562,7 +6621,7 @@ add(paths_, _origAdd, _internal) {
     ).then(results => {
       if (this.closed) return;
       results.filter(item => item).forEach(item => {
-        this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+        this.add(sysPath$3.dirname(item), sysPath$3.basename(_origAdd || item));
       });
     });
   }
@@ -6582,9 +6641,9 @@ unwatch(paths_) {
 
   paths.forEach((path) => {
     // convert to absolute path unless relative path already matches
-    if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
-      if (cwd) path = sysPath.join(cwd, path);
-      path = sysPath.resolve(path);
+    if (!sysPath$3.isAbsolute(path) && !this._closers.has(path)) {
+      if (cwd) path = sysPath$3.join(cwd, path);
+      path = sysPath$3.resolve(path);
     }
 
     this._closePath(path);
@@ -6637,7 +6696,7 @@ close() {
 getWatched() {
   const watchList = {};
   this._watched.forEach((entry, dir) => {
-    const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+    const key = this.options.cwd ? sysPath$3.relative(this.options.cwd, dir) : dir;
     watchList[key || ONE_DOT] = entry.getChildren().sort();
   });
   return watchList;
@@ -6665,8 +6724,8 @@ async _emit(event, path, val1, val2, val3) {
   if (this.closed) return;
 
   const opts = this.options;
-  if (isWindows$1) path = sysPath.normalize(path);
-  if (opts.cwd) path = sysPath.relative(opts.cwd, path);
+  if (isWindows$1) path = sysPath$3.normalize(path);
+  if (opts.cwd) path = sysPath$3.relative(opts.cwd, path);
   /** @type Array<any> */
   const args = [event, path];
   if (val3 !== undefined) args.push(val1, val2, val3);
@@ -6727,7 +6786,7 @@ async _emit(event, path, val1, val2, val3) {
   if (opts.alwaysStat && val1 === undefined &&
     (event === EV_ADD$2 || event === EV_ADD_DIR$2 || event === EV_CHANGE$2)
   ) {
-    const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+    const fullPath = opts.cwd ? sysPath$3.join(opts.cwd, path) : path;
     let stats;
     try {
       stats = await stat$3(fullPath);
@@ -6809,14 +6868,14 @@ _awaitWriteFinish(path, threshold, event, awfEmit) {
   let timeoutHandler;
 
   let fullPath = path;
-  if (this.options.cwd && !sysPath.isAbsolute(path)) {
-    fullPath = sysPath.join(this.options.cwd, path);
+  if (this.options.cwd && !sysPath$3.isAbsolute(path)) {
+    fullPath = sysPath$3.join(this.options.cwd, path);
   }
 
   const now = new Date();
 
   const awaitWriteFinish = (prevStat) => {
-    fs.stat(fullPath, (err, curStat) => {
+    fs$3.stat(fullPath, (err, curStat) => {
       if (err || !this._pendingWrites.has(path)) {
         if (err && err.code !== 'ENOENT') awfEmit(err);
         return;
@@ -6877,10 +6936,10 @@ _isIgnored(path, stats) {
 
     const ignored = ign && ign.map(normalizeIgnored(cwd));
     const paths = arrify$1(ignored)
-      .filter((path) => typeof path === STRING_TYPE && !isGlob(path))
+      .filter((path) => typeof path === STRING_TYPE && !isGlob$2(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$2(list, undefined, ANYMATCH_OPTS);
   }
 
   return this._userIgnored([path, stats]);
@@ -6897,7 +6956,7 @@ _isntIgnored(path, stat) {
  * @returns {WatchHelper} object containing helpers for this path
  */
 _getWatchHelpers(path, depth) {
-  const watchPath = depth || this.options.disableGlobbing || !isGlob(path) ? path : globParent(path);
+  const watchPath = depth || this.options.disableGlobbing || !isGlob$2(path) ? path : globParent$1(path);
   const follow = this.options.followSymlinks;
 
   return new WatchHelper(path, watchPath, follow, this);
@@ -6913,7 +6972,7 @@ _getWatchHelpers(path, depth) {
  */
 _getWatchedDir(directory) {
   if (!this._boundRemove) this._boundRemove = this._remove.bind(this);
-  const dir = sysPath.resolve(directory);
+  const dir = sysPath$3.resolve(directory);
   if (!this._watched.has(dir)) this._watched.set(dir, new DirEntry(dir, this._boundRemove));
   return this._watched.get(dir);
 }
@@ -6949,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.join(directory, item);
-  const fullPath = sysPath.resolve(path);
+  const path = sysPath$3.join(directory, item);
+  const fullPath = sysPath$3.resolve(path);
   isDirectory = isDirectory != null
     ? isDirectory
     : this._watched.has(path) || this._watched.has(fullPath);
@@ -6988,7 +7047,7 @@ _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.relative(this.options.cwd, path);
+  if (this.options.cwd) relPath = sysPath$3.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;
@@ -7013,8 +7072,8 @@ _remove(directory, item, isDirectory) {
  */
 _closePath(path) {
   this._closeFile(path);
-  const dir = sysPath.dirname(path);
-  this._getWatchedDir(dir).remove(sysPath.basename(path));
+  const dir = sysPath$3.dirname(path);
+  this._getWatchedDir(dir).remove(sysPath$3.basename(path));
 }
 
 /**
@@ -7046,7 +7105,7 @@ _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$1(root, options);
   this._streams.add(stream);
   stream.once(STR_CLOSE, () => {
     stream = undefined;
@@ -7063,7 +7122,7 @@ _readdirp(root, opts) {
 }
 
 // Export FSWatcher class
-var FSWatcher_1 = FSWatcher;
+chokidar.FSWatcher = FSWatcher;
 
 /**
  * Instantiates watcher with paths to be tracked.
@@ -7077,12 +7136,7 @@ const watch = (paths, options) => {
   return watcher;
 };
 
-var watch_1 = watch;
-
-var chokidar = {
-	FSWatcher: FSWatcher_1,
-	watch: watch_1
-};
+chokidar.watch = watch;
 
 class FileWatcher {
     constructor(task, chokidarOptions) {