rollup 2.75.5 → 2.76.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.75.5
-	Wed, 01 Jun 2022 12:43:56 GMT - commit 14dedb52b4d799deebd8b711c1e14759fc0213d9
+	Rollup.js v2.76.0
+	Fri, 08 Jul 2022 08:35:58 GMT - commit 0eb042740eb41812b9e96e0e7b6ed8aa4cab04a7
 
 	https://github.com/rollup/rollup
 
@@ -27,7 +27,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
 
-var version$1 = "2.75.5";
+var version$1 = "2.76.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -2228,8 +2228,8 @@ class ExpressionEntity {
         this.included = false;
     }
     deoptimizePath(_path) { }
-    deoptimizeThisOnEventAtPath(_event, _path, thisParameter, _recursionTracker) {
-        thisParameter.deoptimizePath(UNKNOWN_PATH);
+    deoptimizeThisOnInteractionAtPath({ thisArg }, _path, _recursionTracker) {
+        thisArg.deoptimizePath(UNKNOWN_PATH);
     }
     /**
      * If possible it returns a stringifyable literal value for this node that can be used
@@ -2239,16 +2239,10 @@ class ExpressionEntity {
     getLiteralValueAtPath(_path, _recursionTracker, _origin) {
         return UnknownValue;
     }
-    getReturnExpressionWhenCalledAtPath(_path, _callOptions, _recursionTracker, _origin) {
+    getReturnExpressionWhenCalledAtPath(_path, _interaction, _recursionTracker, _origin) {
         return UNKNOWN_EXPRESSION;
     }
-    hasEffectsWhenAccessedAtPath(_path, _context) {
-        return true;
-    }
-    hasEffectsWhenAssignedAtPath(_path, _context) {
-        return true;
-    }
-    hasEffectsWhenCalledAtPath(_path, _callOptions, _context) {
+    hasEffectsOnInteractionAtPath(_path, _interaction, _context) {
         return true;
     }
     include(_context, _includeChildrenRecursively, _options) {
@@ -2266,6 +2260,30 @@ class ExpressionEntity {
 const UNKNOWN_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
 })();
 
+const INTERACTION_ACCESSED = 0;
+const INTERACTION_ASSIGNED = 1;
+const INTERACTION_CALLED = 2;
+const NODE_INTERACTION_UNKNOWN_ACCESS = {
+    thisArg: null,
+    type: INTERACTION_ACCESSED
+};
+const UNKNOWN_ARG = [UNKNOWN_EXPRESSION];
+const NODE_INTERACTION_UNKNOWN_ASSIGNMENT = {
+    args: UNKNOWN_ARG,
+    thisArg: null,
+    type: INTERACTION_ASSIGNED
+};
+const NO_ARGS = [];
+// While this is technically a call without arguments, we can compare against
+// this reference in places where precise values or thisArg would make a
+// difference
+const NODE_INTERACTION_UNKNOWN_CALL = {
+    args: NO_ARGS,
+    thisArg: null,
+    type: INTERACTION_CALLED,
+    withNew: false
+};
+
 class Variable extends ExpressionEntity {
     constructor(name) {
         super();
@@ -2290,8 +2308,8 @@ class Variable extends ExpressionEntity {
         const name = this.renderName || this.name;
         return this.renderBaseName ? `${this.renderBaseName}${getPropertyAccess(name)}` : name;
     }
-    hasEffectsWhenAccessedAtPath(path, _context) {
-        return path.length > 0;
+    hasEffectsOnInteractionAtPath(path, { type }, _context) {
+        return type !== INTERACTION_ACCESSED || path.length > 0;
     }
     /**
      * Marks this variable as being part of the bundle, which is usually the case when one of
@@ -2322,8 +2340,8 @@ class ExternalVariable extends Variable {
             this.module.suggestName(identifier.name);
         }
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > (this.isNamespace ? 1 : 0);
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > (this.isNamespace ? 1 : 0);
     }
     include() {
         if (!this.included) {
@@ -4710,8 +4728,6 @@ function createHasEffectsContext() {
     };
 }
 
-const NO_ARGS = [];
-
 function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
     return Object.create(inheritedDescriptions, memberDescriptions);
 }
@@ -4733,12 +4749,12 @@ const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEnti
         }
         return UNKNOWN_EXPRESSION;
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalBooleanMembers, path[0], interaction, context);
         }
         return true;
     }
@@ -4756,12 +4772,12 @@ const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity
         }
         return UNKNOWN_EXPRESSION;
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalNumberMembers, path[0], interaction, context);
         }
         return true;
     }
@@ -4779,12 +4795,12 @@ const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity
         }
         return UNKNOWN_EXPRESSION;
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(literalStringMembers, path[0], callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
         }
         return true;
     }
@@ -4797,17 +4813,13 @@ const returnsString = {
 };
 const stringReplace = {
     value: {
-        hasEffectsWhenCalled(callOptions, context) {
-            const arg1 = callOptions.args[1];
-            return (callOptions.args.length < 2 ||
+        hasEffectsWhenCalled({ args }, context) {
+            const arg1 = args[1];
+            return (args.length < 2 ||
                 (typeof arg1.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, {
                     deoptimizeCache() { }
                 }) === 'symbol' &&
-                    arg1.hasEffectsWhenCalledAtPath(EMPTY_PATH, {
-                        args: NO_ARGS,
-                        thisParam: null,
-                        withNew: false
-                    }, context)));
+                    arg1.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)));
         },
         returns: UNKNOWN_LITERAL_STRING
     }
@@ -4891,12 +4903,12 @@ function getLiteralMembersForValue(value) {
     }
     return Object.create(null);
 }
-function hasMemberEffectWhenCalled(members, memberName, callOptions, context) {
+function hasMemberEffectWhenCalled(members, memberName, interaction, context) {
     var _a, _b;
     if (typeof memberName !== 'string' || !members[memberName]) {
         return true;
     }
-    return ((_b = (_a = members[memberName]).hasEffectsWhenCalled) === null || _b === void 0 ? void 0 : _b.call(_a, callOptions, context)) || false;
+    return ((_b = (_a = members[memberName]).hasEffectsWhenCalled) === null || _b === void 0 ? void 0 : _b.call(_a, interaction, context)) || false;
 }
 function getMemberReturnExpressionWhenCalled(members, memberName) {
     if (typeof memberName !== 'string' || !members[memberName])
@@ -5335,10 +5347,12 @@ const INCLUDE_PARAMETERS = 'variables';
 class NodeBase extends ExpressionEntity {
     constructor(esTreeNode, parent, parentScope) {
         super();
-        // Nodes can apply custom deoptimizations once they become part of the
-        // executed code. To do this, they must initialize this as false, implement
-        // applyDeoptimizations and call this from include and hasEffects if they
-        // have custom handlers
+        /**
+         * Nodes can apply custom deoptimizations once they become part of the
+         * executed code. To do this, they must initialize this as false, implement
+         * applyDeoptimizations and call this from include and hasEffects if they have
+         * custom handlers
+         */
         this.deoptimized = false;
         this.esTreeNode = esTreeNode;
         this.keys = keys[esTreeNode.type] || getAndCreateKeys(esTreeNode);
@@ -5394,6 +5408,10 @@ class NodeBase extends ExpressionEntity {
         }
         return false;
     }
+    hasEffectsAsAssignmentTarget(context, _checkAccess) {
+        return (this.hasEffects(context) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
+    }
     include(context, includeChildrenRecursively, _options) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -5412,6 +5430,9 @@ class NodeBase extends ExpressionEntity {
             }
         }
     }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, _deoptimizeAccess) {
+        this.include(context, includeChildrenRecursively);
+    }
     /**
      * Override to perform special initialisation steps after the scope is initialised
      */
@@ -5466,6 +5487,9 @@ class NodeBase extends ExpressionEntity {
             }
         }
     }
+    setAssignedValue(value) {
+        this.assignmentInteraction = { args: [value], thisArg: null, type: INTERACTION_ASSIGNED };
+    }
     shouldBeIncluded(context) {
         return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
     }
@@ -5494,9 +5518,9 @@ class NodeBase extends ExpressionEntity {
 }
 
 class SpreadElement extends NodeBase {
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         if (path.length > 0) {
-            this.argument.deoptimizeThisOnEventAtPath(event, [UnknownKey, ...path], thisParameter, recursionTracker);
+            this.argument.deoptimizeThisOnInteractionAtPath(interaction, [UnknownKey, ...path], recursionTracker);
         }
     }
     hasEffects(context) {
@@ -5507,7 +5531,7 @@ class SpreadElement extends NodeBase {
         return (this.argument.hasEffects(context) ||
             (propertyReadSideEffects &&
                 (propertyReadSideEffects === 'always' ||
-                    this.argument.hasEffectsWhenAccessedAtPath(UNKNOWN_PATH, context))));
+                    this.argument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context))));
     }
     applyDeoptimizations() {
         this.deoptimized = true;
@@ -5518,53 +5542,43 @@ class SpreadElement extends NodeBase {
     }
 }
 
