npm - rollup - Versions diffs - 2.72.0 → 2.74.0 - Mend

rollup 2.72.0 → 2.74.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/CHANGELOG.md +53 -0
package/dist/bin/rollup +2 -2
package/dist/es/rollup.browser.js +3 -3
package/dist/es/rollup.js +2 -2
package/dist/es/shared/rollup.js +881 -675
package/dist/es/shared/watch.js +5 -5
package/dist/loadConfigFile.js +3 -3
package/dist/rollup.browser.js +3 -3
package/dist/rollup.browser.js.map +1 -1
package/dist/rollup.js +2 -2
package/dist/shared/index.js +4 -4
package/dist/shared/loadConfigFile.js +4 -5
package/dist/shared/mergeOptions.js +2 -2
package/dist/shared/rollup.js +881 -675
package/dist/shared/watch-cli.js +2 -2
package/dist/shared/watch.js +2 -2
package/package.json +1 -1

package/dist/shared/rollup.js CHANGED Viewed

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v2.72.0
-	Thu, 05 May 2022 04:32:50 GMT - commit 19aef1315cf45b04c74c37a290cbef8072ddfa6b
+	Rollup.js v2.74.0
+	Thu, 19 May 2022 05:01:43 GMT - commit fc99e96e09d26798f1c0aabdd7429307cc908c8e
 	https://github.com/rollup/rollup
@@ -27,7 +27,7 @@ function _interopNamespaceDefault(e) {
   return n;
 }
-var version$1 = "2.72.0";
+var version$1 = "2.74.0";
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -1865,7 +1865,7 @@ class MagicString {
 const hasOwnProp = Object.prototype.hasOwnProperty;
 class Bundle$1 {
-	constructor(options = {}) {
+	constructor(options) {
 		this.intro = options.intro || '';
 		this.separator = options.separator !== undefined ? options.separator : '\n';
 		this.sources = [];
@@ -2155,9 +2155,16 @@ function getOrCreate(map, key, init) {
 }
 const UnknownKey = Symbol('Unknown Key');
+const UnknownNonAccessorKey = Symbol('Unknown Non-Accessor Key');
 const UnknownInteger = Symbol('Unknown Integer');
 const EMPTY_PATH = [];
 const UNKNOWN_PATH = [UnknownKey];
+// For deoptimizations, this means we are modifying an unknown property but did
+// not lose track of the object or are creating a setter/getter;
+// For assignment effects it means we do not check for setter/getter effects
+// but only if something is mutated that is included, which is relevant for
+// Object.defineProperty
+const UNKNOWN_NON_ACCESSOR_PATH = [UnknownNonAccessorKey];
 const UNKNOWN_INTEGER_PATH = [UnknownInteger];
 const EntitiesKey = Symbol('Entities');
 class PathTracker {
@@ -2215,6 +2222,7 @@ class DiscriminatedPathTracker {
 }
 const UnknownValue = Symbol('Unknown Value');
+const UnknownTruthyValue = Symbol('Unknown Truthy Value');
 class ExpressionEntity {
     constructor() {
         this.included = false;
@@ -2243,14 +2251,17 @@ class ExpressionEntity {
     hasEffectsWhenCalledAtPath(_path, _callOptions, _context) {
         return true;
     }
-    include(_context, _includeChildrenRecursively) {
+    include(_context, _includeChildrenRecursively, _options) {
         this.included = true;
     }
-    includeCallArguments(context, args) {
+    includeArgumentsWhenCalledAtPath(_path, context, args) {
         for (const arg of args) {
             arg.include(context, false);
         }
     }
+    shouldBeIncluded(_context) {
+        return true;
+    }
 }
 const UNKNOWN_EXPRESSION = new (class UnknownExpression extends ExpressionEntity {
 })();
@@ -4711,7 +4722,7 @@ const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEn
 })();
 const returnsUnknown = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_EXPRESSION
     }
 };
@@ -4734,7 +4745,7 @@ const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEnti
 })();
 const returnsBoolean = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_LITERAL_BOOLEAN
     }
 };
@@ -4757,7 +4768,7 @@ const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity
 })();
 const returnsNumber = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_LITERAL_NUMBER
     }
 };
@@ -4780,7 +4791,24 @@ const UNKNOWN_LITERAL_STRING = new (class UnknownString extends ExpressionEntity
 })();
 const returnsString = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
+        returns: UNKNOWN_LITERAL_STRING
+    }
+};
+const stringReplace = {
+    value: {
+        hasEffectsWhenCalled(callOptions, context) {
+            const arg1 = callOptions.args[1];
+            return (callOptions.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)));
+        },
         returns: UNKNOWN_LITERAL_STRING
     }
 };
@@ -4828,18 +4856,8 @@ const literalStringMembers = assembleMemberDescriptions({
     padEnd: returnsString,
     padStart: returnsString,
     repeat: returnsString,
-    replace: {
-        value: {
-            callsArgs: [1],
-            returns: UNKNOWN_LITERAL_STRING
-        }
-    },
-    replaceAll: {
-        value: {
-            callsArgs: [1],
-            returns: UNKNOWN_LITERAL_STRING
-        }
-    },
+    replace: stringReplace,
+    replaceAll: stringReplace,
     search: returnsNumber,
     slice: returnsString,
     small: returnsString,
@@ -4874,21 +4892,11 @@ function getLiteralMembersForValue(value) {
     return Object.create(null);
 }
 function hasMemberEffectWhenCalled(members, memberName, callOptions, context) {
+    var _a, _b;
     if (typeof memberName !== 'string' || !members[memberName]) {
         return true;
     }
-    if (!members[memberName].callsArgs)
-        return false;
-    for (const argIndex of members[memberName].callsArgs) {
-        if (callOptions.args[argIndex] &&
-            callOptions.args[argIndex].hasEffectsWhenCalledAtPath(EMPTY_PATH, {
-                args: NO_ARGS,
-                thisParam: null,
-                withNew: false
-            }, context))
-            return true;
-    }
-    return false;
+    return ((_b = (_a = members[memberName]).hasEffectsWhenCalled) === null || _b === void 0 ? void 0 : _b.call(_a, callOptions, context)) || false;
 }
 function getMemberReturnExpressionWhenCalled(members, memberName) {
     if (typeof memberName !== 'string' || !members[memberName])
@@ -5349,8 +5357,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null)
-                        child.bind();
+                    child === null || child === void 0 ? void 0 : child.bind();
                 }
             }
             else {
@@ -5373,7 +5380,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null && child.hasEffects(context))
+                    if (child === null || child === void 0 ? void 0 : child.hasEffects(context))
                         return true;
                 }
             }
@@ -5382,7 +5389,7 @@ class NodeBase extends ExpressionEntity {
         }
         return false;
     }
-    include(context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively, _options) {
         if (this.deoptimized === false)
             this.applyDeoptimizations();
         this.included = true;
@@ -5392,8 +5399,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null)
-                        child.include(context, includeChildrenRecursively);
+                    child === null || child === void 0 ? void 0 : child.include(context, includeChildrenRecursively);
                 }
             }
             else {
@@ -5401,9 +5407,6 @@ class NodeBase extends ExpressionEntity {
             }
         }
     }
-    includeAsSingleStatement(context, includeChildrenRecursively) {
-        this.include(context, includeChildrenRecursively);
-    }
     /**
      * Override to perform special initialisation steps after the scope is initialised
      */
