rollup 2.50.1 → 2.50.5

package/dist/es/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.50.1
-	Wed, 26 May 2021 07:27:41 GMT - commit 9a50fbb35a0c5be4fc0a6ec37a06827bab99923b
+	Rollup.js v2.50.5
+	Sun, 30 May 2021 18:56:20 GMT - commit b3d130b1a5448a2abc07fa3d7cde749c3169d220
 
 
 	https://github.com/rollup/rollup

package/dist/es/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.50.1
-	Wed, 26 May 2021 07:27:41 GMT - commit 9a50fbb35a0c5be4fc0a6ec37a06827bab99923b
+	Rollup.js v2.50.5
+	Sun, 30 May 2021 18:56:20 GMT - commit b3d130b1a5448a2abc07fa3d7cde749c3169d220
 
 
 	https://github.com/rollup/rollup
@@ -14,7 +14,7 @@ import * as fs from 'fs';
 import { lstatSync, realpathSync, readdirSync } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.50.1";
+var version$1 = "2.50.5";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -3397,10 +3397,11 @@ const knownGlobals = {
     Promise: {
         __proto__: null,
         [ValueProperties]: IMPURE,
-        all: PF,
+        all: O,
         prototype: O,
-        race: PF,
-        resolve: PF
+        race: O,
+        reject: O,
+        resolve: O
     },
     propertyIsEnumerable: O,
     Proxy: O,
@@ -4194,6 +4195,7 @@ class Identifier extends NodeBase {
         this.deoptimized = true;
         if (this.variable !== null && this.variable instanceof LocalVariable) {
             this.variable.consolidateInitializers();
+            this.context.requestTreeshakingPass();
         }
     }
     disallowImportReassignment() {
@@ -4720,7 +4722,7 @@ class Method extends ExpressionEntity {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         var _a, _b;
         if (path.length > 0 ||
-            (this.description.mutatesSelfAsArray &&
+            (this.description.mutatesSelfAsArray === true &&
                 ((_a = callOptions.thisParam) === null || _a === void 0 ? void 0 : _a.hasEffectsWhenAssignedAtPath(UNKNOWN_INTEGER_PATH, context)))) {
             return true;
         }
@@ -4985,11 +4987,16 @@ class SpreadElement extends NodeBase {
             this.argument.deoptimizeThisOnEventAtPath(event, [UnknownKey, ...path], thisParameter, recursionTracker);
         }
     }
+    hasEffects(context) {
+        return (this.argument.hasEffects(context) ||
+            this.argument.hasEffectsWhenAccessedAtPath(UNKNOWN_PATH, context));
+    }
     applyDeoptimizations() {
         this.deoptimized = true;
         // Only properties of properties of the argument could become subject to reassignment
         // This will also reassign the return values of iterators
         this.argument.deoptimizePath([UnknownKey, UnknownKey]);
+        this.context.requestTreeshakingPass();
     }
 }
 
@@ -5139,6 +5146,7 @@ class RestElement extends NodeBase {
         this.deoptimized = true;
         if (this.declarationInit !== null) {
             this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.context.requestTreeshakingPass();
         }
     }
 }
@@ -5176,7 +5184,7 @@ class FunctionNode extends NodeBase {
         }
     }
     getReturnExpressionWhenCalledAtPath(path) {
-        return path.length === 0 ? this.scope.getReturnExpression() : UNKNOWN_EXPRESSION;
+        return !this.async && path.length === 0 ? this.scope.getReturnExpression() : UNKNOWN_EXPRESSION;
     }
     hasEffects() {
         return this.id !== null && this.id.hasEffects();
@@ -5195,6 +5203,12 @@ class FunctionNode extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         if (path.length > 0)
             return true;
+        if (this.async &&
+            this.scope
+                .getReturnExpression()
+                .hasEffectsWhenCalledAtPath(['then'], { args: NO_ARGS, thisParam: null, withNew: false }, context)) {
+            return true;
+        }
         for (const param of this.params) {
             if (param.hasEffects(context))
                 return true;
@@ -5622,42 +5636,42 @@ const NEW_ARRAY_PROPERTIES = [
     { key: UnknownInteger, kind: 'init', property: UNKNOWN_EXPRESSION },
     { key: 'length', kind: 'init', property: UNKNOWN_LITERAL_NUMBER }
 ];
-const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_BOOLEAN = [
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN = [
     new Method({
         callsArgs: [0],
-        mutatesSelfAsArray: true,
+        mutatesSelfAsArray: 'deopt-only',
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
     })
 ];
-const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_NUMBER = [
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER = [
     new Method({
         callsArgs: [0],
-        mutatesSelfAsArray: true,
+        mutatesSelfAsArray: 'deopt-only',
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_NUMBER
     })
 ];
-const METHOD_RETURNS_NEW_ARRAY = [
+const METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY = [
     new Method({
         callsArgs: null,
-        mutatesSelfAsArray: false,
+        mutatesSelfAsArray: true,
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
     })
 ];
-const METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY = [
+const METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
     new Method({
         callsArgs: null,
-        mutatesSelfAsArray: true,
+        mutatesSelfAsArray: 'deopt-only',
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
     })
 ];
-const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_NEW_ARRAY = [
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
     new Method({
         callsArgs: [0],
-        mutatesSelfAsArray: true,
+        mutatesSelfAsArray: 'deopt-only',
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
     })
@@ -5678,10 +5692,18 @@ const METHOD_MUTATES_SELF_RETURNS_UNKNOWN = [
         returnsPrimitive: UNKNOWN_EXPRESSION
     })
 ];
-const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_UNKNOWN = [
+const METHOD_DEOPTS_SELF_RETURNS_UNKNOWN = [
+    new Method({
+        callsArgs: null,
+        mutatesSelfAsArray: 'deopt-only',
+        returns: null,
+        returnsPrimitive: UNKNOWN_EXPRESSION
+    })
+];
+const METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN = [
     new Method({
         callsArgs: [0],
-        mutatesSelfAsArray: true,
+        mutatesSelfAsArray: 'deopt-only',
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
     })
@@ -5705,34 +5727,34 @@ const METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF = [
 const ARRAY_PROTOTYPE = new ObjectEntity({
     __proto__: null,
     // We assume that accessors have effects as we do not track the accessed value afterwards
-    at: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
-    concat: METHOD_RETURNS_NEW_ARRAY,
+    at: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN,
+    concat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     copyWithin: METHOD_MUTATES_SELF_RETURNS_SELF,
-    entries: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
-    every: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_BOOLEAN,
+    entries: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    every: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
     fill: METHOD_MUTATES_SELF_RETURNS_SELF,
-    filter: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_NEW_ARRAY,
-    find: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_UNKNOWN,
-    findIndex: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_NUMBER,
-    forEach: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_UNKNOWN,
+    filter: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    find: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    findIndex: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER,
+    forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     includes: METHOD_RETURNS_BOOLEAN,
     indexOf: METHOD_RETURNS_NUMBER,
     join: METHOD_RETURNS_STRING,
     keys: METHOD_RETURNS_UNKNOWN,
     lastIndexOf: METHOD_RETURNS_NUMBER,
-    map: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_NEW_ARRAY,
+    map: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     pop: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
     push: METHOD_MUTATES_SELF_RETURNS_NUMBER,
-    reduce: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_UNKNOWN,
-    reduceRight: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_UNKNOWN,
+    reduce: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    reduceRight: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     reverse: METHOD_MUTATES_SELF_RETURNS_SELF,
     shift: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
-    slice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
-    some: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_BOOLEAN,
+    slice: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
+    some: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN,
     sort: METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF,
     splice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
     unshift: METHOD_MUTATES_SELF_RETURNS_NUMBER,
-    values: METHOD_MUTATES_SELF_RETURNS_UNKNOWN
+    values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
 }, OBJECT_PROTOTYPE);
 
 class ArrayExpression extends NodeBase {
@@ -6060,6 +6082,7 @@ class AssignmentExpression extends NodeBase {
         this.deoptimized = true;
         this.left.deoptimizePath(EMPTY_PATH);
         this.right.deoptimizePath(UNKNOWN_PATH);
+        this.context.requestTreeshakingPass();
     }
 }
 
@@ -6088,12 +6111,20 @@ class AssignmentPattern extends NodeBase {
         this.deoptimized = true;
         this.left.deoptimizePath(EMPTY_PATH);
         this.right.deoptimizePath(UNKNOWN_PATH);
+        this.context.requestTreeshakingPass();
     }
 }
 
 class AwaitExpression extends NodeBase {
     hasEffects(context) {
-        return !context.ignore.returnAwaitYield || this.argument.hasEffects(context);
+        const { propertyReadSideEffects } = this.context.options
+            .treeshake;
+        return (!context.ignore.returnAwaitYield ||
+            this.argument.hasEffects(context) ||
+            this.argument.hasEffectsWhenCalledAtPath(['then'], { args: NO_ARGS, thisParam: null, withNew: false }, context) ||
+            (propertyReadSideEffects &&
+                (propertyReadSideEffects === 'always' ||
+                    this.argument.hasEffectsWhenAccessedAtPath(['then'], context))));
     }
     include(context, includeChildrenRecursively) {
         if (!this.included) {
@@ -6374,10 +6405,9 @@ class MemberExpression extends NodeBase {
         this.propertyKey = getResolvablePropertyKey(this);
     }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = BLANK) {
-        const isCalleeOfDifferentParent = renderedParentType === CallExpression$1 && isCalleeOfRenderedParent;
         if (this.variable || this.replacement) {
             let replacement = this.variable ? this.variable.getName() : this.replacement;
-            if (isCalleeOfDifferentParent)
+            if (renderedParentType && isCalleeOfRenderedParent)
                 replacement = '0, ' + replacement;
             code.overwrite(this.start, this.end, replacement, {
                 contentOnly: true,
@@ -6385,7 +6415,7 @@ class MemberExpression extends NodeBase {
             });
         }
         else {
-            if (isCalleeOfDifferentParent) {
+            if (renderedParentType && isCalleeOfRenderedParent) {
                 code.appendRight(this.start, '0, ');
             }
             const surroundingElement = renderedParentType || renderedSurroundingElement;
@@ -6409,6 +6439,7 @@ class MemberExpression extends NodeBase {
             if (this.parent instanceof AssignmentExpression) {
                 this.object.deoptimizeThisOnEventAtPath(EVENT_ASSIGNED, [this.propertyKey], this.object, SHARED_RECURSION_TRACKER);
             }
+            this.context.requestTreeshakingPass();
         }
     }
     disallowNamespaceReassignment() {
@@ -6593,7 +6624,10 @@ class CallExpression extends NodeBase {
     }
     render(code, options, { renderedParentType, renderedSurroundingElement } = BLANK) {
         const surroundingELement = renderedParentType || renderedSurroundingElement;
-        this.callee.render(code, options, surroundingELement ? { renderedSurroundingElement: surroundingELement } : BLANK);
+        this.callee.render(code, options, {
+            isCalleeOfRenderedParent: true,
+            renderedSurroundingElement: surroundingELement
+        });
         if (this.arguments.length > 0) {
             if (this.arguments[this.arguments.length - 1].included) {
                 for (const arg of this.arguments) {
@@ -6627,6 +6661,7 @@ class CallExpression extends NodeBase {
             // This will make sure all properties of parameters behave as "unknown"
             argument.deoptimizePath(UNKNOWN_PATH);
         }
+        this.context.requestTreeshakingPass();
     }
     getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
         if (this.returnExpression === null) {
@@ -6639,12 +6674,14 @@ class CallExpression extends NodeBase {
 
 class CatchScope extends ParameterScope {
     addDeclaration(identifier, context, init, isHoisted) {
-        if (isHoisted) {
-            return this.parent.addDeclaration(identifier, context, init, isHoisted);
-        }
-        else {
-            return super.addDeclaration(identifier, context, init, false);
+        const existingParameter = this.variables.get(identifier.name);
+        if (existingParameter) {
+            existingParameter.addDeclaration(identifier, init);
+            return existingParameter;
         }
+        // as parameters are handled differently, all remaining declarations are
+        // hoisted
+        return this.parent.addDeclaration(identifier, context, init, isHoisted);
     }
 }
 
@@ -6652,17 +6689,19 @@ class CatchClause extends NodeBase {
     createScope(parentScope) {
         this.scope = new CatchScope(parentScope, this.context);
     }
-    initialise() {
-        if (this.param) {
+    parseNode(esTreeNode) {
+        // Parameters need to be declared first as the logic is that hoisted body
+        // variables are associated with outside vars unless there is a parameter,
+        // in which case they are associated with the parameter
+        const { param } = esTreeNode;
+        if (param) {
+            this.param = new (this.context.nodeConstructors[param.type] ||
+                this.context.nodeConstructors.UnknownNode)(param, this, this.scope);
             this.param.declare('parameter', UNKNOWN_EXPRESSION);
         }
-    }
-    parseNode(esTreeNode) {
-        this.body = new this.context.nodeConstructors.BlockStatement(esTreeNode.body, this, this.scope);
         super.parseNode(esTreeNode);
     }
 }
-CatchClause.prototype.preventChildBlockScope = true;
 
 class ChainExpression extends NodeBase {
 }
@@ -6859,7 +6898,7 @@ class ConditionalExpression extends NodeBase {
             usedBranch.includeCallArguments(context, args);
         }
     }
-    render(code, options, { isCalleeOfRenderedParent, renderedParentType, preventASI } = BLANK) {
+    render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
         const usedBranch = this.getUsedBranch();
         if (!this.test.included) {
             const colonPos = findFirstOccurrenceOutsideComment(code.original, ':', this.consequent.end);
@@ -6875,16 +6914,16 @@ class ConditionalExpression extends NodeBase {
             }
             removeAnnotations(this, code);
             usedBranch.render(code, options, {
-                isCalleeOfRenderedParent: renderedParentType
-                    ? isCalleeOfRenderedParent
-                    : this.parent.callee === this,
+                isCalleeOfRenderedParent,
                 preventASI: true,
-                renderedParentType: renderedParentType || this.parent.type
+                ...(renderedSurroundingElement
+                    ? { renderedSurroundingElement }
+                    : { renderedParentType: renderedParentType || this.parent.type })
             });
         }
         else {
             this.test.render(code, options, {
-                renderedSurroundingElement: renderedParentType
+                renderedSurroundingElement: renderedParentType || renderedSurroundingElement
             });
             this.consequent.render(code, options);
             this.alternate.render(code, options);
@@ -7032,6 +7071,7 @@ class ForInStatement extends NodeBase {
     applyDeoptimizations() {
         this.deoptimized = true;
         this.left.deoptimizePath(EMPTY_PATH);
+        this.context.requestTreeshakingPass();
     }
 }
 
@@ -7071,6 +7111,7 @@ class ForOfStatement extends NodeBase {
     applyDeoptimizations() {
         this.deoptimized = true;
         this.left.deoptimizePath(EMPTY_PATH);
+        this.context.requestTreeshakingPass();
     }
 }
 
@@ -7712,11 +7753,11 @@ class LogicalExpression extends NodeBase {
             }
             removeAnnotations(this, code);
             this.getUsedBranch().render(code, options, {
-                isCalleeOfRenderedParent: renderedParentType
-                    ? isCalleeOfRenderedParent
-                    : this.parent.callee === this,
+                isCalleeOfRenderedParent,
                 preventASI,
-                renderedParentType: renderedParentType || this.parent.type
+                ...(renderedSurroundingElement
+                    ? { renderedSurroundingElement }
+                    : { renderedParentType: renderedParentType || this.parent.type })
             });
         }
         else {
@@ -8320,6 +8361,7 @@ class NewExpression extends NodeBase {
             // This will make sure all properties of parameters behave as "unknown"
             argument.deoptimizePath(UNKNOWN_PATH);
         }
+        this.context.requestTreeshakingPass();
     }
 }
 
@@ -8365,6 +8407,7 @@ class ObjectExpression extends NodeBase {
         if (this.objectEntity !== null) {
             return this.objectEntity;
         }
+        let prototype = OBJECT_PROTOTYPE;
         const properties = [];
         for (const property of this.properties) {
             if (property instanceof SpreadElement) {
@@ -8388,13 +8431,16 @@ class ObjectExpression extends NodeBase {
                         ? property.key.name
                         : String(property.key.value);
                 if (key === '__proto__' && property.kind === 'init') {
-                    properties.unshift({ key: UnknownKey, kind: 'init', property: UNKNOWN_EXPRESSION });
+                    prototype =
+                        property.value instanceof Literal && property.value.value === null
+                            ? null
+                            : property.value;
                     continue;
                 }
             }
             properties.push({ key, kind: property.kind, property });
         }
-        return (this.objectEntity = new ObjectEntity(properties, OBJECT_PROTOTYPE));
+        return (this.objectEntity = new ObjectEntity(properties, prototype));
     }
 }
 
@@ -8466,6 +8512,7 @@ class Property extends MethodBase {
         this.deoptimized = true;
         if (this.declarationInit !== null) {
             this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.context.requestTreeshakingPass();
         }
     }
 }
@@ -8534,13 +8581,10 @@ class ReturnStatement extends NodeBase {
 
 class SequenceExpression extends NodeBase {
     deoptimizePath(path) {
-        if (path.length > 0)
-            this.expressions[this.expressions.length - 1].deoptimizePath(path);
+        this.expressions[this.expressions.length - 1].deoptimizePath(path);
     }
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        if (event === EVENT_CALLED || path.length > 0) {
-            this.expressions[this.expressions.length - 1].deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
-        }
+        this.expressions[this.expressions.length - 1].deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.expressions[this.expressions.length - 1].getLiteralValueAtPath(path, recursionTracker, origin);
@@ -8557,8 +8601,7 @@ class SequenceExpression extends NodeBase {
             this.expressions[this.expressions.length - 1].hasEffectsWhenAccessedAtPath(path, context));
     }
     hasEffectsWhenAssignedAtPath(path, context) {
-        return (path.length === 0 ||
-            this.expressions[this.expressions.length - 1].hasEffectsWhenAssignedAtPath(path, context));
+        return this.expressions[this.expressions.length - 1].hasEffectsWhenAssignedAtPath(path, context);
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return this.expressions[this.expressions.length - 1].hasEffectsWhenCalledAtPath(path, callOptions, context);
@@ -8587,13 +8630,18 @@ class SequenceExpression extends NodeBase {
             if (includedNodes === 1 && preventASI) {
                 removeLineBreaks(code, start, node.start);
             }
-            if (node === lastNode && includedNodes === 1) {
-                node.render(code, options, {
-                    isCalleeOfRenderedParent: renderedParentType
-                        ? isCalleeOfRenderedParent
-                        : this.parent.callee === this,
-                    renderedParentType: renderedParentType || this.parent.type
-                });
+            if (includedNodes === 1) {
+                if (node === lastNode) {
+                    node.render(code, options, {
+                        isCalleeOfRenderedParent,
+                        renderedParentType: renderedParentType || this.parent.type
+                    });
+                }
+                else {
+                    node.render(code, options, {
+                        renderedSurroundingElement: renderedParentType || this.parent.type
+                    });
+                }
             }
             else {
                 node.render(code, options);
@@ -8740,13 +8788,6 @@ class TaggedTemplateExpression extends NodeBase {
                     message: `Cannot call a namespace ('${name}')`
                 }, this.start);
             }
-            if (name === 'eval') {
-                this.context.warn({
-                    code: 'EVAL',
-                    message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
-                    url: 'https://rollupjs.org/guide/en/#avoiding-eval'
-                }, this.start);
-            }
         }
     }
     hasEffects(context) {
@@ -8760,6 +8801,10 @@ class TaggedTemplateExpression extends NodeBase {
             withNew: false
         };
     }
+    render(code, options) {
+        this.tag.render(code, options, { isCalleeOfRenderedParent: true });
+        this.quasi.render(code, options);
+    }
 }
 
 class TemplateElement extends NodeBase {
@@ -9031,6 +9076,7 @@ class UnaryExpression extends NodeBase {
         this.deoptimized = true;
         if (this.operator === 'delete') {
             this.argument.deoptimizePath(EMPTY_PATH);
+            this.context.requestTreeshakingPass();
         }
     }
 }
@@ -9099,6 +9145,7 @@ class UpdateExpression extends NodeBase {
             const variable = this.scope.findVariable(this.argument.name);
             variable.isReassigned = true;
         }
+        this.context.requestTreeshakingPass();
     }
 }
 
@@ -9184,9 +9231,12 @@ class YieldExpression extends NodeBase {
         }
     }
     applyDeoptimizations() {
-        var _a;
         this.deoptimized = true;
-        (_a = this.argument) === null || _a === void 0 ? void 0 : _a.deoptimizePath(UNKNOWN_PATH);
+        const { argument } = this;
+        if (argument) {
+            argument.deoptimizePath(UNKNOWN_PATH);
+            this.context.requestTreeshakingPass();
+        }
     }
 }
 
@@ -9775,14 +9825,14 @@ class Module {
             }
             necessaryDependencies.add(variable.module);
         }
-        if (this.options.treeshake && this.info.hasModuleSideEffects !== 'no-treeshake') {
-            this.addRelevantSideEffectDependencies(relevantDependencies, necessaryDependencies, alwaysCheckedDependencies);
-        }
-        else {
+        if (!this.options.treeshake || this.info.hasModuleSideEffects === 'no-treeshake') {
             for (const dependency of this.dependencies) {
-                relevantDependencies.add(dependency);
+                if (dependency instanceof ExternalModule || dependency.isIncluded()) {
+                    relevantDependencies.add(dependency);
+                }
             }
         }
+        this.addRelevantSideEffectDependencies(relevantDependencies, necessaryDependencies, alwaysCheckedDependencies);
         for (const dependency of necessaryDependencies) {
             relevantDependencies.add(dependency);
         }
@@ -10052,6 +10102,7 @@ class Module {
             moduleContext: this.context,
             nodeConstructors,
             options: this.options,
+            requestTreeshakingPass: () => (this.graph.needsTreeshakingPass = true),
             traceExport: this.getVariableForExportName.bind(this),
             traceVariable: this.traceVariable.bind(this),
             usesTopLevelAwait: false,

package/dist/es/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.50.1
-	Wed, 26 May 2021 07:27:41 GMT - commit 9a50fbb35a0c5be4fc0a6ec37a06827bab99923b
+	Rollup.js v2.50.5
+	Sun, 30 May 2021 18:56:20 GMT - commit b3d130b1a5448a2abc07fa3d7cde749c3169d220
 
 
 	https://github.com/rollup/rollup

package/dist/loadConfigFile.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.50.1
-	Wed, 26 May 2021 07:27:41 GMT - commit 9a50fbb35a0c5be4fc0a6ec37a06827bab99923b
+	Rollup.js v2.50.5
+	Sun, 30 May 2021 18:56:20 GMT - commit b3d130b1a5448a2abc07fa3d7cde749c3169d220
 
 
 	https://github.com/rollup/rollup