rollup 2.72.0 → 2.74.0

package/dist/es/shared/rollup.js

@@ -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
 
@@ -14,7 +14,7 @@ import { createHash as createHash$1 } from 'crypto';
 import { promises } from 'fs';
 import { EventEmitter } from 'events';
 
-var version$1 = "2.72.0";
+var version$1 = "2.74.0";
 
 var charToInteger = {};
 var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -1209,7 +1209,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 = [];
@@ -1521,9 +1521,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 {
@@ -1581,6 +1588,7 @@ class DiscriminatedPathTracker {
 }
 
 const UnknownValue = Symbol('Unknown Value');
+const UnknownTruthyValue = Symbol('Unknown Truthy Value');
 class ExpressionEntity {
     constructor() {
         this.included = false;
@@ -1609,14 +1617,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 {
 })();
@@ -4580,7 +4591,7 @@ const UNDEFINED_EXPRESSION = new (class UndefinedExpression extends ExpressionEn
 })();
 const returnsUnknown = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_EXPRESSION
     }
 };
@@ -4603,7 +4614,7 @@ const UNKNOWN_LITERAL_BOOLEAN = new (class UnknownBoolean extends ExpressionEnti
 })();
 const returnsBoolean = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_LITERAL_BOOLEAN
     }
 };
@@ -4626,7 +4637,7 @@ const UNKNOWN_LITERAL_NUMBER = new (class UnknownNumber extends ExpressionEntity
 })();
 const returnsNumber = {
     value: {
-        callsArgs: null,
+        hasEffectsWhenCalled: null,
         returns: UNKNOWN_LITERAL_NUMBER
     }
 };
@@ -4649,7 +4660,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
     }
 };
@@ -4697,18 +4725,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,
@@ -4743,21 +4761,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])
@@ -5218,8 +5226,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 {
@@ -5242,7 +5249,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;
                 }
             }
@@ -5251,7 +5258,7 @@ class NodeBase extends ExpressionEntity {
         }
         return false;
     }
-    include(context, includeChildrenRecursively) {
+    include(context, includeChildrenRecursively, _options) {
         if (this.deoptimized === false)
             this.applyDeoptimizations();
         this.included = true;
@@ -5261,8 +5268,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 {
@@ -5270,9 +5276,6 @@ class NodeBase extends ExpressionEntity {
             }
         }
     }
-    includeAsSingleStatement(context, includeChildrenRecursively) {
-        this.include(context, includeChildrenRecursively);
-    }
     /**
      * Override to perform special initialisation steps after the scope is initialised
      */
@@ -5319,8 +5322,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 {
@@ -5331,7 +5333,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 {
@@ -5413,7 +5436,7 @@ class Method extends ExpressionEntity {
         }
         return false;
     }
-    includeCallArguments(context, args) {
+    includeArgumentsWhenCalledAtPath(_path, context, args) {
         for (const arg of args) {
             arg.include(context, false);
         }
@@ -5464,6 +5487,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);
@@ -5484,12 +5508,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);
@@ -5500,7 +5530,9 @@ class ObjectEntity extends ExpressionEntity {
         this.deoptimizeCachedEntities();
     }
     deoptimizeIntegerProperties() {
-        if (this.hasUnknownDeoptimizedProperty || this.hasUnknownDeoptimizedInteger) {
+        if (this.hasLostTrack ||
+            this.hasUnknownDeoptimizedProperty ||
+            this.hasUnknownDeoptimizedInteger) {
             return;
         }
         this.hasUnknownDeoptimizedInteger = true;
@@ -5513,17 +5545,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;
@@ -5543,16 +5577,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;
         }
@@ -5606,7 +5640,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);
@@ -5650,7 +5684,7 @@ class ObjectEntity extends ExpressionEntity {
             }
             return true;
         }
-        if (this.hasUnknownDeoptimizedProperty)
+        if (this.hasLostTrack)
             return true;
         if (typeof key === 'string') {
             if (this.propertiesAndGettersByKey[key]) {
@@ -5697,9 +5731,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];
@@ -5717,6 +5752,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);
         }
@@ -5733,6 +5776,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 = [];
@@ -5800,7 +5853,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]) {
@@ -6001,6 +6055,7 @@ const ARRAY_PROTOTYPE = new ObjectEntity({
 class ArrayExpression extends NodeBase {
     constructor() {
         super(...arguments);
+        this.deoptimized = false;
         this.objectEntity = null;
     }
     deoptimizePath(path) {
@@ -6024,6 +6079,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;
@@ -6034,7 +6106,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 });
@@ -6054,9 +6126,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) {
@@ -6068,29 +6138,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();
         }
     }
 }
@@ -6210,7 +6274,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);
@@ -6218,7 +6282,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);
         }
     }
@@ -6466,6 +6530,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) {
@@ -6718,109 +6824,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
@@ -6922,6 +7282,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,
@@ -7605,27 +7970,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);
     }
 }
 
@@ -7644,12 +8009,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);
         }
@@ -7711,18 +8076,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)
@@ -7734,8 +8095,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
@@ -7788,7 +8149,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();
         }