@@ -5450,8 +5453,7 @@ class NodeBase extends ExpressionEntity {
                 continue;
             if (Array.isArray(value)) {
                 for (const child of value) {
-                    if (child !== null)
-                        child.render(code, options);
+                    child === null || child === void 0 ? void 0 : child.render(code, options);
                 }
             }
             else {
@@ -5462,7 +5464,28 @@ class NodeBase extends ExpressionEntity {
     shouldBeIncluded(context) {
         return this.included || (!context.brokenFlow && this.hasEffects(createHasEffectsContext()));
     }
-    applyDeoptimizations() { }
+    /**
+     * Just deoptimize everything by default so that when e.g. we do not track
+     * something properly, it is deoptimized.
+     * @protected
+     */
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const key of this.keys) {
+            const value = this[key];
+            if (value === null)
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    child === null || child === void 0 ? void 0 : child.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+            else {
+                value.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.context.requestTreeshakingPass();
+    }
 }
 class SpreadElement extends NodeBase {
@@ -5544,7 +5567,7 @@ class Method extends ExpressionEntity {
         }
         return false;
     }
-    includeCallArguments(context, args) {
+    includeArgumentsWhenCalledAtPath(_path, context, args) {
         for (const arg of args) {
             arg.include(context, false);
         }
@@ -5595,6 +5618,7 @@ class ObjectEntity extends ExpressionEntity {
         this.deoptimizedPaths = Object.create(null);
         this.expressionsToBeDeoptimizedByKey = Object.create(null);
         this.gettersByKey = Object.create(null);
+        this.hasLostTrack = false;
         this.hasUnknownDeoptimizedInteger = false;
         this.hasUnknownDeoptimizedProperty = false;
         this.propertiesAndGettersByKey = Object.create(null);
@@ -5615,12 +5639,18 @@ class ObjectEntity extends ExpressionEntity {
             }
         }
     }
-    deoptimizeAllProperties() {
+    deoptimizeAllProperties(noAccessors) {
         var _a;
-        if (this.hasUnknownDeoptimizedProperty) {
+        const isDeoptimized = this.hasLostTrack || this.hasUnknownDeoptimizedProperty;
+        if (noAccessors) {
+            this.hasUnknownDeoptimizedProperty = true;
+        }
+        else {
+            this.hasLostTrack = true;
+        }
+        if (isDeoptimized) {
             return;
         }
-        this.hasUnknownDeoptimizedProperty = true;
         for (const properties of Object.values(this.propertiesAndGettersByKey).concat(Object.values(this.settersByKey))) {
             for (const property of properties) {
                 property.deoptimizePath(UNKNOWN_PATH);
@@ -5631,7 +5661,9 @@ class ObjectEntity extends ExpressionEntity {
         this.deoptimizeCachedEntities();
     }
     deoptimizeIntegerProperties() {
-        if (this.hasUnknownDeoptimizedProperty || this.hasUnknownDeoptimizedInteger) {
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
+            this.hasUnknownDeoptimizedInteger) {
             return;
         }
         this.hasUnknownDeoptimizedInteger = true;
@@ -5644,17 +5676,19 @@ class ObjectEntity extends ExpressionEntity {
         }
         this.deoptimizeCachedIntegerEntities();
     }
+    // Assumption: If only a specific path is deoptimized, no accessors are created
     deoptimizePath(path) {
         var _a;
-        if (this.hasUnknownDeoptimizedProperty || this.immutable)
+        if (this.hasLostTrack || this.immutable) {
             return;
+        }
         const key = path[0];
         if (path.length === 1) {
             if (typeof key !== 'string') {
                 if (key === UnknownInteger) {
                     return this.deoptimizeIntegerProperties();
                 }
-                return this.deoptimizeAllProperties();
+                return this.deoptimizeAllProperties(key === UnknownNonAccessorKey);
             }
             if (!this.deoptimizedPaths[key]) {
                 this.deoptimizedPaths[key] = true;
@@ -5674,16 +5708,16 @@ class ObjectEntity extends ExpressionEntity {
             : this.allProperties) {
             property.deoptimizePath(subPath);
         }
-        (_a = this.prototypeExpression) === null || _a === void 0 ? void 0 : _a.deoptimizePath(path.length === 1 ? [UnknownKey, UnknownKey] : path);
+        (_a = this.prototypeExpression) === null || _a === void 0 ? void 0 : _a.deoptimizePath(path.length === 1 ? [...path, UnknownKey] : path);
     }
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
         var _a;
         const [key, ...subPath] = path;
-        if (this.hasUnknownDeoptimizedProperty ||
+        if (this.hasLostTrack ||
             // single paths that are deoptimized will not become getters or setters
             ((event === EVENT_CALLED || path.length > 1) &&
-                typeof key === 'string' &&
-                this.deoptimizedPaths[key])) {
+                (this.hasUnknownDeoptimizedProperty ||
+                    (typeof key === 'string' && this.deoptimizedPaths[key])))) {
             thisParameter.deoptimizePath(UNKNOWN_PATH);
             return;
         }
@@ -5737,7 +5771,7 @@ class ObjectEntity extends ExpressionEntity {
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
         if (path.length === 0) {
-            return UnknownValue;
+            return UnknownTruthyValue;
         }
         const key = path[0];
         const expressionAtPath = this.getMemberExpressionAndTrackDeopt(key, origin);
@@ -5781,7 +5815,7 @@ class ObjectEntity extends ExpressionEntity {
             }
             return true;
         }
-        if (this.hasUnknownDeoptimizedProperty)
+        if (this.hasLostTrack)
             return true;
         if (typeof key === 'string') {
             if (this.propertiesAndGettersByKey[key]) {
@@ -5828,9 +5862,10 @@ class ObjectEntity extends ExpressionEntity {
             }
             return true;
         }
-        if (this.hasUnknownDeoptimizedProperty)
+        if (key === UnknownNonAccessorKey)
+            return false;
+        if (this.hasLostTrack)
             return true;
-        // We do not need to test for unknown properties as in that case, hasUnknownDeoptimizedProperty is true
         if (typeof key === 'string') {
             if (this.propertiesAndSettersByKey[key]) {
                 const setters = this.settersByKey[key];
@@ -5848,6 +5883,14 @@ class ObjectEntity extends ExpressionEntity {
                 }
             }
         }
+        else {
+            for (const setters of Object.values(this.settersByKey).concat([this.unmatchableSetters])) {
+                for (const setter of setters) {
+                    if (setter.hasEffectsWhenAssignedAtPath(subPath, context))
+                        return true;
+                }
+            }
+        }
         if (this.prototypeExpression) {
             return this.prototypeExpression.hasEffectsWhenAssignedAtPath(path, context);
         }
@@ -5864,6 +5907,16 @@ class ObjectEntity extends ExpressionEntity {
         }
         return true;
     }
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        const key = path[0];
+        const expressionAtPath = this.getMemberExpression(key);
+        if (expressionAtPath) {
+            return expressionAtPath.includeArgumentsWhenCalledAtPath(path.slice(1), context, args);
+        }
+        if (this.prototypeExpression) {
+            return this.prototypeExpression.includeArgumentsWhenCalledAtPath(path, context, args);
+        }
+    }
     buildPropertyMaps(properties) {
         const { allProperties, propertiesAndGettersByKey, propertiesAndSettersByKey, settersByKey, gettersByKey, unknownIntegerProps, unmatchablePropertiesAndGetters, unmatchableGetters, unmatchableSetters } = this;
         const unmatchablePropertiesAndSetters = [];
@@ -5931,7 +5984,8 @@ class ObjectEntity extends ExpressionEntity {
         }
     }
     getMemberExpression(key) {
-        if (this.hasUnknownDeoptimizedProperty ||
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
             typeof key !== 'string' ||
             (this.hasUnknownDeoptimizedInteger && INTEGER_REG_EXP.test(key)) ||
             this.deoptimizedPaths[key]) {
@@ -6132,6 +6186,7 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
 class ArrayExpression extends NodeBase {
     constructor() {
         super(...arguments);
+        this.deoptimized = false;
         this.objectEntity = null;
     }
     deoptimizePath(path) {
@@ -6155,6 +6210,23 @@ class ArrayExpression extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        this.getObjectEntity().includeArgumentsWhenCalledAtPath(path, context, args);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        let hasSpread = false;
+        for (let index = 0; index < this.elements.length; index++) {
+            const element = this.elements[index];
+            if (hasSpread || element instanceof SpreadElement) {
+                if (element) {
+                    hasSpread = true;
+                    element.deoptimizePath(UNKNOWN_PATH);
+                }
+            }
+        }
+        this.context.requestTreeshakingPass();
+    }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -6165,7 +6237,7 @@ class ArrayExpression extends NodeBase {
         let hasSpread = false;
         for (let index = 0; index < this.elements.length; index++) {
             const element = this.elements[index];
-            if (element instanceof SpreadElement || hasSpread) {
+            if (hasSpread || element instanceof SpreadElement) {
                 if (element) {
                     hasSpread = true;
                     properties.unshift({ key: UnknownInteger, kind: 'init', property: element });
@@ -6185,9 +6257,7 @@ class ArrayExpression extends NodeBase {
 class ArrayPattern extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         for (const element of this.elements) {
-            if (element !== null) {
-                element.addExportedVariables(variables, exportNamesByVariable);
-            }
+            element === null || element === void 0 ? void 0 : element.addExportedVariables(variables, exportNamesByVariable);
         }
     }
     declare(kind) {
@@ -6199,29 +6269,23 @@ class ArrayPattern extends NodeBase {
         }
         return variables;
     }
-    deoptimizePath(path) {
-        if (path.length === 0) {
-            for (const element of this.elements) {
-                if (element !== null) {
-                    element.deoptimizePath(path);
-                }
-            }
+    // Patterns can only be deoptimized at the empty path at the moment
+    deoptimizePath() {
+        for (const element of this.elements) {
+            element === null || element === void 0 ? void 0 : element.deoptimizePath(EMPTY_PATH);
         }
     }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        if (path.length > 0)
-            return true;
+    // Patterns are only checked at the emtpy path at the moment
+    hasEffectsWhenAssignedAtPath(_path, context) {
         for (const element of this.elements) {
-            if (element !== null && element.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
+            if (element === null || element === void 0 ? void 0 : element.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context))
                 return true;
         }
         return false;
     }
     markDeclarationReached() {
         for (const element of this.elements) {
-            if (element !== null) {
-                element.markDeclarationReached();
-            }
+            element === null || element === void 0 ? void 0 : element.markDeclarationReached();
         }
     }
 }
@@ -6341,7 +6405,7 @@ class LocalVariable extends Variable {
             }
         }
     }
-    includeCallArguments(context, args) {
+    includeArgumentsWhenCalledAtPath(path, context, args) {
         if (this.isReassigned || (this.init && context.includedCallArguments.has(this.init))) {
             for (const arg of args) {
                 arg.include(context, false);
@@ -6349,7 +6413,7 @@ class LocalVariable extends Variable {
         }
         else if (this.init) {
             context.includedCallArguments.add(this.init);
-            this.init.includeCallArguments(context, args);
+            this.init.includeArgumentsWhenCalledAtPath(path, context, args);
             context.includedCallArguments.delete(this.init);
         }
     }
@@ -6597,6 +6661,48 @@ class ReturnValueScope extends ParameterScope {
     }
 }
+class AssignmentPattern extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.deoptimized = false;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.left.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        return this.left.declare(kind, init);
+    }
+    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) {
+        this.included = true;
+        this.left.include(context, includeChildrenRecursively);
+        this.right.include(context, includeChildrenRecursively);
+    }
+    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);
+        }
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        this.left.deoptimizePath(EMPTY_PATH);
+        this.right.deoptimizePath(UNKNOWN_PATH);
+        this.context.requestTreeshakingPass();
+    }
+}
 function treeshakeNode(node, code, start, end) {
     code.remove(start, end);
     if (node.annotations) {
@@ -6849,109 +6955,363 @@ class BlockStatement extends NodeBase {
     }
 }
-//@ts-check
-/** @typedef { import('estree').Node} Node */
-/** @typedef {Node | {
- *   type: 'PropertyDefinition';
- *   computed: boolean;
- *   value: Node
- * }} NodeWithPropertyDefinition */
-/**
- *
- * @param {NodeWithPropertyDefinition} node
- * @param {NodeWithPropertyDefinition} parent
- * @returns boolean
- */
-function is_reference (node, parent) {
-	if (node.type === 'MemberExpression') {
-		return !node.computed && is_reference(node.object, node);
-	}
-	if (node.type === 'Identifier') {
-		if (!parent) return true;
-		switch (parent.type) {
-			// disregard `bar` in `foo.bar`
-			case 'MemberExpression': return parent.computed || node === parent.object;
-			// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
-			case 'MethodDefinition': return parent.computed;
-			// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
-			case 'PropertyDefinition': return parent.computed || node === parent.value;
-			// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
-			case 'Property': return parent.computed || node === parent.value;
-			// disregard the `bar` in `export { foo as bar }` or
-			// the foo in `import { foo as bar }`
-			case 'ExportSpecifier':
-			case 'ImportSpecifier': return node === parent.local;
-			// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
-			case 'LabeledStatement':
-			case 'BreakStatement':
-			case 'ContinueStatement': return false;
-			default: return true;
-		}
-	}
-	return false;
+class RestElement extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.deoptimized = false;
+        this.declarationInit = null;
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        this.argument.addExportedVariables(variables, exportNamesByVariable);
+    }
+    declare(kind, init) {
+        this.declarationInit = init;
+        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        path.length === 0 && this.argument.deoptimizePath(EMPTY_PATH);
+    }
+    hasEffectsWhenAssignedAtPath(path, context) {
+        return path.length > 0 || this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
+    }
+    markDeclarationReached() {
+        this.argument.markDeclarationReached();
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.declarationInit !== null) {
+            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
+            this.context.requestTreeshakingPass();
+        }
+    }
 }
-/* eslint sort-keys: "off" */
-const ValueProperties = Symbol('Value Properties');
-const PURE = { pure: true };
-const IMPURE = { pure: false };
-// We use shortened variables to reduce file size here
-/* OBJECT */
-const O = {
-    __proto__: null,
-    [ValueProperties]: IMPURE
-};
-/* PURE FUNCTION */
-const PF = {
-    __proto__: null,
-    [ValueProperties]: PURE
-};
-/* CONSTRUCTOR */
-const C = {
-    __proto__: null,
-    [ValueProperties]: IMPURE,
-    prototype: O
-};
-/* PURE CONSTRUCTOR */
-const PC = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    prototype: O
-};
-const ARRAY_TYPE = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    from: PF,
-    of: PF,
-    prototype: O
-};
-const INTL_MEMBER = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    supportedLocalesOf: PC
-};
-const knownGlobals = {
-    // Placeholders for global objects to avoid shape mutations
-    global: O,
-    globalThis: O,
-    self: O,
-    window: O,
-    // Common globals
-    __proto__: null,
-    [ValueProperties]: IMPURE,
-    Array: {
-        __proto__: null,
-        [ValueProperties]: IMPURE,
-        from: O,
+class FunctionBase extends NodeBase {
+    constructor() {
+        super(...arguments);
+        // By default, parameters are included via includeArgumentsWhenCalledAtPath
+        this.alwaysIncludeParameters = false;
+        this.objectEntity = null;
+        this.deoptimizedReturn = false;
+    }
+    deoptimizeCache() {
+        this.alwaysIncludeParameters = true;
+    }
+    deoptimizePath(path) {
+        this.getObjectEntity().deoptimizePath(path);
+        if (path.length === 1 && path[0] === UnknownKey) {
+            // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
+            // which means the return expression needs to be reassigned
+            this.alwaysIncludeParameters = true;
+            this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
+        }
+    }
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        if (path.length > 0) {
+            this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getObjectEntity().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin) {
+        if (path.length > 0) {
+            return this.getObjectEntity().getReturnExpressionWhenCalledAtPath(path, callOptions, recursionTracker, origin);
+        }
+        if (this.async) {
+            if (!this.deoptimizedReturn) {
+                this.deoptimizedReturn = true;
+                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
+                this.context.requestTreeshakingPass();
+            }
+            return UNKNOWN_EXPRESSION;
+        }
+        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);
+        }
+        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) ||
+                (propertyReadSideEffects &&
+                    (propertyReadSideEffects === 'always' ||
+                        returnExpression.hasEffectsWhenAccessedAtPath(['then'], context)))) {
+                return true;
+            }
+        }
+        for (const param of this.params) {
+            if (param.hasEffects(context))
+                return true;
+        }
+        return false;
+    }
+    include(context, includeChildrenRecursively) {
+        this.included = true;
+        const { brokenFlow } = context;
+        context.brokenFlow = BROKEN_FLOW_NONE;
+        this.body.include(context, includeChildrenRecursively);
+        context.brokenFlow = brokenFlow;
+        if (includeChildrenRecursively || this.alwaysIncludeParameters) {
+            for (const param of this.params) {
+                param.include(context, includeChildrenRecursively);
+            }
+        }
+    }
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        var _a;
+        if (path.length === 0) {
+            for (let position = 0; position < this.params.length; position++) {
+                const parameter = this.params[position];
+                if (parameter instanceof AssignmentPattern) {
+                    if (parameter.left.shouldBeIncluded(context)) {
+                        parameter.left.include(context, false);
+                    }
+                    const argumentValue = (_a = args[position]) === null || _a === void 0 ? void 0 : _a.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+                    // If argumentValue === UnknownTruthyValue, then we do not need to
+                    // include the default
+                    if ((argumentValue === undefined || argumentValue === UnknownValue) &&
+                        (this.parameterVariables[position].some(variable => variable.included) ||
+                            parameter.right.shouldBeIncluded(context))) {
+                        parameter.right.include(context, false);
+                    }
+                }
+                else if (parameter.shouldBeIncluded(context)) {
+                    parameter.include(context, false);
+                }
+            }
+            this.scope.includeCallArguments(context, args);
+        }
+        else {
+            this.getObjectEntity().includeArgumentsWhenCalledAtPath(path, context, args);
+        }
+    }
+    initialise() {
+        this.parameterVariables = this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION));
+        this.scope.addParameterVariables(this.parameterVariables, this.params[this.params.length - 1] instanceof RestElement);
+        if (this.body instanceof BlockStatement) {
+            this.body.addImplicitReturnExpressionToScope();
+        }
+        else {
+            this.scope.addReturnExpression(this.body);
+        }
+    }
+    parseNode(esTreeNode) {
+        if (esTreeNode.body.type === BlockStatement$1) {
+            this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
+        }
+        super.parseNode(esTreeNode);
+    }
+}
+FunctionBase.prototype.preventChildBlockScope = true;
+class ArrowFunctionExpression extends FunctionBase {
+    constructor() {
+        super(...arguments);
+        this.objectEntity = null;
+    }
+    createScope(parentScope) {
+        this.scope = new ReturnValueScope(parentScope, this.context);
+    }
+    hasEffects() {
+        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))
+            return true;
+        context.ignore = ignore;
+        context.brokenFlow = brokenFlow;
+        return false;
+    }
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([], OBJECT_PROTOTYPE));
+    }
+}
+function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
+    if (exportedVariables.length === 1 &&
+        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
+        const variable = exportedVariables[0];
+        return `exports('${exportNamesByVariable.get(variable)}',${_}${variable.getName(getPropertyAccess)}${modifier})`;
+    }
+    else {
+        const fields = [];
+        for (const variable of exportedVariables) {
+            for (const exportName of exportNamesByVariable.get(variable)) {
+                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
+            }
+        }
+        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
+    }
+}
+function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
+    code.prependRight(expressionStart, `exports('${exportNamesByVariable.get(exportedVariable)}',${_}`);
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getDirectReturnIifeLeft } = options.snippets;
+    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
+    code.appendLeft(expressionEnd, ')');
+}
+function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
+    const { _, getPropertyAccess } = options.snippets;
+    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
+    const { _ } = options.snippets;
+    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
+    if (needsParens) {
+        code.prependRight(expressionStart, '(');
+        code.appendLeft(expressionEnd, ')');
+    }
+}
+//@ts-check
+/** @typedef { import('estree').Node} Node */
+/** @typedef {Node | {
+ *   type: 'PropertyDefinition';
+ *   computed: boolean;
+ *   value: Node
+ * }} NodeWithPropertyDefinition */
+/**
+ *
+ * @param {NodeWithPropertyDefinition} node
+ * @param {NodeWithPropertyDefinition} parent
+ * @returns boolean
+ */
+function is_reference (node, parent) {
+	if (node.type === 'MemberExpression') {
+		return !node.computed && is_reference(node.object, node);
+	}
+	if (node.type === 'Identifier') {
+		if (!parent) return true;
+		switch (parent.type) {
+			// disregard `bar` in `foo.bar`
+			case 'MemberExpression': return parent.computed || node === parent.object;
+			// disregard the `foo` in `class {foo(){}}` but keep it in `class {[foo](){}}`
+			case 'MethodDefinition': return parent.computed;
+			// disregard the `foo` in `class {foo=bar}` but keep it in `class {[foo]=bar}` and `class {bar=foo}`
+			case 'PropertyDefinition': return parent.computed || node === parent.value;
+			// disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+			case 'Property': return parent.computed || node === parent.value;
+			// disregard the `bar` in `export { foo as bar }` or
+			// the foo in `import { foo as bar }`
+			case 'ExportSpecifier':
+			case 'ImportSpecifier': return node === parent.local;
+			// disregard the `foo` in `foo: while (...) { ... break foo; ... continue foo;}`
+			case 'LabeledStatement':
+			case 'BreakStatement':
+			case 'ContinueStatement': return false;
+			default: return true;
+		}
+	}
+	return false;
+}
+/* eslint sort-keys: "off" */
+const ValueProperties = Symbol('Value Properties');
+const PURE = {
+    hasEffectsWhenCalled() {
+        return false;
+    }
+};
+const IMPURE = {
+    hasEffectsWhenCalled() {
+        return true;
+    }
+};
+// We use shortened variables to reduce file size here
+/* OBJECT */
+const O = {
+    __proto__: null,
+    [ValueProperties]: IMPURE
+};
+/* PURE FUNCTION */
+const PF = {
+    __proto__: null,
+    [ValueProperties]: PURE
+};
+/* FUNCTION THAT MUTATES FIRST ARG WITHOUT TRIGGERING ACCESSORS */
+const MUTATES_ARG_WITHOUT_ACCESSOR = {
+    __proto__: null,
+    [ValueProperties]: {
+        hasEffectsWhenCalled(callOptions, context) {
+            return (!callOptions.args.length ||
+                callOptions.args[0].hasEffectsWhenAssignedAtPath(UNKNOWN_NON_ACCESSOR_PATH, context));
+        }
+    }
+};
+/* CONSTRUCTOR */
+const C = {
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    prototype: O
+};
+/* PURE CONSTRUCTOR */
+const PC = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    prototype: O
+};
+const ARRAY_TYPE = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    from: PF,
+    of: PF,
+    prototype: O
+};
+const INTL_MEMBER = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    supportedLocalesOf: PC
+};
+const knownGlobals = {
+    // Placeholders for global objects to avoid shape mutations
+    global: O,
+    globalThis: O,
+    self: O,
+    window: O,
+    // Common globals
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    Array: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        from: O,
         isArray: PF,
         of: PF,
         prototype: O
@@ -7053,6 +7413,11 @@ const knownGlobals = {
         __proto__: null,
         [ValueProperties]: PURE,
         create: PF,
+        // Technically those can throw in certain situations, but we ignore this as
+        // code that relies on this will hopefully wrap this in a try-catch, which
+        // deoptimizes everything anyway
+        defineProperty: MUTATES_ARG_WITHOUT_ACCESSOR,
+        defineProperties: MUTATES_ARG_WITHOUT_ACCESSOR,
         getOwnPropertyDescriptor: PF,
         getOwnPropertyNames: PF,
         getOwnPropertySymbols: PF,
@@ -7736,27 +8101,27 @@ function getGlobalAtPath(path) {
     }
     return currentGlobal[ValueProperties];
 }
-function isPureGlobal(path) {
-    const globalAtPath = getGlobalAtPath(path);
-    return globalAtPath !== null && globalAtPath.pure;
-}
-function isGlobalMember(path) {
-    if (path.length === 1) {
-        return path[0] === 'undefined' || getGlobalAtPath(path) !== null;
-    }
-    return getGlobalAtPath(path.slice(0, -1)) !== null;
-}
 class GlobalVariable extends Variable {
     constructor() {
         super(...arguments);
+        // Ensure we use live-bindings for globals as we do not know if they have
+        // been reassigned
         this.isReassigned = true;
     }
+    getLiteralValueAtPath(path, _recursionTracker, _origin) {
+        return getGlobalAtPath([this.name, ...path]) ? UnknownTruthyValue : UnknownValue;
+    }
     hasEffectsWhenAccessedAtPath(path) {
-        return !isGlobalMember([this.name, ...path]);
+        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));
     }
