@rollup/wasm-node 4.16.3 → 4.17.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.16.3
-	Tue, 23 Apr 2024 05:12:04 GMT - commit b9a62fd4cf28538d7c3b268eb25e709b45d44cce
+	Rollup.js v4.17.0
+	Sat, 27 Apr 2024 11:29:22 GMT - commit 91352494fc722bcd5e8e922cd1497b34aec57a67
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.16.3";
+var version = "4.17.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -3416,7 +3416,6 @@ class Variable extends ExpressionEntity {
     addReference(_identifier) { }
     /**
      * Check if the identifier variable is only used as function call
-     * Forward the check to the export default variable if it is only used once
      * @returns true if the variable is only used as function call
      */
     getOnlyFunctionCallUsed() {
@@ -7133,936 +7132,338 @@ class ArrayPattern extends NodeBase {
     }
 }
 
-class LocalVariable extends Variable {
-    constructor(name, declarator, init, context, kind) {
-        super(name);
-        this.init = init;
-        this.calledFromTryStatement = false;
-        this.additionalInitializers = null;
-        this.expressionsToBeDeoptimized = [];
-        this.declarations = declarator ? [declarator] : [];
-        this.deoptimizationTracker = context.deoptimizationTracker;
-        this.module = context.module;
-        this.kind = kind;
-    }
-    addDeclaration(identifier, init) {
-        this.declarations.push(identifier);
-        this.markInitializersForDeoptimization().push(init);
-    }
-    consolidateInitializers() {
-        if (this.additionalInitializers) {
-            for (const initializer of this.additionalInitializers) {
-                initializer.deoptimizePath(UNKNOWN_PATH);
-            }
-            this.additionalInitializers = null;
-        }
-    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (this.isReassigned) {
-            deoptimizeInteraction(interaction);
-            return;
-        }
-        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker), undefined);
-    }
-    deoptimizePath(path) {
-        if (this.isReassigned ||
-            this.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
-            return;
-        }
-        if (path.length === 0) {
-            this.markReassigned();
-            const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
-            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
-            for (const expression of expressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
-            }
-            this.init.deoptimizePath(UNKNOWN_PATH);
-        }
-        else {
-            this.init.deoptimizePath(path);
-        }
-    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.isReassigned) {
-            return UnknownValue;
-        }
-        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
-            this.expressionsToBeDeoptimized.push(origin);
-            return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
-        }, UnknownValue);
-    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        if (this.isReassigned) {
-            return UNKNOWN_RETURN_EXPRESSION;
-        }
-        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
-            this.expressionsToBeDeoptimized.push(origin);
-            return this.init.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
-        }, UNKNOWN_RETURN_EXPRESSION);
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        switch (interaction.type) {
-            case INTERACTION_ACCESSED: {
-                if (this.isReassigned)
-                    return true;
-                return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
-                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
-            }
-            case INTERACTION_ASSIGNED: {
-                if (this.included)
-                    return true;
-                if (path.length === 0)
-                    return false;
-                if (this.isReassigned)
-                    return true;
-                return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
-                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
-            }
-            case INTERACTION_CALLED: {
-                if (this.isReassigned)
-                    return true;
-                return (!(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
-                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
-            }
-        }
-    }
-    include() {
-        if (!this.included) {
-            super.include();
-            for (const declaration of this.declarations) {
-                // If node is a default export, it can save a tree-shaking run to include the full declaration now
-                if (!declaration.included)
-                    declaration.include(createInclusionContext(), false);
-                let node = declaration.parent;
-                while (!node.included) {
-                    // We do not want to properly include parents in case they are part of a dead branch
-                    // in which case .include() might pull in more dead code
-                    node.included = true;
-                    if (node.type === parseAst_js.Program)
-                        break;
-                    node = node.parent;
-                }
-            }
+/** @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;
+}
+
+const PureFunctionKey = Symbol('PureFunction');
+const getPureFunctions = ({ treeshake }) => {
+    const pureFunctions = Object.create(null);
+    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
+        let currentFunctions = pureFunctions;
+        for (const pathSegment of functionName.split('.')) {
+            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
         }
+        currentFunctions[PureFunctionKey] = true;
     }
-    includeCallArguments(context, parameters) {
-        if (this.isReassigned || context.includedCallArguments.has(this.init)) {
-            for (const argument of parameters) {
-                argument.include(context, false);
-            }
-        }
-        else {
-            context.includedCallArguments.add(this.init);
-            this.init.includeCallArguments(context, parameters);
-            context.includedCallArguments.delete(this.init);
-        }
+    return pureFunctions;
+};
+
+/* eslint sort-keys: "off" */
+const ValueProperties = Symbol('Value Properties');
+const getTruthyLiteralValue = () => UnknownTruthyValue;
+const returnFalse = () => false;
+const returnTrue = () => true;
+const PURE = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled: returnFalse
+};
+const IMPURE = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled: returnTrue
+};
+const PURE_WITH_ARRAY = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }) {
+        return args.length > 1 && !(args[1] instanceof ArrayExpression);
     }
