rollup 3.20.7 → 3.21.1

package/LICENSE.md

@@ -611,7 +611,7 @@ Repository: https://github.com/tapjs/signal-exit.git
 
 > The ISC License
 > 
-> Copyright (c) 2015, Contributors
+> Copyright (c) 2015-2023 Benjamin Coe, Isaac Z. Schlueter, and Contributors
 > 
 > Permission to use, copy, modify, and/or distribute this software
 > for any purpose with or without fee is hereby granted, provided

package/dist/bin/rollup

@@ -2,8 +2,8 @@
 
 /*
   @license
-	Rollup.js v3.20.7
-	Fri, 21 Apr 2023 04:31:37 GMT - commit 2820962446b40b7dfab9bdd936be1e230d8b944c
+	Rollup.js v3.21.1
+	Sat, 29 Apr 2023 05:15:23 GMT - commit e01f0a2e7264e0bae267b2fab4b2231d7671d4c2
 
 	https://github.com/rollup/rollup
 

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.20.7
-	Fri, 21 Apr 2023 04:31:37 GMT - commit 2820962446b40b7dfab9bdd936be1e230d8b944c
+	Rollup.js v3.21.1
+	Sat, 29 Apr 2023 05:15:23 GMT - commit e01f0a2e7264e0bae267b2fab4b2231d7671d4c2
 
 	https://github.com/rollup/rollup
 

package/dist/es/shared/node-entry.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v3.20.7
-	Fri, 21 Apr 2023 04:31:37 GMT - commit 2820962446b40b7dfab9bdd936be1e230d8b944c
+	Rollup.js v3.21.1
+	Sat, 29 Apr 2023 05:15:23 GMT - commit e01f0a2e7264e0bae267b2fab4b2231d7671d4c2
 
 	https://github.com/rollup/rollup
 
@@ -16,7 +16,7 @@ import { lstat, realpath, readdir, readFile, mkdir, writeFile } from 'node:fs/pr
 import { EventEmitter } from 'node:events';
 import * as tty from 'tty';
 
-var version$1 = "3.20.7";
+var version$1 = "3.21.1";
 
 const comma = ','.charCodeAt(0);
 const semicolon = ';'.charCodeAt(0);
@@ -2861,12 +2861,6 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
-var picomatchExports = {};
-var picomatch$1 = {
-  get exports(){ return picomatchExports; },
-  set exports(v){ picomatchExports = v; },
-};
-
 var utils$3 = {};
 
 const path$1 = require$$0$1;
@@ -3110,7 +3104,7 @@ var constants$2 = {
 	    output = `(?:^(?!${output}).*$)`;
 	  }
 	  return output;
-	};
+	}; 
 } (utils$3));
 
 const utils$2 = utils$3;
@@ -4615,9 +4609,9 @@ const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
  * @api public
  */
 
