rollup 2.51.2 → 2.52.3

package/dist/rollup.d.ts

@@ -277,7 +277,8 @@ export type RenderChunkHook = (
 	| Promise<{ code: string; map?: SourceMapInput } | null>
 	| { code: string; map?: SourceMapInput }
 	| string
-	| null;
+	| null
+	| undefined;
 
 export type ResolveDynamicImportHook = (
 	this: PluginContext,
@@ -474,9 +475,13 @@ export interface OutputPlugin extends Partial<OutputPluginHooks>, Partial<Output
 	name: string;
 }
 
+type TreeshakingPreset = 'smallest' | 'safest' | 'recommended';
+
 export interface TreeshakingOptions {
 	annotations?: boolean;
+	correctVarValueBeforeDeclaration?: boolean;
 	moduleSideEffects?: ModuleSideEffectsOption;
+	preset?: TreeshakingPreset;
 	propertyReadSideEffects?: boolean | 'always';
 	/** @deprecated Use `moduleSideEffects` instead */
 	pureExternalModules?: PureModulesOption;
@@ -486,6 +491,7 @@ export interface TreeshakingOptions {
 
 export interface NormalizedTreeshakingOptions {
 	annotations: boolean;
+	correctVarValueBeforeDeclaration: boolean;
 	moduleSideEffects: HasModuleSideEffects;
 	propertyReadSideEffects: boolean | 'always';
 	tryCatchDeoptimization: boolean;
@@ -534,14 +540,14 @@ export interface InputOptions {
 	moduleContext?: ((id: string) => string | null | undefined) | { [id: string]: string };
 	onwarn?: WarningHandlerWithDefault;
 	perf?: boolean;
-	plugins?: Plugin[];
+	plugins?: (Plugin | null | false | undefined)[];
 	preserveEntrySignatures?: PreserveEntrySignaturesOption;
 	/** @deprecated Use the "preserveModules" output option instead. */
 	preserveModules?: boolean;
 	preserveSymlinks?: boolean;
 	shimMissingExports?: boolean;
 	strictDeprecations?: boolean;
-	treeshake?: boolean | TreeshakingOptions;
+	treeshake?: boolean | TreeshakingPreset | TreeshakingOptions;
 	watch?: WatcherOptions | false;
 }
 
@@ -645,7 +651,7 @@ export interface OutputOptions {
 	noConflict?: boolean;
 	outro?: string | (() => string | Promise<string>);
 	paths?: OptionsPaths;
-	plugins?: OutputPlugin[];
+	plugins?: (OutputPlugin | null | false | undefined)[];
 	preferConst?: boolean;
 	preserveModules?: boolean;
 	preserveModulesRoot?: string;

package/dist/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.51.2
-	Fri, 11 Jun 2021 05:35:15 GMT - commit bfae7910ea7553d56782cb5ee0c8581e2b451729
+	Rollup.js v2.52.3
+	Fri, 25 Jun 2021 13:12:43 GMT - commit 9c436a7c7c368f2ff840735a30119899513ff4bd
 
 
 	https://github.com/rollup/rollup

package/dist/shared/index.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.51.2
-	Fri, 11 Jun 2021 05:35:15 GMT - commit bfae7910ea7553d56782cb5ee0c8581e2b451729
+	Rollup.js v2.52.3
+	Fri, 25 Jun 2021 13:12:43 GMT - commit 9c436a7c7c368f2ff840735a30119899513ff4bd
 
 
 	https://github.com/rollup/rollup
@@ -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$3.parse = (pattern, options) => {
 picomatch$3.scan = (input, options) => scan(input, options);
 
 /**
- * Create a regular expression from a parsed glob pattern.
+ * Compile a regular expression from the `state` object returned by the
+ * [parse()](#parse) method.
  *
- * ```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} `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$3.compileRe = (parsed, options, returnOutput = false, returnState = false) => {
+picomatch$3.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$3.toRegex(source, options);
   if (returnState === true) {
-    regex.state = parsed;
+    regex.state = state;
   }
 
   return regex;
 };
 
-picomatch$3.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$3.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$3.compileRe(parsed, options, returnOutput, returnState);
@@ -3516,7 +3531,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';
@@ -3524,6 +3540,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;
@@ -3586,7 +3604,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;
@@ -3661,7 +3679,7 @@ class ReaddirpStream extends Readable {
     } catch (error) {
       this._onError(error);
     }
-    return {files, depth, path};
+    return { files, depth, path };
   }
 
   async _formatEntry(dirent, path) {
@@ -3669,7 +3687,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);
@@ -3709,9 +3727,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';
         }
@@ -4304,6 +4324,7 @@ var constants = {};
 
 const {sep} = path$3;
 const {platform} = process;
+const os = require$$2;
 
 exports.EV_ALL = 'all';
 exports.EV_READY = 'ready';
@@ -4363,6 +4384,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$4;
@@ -5108,7 +5130,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);
 
@@ -5574,7 +5597,8 @@ const {
   EMPTY_FN,
 
   isWindows,
-  isMacos
+  isMacos,
+  isIBMi
 } = constants;
 
 const stat = promisify(fs.stat);
@@ -5856,6 +5880,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/shared/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.51.2
-	Fri, 11 Jun 2021 05:35:15 GMT - commit bfae7910ea7553d56782cb5ee0c8581e2b451729
+	Rollup.js v2.52.3
+	Fri, 25 Jun 2021 13:12:43 GMT - commit 9c436a7c7c368f2ff840735a30119899513ff4bd
 
 
 	https://github.com/rollup/rollup
@@ -379,7 +379,9 @@ function addCommandPluginsToInputOptions(inputOptions, command) {
     if (command.waitForBundleInput === true) {
         inputOptions.plugins.push(waitForInputPlugin());
     }
-    const commandPlugin = command.plugin;
+    addPluginsFromCommandOption(command.plugin, inputOptions);
+}
+function addPluginsFromCommandOption(commandPlugin, inputOptions) {
     if (commandPlugin) {
         const plugins = Array.isArray(commandPlugin) ? commandPlugin : [commandPlugin];
         for (const plugin of plugins) {
@@ -480,25 +482,29 @@ async function loadAndParseConfigFile(fileName, commandOptions = {}) {
 }
 async function loadConfigFile(fileName, commandOptions) {
     const extension = path__namespace.extname(fileName);
-    const configFileExport = extension === '.mjs' && supportsNativeESM()
-        ? (await import(url.pathToFileURL(fileName).href)).default
+    const configFileExport = commandOptions.configPlugin ||
+        !(extension === '.cjs' || (extension === '.mjs' && supportsNativeESM()))
+        ? await getDefaultFromTranspiledConfigFile(fileName, commandOptions)
         : extension === '.cjs'
             ? getDefaultFromCjs(require(fileName))
-            : await getDefaultFromTranspiledConfigFile(fileName, commandOptions.silent);
+            : (await import(url.pathToFileURL(fileName).href)).default;
     return getConfigList(configFileExport, commandOptions);
 }
 function getDefaultFromCjs(namespace) {
     return namespace.__esModule ? namespace.default : namespace;
 }
-async function getDefaultFromTranspiledConfigFile(fileName, silent) {
+async function getDefaultFromTranspiledConfigFile(fileName, commandOptions) {
     const warnings = batchWarnings();
-    const bundle = await rollup.rollup({
+    const inputOptions = {
         external: (id) => (id[0] !== '.' && !path__namespace.isAbsolute(id)) || id.slice(-5, id.length) === '.json',
         input: fileName,
         onwarn: warnings.add,
+        plugins: [],
         treeshake: false
-    });
-    if (!silent && warnings.count > 0) {
+    };
+    addPluginsFromCommandOption(commandOptions.configPlugin, inputOptions);
+    const bundle = await rollup.rollup(inputOptions);
+    if (!commandOptions.silent && warnings.count > 0) {
         stderr(bold(`loaded ${rollup.relativeId(fileName)} with warnings`));
         warnings.flush();
     }

package/dist/shared/mergeOptions.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.51.2
-	Fri, 11 Jun 2021 05:35:15 GMT - commit bfae7910ea7553d56782cb5ee0c8581e2b451729
+	Rollup.js v2.52.3
+	Fri, 25 Jun 2021 13:12:43 GMT - commit 9c436a7c7c368f2ff840735a30119899513ff4bd
 
 
 	https://github.com/rollup/rollup
@@ -38,7 +38,7 @@ function mergeOptions(config, rawCommandOptions = { external: [], globals: undef
     if (outputOptionsArray.length === 0)
         outputOptionsArray.push({});
     const outputOptions = outputOptionsArray.map(singleOutputOptions => mergeOutputOptions(singleOutputOptions, command, warn));
-    rollup.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/);
+    rollup.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;
 }
@@ -83,7 +83,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')
     };
     rollup.warnUnknownOptions(config, Object.keys(inputOptions), 'input options', inputOptions.onwarn, /^output$/);
@@ -98,26 +98,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 = rollup.treeshakePresets[value];
+        if (preset) {
+            return preset;
+        }
+        rollup.error(rollup.errInvalidOption('treeshake', `valid values are false, true, ${rollup.printQuotedStringList(Object.keys(rollup.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]; };