-    markCalledFromTryStatement() {
-        this.calledFromTryStatement = true;
+};
+const GETTER_ACCESS = {
+    deoptimizeArgumentsOnCall: doNothing,
+    getLiteralValue: getTruthyLiteralValue,
+    hasEffectsWhenCalled({ args }, context) {
+        const [_thisArgument, firstArgument] = args;
+        return (!(firstArgument instanceof ExpressionEntity) ||
+            firstArgument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
     }
-    markInitializersForDeoptimization() {
-        if (this.additionalInitializers === null) {
-            this.additionalInitializers = [this.init];
-            this.init = UNKNOWN_EXPRESSION;
-            this.markReassigned();
+};
+// We use shortened variables to reduce file size here
+/* OBJECT */
+const O = {
+    __proto__: null,
+    [ValueProperties]: IMPURE
+};
+/* PURE FUNCTION */
+const PF = {
+    __proto__: null,
+    [ValueProperties]: PURE
+};
+/* PURE FUNCTION IF FIRST ARG DOES NOT CONTAIN A GETTER */
+const PF_NO_GETTER = {
+    __proto__: null,
+    [ValueProperties]: GETTER_ACCESS
+};
+/* FUNCTION THAT MUTATES FIRST ARG WITHOUT TRIGGERING ACCESSORS */
+const MUTATES_ARG_WITHOUT_ACCESSOR = {
+    __proto__: null,
+    [ValueProperties]: {
+        deoptimizeArgumentsOnCall({ args: [, firstArgument] }) {
+            firstArgument?.deoptimizePath(UNKNOWN_PATH);
+        },
+        getLiteralValue: getTruthyLiteralValue,
+        hasEffectsWhenCalled({ args }, context) {
+            return (args.length <= 1 ||
+                args[1].hasEffectsOnInteractionAtPath(UNKNOWN_NON_ACCESSOR_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context));
         }
-        return this.additionalInitializers;
     }
-}
-
-const MAX_TRACKED_INTERACTIONS = 20;
-const NO_INTERACTIONS = parseAst_js.EMPTY_ARRAY;
-const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
-const EMPTY_PATH_TRACKER = new PathTracker();
-const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
-class ParameterVariable extends LocalVariable {
-    constructor(name, declarator, context) {
-        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
-        this.deoptimizationInteractions = [];
-        this.deoptimizations = new PathTracker();
-        this.deoptimizedFields = new Set();
-        this.entitiesToBeDeoptimized = new Set();
-        this.knownExpressionsToBeDeoptimized = [];
-        this.knownValue = UNKNOWN_EXPRESSION;
-    }
-    addEntityToBeDeoptimized(entity) {
-        if (entity === UNKNOWN_EXPRESSION) {
-            // As unknown expressions fully deoptimize all interactions, we can clear
-            // the interaction cache at this point provided we keep this optimization
-            // in mind when adding new interactions
-            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
-                this.entitiesToBeDeoptimized.add(UNKNOWN_EXPRESSION);
-                for (const { interaction } of this.deoptimizationInteractions) {
-                    deoptimizeInteraction(interaction);
-                }
-                this.deoptimizationInteractions = NO_INTERACTIONS;
-            }
-        }
-        else if (this.deoptimizedFields.has(UnknownKey)) {
-            // This means that we already deoptimized all interactions and no longer
-            // track them
-            entity.deoptimizePath(UNKNOWN_PATH);
-        }
-        else if (!this.entitiesToBeDeoptimized.has(entity)) {
-            this.entitiesToBeDeoptimized.add(entity);
-            for (const field of this.deoptimizedFields) {
-                entity.deoptimizePath([field]);
-            }
-            for (const { interaction, path } of this.deoptimizationInteractions) {
-                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
-            }
-        }
-    }
-    markReassigned() {
-        if (this.isReassigned) {
-            return;
-        }
-        super.markReassigned();
-        for (const expression of this.knownExpressionsToBeDeoptimized) {
-            expression.deoptimizeCache();
-        }
-        this.knownExpressionsToBeDeoptimized = [];
-    }
-    /**
-     * If we are sure about the value of this parameter, we can set it here.
-     * It can be a literal or the only possible value of the parameter.
-     * an undefined value means that the parameter is not known.
-     * @param value The known value of the parameter to be set.
-     */
-    setKnownValue(value) {
-        if (this.isReassigned) {
-            return;
-        }
-        if (this.knownValue !== value) {
-            for (const expression of this.knownExpressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
-            }
-            this.knownExpressionsToBeDeoptimized = [];
-        }
-        this.knownValue = value;
-    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        if (this.isReassigned) {
-            return UnknownValue;
-        }
-        this.knownExpressionsToBeDeoptimized.push(origin);
-        return recursionTracker.withTrackedEntityAtPath(path, this.knownValue, () => this.knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
-    }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        // assigned is a bit different, since the value has a new name (the parameter)
-        return interaction.type === INTERACTION_ASSIGNED
-            ? super.hasEffectsOnInteractionAtPath(path, interaction, context)
-            : this.knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
-    }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
-        // For performance reasons, we fully deoptimize all deeper interactions
-        if (path.length >= 2 ||
-            this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
-            this.deoptimizationInteractions.length >= MAX_TRACKED_INTERACTIONS ||
-            (path.length === 1 &&
-                (this.deoptimizedFields.has(UnknownKey) ||
-                    (interaction.type === INTERACTION_CALLED && this.deoptimizedFields.has(path[0]))))) {
-            deoptimizeInteraction(interaction);
-            return;
-        }
-        if (!this.deoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.args)) {
-            for (const entity of this.entitiesToBeDeoptimized) {
-                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
-            }
-            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
-                this.deoptimizationInteractions.push({
-                    interaction,
-                    path
-                });
-            }
-        }
-    }
-    deoptimizePath(path) {
-        if (path.length === 0) {
-            this.markReassigned();
-            return;
-        }
-        if (this.deoptimizedFields.has(UnknownKey)) {
-            return;
-        }
-        const key = path[0];
-        if (this.deoptimizedFields.has(key)) {
-            return;
-        }
-        this.deoptimizedFields.add(key);
-        for (const entity of this.entitiesToBeDeoptimized) {
-            // We do not need a recursion tracker here as we already track whether
-            // this field is deoptimized
-            entity.deoptimizePath([key]);
-        }
-        if (key === UnknownKey) {
-            // save some memory
-            this.deoptimizationInteractions = NO_INTERACTIONS;
-            this.deoptimizations = EMPTY_PATH_TRACKER;
-            this.deoptimizedFields = UNKNOWN_DEOPTIMIZED_FIELD;
-            this.entitiesToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
-        }
-    }
-    getReturnExpressionWhenCalledAtPath(path) {
-        // We deoptimize everything that is called as that will trivially deoptimize
-        // the corresponding return expressions as well and avoid badly performing
-        // and complicated alternatives
-        if (path.length === 0) {
-            this.deoptimizePath(UNKNOWN_PATH);
-        }
-        else if (!this.deoptimizedFields.has(path[0])) {
-            this.deoptimizePath([path[0]]);
-        }
-        return UNKNOWN_RETURN_EXPRESSION;
-    }
-}
-
-function getSafeName(baseName, usedNames, forbiddenNames) {
-    let safeName = baseName;
-    let count = 1;
-    while (usedNames.has(safeName) || RESERVED_NAMES.has(safeName) || forbiddenNames?.has(safeName)) {
-        safeName = `${baseName}$${toBase64(count++)}`;
-    }
-    usedNames.add(safeName);
-    return safeName;
-}
-
-class Scope {
-    constructor() {
-        this.children = [];
-        this.variables = new Map();
-    }
-    /*
-    Redeclaration rules:
-    - var can redeclare var
-    - in function scopes, function and var can redeclare function and var
-    - var is hoisted across scopes, function remains in the scope it is declared
-    - var and function can redeclare function parameters, but parameters cannot redeclare parameters
-    - function cannot redeclare catch scope parameters
-    - var can redeclare catch scope parameters in a way
-        - if the parameter is an identifier and not a pattern
-        - then the variable is still declared in the hoisted outer scope, but the initializer is assigned to the parameter
-    - const, let, class, and function except in the cases above cannot redeclare anything
-     */
-    addDeclaration(identifier, context, init, kind) {
-        const name = identifier.name;
-        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
-        if (existingVariable) {
-            const existingKind = existingVariable.kind;
-            if (kind === 'var' && existingKind === 'var') {
-                existingVariable.addDeclaration(identifier, init);
-                return existingVariable;
-            }
-            context.error(parseAst_js.logRedeclarationError(name), identifier.start);
-        }
-        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
-        this.variables.set(name, newVariable);
-        return newVariable;
-    }
-    addHoistedVariable(name, variable) {
-        (this.hoistedVariables ||= new Map()).set(name, variable);
-    }
-    contains(name) {
-        return this.variables.has(name);
-    }
-    findVariable(_name) {
-        /* istanbul ignore next */
-        throw new Error('Internal Error: findVariable needs to be implemented by a subclass');
-    }
-}
-
-class ChildScope extends Scope {
-    constructor(parent, context) {
-        super();
-        this.parent = parent;
-        this.context = context;
-        this.accessedOutsideVariables = new Map();
-        parent.children.push(this);
-    }
-    addAccessedDynamicImport(importExpression) {
-        (this.accessedDynamicImports || (this.accessedDynamicImports = new Set())).add(importExpression);
-        if (this.parent instanceof ChildScope) {
-            this.parent.addAccessedDynamicImport(importExpression);
-        }
-    }
-    addAccessedGlobals(globals, accessedGlobalsByScope) {
-        const accessedGlobals = accessedGlobalsByScope.get(this) || new Set();
-        for (const name of globals) {
-            accessedGlobals.add(name);
-        }
-        accessedGlobalsByScope.set(this, accessedGlobals);
-        if (this.parent instanceof ChildScope) {
-            this.parent.addAccessedGlobals(globals, accessedGlobalsByScope);
-        }
-    }
-    addNamespaceMemberAccess(name, variable) {
-        this.accessedOutsideVariables.set(name, variable);
-        this.parent.addNamespaceMemberAccess(name, variable);
-    }
-    addReturnExpression(expression) {
-        this.parent instanceof ChildScope && this.parent.addReturnExpression(expression);
-    }
-    addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope) {
-        for (const variable of this.accessedOutsideVariables.values()) {
-            if (variable.included) {
-                usedNames.add(variable.getBaseVariableName());
-                if (format === 'system' && exportNamesByVariable.has(variable)) {
-                    usedNames.add('exports');
-                }
-            }
-        }
-        const accessedGlobals = accessedGlobalsByScope.get(this);
-        if (accessedGlobals) {
-            for (const name of accessedGlobals) {
-                usedNames.add(name);
-            }
-        }
-    }
-    contains(name) {
-        return this.variables.has(name) || this.parent.contains(name);
-    }
-    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
-        const usedNames = new Set();
-        this.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
-        if (this.accessedDynamicImports) {
-            for (const importExpression of this.accessedDynamicImports) {
-                if (importExpression.inlineNamespace) {
-                    usedNames.add(importExpression.inlineNamespace.getBaseVariableName());
-                }
-            }
-        }
-        for (const [name, variable] of this.variables) {
-            if (variable.included || variable.alwaysRendered) {
-                variable.setRenderNames(null, getSafeName(name, usedNames, variable.forbiddenNames));
-            }
-        }
-        for (const scope of this.children) {
-            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
-        }
-    }
-    findLexicalBoundary() {
-        return this.parent.findLexicalBoundary();
-    }
-    findVariable(name) {
-        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
-        if (knownVariable) {
-            return knownVariable;
-        }
-        const variable = this.parent.findVariable(name);
-        this.accessedOutsideVariables.set(name, variable);
-        return variable;
-    }
-}
-
-class CatchBodyScope extends ChildScope {
-    constructor(parent) {
-        super(parent, parent.context);
-        this.parent = parent;
-    }
-    addDeclaration(identifier, context, init, kind) {
-        if (kind === 'var') {
-            const name = identifier.name;
-            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
-            if (existingVariable) {
-                const existingKind = existingVariable.kind;
-                if (existingKind === 'parameter' &&
-                    // If this is a destructured parameter, it is forbidden to redeclare
-                    existingVariable.declarations[0].parent.type === parseAst_js.CatchClause) {
-                    // If this is a var with the same name as the catch scope parameter,
-                    // the assignment actually goes to the parameter and the var is
-                    // hoisted without assignment. Locally, it is shadowed by the
-                    // parameter
-                    const declaredVariable = this.parent.parent.addDeclaration(identifier, context, UNDEFINED_EXPRESSION, kind);
-                    // To avoid the need to rewrite the declaration, we link the variable
-                    // names. If we ever implement a logic that splits initialization and
-                    // assignment for hoisted vars, the "renderLikeHoisted" logic can be
-                    // removed again.
-                    // We do not need to check whether there already is a linked
-                    // variable because then declaredVariable would be that linked
-                    // variable.
-                    existingVariable.renderLikeHoisted(declaredVariable);
-                    this.addHoistedVariable(name, declaredVariable);
-                    return declaredVariable;
-                }
-                if (existingKind === 'var') {
-                    existingVariable.addDeclaration(identifier, init);
-                    return existingVariable;
-                }
-                return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
-            }
-            // We only add parameters to parameter scopes
-            const declaredVariable = this.parent.parent.addDeclaration(identifier, context, init, kind);
-            // Necessary to make sure the init is deoptimized for conditional declarations.
-            // We cannot call deoptimizePath here.
-            declaredVariable.markInitializersForDeoptimization();
-            // We add the variable to this and all parent scopes to reliably detect conflicts
-            this.addHoistedVariable(name, declaredVariable);
-            return declaredVariable;
-        }
-        return super.addDeclaration(identifier, context, init, kind);
-    }
-}
-
-class FunctionBodyScope extends ChildScope {
-    constructor(parent) {
-        super(parent, parent.context);
-    }
-    // There is stuff that is only allowed in function scopes, i.e. functions can
-    // be redeclared, functions and var can redeclare each other
-    addDeclaration(identifier, context, init, kind) {
-        const name = identifier.name;
-        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
-        if (existingVariable) {
-            const existingKind = existingVariable.kind;
-            if ((kind === 'var' || kind === 'function') &&
-                (existingKind === 'var' || existingKind === 'function' || existingKind === 'parameter')) {
-                existingVariable.addDeclaration(identifier, init);
-                return existingVariable;
-            }
-            context.error(parseAst_js.logRedeclarationError(name), identifier.start);
-        }
-        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
-        this.variables.set(name, newVariable);
-        return newVariable;
-    }
-}
-
-class ParameterScope extends ChildScope {
-    constructor(parent, isCatchScope) {
-        super(parent, parent.context);
-        this.parameters = [];
-        this.hasRest = false;
-        this.bodyScope = isCatchScope ? new CatchBodyScope(this) : new FunctionBodyScope(this);
-    }
-    /**
-     * Adds a parameter to this scope. Parameters must be added in the correct
-     * order, i.e. from left to right.
-     */
-    addParameterDeclaration(identifier) {
-        const { name, start } = identifier;
-        const existingParameter = this.variables.get(name);
-        if (existingParameter) {
-            return this.context.error(parseAst_js.logDuplicateArgumentNameError(name), start);
-        }
-        const variable = new ParameterVariable(name, identifier, this.context);
-        this.variables.set(name, variable);
-        // We also add it to the body scope to detect name conflicts with local
-        // variables. We still need the intermediate scope, though, as parameter
-        // defaults are NOT taken from the body scope but from the parameters or
-        // outside scope.
-        this.bodyScope.addHoistedVariable(name, variable);
-        return variable;
-    }
-    addParameterVariables(parameters, hasRest) {
-        this.parameters = parameters;
-        for (const parameterList of parameters) {
-            for (const parameter of parameterList) {
-                parameter.alwaysRendered = true;
-            }
-        }
-        this.hasRest = hasRest;
-    }
-    includeCallArguments(context, parameters) {
-        let calledFromTryStatement = false;
-        let argumentIncluded = false;
-        const restParameter = this.hasRest && this.parameters[this.parameters.length - 1];
-        for (const checkedArgument of parameters) {
-            if (checkedArgument instanceof SpreadElement) {
-                for (const argument of parameters) {
-                    argument.include(context, false);
-                }
-                break;
-            }
-        }
-        for (let index = parameters.length - 1; index >= 0; index--) {
-            const parameterVariables = this.parameters[index] || restParameter;
-            const argument = parameters[index];
-            if (parameterVariables) {
-                calledFromTryStatement = false;
-                if (parameterVariables.length === 0) {
-                    // handle empty destructuring
-                    argumentIncluded = true;
-                }
-                else {
-                    for (const variable of parameterVariables) {
-                        if (variable.included) {
-                            argumentIncluded = true;
-                        }
-                        if (variable.calledFromTryStatement) {
-                            calledFromTryStatement = true;
-                        }
-                    }
-                }
-            }
-            if (!argumentIncluded && argument.shouldBeIncluded(context)) {
-                argumentIncluded = true;
-            }
-            if (argumentIncluded) {
-                argument.include(context, calledFromTryStatement);
-            }
-        }
-    }
-}
-
-class ReturnValueScope extends ParameterScope {
-    constructor() {
-        super(...arguments);
-        this.returnExpression = null;
-        this.returnExpressions = [];
-    }
-    addReturnExpression(expression) {
-        this.returnExpressions.push(expression);
-    }
-    getReturnExpression() {
-        if (this.returnExpression === null)
-            this.updateReturnExpression();
-        return this.returnExpression;
-    }
-    updateReturnExpression() {
-        if (this.returnExpressions.length === 1) {
-            this.returnExpression = this.returnExpressions[0];
-        }
-        else {
-            this.returnExpression = UNKNOWN_EXPRESSION;
-            for (const expression of this.returnExpressions) {
-                expression.deoptimizePath(UNKNOWN_PATH);
-            }
-        }
-    }
-}
-
-/** @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;
-}
-
-const PureFunctionKey = Symbol('PureFunction');
-const getPureFunctions = ({ treeshake }) => {
-    const pureFunctions = Object.create(null);
-    for (const functionName of treeshake ? treeshake.manualPureFunctions : []) {
-        let currentFunctions = pureFunctions;
-        for (const pathSegment of functionName.split('.')) {
-            currentFunctions = currentFunctions[pathSegment] ||= Object.create(null);
-        }
-        currentFunctions[PureFunctionKey] = true;
-    }
-    return pureFunctions;
-};
-
-/* eslint sort-keys: "off" */
-const ValueProperties = Symbol('Value Properties');
-const getTruthyLiteralValue = () => UnknownTruthyValue;
-const returnFalse = () => false;
-const returnTrue = () => true;
-const PURE = {
-    deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
-    hasEffectsWhenCalled: returnFalse
-};
-const IMPURE = {
-    deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
-    hasEffectsWhenCalled: returnTrue
-};
-const PURE_WITH_ARRAY = {
-    deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
-    hasEffectsWhenCalled({ args }) {
-        return args.length > 1 && !(args[1] instanceof ArrayExpression);
-    }
-};
-const GETTER_ACCESS = {
-    deoptimizeArgumentsOnCall: doNothing,
-    getLiteralValue: getTruthyLiteralValue,
-    hasEffectsWhenCalled({ args }, context) {
-        const [_thisArgument, firstArgument] = args;
-        return (!(firstArgument instanceof ExpressionEntity) ||
-            firstArgument.hasEffectsOnInteractionAtPath(UNKNOWN_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
-    }
-};
-// We use shortened variables to reduce file size here
-/* OBJECT */
-const O = {
-    __proto__: null,
-    [ValueProperties]: IMPURE
-};
-/* PURE FUNCTION */
-const PF = {
-    __proto__: null,
-    [ValueProperties]: PURE
-};
-/* PURE FUNCTION IF FIRST ARG DOES NOT CONTAIN A GETTER */
-const PF_NO_GETTER = {
-    __proto__: null,
-    [ValueProperties]: GETTER_ACCESS
-};
-/* FUNCTION THAT MUTATES FIRST ARG WITHOUT TRIGGERING ACCESSORS */
-const MUTATES_ARG_WITHOUT_ACCESSOR = {
-    __proto__: null,
-    [ValueProperties]: {
-        deoptimizeArgumentsOnCall({ args: [, firstArgument] }) {
-            firstArgument?.deoptimizePath(UNKNOWN_PATH);
-        },
-        getLiteralValue: getTruthyLiteralValue,
-        hasEffectsWhenCalled({ args }, context) {
-            return (args.length <= 1 ||
-                args[1].hasEffectsOnInteractionAtPath(UNKNOWN_NON_ACCESSOR_PATH, NODE_INTERACTION_UNKNOWN_ASSIGNMENT, context));
-        }
-    }
-};
-/* CONSTRUCTOR */
-const C = {
-    __proto__: null,
-    [ValueProperties]: IMPURE,
-    prototype: O
-};
-/* PURE CONSTRUCTOR */
-const PC = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    prototype: O
-};
-const PC_WITH_ARRAY = {
-    __proto__: null,
-    [ValueProperties]: PURE_WITH_ARRAY,
-    prototype: O
-};
-const ARRAY_TYPE = {
-    __proto__: null,
-    [ValueProperties]: PURE,
-    from: O,
-    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
-    },
-    ArrayBuffer: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        isView: PF,
-        prototype: O
-    },
-    Atomics: O,
-    BigInt: C,
-    BigInt64Array: C,
-    BigUint64Array: C,
-    Boolean: PC,
-    constructor: C,
-    DataView: PC,
-    Date: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        now: PF,
-        parse: PF,
-        prototype: O,
-        UTC: PF
-    },
-    decodeURI: PF,
-    decodeURIComponent: PF,
-    encodeURI: PF,
-    encodeURIComponent: PF,
-    Error: PC,
-    escape: PF,
-    eval: O,
-    EvalError: PC,
-    Float32Array: ARRAY_TYPE,
-    Float64Array: ARRAY_TYPE,
-    Function: C,
-    hasOwnProperty: O,
-    Infinity: O,
-    Int16Array: ARRAY_TYPE,
-    Int32Array: ARRAY_TYPE,
-    Int8Array: ARRAY_TYPE,
-    isFinite: PF,
-    isNaN: PF,
-    isPrototypeOf: O,
-    JSON: O,
-    Map: PC_WITH_ARRAY,
-    Math: {
-        __proto__: null,
-        [ValueProperties]: IMPURE,
-        abs: PF,
-        acos: PF,
-        acosh: PF,
-        asin: PF,
-        asinh: PF,
-        atan: PF,
-        atan2: PF,
-        atanh: PF,
-        cbrt: PF,
-        ceil: PF,
-        clz32: PF,
-        cos: PF,
-        cosh: PF,
-        exp: PF,
-        expm1: PF,
-        floor: PF,
-        fround: PF,
-        hypot: PF,
-        imul: PF,
-        log: PF,
-        log10: PF,
-        log1p: PF,
-        log2: PF,
-        max: PF,
-        min: PF,
-        pow: PF,
-        random: PF,
-        round: PF,
-        sign: PF,
-        sin: PF,
-        sinh: PF,
-        sqrt: PF,
-        tan: PF,
-        tanh: PF,
-        trunc: PF
-    },
-    NaN: O,
-    Number: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        isFinite: PF,
-        isInteger: PF,
-        isNaN: PF,
-        isSafeInteger: PF,
-        parseFloat: PF,
-        parseInt: PF,
-        prototype: O
-    },
-    Object: {
-        __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,
-        freeze: MUTATES_ARG_WITHOUT_ACCESSOR,
-        getOwnPropertyDescriptor: PF,
-        getOwnPropertyDescriptors: PF,
-        getOwnPropertyNames: PF,
-        getOwnPropertySymbols: PF,
-        getPrototypeOf: PF,
-        hasOwn: PF,
-        is: PF,
-        isExtensible: PF,
-        isFrozen: PF,
-        isSealed: PF,
-        keys: PF,
-        fromEntries: O,
-        entries: PF_NO_GETTER,
-        values: PF_NO_GETTER,
-        prototype: O
-    },
-    parseFloat: PF,
-    parseInt: PF,
-    Promise: {
-        __proto__: null,
-        [ValueProperties]: IMPURE,
-        all: O,
-        allSettled: O,
-        any: O,
-        prototype: O,
-        race: O,
-        reject: O,
-        resolve: O
-    },
-    propertyIsEnumerable: O,
-    Proxy: O,
-    RangeError: PC,
-    ReferenceError: PC,
-    Reflect: O,
-    RegExp: PC,
-    Set: PC_WITH_ARRAY,
-    SharedArrayBuffer: C,
-    String: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        fromCharCode: PF,
-        fromCodePoint: PF,
-        prototype: O,
-        raw: PF
-    },
-    Symbol: {
-        __proto__: null,
-        [ValueProperties]: PURE,
-        for: PF,
-        keyFor: PF,
-        prototype: O,
-        toStringTag: {
-            __proto__: null,
-            [ValueProperties]: {
-                deoptimizeArgumentsOnCall: doNothing,
-                getLiteralValue() {
-                    return SymbolToStringTag;
-                },
-                hasEffectsWhenCalled: returnTrue
+};
+/* CONSTRUCTOR */
+const C = {
+    __proto__: null,
+    [ValueProperties]: IMPURE,
+    prototype: O
+};
+/* PURE CONSTRUCTOR */
+const PC = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    prototype: O
+};
+const PC_WITH_ARRAY = {
+    __proto__: null,
+    [ValueProperties]: PURE_WITH_ARRAY,
+    prototype: O
+};
+const ARRAY_TYPE = {
+    __proto__: null,
+    [ValueProperties]: PURE,
+    from: O,
+    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
+    },
+    ArrayBuffer: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isView: PF,
+        prototype: O
+    },
+    Atomics: O,
+    BigInt: C,
+    BigInt64Array: C,
+    BigUint64Array: C,
+    Boolean: PC,
+    constructor: C,
+    DataView: PC,
+    Date: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        now: PF,
+        parse: PF,
+        prototype: O,
+        UTC: PF
+    },
+    decodeURI: PF,
+    decodeURIComponent: PF,
+    encodeURI: PF,
+    encodeURIComponent: PF,
+    Error: PC,
+    escape: PF,
+    eval: O,
+    EvalError: PC,
+    Float32Array: ARRAY_TYPE,
+    Float64Array: ARRAY_TYPE,
+    Function: C,
+    hasOwnProperty: O,
+    Infinity: O,
+    Int16Array: ARRAY_TYPE,
+    Int32Array: ARRAY_TYPE,
+    Int8Array: ARRAY_TYPE,
+    isFinite: PF,
+    isNaN: PF,
+    isPrototypeOf: O,
+    JSON: O,
+    Map: PC_WITH_ARRAY,
+    Math: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        abs: PF,
+        acos: PF,
+        acosh: PF,
+        asin: PF,
+        asinh: PF,
+        atan: PF,
+        atan2: PF,
+        atanh: PF,
+        cbrt: PF,
+        ceil: PF,
+        clz32: PF,
+        cos: PF,
+        cosh: PF,
+        exp: PF,
+        expm1: PF,
+        floor: PF,
+        fround: PF,
+        hypot: PF,
+        imul: PF,
+        log: PF,
+        log10: PF,
+        log1p: PF,
+        log2: PF,
+        max: PF,
+        min: PF,
+        pow: PF,
+        random: PF,
+        round: PF,
+        sign: PF,
+        sin: PF,
+        sinh: PF,
+        sqrt: PF,
+        tan: PF,
+        tanh: PF,
+        trunc: PF
+    },
+    NaN: O,
+    Number: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        isFinite: PF,
+        isInteger: PF,
+        isNaN: PF,
+        isSafeInteger: PF,
+        parseFloat: PF,
+        parseInt: PF,
+        prototype: O
+    },
+    Object: {
+        __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,
+        freeze: MUTATES_ARG_WITHOUT_ACCESSOR,
+        getOwnPropertyDescriptor: PF,
+        getOwnPropertyDescriptors: PF,
+        getOwnPropertyNames: PF,
+        getOwnPropertySymbols: PF,
+        getPrototypeOf: PF,
+        hasOwn: PF,
+        is: PF,
+        isExtensible: PF,
+        isFrozen: PF,
+        isSealed: PF,
+        keys: PF,
+        fromEntries: O,
+        entries: PF_NO_GETTER,
+        values: PF_NO_GETTER,
+        prototype: O
+    },
+    parseFloat: PF,
+    parseInt: PF,
+    Promise: {
+        __proto__: null,
+        [ValueProperties]: IMPURE,
+        all: O,
+        allSettled: O,
+        any: O,
+        prototype: O,
+        race: O,
+        reject: O,
+        resolve: O
+    },
+    propertyIsEnumerable: O,
+    Proxy: O,
+    RangeError: PC,
+    ReferenceError: PC,
+    Reflect: O,
+    RegExp: PC,
+    Set: PC_WITH_ARRAY,
+    SharedArrayBuffer: C,
+    String: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        fromCharCode: PF,
+        fromCodePoint: PF,
+        prototype: O,
+        raw: PF
+    },
+    Symbol: {
+        __proto__: null,
+        [ValueProperties]: PURE,
+        for: PF,
+        keyFor: PF,
+        prototype: O,
+        toStringTag: {
+            __proto__: null,
+            [ValueProperties]: {
+                deoptimizeArgumentsOnCall: doNothing,
+                getLiteralValue() {
+                    return SymbolToStringTag;
+                },
+                hasEffectsWhenCalled: returnTrue
             }
         }
     },