-const picomatch = (glob, options, returnState = false) => {
+const picomatch$1 = (glob, options, returnState = false) => {
   if (Array.isArray(glob)) {
-    const fns = glob.map(input => picomatch(input, options, returnState));
+    const fns = glob.map(input => picomatch$1(input, options, returnState));
     const arrayMatcher = str => {
       for (const isMatch of fns) {
         const state = isMatch(str);
@@ -4637,8 +4631,8 @@ const picomatch = (glob, options, returnState = false) => {
   const opts = options || {};
   const posix = utils.isWindows(options);
   const regex = isState
-    ? picomatch.compileRe(glob, options)
-    : picomatch.makeRe(glob, options, false, true);
+    ? picomatch$1.compileRe(glob, options)
+    : picomatch$1.makeRe(glob, options, false, true);
 
   const state = regex.state;
   delete regex.state;
@@ -4646,11 +4640,11 @@ const picomatch = (glob, options, returnState = false) => {
   let isIgnored = () => false;
   if (opts.ignore) {
     const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+    isIgnored = picomatch$1(opts.ignore, ignoreOpts, returnState);
   }
 
   const matcher = (input, returnObject = false) => {
-    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+    const { isMatch, match, output } = picomatch$1.test(input, regex, options, { glob, posix });
     const result = { glob, state, regex, posix, input, output, match, isMatch };
 
     if (typeof opts.onResult === 'function') {
@@ -4700,7 +4694,7 @@ const picomatch = (glob, options, returnState = false) => {
  * @api public
  */
 
-picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+picomatch$1.test = (input, regex, options, { glob, posix } = {}) => {
   if (typeof input !== 'string') {
     throw new TypeError('Expected input to be a string');
   }
@@ -4721,7 +4715,7 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
 
   if (match === false || opts.capture === true) {
     if (opts.matchBase === true || opts.basename === true) {
-      match = picomatch.matchBase(input, regex, options, posix);
+      match = picomatch$1.matchBase(input, regex, options, posix);
     } else {
       match = regex.exec(output);
     }
@@ -4744,8 +4738,8 @@ picomatch.test = (input, regex, options, { glob, posix } = {}) => {
  * @api public
  */
 
-picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
-  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+picomatch$1.matchBase = (input, glob, options, posix = utils.isWindows(options)) => {
+  const regex = glob instanceof RegExp ? glob : picomatch$1.makeRe(glob, options);
   return regex.test(path.basename(input));
 };
 
@@ -4766,7 +4760,7 @@ picomatch.matchBase = (input, glob, options, posix = utils.isWindows(options)) =
  * @api public
  */
 
-picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+picomatch$1.isMatch = (str, patterns, options) => picomatch$1(patterns, options)(str);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -4782,8 +4776,8 @@ picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str
  * @api public
  */
 
-picomatch.parse = (pattern, options) => {
-  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+picomatch$1.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch$1.parse(p, options));
   return parse$1(pattern, { ...options, fastpaths: false });
 };
 
@@ -4814,7 +4808,7 @@ picomatch.parse = (pattern, options) => {
  * @api public
  */
 
-picomatch.scan = (input, options) => scan(input, options);
+picomatch$1.scan = (input, options) => scan(input, options);
 
 /**
  * Compile a regular expression from the `state` object returned by the
@@ -4828,7 +4822,7 @@ picomatch.scan = (input, options) => scan(input, options);
  * @api public
  */
 
-picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+picomatch$1.compileRe = (state, options, returnOutput = false, returnState = false) => {
   if (returnOutput === true) {
     return state.output;
   }
@@ -4842,7 +4836,7 @@ picomatch.compileRe = (state, options, returnOutput = false, returnState = false
     source = `^(?!${source}).*$`;
   }
 
-  const regex = picomatch.toRegex(source, options);
+  const regex = picomatch$1.toRegex(source, options);
   if (returnState === true) {
     regex.state = state;
   }
@@ -4869,7 +4863,7 @@ picomatch.compileRe = (state, options, returnOutput = false, returnState = false
  * @api public
  */
 
-picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+picomatch$1.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
   if (!input || typeof input !== 'string') {
     throw new TypeError('Expected a non-empty string');
   }
@@ -4884,7 +4878,7 @@ picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = fal
     parsed = parse$1(input, options);
   }
 
-  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+  return picomatch$1.compileRe(parsed, options, returnOutput, returnState);
 };
 
 /**
@@ -4904,7 +4898,7 @@ picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = fal
  * @api public
  */
 
-picomatch.toRegex = (source, options) => {
+picomatch$1.toRegex = (source, options) => {
   try {
     const opts = options || {};
     return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
@@ -4919,20 +4913,17 @@ picomatch.toRegex = (source, options) => {
  * @return {Object}
  */
 
-picomatch.constants = constants;
+picomatch$1.constants = constants;
 
 /**
  * Expose "picomatch"
  */
 
-var picomatch_1 = picomatch;
-
-(function (module) {
+var picomatch_1 = picomatch$1;
 
-	module.exports = picomatch_1;
-} (picomatch$1));
+var picomatch = picomatch_1;
 
-const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatchExports);
+const pm = /*@__PURE__*/getDefaultExportFromCjs(picomatch);
 
 const extractors = {
     ArrayPattern(names, param) {
@@ -8612,10 +8603,14 @@ class FunctionBase extends NodeBase {
                 }
                 else if (parameter instanceof Identifier) {
                     parameters[position][0].addEntityToBeDeoptimized(argument);
+                    this.addArgumentToBeDeoptimized(argument);
                 }
                 else if (parameter) {
                     argument.deoptimizePath(UNKNOWN_PATH);
                 }
+                else {
+                    this.addArgumentToBeDeoptimized(argument);
+                }
             }
         }
         else {
@@ -8695,6 +8690,7 @@ class FunctionBase extends NodeBase {
         }
         super.parseNode(esTreeNode);
     }
+    addArgumentToBeDeoptimized(_argument) { }
     applyDeoptimizations() { }
 }
 FunctionBase.prototype.preventChildBlockScope = true;
@@ -8946,10 +8942,26 @@ class AssignmentPattern extends NodeBase {
 class ArgumentsVariable extends LocalVariable {
     constructor(context) {
         super('arguments', null, UNKNOWN_EXPRESSION, context);
+        this.deoptimizedArguments = [];
+    }
+    addArgumentToBeDeoptimized(argument) {
+        if (this.included) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        else {
+            this.deoptimizedArguments.push(argument);
+        }
     }
     hasEffectsOnInteractionAtPath(path, { type }) {
         return type !== INTERACTION_ACCESSED || path.length > 1;
     }
+    include() {
+        super.include();
+        for (const argument of this.deoptimizedArguments) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        this.deoptimizedArguments.length = 0;
+    }
 }
 
 class ThisVariable extends ParameterVariable {
@@ -9047,6 +9059,9 @@ class FunctionNode extends FunctionBase {
         super.initialise();
         this.id?.declare('function', this);
     }
+    addArgumentToBeDeoptimized(argument) {
+        this.scope.argumentsVariable.addArgumentToBeDeoptimized(argument);
+    }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -10985,6 +11000,74 @@ function getToStringTagValue(getObject) {
     });
 }
 
+function isReassignedExportsMember(variable, exportNamesByVariable) {
+    return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
+}
+
+class VariableDeclarator extends NodeBase {
+    declareDeclarator(kind) {
+        this.id.declare(kind, this.init || UNDEFINED_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        this.id.deoptimizePath(path);
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        const initEffect = this.init?.hasEffects(context);
+        this.id.markDeclarationReached();
+        return initEffect || this.id.hasEffects(context);
+    }
+    include(context, includeChildrenRecursively) {
+        const { deoptimized, id, init } = this;
+        if (!deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        init?.include(context, includeChildrenRecursively);
+        id.markDeclarationReached();
+        if (includeChildrenRecursively || id.shouldBeIncluded(context)) {
+            id.include(context, includeChildrenRecursively);
+        }
+    }
+    render(code, options) {
+        const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
+        const { end, id, init, start } = this;
+        const renderId = id.included;
+        if (renderId) {
+            id.render(code, options);
+        }
+        else {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', id.end);
+            code.remove(start, findNonWhiteSpace(code.original, operatorPos + 1));
+        }
+        if (init) {
+            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+                const renderedVariable = id.variable.getName(getPropertyAccess);
+                if (renderedVariable !== id.name) {
+                    code.appendLeft(init.start + 5, ` ${id.name}`);
+                }
+            }
+            init.render(code, options, renderId ? BLANK : { renderedSurroundingElement: ExpressionStatement$1 });
+        }
+        else if (id instanceof Identifier &&
+            isReassignedExportsMember(id.variable, exportNamesByVariable)) {
+            code.appendLeft(end, `${_}=${_}void 0`);
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { id, init } = this;
+        if (init && id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+            const { name, variable } = id;
+            for (const accessedVariable of init.scope.accessedOutsideVariables.values()) {
+                if (accessedVariable !== variable) {
+                    accessedVariable.forbidName(name);
+                }
+            }
+        }
+    }
+}
+
 // TODO once ImportExpression follows official ESTree specs with "null" as
 //  default, keys.ts should be updated
 class ImportExpression extends NodeBase {
@@ -11001,6 +11084,79 @@ class ImportExpression extends NodeBase {
     bind() {
         this.source.bind();
     }
+    /**
+     * Get imported variables for deterministic usage, valid cases are:
+     *
+     * - `const { foo } = await import('bar')`.
+     * - `(await import('bar')).foo`
+     * - `import('bar').then(({ foo }) => {})`
+     *
+     * Returns empty array if it's side-effect only import.
+     * Returns undefined if it's not fully deterministic.
+     */
+    getDeterministicImportedNames() {
+        const parent1 = this.parent;
+        // Side-effect only: import('bar')
+        if (parent1 instanceof ExpressionStatement) {
+            return EMPTY_ARRAY;
+        }
+        if (parent1 instanceof AwaitExpression) {
+            const parent2 = parent1.parent;
+            // Side-effect only: await import('bar')
+            if (parent2 instanceof ExpressionStatement) {
+                return EMPTY_ARRAY;
+            }
+            // Case 1: const { foo } = await import('bar')
+            if (parent2 instanceof VariableDeclarator) {
+                const declaration = parent2.id;
+                return declaration instanceof ObjectPattern
+                    ? getDeterministicObjectDestructure(declaration)
+                    : undefined;
+            }
+            // Case 2: (await import('bar')).foo
+            if (parent2 instanceof MemberExpression) {
+                const id = parent2.property;
+                if (!parent2.computed && id instanceof Identifier) {
+                    return [id.name];
+                }
+            }
+            return;
+        }
+        // Case 3: import('bar').then(({ foo }) => {})
+        if (parent1 instanceof MemberExpression) {
+            const callExpression = parent1.parent;
+            const property = parent1.property;
+            if (!(callExpression instanceof CallExpression) || !(property instanceof Identifier)) {
+                return;
+            }
+            const memberName = property.name;
+            // side-effect only, when only chaining .catch or .finally
+            if (callExpression.parent instanceof ExpressionStatement &&
+                ['catch', 'finally'].includes(memberName)) {
+                return EMPTY_ARRAY;
+            }
+            if (memberName !== 'then')
+                return;
+            // Side-effect only: import('bar').then()
+            if (callExpression.arguments.length === 0) {
+                return EMPTY_ARRAY;
+            }
+            const argument = callExpression.arguments[0];
+            if (callExpression.arguments.length !== 1 ||
+                !(argument instanceof ArrowFunctionExpression || argument instanceof FunctionExpression)) {
+                return;
+            }
+            // Side-effect only: import('bar').then(() => {})
+            if (argument.params.length === 0) {
+                return EMPTY_ARRAY;
+            }
+            const declaration = argument.params[0];
+            if (argument.params.length === 1 && declaration instanceof ObjectPattern) {
+                return getDeterministicObjectDestructure(declaration);
+            }
+            return;
+        }
+    }
     hasEffects() {
         return true;
     }
@@ -11192,6 +11348,15 @@ const accessedImportGlobals = {
     cjs: ['require'],
     system: ['module']
 };
+function getDeterministicObjectDestructure(objectPattern) {
+    const variables = [];
+    for (const property of objectPattern.properties) {
+        if (property.type === 'RestElement' || property.computed || property.key.type !== 'Identifier')
+            return;
+        variables.push(property.key.name);
+    }
+    return variables;
+}
 
 class ImportNamespaceSpecifier extends NodeBase {
     applyDeoptimizations() { }
@@ -12436,10 +12601,6 @@ class UpdateExpression extends NodeBase {
     }
 }
 
-function isReassignedExportsMember(variable, exportNamesByVariable) {
-    return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
-}
-
 function areAllDeclarationsIncludedAndNotExported(declarations, exportNamesByVariable) {
     for (const declarator of declarations) {
         if (!declarator.id.included)
@@ -12616,70 +12777,6 @@ function gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregat
     return singleSystemExport;
 }
 
-class VariableDeclarator extends NodeBase {
-    declareDeclarator(kind) {
-        this.id.declare(kind, this.init || UNDEFINED_EXPRESSION);
-    }
-    deoptimizePath(path) {
-        this.id.deoptimizePath(path);
-    }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        const initEffect = this.init?.hasEffects(context);
-        this.id.markDeclarationReached();
-        return initEffect || this.id.hasEffects(context);
-    }
-    include(context, includeChildrenRecursively) {
-        const { deoptimized, id, init } = this;
-        if (!deoptimized)
-            this.applyDeoptimizations();
-        this.included = true;
-        init?.include(context, includeChildrenRecursively);
-        id.markDeclarationReached();
-        if (includeChildrenRecursively || id.shouldBeIncluded(context)) {
-            id.include(context, includeChildrenRecursively);
-        }
-    }
-    render(code, options) {
-        const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
-        const { end, id, init, start } = this;
-        const renderId = id.included;
-        if (renderId) {
-            id.render(code, options);
-        }
-        else {
-            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', id.end);
-            code.remove(start, findNonWhiteSpace(code.original, operatorPos + 1));
-        }
-        if (init) {
-            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
-                const renderedVariable = id.variable.getName(getPropertyAccess);
-                if (renderedVariable !== id.name) {
-                    code.appendLeft(init.start + 5, ` ${id.name}`);
-                }
-            }
-            init.render(code, options, renderId ? BLANK : { renderedSurroundingElement: ExpressionStatement$1 });
-        }
-        else if (id instanceof Identifier &&
-            isReassignedExportsMember(id.variable, exportNamesByVariable)) {
-            code.appendLeft(end, `${_}=${_}void 0`);
-        }
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        const { id, init } = this;
-        if (init && id instanceof Identifier && init instanceof ClassExpression && !init.id) {
-            const { name, variable } = id;
-            for (const accessedVariable of init.scope.accessedOutsideVariables.values()) {
-                if (accessedVariable !== variable) {
-                    accessedVariable.forbidName(name);
-                }
-            }
-        }
-    }
-}
-
 class WhileStatement extends NodeBase {
     hasEffects(context) {
         if (this.test.hasEffects(context))
@@ -12880,7 +12977,9 @@ class NamespaceVariable extends Variable {
     renderBlock(options) {
         const { exportNamesByVariable, format, freeze, indent: t, namespaceToStringTag, snippets: { _, cnst, getObject, getPropertyAccess, n, s } } = options;
         const memberVariables = this.getMemberVariables();
-        const members = Object.entries(memberVariables).map(([name, original]) => {
+        const members = Object.entries(memberVariables)
+            .filter(([_, variable]) => variable.included)
+            .map(([name, original]) => {
             if (this.referencedEarly || original.isReassigned) {
                 return [
                     null,
@@ -13582,6 +13681,28 @@ class Module {
         this.ast.include(createInclusionContext(), true);
         this.includeAllExports(false);
     }
+    includeExportsByNames(names) {
+        if (!this.isExecuted) {
+            markModuleAndImpureDependenciesAsExecuted(this);
+            this.graph.needsTreeshakingPass = true;
+        }
+        let includeNamespaceMembers = false;
+        for (const name of names) {
+            const variable = this.getVariableForExportName(name)[0];
+            if (variable) {
+                variable.deoptimizePath(UNKNOWN_PATH);
+                if (!variable.included) {
+                    this.includeVariable(variable);
+                }
+            }
+            if (!this.exports.has(name) && !this.reexportDescriptions.has(name)) {
+                includeNamespaceMembers = true;
+            }
+        }
+        if (includeNamespaceMembers) {
+            this.namespace.setMergedNamespaces(this.includeAndGetAdditionalMergedNamespaces());
+        }
+    }
     isIncluded() {
         // Modules where this.ast is missing have been loaded via this.load and are
         // not yet fully processed, hence they cannot be included.
@@ -13974,7 +14095,15 @@ class Module {
         const resolution = this.dynamicImports.find(dynamicImport => dynamicImport.node === node).resolution;
         if (resolution instanceof Module) {
             resolution.includedDynamicImporters.push(this);
-            resolution.includeAllExports(true);
+            const importedNames = this.options.treeshake
+                ? node.getDeterministicImportedNames()
+                : undefined;
+            if (importedNames) {
+                resolution.includeExportsByNames(importedNames);
+            }
+            else {
+                resolution.includeAllExports(true);
+            }
         }
     }
     includeVariable(variable) {
@@ -14250,12 +14379,6 @@ function updateExtensionForRelativeAmdId(id, forceJsExtensionForImports) {
     return forceJsExtensionForImports ? addJsExtension(id) : removeJsExtension(id);
 }
 
-var _staticExports = {};
-var _static = {
-  get exports(){ return _staticExports; },
-  set exports(v){ _staticExports = v; },
-};
-
 const require$$0 = [
 	"assert",
 	"async_hooks",
@@ -14300,11 +14423,9 @@ const require$$0 = [
 	"zlib"
 ];
 
-(function (module) {
-	module.exports = require$$0;
-} (_static));
+var _static = require$$0;
 
-const builtinModules = /*@__PURE__*/getDefaultExportFromCjs(_staticExports);
+const builtinModules = /*@__PURE__*/getDefaultExportFromCjs(_static);
 
 const nodeBuiltins = new Set([
     ...builtinModules,
@@ -26167,4 +26288,4 @@ async function watchInternal(configs, emitter) {
     new Watcher(watchOptionsList, emitter);
 }
 
-export { createFilter, defineConfig, fseventsImporter, getAugmentedNamespace, picomatchExports, rollup, rollupInternal, version$1 as version, watch };
+export { createFilter, defineConfig, fseventsImporter, getAugmentedNamespace, picomatch, rollup, rollupInternal, version$1 as version, watch };