-    hasEffectsWhenCalledAtPath(path) {
-        return !isPureGlobal([this.name, ...path]);
+    hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        const globalAtPath = getGlobalAtPath([this.name, ...path]);
+        return !globalAtPath || globalAtPath.hasEffectsWhenCalled(callOptions, context);
     }
 }
@@ -7775,12 +8140,12 @@ class Identifier extends NodeBase {
         this.isTDZAccess = null;
     }
     addExportedVariables(variables, exportNamesByVariable) {
-        if (this.variable !== null && exportNamesByVariable.has(this.variable)) {
+        if (exportNamesByVariable.has(this.variable)) {
             variables.push(this.variable);
         }
     }
     bind() {
-        if (this.variable === null && is_reference(this, this.parent)) {
+        if (!this.variable && is_reference(this, this.parent)) {
             this.variable = this.scope.findVariable(this.name);
             this.variable.addReference(this);
         }
@@ -7842,18 +8207,14 @@ class Identifier extends NodeBase {
             this.variable.hasEffectsWhenAccessedAtPath(EMPTY_PATH));
     }
     hasEffectsWhenAccessedAtPath(path, context) {
-        return (this.variable !== null &&
-            this.getVariableRespectingTDZ().hasEffectsWhenAccessedAtPath(path, context));
+        var _a;
+        return (_a = this.getVariableRespectingTDZ()) === null || _a === void 0 ? void 0 : _a.hasEffectsWhenAccessedAtPath(path, context);
     }
     hasEffectsWhenAssignedAtPath(path, context) {
-        return (!this.variable ||
-            (path.length > 0
-                ? this.getVariableRespectingTDZ()
-                : this.variable).hasEffectsWhenAssignedAtPath(path, context));
+        return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsWhenAssignedAtPath(path, context);
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        return (!this.variable ||
-            this.getVariableRespectingTDZ().hasEffectsWhenCalledAtPath(path, callOptions, context));
+        return this.getVariableRespectingTDZ().hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
     include() {
         if (!this.deoptimized)
@@ -7865,8 +8226,8 @@ class Identifier extends NodeBase {
             }
         }
     }
-    includeCallArguments(context, args) {
-        this.getVariableRespectingTDZ().includeCallArguments(context, args);
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        this.variable.includeArgumentsWhenCalledAtPath(path, context, args);
     }
     isPossibleTDZ() {
         // return cached value to avoid issues with the next tree-shaking pass
@@ -7919,7 +8280,7 @@ class Identifier extends NodeBase {
     }
     applyDeoptimizations() {
         this.deoptimized = true;
-        if (this.variable !== null && this.variable instanceof LocalVariable) {
+        if (this.variable instanceof LocalVariable) {
             this.variable.consolidateInitializers();
             this.context.requestTreeshakingPass();
         }
@@ -7945,183 +8306,6 @@ function closestParentFunctionOrProgram(node) {
     return node;
 }
-class RestElement extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-        this.declarationInit = null;
-    }
-    addExportedVariables(variables, exportNamesByVariable) {
-        this.argument.addExportedVariables(variables, exportNamesByVariable);
-    }
-    declare(kind, init) {
-        this.declarationInit = init;
-        return this.argument.declare(kind, UNKNOWN_EXPRESSION);
-    }
-    deoptimizePath(path) {
-        path.length === 0 && this.argument.deoptimizePath(EMPTY_PATH);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return path.length > 0 || this.argument.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
-    }
-    markDeclarationReached() {
-        this.argument.markDeclarationReached();
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        if (this.declarationInit !== null) {
-            this.declarationInit.deoptimizePath([UnknownKey, UnknownKey]);
-            this.context.requestTreeshakingPass();
-        }
-    }
-}
-class ArrowFunctionExpression extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimizedReturn = false;
-    }
-    createScope(parentScope) {
-        this.scope = new ReturnValueScope(parentScope, this.context);
-    }
-    deoptimizePath(path) {
-        // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
-        // which means the return expression needs to be reassigned
-        if (path.length === 1 && path[0] === UnknownKey) {
-            this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-        }
-    }
-    // Arrow functions do not mutate their context
-    deoptimizeThisOnEventAtPath() { }
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length !== 0) {
-            return UNKNOWN_EXPRESSION;
-        }
-        if (this.async) {
-            if (!this.deoptimizedReturn) {
-                this.deoptimizedReturn = true;
-                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-                this.context.requestTreeshakingPass();
-            }
-            return UNKNOWN_EXPRESSION;
-        }
-        return this.scope.getReturnExpression();
-    }
-    hasEffects() {
-        return false;
-    }
-    hasEffectsWhenAccessedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenAssignedAtPath(path) {
-        return path.length > 1;
-    }
-    hasEffectsWhenCalledAtPath(path, _callOptions, context) {
-        if (path.length > 0)
-            return true;
-        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) ||
-                (propertyReadSideEffects &&
-                    (propertyReadSideEffects === 'always' ||
-                        returnExpression.hasEffectsWhenAccessedAtPath(['then'], context)))) {
-                return true;
-            }
-        }
-        for (const param of this.params) {
-            if (param.hasEffects(context))
-                return true;
-        }
-        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) {
-        this.included = true;
-        for (const param of this.params) {
-            if (!(param instanceof Identifier)) {
-                param.include(context, includeChildrenRecursively);
-            }
-        }
-        const { brokenFlow } = context;
-        context.brokenFlow = BROKEN_FLOW_NONE;
-        this.body.include(context, includeChildrenRecursively);
-        context.brokenFlow = brokenFlow;
-    }
-    includeCallArguments(context, args) {
-        this.scope.includeCallArguments(context, args);
-    }
-    initialise() {
-        this.scope.addParameterVariables(this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
-        if (this.body instanceof BlockStatement) {
-            this.body.addImplicitReturnExpressionToScope();
-        }
-        else {
-            this.scope.addReturnExpression(this.body);
-        }
-    }
-    parseNode(esTreeNode) {
-        if (esTreeNode.body.type === BlockStatement$1) {
-            this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
-        }
-        super.parseNode(esTreeNode);
-    }
-}
-ArrowFunctionExpression.prototype.preventChildBlockScope = true;
-function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = '') {
-    if (exportedVariables.length === 1 &&
-        exportNamesByVariable.get(exportedVariables[0]).length === 1) {
-        const variable = exportedVariables[0];
-        return `exports('${exportNamesByVariable.get(variable)}',${_}${variable.getName(getPropertyAccess)}${modifier})`;
-    }
-    else {
-        const fields = [];
-        for (const variable of exportedVariables) {
-            for (const exportName of exportNamesByVariable.get(variable)) {
-                fields.push([exportName, variable.getName(getPropertyAccess) + modifier]);
-            }
-        }
-        return `exports(${getObject(fields, { lineBreakIndent: null })})`;
-    }
-}
-function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
-    code.prependRight(expressionStart, `exports('${exportNamesByVariable.get(exportedVariable)}',${_}`);
-    code.appendLeft(expressionEnd, ')');
-}
-function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
-    const { _, getDirectReturnIifeLeft } = options.snippets;
-    code.prependRight(expressionStart, getDirectReturnIifeLeft(['v'], `${getSystemExportStatement(exportedVariables, options)},${_}v`, { needsArrowReturnParens: true, needsWrappedFunction: needsParens }));
-    code.appendLeft(expressionEnd, ')');
-}
-function renderSystemExportSequenceAfterExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options) {
-    const { _, getPropertyAccess } = options.snippets;
-    code.appendLeft(expressionEnd, `,${_}${getSystemExportStatement([exportedVariable], options)},${_}${exportedVariable.getName(getPropertyAccess)}`);
-    if (needsParens) {
-        code.prependRight(expressionStart, '(');
-        code.appendLeft(expressionEnd, ')');
-    }
-}
-function renderSystemExportSequenceBeforeExpression(exportedVariable, expressionStart, expressionEnd, needsParens, code, options, modifier) {
-    const { _ } = options.snippets;
-    code.prependRight(expressionStart, `${getSystemExportStatement([exportedVariable], options, modifier)},${_}`);
-    if (needsParens) {
-        code.prependRight(expressionStart, '(');
-        code.appendLeft(expressionEnd, ')');
-    }
-}
 class ObjectPattern extends NodeBase {
     addExportedVariables(variables, exportNamesByVariable) {
         for (const property of this.properties) {
@@ -8248,38 +8432,6 @@ class AssignmentExpression extends NodeBase {
     }
 }
-class AssignmentPattern extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.deoptimized = false;
-    }
-    addExportedVariables(variables, exportNamesByVariable) {
-        this.left.addExportedVariables(variables, exportNamesByVariable);
-    }
-    declare(kind, init) {
-        return this.left.declare(kind, init);
-    }
-    deoptimizePath(path) {
-        path.length === 0 && this.left.deoptimizePath(path);
-    }
-    hasEffectsWhenAssignedAtPath(path, context) {
-        return path.length > 0 || this.left.hasEffectsWhenAssignedAtPath(EMPTY_PATH, context);
-    }
-    markDeclarationReached() {
-        this.left.markDeclarationReached();
-    }
-    render(code, options, { isShorthandProperty } = BLANK) {
-        this.left.render(code, options, { isShorthandProperty });
-        this.right.render(code, options);
-    }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.left.deoptimizePath(EMPTY_PATH);
-        this.right.deoptimizePath(UNKNOWN_PATH);
-        this.context.requestTreeshakingPass();
-    }
-}
 class ArgumentsVariable extends LocalVariable {
     constructor(context) {
         super('arguments', null, UNKNOWN_EXPRESSION, context);
@@ -8372,85 +8524,27 @@ class FunctionScope extends ReturnValueScope {
     }
 }
-class FunctionNode extends NodeBase {
+class FunctionNode extends FunctionBase {
     constructor() {
         super(...arguments);
-        this.deoptimizedReturn = false;
-        this.isPrototypeDeoptimized = false;
+        this.objectEntity = null;
     }
     createScope(parentScope) {
         this.scope = new FunctionScope(parentScope, this.context);
     }
-    deoptimizePath(path) {
-        if (path.length === 1) {
-            if (path[0] === 'prototype') {
-                this.isPrototypeDeoptimized = true;
-            }
-            else if (path[0] === UnknownKey) {
-                this.isPrototypeDeoptimized = true;
-                // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
-                // which means the return expression needs to be reassigned as well
-                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-            }
-        }
-    }
-    // TODO for completeness, we should also track other events here
-    deoptimizeThisOnEventAtPath(event, path, thisParameter) {
-        if (event === EVENT_CALLED) {
-            if (path.length > 0) {
-                thisParameter.deoptimizePath(UNKNOWN_PATH);
-            }
-            else {
-                this.scope.thisVariable.addEntityToBeDeoptimized(thisParameter);
-            }
-        }
-    }
-    getReturnExpressionWhenCalledAtPath(path) {
-        if (path.length !== 0) {
-            return UNKNOWN_EXPRESSION;
-        }
-        if (this.async) {
-            if (!this.deoptimizedReturn) {
-                this.deoptimizedReturn = true;
-                this.scope.getReturnExpression().deoptimizePath(UNKNOWN_PATH);
-                this.context.requestTreeshakingPass();
-            }
-            return UNKNOWN_EXPRESSION;
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        super.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+        if (event === EVENT_CALLED && path.length === 0) {
+            this.scope.thisVariable.addEntityToBeDeoptimized(thisParameter);
         }
-        return this.scope.getReturnExpression();
     }
     hasEffects() {
-        return this.id !== null && this.id.hasEffects();
-    }
-    hasEffectsWhenAccessedAtPath(path) {
-        if (path.length <= 1)
-            return false;
-        return path.length > 2 || path[0] !== 'prototype' || this.isPrototypeDeoptimized;
-    }
-    hasEffectsWhenAssignedAtPath(path) {
-        if (path.length <= 1) {
-            return false;
-        }
-        return path.length > 2 || path[0] !== 'prototype' || this.isPrototypeDeoptimized;
+        var _a;
+        return (_a = this.id) === null || _a === void 0 ? void 0 : _a.hasEffects();
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
-        if (path.length > 0)
-            return true;
-        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) ||
-                (propertyReadSideEffects &&
-                    (propertyReadSideEffects === 'always' ||
-                        returnExpression.hasEffectsWhenAccessedAtPath(['then'], context)))) {
-                return true;
-            }
-        }
-        for (const param of this.params) {
-            if (param.hasEffects(context))
-                return true;
-        }
+        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)
@@ -8475,36 +8569,32 @@ class FunctionNode extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
-        this.included = true;
-        if (this.id)
-            this.id.include();
-        const hasArguments = this.scope.argumentsVariable.included;
-        for (const param of this.params) {
-            if (!(param instanceof Identifier) || hasArguments) {
-                param.include(context, includeChildrenRecursively);
-            }
+        var _a;
+        // This ensures that super.include will also include all parameters
+        if (this.scope.argumentsVariable.included) {
+            this.alwaysIncludeParameters = true;
         }
-        const { brokenFlow } = context;
-        context.brokenFlow = BROKEN_FLOW_NONE;
-        this.body.include(context, includeChildrenRecursively);
-        context.brokenFlow = brokenFlow;
-    }
-    includeCallArguments(context, args) {
-        this.scope.includeCallArguments(context, args);
+        (_a = this.id) === null || _a === void 0 ? void 0 : _a.include();
+        super.include(context, includeChildrenRecursively);
     }
     initialise() {
-        if (this.id !== null) {
-            this.id.declare('function', this);
-        }
-        this.scope.addParameterVariables(this.params.map(param => param.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
-        this.body.addImplicitReturnExpressionToScope();
+        var _a;
+        super.initialise();
+        (_a = this.id) === null || _a === void 0 ? void 0 : _a.declare('function', this);
     }
-    parseNode(esTreeNode) {
-        this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
-        super.parseNode(esTreeNode);
+    getObjectEntity() {
+        if (this.objectEntity !== null) {
+            return this.objectEntity;
+        }
+        return (this.objectEntity = new ObjectEntity([
+            {
+                key: 'prototype',
+                kind: 'init',
+                property: new ObjectEntity([], OBJECT_PROTOTYPE)
+            }
+        ], OBJECT_PROTOTYPE));
     }
 }
-FunctionNode.prototype.preventChildBlockScope = true;
 class AwaitExpression extends NodeBase {
     constructor() {
@@ -8532,11 +8622,6 @@ class AwaitExpression extends NodeBase {
         }
         this.argument.include(context, includeChildrenRecursively);
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.argument.deoptimizePath(UNKNOWN_PATH);
-        this.context.requestTreeshakingPass();
-    }
 }
 const binaryOperators = {
@@ -8570,10 +8655,10 @@ class BinaryExpression extends NodeBase {
         if (path.length > 0)
             return UnknownValue;
         const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (leftValue === UnknownValue)
+        if (typeof leftValue === 'symbol')
             return UnknownValue;
         const rightValue = this.right.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (rightValue === UnknownValue)
+        if (typeof rightValue === 'symbol')
             return UnknownValue;
         const operatorFn = binaryOperators[this.operator];
         if (!operatorFn)
@@ -8754,7 +8839,11 @@ class MemberExpression extends NodeBase {
         }
         else if (!this.replacement) {
             if (path.length < MAX_PATH_DEPTH) {
-                this.object.deoptimizePath([this.getPropertyKey(), ...path]);
+                const propertyKey = this.getPropertyKey();
+                this.object.deoptimizePath([
+                    propertyKey === UnknownKey ? UnknownNonAccessorKey : propertyKey,
+                    ...path
+                ]);
             }
         }
     }
@@ -8860,12 +8949,15 @@ class MemberExpression extends NodeBase {
         this.object.include(context, includeChildrenRecursively);
         this.property.include(context, includeChildrenRecursively);
     }
-    includeCallArguments(context, args) {
+    includeArgumentsWhenCalledAtPath(path, context, args) {
         if (this.variable) {
-            this.variable.includeCallArguments(context, args);
+            this.variable.includeArgumentsWhenCalledAtPath(path, context, args);
         }
-        else {
-            super.includeCallArguments(context, args);
+        else if (this.replacement) {
+            super.includeArgumentsWhenCalledAtPath(path, context, args);
+        }
+        else if (path.length < MAX_PATH_DEPTH) {
+            this.object.includeArgumentsWhenCalledAtPath([this.getPropertyKey(), ...path], context, args);
         }
     }
     initialise() {
@@ -8927,7 +9019,7 @@ class MemberExpression extends NodeBase {
         if (this.propertyKey === null) {
             this.propertyKey = UnknownKey;
             const value = this.property.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            return (this.propertyKey = value === UnknownValue ? UnknownKey : String(value));
+            return (this.propertyKey = typeof value === 'symbol' ? UnknownKey : String(value));
         }
         return this.propertyKey;
     }
@@ -8954,39 +9046,13 @@ class MemberExpression extends NodeBase {
     }
 }
-class CallExpression extends NodeBase {
+class CallExpressionBase extends NodeBase {
     constructor() {
         super(...arguments);
         this.deoptimized = false;
+        this.returnExpression = null;
         this.deoptimizableDependentExpressions = [];
         this.expressionsToBeDeoptimized = new Set();
-        this.returnExpression = null;
-    }
-    bind() {
-        super.bind();
-        if (this.callee instanceof Identifier) {
-            const variable = this.scope.findVariable(this.callee.name);
-            if (variable.isNamespace) {
-                this.context.warn({
-                    code: 'CANNOT_CALL_NAMESPACE',
-                    message: `Cannot call a namespace ('${this.callee.name}')`
-                }, this.start);
-            }
-            if (this.callee.name === 'eval') {
-                this.context.warn({
-                    code: 'EVAL',
-                    message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
-                    url: 'https://rollupjs.org/guide/en/#avoiding-eval'
-                }, this.start);
-            }
-        }
-        this.callOptions = {
-            args: this.arguments,
-            thisParam: this.callee instanceof MemberExpression && !this.callee.variable
-                ? this.callee.object
-                : null,
-            withNew: false
-        };
     }
     deoptimizeCache() {
         if (this.returnExpression !== UNKNOWN_EXPRESSION) {
@@ -9041,6 +9107,47 @@ class CallExpression extends NodeBase {
             return returnExpression.getReturnExpressionWhenCalledAtPath(path, callOptions, 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));
+    }
+}
+class CallExpression extends CallExpressionBase {
+    bind() {
+        super.bind();
+        if (this.callee instanceof Identifier) {
+            const variable = this.scope.findVariable(this.callee.name);
+            if (variable.isNamespace) {
+                this.context.warn({
+                    code: 'CANNOT_CALL_NAMESPACE',
+                    message: `Cannot call a namespace ('${this.callee.name}')`
+                }, this.start);
+            }
+            if (this.callee.name === 'eval') {
+                this.context.warn({
+                    code: 'EVAL',
+                    message: `Use of eval is strongly discouraged, as it poses security risks and may cause issues with minification`,
+                    url: 'https://rollupjs.org/guide/en/#avoiding-eval'
+                }, this.start);
+            }
+        }
+        this.callOptions = {
+            args: this.arguments,
+            thisParam: this.callee instanceof MemberExpression && !this.callee.variable
+                ? this.callee.object
+                : null,
+            withNew: false
+        };
+    }
     hasEffects(context) {
         try {
             for (const argument of this.arguments) {
@@ -9058,18 +9165,6 @@ class CallExpression extends NodeBase {
                 this.applyDeoptimizations();
         }
     }
-    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));
-    }
     include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -9085,7 +9180,7 @@ class CallExpression extends NodeBase {
             this.included = true;
             this.callee.include(context, false);
         }
-        this.callee.includeCallArguments(context, this.arguments);
+        this.callee.includeArgumentsWhenCalledAtPath(EMPTY_PATH, context, this.arguments);
         const returnExpression = this.getReturnExpression();
         if (!returnExpression.included) {
             returnExpression.include(context, false);
@@ -9256,6 +9351,9 @@ class MethodBase extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return this.getAccessedValue().hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        this.getAccessedValue().includeArgumentsWhenCalledAtPath(path, context, args);
+    }
     getAccessedValue() {
         if (this.accessedValue === null) {
             if (this.kind === 'get') {
@@ -9292,8 +9390,6 @@ class ObjectMember extends ExpressionEntity {
         return this.object.getReturnExpressionWhenCalledAtPath([this.key, ...path], callOptions, recursionTracker, origin);
     }
     hasEffectsWhenAccessedAtPath(path, context) {
-        if (path.length === 0)
-            return false;
         return this.object.hasEffectsWhenAccessedAtPath([this.key, ...path], context);
     }
     hasEffectsWhenAssignedAtPath(path, context) {
@@ -9307,6 +9403,7 @@ class ObjectMember extends ExpressionEntity {
 class ClassNode extends NodeBase {
     constructor() {
         super(...arguments);
+        this.deoptimized = false;
         this.objectEntity = null;
     }
     createScope(parentScope) {
@@ -9316,7 +9413,14 @@ class ClassNode extends NodeBase {
         this.getObjectEntity().deoptimizeAllProperties();
     }
     deoptimizePath(path) {
+        var _a, _b;
         this.getObjectEntity().deoptimizePath(path);
+        if (path.length === 1 && path[0] === UnknownKey) {
+            // A reassignment of UNKNOWN_PATH is considered equivalent to having lost track
+            // which means the constructor needs to be reassigned
+            (_a = this.classConstructor) === null || _a === void 0 ? void 0 : _a.deoptimizePath(UNKNOWN_PATH);
+            (_b = this.superClass) === null || _b === void 0 ? void 0 : _b.deoptimizePath(UNKNOWN_PATH);
+        }
     }
     deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
         this.getObjectEntity().deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
@@ -9329,6 +9433,8 @@ class ClassNode extends NodeBase {
     }
     hasEffects(context) {
         var _a, _b;
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         const initEffect = ((_a = this.superClass) === null || _a === void 0 ? void 0 : _a.hasEffects(context)) || this.body.hasEffects(context);
         (_b = this.id) === null || _b === void 0 ? void 0 : _b.markDeclarationReached();
         return initEffect || super.hasEffects(context);
@@ -9340,12 +9446,13 @@ class ClassNode extends NodeBase {
         return this.getObjectEntity().hasEffectsWhenAssignedAtPath(path, context);
     }
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
+        var _a;
         if (path.length === 0) {
             return (!callOptions.withNew ||
                 (this.classConstructor !== null
                     ? this.classConstructor.hasEffectsWhenCalledAtPath(EMPTY_PATH, callOptions, context)
-                    : this.superClass !== null &&
-                        this.superClass.hasEffectsWhenCalledAtPath(path, callOptions, context)));
+                    : (_a = this.superClass) === null || _a === void 0 ? void 0 : _a.hasEffectsWhenCalledAtPath(path, callOptions, context)) ||
+                false);
         }
         else {
             return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
@@ -9353,6 +9460,8 @@ class ClassNode extends NodeBase {
     }
     include(context, includeChildrenRecursively) {
         var _a;
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
         this.included = true;
         (_a = this.superClass) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         this.body.include(context, includeChildrenRecursively);
@@ -9361,6 +9470,20 @@ class ClassNode extends NodeBase {
             this.id.include();
         }
     }
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        var _a;
+        if (path.length === 0) {
+            if (this.classConstructor) {
+                this.classConstructor.includeArgumentsWhenCalledAtPath(path, context, args);
+            }
+            else {
+                (_a = this.superClass) === null || _a === void 0 ? void 0 : _a.includeArgumentsWhenCalledAtPath(path, context, args);
+            }
+        }
+        else {
+            this.getObjectEntity().includeArgumentsWhenCalledAtPath(path, context, args);
+        }
+    }
     initialise() {
         var _a;
         (_a = this.id) === null || _a === void 0 ? void 0 : _a.declare('class', this);
@@ -9372,6 +9495,18 @@ class ClassNode extends NodeBase {
         }
         this.classConstructor = null;
     }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        for (const definition of this.body.body) {
+            if (!(definition.static ||
+                (definition instanceof MethodDefinition && definition.kind === 'constructor'))) {
+                // Calls to methods are not tracked, ensure that parameter defaults are
+                // included and the return value is deoptimized
+                definition.deoptimizePath(UNKNOWN_PATH);
+            }
+        }
+        this.context.requestTreeshakingPass();
+    }
     getObjectEntity() {
         if (this.objectEntity !== null) {
             return this.objectEntity;
@@ -9388,7 +9523,7 @@ class ClassNode extends NodeBase {
             let key;
             if (definition.computed) {
                 const keyValue = definition.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-                if (keyValue === UnknownValue) {
+                if (typeof keyValue === 'symbol') {
                     properties.push({ key: UnknownKey, kind, property: definition });
                     continue;
                 }
@@ -9584,14 +9719,14 @@ class ConditionalExpression extends NodeBase {
             usedBranch.include(context, includeChildrenRecursively);
         }
     }
-    includeCallArguments(context, args) {
+    includeArgumentsWhenCalledAtPath(path, context, args) {
         const usedBranch = this.getUsedBranch();
         if (usedBranch === null) {
-            this.consequent.includeCallArguments(context, args);
-            this.alternate.includeCallArguments(context, args);
+            this.consequent.includeArgumentsWhenCalledAtPath(path, context, args);
+            this.alternate.includeArgumentsWhenCalledAtPath(path, context, args);
         }
         else {
-            usedBranch.includeCallArguments(context, args);
+            usedBranch.includeArgumentsWhenCalledAtPath(path, context, args);
         }
     }
     render(code, options, { isCalleeOfRenderedParent, preventASI, renderedParentType, renderedSurroundingElement } = BLANK) {
@@ -9628,7 +9763,7 @@ class ConditionalExpression extends NodeBase {
         }
         this.isBranchResolutionAnalysed = true;
         const testValue = this.test.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-        return testValue === UnknownValue
+        return typeof testValue === 'symbol'
             ? null
             : (this.usedBranch = testValue ? this.consequent : this.alternate);
     }
@@ -9677,7 +9812,7 @@ class DoWhileStatement extends NodeBase {
         this.included = true;
         this.test.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
 }
@@ -9805,12 +9940,13 @@ ExportDefaultDeclaration.prototype.needsBoundaries = true;
 class ExportNamedDeclaration extends NodeBase {
     bind() {
+        var _a;
         // Do not bind specifiers
-        if (this.declaration !== null)
-            this.declaration.bind();
+        (_a = this.declaration) === null || _a === void 0 ? void 0 : _a.bind();
     }
     hasEffects(context) {
-        return this.declaration !== null && this.declaration.hasEffects(context);
+        var _a;
+        return (_a = this.declaration) === null || _a === void 0 ? void 0 : _a.hasEffects(context);
     }
     initialise() {
         this.context.addExport(this);
@@ -9864,7 +10000,7 @@ class ForInStatement extends NodeBase {
         this.left.include(context, includeChildrenRecursively || true);
         this.right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
     render(code, options) {
@@ -9904,7 +10040,7 @@ class ForOfStatement extends NodeBase {
         this.left.include(context, includeChildrenRecursively || true);
         this.right.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
     render(code, options) {
@@ -9928,9 +10064,10 @@ class ForStatement extends NodeBase {
         this.scope = new BlockScope(parentScope);
     }
     hasEffects(context) {
-        if ((this.init && this.init.hasEffects(context)) ||
-            (this.test && this.test.hasEffects(context)) ||
-            (this.update && this.update.hasEffects(context)))
+        var _a, _b, _c;
+        if (((_a = this.init) === null || _a === void 0 ? void 0 : _a.hasEffects(context)) ||
+            ((_b = this.test) === null || _b === void 0 ? void 0 : _b.hasEffects(context)) ||
+            ((_c = this.update) === null || _c === void 0 ? void 0 : _c.hasEffects(context)))
             return true;
         const { brokenFlow, ignore: { breaks, continues } } = context;
         context.ignore.breaks = true;
@@ -9943,24 +10080,20 @@ class ForStatement extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
+        var _a, _b, _c;
         this.included = true;
-        if (this.init)
-            this.init.includeAsSingleStatement(context, includeChildrenRecursively);
-        if (this.test)
-            this.test.include(context, includeChildrenRecursively);
+        (_a = this.init) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively, { asSingleStatement: true });
+        (_b = this.test) === null || _b === void 0 ? void 0 : _b.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        if (this.update)
-            this.update.include(context, includeChildrenRecursively);
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        (_c = this.update) === null || _c === void 0 ? void 0 : _c.include(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
     render(code, options) {
-        if (this.init)
-            this.init.render(code, options, NO_SEMICOLON);
-        if (this.test)
-            this.test.render(code, options, NO_SEMICOLON);
-        if (this.update)
-            this.update.render(code, options, NO_SEMICOLON);
+        var _a, _b, _c;
+        (_a = this.init) === null || _a === void 0 ? void 0 : _a.render(code, options, NO_SEMICOLON);
+        (_b = this.test) === null || _b === void 0 ? void 0 : _b.render(code, options, NO_SEMICOLON);
+        (_c = this.update) === null || _c === void 0 ? void 0 : _c.render(code, options, NO_SEMICOLON);
         this.body.render(code, options);
     }
 }
@@ -9996,11 +10129,12 @@ class IfStatement extends NodeBase {
         this.testValue = UnknownValue;
     }
     hasEffects(context) {
+        var _a;
         if (this.test.hasEffects(context)) {
             return true;
         }
         const testValue = this.getTestValue();
-        if (testValue === UnknownValue) {
+        if (typeof testValue === 'symbol') {
             const { brokenFlow } = context;
             if (this.consequent.hasEffects(context))
                 return true;
@@ -10014,9 +10148,7 @@ class IfStatement extends NodeBase {
                 context.brokenFlow < consequentBrokenFlow ? context.brokenFlow : consequentBrokenFlow;
             return false;
         }
-        return testValue
-            ? this.consequent.hasEffects(context)
-            : this.alternate !== null && this.alternate.hasEffects(context);
+        return testValue ? this.consequent.hasEffects(context) : (_a = this.alternate) === null || _a === void 0 ? void 0 : _a.hasEffects(context);
     }
     include(context, includeChildrenRecursively) {
         this.included = true;
@@ -10025,7 +10157,7 @@ class IfStatement extends NodeBase {
         }
         else {
             const testValue = this.getTestValue();
-            if (testValue === UnknownValue) {
+            if (typeof testValue === 'symbol') {
                 this.includeUnknownTest(context);
             }
             else {
@@ -10055,7 +10187,7 @@ class IfStatement extends NodeBase {
         else {
             code.remove(this.start, this.consequent.start);
         }
-        if (this.consequent.included && (noTreeshake || testValue === UnknownValue || testValue)) {
+        if (this.consequent.included && (noTreeshake || typeof testValue === 'symbol' || testValue)) {
             this.consequent.render(code, options);
         }
         else {
@@ -10063,7 +10195,7 @@ class IfStatement extends NodeBase {
             hoistedDeclarations.push(...this.consequentScope.hoistedDeclarations);
         }
         if (this.alternate) {
-            if (this.alternate.included && (noTreeshake || testValue === UnknownValue || !testValue)) {
+            if (this.alternate.included && (noTreeshake || typeof testValue === 'symbol' || !testValue)) {
                 if (includesIfElse) {
                     if (code.original.charCodeAt(this.alternate.start - 1) === 101) {
                         code.prependLeft(this.alternate.start, ' ');
@@ -10093,34 +10225,35 @@ class IfStatement extends NodeBase {
         return this.testValue;
     }
     includeKnownTest(context, testValue) {
+        var _a;
         if (this.test.shouldBeIncluded(context)) {
             this.test.include(context, false);
         }
         if (testValue && this.consequent.shouldBeIncluded(context)) {
-            this.consequent.includeAsSingleStatement(context, false);
+            this.consequent.include(context, false, { asSingleStatement: true });
         }
-        if (this.alternate !== null && !testValue && this.alternate.shouldBeIncluded(context)) {
-            this.alternate.includeAsSingleStatement(context, false);
+        if (!testValue && ((_a = this.alternate) === null || _a === void 0 ? void 0 : _a.shouldBeIncluded(context))) {
+            this.alternate.include(context, false, { asSingleStatement: true });
         }
     }
     includeRecursively(includeChildrenRecursively, context) {
+        var _a;
         this.test.include(context, includeChildrenRecursively);
         this.consequent.include(context, includeChildrenRecursively);
-        if (this.alternate !== null) {
-            this.alternate.include(context, includeChildrenRecursively);
-        }
+        (_a = this.alternate) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
     }
     includeUnknownTest(context) {
+        var _a;
         this.test.include(context, false);
         const { brokenFlow } = context;
         let consequentBrokenFlow = BROKEN_FLOW_NONE;
         if (this.consequent.shouldBeIncluded(context)) {
-            this.consequent.includeAsSingleStatement(context, false);
+            this.consequent.include(context, false, { asSingleStatement: true });
             consequentBrokenFlow = context.brokenFlow;
             context.brokenFlow = brokenFlow;
         }
-        if (this.alternate !== null && this.alternate.shouldBeIncluded(context)) {
-            this.alternate.includeAsSingleStatement(context, false);
+        if ((_a = this.alternate) === null || _a === void 0 ? void 0 : _a.shouldBeIncluded(context)) {
+            this.alternate.include(context, false, { asSingleStatement: true });
             context.brokenFlow =
                 context.brokenFlow < consequentBrokenFlow ? context.brokenFlow : consequentBrokenFlow;
         }
@@ -10707,7 +10840,7 @@ class LogicalExpression extends NodeBase {
         if (!this.isBranchResolutionAnalysed) {
             this.isBranchResolutionAnalysed = true;
             const leftValue = this.left.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-            if (leftValue === UnknownValue) {
+            if (typeof leftValue === 'symbol') {
                 return null;
             }
             else {
@@ -10893,21 +11026,32 @@ class NewExpression extends NodeBase {
         this.deoptimized = false;
     }
     hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        for (const argument of this.arguments) {
-            if (argument.hasEffects(context))
-                return true;
+        try {
+            for (const argument of this.arguments) {
+                if (argument.hasEffects(context))
+                    return true;
+            }
+            if (this.context.options.treeshake.annotations &&
+                this.annotations)
+                return false;
+            return (this.callee.hasEffects(context) ||
+                this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+        }
+        finally {
+            if (!this.deoptimized)
+                this.applyDeoptimizations();
         }
-        if (this.context.options.treeshake.annotations &&
-            this.annotations)
-            return false;
-        return (this.callee.hasEffects(context) ||
-            this.callee.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
     }
     hasEffectsWhenAccessedAtPath(path) {
         return path.length > 0;
     }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.callee.include(context, includeChildrenRecursively);
+        this.callee.includeArgumentsWhenCalledAtPath(EMPTY_PATH, context, this.arguments);
+    }
     initialise() {
         this.callOptions = {
             args: this.arguments,
@@ -10954,6 +11098,9 @@ class ObjectExpression extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return this.getObjectEntity().hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        this.getObjectEntity().includeArgumentsWhenCalledAtPath(path, context, args);
+    }
     render(code, options, { renderedSurroundingElement } = BLANK) {
         super.render(code, options);
         if (renderedSurroundingElement === ExpressionStatement$1 ||
@@ -10976,7 +11123,7 @@ class ObjectExpression extends NodeBase {
             let key;
             if (property.computed) {
                 const keyValue = property.key.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
-                if (keyValue === UnknownValue) {
+                if (typeof keyValue === 'symbol') {
                     properties.push({ key: UnknownKey, kind: property.kind, property });
                     continue;
                 }
@@ -11097,8 +11244,8 @@ class PropertyDefinition extends NodeBase {
             : UNKNOWN_EXPRESSION;
     }
     hasEffects(context) {
-        return (this.key.hasEffects(context) ||
-            (this.static && this.value !== null && this.value.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);
@@ -11109,21 +11256,24 @@ class PropertyDefinition extends NodeBase {
     hasEffectsWhenCalledAtPath(path, callOptions, context) {
         return !this.value || this.value.hasEffectsWhenCalledAtPath(path, callOptions, context);
     }
+    includeArgumentsWhenCalledAtPath(path, context, args) {
+        var _a;
+        (_a = this.value) === null || _a === void 0 ? void 0 : _a.includeArgumentsWhenCalledAtPath(path, context, args);
+    }
 }
 class ReturnStatement extends NodeBase {
     hasEffects(context) {
-        if (!context.ignore.returnYield ||
-            (this.argument !== null && this.argument.hasEffects(context)))
+        var _a;
+        if (!context.ignore.returnYield || ((_a = this.argument) === null || _a === void 0 ? void 0 : _a.hasEffects(context)))
             return true;
         context.brokenFlow = BROKEN_FLOW_ERROR_RETURN_LABEL;
         return false;
     }
     include(context, includeChildrenRecursively) {
+        var _a;
         this.included = true;
-        if (this.argument) {
-            this.argument.include(context, includeChildrenRecursively);
-        }
+        (_a = this.argument) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         context.brokenFlow = BROKEN_FLOW_ERROR_RETURN_LABEL;
     }
     initialise() {
@@ -11243,6 +11393,9 @@ class Super extends NodeBase {
     deoptimizePath(path) {
         this.variable.deoptimizePath(path);
     }
+    deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker) {
+        this.variable.deoptimizeThisOnEventAtPath(event, path, thisParameter, recursionTracker);
+    }
     include() {
         if (!this.included) {
             this.included = true;
@@ -11253,7 +11406,8 @@ class Super extends NodeBase {
 class SwitchCase extends NodeBase {
     hasEffects(context) {
-        if (this.test && this.test.hasEffects(context))
+        var _a;
+        if ((_a = this.test) === null || _a === void 0 ? void 0 : _a.hasEffects(context))
             return true;
         for (const node of this.consequent) {
             if (context.brokenFlow)
@@ -11264,9 +11418,9 @@ class SwitchCase extends NodeBase {
         return false;
     }
     include(context, includeChildrenRecursively) {
+        var _a;
         this.included = true;
-        if (this.test)
-            this.test.include(context, includeChildrenRecursively);
+        (_a = this.test) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         for (const node of this.consequent) {
             if (includeChildrenRecursively || node.shouldBeIncluded(context))
                 node.include(context, includeChildrenRecursively);
@@ -11359,7 +11513,7 @@ class SwitchStatement extends NodeBase {
     }
 }
-class TaggedTemplateExpression extends NodeBase {
+class TaggedTemplateExpression extends CallExpressionBase {
     bind() {
         super.bind();
         if (this.tag.type === Identifier$1) {
@@ -11374,13 +11528,35 @@ class TaggedTemplateExpression extends NodeBase {
         }
     }
     hasEffects(context) {
-        return (super.hasEffects(context) ||
-            this.tag.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+        try {
+            for (const argument of this.quasi.expressions) {
+                if (argument.hasEffects(context))
+                    return true;
+            }
+            return (this.tag.hasEffects(context) ||
+                this.tag.hasEffectsWhenCalledAtPath(EMPTY_PATH, this.callOptions, context));
+        }
+        finally {
+            if (!this.deoptimized)
+                this.applyDeoptimizations();
+        }
+    }
+    include(context, includeChildrenRecursively) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        this.included = true;
+        this.tag.include(context, includeChildrenRecursively);
+        this.quasi.include(context, includeChildrenRecursively);
+        this.tag.includeArgumentsWhenCalledAtPath(EMPTY_PATH, context, this.callOptions.args);
+        const returnExpression = this.getReturnExpression();
+        if (!returnExpression.included) {
+            returnExpression.include(context, false);
+        }
     }
     initialise() {
         this.callOptions = {
-            args: NO_ARGS,
-            thisParam: null,
+            args: [UNKNOWN_EXPRESSION, ...this.quasi.expressions],
+            thisParam: this.tag instanceof MemberExpression && !this.tag.variable ? this.tag.object : null,
             withNew: false
         };
     }
@@ -11388,6 +11564,25 @@ class TaggedTemplateExpression extends NodeBase {
         this.tag.render(code, options, { isCalleeOfRenderedParent: true });
         this.quasi.render(code, options);
     }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        const { thisParam } = this.callOptions;
+        if (thisParam) {
+            this.tag.deoptimizeThisOnEventAtPath(EVENT_CALLED, EMPTY_PATH, thisParam, SHARED_RECURSION_TRACKER);
+        }
+        for (const argument of this.quasi.expressions) {
+            // This will make sure all properties of parameters behave as "unknown"
+            argument.deoptimizePath(UNKNOWN_PATH);
+        }
+        this.context.requestTreeshakingPass();
+    }
+    getReturnExpression(recursionTracker = SHARED_RECURSION_TRACKER) {
+        if (this.returnExpression === null) {
+            this.returnExpression = UNKNOWN_EXPRESSION;
+            return (this.returnExpression = this.tag.getReturnExpressionWhenCalledAtPath(EMPTY_PATH, this.callOptions, recursionTracker, this));
+        }
+        return this.returnExpression;
+    }
 }
 class TemplateElement extends NodeBase {
@@ -11599,13 +11794,15 @@ class TryStatement extends NodeBase {
         this.includedLabelsAfterBlock = null;
     }
     hasEffects(context) {
+        var _a;
         return ((this.context.options.treeshake.tryCatchDeoptimization
             ? this.block.body.length > 0
             : this.block.hasEffects(context)) ||
-            (this.finalizer !== null && this.finalizer.hasEffects(context)));
+            ((_a = this.finalizer) === null || _a === void 0 ? void 0 : _a.hasEffects(context)) ||
+            false);
     }
     include(context, includeChildrenRecursively) {
-        var _a;
+        var _a, _b;
         const tryCatchDeoptimization = (_a = this.context.options.treeshake) === null || _a === void 0 ? void 0 : _a.tryCatchDeoptimization;
         const { brokenFlow } = context;
         if (!this.directlyIncluded || !tryCatchDeoptimization) {
@@ -11626,9 +11823,7 @@ class TryStatement extends NodeBase {
             this.handler.include(context, includeChildrenRecursively);
             context.brokenFlow = brokenFlow;
         }
-        if (this.finalizer !== null) {
-            this.finalizer.include(context, includeChildrenRecursively);
-        }
+        (_b = this.finalizer) === null || _b === void 0 ? void 0 : _b.include(context, includeChildrenRecursively);
     }
 }
@@ -11650,7 +11845,7 @@ class UnaryExpression extends NodeBase {
         if (path.length > 0)
             return UnknownValue;
         const argumentValue = this.argument.getLiteralValueAtPath(EMPTY_PATH, recursionTracker, origin);
-        if (argumentValue === UnknownValue)
+        if (typeof argumentValue === 'symbol')
             return UnknownValue;
         return unaryOperators[this.operator](argumentValue);
     }
@@ -11764,18 +11959,12 @@ class VariableDeclaration extends NodeBase {
     hasEffectsWhenAssignedAtPath() {
         return false;
     }
-    include(context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively, { asSingleStatement } = BLANK) {
         this.included = true;
         for (const declarator of this.declarations) {
             if (includeChildrenRecursively || declarator.shouldBeIncluded(context))
                 declarator.include(context, includeChildrenRecursively);
-        }
-    }
-    includeAsSingleStatement(context, includeChildrenRecursively) {
-        this.included = true;
-        for (const declarator of this.declarations) {
-            if (includeChildrenRecursively || declarator.shouldBeIncluded(context)) {
-                declarator.include(context, includeChildrenRecursively);
+            if (asSingleStatement) {
                 declarator.id.include(context, includeChildrenRecursively);
             }
         }
@@ -11923,15 +12112,15 @@ class VariableDeclarator extends NodeBase {
         this.id.deoptimizePath(path);
     }
     hasEffects(context) {
-        const initEffect = this.init !== null && this.init.hasEffects(context);
+        var _a;
+        const initEffect = (_a = this.init) === null || _a === void 0 ? void 0 : _a.hasEffects(context);
         this.id.markDeclarationReached();
         return initEffect || this.id.hasEffects(context);
     }
     include(context, includeChildrenRecursively) {
+        var _a;
         this.included = true;
-        if (this.init) {
-            this.init.include(context, includeChildrenRecursively);
-        }
+        (_a = this.init) === null || _a === void 0 ? void 0 : _a.include(context, includeChildrenRecursively);
         this.id.markDeclarationReached();
         if (includeChildrenRecursively || this.id.shouldBeIncluded(context)) {
             this.id.include(context, includeChildrenRecursively);
@@ -11975,7 +12164,7 @@ class WhileStatement extends NodeBase {
         this.included = true;
         this.test.include(context, includeChildrenRecursively);
         const { brokenFlow } = context;
-        this.body.includeAsSingleStatement(context, includeChildrenRecursively);
+        this.body.include(context, includeChildrenRecursively, { asSingleStatement: true });
         context.brokenFlow = brokenFlow;
     }
 }
@@ -11986,9 +12175,10 @@ class YieldExpression extends NodeBase {
         this.deoptimized = false;
     }
     hasEffects(context) {
+        var _a;
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        return (!context.ignore.returnYield || (this.argument !== null && this.argument.hasEffects(context)));
+        return !context.ignore.returnYield || ((_a = this.argument) === null || _a === void 0 ? void 0 : _a.hasEffects(context));
     }
     render(code, options) {
         if (this.argument) {
@@ -11998,14 +12188,6 @@ class YieldExpression extends NodeBase {
             }
         }
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        const { argument } = this;
-        if (argument) {
-            argument.deoptimizePath(UNKNOWN_PATH);
-            this.context.requestTreeshakingPass();
-        }
-    }
 }
 const nodeConstructors = {
@@ -12434,8 +12616,8 @@ class Module {
         this.importMetas = [];
         this.importedFromNotTreeshaken = false;
         this.importers = [];
-        this.imports = new Set();
         this.includedDynamicImporters = [];
+        this.includedImports = new Set();
         this.isExecuted = false;
         this.isUserDefinedEntryPoint = false;
         this.needsExportShim = false;
@@ -12564,7 +12746,7 @@ class Module {
         this.relevantDependencies = new Set();
         const necessaryDependencies = new Set();
         const alwaysCheckedDependencies = new Set();
-        const dependencyVariables = new Set(this.imports);
+        const dependencyVariables = new Set(this.includedImports);
         if (this.info.isEntry ||
             this.includedDynamicImporters.length > 0 ||
             this.namespace.included ||
@@ -13142,13 +13324,13 @@ class Module {
             if (module instanceof ExternalModule) {
                 const [externalVariable] = module.getVariableForExportName('*');
                 externalVariable.include();
-                this.imports.add(externalVariable);
+                this.includedImports.add(externalVariable);
                 externalNamespaces.add(externalVariable);
             }
             else if (module.info.syntheticNamedExports) {
                 const syntheticNamespace = module.getSyntheticNamespace();
                 syntheticNamespace.include();
-                this.imports.add(syntheticNamespace);
+                this.includedImports.add(syntheticNamespace);
                 syntheticNamespaces.add(syntheticNamespace);
             }
         }
@@ -13185,7 +13367,7 @@ class Module {
         this.includeVariable(variable);
         const variableModule = variable.module;
         if (variableModule && variableModule !== this) {
-            this.imports.add(variable);
+            this.includedImports.add(variable);
         }
     }
     shimMissingExport(name) {
@@ -14517,6 +14699,7 @@ class Chunk {
         this.implicitEntryModules = [];
         this.implicitlyLoadedBefore = new Set();
         this.imports = new Set();
+        this.includedReexportsByModule = new Map();
         this.indentString = undefined;
         // This may only be updated in the constructor
         this.isEmpty = true;
@@ -14688,6 +14871,9 @@ class Chunk {
                 this.exports.add(module.namespace);
             }
         }
+        if (!this.outputOptions.preserveModules) {
+            this.addNecessaryImportsForFacades();
+        }
         return facades;
     }
     generateId(addons, options, existingNames, includeHash) {
@@ -15030,6 +15216,15 @@ class Chunk {
             }
         }
     }
+    addNecessaryImportsForFacades() {
+        for (const [module, variables] of this.includedReexportsByModule) {
+            if (this.includedNamespaces.has(module)) {
+                for (const variable of variables) {
+                    this.imports.add(variable);
+                }
+            }
+        }
+    }
     assignFacadeName({ fileName, name }, facadedModule) {
         if (fileName) {
             this.fileName = fileName;
@@ -15077,6 +15272,7 @@ class Chunk {
         return hash.digest('hex').substr(0, 8);
     }
     ensureReexportsAreAvailableForModule(module) {
+        const includedReexports = [];
         const map = module.getExportNamesByVariable();
         for (const exportedVariable of map.keys()) {
             const isSynthetic = exportedVariable instanceof SyntheticNamedExportVariable;
@@ -15090,6 +15286,7 @@ class Chunk {
                     const chunk = this.chunkByModule.get(exportingModule);
                     if (chunk && chunk !== this) {
                         chunk.exports.add(importedVariable);
+                        includedReexports.push(importedVariable);
                         if (isSynthetic) {
                             this.imports.add(importedVariable);
                         }
@@ -15097,6 +15294,9 @@ class Chunk {
                 }
             }
         }
+        if (includedReexports.length) {
+            this.includedReexportsByModule.set(module, includedReexports);
+        }
     }
     finaliseDynamicImports(options, snippets) {
         const stripKnownJsExtensions = options.format === 'amd';
@@ -15452,7 +15652,7 @@ class Chunk {
         deconflictChunk(this.orderedModules, this.getDependenciesToBeDeconflicted(format !== 'es' && format !== 'system', format === 'amd' || format === 'umd' || format === 'iife', interop), this.imports, usedNames, format, interop, this.outputOptions.preserveModules, this.outputOptions.externalLiveBindings, this.chunkByModule, syntheticExports, this.exportNamesByVariable, this.accessedGlobalsByScope, this.includedNamespaces);
     }
     setUpChunkImportsAndExportsForModule(module) {
-        const moduleImports = new Set(module.imports);
+        const moduleImports = new Set(module.includedImports);
         // when we are not preserving modules, we need to make all namespace variables available for
         // rendering the namespace object
         if (!this.outputOptions.preserveModules) {
@@ -23119,6 +23319,12 @@ function formatAction([pluginName, hookName, args]) {
     }
     return action;
 }
+// We do not directly listen on process to avoid max listeners warnings for
+// complicated build processes
+const beforeExitEvent = 'beforeExit';
+const beforeExitEmitter = new require$$0$2.EventEmitter();
+beforeExitEmitter.setMaxListeners(0);
+process$1.on(beforeExitEvent, () => beforeExitEmitter.emit(beforeExitEvent));
 async function catchUnfinishedHookActions(pluginDriver, callback) {
     let handleEmptyEventLoop;
     const emptyEventLoopPromise = new Promise((_, reject) => {
@@ -23127,10 +23333,10 @@ async function catchUnfinishedHookActions(pluginDriver, callback) {
             reject(new Error(`Unexpected early exit. This happens when Promises returned by plugins cannot resolve. Unfinished hook action(s) on exit:\n` +
                 [...unfulfilledActions].map(formatAction).join('\n')));
         };
-        process$1.once('beforeExit', handleEmptyEventLoop);
+        beforeExitEmitter.once(beforeExitEvent, handleEmptyEventLoop);
     });
     const result = await Promise.race([callback(), emptyEventLoopPromise]);
-    process$1.off('beforeExit', handleEmptyEventLoop);
+    beforeExitEmitter.off(beforeExitEvent, handleEmptyEventLoop);
     return result;
 }