-const EVENT_ACCESSED = 0;
-const EVENT_ASSIGNED = 1;
-const EVENT_CALLED = 2;
-
 class Method extends ExpressionEntity {
     constructor(description) {
         super();
         this.description = description;
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter) {
-        if (event === EVENT_CALLED && path.length === 0 && this.description.mutatesSelfAsArray) {
-            thisParameter.deoptimizePath(UNKNOWN_INTEGER_PATH);
+    deoptimizeThisOnInteractionAtPath({ type, thisArg }, path) {
+        if (type === INTERACTION_CALLED && path.length === 0 && this.description.mutatesSelfAsArray) {
+            thisArg.deoptimizePath(UNKNOWN_INTEGER_PATH);
         }
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions) {
+    getReturnExpressionWhenCalledAtPath(path, { thisArg }) {
         if (path.length > 0) {
             return UNKNOWN_EXPRESSION;
         }
         return (this.description.returnsPrimitive ||
             (this.description.returns === 'self'
-                ? callOptions.thisParam || UNKNOWN_EXPRESSION
+                ? thisArg || UNKNOWN_EXPRESSION
                 : this.description.returns()));
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenAssignedAtPath(path) {
-        return path.length > 0;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
         var _a, _b;
-        if (path.length > 0 ||
-            (this.description.mutatesSelfAsArray === true &&
-                ((_a = callOptions.thisParam) === null || _a === void 0 ? void 0 : _a.hasEffectsWhenAssignedAtPath(UNKNOWN_INTEGER_PATH, context)))) {
+        const { type } = interaction;
+        if (path.length > (type === INTERACTION_ACCESSED ? 1 : 0)) {
             return true;
         }
-        if (!this.description.callsArgs) {
-            return false;
-        }
-        for (const argIndex of this.description.callsArgs) {
-            if ((_b = callOptions.args[argIndex]) === null || _b === void 0 ? void 0 : _b.hasEffectsWhenCalledAtPath(EMPTY_PATH, {
-                args: NO_ARGS,
-                thisParam: null,
-                withNew: false
-            }, context)) {
+        if (type === INTERACTION_CALLED) {
+            if (this.description.mutatesSelfAsArray === true &&
+                ((_a = interaction.thisArg) === null || _a === void 0 ? void 0 : _a.hasEffectsOnInteractionAtPath(UNKNOWN_INTEGER_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context))) {
                 return true;
             }
+            if (this.description.callsArgs) {
+                for (const argIndex of this.description.callsArgs) {
+                    if ((_b = interaction.args[argIndex]) === null || _b === void 0 ? void 0 : _b.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, context)) {
+                        return true;
+                    }
+                }
+            }
         }
         return false;
     }
@@ -5706,24 +5720,24 @@ class ObjectEntity extends ExpressionEntity {
         }
         (_a = this.prototypeExpression) === null || _a === void 0 ? void 0 : _a.deoptimizePath(path.length === 1 ? [...path, UnknownKey] : path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         var _a;
         const [key, ...subPath] = path;
         if (this.hasLostTrack ||
             // single paths that are deoptimized will not become getters or setters
-            ((event === EVENT_CALLED || path.length > 1) &&
+            ((interaction.type === INTERACTION_CALLED || path.length > 1) &&
                 (this.hasUnknownDeoptimizedProperty ||
                     (typeof key === 'string' && this.deoptimizedPaths[key])))) {
-            thisParameter.deoptimizePath(UNKNOWN_PATH);
+            interaction.thisArg.deoptimizePath(UNKNOWN_PATH);
             return;
         }
-        const [propertiesForExactMatchByKey, relevantPropertiesByKey, relevantUnmatchableProperties] = event === EVENT_CALLED || path.length > 1
+        const [propertiesForExactMatchByKey, relevantPropertiesByKey, relevantUnmatchableProperties] = interaction.type === INTERACTION_CALLED || path.length > 1
             ? [
                 this.propertiesAndGettersByKey,
                 this.propertiesAndGettersByKey,
                 this.unmatchablePropertiesAndGetters
             ]
-            : event === EVENT_ACCESSED
+            : interaction.type === INTERACTION_ACCESSED
                 ? [this.propertiesAndGettersByKey, this.gettersByKey, this.unmatchableGetters]
                 : [this.propertiesAndSettersByKey, this.settersByKey, this.unmatchableSetters];
         if (typeof key === 'string') {
@@ -5731,20 +5745,20 @@ class ObjectEntity extends ExpressionEntity {
                 const properties = relevantPropertiesByKey[key];
                 if (properties) {
                     for (const property of properties) {
-                        property.deoptimizeThisOnEventAtPath(event, subPath, thisParameter, recursionTracker);
+                        property.deoptimizeThisOnInteractionAtPath(interaction, subPath, recursionTracker);
                     }
                 }
                 if (!this.immutable) {
-                    this.thisParametersToBeDeoptimized.add(thisParameter);
+                    this.thisParametersToBeDeoptimized.add(interaction.thisArg);
                 }
                 return;
             }
             for (const property of relevantUnmatchableProperties) {
-                property.deoptimizeThisOnEventAtPath(event, subPath, thisParameter, recursionTracker);
+                property.deoptimizeThisOnInteractionAtPath(interaction, subPath, recursionTracker);
             }
             if (INTEGER_REG_EXP.test(key)) {
                 for (const property of this.unknownIntegerProps) {
-                    property.deoptimizeThisOnEventAtPath(event, subPath, thisParameter, recursionTracker);
+                    property.deoptimizeThisOnInteractionAtPath(interaction, subPath, recursionTracker);
                 }
             }
         }
@@ -5753,17 +5767,17 @@ class ObjectEntity extends ExpressionEntity {
                 relevantUnmatchableProperties
             ])) {
                 for (const property of properties) {
-                    property.deoptimizeThisOnEventAtPath(event, subPath, thisParameter, recursionTracker);
+                    property.deoptimizeThisOnInteractionAtPath(interaction, subPath, recursionTracker);
                 }
             }
             for (const property of this.unknownIntegerProps) {
-                property.deoptimizeThisOnEventAtPath(event, subPath, thisParameter, recursionTracker);
+                property.deoptimizeThisOnInteractionAtPath(interaction, subPath, recursionTracker);
             }
         }
         if (!this.immutable) {
-            this.thisParametersToBeDeoptimized.add(thisParameter);
+            this.thisParametersToBeDeoptimized.add(interaction.thisArg);
         }
-        (_a = this.prototypeExpression) === null || _a === void 0 ? void 0 : _a.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        (_a = this.prototypeExpression) === null || _a === void 0 ? void 0 : _a.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         if (path.length === 0) {
@@ -5782,79 +5796,29 @@ class ObjectEntity extends ExpressionEntity {
         }
         return UnknownValue;
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         if (path.length === 0) {
             return UNKNOWN_EXPRESSION;
         }
-        const key = path[0];
+        const [key, ...subPath] = path;
         const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
         if (expressionAtPath) {
-            return expressionAtPath.getReturnExpressionWhenCalledAtPath(path.slice(1), callOptions, recursionTracker, origin);
+            return expressionAtPath.getReturnExpressionWhenCalledAtPath(subPath, interaction, recursionTracker, origin);
         }
         if (this.prototypeExpression) {
-            return this.prototypeExpression.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+            return this.prototypeExpression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }
         return UNKNOWN_EXPRESSION;
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
         const [key, ...subPath] = path;
-        if (path.length > 1) {
-            if (typeof key !== 'string') {
-                return true;
-            }
+        if (subPath.length || interaction.type === INTERACTION_CALLED) {
             const expressionAtPath = this.getMemberExpression(key);
             if (expressionAtPath) {
-                return expressionAtPath.hasEffectsWhenAccessedAtPath(subPath, context);
+                return expressionAtPath.hasEffectsOnInteractionAtPath(subPath, interaction, context);
             }
             if (this.prototypeExpression) {
-                return this.prototypeExpression.hasEffectsWhenAccessedAtPath(path, context);
-            }
-            return true;
-        }
-        if (this.hasLostTrack)
-            return true;
-        if (typeof key === 'string') {
-            if (this.propertiesAndGettersByKey[key]) {
-                const getters = this.gettersByKey[key];
-                if (getters) {
-                    for (const getter of getters) {
-                        if (getter.hasEffectsWhenAccessedAtPath(subPath, context))
-                            return true;
-                    }
-                }
-                return false;
-            }
-            for (const getter of this.unmatchableGetters) {
-                if (getter.hasEffectsWhenAccessedAtPath(subPath, context)) {
-                    return true;
-                }
-            }
-        }
-        else {
-            for (const getters of Object.values(this.gettersByKey).concat([this.unmatchableGetters])) {
-                for (const getter of getters) {
-                    if (getter.hasEffectsWhenAccessedAtPath(subPath, context))
-                        return true;
-                }
-            }
-        }
-        if (this.prototypeExpression) {
-            return this.prototypeExpression.hasEffectsWhenAccessedAtPath(path, context);
-        }
-        return false;
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        const [key, ...subPath] = path;
-        if (path.length > 1) {
-            if (typeof key !== 'string') {
-                return true;
-            }
-            const expressionAtPath = this.getMemberExpression(key);
-            if (expressionAtPath) {
-                return expressionAtPath.hasEffectsWhenAssignedAtPath(subPath, context);
-            }
-            if (this.prototypeExpression) {
-                return this.prototypeExpression.hasEffectsWhenAssignedAtPath(path, context);
+                return this.prototypeExpression.hasEffectsOnInteractionAtPath(path, interaction, context);
             }
             return true;
         }
@@ -5862,47 +5826,39 @@ class ObjectEntity extends ExpressionEntity {
             return false;
         if (this.hasLostTrack)
             return true;
+        const [propertiesAndAccessorsByKey, accessorsByKey, unmatchableAccessors] = interaction.type === INTERACTION_ACCESSED
+            ? [this.propertiesAndGettersByKey, this.gettersByKey, this.unmatchableGetters]
+            : [this.propertiesAndSettersByKey, this.settersByKey, this.unmatchableSetters];
         if (typeof key === 'string') {
-            if (this.propertiesAndSettersByKey[key]) {
-                const setters = this.settersByKey[key];
-                if (setters) {
-                    for (const setter of setters) {
-                        if (setter.hasEffectsWhenAssignedAtPath(subPath, context))
+            if (propertiesAndAccessorsByKey[key]) {
+                const accessors = accessorsByKey[key];
+                if (accessors) {
+                    for (const accessor of accessors) {
+                        if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context))
                             return true;
                     }
                 }
                 return false;
             }
-            for (const property of this.unmatchableSetters) {
-                if (property.hasEffectsWhenAssignedAtPath(subPath, context)) {
+            for (const accessor of unmatchableAccessors) {
+                if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context)) {
                     return true;
                 }
             }
         }
         else {
-            for (const setters of Object.values(this.settersByKey).concat([this.unmatchableSetters])) {
-                for (const setter of setters) {
-                    if (setter.hasEffectsWhenAssignedAtPath(subPath, context))
+            for (const accessors of Object.values(accessorsByKey).concat([unmatchableAccessors])) {
+                for (const accessor of accessors) {
+                    if (accessor.hasEffectsOnInteractionAtPath(subPath, interaction, context))
                         return true;
                 }
             }
         }
         if (this.prototypeExpression) {
-            return this.prototypeExpression.hasEffectsWhenAssignedAtPath(path, context);
+            return this.prototypeExpression.hasEffectsOnInteractionAtPath(path, interaction, context);
         }
         return false;
     }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        const key = path[0];
-        const expressionAtPath = this.getMemberExpression(key);
-        if (expressionAtPath) {
-            return expressionAtPath.hasEffectsWhenCalledAtPath(path.slice(1), callOptions, context);
-        }
-        if (this.prototypeExpression) {
-            return this.prototypeExpression.hasEffectsWhenCalledAtPath(path, callOptions, context);
-        }
-        return true;
-    }
     buildPropertyMaps(properties) {
         const { allProperties, propertiesAndGettersByKey, propertiesAndSettersByKey, settersByKey, gettersByKey, unknownIntegerProps, unmatchablePropertiesAndGetters, unmatchableGetters, unmatchableSetters } = this;
         const unmatchablePropertiesAndSetters = [];
@@ -6008,9 +5964,9 @@ const isInteger = (prop) => typeof prop === 'string' && /^\d+$/.test(prop);
 // properties as we do not expect new builtin properties to be numbers, this
 // will improve tree-shaking for out-of-bounds array properties
 const OBJECT_PROTOTYPE_FALLBACK = new (class ObjectPrototypeFallbackExpression extends ExpressionEntity {
-    deoptimizeThisOnEventAtPath(event, path, thisParameter) {
-        if (event === EVENT_CALLED && path.length === 1 && !isInteger(path[0])) {
-            thisParameter.deoptimizePath(UNKNOWN_PATH);
+    deoptimizeThisOnInteractionAtPath({ type, thisArg }, path) {
+        if (type === INTERACTION_CALLED && path.length === 1 && !isInteger(path[0])) {
+            thisArg.deoptimizePath(UNKNOWN_PATH);
         }
     }
     getLiteralValueAtPath(path) {
@@ -6019,11 +5975,8 @@ const OBJECT_PROTOTYPE_FALLBACK = new (class ObjectPrototypeFallbackExpression e
         // "undefined"
         return path.length === 1 && isInteger(path[0]) ? undefined : UnknownValue;
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenAssignedAtPath(path) {
-        return path.length > 1;
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type === INTERACTION_CALLED;
     }
 })();
 const OBJECT_PROTOTYPE = new ObjectEntity({
@@ -6145,8 +6098,8 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
     flat: METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     flatMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
     forEach: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
-    groupBy: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
-    groupByToMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    group: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
+    groupToMap: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
     includes: METHOD_RETURNS_BOOLEAN,
     indexOf: METHOD_RETURNS_NUMBER,
     join: METHOD_RETURNS_STRING,
@@ -6177,23 +6130,17 @@ class ArrayExpression extends NodeBase {
     deoptimizePath(path) {
         this.getObjectEntity().deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     applyDeoptimizations() {
         this.deoptimized = true;
@@ -6258,9 +6205,9 @@ class ArrayPattern extends NodeBase {
         }
     }
     // Patterns are only checked at the emtpy path at the moment
-    hasEffectsWhenAssignedAtPath(_path, context) {
+    hasEffectsOnInteractionAtPath(_path, interaction, context) {
         for (const element of this.elements) {
-            if (element === null || element === void 0 ? void 0 : element.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
+            if (element === null || element === void 0 ? void 0 : element.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
                 return true;
         }
         return false;
@@ -6319,11 +6266,11 @@ class LocalVariable extends Variable {
             (_b = this.init) === null || _b === void 0 ? void 0 : _b.deoptimizePath(path);
         }
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         if (this.isReassigned || !this.init) {
-            return thisParameter.deoptimizePath(UNKNOWN_PATH);
+            return interaction.thisArg.deoptimizePath(UNKNOWN_PATH);
         }
-        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker), undefined);
+        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker), undefined);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         if (this.isReassigned || !this.init) {
@@ -6334,39 +6281,40 @@ class LocalVariable extends Variable {
             return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
         }, UnknownValue);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         if (this.isReassigned || !this.init) {
             return UNKNOWN_EXPRESSION;
         }
         return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
             this.expressionsToBeDeoptimized.push(origin);
-            return this.init.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+            return this.init.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }, UNKNOWN_EXPRESSION);
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        if (this.isReassigned)
-            return true;
-        return (this.init &&
-            !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.init.hasEffectsWhenAccessedAtPath(path, context));
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (this.included)
-            return true;
-        if (path.length === 0)
-            return false;
-        if (this.isReassigned)
-            return true;
-        return (this.init &&
-            !context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.init.hasEffectsWhenAssignedAtPath(path, context));
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (this.isReassigned)
-            return true;
-        return (this.init &&
-            !(callOptions.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, callOptions, this) &&
-            this.init.hasEffectsWhenCalledAtPath(path, callOptions, context));
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED:
+                if (this.isReassigned)
+                    return true;
+                return (this.init &&
+                    !context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            case INTERACTION_ASSIGNED:
+                if (this.included)
+                    return true;
+                if (path.length === 0)
+                    return false;
+                if (this.isReassigned)
+                    return true;
+                return (this.init &&
+                    !context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            case INTERACTION_CALLED:
+                if (this.isReassigned)
+                    return true;
+                return (this.init &&
+                    !(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+        }
     }
     include() {
         if (!this.included) {
@@ -6721,9 +6669,9 @@ const PF = {
 const MUTATES_ARG_WITHOUT_ACCESSOR = {
     __proto__: null,
     [ValueProperties]: {
-        hasEffectsWhenCalled(callOptions, context) {
-            return (!callOptions.args.length ||
-                callOptions.args[0].hasEffectsWhenAssignedAtPath(UNKNOWN_NON_ACCESSOR_PATH, context));
+        hasEffectsWhenCalled({ args }, context) {
+            return (!args.length ||
+                args[0].hasEffectsOnInteractionAtPath(UNKNOWN_NON_ACCESSOR_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context));
         }
     }
 };
@@ -7564,16 +7512,21 @@ class GlobalVariable extends Variable {
     getLiteralValueAtPath(path, _recursionTracker, _origin) {
         return getGlobalAtPath([this.name, ...path]) ? UnknownTruthyValue : UnknownValue;
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (path.length === 0) {
-            // Technically, "undefined" is a global variable of sorts
-            return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED:
+                if (path.length === 0) {
+                    // Technically, "undefined" is a global variable of sorts
+                    return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+                }
+                return !getGlobalAtPath([this.name, ...path].slice(0, -1));
+            case INTERACTION_ASSIGNED:
+                return true;
+            case INTERACTION_CALLED: {
+                const globalAtPath = getGlobalAtPath([this.name, ...path]);
+                return !globalAtPath || globalAtPath.hasEffectsWhenCalled(interaction, context);
+            }
         }
-        return !getGlobalAtPath([this.name, ...path].slice(0, -1));
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        const globalAtPath = getGlobalAtPath([this.name, ...path]);
-        return !globalAtPath || globalAtPath.hasEffectsWhenCalled(callOptions, context);
     }
 }
 
@@ -7641,16 +7594,16 @@ class Identifier extends NodeBase {
         // Identifier as property that might be deoptimized by default
         (_a = this.variable) === null || _a === void 0 ? void 0 : _a.deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
-    hasEffects() {
+    hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
         if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
@@ -7658,17 +7611,18 @@ class Identifier extends NodeBase {
         }
         return (this.context.options.treeshake.unknownGlobalSideEffects &&
             this.variable instanceof GlobalVariable &&
-            this.variable.hasEffectsWhenAccessedAtPath(EMPTY_PATH));
+            this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return (this.variable !== null &&
-            this.getVariableRespectingTDZ().hasEffectsWhenAccessedAtPath(path, context));
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return this.getVariableRespectingTDZ().hasEffectsWhenCalledAtPath(path, callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED:
+                return (this.variable !== null &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            case INTERACTION_ASSIGNED:
+                return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
+            case INTERACTION_CALLED:
+                return this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
     }
     include() {
         if (!this.deoptimized)
@@ -8028,8 +7982,9 @@ class RestElement extends NodeBase {
     deoptimizePath(path) {
         path.length === 0 && this.argument.deoptimizePath(EMPTY_PATH);
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return path.length > 0 || this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 ||
+            this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
     }
     markDeclarationReached() {
         this.argument.markDeclarationReached();
@@ -8057,17 +8012,17 @@ class FunctionBase extends NodeBase {
             this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
         }
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         if (path.length > 0) {
-            this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+            this.getObjectEntity().deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         if (path.length > 0) {
-            return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+            return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }
         if (this.async) {
             if (!this.deoptimizedReturn) {
@@ -8079,24 +8034,18 @@ class FunctionBase extends NodeBase {
         }
         return this.scope.getReturnExpression();
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length > 0) {
-            return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (path.length > 0 || interaction.type !== INTERACTION_CALLED) {
+            return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
         }
         if (this.async) {
             const { propertyReadSideEffects } = this.context.options
                 .treeshake;
             const returnExpression = this.scope.getReturnExpression();
-            if (returnExpression.hasEffectsWhenCalledAtPath(['then'], { args: NO_ARGS, thisParam: null, withNew: false }, context) ||
+            if (returnExpression.hasEffectsOnInteractionAtPath(['then'], NODE_INTERACTION_UNKNOWN_CALL, context) ||
                 (propertyReadSideEffects &&
                     (propertyReadSideEffects === 'always' ||
-                        returnExpression.hasEffectsWhenAccessedAtPath(['then'], context)))) {
+                        returnExpression.hasEffectsOnInteractionAtPath(['then'], NODE_INTERACTION_UNKNOWN_ACCESS, context)))) {
                 return true;
             }
         }
@@ -8150,20 +8099,22 @@ class ArrowFunctionExpression extends FunctionBase {
             this.applyDeoptimizations();
         return false;
     }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (super.hasEffectsWhenCalledAtPath(path, callOptions, context))
-            return true;
-        const { ignore, brokenFlow } = context;
-        context.ignore = {
-            breaks: false,
-            continues: false,
-            labels: new Set(),
-            returnYield: true
-        };
-        if (this.body.hasEffects(context))
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context))
             return true;
-        context.ignore = ignore;
-        context.brokenFlow = brokenFlow;
+        if (interaction.type === INTERACTION_CALLED) {
+            const { ignore, brokenFlow } = context;
+            context.ignore = {
+                breaks: false,
+                continues: false,
+                labels: new Set(),
+                returnYield: true
+            };
+            if (this.body.hasEffects(context))
+                return true;
+            context.ignore = ignore;
+            context.brokenFlow = brokenFlow;
+        }
         return false;
     }
     include(context, includeChildrenRecursively) {
@@ -8249,11 +8200,12 @@ class ObjectPattern extends NodeBase {
             }
         }
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (path.length > 0)
-            return true;
+    hasEffectsOnInteractionAtPath(
+    // At the moment, this is only triggered for assignment left-hand sides,
+    // where the path is empty
+    _path, interaction, context) {
         for (const property of this.properties) {
-            if (property.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
+            if (property.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context))
                 return true;
         }
         return false;
@@ -8267,75 +8219,78 @@ class ObjectPattern extends NodeBase {
 
 class AssignmentExpression extends NodeBase {
     hasEffects(context) {
-        if (!this.deoptimized)
+        const { deoptimized, left, right } = this;
+        if (!deoptimized)
             this.applyDeoptimizations();
-        return (this.right.hasEffects(context) ||
-            this.left.hasEffects(context) ||
-            this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context));
+        // MemberExpressions do not access the property before assignments if the
+        // operator is '='.
+        return (right.hasEffects(context) || left.hasEffectsAsAssignmentTarget(context, this.operator !== '='));
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return path.length > 0 && this.right.hasEffectsWhenAccessedAtPath(path, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.right.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
+        const { deoptimized, left, right, operator } = this;
+        if (!deoptimized)
             this.applyDeoptimizations();
         this.included = true;
-        let hasEffectsContext;
         if (includeChildrenRecursively ||
-            this.operator !== '=' ||
-            this.left.included ||
-            ((hasEffectsContext = createHasEffectsContext()),
-                this.left.hasEffects(hasEffectsContext) ||
-                    this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, hasEffectsContext))) {
-            this.left.include(context, includeChildrenRecursively);
+            operator !== '=' ||
+            left.included ||
+            left.hasEffectsAsAssignmentTarget(createHasEffectsContext(), false)) {
+            left.includeAsAssignmentTarget(context, includeChildrenRecursively, operator !== '=');
         }
-        this.right.include(context, includeChildrenRecursively);
+        right.include(context, includeChildrenRecursively);
+    }
+    initialise() {
+        this.left.setAssignedValue(this.right);
     }
     render(code, options, { preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
-        if (this.left.included) {
-            this.left.render(code, options);
-            this.right.render(code, options);
+        const { left, right, start, end, parent } = this;
+        if (left.included) {
+            left.render(code, options);
+            right.render(code, options);
         }
         else {
-            const inclusionStart = findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, '=', this.left.end) + 1);
-            code.remove(this.start, inclusionStart);
+            const inclusionStart = findNonWhiteSpace(code.original, findFirstOccurrenceOutsideComment(code.original, '=', left.end) + 1);
+            code.remove(start, inclusionStart);
             if (preventASI) {
-                removeLineBreaks(code, inclusionStart, this.right.start);
+                removeLineBreaks(code, inclusionStart, right.start);
             }
-            this.right.render(code, options, {
-                renderedParentType: renderedParentType || this.parent.type,
-                renderedSurroundingElement: renderedSurroundingElement || this.parent.type
+            right.render(code, options, {
+                renderedParentType: renderedParentType || parent.type,
+                renderedSurroundingElement: renderedSurroundingElement || parent.type
             });
         }
         if (options.format === 'system') {
-            if (this.left instanceof Identifier) {
-                const variable = this.left.variable;
+            if (left instanceof Identifier) {
+                const variable = left.variable;
                 const exportNames = options.exportNamesByVariable.get(variable);
                 if (exportNames) {
                     if (exportNames.length === 1) {
-                        renderSystemExportExpression(variable, this.start, this.end, code, options);
+                        renderSystemExportExpression(variable, start, end, code, options);
                     }
                     else {
-                        renderSystemExportSequenceAfterExpression(variable, this.start, this.end, this.parent.type !== ExpressionStatement$1, code, options);
+                        renderSystemExportSequenceAfterExpression(variable, start, end, parent.type !== ExpressionStatement$1, code, options);
                     }
                     return;
                 }
             }
             else {
                 const systemPatternExports = [];
-                this.left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
+                left.addExportedVariables(systemPatternExports, options.exportNamesByVariable);
                 if (systemPatternExports.length > 0) {
-                    renderSystemExportFunction(systemPatternExports, this.start, this.end, renderedSurroundingElement === ExpressionStatement$1, code, options);
+                    renderSystemExportFunction(systemPatternExports, start, end, renderedSurroundingElement === ExpressionStatement$1, code, options);
                     return;
                 }
             }
         }
-        if (this.left.included &&
-            this.left instanceof ObjectPattern &&
+        if (left.included &&
+            left instanceof ObjectPattern &&
             (renderedSurroundingElement === ExpressionStatement$1 ||
                 renderedSurroundingElement === ArrowFunctionExpression$1)) {
-            code.appendRight(this.start, '(');
-            code.prependLeft(this.end, ')');
+            code.appendRight(start, '(');
+            code.prependLeft(end, ')');
         }
     }
     applyDeoptimizations() {
@@ -8356,27 +8311,15 @@ class AssignmentPattern extends NodeBase {
     deoptimizePath(path) {
         path.length === 0 && this.left.deoptimizePath(path);
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return path.length > 0 || this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
-    }
-    include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        this.included = true;
-        this.left.include(context, includeChildrenRecursively);
-        this.right.include(context, includeChildrenRecursively);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (path.length > 0 || this.left.hasEffectsOnInteractionAtPath(EMPTY_PATH, interaction, context));
     }
     markDeclarationReached() {
         this.left.markDeclarationReached();
     }
     render(code, options, { isShorthandProperty } = BLANK) {
         this.left.render(code, options, { isShorthandProperty });
-        if (this.right.included) {
-            this.right.render(code, options);
-        }
-        else {
-            code.remove(this.left.end, this.end);
-        }
+        this.right.render(code, options);
     }
     applyDeoptimizations() {
         this.deoptimized = true;
@@ -8390,14 +8333,8 @@ class ArgumentsVariable extends LocalVariable {
     constructor(context) {
         super('arguments', null, UNKNOWN_EXPRESSION, context);
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenAssignedAtPath() {
-        return true;
-    }
-    hasEffectsWhenCalledAtPath() {
-        return true;
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
     }
 }
 
@@ -8413,8 +8350,8 @@ class ThisVariable extends LocalVariable {
         for (const path of this.deoptimizedPaths) {
             entity.deoptimizePath(path);
         }
-        for (const thisDeoptimization of this.thisDeoptimizationList) {
-            this.applyThisDeoptimizationEvent(entity, thisDeoptimization);
+        for (const { interaction, path } of this.thisDeoptimizationList) {
+            entity.deoptimizeThisOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
         }
         this.entitiesToBeDeoptimized.add(entity);
     }
@@ -8428,29 +8365,21 @@ class ThisVariable extends LocalVariable {
             entity.deoptimizePath(path);
         }
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter) {
+    deoptimizeThisOnInteractionAtPath(interaction, path) {
         const thisDeoptimization = {
-            event,
-            path,
-            thisParameter
+            interaction,
+            path
         };
-        if (!this.thisDeoptimizations.trackEntityAtPathAndGetIfTracked(path, event, thisParameter)) {
+        if (!this.thisDeoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.type, interaction.thisArg)) {
             for (const entity of this.entitiesToBeDeoptimized) {
-                this.applyThisDeoptimizationEvent(entity, thisDeoptimization);
+                entity.deoptimizeThisOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
             }
             this.thisDeoptimizationList.push(thisDeoptimization);
         }
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return (this.getInit(context).hasEffectsWhenAccessedAtPath(path, context) ||
-            super.hasEffectsWhenAccessedAtPath(path, context));
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return (this.getInit(context).hasEffectsWhenAssignedAtPath(path, context) ||
-            super.hasEffectsWhenAssignedAtPath(path, context));
-    }
-    applyThisDeoptimizationEvent(entity, { event, path, thisParameter }) {
-        entity.deoptimizeThisOnEventAtPath(event, path, thisParameter === this ? entity : thisParameter, SHARED_RECURSION_TRACKER);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return (this.getInit(context).hasEffectsOnInteractionAtPath(path, interaction, context) ||
+            super.hasEffectsOnInteractionAtPath(path, interaction, context));
     }
     getInit(context) {
         return context.replacedVariableInits.get(this) || UNKNOWN_EXPRESSION;
@@ -8486,42 +8415,44 @@ class FunctionNode extends FunctionBase {
     createScope(parentScope) {
         this.scope = new FunctionScope(parentScope, this.context);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        super.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
-        if (event === EVENT_CALLED && path.length === 0) {
-            this.scope.thisVariable.addEntityToBeDeoptimized(thisParameter);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        super.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
+        if (interaction.type === INTERACTION_CALLED && path.length === 0) {
+            this.scope.thisVariable.addEntityToBeDeoptimized(interaction.thisArg);
         }
     }
-    hasEffects() {
+    hasEffects(context) {
         var _a;
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        return !!((_a = this.id) === null || _a === void 0 ? void 0 : _a.hasEffects());
+        return !!((_a = this.id) === null || _a === void 0 ? void 0 : _a.hasEffects(context));
     }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (super.hasEffectsWhenCalledAtPath(path, callOptions, context))
-            return true;
-        const thisInit = context.replacedVariableInits.get(this.scope.thisVariable);
-        context.replacedVariableInits.set(this.scope.thisVariable, callOptions.withNew
-            ? new ObjectEntity(Object.create(null), OBJECT_PROTOTYPE)
-            : UNKNOWN_EXPRESSION);
-        const { brokenFlow, ignore } = context;
-        context.ignore = {
-            breaks: false,
-            continues: false,
-            labels: new Set(),
-            returnYield: true
-        };
-        if (this.body.hasEffects(context))
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (super.hasEffectsOnInteractionAtPath(path, interaction, context))
             return true;
-        context.brokenFlow = brokenFlow;
-        if (thisInit) {
-            context.replacedVariableInits.set(this.scope.thisVariable, thisInit);
-        }
-        else {
-            context.replacedVariableInits.delete(this.scope.thisVariable);
+        if (interaction.type === INTERACTION_CALLED) {
+            const thisInit = context.replacedVariableInits.get(this.scope.thisVariable);
+            context.replacedVariableInits.set(this.scope.thisVariable, interaction.withNew
+                ? new ObjectEntity(Object.create(null), OBJECT_PROTOTYPE)
+                : UNKNOWN_EXPRESSION);
+            const { brokenFlow, ignore } = context;
+            context.ignore = {
+                breaks: false,
+                continues: false,
+                labels: new Set(),
+                returnYield: true
+            };
+            if (this.body.hasEffects(context))
+                return true;
+            context.brokenFlow = brokenFlow;
+            if (thisInit) {
+                context.replacedVariableInits.set(this.scope.thisVariable, thisInit);
+            }
+            else {
+                context.replacedVariableInits.delete(this.scope.thisVariable);
+            }
+            context.ignore = ignore;
         }
-        context.ignore = ignore;
         return false;
     }
     include(context, includeChildrenRecursively) {
@@ -8624,12 +8555,13 @@ class BinaryExpression extends NodeBase {
         // support some implicit type coercion runtime errors
         if (this.operator === '+' &&
             this.parent instanceof ExpressionStatement &&
-            this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '')
+            this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this) === '') {
             return true;
+        }
         return super.hasEffects(context);
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > 1;
     }
     render(code, options, { renderedSurroundingElement } = BLANK) {
         this.left.render(code, options, { renderedSurroundingElement });
@@ -8688,7 +8620,7 @@ function renderCallArguments(code, options, node) {
 }
 
 class Literal extends NodeBase {
-    deoptimizeThisOnEventAtPath() { }
+    deoptimizeThisOnInteractionAtPath() { }
     getLiteralValueAtPath(path) {
         if (path.length > 0 ||
             // unknown literals can also be null but do not start with an "n"
@@ -8705,17 +8637,16 @@ class Literal extends NodeBase {
             return UNKNOWN_EXPRESSION;
         return getMemberReturnExpressionWhenCalled(this.members, path[0]);
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (this.value === null) {
-            return path.length > 0;
-        }
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(this.members, path[0], callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED:
+                return path.length > (this.value === null ? 0 : 1);
+            case INTERACTION_ASSIGNED:
+                return true;
+            case INTERACTION_CALLED:
+                return (path.length !== 1 ||
+                    hasMemberEffectWhenCalled(this.members, path[0], interaction, context));
         }
-        return true;
     }
     initialise() {
         this.members = getLiteralMembersForValue(this.value);
@@ -8773,6 +8704,7 @@ class MemberExpression extends NodeBase {
     constructor() {
         super(...arguments);
         this.variable = null;
+        this.assignmentDeoptimized = false;
         this.bound = false;
         this.expressionsToBeDeoptimized = [];
         this.replacement = null;
@@ -8782,7 +8714,7 @@ class MemberExpression extends NodeBase {
         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));
+            const resolvedVariable = resolveNamespaceVariables(baseVariable, path.slice(1), this.context);
             if (!resolvedVariable) {
                 super.bind();
             }
@@ -8823,21 +8755,21 @@ class MemberExpression extends NodeBase {
             }
         }
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         if (this.variable) {
-            this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+            this.variable.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
         }
         else if (!this.replacement) {
             if (path.length < MAX_PATH_DEPTH) {
-                this.object.deoptimizeThisOnEventAtPath(event, [this.getPropertyKey(), ...path], thisParameter, recursionTracker);
+                this.object.deoptimizeThisOnInteractionAtPath(interaction, [this.getPropertyKey(), ...path], recursionTracker);
             }
             else {
-                thisParameter.deoptimizePath(UNKNOWN_PATH);
+                interaction.thisArg.deoptimizePath(UNKNOWN_PATH);
             }
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.variable !== null) {
+        if (this.variable) {
             return this.variable.getLiteralValueAtPath(path, recursionTracker, origin);
         }
         if (this.replacement) {
@@ -8849,81 +8781,62 @@ class MemberExpression extends NodeBase {
         }
         return UnknownValue;
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        if (this.variable !== null) {
-            return this.variable.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (this.variable) {
+            return this.variable.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }
         if (this.replacement) {
             return UNKNOWN_EXPRESSION;
         }
         this.expressionsToBeDeoptimized.push(origin);
         if (path.length < MAX_PATH_DEPTH) {
-            return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], callOptions, recursionTracker, origin);
+            return this.object.getReturnExpressionWhenCalledAtPath([this.getPropertyKey(), ...path], interaction, recursionTracker, origin);
         }
         return UNKNOWN_EXPRESSION;
     }
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        const { propertyReadSideEffects } = this.context.options
-            .treeshake;
         return (this.property.hasEffects(context) ||
             this.object.hasEffects(context) ||
-            // Assignments do not access the property before assigning
-            (!(this.variable ||
-                this.replacement ||
-                (this.parent instanceof AssignmentExpression && this.parent.operator === '=')) &&
-                propertyReadSideEffects &&
-                (propertyReadSideEffects === 'always' ||
-                    this.object.hasEffectsWhenAccessedAtPath([this.getPropertyKey()], context))));
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        if (this.variable !== null) {
-            return this.variable.hasEffectsWhenAccessedAtPath(path, context);
-        }
-        if (this.replacement) {
-            return true;
-        }
-        if (path.length < MAX_PATH_DEPTH) {
-            return this.object.hasEffectsWhenAccessedAtPath([this.getPropertyKey(), ...path], context);
-        }
-        return true;
+            this.hasAccessEffect(context));
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (this.variable !== null) {
-            return this.variable.hasEffectsWhenAssignedAtPath(path, context);
-        }
-        if (this.replacement) {
-            return true;
-        }
-        if (path.length < MAX_PATH_DEPTH) {
-            return this.object.hasEffectsWhenAssignedAtPath([this.getPropertyKey(), ...path], context);
-        }
-        return true;
+    hasEffectsAsAssignmentTarget(context, checkAccess) {
+        if (checkAccess && !this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        return (this.property.hasEffects(context) ||
+            this.object.hasEffects(context) ||
+            (checkAccess && this.hasAccessEffect(context)) ||
+            this.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.assignmentInteraction, context));
     }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (this.variable !== null) {
-            return this.variable.hasEffectsWhenCalledAtPath(path, callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.variable) {
+            return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
         }
         if (this.replacement) {
             return true;
         }
         if (path.length < MAX_PATH_DEPTH) {
-            return this.object.hasEffectsWhenCalledAtPath([this.getPropertyKey(), ...path], callOptions, context);
+            return this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey(), ...path], interaction, context);
         }
         return true;
     }
     include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.context.includeVariableInModule(this.variable);
-            }
+        this.includeProperties(context, includeChildrenRecursively);
+    }
+    includeAsAssignmentTarget(context, includeChildrenRecursively, deoptimizeAccess) {
+        if (!this.assignmentDeoptimized)
+            this.applyAssignmentDeoptimization();
+        if (deoptimizeAccess) {
+            this.include(context, includeChildrenRecursively);
+        }
+        else {
+            this.includeProperties(context, includeChildrenRecursively);
         }
-        this.object.include(context, includeChildrenRecursively);
-        this.property.include(context, includeChildrenRecursively);
     }
     includeCallArguments(context, args) {
         if (this.variable) {
@@ -8935,6 +8848,7 @@ class MemberExpression extends NodeBase {
     }
     initialise() {
         this.propertyKey = getResolvablePropertyKey(this);
+        this.accessInteraction = { thisArg: this.object, type: INTERACTION_ACCESSED };
     }
     render(code, options, { renderedParentType, isCalleeOfRenderedParent, renderedSurroundingElement } = BLANK) {
         if (this.variable || this.replacement) {
@@ -8955,6 +8869,13 @@ class MemberExpression extends NodeBase {
             this.property.render(code, options);
         }
     }
+    setAssignedValue(value) {
+        this.assignmentInteraction = {
+            args: [value],
+            thisArg: this.object,
+            type: INTERACTION_ASSIGNED
+        };
+    }
     applyDeoptimizations() {
         this.deoptimized = true;
         const { propertyReadSideEffects } = this.context.options
@@ -8964,13 +8885,21 @@ class MemberExpression extends NodeBase {
         this.bound &&
             propertyReadSideEffects &&
             !(this.variable || this.replacement)) {
-            // Regular Assignments do not access the property before assigning
-            if (!(this.parent instanceof AssignmentExpression && this.parent.operator === '=')) {
-                this.object.deoptimizeThisOnEventAtPath(EVENT_ACCESSED, [this.propertyKey], this.object, SHARED_RECURSION_TRACKER);
-            }
-            if (this.parent instanceof AssignmentExpression) {
-                this.object.deoptimizeThisOnEventAtPath(EVENT_ASSIGNED, [this.propertyKey], this.object, SHARED_RECURSION_TRACKER);
-            }
+            const propertyKey = this.getPropertyKey();
+            this.object.deoptimizeThisOnInteractionAtPath(this.accessInteraction, [propertyKey], SHARED_RECURSION_TRACKER);
+            this.context.requestTreeshakingPass();
+        }
+    }
+    applyAssignmentDeoptimization() {
+        this.assignmentDeoptimized = true;
+        const { propertyReadSideEffects } = this.context.options
+            .treeshake;
+        if (
+        // Namespaces are not bound and should not be deoptimized
+        this.bound &&
+            propertyReadSideEffects &&
+            !(this.variable || this.replacement)) {
+            this.object.deoptimizeThisOnInteractionAtPath(this.assignmentInteraction, [this.getPropertyKey()], SHARED_RECURSION_TRACKER);
             this.context.requestTreeshakingPass();
         }
     }
@@ -8996,28 +8925,46 @@ class MemberExpression extends NodeBase {
         }
         return this.propertyKey;
     }
-    resolveNamespaceVariables(baseVariable, path) {
-        if (path.length === 0)
-            return baseVariable;
-        if (!baseVariable.isNamespace || baseVariable instanceof ExternalVariable)
-            return null;
-        const exportName = path[0].key;
-        const variable = baseVariable.context.traceExport(exportName);
-        if (!variable) {
-            const fileName = 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';
+    hasAccessEffect(context) {
+        const { propertyReadSideEffects } = this.context.options
+            .treeshake;
+        return (!(this.variable || this.replacement) &&
+            propertyReadSideEffects &&
+            (propertyReadSideEffects === 'always' ||
+                this.object.hasEffectsOnInteractionAtPath([this.getPropertyKey()], this.accessInteraction, context)));
+    }
+    includeProperties(context, includeChildrenRecursively) {
+        if (!this.included) {
+            this.included = true;
+            if (this.variable) {
+                this.context.includeVariableInModule(this.variable);
+            }
         }
-        return this.resolveNamespaceVariables(variable, path.slice(1));
+        this.object.include(context, includeChildrenRecursively);
+        this.property.include(context, includeChildrenRecursively);
     }
 }
+function resolveNamespaceVariables(baseVariable, path, astContext) {
+    if (path.length === 0)
+        return baseVariable;
+    if (!baseVariable.isNamespace || baseVariable instanceof ExternalVariable)
+        return null;
+    const exportName = path[0].key;
+    const variable = baseVariable.context.traceExport(exportName);
+    if (!variable) {
+        const fileName = baseVariable.context.fileName;
+        astContext.warn({
+            code: 'MISSING_EXPORT',
+            exporter: relativeId(fileName),
+            importer: relativeId(astContext.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 resolveNamespaceVariables(variable, path.slice(1), astContext);
+}
 
 class CallExpressionBase extends NodeBase {
     constructor() {
@@ -9047,15 +8994,15 @@ class CallExpressionBase extends NodeBase {
             returnExpression.deoptimizePath(path);
         }
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         const returnExpression = this.getReturnExpression(recursionTracker);
         if (returnExpression === UNKNOWN_EXPRESSION) {
-            thisParameter.deoptimizePath(UNKNOWN_PATH);
+            interaction.thisArg.deoptimizePath(UNKNOWN_PATH);
         }
         else {
             recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
-                this.expressionsToBeDeoptimized.add(thisParameter);
-                returnExpression.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+                this.expressionsToBeDeoptimized.add(interaction.thisArg);
+                returnExpression.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
             }, undefined);
         }
     }
@@ -9069,27 +9016,31 @@ class CallExpressionBase extends NodeBase {
             return returnExpression.getLiteralValueAtPath(path, recursionTracker, origin);
         }, UnknownValue);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         const returnExpression = this.getReturnExpression(recursionTracker);
         if (this.returnExpression === UNKNOWN_EXPRESSION) {
             return UNKNOWN_EXPRESSION;
         }
         return recursionTracker.withTrackedEntityAtPath(path, returnExpression, () => {
             this.deoptimizableDependentExpressions.push(origin);
-            return returnExpression.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+            return returnExpression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
         }, UNKNOWN_EXPRESSION);
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.getReturnExpression().hasEffectsWhenAccessedAtPath(path, context));
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
-            this.getReturnExpression().hasEffectsWhenAssignedAtPath(path, context));
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return (!(callOptions.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, callOptions, this) &&
-            this.getReturnExpression().hasEffectsWhenCalledAtPath(path, callOptions, context));
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        const { type } = interaction;
+        if (type === INTERACTION_CALLED) {
+            if ((interaction.withNew
+                ? context.instantiated
+                : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this)) {
+                return false;
+            }
+        }
+        else if ((type === INTERACTION_ASSIGNED
+            ? context.assigned
+            : context.accessed).trackEntityAtPathAndGetIfTracked(path, this)) {
+            return false;
+        }
+        return this.getReturnExpression().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
 }
 
@@ -9112,11 +9063,12 @@ class CallExpression extends CallExpressionBase {
                 }, this.start);
             }
         }
-        this.callOptions = {
+        this.interaction = {
             args: this.arguments,
-            thisParam: this.callee instanceof MemberExpression && !this.callee.variable
+            thisArg: this.callee instanceof MemberExpression && !this.callee.variable
                 ? this.callee.object
                 : null,
+            type: INTERACTION_CALLED,
             withNew: false
         };
     }
@@ -9130,7 +9082,7 @@ class CallExpression extends CallExpressionBase {
                 this.annotations)
                 return false;
             return (this.callee.hasEffects(context) ||
-                this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+                this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
         }
         finally {
             if (!this.deoptimized)
@@ -9167,9 +9119,8 @@ class CallExpression extends CallExpressionBase {
     }
     applyDeoptimizations() {
         this.deoptimized = true;
-        const { thisParam } = this.callOptions;
-        if (thisParam) {
-            this.callee.deoptimizeThisOnEventAtPath(EVENT_CALLED, EMPTY_PATH, thisParam, SHARED_RECURSION_TRACKER);
+        if (this.interaction.thisArg) {
+            this.callee.deoptimizeThisOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
         }
         for (const argument of this.arguments) {
             // This will make sure all properties of parameters behave as "unknown"
@@ -9180,7 +9131,7 @@ class CallExpression extends CallExpressionBase {
     getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
         if (this.returnExpression === null) {
             this.returnExpression = UNKNOWN_EXPRESSION;
-            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.callOptions, recursionTracker, this));
+            return (this.returnExpression = this.callee.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
         }
         return this.returnExpression;
     }
@@ -9258,11 +9209,6 @@ class MethodBase extends NodeBase {
     constructor() {
         super(...arguments);
         this.accessedValue = null;
-        this.accessorCallOptions = {
-            args: NO_ARGS,
-            thisParam: null,
-            withNew: false
-        };
     }
     // As getter properties directly receive their values from fixed function
     // expressions, there is no known situation where a getter is deoptimized.
@@ -9270,45 +9216,60 @@ class MethodBase extends NodeBase {
     deoptimizePath(path) {
         this.getAccessedValue().deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        if (event === EVENT_ACCESSED && this.kind === 'get' && path.length === 0) {
-            return this.value.deoptimizeThisOnEventAtPath(EVENT_CALLED, EMPTY_PATH, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (interaction.type === INTERACTION_ACCESSED && this.kind === 'get' && path.length === 0) {
+            return this.value.deoptimizeThisOnInteractionAtPath({
+                args: NO_ARGS,
+                thisArg: interaction.thisArg,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
         }
-        if (event === EVENT_ASSIGNED && this.kind === 'set' && path.length === 0) {
-            return this.value.deoptimizeThisOnEventAtPath(EVENT_CALLED, EMPTY_PATH, thisParameter, recursionTracker);
+        if (interaction.type === INTERACTION_ASSIGNED && this.kind === 'set' && path.length === 0) {
+            return this.value.deoptimizeThisOnInteractionAtPath({
+                args: interaction.args,
+                thisArg: interaction.thisArg,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, EMPTY_PATH, recursionTracker);
         }
-        this.getAccessedValue().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        this.getAccessedValue().deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.getAccessedValue().getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return this.getAccessedValue().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getAccessedValue().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
     hasEffects(context) {
         return this.key.hasEffects(context);
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        if (this.kind === 'get' && path.length === 0) {
-            return this.value.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.accessorCallOptions, context);
-        }
-        return this.getAccessedValue().hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (this.kind === 'set') {
-            return this.value.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.accessorCallOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.kind === 'get' && interaction.type === INTERACTION_ACCESSED && path.length === 0) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: NO_ARGS,
+                thisArg: interaction.thisArg,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
+        }
+        // setters are only called for empty paths
+        if (this.kind === 'set' && interaction.type === INTERACTION_ASSIGNED) {
+            return this.value.hasEffectsOnInteractionAtPath(EMPTY_PATH, {
+                args: interaction.args,
+                thisArg: interaction.thisArg,
+                type: INTERACTION_CALLED,
+                withNew: false
+            }, context);
         }
-        return this.getAccessedValue().hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return this.getAccessedValue().hasEffectsWhenCalledAtPath(path, callOptions, context);
+        return this.getAccessedValue().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     applyDeoptimizations() { }
     getAccessedValue() {
         if (this.accessedValue === null) {
             if (this.kind === 'get') {
                 this.accessedValue = UNKNOWN_EXPRESSION;
-                return (this.accessedValue = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.accessorCallOptions, SHARED_RECURSION_TRACKER, this));
+                return (this.accessedValue = this.value.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_CALL, SHARED_RECURSION_TRACKER, this));
             }
             else {
                 return (this.accessedValue = this.value);
@@ -9331,23 +9292,17 @@ class ObjectMember extends ExpressionEntity {
     deoptimizePath(path) {
         this.object.deoptimizePath([this.key, ...path]);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.object.deoptimizeThisOnEventAtPath(event, [this.key, ...path], thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.object.deoptimizeThisOnInteractionAtPath(interaction, [this.key, ...path], recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.object.getLiteralValueAtPath([this.key, ...path], recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], callOptions, recursionTracker, origin);
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return this.object.hasEffectsWhenAccessedAtPath([this.key, ...path], context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return this.object.hasEffectsWhenAssignedAtPath([this.key, ...path], context);
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], interaction, recursionTracker, origin);
     }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return this.object.hasEffectsWhenCalledAtPath([this.key, ...path], callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.object.hasEffectsOnInteractionAtPath([this.key, ...path], interaction, context);
     }
 }
 
@@ -9365,14 +9320,14 @@ class ClassNode extends NodeBase {
     deoptimizePath(path) {
         this.getObjectEntity().deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
     hasEffects(context) {
         var _a, _b;
@@ -9382,23 +9337,17 @@ class ClassNode extends NodeBase {
         (_b = this.id) === null || _b === void 0 ? void 0 : _b.markDeclarationReached();
         return initEffect || super.hasEffects(context);
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
         var _a;
-        if (path.length === 0) {
-            return (!callOptions.withNew ||
+        if (interaction.type === INTERACTION_CALLED && path.length === 0) {
+            return (!interaction.withNew ||
                 (this.classConstructor !== null
-                    ? this.classConstructor.hasEffectsWhenCalledAtPath(EMPTY_PATH, callOptions, context)
-                    : (_a = this.superClass) === null || _a === void 0 ? void 0 : _a.hasEffectsWhenCalledAtPath(path, callOptions, context)) ||
+                    ? this.classConstructor.hasEffectsOnInteractionAtPath(path, interaction, context)
+                    : (_a = this.superClass) === null || _a === void 0 ? void 0 : _a.hasEffectsOnInteractionAtPath(path, interaction, context)) ||
                 false);
         }
         else {
-            return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
+            return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
         }
     }
     include(context, includeChildrenRecursively) {
@@ -9519,26 +9468,12 @@ class MultiExpression extends ExpressionEntity {
             expression.deoptimizePath(path);
         }
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin)));
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        for (const expression of this.expressions) {
-            if (expression.hasEffectsWhenAccessedAtPath(path, context))
-                return true;
-        }
-        return false;
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return new MultiExpression(this.expressions.map(expression => expression.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)));
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
         for (const expression of this.expressions) {
-            if (expression.hasEffectsWhenAssignedAtPath(path, context))
-                return true;
-        }
-        return false;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        for (const expression of this.expressions) {
-            if (expression.hasEffectsWhenCalledAtPath(path, callOptions, context))
+            if (expression.hasEffectsOnInteractionAtPath(path, interaction, context))
                 return true;
         }
         return false;
@@ -9581,9 +9516,9 @@ class ConditionalExpression extends NodeBase {
             usedBranch.deoptimizePath(path);
         }
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.consequent.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
-        this.alternate.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.consequent.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
+        this.alternate.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
@@ -9592,15 +9527,15 @@ class ConditionalExpression extends NodeBase {
         this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
             return new MultiExpression([
-                this.consequent.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin),
-                this.alternate.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin)
+                this.consequent.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin),
+                this.alternate.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
             ]);
         this.expressionsToBeDeoptimized.push(origin);
-        return usedBranch.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
     hasEffects(context) {
         if (this.test.hasEffects(context))
@@ -9611,29 +9546,13 @@ class ConditionalExpression extends NodeBase {
         }
         return usedBranch.hasEffects(context);
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            return (this.consequent.hasEffectsWhenAccessedAtPath(path, context) ||
-                this.alternate.hasEffectsWhenAccessedAtPath(path, context));
-        }
-        return usedBranch.hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            return (this.consequent.hasEffectsWhenAssignedAtPath(path, context) ||
-                this.alternate.hasEffectsWhenAssignedAtPath(path, context));
-        }
-        return usedBranch.hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
         const usedBranch = this.getUsedBranch();
         if (!usedBranch) {
-            return (this.consequent.hasEffectsWhenCalledAtPath(path, callOptions, context) ||
-                this.alternate.hasEffectsWhenCalledAtPath(path, callOptions, context));
+            return (this.consequent.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.alternate.hasEffectsOnInteractionAtPath(path, interaction, context));
         }
-        return usedBranch.hasEffectsWhenCalledAtPath(path, callOptions, context);
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
@@ -9904,12 +9823,10 @@ class ForInStatement extends NodeBase {
         this.scope = new BlockScope(parentScope);
     }
     hasEffects(context) {
-        if (!this.deoptimized)
+        const { deoptimized, left, right } = this;
+        if (!deoptimized)
             this.applyDeoptimizations();
-        if ((this.left &&
-            (this.left.hasEffects(context) ||
-                this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))) ||
-            (this.right && this.right.hasEffects(context)))
+        if (left.hasEffectsAsAssignmentTarget(context, false) || right.hasEffects(context))
             return true;
         const { brokenFlow, ignore: { breaks, continues } } = context;
         context.ignore.breaks = true;
@@ -9922,15 +9839,19 @@ class ForInStatement extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
             this.applyDeoptimizations();
         this.included = true;
-        this.left.include(context, includeChildrenRecursively || true);
-        this.right.include(context, includeChildrenRecursively);
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
+    initialise() {
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
     render(code, options) {
         this.left.render(code, options, NO_SEMICOLON);
         this.right.render(code, options, NO_SEMICOLON);
@@ -9958,15 +9879,19 @@ class ForOfStatement extends NodeBase {
         return true;
     }
     include(context, includeChildrenRecursively) {
-        if (!this.deoptimized)
+        const { body, deoptimized, left, right } = this;
+        if (!deoptimized)
             this.applyDeoptimizations();
         this.included = true;
-        this.left.include(context, includeChildrenRecursively || true);
-        this.right.include(context, includeChildrenRecursively);
+        left.includeAsAssignmentTarget(context, includeChildrenRecursively || true, false);
+        right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
+    initialise() {
+        this.left.setAssignedValue(UNKNOWN_EXPRESSION);
+    }
     render(code, options) {
         this.left.render(code, options, NO_SEMICOLON);
         this.right.render(code, options, NO_SEMICOLON);
@@ -10673,9 +10598,9 @@ class LogicalExpression extends NodeBase {
             usedBranch.deoptimizePath(path);
         }
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.left.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
-        this.right.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.left.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
+        this.right.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
@@ -10684,15 +10609,15 @@ class LogicalExpression extends NodeBase {
         this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
             return new MultiExpression([
-                this.left.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin),
-                this.right.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin)
+                this.left.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin),
+                this.right.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
             ]);
         this.expressionsToBeDeoptimized.push(origin);
-        return usedBranch.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+        return usedBranch.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
     hasEffects(context) {
         if (this.left.hasEffects(context)) {
@@ -10703,29 +10628,13 @@ class LogicalExpression extends NodeBase {
         }
         return false;
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
         const usedBranch = this.getUsedBranch();
         if (!usedBranch) {
-            return (this.left.hasEffectsWhenAccessedAtPath(path, context) ||
-                this.right.hasEffectsWhenAccessedAtPath(path, context));
+            return (this.left.hasEffectsOnInteractionAtPath(path, interaction, context) ||
+                this.right.hasEffectsOnInteractionAtPath(path, interaction, context));
         }
-        return usedBranch.hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            return (this.left.hasEffectsWhenAssignedAtPath(path, context) ||
-                this.right.hasEffectsWhenAssignedAtPath(path, context));
-        }
-        return usedBranch.hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        const usedBranch = this.getUsedBranch();
-        if (!usedBranch) {
-            return (this.left.hasEffectsWhenCalledAtPath(path, callOptions, context) ||
-                this.right.hasEffectsWhenCalledAtPath(path, callOptions, context));
-        }
-        return usedBranch.hasEffectsWhenCalledAtPath(path, callOptions, context);
+        return usedBranch.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
@@ -10815,8 +10724,8 @@ class MetaProperty extends NodeBase {
     hasEffects() {
         return false;
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type !== INTERACTION_ACCESSED;
     }
     include() {
         if (!this.included) {
@@ -10961,18 +10870,19 @@ class NewExpression extends NodeBase {
                     return true;
             }
             if (this.context.options.treeshake.annotations &&
-                this.annotations)
+                this.annotations) {
                 return false;
+            }
             return (this.callee.hasEffects(context) ||
-                this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+                this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
         }
         finally {
             if (!this.deoptimized)
                 this.applyDeoptimizations();
         }
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 0;
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 0 || type !== INTERACTION_ACCESSED;
     }
     include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
@@ -10987,9 +10897,10 @@ class NewExpression extends NodeBase {
         this.callee.includeCallArguments(context, this.arguments);
     }
     initialise() {
-        this.callOptions = {
+        this.interaction = {
             args: this.arguments,
-            thisParam: null,
+            thisArg: null,
+            type: INTERACTION_CALLED,
             withNew: true
         };
     }
@@ -11018,23 +10929,17 @@ class ObjectExpression extends NodeBase {
     deoptimizePath(path) {
         this.getObjectEntity().deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.getObjectEntity().deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
-        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
-    }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAccessedAtPath(path, context);
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.getObjectEntity().hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
@@ -11165,32 +11070,26 @@ class PropertyDefinition extends NodeBase {
         var _a;
         (_a = this.value) === null || _a === void 0 ? void 0 : _a.deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         var _a;
-        (_a = this.value) === null || _a === void 0 ? void 0 : _a.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        (_a = this.value) === null || _a === void 0 ? void 0 : _a.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.value
             ? this.value.getLiteralValueAtPath(path, recursionTracker, origin)
             : UnknownValue;
     }
-    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
         return this.value
-            ? this.value.getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin)
+            ? this.value.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin)
             : UNKNOWN_EXPRESSION;
     }
     hasEffects(context) {
         var _a;
         return this.key.hasEffects(context) || (this.static && !!((_a = this.value) === null || _a === void 0 ? void 0 : _a.hasEffects(context)));
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return !this.value || this.value.hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return !this.value || this.value.hasEffectsWhenAssignedAtPath(path, context);
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return !this.value || this.value.hasEffectsWhenCalledAtPath(path, callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return !this.value || this.value.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     applyDeoptimizations() { }
 }
@@ -11226,8 +11125,8 @@ class SequenceExpression extends NodeBase {
     deoptimizePath(path) {
         this.expressions[this.expressions.length - 1].deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.expressions[this.expressions.length - 1].deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.expressions[this.expressions.length - 1].deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         return this.expressions[this.expressions.length - 1].getLiteralValueAtPath(path, recursionTracker, origin);
@@ -11239,15 +11138,8 @@ class SequenceExpression extends NodeBase {
         }
         return false;
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return (path.length > 0 &&
-            this.expressions[this.expressions.length - 1].hasEffectsWhenAccessedAtPath(path, context));
-    }
-    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);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        return this.expressions[this.expressions.length - 1].hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
@@ -11326,8 +11218,8 @@ class Super extends NodeBase {
     deoptimizePath(path) {
         this.variable.deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker);
     }
     include() {
         if (!this.included) {
@@ -11467,7 +11359,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
                     return true;
             }
             return (this.tag.hasEffects(context) ||
-                this.tag.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+                this.tag.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
         }
         finally {
             if (!this.deoptimized)
@@ -11485,16 +11377,17 @@ class TaggedTemplateExpression extends CallExpressionBase {
             this.tag.include(context, includeChildrenRecursively);
             this.quasi.include(context, includeChildrenRecursively);
         }
-        this.tag.includeCallArguments(context, this.callOptions.args);
+        this.tag.includeCallArguments(context, this.interaction.args);
         const returnExpression = this.getReturnExpression();
         if (!returnExpression.included) {
             returnExpression.include(context, false);
         }
     }
     initialise() {
-        this.callOptions = {
+        this.interaction = {
             args: [UNKNOWN_EXPRESSION, ...this.quasi.expressions],
-            thisParam: this.tag instanceof MemberExpression && !this.tag.variable ? this.tag.object : null,
+            thisArg: this.tag instanceof MemberExpression && !this.tag.variable ? this.tag.object : null,
+            type: INTERACTION_CALLED,
             withNew: false
         };
     }
@@ -11504,9 +11397,8 @@ class TaggedTemplateExpression extends CallExpressionBase {
     }
     applyDeoptimizations() {
         this.deoptimized = true;
-        const { thisParam } = this.callOptions;
-        if (thisParam) {
-            this.tag.deoptimizeThisOnEventAtPath(EVENT_CALLED, EMPTY_PATH, thisParam, SHARED_RECURSION_TRACKER);
+        if (this.interaction.thisArg) {
+            this.tag.deoptimizeThisOnInteractionAtPath(this.interaction, EMPTY_PATH, SHARED_RECURSION_TRACKER);
         }
         for (const argument of this.quasi.expressions) {
             // This will make sure all properties of parameters behave as "unknown"
@@ -11517,7 +11409,7 @@ class TaggedTemplateExpression extends CallExpressionBase {
     getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
         if (this.returnExpression === null) {
             this.returnExpression = UNKNOWN_EXPRESSION;
-            return (this.returnExpression = this.tag.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.callOptions, recursionTracker, this));
+            return (this.returnExpression = this.tag.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.interaction, recursionTracker, this));
         }
         return this.returnExpression;
     }
@@ -11540,7 +11432,7 @@ class TemplateElement extends NodeBase {
 }
 
 class TemplateLiteral extends NodeBase {
-    deoptimizeThisOnEventAtPath() { }
+    deoptimizeThisOnInteractionAtPath() { }
     getLiteralValueAtPath(path) {
         if (path.length > 0 || this.quasis.length !== 1) {
             return UnknownValue;
@@ -11553,12 +11445,12 @@ class TemplateLiteral extends NodeBase {
         }
         return getMemberReturnExpressionWhenCalled(literalStringMembers, path[0]);
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length === 1) {
-            return hasMemberEffectWhenCalled(literalStringMembers, path[0], callOptions, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (interaction.type === INTERACTION_ACCESSED) {
+            return path.length > 1;
+        }
+        if (interaction.type === INTERACTION_CALLED && path.length === 1) {
+            return hasMemberEffectWhenCalled(literalStringMembers, path[0], interaction, context);
         }
         return true;
     }
@@ -11686,16 +11578,15 @@ class ThisExpression extends NodeBase {
     deoptimizePath(path) {
         this.variable.deoptimizePath(path);
     }
-    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
-        this.variable.deoptimizeThisOnEventAtPath(event, path, 
+    deoptimizeThisOnInteractionAtPath(interaction, path, recursionTracker) {
         // We rewrite the parameter so that a ThisVariable can detect self-mutations
-        thisParameter === this ? this.variable : thisParameter, recursionTracker);
+        this.variable.deoptimizeThisOnInteractionAtPath(interaction.thisArg === this ? { ...interaction, thisArg: this.variable } : interaction, path, recursionTracker);
     }
-    hasEffectsWhenAccessedAtPath(path, context) {
-        return path.length > 0 && this.variable.hasEffectsWhenAccessedAtPath(path, context);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return this.variable.hasEffectsWhenAssignedAtPath(path, context);
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (path.length === 0) {
+            return interaction.type !== INTERACTION_ACCESSED;
+        }
+        return this.variable.hasEffectsOnInteractionAtPath(path, interaction, context);
     }
     include() {
         if (!this.included) {
@@ -11804,13 +11695,10 @@ class UnaryExpression extends NodeBase {
             return false;
         return (this.argument.hasEffects(context) ||
             (this.operator === 'delete' &&
-                this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context)));
+                this.argument.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context)));
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (this.operator === 'void') {
-            return path.length > 0;
-        }
-        return path.length > 1;
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return type !== INTERACTION_ACCESSED || path.length > (this.operator === 'void' ? 0 : 1);
     }
     applyDeoptimizations() {
         this.deoptimized = true;
@@ -11834,11 +11722,19 @@ class UpdateExpression extends NodeBase {
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        return (this.argument.hasEffects(context) ||
-            this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context));
+        return this.argument.hasEffectsAsAssignmentTarget(context, true);
+    }
+    hasEffectsOnInteractionAtPath(path, { type }) {
+        return path.length > 1 || type !== INTERACTION_ACCESSED;
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.argument.includeAsAssignmentTarget(context, includeChildrenRecursively, true);
     }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
+    initialise() {
+        this.argument.setAssignedValue(UNKNOWN_EXPRESSION);
     }
     render(code, options) {
         const { exportNamesByVariable, format, snippets: { _ } } = options;
@@ -11900,7 +11796,7 @@ class VariableDeclaration extends NodeBase {
             declarator.deoptimizePath(EMPTY_PATH);
         }
     }
-    hasEffectsWhenAssignedAtPath() {
+    hasEffectsOnInteractionAtPath() {
         return false;
     }
     include(context, includeChildrenRecursively, { asSingleStatement } = BLANK) {
@@ -14569,7 +14465,7 @@ function renderChunk({ code, options, outputPluginDriver, renderChunk, sourcemap
 
 function renderNamePattern(pattern, patternName, replacements) {
     if (isPathFragment(pattern))
-        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths.`));
+        return error(errFailedValidation(`Invalid pattern "${pattern}" for "${patternName}", patterns can be neither absolute nor relative paths. If you want your files to be stored in a subdirectory, write its name without a leading slash like this: subdirectory/pattern.`));
     return pattern.replace(/\[(\w+)\]/g, (_match, type) => {
         if (!replacements.hasOwnProperty(type)) {
             return error(errFailedValidation(`"[${type}]" is not a valid placeholder in "${patternName}" pattern.`));
@@ -23472,6 +23368,16 @@ function sanitizeFileName(name) {
     return driveLetter + name.substr(driveLetter.length).replace(INVALID_CHAR_REGEX, '_');
 }
 
+function isValidUrl(url) {
+    try {
+        new URL(url);
+    }
+    catch (_) {
+        return false;
+    }
+    return true;
+}
+
 function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
     var _a, _b, _c, _d, _e, _f, _g;
     // These are options that may trigger special warnings or behaviour later
@@ -23525,6 +23431,7 @@ function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
                 ? id => id
                 : sanitizeFileName,
         sourcemap: config.sourcemap || false,
+        sourcemapBaseUrl: getSourcemapBaseUrl(config),
         sourcemapExcludeSources: config.sourcemapExcludeSources || false,
         sourcemapFile: config.sourcemapFile,
         sourcemapPathTransform: config.sourcemapPathTransform,
@@ -23750,6 +23657,15 @@ const getNamespaceToStringTag = (config, generatedCode, inputOptions) => {
     }
     return generatedCode.symbols || false;
 };
+const getSourcemapBaseUrl = (config) => {
+    const { sourcemapBaseUrl } = config;
+    if (sourcemapBaseUrl) {
+        if (isValidUrl(sourcemapBaseUrl)) {
+            return sourcemapBaseUrl;
+        }
+        return error(errInvalidOption('output.sourcemapBaseUrl', 'outputsourcemapbaseurl', `must be a valid URL, received ${JSON.stringify(sourcemapBaseUrl)}`));
+    }
+};
 
 function rollup(rawInputOptions) {
     return rollupInternal(rawInputOptions, null);
@@ -23912,7 +23828,11 @@ async function writeOutputFile(outputFile, outputOptions) {
                 url = outputFile.map.toUrl();
             }
             else {
-                url = `${require$$0.basename(outputFile.fileName)}.map`;
+                const { sourcemapBaseUrl } = outputOptions;
+                const sourcemapFileName = `${require$$0.basename(outputFile.fileName)}.map`;
+                url = sourcemapBaseUrl
+                    ? new URL(sourcemapFileName, sourcemapBaseUrl).toString()
+                    : sourcemapFileName;
                 writeSourceMapPromise = require$$0$1.promises.writeFile(`${fileName}.map`, outputFile.map.toString());
             }
             if (outputOptions.sourcemap !== 'hidden') {