@@ -8729,295 +8130,928 @@ const knownGlobals = {
 for (const global of ['window', 'global', 'self', 'globalThis']) {
     knownGlobals[global] = knownGlobals;
 }
-function getGlobalAtPath(path) {
-    let currentGlobal = knownGlobals;
-    for (const pathSegment of path) {
-        if (typeof pathSegment !== 'string') {
-            return null;
+function getGlobalAtPath(path) {
+    let currentGlobal = knownGlobals;
+    for (const pathSegment of path) {
+        if (typeof pathSegment !== 'string') {
+            return null;
+        }
+        currentGlobal = currentGlobal[pathSegment];
+        if (!currentGlobal) {
+            return null;
+        }
+    }
+    return currentGlobal[ValueProperties];
+}
+
+class GlobalVariable extends Variable {
+    constructor(name) {
+        super(name);
+        // Ensure we use live-bindings for globals as we do not know if they have
+        // been reassigned
+        this.markReassigned();
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        switch (interaction.type) {
+            // While there is no point in testing these cases as at the moment, they
+            // are also covered via other means, we keep them for completeness
+            case INTERACTION_ACCESSED:
+            case INTERACTION_ASSIGNED: {
+                if (!getGlobalAtPath([this.name, ...path].slice(0, -1))) {
+                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+                }
+                return;
+            }
+            case INTERACTION_CALLED: {
+                const globalAtPath = getGlobalAtPath([this.name, ...path]);
+                if (globalAtPath) {
+                    globalAtPath.deoptimizeArgumentsOnCall(interaction);
+                }
+                else {
+                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+                }
+                return;
+            }
+        }
+    }
+    getLiteralValueAtPath(path, _recursionTracker, _origin) {
+        const globalAtPath = getGlobalAtPath([this.name, ...path]);
+        return globalAtPath ? globalAtPath.getLiteralValue() : UnknownValue;
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                if (path.length === 0) {
+                    // Technically, "undefined" is a global variable of sorts
+                    return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+                }
+                return !getGlobalAtPath([this.name, ...path].slice(0, -1));
+            }
+            case INTERACTION_ASSIGNED: {
+                return true;
+            }
+            case INTERACTION_CALLED: {
+                const globalAtPath = getGlobalAtPath([this.name, ...path]);
+                return !globalAtPath || globalAtPath.hasEffectsWhenCalled(interaction, context);
+            }
+        }
+    }
+}
+
+class LocalVariable extends Variable {
+    constructor(name, declarator, init, context, kind) {
+        super(name);
+        this.init = init;
+        this.calledFromTryStatement = false;
+        this.additionalInitializers = null;
+        this.expressionsToBeDeoptimized = [];
+        this.declarations = declarator ? [declarator] : [];
+        this.deoptimizationTracker = context.deoptimizationTracker;
+        this.module = context.module;
+        this.kind = kind;
+    }
+    addDeclaration(identifier, init) {
+        this.declarations.push(identifier);
+        this.markInitializersForDeoptimization().push(init);
+    }
+    consolidateInitializers() {
+        if (this.additionalInitializers) {
+            for (const initializer of this.additionalInitializers) {
+                initializer.deoptimizePath(UNKNOWN_PATH);
+            }
+            this.additionalInitializers = null;
+        }
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        if (this.isReassigned) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        recursionTracker.withTrackedEntityAtPath(path, this.init, () => this.init.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker), undefined);
+    }
+    deoptimizePath(path) {
+        if (this.isReassigned ||
+            this.deoptimizationTracker.trackEntityAtPathAndGetIfTracked(path, this)) {
+            return;
+        }
+        if (path.length === 0) {
+            this.markReassigned();
+            const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            this.init.deoptimizePath(UNKNOWN_PATH);
+        }
+        else {
+            this.init.deoptimizePath(path);
+        }
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getLiteralValueAtPath(path, recursionTracker, origin);
+        }, UnknownValue);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UNKNOWN_RETURN_EXPRESSION;
+        }
+        return recursionTracker.withTrackedEntityAtPath(path, this.init, () => {
+            this.expressionsToBeDeoptimized.push(origin);
+            return this.init.getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        }, UNKNOWN_RETURN_EXPRESSION);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                if (this.isReassigned)
+                    return true;
+                return (!context.accessed.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_ASSIGNED: {
+                if (this.included)
+                    return true;
+                if (path.length === 0)
+                    return false;
+                if (this.isReassigned)
+                    return true;
+                return (!context.assigned.trackEntityAtPathAndGetIfTracked(path, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_CALLED: {
+                if (this.isReassigned)
+                    return true;
+                return (!(interaction.withNew ? context.instantiated : context.called).trackEntityAtPathAndGetIfTracked(path, interaction.args, this) &&
+                    this.init.hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
+    include() {
+        if (!this.included) {
+            super.include();
+            for (const declaration of this.declarations) {
+                // If node is a default export, it can save a tree-shaking run to include the full declaration now
+                if (!declaration.included)
+                    declaration.include(createInclusionContext(), false);
+                let node = declaration.parent;
+                while (!node.included) {
+                    // We do not want to properly include parents in case they are part of a dead branch
+                    // in which case .include() might pull in more dead code
+                    node.included = true;
+                    if (node.type === parseAst_js.Program)
+                        break;
+                    node = node.parent;
+                }
+            }
+        }
+    }
+    includeCallArguments(context, parameters) {
+        if (this.isReassigned || context.includedCallArguments.has(this.init)) {
+            for (const argument of parameters) {
+                argument.include(context, false);
+            }
+        }
+        else {
+            context.includedCallArguments.add(this.init);
+            this.init.includeCallArguments(context, parameters);
+            context.includedCallArguments.delete(this.init);
+        }
+    }
+    markCalledFromTryStatement() {
+        this.calledFromTryStatement = true;
+    }
+    markInitializersForDeoptimization() {
+        if (this.additionalInitializers === null) {
+            this.additionalInitializers = [this.init];
+            this.init = UNKNOWN_EXPRESSION;
+            this.markReassigned();
+        }
+        return this.additionalInitializers;
+    }
+}
+
+const tdzVariableKinds = new Set(['class', 'const', 'let', 'var', 'using', 'await using']);
+class Identifier extends NodeBase {
+    constructor() {
+        super(...arguments);
+        this.variable = null;
+        this.isReferenceVariable = false;
+    }
+    get isTDZAccess() {
+        if (!isFlagSet(this.flags, 4 /* Flag.tdzAccessDefined */)) {
+            return null;
+        }
+        return isFlagSet(this.flags, 8 /* Flag.tdzAccess */);
+    }
+    set isTDZAccess(value) {
+        this.flags = setFlag(this.flags, 4 /* Flag.tdzAccessDefined */, true);
+        this.flags = setFlag(this.flags, 8 /* Flag.tdzAccess */, value);
+    }
+    addExportedVariables(variables, exportNamesByVariable) {
+        if (exportNamesByVariable.has(this.variable)) {
+            variables.push(this.variable);
+        }
+    }
+    bind() {
+        if (!this.variable && is_reference(this, this.parent)) {
+            this.variable = this.scope.findVariable(this.name);
+            this.variable.addReference(this);
+            this.isReferenceVariable = true;
+        }
+    }
+    declare(kind, init) {
+        let variable;
+        const { treeshake } = this.scope.context.options;
+        switch (kind) {
+            case 'var': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
+                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
+                    variable.markInitializersForDeoptimization();
+                }
+                break;
+            }
+            case 'function': {
+                // in strict mode, functions are only hoisted within a scope but not across block scopes
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'let':
+            case 'const':
+            case 'using':
+            case 'await using':
+            case 'class': {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
+                break;
+            }
+            case 'parameter': {
+                variable = this.scope.addParameterDeclaration(this);
+                break;
+            }
+            /* istanbul ignore next */
+            default: {
+                /* istanbul ignore next */
+                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+            }
+        }
+        return [(this.variable = variable)];
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    }
+    deoptimizePath(path) {
+        if (path.length === 0 && !this.scope.contains(this.name)) {
+            this.disallowImportReassignment();
+        }
+        // We keep conditional chaining because an unknown Node could have an
+        // Identifier as property that might be deoptimized by default
+        this.variable?.deoptimizePath(path);
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
+    }
+    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
+        const [expression, isPure] = this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
+        return [expression, isPure || this.isPureFunction(path)];
+    }
+    hasEffects(context) {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
+            return true;
+        }
+        return (this.scope.context.options.treeshake
+            .unknownGlobalSideEffects &&
+            this.variable instanceof GlobalVariable &&
+            !this.isPureFunction(EMPTY_PATH) &&
+            this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        switch (interaction.type) {
+            case INTERACTION_ACCESSED: {
+                return (this.variable !== null &&
+                    !this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+            case INTERACTION_ASSIGNED: {
+                return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
+            }
+            case INTERACTION_CALLED: {
+                return (!this.isPureFunction(path) &&
+                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
+            }
+        }
+    }
+    include() {
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        if (!this.included) {
+            this.included = true;
+            if (this.variable !== null) {
+                this.scope.context.includeVariableInModule(this.variable);
+            }
+        }
+    }
+    includeCallArguments(context, parameters) {
+        this.variable.includeCallArguments(context, parameters);
+    }
+    isPossibleTDZ() {
+        // return cached value to avoid issues with the next tree-shaking pass
+        const cachedTdzAccess = this.isTDZAccess;
+        if (cachedTdzAccess !== null)
+            return cachedTdzAccess;
+        if (!(this.variable instanceof LocalVariable &&
+            this.variable.kind &&
+            tdzVariableKinds.has(this.variable.kind) &&
+            // we ignore possible TDZs due to circular module dependencies as
+            // otherwise we get many false positives
+            this.variable.module === this.scope.context.module)) {
+            return (this.isTDZAccess = false);
+        }
+        let decl_id;
+        if (this.variable.declarations &&
+            this.variable.declarations.length === 1 &&
+            (decl_id = this.variable.declarations[0]) &&
+            this.start < decl_id.start &&
+            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
+            // a variable accessed before its declaration
+            // in the same function or at top level of module
+            return (this.isTDZAccess = true);
+        }
+        // We ignore the case where the module is not yet executed because
+        // moduleSideEffects are false.
+        if (!this.variable.initReached && this.scope.context.module.isExecuted) {
+            // Either a const/let TDZ violation or
+            // var use before declaration was encountered.
+            return (this.isTDZAccess = true);
+        }
+        return (this.isTDZAccess = false);
+    }
+    markDeclarationReached() {
+        this.variable.initReached = true;
+    }
+    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = parseAst_js.BLANK) {
+        if (this.variable) {
+            const name = this.variable.getName(getPropertyAccess, useOriginalName);
+            if (name !== this.name) {
+                code.overwrite(this.start, this.end, name, {
+                    contentOnly: true,
+                    storeName: true
+                });
+                if (isShorthandProperty) {
+                    code.prependRight(this.start, `${this.name}: `);
+                }
+            }
+            // In strict mode, any variable named "eval" must be the actual "eval" function
+            if (name === 'eval' &&
+                renderedParentType === parseAst_js.CallExpression &&
+                isCalleeOfRenderedParent) {
+                code.appendRight(this.start, '0, ');
+            }
+        }
+    }
+    disallowImportReassignment() {
+        return this.scope.context.error(parseAst_js.logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
+    }
+    applyDeoptimizations() {
+        this.deoptimized = true;
+        if (this.variable instanceof LocalVariable) {
+            this.variable.consolidateInitializers();
+            this.scope.context.requestTreeshakingPass();
+        }
+        if (this.isReferenceVariable) {
+            this.variable.addUsedPlace(this);
+            this.scope.context.requestTreeshakingPass();
+        }
+    }
+    getVariableRespectingTDZ() {
+        if (this.isPossibleTDZ()) {
+            return UNKNOWN_EXPRESSION;
+        }
+        return this.variable;
+    }
+    isPureFunction(path) {
+        let currentPureFunction = this.scope.context.manualPureFunctions[this.name];
+        for (const segment of path) {
+            if (currentPureFunction) {
+                if (currentPureFunction[PureFunctionKey]) {
+                    return true;
+                }
+                currentPureFunction = currentPureFunction[segment];
+            }
+            else {
+                return false;
+            }
+        }
+        return currentPureFunction?.[PureFunctionKey];
+    }
+}
+function closestParentFunctionOrProgram(node) {
+    while (node && !/^Program|Function/.test(node.type)) {
+        node = node.parent;
+    }
+    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
+    return node;
+}
+
+const MAX_TRACKED_INTERACTIONS = 20;
+const NO_INTERACTIONS = parseAst_js.EMPTY_ARRAY;
+const UNKNOWN_DEOPTIMIZED_FIELD = new Set([UnknownKey]);
+const EMPTY_PATH_TRACKER = new PathTracker();
+const UNKNOWN_DEOPTIMIZED_ENTITY = new Set([UNKNOWN_EXPRESSION]);
+class ParameterVariable extends LocalVariable {
+    constructor(name, declarator, context) {
+        super(name, declarator, UNKNOWN_EXPRESSION, context, 'parameter');
+        this.deoptimizationInteractions = [];
+        this.deoptimizations = new PathTracker();
+        this.deoptimizedFields = new Set();
+        this.entitiesToBeDeoptimized = new Set();
+        this.expressionsUseTheKnownValue = [];
+        this.knownValue = null;
+        this.knownValueLiteral = UnknownValue;
+        this.frozenValue = null;
+    }
+    addEntityToBeDeoptimized(entity) {
+        if (entity === UNKNOWN_EXPRESSION) {
+            // As unknown expressions fully deoptimize all interactions, we can clear
+            // the interaction cache at this point provided we keep this optimization
+            // in mind when adding new interactions
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.entitiesToBeDeoptimized.add(UNKNOWN_EXPRESSION);
+                for (const { interaction } of this.deoptimizationInteractions) {
+                    deoptimizeInteraction(interaction);
+                }
+                this.deoptimizationInteractions = NO_INTERACTIONS;
+            }
+        }
+        else if (this.deoptimizedFields.has(UnknownKey)) {
+            // This means that we already deoptimized all interactions and no longer
+            // track them
+            entity.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.entitiesToBeDeoptimized.has(entity)) {
+            this.entitiesToBeDeoptimized.add(entity);
+            for (const field of this.deoptimizedFields) {
+                entity.deoptimizePath([field]);
+            }
+            for (const { interaction, path } of this.deoptimizationInteractions) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+        }
+    }
+    markReassigned() {
+        if (this.isReassigned) {
+            return;
+        }
+        super.markReassigned();
+        for (const expression of this.expressionsUseTheKnownValue) {
+            expression.deoptimizeCache();
+        }
+        this.expressionsUseTheKnownValue = parseAst_js.EMPTY_ARRAY;
+    }
+    deoptimizeCache() {
+        this.markReassigned();
+    }
+    /**
+     * Update the known value of the parameter variable.
+     * Must be called for every function call, so it can track all the arguments,
+     * and deoptimizeCache itself to mark reassigned if the argument is changed.
+     * @param argument The argument of the function call
+     */
+    updateKnownValue(argument) {
+        if (this.isReassigned) {
+            return;
+        }
+        if (this.knownValue === null) {
+            this.knownValue = argument;
+            this.knownValueLiteral = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+            return;
+        }
+        // the same literal or identifier, do nothing
+        if (this.knownValue === argument ||
+            (this.knownValue instanceof Identifier &&
+                argument instanceof Identifier &&
+                this.knownValue.variable === argument.variable)) {
+            return;
+        }
+        const oldValue = this.knownValueLiteral;
+        if (typeof oldValue === 'symbol') {
+            this.markReassigned();
+            return;
+        }
+        // add tracking for the new argument
+        const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, this);
+        if (newValue !== oldValue) {
+            this.markReassigned();
+        }
+    }
+    /**
+     * This function freezes the known value of the parameter variable,
+     * so the optimization starts with a certain ExpressionEntity.
+     * The optimization can be undone by calling `markReassigned`.
+     * @returns the frozen value
+     */
+    getKnownValue() {
+        if (this.frozenValue === null) {
+            this.frozenValue = this.knownValue || UNKNOWN_EXPRESSION;
+        }
+        return this.frozenValue;
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        const knownValue = this.getKnownValue();
+        this.expressionsUseTheKnownValue.push(origin);
+        return recursionTracker.withTrackedEntityAtPath(path, knownValue, () => knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        if (this.isReassigned || interaction.type === INTERACTION_ASSIGNED) {
+            return super.hasEffectsOnInteractionAtPath(path, interaction, context);
+        }
+        const knownValue = this.getKnownValue();
+        return knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
+        // For performance reasons, we fully deoptimize all deeper interactions
+        if (path.length >= 2 ||
+            this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION) ||
+            this.deoptimizationInteractions.length >= MAX_TRACKED_INTERACTIONS ||
+            (path.length === 1 &&
+                (this.deoptimizedFields.has(UnknownKey) ||
+                    (interaction.type === INTERACTION_CALLED && this.deoptimizedFields.has(path[0]))))) {
+            deoptimizeInteraction(interaction);
+            return;
+        }
+        if (!this.deoptimizations.trackEntityAtPathAndGetIfTracked(path, interaction.args)) {
+            for (const entity of this.entitiesToBeDeoptimized) {
+                entity.deoptimizeArgumentsOnInteractionAtPath(interaction, path, SHARED_RECURSION_TRACKER);
+            }
+            if (!this.entitiesToBeDeoptimized.has(UNKNOWN_EXPRESSION)) {
+                this.deoptimizationInteractions.push({
+                    interaction,
+                    path
+                });
+            }
+        }
+    }
+    deoptimizePath(path) {
+        if (path.length === 0) {
+            this.markReassigned();
+            return;
+        }
+        if (this.deoptimizedFields.has(UnknownKey)) {
+            return;
+        }
+        const key = path[0];
+        if (this.deoptimizedFields.has(key)) {
+            return;
+        }
+        this.deoptimizedFields.add(key);
+        for (const entity of this.entitiesToBeDeoptimized) {
+            // We do not need a recursion tracker here as we already track whether
+            // this field is deoptimized
+            entity.deoptimizePath([key]);
+        }
+        if (key === UnknownKey) {
+            // save some memory
+            this.deoptimizationInteractions = NO_INTERACTIONS;
+            this.deoptimizations = EMPTY_PATH_TRACKER;
+            this.deoptimizedFields = UNKNOWN_DEOPTIMIZED_FIELD;
+            this.entitiesToBeDeoptimized = UNKNOWN_DEOPTIMIZED_ENTITY;
+        }
+    }
+    getReturnExpressionWhenCalledAtPath(path) {
+        // We deoptimize everything that is called as that will trivially deoptimize
+        // the corresponding return expressions as well and avoid badly performing
+        // and complicated alternatives
+        if (path.length === 0) {
+            this.deoptimizePath(UNKNOWN_PATH);
+        }
+        else if (!this.deoptimizedFields.has(path[0])) {
+            this.deoptimizePath([path[0]]);
+        }
+        return UNKNOWN_RETURN_EXPRESSION;
+    }
+}
+
+function getSafeName(baseName, usedNames, forbiddenNames) {
+    let safeName = baseName;
+    let count = 1;
+    while (usedNames.has(safeName) || RESERVED_NAMES.has(safeName) || forbiddenNames?.has(safeName)) {
+        safeName = `${baseName}$${toBase64(count++)}`;
+    }
+    usedNames.add(safeName);
+    return safeName;
+}
+
+class Scope {
+    constructor() {
+        this.children = [];
+        this.variables = new Map();
+    }
+    /*
+    Redeclaration rules:
+    - var can redeclare var
+    - in function scopes, function and var can redeclare function and var
+    - var is hoisted across scopes, function remains in the scope it is declared
+    - var and function can redeclare function parameters, but parameters cannot redeclare parameters
+    - function cannot redeclare catch scope parameters
+    - var can redeclare catch scope parameters in a way
+        - if the parameter is an identifier and not a pattern
+        - then the variable is still declared in the hoisted outer scope, but the initializer is assigned to the parameter
+    - const, let, class, and function except in the cases above cannot redeclare anything
+     */
+    addDeclaration(identifier, context, init, kind) {
+        const name = identifier.name;
+        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+        if (existingVariable) {
+            const existingKind = existingVariable.kind;
+            if (kind === 'var' && existingKind === 'var') {
+                existingVariable.addDeclaration(identifier, init);
+                return existingVariable;
+            }
+            context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+        }
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
+        this.variables.set(name, newVariable);
+        return newVariable;
+    }
+    addHoistedVariable(name, variable) {
+        (this.hoistedVariables ||= new Map()).set(name, variable);
+    }
+    contains(name) {
+        return this.variables.has(name);
+    }
+    findVariable(_name) {
+        /* istanbul ignore next */
+        throw new Error('Internal Error: findVariable needs to be implemented by a subclass');
+    }
+}
+
+class ChildScope extends Scope {
+    constructor(parent, context) {
+        super();
+        this.parent = parent;
+        this.context = context;
+        this.accessedOutsideVariables = new Map();
+        parent.children.push(this);
+    }
+    addAccessedDynamicImport(importExpression) {
+        (this.accessedDynamicImports || (this.accessedDynamicImports = new Set())).add(importExpression);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedDynamicImport(importExpression);
         }
-        currentGlobal = currentGlobal[pathSegment];
-        if (!currentGlobal) {
-            return null;
+    }
+    addAccessedGlobals(globals, accessedGlobalsByScope) {
+        const accessedGlobals = accessedGlobalsByScope.get(this) || new Set();
+        for (const name of globals) {
+            accessedGlobals.add(name);
+        }
+        accessedGlobalsByScope.set(this, accessedGlobals);
+        if (this.parent instanceof ChildScope) {
+            this.parent.addAccessedGlobals(globals, accessedGlobalsByScope);
         }
     }
-    return currentGlobal[ValueProperties];
-}
-
-class GlobalVariable extends Variable {
-    constructor(name) {
-        super(name);
-        // Ensure we use live-bindings for globals as we do not know if they have
-        // been reassigned
-        this.markReassigned();
+    addNamespaceMemberAccess(name, variable) {
+        this.accessedOutsideVariables.set(name, variable);
+        this.parent.addNamespaceMemberAccess(name, variable);
     }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        switch (interaction.type) {
-            // While there is no point in testing these cases as at the moment, they
-            // are also covered via other means, we keep them for completeness
-            case INTERACTION_ACCESSED:
-            case INTERACTION_ASSIGNED: {
-                if (!getGlobalAtPath([this.name, ...path].slice(0, -1))) {
-                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+    addReturnExpression(expression) {
+        this.parent instanceof ChildScope && this.parent.addReturnExpression(expression);
+    }
+    addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope) {
+        for (const variable of this.accessedOutsideVariables.values()) {
+            if (variable.included) {
+                usedNames.add(variable.getBaseVariableName());
+                if (format === 'system' && exportNamesByVariable.has(variable)) {
+                    usedNames.add('exports');
                 }
-                return;
             }
-            case INTERACTION_CALLED: {
-                const globalAtPath = getGlobalAtPath([this.name, ...path]);
-                if (globalAtPath) {
-                    globalAtPath.deoptimizeArgumentsOnCall(interaction);
-                }
-                else {
-                    super.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
-                }
-                return;
+        }
+        const accessedGlobals = accessedGlobalsByScope.get(this);
+        if (accessedGlobals) {
+            for (const name of accessedGlobals) {
+                usedNames.add(name);
             }
         }
     }
-    getLiteralValueAtPath(path, _recursionTracker, _origin) {
-        const globalAtPath = getGlobalAtPath([this.name, ...path]);
-        return globalAtPath ? globalAtPath.getLiteralValue() : UnknownValue;
+    contains(name) {
+        return this.variables.has(name) || this.parent.contains(name);
     }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        switch (interaction.type) {
-            case INTERACTION_ACCESSED: {
-                if (path.length === 0) {
-                    // Technically, "undefined" is a global variable of sorts
-                    return this.name !== 'undefined' && !getGlobalAtPath([this.name]);
+    deconflict(format, exportNamesByVariable, accessedGlobalsByScope) {
+        const usedNames = new Set();
+        this.addUsedOutsideNames(usedNames, format, exportNamesByVariable, accessedGlobalsByScope);
+        if (this.accessedDynamicImports) {
+            for (const importExpression of this.accessedDynamicImports) {
+                if (importExpression.inlineNamespace) {
+                    usedNames.add(importExpression.inlineNamespace.getBaseVariableName());
                 }
-                return !getGlobalAtPath([this.name, ...path].slice(0, -1));
-            }
-            case INTERACTION_ASSIGNED: {
-                return true;
             }
-            case INTERACTION_CALLED: {
-                const globalAtPath = getGlobalAtPath([this.name, ...path]);
-                return !globalAtPath || globalAtPath.hasEffectsWhenCalled(interaction, context);
+        }
+        for (const [name, variable] of this.variables) {
+            if (variable.included || variable.alwaysRendered) {
+                variable.setRenderNames(null, getSafeName(name, usedNames, variable.forbiddenNames));
             }
         }
-    }
-}
-
-const tdzVariableKinds = new Set(['class', 'const', 'let', 'var', 'using', 'await using']);
-class Identifier extends NodeBase {
-    constructor() {
-        super(...arguments);
-        this.variable = null;
-        this.isReferenceVariable = false;
-    }
-    get isTDZAccess() {
-        if (!isFlagSet(this.flags, 4 /* Flag.tdzAccessDefined */)) {
-            return null;
+        for (const scope of this.children) {
+            scope.deconflict(format, exportNamesByVariable, accessedGlobalsByScope);
         }
-        return isFlagSet(this.flags, 8 /* Flag.tdzAccess */);
     }
-    set isTDZAccess(value) {
-        this.flags = setFlag(this.flags, 4 /* Flag.tdzAccessDefined */, true);
-        this.flags = setFlag(this.flags, 8 /* Flag.tdzAccess */, value);
+    findLexicalBoundary() {
+        return this.parent.findLexicalBoundary();
     }
-    addExportedVariables(variables, exportNamesByVariable) {
-        if (exportNamesByVariable.has(this.variable)) {
-            variables.push(this.variable);
+    findVariable(name) {
+        const knownVariable = this.variables.get(name) || this.accessedOutsideVariables.get(name);
+        if (knownVariable) {
+            return knownVariable;
         }
+        const variable = this.parent.findVariable(name);
+        this.accessedOutsideVariables.set(name, variable);
+        return variable;
     }
-    bind() {
-        if (!this.variable && is_reference(this, this.parent)) {
-            this.variable = this.scope.findVariable(this.name);
-            this.variable.addReference(this);
-            this.isReferenceVariable = true;
-        }
+}
+
+class CatchBodyScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
+        this.parent = parent;
     }
-    declare(kind, init) {
-        let variable;
-        const { treeshake } = this.scope.context.options;
-        switch (kind) {
-            case 'var': {
-                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
-                if (treeshake && treeshake.correctVarValueBeforeDeclaration) {
-                    // Necessary to make sure the init is deoptimized. We cannot call deoptimizePath here.
-                    variable.markInitializersForDeoptimization();
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === 'var') {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                const existingKind = existingVariable.kind;
+                if (existingKind === 'parameter' &&
+                    // If this is a destructured parameter, it is forbidden to redeclare
+                    existingVariable.declarations[0].parent.type === parseAst_js.CatchClause) {
+                    // If this is a var with the same name as the catch scope parameter,
+                    // the assignment actually goes to the parameter and the var is
+                    // hoisted without assignment. Locally, it is shadowed by the
+                    // parameter
+                    const declaredVariable = this.parent.parent.addDeclaration(identifier, context, UNDEFINED_EXPRESSION, kind);
+                    // To avoid the need to rewrite the declaration, we link the variable
+                    // names. If we ever implement a logic that splits initialization and
+                    // assignment for hoisted vars, the "renderLikeHoisted" logic can be
+                    // removed again.
+                    // We do not need to check whether there already is a linked
+                    // variable because then declaredVariable would be that linked
+                    // variable.
+                    existingVariable.renderLikeHoisted(declaredVariable);
+                    this.addHoistedVariable(name, declaredVariable);
+                    return declaredVariable;
                 }
-                break;
-            }
-            case 'function': {
-                // in strict mode, functions are only hoisted within a scope but not across block scopes
-                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
-                break;
-            }
-            case 'let':
-            case 'const':
-            case 'using':
-            case 'await using':
-            case 'class': {
-                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
-                break;
-            }
-            case 'parameter': {
-                variable = this.scope.addParameterDeclaration(this);
-                break;
-            }
-            /* istanbul ignore next */
-            default: {
-                /* istanbul ignore next */
-                throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
+                if (existingKind === 'var') {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+                }
+                return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
             }
+            // We only add parameters to parameter scopes
+            const declaredVariable = this.parent.parent.addDeclaration(identifier, context, init, kind);
+            // Necessary to make sure the init is deoptimized for conditional declarations.
+            // We cannot call deoptimizePath here.
+            declaredVariable.markInitializersForDeoptimization();
+            // We add the variable to this and all parent scopes to reliably detect conflicts
+            this.addHoistedVariable(name, declaredVariable);
+            return declaredVariable;
         }
-        return [(this.variable = variable)];
+        return super.addDeclaration(identifier, context, init, kind);
     }
-    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+}
+
+class FunctionBodyScope extends ChildScope {
+    constructor(parent) {
+        super(parent, parent.context);
     }
-    deoptimizePath(path) {
-        if (path.length === 0 && !this.scope.contains(this.name)) {
-            this.disallowImportReassignment();
+    // There is stuff that is only allowed in function scopes, i.e. functions can
+    // be redeclared, functions and var can redeclare each other
+    addDeclaration(identifier, context, init, kind) {
+        const name = identifier.name;
+        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+        if (existingVariable) {
+            const existingKind = existingVariable.kind;
+            if ((kind === 'var' || kind === 'function') &&
+                (existingKind === 'var' || existingKind === 'function' || existingKind === 'parameter')) {
+                existingVariable.addDeclaration(identifier, init);
+                return existingVariable;
+            }
+            context.error(parseAst_js.logRedeclarationError(name), identifier.start);
         }
-        // We keep conditional chaining because an unknown Node could have an
-        // Identifier as property that might be deoptimized by default
-        this.variable?.deoptimizePath(path);
-    }
-    getLiteralValueAtPath(path, recursionTracker, origin) {
-        return this.getVariableRespectingTDZ().getLiteralValueAtPath(path, recursionTracker, origin);
-    }
-    getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
-        const [expression, isPure] = this.getVariableRespectingTDZ().getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin);
-        return [expression, isPure || this.isPureFunction(path)];
+        const newVariable = new LocalVariable(identifier.name, identifier, init, context, kind);
+        this.variables.set(name, newVariable);
+        return newVariable;
     }
-    hasEffects(context) {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
-            return true;
-        }
-        return (this.scope.context.options.treeshake
-            .unknownGlobalSideEffects &&
-            this.variable instanceof GlobalVariable &&
-            !this.isPureFunction(EMPTY_PATH) &&
-            this.variable.hasEffectsOnInteractionAtPath(EMPTY_PATH, NODE_INTERACTION_UNKNOWN_ACCESS, context));
+}
+
+class ParameterScope extends ChildScope {
+    constructor(parent, isCatchScope) {
+        super(parent, parent.context);
+        this.parameters = [];
+        this.hasRest = false;
+        this.bodyScope = isCatchScope ? new CatchBodyScope(this) : new FunctionBodyScope(this);
     }
-    hasEffectsOnInteractionAtPath(path, interaction, context) {
-        switch (interaction.type) {
-            case INTERACTION_ACCESSED: {
-                return (this.variable !== null &&
-                    !this.isPureFunction(path) &&
-                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
-            }
-            case INTERACTION_ASSIGNED: {
-                return (path.length > 0 ? this.getVariableRespectingTDZ() : this.variable).hasEffectsOnInteractionAtPath(path, interaction, context);
-            }
-            case INTERACTION_CALLED: {
-                return (!this.isPureFunction(path) &&
-                    this.getVariableRespectingTDZ().hasEffectsOnInteractionAtPath(path, interaction, context));
-            }
+    /**
+     * Adds a parameter to this scope. Parameters must be added in the correct
+     * order, i.e. from left to right.
+     */
+    addParameterDeclaration(identifier) {
+        const { name, start } = identifier;
+        const existingParameter = this.variables.get(name);
+        if (existingParameter) {
+            return this.context.error(parseAst_js.logDuplicateArgumentNameError(name), start);
         }
+        const variable = new ParameterVariable(name, identifier, this.context);
+        this.variables.set(name, variable);
+        // We also add it to the body scope to detect name conflicts with local
+        // variables. We still need the intermediate scope, though, as parameter
+        // defaults are NOT taken from the body scope but from the parameters or
+        // outside scope.
+        this.bodyScope.addHoistedVariable(name, variable);
+        return variable;
     }
-    include() {
-        if (!this.deoptimized)
-            this.applyDeoptimizations();
-        if (!this.included) {
-            this.included = true;
-            if (this.variable !== null) {
-                this.scope.context.includeVariableInModule(this.variable);
+    addParameterVariables(parameters, hasRest) {
+        this.parameters = parameters;
+        for (const parameterList of parameters) {
+            for (const parameter of parameterList) {
+                parameter.alwaysRendered = true;
             }
         }
+        this.hasRest = hasRest;
     }
     includeCallArguments(context, parameters) {
-        this.variable.includeCallArguments(context, parameters);
-    }
-    isPossibleTDZ() {
-        // return cached value to avoid issues with the next tree-shaking pass
-        const cachedTdzAccess = this.isTDZAccess;
-        if (cachedTdzAccess !== null)
-            return cachedTdzAccess;
-        if (!(this.variable instanceof LocalVariable &&
-            this.variable.kind &&
-            tdzVariableKinds.has(this.variable.kind) &&
-            // we ignore possible TDZs due to circular module dependencies as
-            // otherwise we get many false positives
-            this.variable.module === this.scope.context.module)) {
-            return (this.isTDZAccess = false);
-        }
-        let decl_id;
-        if (this.variable.declarations &&
-            this.variable.declarations.length === 1 &&
-            (decl_id = this.variable.declarations[0]) &&
-            this.start < decl_id.start &&
-            closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
-            // a variable accessed before its declaration
-            // in the same function or at top level of module
-            return (this.isTDZAccess = true);
-        }
-        // We ignore the case where the module is not yet executed because
-        // moduleSideEffects are false.
-        if (!this.variable.initReached && this.scope.context.module.isExecuted) {
-            // Either a const/let TDZ violation or
-            // var use before declaration was encountered.
-            return (this.isTDZAccess = true);
+        let calledFromTryStatement = false;
+        let argumentIncluded = false;
+        const restParameter = this.hasRest && this.parameters[this.parameters.length - 1];
+        for (const checkedArgument of parameters) {
+            if (checkedArgument instanceof SpreadElement) {
+                for (const argument of parameters) {
+                    argument.include(context, false);
+                }
+                break;
+            }
         }
-        return (this.isTDZAccess = false);
-    }
-    markDeclarationReached() {
-        this.variable.initReached = true;
-    }
-    render(code, { snippets: { getPropertyAccess }, useOriginalName }, { renderedParentType, isCalleeOfRenderedParent, isShorthandProperty } = parseAst_js.BLANK) {
-        if (this.variable) {
-            const name = this.variable.getName(getPropertyAccess, useOriginalName);
-            if (name !== this.name) {
-                code.overwrite(this.start, this.end, name, {
-                    contentOnly: true,
-                    storeName: true
-                });
-                if (isShorthandProperty) {
-                    code.prependRight(this.start, `${this.name}: `);
+        for (let index = parameters.length - 1; index >= 0; index--) {
+            const parameterVariables = this.parameters[index] || restParameter;
+            const argument = parameters[index];
+            if (parameterVariables) {
+                calledFromTryStatement = false;
+                if (parameterVariables.length === 0) {
+                    // handle empty destructuring
+                    argumentIncluded = true;
+                }
+                else {
+                    for (const variable of parameterVariables) {
+                        if (variable.included) {
+                            argumentIncluded = true;
+                        }
+                        if (variable.calledFromTryStatement) {
+                            calledFromTryStatement = true;
+                        }
+                    }
                 }
             }
-            // In strict mode, any variable named "eval" must be the actual "eval" function
-            if (name === 'eval' &&
-                renderedParentType === parseAst_js.CallExpression &&
-                isCalleeOfRenderedParent) {
-                code.appendRight(this.start, '0, ');
+            if (!argumentIncluded && argument.shouldBeIncluded(context)) {
+                argumentIncluded = true;
+            }
+            if (argumentIncluded) {
+                argument.include(context, calledFromTryStatement);
             }
         }
     }
-    disallowImportReassignment() {
-        return this.scope.context.error(parseAst_js.logIllegalImportReassignment(this.name, this.scope.context.module.id), this.start);
+}
+
+class ReturnValueScope extends ParameterScope {
+    constructor() {
+        super(...arguments);
+        this.returnExpression = null;
+        this.returnExpressions = [];
     }
-    applyDeoptimizations() {
-        this.deoptimized = true;
-        if (this.variable instanceof LocalVariable) {
-            this.variable.consolidateInitializers();
-            this.scope.context.requestTreeshakingPass();
-        }
-        if (this.isReferenceVariable) {
-            this.variable.addUsedPlace(this);
-        }
+    addReturnExpression(expression) {
+        this.returnExpressions.push(expression);
     }
-    getVariableRespectingTDZ() {
-        if (this.isPossibleTDZ()) {
-            return UNKNOWN_EXPRESSION;
-        }
-        return this.variable;
+    getReturnExpression() {
+        if (this.returnExpression === null)
+            this.updateReturnExpression();
+        return this.returnExpression;
     }
-    isPureFunction(path) {
-        let currentPureFunction = this.scope.context.manualPureFunctions[this.name];
-        for (const segment of path) {
-            if (currentPureFunction) {
-                if (currentPureFunction[PureFunctionKey]) {
-                    return true;
-                }
-                currentPureFunction = currentPureFunction[segment];
-            }
-            else {
-                return false;
+    updateReturnExpression() {
+        if (this.returnExpressions.length === 1) {
+            this.returnExpression = this.returnExpressions[0];
+        }
+        else {
+            this.returnExpression = UNKNOWN_EXPRESSION;
+            for (const expression of this.returnExpressions) {
+                expression.deoptimizePath(UNKNOWN_PATH);
             }
         }
-        return currentPureFunction?.[PureFunctionKey];
-    }
-}
-function closestParentFunctionOrProgram(node) {
-    while (node && !/^Program|Function/.test(node.type)) {
-        node = node.parent;
     }
-    // one of: ArrowFunctionExpression, FunctionDeclaration, FunctionExpression or Program
-    return node;
 }
 
 function treeshakeNode(node, code, start, end) {
@@ -9308,17 +9342,11 @@ class RestElement extends NodeBase {
     }
 }
 
-// This handler does nothing.
-// Since we always re-evaluate argument values in a new tree-shaking pass,
-// we don't need to get notified if it is deoptimized.
-const EMPTY_DEOPTIMIZABLE_HANDLER = { deoptimizeCache() { } };
 class FunctionBase extends NodeBase {
     constructor() {
         super(...arguments);
-        this.knownParameterValues = [];
-        this.allArguments = [];
         this.objectEntity = null;
-        this.functionParametersOptimized = false;
+        this.parameterVariableValuesDeoptimized = false;
     }
     get async() {
         return isFlagSet(this.flags, 256 /* Flag.async */);
@@ -9338,84 +9366,22 @@ class FunctionBase extends NodeBase {
     set generator(value) {
         this.flags = setFlag(this.flags, 4194304 /* Flag.generator */, value);
     }
-    /**
-     * update knownParameterValues when a call is made to this function
-     * @param newArguments arguments of the call
-     */
-    updateKnownParameterValues(newArguments) {
+    updateParameterVariableValues(_arguments) {
         for (let position = 0; position < this.params.length; position++) {
-            // only the "this" argument newArguments[0] can be null
-            // it's possible that some arguments are empty, so the value is undefined
-            const argument = newArguments[position + 1] ?? UNDEFINED_EXPRESSION;
             const parameter = this.params[position];
-            // RestElement can be, and can only be, the last parameter
-            if (parameter instanceof RestElement) {
-                return;
-            }
-            const knownParameterValue = this.knownParameterValues[position];
-            if (knownParameterValue === undefined) {
-                this.knownParameterValues[position] = argument;
-                continue;
-            }
-            if (knownParameterValue === UNKNOWN_EXPRESSION ||
-                knownParameterValue === argument ||
-                (knownParameterValue instanceof Identifier &&
-                    argument instanceof Identifier &&
-                    knownParameterValue.variable === argument.variable)) {
+            if (!(parameter instanceof Identifier)) {
                 continue;
             }
-            const oldValue = knownParameterValue.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, EMPTY_DEOPTIMIZABLE_HANDLER);
-            const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, EMPTY_DEOPTIMIZABLE_HANDLER);
-            if (oldValue !== newValue || typeof oldValue === 'symbol') {
-                this.knownParameterValues[position] = UNKNOWN_EXPRESSION;
-            } // else both are the same literal, no need to update
-        }
-    }
-    forwardArgumentsForFunctionCalledOnce(newArguments) {
-        for (let position = 0; position < this.params.length; position++) {
-            const parameter = this.params[position];
-            if (parameter instanceof Identifier) {
-                const ParameterVariable = parameter.variable;
-                const argument = newArguments[position + 1] ?? UNDEFINED_EXPRESSION;
-                ParameterVariable?.setKnownValue(argument);
-            }
-        }
-    }
-    /**
-     * each time tree-shake starts, this method should be called to reoptimize the parameters
-     * a parameter's state will change at most twice:
-     *   `undefined` (no call is made) -> an expression -> `UnknownArgument`
-     * we are sure it will converge, and can use state from last iteration
-     */
-    applyFunctionParameterOptimization() {
-        if (this.allArguments.length === 0) {
-            return;
-        }
-        if (this.allArguments.length === 1) {
-            // we are sure what knownParameterValues will be, so skip it and do setKnownValue
-            this.forwardArgumentsForFunctionCalledOnce(this.allArguments[0]);
-            return;
-        }
-        // reoptimize all arguments, that's why we save them
-        for (const argumentsList of this.allArguments) {
-            this.updateKnownParameterValues(argumentsList);
-        }
-        for (let position = 0; position < this.params.length; position++) {
-            const parameter = this.params[position];
-            // Parameters without default values
-            if (parameter instanceof Identifier) {
-                const parameterVariable = parameter.variable;
-                // Only the RestElement may be undefined
-                const knownParameterValue = this.knownParameterValues[position];
-                parameterVariable?.setKnownValue(knownParameterValue);
-            }
+            const parameterVariable = parameter.variable;
+            const argument = _arguments[position + 1] ?? UNDEFINED_EXPRESSION;
+            parameterVariable.updateKnownValue(argument);
         }
     }
-    deoptimizeFunctionParameters() {
+    deoptimizeParameterVariableValues() {
         for (const parameter of this.params) {
             if (parameter instanceof Identifier) {
                 const parameterVariable = parameter.variable;
-                parameterVariable?.markReassigned();
+                parameterVariable.markReassigned();
             }
         }
     }
@@ -9443,7 +9409,7 @@ class FunctionBase extends NodeBase {
                     this.addArgumentToBeDeoptimized(argument);
                 }
             }
-            this.allArguments.push(args);
+            this.updateParameterVariableValues(args);
         }
         else {
             this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
@@ -9518,14 +9484,10 @@ class FunctionBase extends NodeBase {
         return variable?.getOnlyFunctionCallUsed() ?? false;
     }
     include(context, includeChildrenRecursively) {
-        const shouldOptimizeFunctionParameters = this.onlyFunctionCallUsed();
-        if (shouldOptimizeFunctionParameters) {
-            this.applyFunctionParameterOptimization();
-        }
-        else if (this.functionParametersOptimized) {
-            this.deoptimizeFunctionParameters();
+        if (!this.parameterVariableValuesDeoptimized && !this.onlyFunctionCallUsed()) {
+            this.parameterVariableValuesDeoptimized = true;
+            this.deoptimizeParameterVariableValues();
         }
-        this.functionParametersOptimized = shouldOptimizeFunctionParameters;
         if (!this.deoptimized)
             this.applyDeoptimizations();
         this.included = true;
@@ -10280,7 +10242,7 @@ class MemberExpression extends NodeBase {
     }
     deoptimizeCache() {
         const { expressionsToBeDeoptimized, object } = this;
-        this.expressionsToBeDeoptimized = [];
+        this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
         this.propertyKey = UnknownKey;
         object.deoptimizePath(UNKNOWN_PATH);
         for (const expression of expressionsToBeDeoptimized) {
@@ -10431,6 +10393,7 @@ class MemberExpression extends NodeBase {
         }
         if (this.variable) {
             this.variable.addUsedPlace(this);
+            this.scope.context.requestTreeshakingPass();
         }
     }
     applyAssignmentDeoptimization() {
@@ -10630,21 +10593,17 @@ class CallExpression extends CallExpressionBase {
         };
     }
     hasEffects(context) {
-        try {
-            for (const argument of this.arguments) {
-                if (argument.hasEffects(context))
-                    return true;
-            }
-            if (this.annotationPure) {
-                return false;
-            }
-            return (this.callee.hasEffects(context) ||
-                this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
+        if (!this.deoptimized)
+            this.applyDeoptimizations();
+        for (const argument of this.arguments) {
+            if (argument.hasEffects(context))
+                return true;
         }
-        finally {
-            if (!this.deoptimized)
-                this.applyDeoptimizations();
+        if (this.annotationPure) {
+            return false;
         }
+        return (this.callee.hasEffects(context) ||
+            this.callee.hasEffectsOnInteractionAtPath(EMPTY_PATH, this.interaction, context));
     }
     include(context, includeChildrenRecursively) {
         if (!this.deoptimized)
@@ -11081,24 +11040,15 @@ class ConditionalExpression extends NodeBase {
         this.alternate.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
     }
     deoptimizeCache() {
-        if (this.usedBranch ||
-            this.isBranchResolutionAnalysed ||
-            this.expressionsToBeDeoptimized.length > 0) {
-            // Request another pass because we need to ensure "include" runs again if it is rendered
-            this.scope.context.requestTreeshakingPass();
-        }
-        const { expressionsToBeDeoptimized } = this;
-        if (expressionsToBeDeoptimized.length > 0) {
-            this.expressionsToBeDeoptimized = [];
-            for (const expression of expressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
-            }
-        }
-        this.isBranchResolutionAnalysed = false;
         if (this.usedBranch !== null) {
             const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            const { expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
         }
     }
     deoptimizePath(path) {
@@ -11112,10 +11062,10 @@ class ConditionalExpression extends NodeBase {
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        this.expressionsToBeDeoptimized.push(origin);
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
             return UnknownValue;
+        this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
@@ -11612,7 +11562,7 @@ class IfStatement extends NodeBase {
         this.testValue = unset;
     }
     deoptimizeCache() {
-        this.testValue = unset;
+        this.testValue = UnknownValue;
     }
     hasEffects(context) {
         if (this.test.hasEffects(context)) {
@@ -12420,24 +12370,18 @@ class LogicalExpression extends NodeBase {
         this.right.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
     }
     deoptimizeCache() {
-        if (this.usedBranch ||
-            this.isBranchResolutionAnalysed ||
-            this.expressionsToBeDeoptimized.length > 0) {
-            // Request another pass because we need to ensure "include" runs again if it is rendered
-            this.scope.context.requestTreeshakingPass();
-        }
-        const { expressionsToBeDeoptimized } = this;
-        if (expressionsToBeDeoptimized.length > 0) {
-            this.expressionsToBeDeoptimized = [];
-            for (const expression of expressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
-            }
-        }
-        this.isBranchResolutionAnalysed = false;
         if (this.usedBranch) {
             const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
+            const { scope: { context }, expressionsToBeDeoptimized } = this;
+            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            // Request another pass because we need to ensure "include" runs again if
+            // it is rendered
+            context.requestTreeshakingPass();
         }
     }
     deoptimizePath(path) {
@@ -12451,10 +12395,10 @@ class LogicalExpression extends NodeBase {
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
-        this.expressionsToBeDeoptimized.push(origin);
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
             return UnknownValue;
+        this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {