rollup 1.27.6 → 1.27.10

package/dist/rollup.es.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v1.27.6
-	Sat, 30 Nov 2019 19:48:08 GMT - commit 5a01f0536e1bcf94dd3489926fe7081c716af705
+	Rollup.js v1.27.10
+	Wed, 11 Dec 2019 08:12:01 GMT - commit a562ec571b1a9e6f12ddfb8b8ef6aef4d5212cf8
 
 
 	https://github.com/rollup/rollup
@@ -50,7 +50,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-var version = "1.27.6";
+var version = "1.27.10";
 
 var charToInteger = {};
 var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1912,7 +1912,7 @@ class PathTracker {
         return currentPaths[EntitiesKey];
     }
 }
-const EMPTY_IMMUTABLE_TRACKER = new PathTracker();
+const SHARED_RECURSION_TRACKER = new PathTracker();
 
 const BROKEN_FLOW_NONE = 0;
 const BROKEN_FLOW_BREAK_CONTINUE = 1;
@@ -6362,7 +6362,7 @@ class BinaryExpression extends NodeBase {
         // support some implicit type coercion runtime errors
         if (this.operator === '+' &&
             this.parent instanceof ExpressionStatement$1 &&
-            this.left.getLiteralValueAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this) === '')
+            this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '')
             return true;
         return super.hasEffects(context);
     }
@@ -6396,12 +6396,282 @@ class BreakStatement extends NodeBase {
     }
 }
 
+class Literal extends NodeBase {
+    getLiteralValueAtPath(path) {
+        if (path.length > 0 ||
+            // unknown literals can also be null but do not start with an "n"
+            (this.value === null && this.context.code.charCodeAt(this.start) !== 110) ||
+            typeof this.value === 'bigint' ||
+            // to support shims for regular expressions
+            this.context.code.charCodeAt(this.start) === 47) {
+            return UnknownValue;
+        }
+        return this.value;
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        if (path.length !== 1)
+            return UNKNOWN_EXPRESSION;
+        return getMemberReturnExpressionWhenCalled(this.members, path[0]);
+    }
+    hasEffectsWhenAccessedAtPath(path) {
+        if (this.value === null) {
+            return path.length > 0;
+        }
+        return path.length > 1;
+    }
+    hasEffectsWhenAssignedAtPath(path) {
+        return path.length > 0;
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (path.length === 1) {
+            return hasMemberEffectWhenCalled(this.members, path[0], this.included, callOptions, context);
+        }
+        return true;
+    }
+    initialise() {
+        this.members = getLiteralMembersForValue(this.value);
+    }
+    render(code) {
+        if (typeof this.value === 'string') {
+            code.indentExclusionRanges.push([this.start + 1, this.end - 1]);
+        }
+    }
+}
+
+function getResolvablePropertyKey(memberExpression) {
+    return memberExpression.computed
+        ? getResolvableComputedPropertyKey(memberExpression.property)
+        : memberExpression.property.name;
+}
+function getResolvableComputedPropertyKey(propertyKey) {
+    if (propertyKey instanceof Literal) {
+        return String(propertyKey.value);
+    }
+    return null;
+}
+function getPathIfNotComputed(memberExpression) {
+    const nextPathKey = memberExpression.propertyKey;
+    const object = memberExpression.object;
+    if (typeof nextPathKey === 'string') {
+        if (object instanceof Identifier$1) {
+            return [
+                { key: object.name, pos: object.start },
+                { key: nextPathKey, pos: memberExpression.property.start }
+            ];
+        }
+        if (object instanceof MemberExpression) {
+            const parentPath = getPathIfNotComputed(object);
+            return (parentPath && [...parentPath, { key: nextPathKey, pos: memberExpression.property.start }]);
+        }
+    }
+    return null;
+}
+function getStringFromPath(path) {
+    let pathString = path[0].key;
+    for (let index = 1; index < path.length; index++) {
+        pathString += '.' + path[index].key;
+    }
+    return pathString;
+}
+class MemberExpression extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.bound = false;
+        this.expressionsToBeDeoptimized = [];
+        this.replacement = null;
+        this.wasPathDeoptimizedWhileOptimized = false;
+    }
+    addExportedVariables() { }
+    bind() {
+        if (this.bound)
+            return;
+        this.bound = true;
+        const path = getPathIfNotComputed(this);
+        const baseVariable = path && this.scope.findVariable(path[0].key);
+        if (baseVariable && baseVariable.isNamespace) {
+            const resolvedVariable = this.resolveNamespaceVariables(baseVariable, path.slice(1));
+            if (!resolvedVariable) {
+                super.bind();
+            }
+            else if (typeof resolvedVariable === 'string') {
+                this.replacement = resolvedVariable;
+            }
+            else {
+                if (resolvedVariable instanceof ExternalVariable && resolvedVariable.module) {
+                    resolvedVariable.module.suggestName(path[0].key);
+                }
+                this.variable = resolvedVariable;
+                this.scope.addNamespaceMemberAccess(getStringFromPath(path), resolvedVariable);
+            }
+        }
+        else {
+            super.bind();
+            // ensure the propertyKey is set for the tree-shaking passes
+            this.getPropertyKey();
+        }
+    }
+    deoptimizeCache() {
+        this.propertyKey = UnknownKey;
+        if (this.wasPathDeoptimizedWhileOptimized) {
+            this.object.deoptimizePath(UNKNOWN_PATH);
+        }
+        for (const expression of this.expressionsToBeDeoptimized) {
+            expression.deoptimizeCache();
+        }
+    }
+    deoptimizePath(path) {
+        if (!this.bound)
+            this.bind();
+        if (path.length === 0)
+            this.disallowNamespaceReassignment();
+        if (this.variable) {
+            this.variable.deoptimizePath(path);
+        }
+        else {
+            const propertyKey = this.getPropertyKey();
+            if (propertyKey === UnknownKey) {
+                this.object.deoptimizePath(UNKNOWN_PATH);
+            }
+            else {
+                this.wasPathDeoptimizedWhileOptimized = true;
+                this.object.deoptimizePath([propertyKey, ...path]);
+            }
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (!this.bound)
+            this.bind();
+        if (this.variable !== null) {
+            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
+        }
+        this.expressionsToBeDeoptimized.push(origin);
+        return this.object.getLiteralValueAtPath([this.getPropertyKey(), ...path], recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin) {
+        if (!this.bound)
+            this.bind();
+        if (this.variable !== null) {
+            return this.variable.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
+        }
+        this.expressionsToBeDeoptimized.push(origin);
+        return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], recursionTracker, origin);
+    }
+    hasEffects(context) {
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            (this.context.propertyReadSideEffects &&
+                this.object.hasEffectsWhenAccessedAtPath([this.propertyKey], context)));
+    }
+    hasEffectsWhenAccessedAtPath(path, context) {
+        if (path.length === 0)
+            return false;
+        if (this.variable !== null) {
+            return this.variable.hasEffectsWhenAccessedAtPath(path, context);
+        }
+        return this.object.hasEffectsWhenAccessedAtPath([this.propertyKey, ...path], context);
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        if (this.variable !== null) {
+            return this.variable.hasEffectsWhenAssignedAtPath(path, context);
+        }
+        return this.object.hasEffectsWhenAssignedAtPath([this.propertyKey, ...path], context);
+    }
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        if (this.variable !== null) {
+            return this.variable.hasEffectsWhenCalledAtPath(path, callOptions, context);
+        }
+        return this.object.hasEffectsWhenCalledAtPath([this.propertyKey, ...path], callOptions, context);
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            if (this.variable !== null) {
+                this.context.includeVariable(context, this.variable);
+            }
+        }
+        this.object.include(context, includeChildrenRecursively);
+        this.property.include(context, includeChildrenRecursively);
+    }
+    includeCallArguments(context, args) {
+        if (this.variable) {
+            this.variable.includeCallArguments(context, args);
+        }
+        else {
+            super.includeCallArguments(context, args);
+        }
+    }
+    initialise() {
+        this.propertyKey = getResolvablePropertyKey(this);
+    }
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
+        const isCalleeOfDifferentParent = renderedParentType === CallExpression && isCalleeOfRenderedParent;
+        if (this.variable || this.replacement) {
+            let replacement = this.variable ? this.variable.getName() : this.replacement;
+            if (isCalleeOfDifferentParent)
+                replacement = '0, ' + replacement;
+            code.overwrite(this.start, this.end, replacement, {
+                contentOnly: true,
+                storeName: true
+            });
+        }
+        else {
+            if (isCalleeOfDifferentParent) {
+                code.appendRight(this.start, '0, ');
+            }
+            super.render(code, options);
+        }
+    }
+    disallowNamespaceReassignment() {
+        if (this.object instanceof Identifier$1 &&
+            this.scope.findVariable(this.object.name).isNamespace) {
+            this.context.error({
+                code: 'ILLEGAL_NAMESPACE_REASSIGNMENT',
+                message: `Illegal reassignment to import '${this.object.name}'`
+            }, this.start);
+        }
+    }
+    getPropertyKey() {
+        if (this.propertyKey === null) {
+            this.propertyKey = UnknownKey;
+            const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return (this.propertyKey = value === UnknownValue ? UnknownKey : String(value));
+        }
+        return this.propertyKey;
+    }
+    resolveNamespaceVariables(baseVariable, path) {
+        if (path.length === 0)
+            return baseVariable;
+        if (!baseVariable.isNamespace)
+            return null;
+        const exportName = path[0].key;
+        const variable = baseVariable instanceof ExternalVariable
+            ? baseVariable.module.getVariableForExportName(exportName)
+            : baseVariable.context.traceExport(exportName);
+        if (!variable) {
+            const fileName = baseVariable instanceof ExternalVariable
+                ? baseVariable.module.id
+                : baseVariable.context.fileName;
+            this.context.warn({
+                code: 'MISSING_EXPORT',
+                exporter: relativeId(fileName),
+                importer: relativeId(this.context.fileName),
+                message: `'${exportName}' is not exported by '${relativeId(fileName)}'`,
+                missing: exportName,
+                url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
+            }, path[0].pos);
+            return 'undefined';
+        }
+        return this.resolveNamespaceVariables(variable, path.slice(1));
+    }
+}
+
 class CallExpression$1 extends NodeBase {
     constructor() {
         super(...arguments);
-        // We collect deoptimization information if returnExpression !== UNKNOWN_EXPRESSION
         this.expressionsToBeDeoptimized = [];
         this.returnExpression = null;
+        this.wasPathDeoptmizedWhileOptimized = false;
     }
     bind() {
         super.bind();
@@ -6421,8 +6691,11 @@ class CallExpression$1 extends NodeBase {
                 }, this.start);
             }
         }
-        if (this.returnExpression === null) {
-            this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
+        // ensure the returnExpression is set for the tree-shaking passes
+        this.getReturnExpression(SHARED_RECURSION_TRACKER);
+        // This deoptimizes "this" for non-namespace calls until we have a better solution
+        if (this.callee instanceof MemberExpression && !this.callee.variable) {
+            this.callee.object.deoptimizePath(UNKNOWN_PATH);
         }
         for (const argument of this.arguments) {
             // This will make sure all properties of parameters behave as "unknown"
@@ -6431,8 +6704,19 @@ class CallExpression$1 extends NodeBase {
     }
     deoptimizeCache() {
         if (this.returnExpression !== UNKNOWN_EXPRESSION) {
-            this.returnExpression = UNKNOWN_EXPRESSION;
-            for (const expression of this.expressionsToBeDeoptimized) {
+            this.returnExpression = null;
+            const returnExpression = this.getReturnExpression(SHARED_RECURSION_TRACKER);
+            const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
+            if (returnExpression !== UNKNOWN_EXPRESSION) {
+                // We need to replace here because is possible new expressions are added
+                // while we are deoptimizing the old ones
+                this.expressionsToBeDeoptimized = [];
+                if (this.wasPathDeoptmizedWhileOptimized) {
+                    returnExpression.deoptimizePath(UNKNOWN_PATH);
+                    this.wasPathDeoptmizedWhileOptimized = false;
+                }
+            }
+            for (const expression of expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
         }
@@ -6444,43 +6728,40 @@ class CallExpression$1 extends NodeBase {
         if (trackedEntities.has(this))
             return;
         trackedEntities.add(this);
-        if (this.returnExpression === null) {
-            this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
+        const returnExpression = this.getReturnExpression(SHARED_RECURSION_TRACKER);
+        if (returnExpression !== UNKNOWN_EXPRESSION) {
+            this.wasPathDeoptmizedWhileOptimized = true;
+            returnExpression.deoptimizePath(path);
         }
-        this.returnExpression.deoptimizePath(path);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.returnExpression === null) {
-            this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, recursionTracker, this);
-        }
-        if (this.returnExpression === UNKNOWN_EXPRESSION) {
+        const returnExpression = this.getReturnExpression(recursionTracker);
+        if (returnExpression === UNKNOWN_EXPRESSION) {
             return UnknownValue;
         }
         const trackedEntities = recursionTracker.getEntities(path);
-        if (trackedEntities.has(this.returnExpression)) {
+        if (trackedEntities.has(returnExpression)) {
             return UnknownValue;
         }
         this.expressionsToBeDeoptimized.push(origin);
-        trackedEntities.add(this.returnExpression);
-        const value = this.returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
-        trackedEntities.delete(this.returnExpression);
+        trackedEntities.add(returnExpression);
+        const value = returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+        trackedEntities.delete(returnExpression);
         return value;
     }
     getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin) {
-        if (this.returnExpression === null) {
-            this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, recursionTracker, this);
-        }
+        const returnExpression = this.getReturnExpression(recursionTracker);
         if (this.returnExpression === UNKNOWN_EXPRESSION) {
             return UNKNOWN_EXPRESSION;
         }
         const trackedEntities = recursionTracker.getEntities(path);
-        if (trackedEntities.has(this.returnExpression)) {
+        if (trackedEntities.has(returnExpression)) {
             return UNKNOWN_EXPRESSION;
         }
         this.expressionsToBeDeoptimized.push(origin);
-        trackedEntities.add(this.returnExpression);
-        const value = this.returnExpression.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
-        trackedEntities.delete(this.returnExpression);
+        trackedEntities.add(returnExpression);
+        const value = returnExpression.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
+        trackedEntities.delete(returnExpression);
         return value;
     }
     hasEffects(context) {
@@ -6574,6 +6855,13 @@ class CallExpression$1 extends NodeBase {
             code.prependLeft(this.end, ')');
         }
     }
+    getReturnExpression(recursionTracker) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_EXPRESSION;
+            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
 }
 
 class CatchScope extends ParameterScope {
@@ -6668,23 +6956,23 @@ class MultiExpression {
 class ConditionalExpression extends NodeBase {
     constructor() {
         super(...arguments);
-        // We collect deoptimization information if usedBranch !== null
         this.expressionsToBeDeoptimized = [];
         this.isBranchResolutionAnalysed = false;
-        this.unusedBranch = null;
         this.usedBranch = null;
+        this.wasPathDeoptimizedWhileOptimized = false;
     }
     bind() {
         super.bind();
-        if (!this.isBranchResolutionAnalysed)
-            this.analyseBranchResolution();
+        // ensure the usedBranch is set for the tree-shaking passes
+        this.getUsedBranch();
     }
     deoptimizeCache() {
         if (this.usedBranch !== null) {
-            // We did not track if there were reassignments to the previous branch.
-            // Also, the return value might need to be reassigned.
+            const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
             this.usedBranch = null;
-            this.unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            if (this.wasPathDeoptimizedWhileOptimized) {
+                unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            }
             for (const expression of this.expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
@@ -6692,35 +6980,33 @@ class ConditionalExpression extends NodeBase {
     }
     deoptimizePath(path) {
         if (path.length > 0) {
-            if (!this.isBranchResolutionAnalysed)
-                this.analyseBranchResolution();
-            if (this.usedBranch === null) {
+            const usedBranch = this.getUsedBranch();
+            if (usedBranch === null) {
                 this.consequent.deoptimizePath(path);
                 this.alternate.deoptimizePath(path);
             }
             else {
-                this.usedBranch.deoptimizePath(path);
+                this.wasPathDeoptimizedWhileOptimized = true;
+                usedBranch.deoptimizePath(path);
             }
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (!this.isBranchResolutionAnalysed)
-            this.analyseBranchResolution();
-        if (this.usedBranch === null)
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch === null)
             return UnknownValue;
         this.expressionsToBeDeoptimized.push(origin);
-        return this.usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
+        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin) {
-        if (!this.isBranchResolutionAnalysed)
-            this.analyseBranchResolution();
-        if (this.usedBranch === null)
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch === null)
             return new MultiExpression([
                 this.consequent.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin),
                 this.alternate.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin)
             ]);
         this.expressionsToBeDeoptimized.push(origin);
-        return this.usedBranch.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
     }
     hasEffects(context) {
         if (this.test.hasEffects(context))
@@ -6793,19 +7079,15 @@ class ConditionalExpression extends NodeBase {
             super.render(code, options);
         }
     }
-    analyseBranchResolution() {
-        this.isBranchResolutionAnalysed = true;
-        const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
-        if (testValue !== UnknownValue) {
-            if (testValue) {
-                this.usedBranch = this.consequent;
-                this.unusedBranch = this.alternate;
-            }
-            else {
-                this.usedBranch = this.alternate;
-                this.unusedBranch = this.consequent;
-            }
+    getUsedBranch() {
+        if (this.isBranchResolutionAnalysed) {
+            return this.usedBranch;
         }
+        this.isBranchResolutionAnalysed = true;
+        const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        return testValue === UnknownValue
+            ? null
+            : (this.usedBranch = testValue ? this.consequent : this.alternate);
     }
 }
 
@@ -7016,7 +7298,8 @@ class FunctionExpression$1 extends FunctionNode {
 class IfStatement extends NodeBase {
     bind() {
         super.bind();
-        this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
+        // ensure the testValue is set for the tree-shaking passes
+        this.testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
     }
     deoptimizeCache() {
         this.testValue = UnknownValue;
@@ -7277,415 +7560,157 @@ class LabeledStatement extends NodeBase {
             context.brokenFlow = brokenFlow;
         }
     }
-    render(code, options) {
-        if (this.label.included) {
-            this.label.render(code, options);
-        }
-        else {
-            code.remove(this.start, findFirstOccurrenceOutsideComment(code.original, ':', this.label.end) + 1);
-        }
-        this.body.render(code, options);
-    }
-}
-
-class Literal extends NodeBase {
-    getLiteralValueAtPath(path) {
-        if (path.length > 0 ||
-            // unknown literals can also be null but do not start with an "n"
-            (this.value === null && this.context.code.charCodeAt(this.start) !== 110) ||
-            typeof this.value === 'bigint' ||
-            // to support shims for regular expressions
-            this.context.code.charCodeAt(this.start) === 47) {
-            return UnknownValue;
-        }
-        return this.value;
-    }
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length !== 1)
-            return UNKNOWN_EXPRESSION;
-        return getMemberReturnExpressionWhenCalled(this.members, path[0]);
-    }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (this.value === null) {
-            return path.length > 0;
-        }
-        return path.length > 1;
-    }
-    hasEffectsWhenAssignedAtPath(path) {
-        return path.length > 0;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(this.members, path[0], this.included, callOptions, context);
-        }
-        return true;
-    }
-    initialise() {
-        this.members = getLiteralMembersForValue(this.value);
-    }
-    render(code) {
-        if (typeof this.value === 'string') {
-            code.indentExclusionRanges.push([this.start + 1, this.end - 1]);
-        }
-    }
-}
-
-class LogicalExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        // We collect deoptimization information if usedBranch !== null
-        this.expressionsToBeDeoptimized = [];
-        this.isBranchResolutionAnalysed = false;
-        this.unusedBranch = null;
-        this.usedBranch = null;
-    }
-    bind() {
-        super.bind();
-        if (!this.isBranchResolutionAnalysed)
-            this.analyseBranchResolution();
-    }
-    deoptimizeCache() {
-        if (this.usedBranch !== null) {
-            // We did not track if there were reassignments to any of the branches.
-            // Also, the return values might need reassignment.
-            this.usedBranch = null;
-            this.unusedBranch.deoptimizePath(UNKNOWN_PATH);
-            for (const expression of this.expressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
-            }
-        }
-    }
-    deoptimizePath(path) {
-        if (path.length > 0) {
-            if (!this.isBranchResolutionAnalysed)
-                this.analyseBranchResolution();
-            if (this.usedBranch === null) {
-                this.left.deoptimizePath(path);
-                this.right.deoptimizePath(path);
-            }
-            else {
-                this.usedBranch.deoptimizePath(path);
-            }
-        }
-    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (!this.isBranchResolutionAnalysed)
-            this.analyseBranchResolution();
-        if (this.usedBranch === null)
-            return UnknownValue;
-        this.expressionsToBeDeoptimized.push(origin);
-        return this.usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
-    }
-    getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin) {
-        if (!this.isBranchResolutionAnalysed)
-            this.analyseBranchResolution();
-        if (this.usedBranch === null)
-            return new MultiExpression([
-                this.left.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin),
-                this.right.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin)
-            ]);
-        this.expressionsToBeDeoptimized.push(origin);
-        return this.usedBranch.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
-    }
-    hasEffects(context) {
-        if (this.usedBranch === null) {
-            return this.left.hasEffects(context) || this.right.hasEffects(context);
-        }
-        return this.usedBranch.hasEffects(context);
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        if (path.length === 0)
-            return false;
-        if (this.usedBranch === null) {
-            return (this.left.hasEffectsWhenAccessedAtPath(path, context) ||
-                this.right.hasEffectsWhenAccessedAtPath(path, context));
-        }
-        return this.usedBranch.hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (path.length === 0)
-            return true;
-        if (this.usedBranch === null) {
-            return (this.left.hasEffectsWhenAssignedAtPath(path, context) ||
-                this.right.hasEffectsWhenAssignedAtPath(path, context));
-        }
-        return this.usedBranch.hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (this.usedBranch === null) {
-            return (this.left.hasEffectsWhenCalledAtPath(path, callOptions, context) ||
-                this.right.hasEffectsWhenCalledAtPath(path, callOptions, context));
-        }
-        return this.usedBranch.hasEffectsWhenCalledAtPath(path, callOptions, context);
-    }
-    include(context, includeChildrenRecursively) {
-        this.included = true;
-        if (includeChildrenRecursively ||
-            this.usedBranch === null ||
-            this.unusedBranch.shouldBeIncluded(context)) {
-            this.left.include(context, includeChildrenRecursively);
-            this.right.include(context, includeChildrenRecursively);
-        }
-        else {
-            this.usedBranch.include(context, includeChildrenRecursively);
-        }
-    }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
-        if (!this.left.included || !this.right.included) {
-            const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
-            if (this.right.included) {
-                code.remove(this.start, operatorPos + 2);
-                if (preventASI) {
-                    removeLineBreaks(code, operatorPos + 2, this.right.start);
-                }
-            }
-            else {
-                code.remove(operatorPos, this.end);
-            }
-            removeAnnotations(this, code);
-            this.usedBranch.render(code, options, {
-                isCalleeOfRenderedParent: renderedParentType
-                    ? isCalleeOfRenderedParent
-                    : this.parent.callee === this,
-                renderedParentType: renderedParentType || this.parent.type
-            });
-        }
-        else {
-            super.render(code, options);
-        }
-    }
-    analyseBranchResolution() {
-        this.isBranchResolutionAnalysed = true;
-        const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
-        if (leftValue !== UnknownValue) {
-            if (this.operator === '||' ? leftValue : !leftValue) {
-                this.usedBranch = this.left;
-                this.unusedBranch = this.right;
-            }
-            else {
-                this.usedBranch = this.right;
-                this.unusedBranch = this.left;
-            }
-        }
-    }
-}
-
-function getResolvablePropertyKey(memberExpression) {
-    return memberExpression.computed
-        ? getResolvableComputedPropertyKey(memberExpression.property)
-        : memberExpression.property.name;
-}
-function getResolvableComputedPropertyKey(propertyKey) {
-    if (propertyKey instanceof Literal) {
-        return String(propertyKey.value);
-    }
-    return null;
-}
-function getPathIfNotComputed(memberExpression) {
-    const nextPathKey = memberExpression.propertyKey;
-    const object = memberExpression.object;
-    if (typeof nextPathKey === 'string') {
-        if (object instanceof Identifier$1) {
-            return [
-                { key: object.name, pos: object.start },
-                { key: nextPathKey, pos: memberExpression.property.start }
-            ];
-        }
-        if (object instanceof MemberExpression) {
-            const parentPath = getPathIfNotComputed(object);
-            return (parentPath && [...parentPath, { key: nextPathKey, pos: memberExpression.property.start }]);
-        }
-    }
-    return null;
-}
-function getStringFromPath(path) {
-    let pathString = path[0].key;
-    for (let index = 1; index < path.length; index++) {
-        pathString += '.' + path[index].key;
+    render(code, options) {
+        if (this.label.included) {
+            this.label.render(code, options);
+        }
+        else {
+            code.remove(this.start, findFirstOccurrenceOutsideComment(code.original, ':', this.label.end) + 1);
+        }
+        this.body.render(code, options);
     }
-    return pathString;
 }
-class MemberExpression extends NodeBase {
+
+class LogicalExpression extends NodeBase {
     constructor() {
         super(...arguments);
-        this.variable = null;
-        this.bound = false;
+        // We collect deoptimization information if usedBranch !== null
         this.expressionsToBeDeoptimized = [];
-        this.replacement = null;
+        this.isBranchResolutionAnalysed = false;
+        this.unusedBranch = null;
+        this.usedBranch = null;
+        this.wasPathDeoptimizedWhileOptimized = false;
     }
-    addExportedVariables() { }
     bind() {
-        if (this.bound)
-            return;
-        this.bound = true;
-        const path = getPathIfNotComputed(this);
-        const baseVariable = path && this.scope.findVariable(path[0].key);
-        if (baseVariable && baseVariable.isNamespace) {
-            const resolvedVariable = this.resolveNamespaceVariables(baseVariable, path.slice(1));
-            if (!resolvedVariable) {
-                super.bind();
-            }
-            else if (typeof resolvedVariable === 'string') {
-                this.replacement = resolvedVariable;
-            }
-            else {
-                if (resolvedVariable instanceof ExternalVariable && resolvedVariable.module) {
-                    resolvedVariable.module.suggestName(path[0].key);
-                }
-                this.variable = resolvedVariable;
-                this.scope.addNamespaceMemberAccess(getStringFromPath(path), resolvedVariable);
-            }
-        }
-        else {
-            super.bind();
-            if (this.propertyKey === null)
-                this.analysePropertyKey();
-        }
+        super.bind();
+        // ensure the usedBranch is set for the tree-shaking passes
+        this.getUsedBranch();
     }
     deoptimizeCache() {
-        for (const expression of this.expressionsToBeDeoptimized) {
-            expression.deoptimizeCache();
+        if (this.usedBranch !== null) {
+            this.usedBranch = null;
+            if (this.wasPathDeoptimizedWhileOptimized) {
+                this.unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            }
+            for (const expression of this.expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
         }
     }
     deoptimizePath(path) {
-        if (!this.bound)
-            this.bind();
-        if (path.length === 0)
-            this.disallowNamespaceReassignment();
-        if (this.variable) {
-            this.variable.deoptimizePath(path);
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch === null) {
+            this.left.deoptimizePath(path);
+            this.right.deoptimizePath(path);
         }
         else {
-            if (this.propertyKey === null)
-                this.analysePropertyKey();
-            this.object.deoptimizePath([this.propertyKey, ...path]);
+            this.wasPathDeoptimizedWhileOptimized = true;
+            usedBranch.deoptimizePath(path);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (!this.bound)
-            this.bind();
-        if (this.variable !== null) {
-            return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
-        }
-        if (this.propertyKey === null)
-            this.analysePropertyKey();
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch === null)
+            return UnknownValue;
         this.expressionsToBeDeoptimized.push(origin);
-        return this.object.getLiteralValueAtPath([this.propertyKey, ...path], recursionTracker, origin);
+        return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin) {
-        if (!this.bound)
-            this.bind();
-        if (this.variable !== null) {
-            return this.variable.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
-        }
-        if (this.propertyKey === null)
-            this.analysePropertyKey();
+        const usedBranch = this.getUsedBranch();
+        if (usedBranch === null)
+            return new MultiExpression([
+                this.left.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin),
+                this.right.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin)
+            ]);
         this.expressionsToBeDeoptimized.push(origin);
-        return this.object.getReturnExpressionWhenCalledAtPath([this.propertyKey, ...path], recursionTracker, origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
     }
     hasEffects(context) {
-        return (this.property.hasEffects(context) ||
-            this.object.hasEffects(context) ||
-            (this.context.propertyReadSideEffects &&
-                this.object.hasEffectsWhenAccessedAtPath([this.propertyKey], context)));
+        if (this.usedBranch === null) {
+            return this.left.hasEffects(context) || this.right.hasEffects(context);
+        }
+        return this.usedBranch.hasEffects(context);
     }
     hasEffectsWhenAccessedAtPath(path, context) {
         if (path.length === 0)
             return false;
-        if (this.variable !== null) {
-            return this.variable.hasEffectsWhenAccessedAtPath(path, context);
+        if (this.usedBranch === null) {
+            return (this.left.hasEffectsWhenAccessedAtPath(path, context) ||
+                this.right.hasEffectsWhenAccessedAtPath(path, context));
         }
-        return this.object.hasEffectsWhenAccessedAtPath([this.propertyKey, ...path], context);
+        return this.usedBranch.hasEffectsWhenAccessedAtPath(path, context);
     }
     hasEffectsWhenAssignedAtPath(path, context) {
-        if (this.variable !== null) {
-            return this.variable.hasEffectsWhenAssignedAtPath(path, context);
+        if (path.length === 0)
+            return true;
+        if (this.usedBranch === null) {
+            return (this.left.hasEffectsWhenAssignedAtPath(path, context) ||
+                this.right.hasEffectsWhenAssignedAtPath(path, context));
         }
-        return this.object.hasEffectsWhenAssignedAtPath([this.propertyKey, ...path], context);
+        return this.usedBranch.hasEffectsWhenAssignedAtPath(path, context);
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (this.variable !== null) {
-            return this.variable.hasEffectsWhenCalledAtPath(path, callOptions, context);
+        if (this.usedBranch === null) {
+            return (this.left.hasEffectsWhenCalledAtPath(path, callOptions, context) ||
+                this.right.hasEffectsWhenCalledAtPath(path, callOptions, context));
         }
-        return this.object.hasEffectsWhenCalledAtPath([this.propertyKey, ...path], callOptions, context);
+        return this.usedBranch.hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
     include(context, includeChildrenRecursively) {
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.context.includeVariable(context, this.variable);
-            }
-        }
-        this.object.include(context, includeChildrenRecursively);
-        this.property.include(context, includeChildrenRecursively);
-    }
-    includeCallArguments(context, args) {
-        if (this.variable) {
-            this.variable.includeCallArguments(context, args);
+        this.included = true;
+        if (includeChildrenRecursively ||
+            this.usedBranch === null ||
+            this.unusedBranch.shouldBeIncluded(context)) {
+            this.left.include(context, includeChildrenRecursively);
+            this.right.include(context, includeChildrenRecursively);
         }
         else {
-            super.includeCallArguments(context, args);
+            this.usedBranch.include(context, includeChildrenRecursively);
         }
     }
-    initialise() {
-        this.propertyKey = getResolvablePropertyKey(this);
-    }
-    render(code, options, { renderedParentType, isCalleeOfRenderedParent } = BLANK) {
-        const isCalleeOfDifferentParent = renderedParentType === CallExpression && isCalleeOfRenderedParent;
-        if (this.variable || this.replacement) {
-            let replacement = this.variable ? this.variable.getName() : this.replacement;
-            if (isCalleeOfDifferentParent)
-                replacement = '0, ' + replacement;
-            code.overwrite(this.start, this.end, replacement, {
-                contentOnly: true,
-                storeName: true
+    render(code, options, { renderedParentType, isCalleeOfRenderedParent, preventASI } = BLANK) {
+        if (!this.left.included || !this.right.included) {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, this.operator, this.left.end);
+            if (this.right.included) {
+                code.remove(this.start, operatorPos + 2);
+                if (preventASI) {
+                    removeLineBreaks(code, operatorPos + 2, this.right.start);
+                }
+            }
+            else {
+                code.remove(operatorPos, this.end);
+            }
+            removeAnnotations(this, code);
+            this.usedBranch.render(code, options, {
+                isCalleeOfRenderedParent: renderedParentType
+                    ? isCalleeOfRenderedParent
+                    : this.parent.callee === this,
+                renderedParentType: renderedParentType || this.parent.type
             });
         }
         else {
-            if (isCalleeOfDifferentParent) {
-                code.appendRight(this.start, '0, ');
-            }
             super.render(code, options);
         }
     }
-    analysePropertyKey() {
-        this.propertyKey = UnknownKey;
-        const value = this.property.getLiteralValueAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
-        this.propertyKey = value === UnknownValue ? UnknownKey : String(value);
-    }
-    disallowNamespaceReassignment() {
-        if (this.object instanceof Identifier$1 &&
-            this.scope.findVariable(this.object.name).isNamespace) {
-            this.context.error({
-                code: 'ILLEGAL_NAMESPACE_REASSIGNMENT',
-                message: `Illegal reassignment to import '${this.object.name}'`
-            }, this.start);
-        }
-    }
-    resolveNamespaceVariables(baseVariable, path) {
-        if (path.length === 0)
-            return baseVariable;
-        if (!baseVariable.isNamespace)
-            return null;
-        const exportName = path[0].key;
-        const variable = baseVariable instanceof ExternalVariable
-            ? baseVariable.module.getVariableForExportName(exportName)
-            : baseVariable.context.traceExport(exportName);
-        if (!variable) {
-            const fileName = baseVariable instanceof ExternalVariable
-                ? baseVariable.module.id
-                : baseVariable.context.fileName;
-            this.context.warn({
-                code: 'MISSING_EXPORT',
-                exporter: relativeId(fileName),
-                importer: relativeId(this.context.fileName),
-                message: `'${exportName}' is not exported by '${relativeId(fileName)}'`,
-                missing: exportName,
-                url: `https://rollupjs.org/guide/en/#error-name-is-not-exported-by-module`
-            }, path[0].pos);
-            return 'undefined';
+    getUsedBranch() {
+        if (!this.isBranchResolutionAnalysed) {
+            this.isBranchResolutionAnalysed = true;
+            const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            if (leftValue === UnknownValue) {
+                return null;
+            }
+            else {
+                if (this.operator === '||' ? leftValue : !leftValue) {
+                    this.usedBranch = this.left;
+                    this.unusedBranch = this.right;
+                }
+                else {
+                    this.usedBranch = this.right;
+                    this.unusedBranch = this.left;
+                }
+            }
         }
-        return this.resolveNamespaceVariables(variable, path.slice(1));
+        return this.usedBranch;
     }
 }
 
@@ -7998,8 +8023,8 @@ class ObjectExpression extends NodeBase {
     }
     bind() {
         super.bind();
-        if (this.propertyMap === null)
-            this.buildPropertyMap();
+        // ensure the propertyMap is set for the tree-shaking passes
+        this.getPropertyMap();
     }
     // We could also track this per-property but this would quickly become much more complex
     deoptimizeCache() {
@@ -8009,12 +8034,7 @@ class ObjectExpression extends NodeBase {
     deoptimizePath(path) {
         if (this.hasUnknownDeoptimizedProperty)
             return;
-        if (this.propertyMap === null)
-            this.buildPropertyMap();
-        if (path.length === 0) {
-            this.deoptimizeAllProperties();
-            return;
-        }
+        const propertyMap = this.getPropertyMap();
         const key = path[0];
         if (path.length === 1) {
             if (typeof key !== 'string') {
@@ -8035,16 +8055,15 @@ class ObjectExpression extends NodeBase {
         }
         const subPath = path.length === 1 ? UNKNOWN_PATH : path.slice(1);
         for (const property of typeof key === 'string'
-            ? this.propertyMap[key]
-                ? this.propertyMap[key].propertiesRead
+            ? propertyMap[key]
+                ? propertyMap[key].propertiesRead
                 : []
             : this.properties) {
             property.deoptimizePath(subPath);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.propertyMap === null)
-            this.buildPropertyMap();
+        const propertyMap = this.getPropertyMap();
         const key = path[0];
         if (path.length === 0 ||
             this.hasUnknownDeoptimizedProperty ||
@@ -8052,7 +8071,7 @@ class ObjectExpression extends NodeBase {
             this.deoptimizedPaths.has(key))
             return UnknownValue;
         if (path.length === 1 &&
-            !this.propertyMap[key] &&
+            !propertyMap[key] &&
             !objectMembers[key] &&
             this.unmatchablePropertiesRead.length === 0) {
             const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized.get(key);
@@ -8064,9 +8083,9 @@ class ObjectExpression extends NodeBase {
             }
             return undefined;
         }
-        if (!this.propertyMap[key] ||
-            this.propertyMap[key].exactMatchRead === null ||
-            this.propertyMap[key].propertiesRead.length > 1) {
+        if (!propertyMap[key] ||
+            propertyMap[key].exactMatchRead === null ||
+            propertyMap[key].propertiesRead.length > 1) {
             return UnknownValue;
         }
         const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized.get(key);
@@ -8076,12 +8095,10 @@ class ObjectExpression extends NodeBase {
         else {
             this.expressionsToBeDeoptimized.set(key, [origin]);
         }
-        return this.propertyMap[key]
-            .exactMatchRead.getLiteralValueAtPath(path.slice(1), recursionTracker, origin);
+        return propertyMap[key].exactMatchRead.getLiteralValueAtPath(path.slice(1), recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin) {
-        if (this.propertyMap === null)
-            this.buildPropertyMap();
+        const propertyMap = this.getPropertyMap();
         const key = path[0];
         if (path.length === 0 ||
             this.hasUnknownDeoptimizedProperty ||
@@ -8091,12 +8108,11 @@ class ObjectExpression extends NodeBase {
         if (path.length === 1 &&
             objectMembers[key] &&
             this.unmatchablePropertiesRead.length === 0 &&
-            (!this.propertyMap[key] ||
-                this.propertyMap[key].exactMatchRead === null))
+            (!propertyMap[key] || propertyMap[key].exactMatchRead === null))
             return getMemberReturnExpressionWhenCalled(objectMembers, key);
-        if (!this.propertyMap[key] ||
-            this.propertyMap[key].exactMatchRead === null ||
-            this.propertyMap[key].propertiesRead.length > 1)
+        if (!propertyMap[key] ||
+            propertyMap[key].exactMatchRead === null ||
+            propertyMap[key].propertiesRead.length > 1)
             return UNKNOWN_EXPRESSION;
         const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized.get(key);
         if (expressionsToBeDeoptimized) {
@@ -8105,25 +8121,25 @@ class ObjectExpression extends NodeBase {
         else {
             this.expressionsToBeDeoptimized.set(key, [origin]);
         }
-        return this.propertyMap[key]
-            .exactMatchRead.getReturnExpressionWhenCalledAtPath(path.slice(1), recursionTracker, origin);
+        return propertyMap[key].exactMatchRead.getReturnExpressionWhenCalledAtPath(path.slice(1), recursionTracker, origin);
     }
     hasEffectsWhenAccessedAtPath(path, context) {
         if (path.length === 0)
             return false;
         const key = path[0];
+        const propertyMap = this.propertyMap;
         if (path.length > 1 &&
             (this.hasUnknownDeoptimizedProperty ||
                 typeof key !== 'string' ||
                 this.deoptimizedPaths.has(key) ||
-                !this.propertyMap[key] ||
-                this.propertyMap[key].exactMatchRead === null))
+                !propertyMap[key] ||
+                propertyMap[key].exactMatchRead === null))
             return true;
         const subPath = path.slice(1);
         for (const property of typeof key !== 'string'
             ? this.properties
-            : this.propertyMap[key]
-                ? this.propertyMap[key].propertiesRead
+            : propertyMap[key]
+                ? propertyMap[key].propertiesRead
                 : []) {
             if (property.hasEffectsWhenAccessedAtPath(subPath, context))
                 return true;
@@ -8131,23 +8147,22 @@ class ObjectExpression extends NodeBase {
         return false;
     }
     hasEffectsWhenAssignedAtPath(path, context) {
-        if (path.length === 0)
-            return false;
         const key = path[0];
+        const propertyMap = this.propertyMap;
         if (path.length > 1 &&
             (this.hasUnknownDeoptimizedProperty ||
-                typeof key !== 'string' ||
                 this.deoptimizedPaths.has(key) ||
-                !this.propertyMap[key] ||
-                this.propertyMap[key].exactMatchRead === null))
+                !propertyMap[key] ||
+                propertyMap[key].exactMatchRead === null)) {
             return true;
+        }
         const subPath = path.slice(1);
         for (const property of typeof key !== 'string'
             ? this.properties
             : path.length > 1
-                ? this.propertyMap[key].propertiesRead
-                : this.propertyMap[key]
-                    ? this.propertyMap[key].propertiesSet
+                ? propertyMap[key].propertiesRead
+                : propertyMap[key]
+                    ? propertyMap[key].propertiesWrite
                     : []) {
             if (property.hasEffectsWhenAssignedAtPath(subPath, context))
                 return true;
@@ -8156,20 +8171,20 @@ class ObjectExpression extends NodeBase {
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         const key = path[0];
-        if (path.length === 0 ||
+        if (typeof key !== 'string' ||
             this.hasUnknownDeoptimizedProperty ||
-            typeof key !== 'string' ||
             this.deoptimizedPaths.has(key) ||
             (this.propertyMap[key]
                 ? !this.propertyMap[key].exactMatchRead
-                : path.length > 1 || !objectMembers[key]))
+                : path.length > 1 || !objectMembers[key])) {
             return true;
+        }
         const subPath = path.slice(1);
-        for (const property of this.propertyMap[key]
-            ? this.propertyMap[key].propertiesRead
-            : []) {
-            if (property.hasEffectsWhenCalledAtPath(subPath, callOptions, context))
-                return true;
+        if (this.propertyMap[key]) {
+            for (const property of this.propertyMap[key].propertiesRead) {
+                if (property.hasEffectsWhenCalledAtPath(subPath, callOptions, context))
+                    return true;
+            }
         }
         if (path.length === 1 && objectMembers[key])
             return hasMemberEffectWhenCalled(objectMembers, key, this.included, callOptions, context);
@@ -8182,8 +8197,22 @@ class ObjectExpression extends NodeBase {
             code.prependLeft(this.end, ')');
         }
     }
-    buildPropertyMap() {
-        this.propertyMap = Object.create(null);
+    deoptimizeAllProperties() {
+        this.hasUnknownDeoptimizedProperty = true;
+        for (const property of this.properties) {
+            property.deoptimizePath(UNKNOWN_PATH);
+        }
+        for (const expressionsToBeDeoptimized of this.expressionsToBeDeoptimized.values()) {
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+        }
+    }
+    getPropertyMap() {
+        if (this.propertyMap !== null) {
+            return this.propertyMap;
+        }
+        const propertyMap = (this.propertyMap = Object.create(null));
         for (let index = this.properties.length - 1; index >= 0; index--) {
             const property = this.properties[index];
             if (property instanceof SpreadElement) {
@@ -8194,7 +8223,7 @@ class ObjectExpression extends NodeBase {
             const isRead = property.kind !== 'set';
             let key;
             if (property.computed) {
-                const keyValue = property.key.getLiteralValueAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
+                const keyValue = property.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
                 if (keyValue === UnknownValue) {
                     if (isRead) {
                         this.unmatchablePropertiesRead.push(property);
@@ -8212,13 +8241,13 @@ class ObjectExpression extends NodeBase {
             else {
                 key = String(property.key.value);
             }
-            const propertyMapProperty = this.propertyMap[key];
+            const propertyMapProperty = propertyMap[key];
             if (!propertyMapProperty) {
-                this.propertyMap[key] = {
+                propertyMap[key] = {
                     exactMatchRead: isRead ? property : null,
                     exactMatchWrite: isWrite ? property : null,
                     propertiesRead: isRead ? [property, ...this.unmatchablePropertiesRead] : [],
-                    propertiesSet: isWrite && !isRead ? [property, ...this.unmatchablePropertiesWrite] : []
+                    propertiesWrite: isWrite && !isRead ? [property, ...this.unmatchablePropertiesWrite] : []
                 };
                 continue;
             }
@@ -8228,20 +8257,10 @@ class ObjectExpression extends NodeBase {
             }
             if (isWrite && !isRead && propertyMapProperty.exactMatchWrite === null) {
                 propertyMapProperty.exactMatchWrite = property;
-                propertyMapProperty.propertiesSet.push(property, ...this.unmatchablePropertiesWrite);
-            }
-        }
-    }
-    deoptimizeAllProperties() {
-        this.hasUnknownDeoptimizedProperty = true;
-        for (const property of this.properties) {
-            property.deoptimizePath(UNKNOWN_PATH);
-        }
-        for (const expressionsToBeDeoptimized of this.expressionsToBeDeoptimized.values()) {
-            for (const expression of expressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
+                propertyMapProperty.propertiesWrite.push(property, ...this.unmatchablePropertiesWrite);
             }
         }
+        return propertyMap;
     }
 }
 
@@ -8315,8 +8334,10 @@ class Property$1 extends NodeBase {
     }
     bind() {
         super.bind();
-        if (this.kind === 'get' && this.returnExpression === null)
-            this.updateReturnExpression();
+        if (this.kind === 'get') {
+            // ensure the returnExpression is set for the tree-shaking passes
+            this.getReturnExpression();
+        }
         if (this.declarationInit !== null) {
             this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
         }
@@ -8325,36 +8346,26 @@ class Property$1 extends NodeBase {
         this.declarationInit = init;
         return this.value.declare(kind, UNKNOWN_EXPRESSION);
     }
-    deoptimizeCache() {
-        // As getter properties directly receive their values from function expressions that always
-        // have a fixed return value, there is no known situation where a getter is deoptimized.
-        throw new Error('Unexpected deoptimization');
-    }
+    // As getter properties directly receive their values from function expressions that always
+    // have a fixed return value, there is no known situation where a getter is deoptimized.
+    deoptimizeCache() { }
     deoptimizePath(path) {
         if (this.kind === 'get') {
-            if (path.length > 0) {
-                if (this.returnExpression === null)
-                    this.updateReturnExpression();
-                this.returnExpression.deoptimizePath(path);
-            }
+            this.getReturnExpression().deoptimizePath(path);
         }
-        else if (this.kind !== 'set') {
+        else {
             this.value.deoptimizePath(path);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         if (this.kind === 'get') {
-            if (this.returnExpression === null)
-                this.updateReturnExpression();
-            return this.returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
+            return this.getReturnExpression().getLiteralValueAtPath(path, recursionTracker, origin);
         }
         return this.value.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin) {
         if (this.kind === 'get') {
-            if (this.returnExpression === null)
-                this.updateReturnExpression();
-            return this.returnExpression.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
+            return this.getReturnExpression().getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
         }
         return this.value.getReturnExpressionWhenCalledAtPath(path, recursionTracker, origin);
     }
@@ -8414,9 +8425,12 @@ class Property$1 extends NodeBase {
         }
         this.value.render(code, options, { isShorthandProperty: this.shorthand });
     }
-    updateReturnExpression() {
-        this.returnExpression = UNKNOWN_EXPRESSION;
-        this.returnExpression = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, EMPTY_IMMUTABLE_TRACKER, this);
+    getReturnExpression() {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_EXPRESSION;
+            return (this.returnExpression = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this));
+        }
+        return this.returnExpression;
     }
 }
 
@@ -9821,7 +9835,9 @@ class Module {
         return { renderedExports, removedExports };
     }
     getTransitiveDependencies() {
-        return this.dependencies.concat(this.getReexports().map(exportName => this.getVariableForExportName(exportName).module));
+        return this.dependencies.concat(this.getReexports()
+            .concat(this.getExports())
+            .map((exportName) => this.getVariableForExportName(exportName).module));
     }
     getVariableForExportName(name, isExportAllSearch) {
         if (name[0] === '*') {