rollup 2.51.0 → 2.52.1

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.51.0
-	Sun, 06 Jun 2021 11:27:34 GMT - commit 592b9fed918ccc99d48ece917a70015ac1898e52
+	Rollup.js v2.52.1
+	Thu, 17 Jun 2021 05:22:05 GMT - commit bef5fe8a573648f73c258ce9adf1a7ff3ffb129d
 
 
 	https://github.com/rollup/rollup
@@ -11,7 +11,7 @@
 import * as require$$0$1 from 'path';
 import require$$0__default, { sep, resolve } from 'path';
 import require$$0$2 from 'util';
-import { defaultOnWarn, ensureArray as ensureArray$1, warnUnknownOptions, fseventsImporter, rollupInternal } from './rollup.js';
+import { defaultOnWarn, ensureArray as ensureArray$1, warnUnknownOptions, error, errInvalidOption, printQuotedStringList, treeshakePresets, fseventsImporter, rollupInternal } from './rollup.js';
 import require$$2, { platform } from 'os';
 import require$$0$3 from 'events';
 import fs__default from 'fs';
@@ -1731,7 +1731,8 @@ const depth = token => {
 /**
  * Quickly scans a glob pattern and returns an object with a handful of
  * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
- * `glob` (the actual pattern), and `negated` (true if the path starts with `!`).
+ * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+ * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
  *
  * ```js
  * const pm = require('picomatch');
@@ -1765,6 +1766,7 @@ const scan$1 = (input, options) => {
   let braceEscaped = false;
   let backslashes = false;
   let negated = false;
+  let negatedExtglob = false;
   let finished = false;
   let braces = 0;
   let prev;
@@ -1876,6 +1878,9 @@ const scan$1 = (input, options) => {
         isGlob = token.isGlob = true;
         isExtglob = token.isExtglob = true;
         finished = true;
+        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+          negatedExtglob = true;
+        }
 
         if (scanToEnd === true) {
           while (eos() !== true && (code = advance())) {
@@ -2029,7 +2034,8 @@ const scan$1 = (input, options) => {
     isGlob,
     isExtglob,
     isGlobstar,
-    negated
+    negated,
+    negatedExtglob
   };
 
   if (opts.tokens === true) {
@@ -2168,7 +2174,7 @@ const parse$1 = (input, options) => {
     START_ANCHOR
   } = PLATFORM_CHARS;
 
-  const globstar = (opts) => {
+  const globstar = opts => {
     return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
   };
 
@@ -2218,12 +2224,13 @@ const parse$1 = (input, options) => {
 
   const eos = () => state.index === len - 1;
   const peek = state.peek = (n = 1) => input[state.index + n];
-  const advance = state.advance = () => input[++state.index];
+  const advance = state.advance = () => input[++state.index] || '';
   const remaining = () => input.slice(state.index + 1);
   const consume = (value = '', num = 0) => {
     state.consumed += value;
     state.index += num;
   };
+
   const append = token => {
     state.output += token.output != null ? token.output : token.value;
     consume(token.value);
@@ -2279,7 +2286,7 @@ const parse$1 = (input, options) => {
       }
     }
 
-    if (extglobs.length && tok.type !== 'paren' && !EXTGLOB_CHARS[tok.value]) {
+    if (extglobs.length && tok.type !== 'paren') {
       extglobs[extglobs.length - 1].inner += tok.value;
     }
 
@@ -2311,6 +2318,7 @@ const parse$1 = (input, options) => {
 
   const extglobClose = token => {
     let output = token.close + (opts.capture ? ')' : '');
+    let rest;
 
     if (token.type === 'negate') {
       let extglobStar = star;
@@ -2323,6 +2331,10 @@ const parse$1 = (input, options) => {
         output = token.close = `)$))${extglobStar}`;
       }
 
+      if (token.inner.includes('*') && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+        output = token.close = `)${rest})${extglobStar})`;
+      }
+
       if (token.prev.type === 'bos') {
         state.negatedExtglob = true;
       }
@@ -2432,9 +2444,9 @@ const parse$1 = (input, options) => {
       }
 
       if (opts.unescape === true) {
-        value = advance() || '';
+        value = advance();
       } else {
-        value += advance() || '';
+        value += advance();
       }
 
       if (state.brackets === 0) {
@@ -3098,7 +3110,7 @@ parse$1.fastpaths = (input, options) => {
     star = `(${star})`;
   }
 
-  const globstar = (opts) => {
+  const globstar = opts => {
     if (opts.noglobstar === true) return star;
     return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
   };
@@ -3384,68 +3396,71 @@ picomatch$4.parse = (pattern, options) => {
 picomatch$4.scan = (input, options) => scan(input, options);
 
 /**
- * Create a regular expression from a parsed glob pattern.
- *
- * ```js
- * const picomatch = require('picomatch');
- * const state = picomatch.parse('*.js');
- * // picomatch.compileRe(state[, options]);
+ * Compile a regular expression from the `state` object returned by the
+ * [parse()](#parse) method.
  *
- * console.log(picomatch.compileRe(state));
- * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
- * ```
- * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `state`
  * @param {Object} `options`
- * @return {RegExp} Returns a regex created from the given pattern.
+ * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+ * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+ * @return {RegExp}
  * @api public
  */
 
-picomatch$4.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
+picomatch$4.compileRe = (state, options, returnOutput = false, returnState = false) => {
   if (returnOutput === true) {
-    return parsed.output;
+    return state.output;
   }
 
   const opts = options || {};
   const prepend = opts.contains ? '' : '^';
   const append = opts.contains ? '' : '$';
 
-  let source = `${prepend}(?:${parsed.output})${append}`;
-  if (parsed && parsed.negated === true) {
+  let source = `${prepend}(?:${state.output})${append}`;
+  if (state && state.negated === true) {
     source = `^(?!${source}).*$`;
   }
 
   const regex = picomatch$4.toRegex(source, options);
   if (returnState === true) {
-    regex.state = parsed;
+    regex.state = state;
   }
 
   return regex;
 };
 
-picomatch$4.makeRe = (input, options, returnOutput = false, returnState = false) => {
+/**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+ * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+picomatch$4.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
 
-  const opts = options || {};
   let parsed = { negated: false, fastpaths: true };
-  let prefix = '';
-  let output;
-
-  if (input.startsWith('./')) {
-    input = input.slice(2);
-    prefix = parsed.prefix = './';
-  }
 
-  if (opts.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
-    output = parse.fastpaths(input, options);
+  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+    parsed.output = parse.fastpaths(input, options);
   }
 
-  if (output === undefined) {
+  if (!parsed.output) {
     parsed = parse(input, options);
-    parsed.prefix = prefix + (parsed.prefix || '');
-  } else {
-    parsed.output = output;
   }
 
   return picomatch$4.compileRe(parsed, options, returnOutput, returnState);
@@ -4032,7 +4047,7 @@ function mergeOptions(config, rawCommandOptions = { external: [], globals: undef
     if (outputOptionsArray.length === 0)
         outputOptionsArray.push({});
     const outputOptions = outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, warn));
-    warnUnknownOptions(command, Object.keys(inputOptions).concat(Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapPathTransform'), Object.keys(commandAliases), 'config', 'environment', 'plugin', 'silent', 'failAfterWarnings', 'stdin', 'waitForBundleInput'), 'CLI flags', warn, /^_$|output$|config/);
+    warnUnknownOptions(command, Object.keys(inputOptions).concat(Object.keys(outputOptions[0]).filter(option => option !== 'sourcemapPathTransform'), Object.keys(commandAliases), 'config', 'environment', 'plugin', 'silent', 'failAfterWarnings', 'stdin', 'waitForBundleInput', 'configPlugin'), 'CLI flags', warn, /^_$|output$|config/);
     inputOptions.output = outputOptions;
     return inputOptions;
 }
@@ -4077,7 +4092,7 @@ function mergeInputOptions(config, overrides, defaultOnWarnHandler) {
         preserveSymlinks: getOption('preserveSymlinks'),
         shimMissingExports: getOption('shimMissingExports'),
         strictDeprecations: getOption('strictDeprecations'),
-        treeshake: getObjectOption(config, overrides, 'treeshake'),
+        treeshake: getObjectOption(config, overrides, 'treeshake', objectifyTreeshakeOption),
         watch: getWatch(config, overrides, 'watch')
     };
     warnUnknownOptions(config, Object.keys(inputOptions), 'input options', inputOptions.onwarn, /^output$/);
@@ -4092,26 +4107,33 @@ const getExternal = (config, overrides) => {
 const getOnWarn = (config, defaultOnWarnHandler) => config.onwarn
     ? warning => config.onwarn(warning, defaultOnWarnHandler)
     : defaultOnWarnHandler;
-const getObjectOption = (config, overrides, name) => {
-    const commandOption = normalizeObjectOptionValue(overrides[name]);
-    const configOption = normalizeObjectOptionValue(config[name]);
+const getObjectOption = (config, overrides, name, objectifyValue = value => (typeof value === 'object' ? value : {})) => {
+    const commandOption = normalizeObjectOptionValue(overrides[name], objectifyValue);
+    const configOption = normalizeObjectOptionValue(config[name], objectifyValue);
     if (commandOption !== undefined) {
         return commandOption && { ...configOption, ...commandOption };
     }
     return configOption;
 };
+const objectifyTreeshakeOption = (value) => {
+    if (typeof value === 'string') {
+        const preset = treeshakePresets[value];
+        if (preset) {
+            return preset;
+        }
+        error(errInvalidOption('treeshake', `valid values are false, true, ${printQuotedStringList(Object.keys(treeshakePresets))}. You can also supply an object for more fine-grained control`));
+    }
+    return typeof value === 'object' ? value : {};
+};
 const getWatch = (config, overrides, name) => config.watch !== false && getObjectOption(config, overrides, name);
-const normalizeObjectOptionValue = (optionValue) => {
+const normalizeObjectOptionValue = (optionValue, objectifyValue) => {
     if (!optionValue) {
         return optionValue;
     }
     if (Array.isArray(optionValue)) {
-        return optionValue.reduce((result, value) => value && result && { ...result, ...value }, {});
-    }
-    if (typeof optionValue !== 'object') {
-        return {};
+        return optionValue.reduce((result, value) => value && result && { ...result, ...objectifyValue(value) }, {});
     }
-    return optionValue;
+    return objectifyValue(optionValue);
 };
 function mergeOutputOptions(config, overrides, warn) {
     const getOption = (name) => { var _a; return (_a = overrides[name]) !== null && _a !== void 0 ? _a : config[name]; };
@@ -4185,7 +4207,8 @@ const realpath$1 = promisify$3(fs$3.realpath);
  */
 
 const BANG$2 = '!';
-const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP']);
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
 const FILE_TYPE = 'files';
 const DIR_TYPE = 'directories';
 const FILE_DIR_TYPE = 'files_directories';
@@ -4193,6 +4216,8 @@ const EVERYTHING_TYPE = 'all';
 const ALL_TYPES = [FILE_TYPE, DIR_TYPE, FILE_DIR_TYPE, EVERYTHING_TYPE];
 
 const isNormalFlowError = error => NORMAL_FLOW_ERRORS.has(error.code);
+const [maj, min] = process.versions.node.split('.').slice(0, 2).map(n => Number.parseInt(n, 10));
+const wantBigintFsStats = process.platform === 'win32' && (maj > 10 || (maj === 10 && min >= 5));
 
 const normalizeFilter = filter => {
   if (filter === undefined) return;
@@ -4255,7 +4280,7 @@ class ReaddirpStream extends Readable {
 
     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$3.length === 3) {
+    if (wantBigintFsStats) {
       this._stat = path => statMethod(path, { bigint: true });
     } else {
       this._stat = statMethod;
@@ -4330,7 +4355,7 @@ class ReaddirpStream extends Readable {
     } catch (error) {
       this._onError(error);
     }
-    return {files, depth, path};
+    return { files, depth, path };
   }
 
   async _formatEntry(dirent, path) {
@@ -4338,7 +4363,7 @@ class ReaddirpStream extends Readable {
     try {
       const basename = this._isDirent ? dirent.name : dirent;
       const fullPath = sysPath$3.resolve(sysPath$3.join(path, basename));
-      entry = {path: sysPath$3.relative(this._root, fullPath), fullPath, 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);
@@ -4378,9 +4403,11 @@ class ReaddirpStream extends Readable {
         if (entryRealPathStats.isDirectory()) {
           const len = entryRealPath.length;
           if (full.startsWith(entryRealPath) && full.substr(len, 1) === sysPath$3.sep) {
-            return this._onError(new Error(
+            const recursiveError = new Error(
               `Circular symlink detected: "${full}" points to "${entryRealPath}"`
-            ));
+            );
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
           }
           return 'directory';
         }
@@ -4973,6 +5000,7 @@ var constants = {};
 
 const {sep} = require$$0__default;
 const {platform} = process;
+const os = require$$2;
 
 exports.EV_ALL = 'all';
 exports.EV_READY = 'ready';
@@ -5032,6 +5060,7 @@ exports.IDENTITY_FN = val => val;
 exports.isWindows = platform === 'win32';
 exports.isMacos = platform === 'darwin';
 exports.isLinux = platform === 'linux';
+exports.isIBMi = os.type() === 'OS400';
 }(constants));
 
 const fs$2 = fs__default;
@@ -5777,7 +5806,8 @@ const createFSEventsInstance = (path, callback) => {
  * @returns {Function} closer
  */
 function setFSEventsListener(path, realPath, listener, rawEmitter) {
-  let watchPath = sysPath$1.extname(path) ? sysPath$1.dirname(path) : path;
+  let watchPath = sysPath$1.extname(realPath) ? sysPath$1.dirname(realPath) : realPath;
+
   const parentPath = sysPath$1.dirname(watchPath);
   let cont = FSEventsWatchers.get(watchPath);
 
@@ -6243,7 +6273,8 @@ const {
   EMPTY_FN,
 
   isWindows,
-  isMacos
+  isMacos,
+  isIBMi
 } = constants;
 
 const stat = promisify(fs.stat);
@@ -6525,6 +6556,11 @@ constructor(_opts) {
     opts.usePolling = isMacos;
   }
 
+  // Always default to polling on IBM i because fs.watch() is not available on IBM i.
+  if(isIBMi) {
+    opts.usePolling = true;
+  }
+
   // Global override (useful for end-developers that need to force polling for all
   // instances of chokidar, regardless of usage/dependency depth)
   const envPoll = process.env.CHOKIDAR_USEPOLLING;

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.51.0
-	Sun, 06 Jun 2021 11:27:34 GMT - commit 592b9fed918ccc99d48ece917a70015ac1898e52
+	Rollup.js v2.52.1
+	Thu, 17 Jun 2021 05:22:05 GMT - commit bef5fe8a573648f73c258ce9adf1a7ff3ffb129d
 
 
 	https://github.com/rollup/rollup