@@ -7814,183 +8175,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) {
@@ -8117,38 +8301,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);
@@ -8241,85 +8393,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)
@@ -8344,36 +8438,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() {
@@ -8401,11 +8491,6 @@ class AwaitExpression extends NodeBase {
         }
         this.argument.include(context, includeChildrenRecursively);
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        this.argument.deoptimizePath(UNKNOWN_PATH);
-        this.context.requestTreeshakingPass();
-    }
 }
 
 const binaryOperators = {
@@ -8439,10 +8524,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)
@@ -8623,7 +8708,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
+                ]);
             }
         }
     }
@@ -8729,12 +8818,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() {
@@ -8796,7 +8888,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;
     }
@@ -8823,39 +8915,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) {
@@ -8910,6 +8976,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) {
@@ -8927,18 +9034,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();
@@ -8954,7 +9049,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);
@@ -9125,6 +9220,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') {
@@ -9161,8 +9259,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) {
@@ -9176,6 +9272,7 @@ class ObjectMember extends ExpressionEntity {
 class ClassNode extends NodeBase {
     constructor() {
         super(...arguments);
+        this.deoptimized = false;
         this.objectEntity = null;
     }
     createScope(parentScope) {
@@ -9185,7 +9282,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);
@@ -9198,6 +9302,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);
@@ -9209,12 +9315,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);
@@ -9222,6 +9329,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);
@@ -9230,6 +9339,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);
@@ -9241,6 +9364,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;
@@ -9257,7 +9392,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;
                 }
@@ -9453,14 +9588,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) {
@@ -9497,7 +9632,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);
     }
@@ -9546,7 +9681,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;
     }
 }
@@ -9674,12 +9809,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);
@@ -9733,7 +9869,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) {
@@ -9773,7 +9909,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) {
@@ -9797,9 +9933,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;
@@ -9812,24 +9949,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);
     }
 }
@@ -9865,11 +9998,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;
@@ -9883,9 +10017,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;
@@ -9894,7 +10026,7 @@ class IfStatement extends NodeBase {
         }
         else {
             const testValue = this.getTestValue();
-            if (testValue === UnknownValue) {
+            if (typeof testValue === 'symbol') {
                 this.includeUnknownTest(context);
             }
             else {
@@ -9924,7 +10056,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 {
@@ -9932,7 +10064,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, ' ');
@@ -9962,34 +10094,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;
         }
@@ -10576,7 +10709,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 {
@@ -10762,21 +10895,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,
@@ -10823,6 +10967,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 ||
@@ -10845,7 +10992,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;
                 }
@@ -10966,8 +11113,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);
@@ -10978,21 +11125,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() {
@@ -11112,6 +11262,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;
@@ -11122,7 +11275,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)
@@ -11133,9 +11287,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);
@@ -11228,7 +11382,7 @@ class SwitchStatement extends NodeBase {
     }
 }
 
-class TaggedTemplateExpression extends NodeBase {
+class TaggedTemplateExpression extends CallExpressionBase {
     bind() {
         super.bind();
         if (this.tag.type === Identifier$1) {
@@ -11243,13 +11397,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
         };
     }
@@ -11257,6 +11433,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 {
@@ -11468,13 +11663,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) {
@@ -11495,9 +11692,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);
     }
 }
 
@@ -11519,7 +11714,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);
     }
@@ -11633,18 +11828,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);
             }
         }
@@ -11792,15 +11981,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);
@@ -11844,7 +12033,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;
     }
 }
@@ -11855,9 +12044,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) {
@@ -11867,14 +12057,6 @@ class YieldExpression extends NodeBase {
             }
         }
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        const { argument } = this;
-        if (argument) {
-            argument.deoptimizePath(UNKNOWN_PATH);
-            this.context.requestTreeshakingPass();
-        }
-    }
 }
 
 const nodeConstructors = {
@@ -12303,8 +12485,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;
@@ -12433,7 +12615,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 ||
@@ -13011,13 +13193,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);
             }
         }
@@ -13054,7 +13236,7 @@ class Module {
         this.includeVariable(variable);
         const variableModule = variable.module;
         if (variableModule && variableModule !== this) {
-            this.imports.add(variable);
+            this.includedImports.add(variable);
         }
     }
     shimMissingExport(name) {
@@ -14386,6 +14568,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;
@@ -14557,6 +14740,9 @@ class Chunk {
                 this.exports.add(module.namespace);
             }
         }
+        if (!this.outputOptions.preserveModules) {
+            this.addNecessaryImportsForFacades();
+        }
         return facades;
     }
     generateId(addons, options, existingNames, includeHash) {
@@ -14899,6 +15085,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;
@@ -14946,6 +15141,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;
@@ -14959,6 +15155,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);
                         }
@@ -14966,6 +15163,9 @@ class Chunk {
                 }
             }
         }
+        if (includedReexports.length) {
+            this.includedReexportsByModule.set(module, includedReexports);
+        }
     }
     finaliseDynamicImports(options, snippets) {
         const stripKnownJsExtensions = options.format === 'amd';
@@ -15321,7 +15521,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) {
@@ -22998,6 +23198,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 EventEmitter();
+beforeExitEmitter.setMaxListeners(0);
+process$1.on(beforeExitEvent, () => beforeExitEmitter.emit(beforeExitEvent));
 async function catchUnfinishedHookActions(pluginDriver, callback) {
     let handleEmptyEventLoop;
     const emptyEventLoopPromise = new Promise((_, reject) => {
@@ -23006,10 +23212,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;
 }