rollup 4.3.1 → 4.4.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.3.1
-	Sat, 11 Nov 2023 07:57:25 GMT - commit 52c55bb1e17154ae6d01fb40e0e4a3589bc20a8f
+	Rollup.js v4.4.0
+	Sun, 12 Nov 2023 07:49:26 GMT - commit 53d636051ac60da9b302c4bd6b7eaaccb4871f4b
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.3.1";
+var version = "4.4.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -3375,12 +3375,18 @@ class Variable extends ExpressionEntity {
         (this.forbiddenNames ||= new Set()).add(name);
     }
     getBaseVariableName() {
-        return this.renderBaseName || this.renderName || this.name;
+        return (this.renderedLikeHoisted?.getBaseVariableName() ||
+            this.renderBaseName ||
+            this.renderName ||
+            this.name);
     }
     getName(getPropertyAccess, useOriginalName) {
         if (useOriginalName?.(this)) {
             return this.name;
         }
+        if (this.renderedLikeHoisted) {
+            return this.renderedLikeHoisted.getName(getPropertyAccess, useOriginalName);
+        }
         const name = this.renderName || this.name;
         return this.renderBaseName ? `${this.renderBaseName}${getPropertyAccess(name)}` : name;
     }
@@ -3395,6 +3401,14 @@ class Variable extends ExpressionEntity {
      */
     include() {
         this.included = true;
+        this.renderedLikeHoisted?.include();
+    }
+    /**
+     * Links the rendered name of this variable to another variable and includes
+     * this variable if the other variable is included.
+     */
+    renderLikeHoisted(variable) {
+        this.renderedLikeHoisted = variable;
     }
     markCalledFromTryStatement() { }
     setRenderNames(baseName, name) {
@@ -3420,10 +3434,8 @@ class ExternalVariable extends Variable {
         return type !== INTERACTION_ACCESSED || path.length > (this.isNamespace ? 1 : 0);
     }
     include() {
-        if (!this.included) {
-            this.included = true;
-            this.module.used = true;
-        }
+        super.include();
+        this.module.used = true;
     }
 }
 
@@ -6944,6 +6956,7 @@ class ArrayPattern extends NodeBase {
 const ArrowFunctionExpression$1 = 'ArrowFunctionExpression';
 const BlockStatement$1 = 'BlockStatement';
 const CallExpression$1 = 'CallExpression';
+const CatchClause$1 = 'CatchClause';
 const ExpressionStatement$1 = 'ExpressionStatement';
 const Identifier$1 = 'Identifier';
 const Program$1 = 'Program';
@@ -6951,7 +6964,7 @@ const Property$1 = 'Property';
 const ReturnStatement$1 = 'ReturnStatement';
 
 class LocalVariable extends Variable {
-    constructor(name, declarator, init, context) {
+    constructor(name, declarator, init, context, kind) {
         super(name);
         this.init = init;
         this.calledFromTryStatement = false;
@@ -6960,6 +6973,7 @@ class LocalVariable extends Variable {
         this.declarations = declarator ? [declarator] : [];
         this.deoptimizationTracker = context.deoptimizationTracker;
         this.module = context.module;
+        this.kind = kind;
     }
     addDeclaration(identifier, init) {
         this.declarations.push(identifier);
@@ -6986,15 +7000,13 @@ class LocalVariable extends Variable {
             return;
         }
         if (path.length === 0) {
-            if (!this.isReassigned) {
-                this.isReassigned = true;
-                const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
-                this.expressionsToBeDeoptimized = EMPTY_ARRAY;
-                for (const expression of expressionsToBeDeoptimized) {
-                    expression.deoptimizeCache();
-                }
-                this.init.deoptimizePath(UNKNOWN_PATH);
+            this.isReassigned = true;
+            const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
+            this.expressionsToBeDeoptimized = EMPTY_ARRAY;
+            for (const expression of expressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
             }
+            this.init.deoptimizePath(UNKNOWN_PATH);
         }
         else {
             this.init.deoptimizePath(path);
@@ -7046,7 +7058,7 @@ class LocalVariable extends Variable {
     }
     include() {
         if (!this.included) {
-            this.included = true;
+            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)
@@ -7086,19 +7098,6 @@ class LocalVariable extends Variable {
         }
         return this.additionalInitializers;
     }
-    mergeDeclarations(variable) {
-        const { declarations } = this;
-        for (const declaration of variable.declarations) {
-            declarations.push(declaration);
-        }
-        const additionalInitializers = this.markInitializersForDeoptimization();
-        additionalInitializers.push(variable.init);
-        if (variable.additionalInitializers) {
-            for (const initializer of variable.additionalInitializers) {
-                additionalInitializers.push(initializer);
-            }
-        }
-    }
 }
 
 const MAX_TRACKED_INTERACTIONS = 20;
@@ -7108,7 +7107,7 @@ 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);
+        super(name, declarator, UNKNOWN_EXPRESSION, context, "parameter" /* VariableKind.parameter */);
         this.deoptimizationInteractions = [];
         this.deoptimizations = new PathTracker();
         this.deoptimizedFields = new Set();
@@ -7216,22 +7215,42 @@ class Scope {
         this.children = [];
         this.variables = new Map();
     }
-    addDeclaration(identifier, context, init, _isHoisted) {
+    /*
+    Redeclaration rules:
+    - var can redeclare 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;
-        let variable = this.variables.get(name);
-        if (variable) {
-            variable.addDeclaration(identifier, init);
-        }
-        else {
-            variable = new LocalVariable(identifier.name, identifier, init || UNDEFINED_EXPRESSION, context);
-            this.variables.set(name, variable);
+        const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+        if (existingVariable) {
+            const existingKind = existingVariable.kind;
+            if ((kind === "var" /* VariableKind.var */ &&
+                (existingKind === "var" /* VariableKind.var */ || existingKind === "parameter" /* VariableKind.parameter */)) ||
+                (kind === "function" /* VariableKind.function */ && existingKind === "parameter" /* VariableKind.parameter */)) {
+                existingVariable.addDeclaration(identifier, init);
+                return existingVariable;
+            }
+            context.error(parseAst_js.logRedeclarationError(name), identifier.start);
         }
-        return variable;
+        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');
     }
 }
@@ -7239,9 +7258,9 @@ class Scope {
 class ChildScope extends Scope {
     constructor(parent, context) {
         super();
-        this.accessedOutsideVariables = new Map();
         this.parent = parent;
         this.context = context;
+        this.accessedOutsideVariables = new Map();
         parent.children.push(this);
     }
     addAccessedDynamicImport(importExpression) {
@@ -7319,26 +7338,89 @@ class ChildScope extends Scope {
     }
 }
 
-class ParameterScope extends ChildScope {
+class CatchBodyScope extends ChildScope {
     constructor(parent, context) {
+        super(parent, context);
+        this.parent = parent;
+        this.context = context;
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === "var" /* VariableKind.var */) {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                const existingKind = existingVariable.kind;
+                if (existingKind === "parameter" /* VariableKind.parameter */ &&
+                    // If this is a destructured parameter, it is forbidden to redeclare
+                    existingVariable.declarations[0].parent.type === CatchClause$1) {
+                    // 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" /* VariableKind.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;
+        }
+        // Functions can never re-declare catch parameters
+        if (kind === "function" /* VariableKind.function */) {
+            const name = identifier.name;
+            if (this.hoistedVariables?.get(name)) {
+                context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+            }
+        }
+        return super.addDeclaration(identifier, context, init, kind);
+    }
+}
+
+class ParameterScope extends ChildScope {
+    constructor(parent, context, isCatchScope) {
         super(parent, context);
         this.parameters = [];
         this.hasRest = false;
-        this.hoistedBodyVarScope = new ChildScope(this, context);
+        this.bodyScope = isCatchScope
+            ? new CatchBodyScope(this, context)
+            : new ChildScope(this, 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 } = identifier;
-        const variable = new ParameterVariable(name, identifier, this.context);
-        const localVariable = this.hoistedBodyVarScope.variables.get(name);
-        if (localVariable) {
-            this.hoistedBodyVarScope.variables.set(name, variable);
-            variable.mergeDeclarations(localVariable);
+        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) {
@@ -8522,26 +8604,26 @@ class Identifier extends NodeBase {
         let variable;
         const { treeshake } = this.scope.context.options;
         switch (kind) {
-            case 'var': {
-                variable = this.scope.addDeclaration(this, this.scope.context, init, true);
+            case "var" /* VariableKind.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': {
+            case "function" /* VariableKind.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, false);
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
                 break;
             }
-            case 'let':
-            case 'const':
-            case 'class': {
-                variable = this.scope.addDeclaration(this, this.scope.context, init, false);
+            case "let" /* VariableKind.let */:
+            case "const" /* VariableKind.const */:
+            case "class" /* VariableKind.class */: {
+                variable = this.scope.addDeclaration(this, this.scope.context, init, kind);
                 break;
             }
-            case 'parameter': {
+            case "parameter" /* VariableKind.parameter */: {
                 variable = this.scope.addParameterDeclaration(this);
                 break;
             }
@@ -8551,13 +8633,15 @@ class Identifier extends NodeBase {
                 throw new Error(`Internal Error: Unexpected identifier kind ${kind}.`);
             }
         }
-        variable.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);
@@ -8572,7 +8656,7 @@ class Identifier extends NodeBase {
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        if (this.isPossibleTDZ() && this.variable.kind !== 'var') {
+        if (this.isPossibleTDZ() && this.variable.kind !== "var" /* VariableKind.var */) {
             return true;
         }
         return (this.scope.context.options.treeshake
@@ -8663,6 +8747,9 @@ class Identifier extends NodeBase {
             }
         }
     }
+    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) {
@@ -8838,17 +8925,26 @@ function removeLineBreaks(code, start, end) {
 }
 
 class BlockScope extends ChildScope {
-    addDeclaration(identifier, context, init, isHoisted) {
-        if (isHoisted) {
-            const variable = this.parent.addDeclaration(identifier, context, init, isHoisted);
+    addDeclaration(identifier, context, init, kind) {
+        if (kind === "var" /* VariableKind.var */) {
+            const name = identifier.name;
+            const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
+            if (existingVariable) {
+                if (existingVariable.kind === "var" /* VariableKind.var */) {
+                    existingVariable.addDeclaration(identifier, init);
+                    return existingVariable;
+                }
+                return context.error(parseAst_js.logRedeclarationError(name), identifier.start);
+            }
+            const declaredVariable = this.parent.addDeclaration(identifier, context, init, kind);
             // Necessary to make sure the init is deoptimized for conditional declarations.
             // We cannot call deoptimizePath here.
-            variable.markInitializersForDeoptimization();
-            return variable;
-        }
-        else {
-            return super.addDeclaration(identifier, context, init, false);
+            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);
     }
 }
 
@@ -9086,7 +9182,6 @@ class FunctionBase extends NodeBase {
         this.scope.includeCallArguments(context, parameters);
     }
     initialise() {
-        this.scope.addParameterVariables(this.params.map(parameter => parameter.declare('parameter', UNKNOWN_EXPRESSION)), this.params[this.params.length - 1] instanceof RestElement);
         if (this.body instanceof BlockStatement) {
             this.body.addImplicitReturnExpressionToScope();
         }
@@ -9095,9 +9190,18 @@ class FunctionBase extends NodeBase {
         }
     }
     parseNode(esTreeNode) {
-        if (esTreeNode.body.type === BlockStatement$1) {
-            this.body = new BlockStatement(esTreeNode.body, this, this.scope.hoistedBodyVarScope);
-        }
+        const { body, params } = esTreeNode;
+        const parameters = (this.params = []);
+        const { scope } = this;
+        const { bodyScope, context } = scope;
+        // We need to ensure that parameters are declared before the body is parsed
+        // so that the scope already knows all parameters and can detect conflicts
+        // when parsing the body.
+        for (const parameter of params) {
+            parameters.push(new (context.getNodeConstructor(parameter.type))(parameter, this, scope, false));
+        }
+        scope.addParameterVariables(parameters.map(parameter => parameter.declare("parameter" /* VariableKind.parameter */, UNKNOWN_EXPRESSION)), parameters[parameters.length - 1] instanceof RestElement);
+        this.body = new (context.getNodeConstructor(body.type))(body, this, bodyScope);
         super.parseNode(esTreeNode);
     }
     addArgumentToBeDeoptimized(_argument) { }
@@ -9111,7 +9215,7 @@ class ArrowFunctionExpression extends FunctionBase {
         this.objectEntity = null;
     }
     createScope(parentScope) {
-        this.scope = new ReturnValueScope(parentScope, this.scope.context);
+        this.scope = new ReturnValueScope(parentScope, this.scope.context, false);
     }
     hasEffects() {
         if (!this.deoptimized)
@@ -9355,7 +9459,7 @@ class AssignmentPattern extends NodeBase {
 
 class ArgumentsVariable extends LocalVariable {
     constructor(context) {
-        super('arguments', null, UNKNOWN_EXPRESSION, context);
+        super('arguments', null, UNKNOWN_EXPRESSION, context, "other" /* VariableKind.other */);
         this.deoptimizedArguments = [];
     }
     addArgumentToBeDeoptimized(argument) {
@@ -9389,7 +9493,7 @@ class ThisVariable extends ParameterVariable {
 
 class FunctionScope extends ReturnValueScope {
     constructor(parent, context) {
-        super(parent, context);
+        super(parent, context, false);
         this.variables.set('arguments', (this.argumentsVariable = new ArgumentsVariable(context)));
         this.variables.set('this', (this.thisVariable = new ThisVariable(context)));
     }
@@ -9477,7 +9581,7 @@ class FunctionNode extends FunctionBase {
     }
     initialise() {
         super.initialise();
-        this.id?.declare('function', this);
+        this.id?.declare("function" /* VariableKind.function */, this);
     }
     addArgumentToBeDeoptimized(argument) {
         this.scope.argumentsVariable.addArgumentToBeDeoptimized(argument);
@@ -10202,37 +10306,22 @@ class CallExpression extends CallExpressionBase {
     }
 }
 
-class CatchScope extends ParameterScope {
-    addDeclaration(identifier, context, init, isHoisted) {
-        const existingParameter = this.variables.get(identifier.name);
-        if (existingParameter) {
-            // While we still create a hoisted declaration, the initializer goes to
-            // the parameter. Note that technically, the declaration now belongs to
-            // two variables, which is not correct but should not cause issues.
-            this.parent.addDeclaration(identifier, context, UNDEFINED_EXPRESSION, isHoisted);
-            existingParameter.addDeclaration(identifier, init);
-            return existingParameter;
-        }
-        return this.parent.addDeclaration(identifier, context, init, isHoisted);
-    }
-}
-
 class CatchClause extends NodeBase {
     createScope(parentScope) {
-        this.scope = new CatchScope(parentScope, this.scope.context);
+        this.scope = new ParameterScope(parentScope, this.scope.context, true);
     }
     parseNode(esTreeNode) {
-        // Parameters need to be declared first as the logic is that initializers
-        // of hoisted body variables are associated with parameters of the same
-        // name instead of the variable
-        const { param } = esTreeNode;
+        const { body, param, type } = esTreeNode;
+        this.type = type;
         if (param) {
             this.param = new (this.scope.context.getNodeConstructor(param.type))(param, this, this.scope);
-            this.param.declare('parameter', UNKNOWN_EXPRESSION);
+            this.param.declare("parameter" /* VariableKind.parameter */, UNKNOWN_EXPRESSION);
         }
+        this.body = new BlockStatement(body, this, this.scope.bodyScope);
         super.parseNode(esTreeNode);
     }
 }
+CatchClause.prototype.preventChildBlockScope = true;
 
 class ChainExpression extends NodeBase {
     // deoptimizations are not relevant as we are not caching values
@@ -10255,7 +10344,7 @@ class ChainExpression extends NodeBase {
 class ClassBodyScope extends ChildScope {
     constructor(parent, classNode, context) {
         super(parent, context);
-        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, context)));
+        this.variables.set('this', (this.thisVariable = new LocalVariable('this', null, classNode, context, "other" /* VariableKind.other */)));
         this.instanceScope = new ChildScope(this, context);
         this.instanceScope.variables.set('this', new ThisVariable(context));
     }
@@ -10439,7 +10528,7 @@ class ClassNode extends NodeBase {
         }
     }
     initialise() {
-        this.id?.declare('class', this);
+        this.id?.declare("class" /* VariableKind.class */, this);
         for (const method of this.body.body) {
             if (method instanceof MethodDefinition && method.kind === 'constructor') {
                 this.classConstructor = method;
@@ -11079,9 +11168,9 @@ class TrackingScope extends BlockScope {
         super(...arguments);
         this.hoistedDeclarations = [];
     }
-    addDeclaration(identifier, context, init, isHoisted) {
+    addDeclaration(identifier, context, init, kind) {
         this.hoistedDeclarations.push(identifier);
-        return super.addDeclaration(identifier, context, init, isHoisted);
+        return super.addDeclaration(identifier, context, init, kind);
     }
 }
 
@@ -12807,7 +12896,7 @@ class UndefinedVariable extends Variable {
 
 class ExportDefaultVariable extends LocalVariable {
     constructor(name, exportDefaultDeclaration, context) {
-        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context);
+        super(name, exportDefaultDeclaration, exportDefaultDeclaration.declaration, context, "other" /* VariableKind.other */);
         this.hasId = false;
         this.originalId = null;
         this.originalVariable = null;
@@ -12878,7 +12967,13 @@ class ExportDefaultVariable extends LocalVariable {
 class ModuleScope extends ChildScope {
     constructor(parent, context) {
         super(parent, context);
-        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, context));
+        this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, context, "other" /* VariableKind.other */));
+    }
+    addDeclaration(identifier, context, init, kind) {
+        if (this.context.module.importDescriptions.has(identifier.name)) {
+            context.error(parseAst_js.logRedeclarationError(identifier.name), identifier.start);
+        }
+        return super.addDeclaration(identifier, context, init, kind);
     }
     addExportDefaultDeclaration(name, exportDefaultDeclaration, context) {
         const variable = new ExportDefaultVariable(name, exportDefaultDeclaration, context);
@@ -13475,7 +13570,7 @@ class NamespaceVariable extends Variable {
             memberVariable.hasEffectsOnInteractionAtPath(path.slice(1), interaction, context));
     }
     include() {
-        this.included = true;
+        super.include();
         this.context.includeAllExports();
     }
     prepare(accessedGlobalsByScope) {
@@ -13569,7 +13664,7 @@ class SyntheticNamedExportVariable extends Variable {
         return `${this.syntheticNamespace.getName(getPropertyAccess)}${getPropertyAccess(this.name)}`;
     }
     include() {
-        this.included = true;
+        super.include();
         this.context.includeVariableInModule(this.syntheticNamespace);
     }
     setRenderNames(baseName, name) {
@@ -14171,7 +14266,7 @@ class Module {
         const removedExports = [];
         for (const exportName of this.exports.keys()) {
             const [variable] = this.getVariableForExportName(exportName);
-            (variable && variable.included ? renderedExports : removedExports).push(exportName);
+            (variable?.included ? renderedExports : removedExports).push(exportName);
         }
         return { removedExports, renderedExports };
     }
@@ -14268,6 +14363,9 @@ class Module {
         for (const exportName of this.exports.keys()) {
             if (includeNamespaceMembers || exportName !== this.info.syntheticNamedExports) {
                 const variable = this.getVariableForExportName(exportName)[0];
+                if (!variable) {
+                    return parseAst_js.error(parseAst_js.logMissingEntryExport(exportName, this.id));
+                }
                 variable.deoptimizePath(UNKNOWN_PATH);
                 if (!variable.included) {
                     this.includeVariable(variable);
@@ -14505,9 +14603,15 @@ class Module {
         }
         this.dynamicImports.push({ argument, id: null, node, resolution: null });
     }
+    assertUniqueExportName(name, nodeStart) {
+        if (this.exports.has(name) || this.reexportDescriptions.has(name)) {
+            this.error(parseAst_js.logDuplicateExportError(name), nodeStart);
+        }
+    }
     addExport(node) {
         if (node instanceof ExportDefaultDeclaration) {
             // export default foo;
+            this.assertUniqueExportName('default', node.start);
             this.exports.set('default', {
                 identifier: node.variable.getAssignedVariableName(),
                 localName: 'default'
@@ -14519,6 +14623,7 @@ class Module {
             if (node.exported) {
                 // export * as name from './other'
                 const name = node.exported.name;
+                this.assertUniqueExportName(name, node.exported.start);
                 this.reexportDescriptions.set(name, {
                     localName: '*',
                     module: null,
@@ -14537,6 +14642,7 @@ class Module {
             this.addSource(source, node);
             for (const { exported, local, start } of node.specifiers) {
                 const name = exported instanceof Literal ? exported.value : exported.name;
+                this.assertUniqueExportName(name, start);
                 this.reexportDescriptions.set(name, {
                     localName: local instanceof Literal ? local.value : local.name,
                     module: null,
@@ -14552,6 +14658,7 @@ class Module {
                 // export var foo = 1, bar = 2;
                 for (const declarator of declaration.declarations) {
                     for (const localName of extractAssignedNames(declarator.id)) {
+                        this.assertUniqueExportName(localName, declarator.id.start);
                         this.exports.set(localName, { identifier: null, localName });
                     }
                 }
@@ -14559,6 +14666,7 @@ class Module {
             else {
                 // export function foo () {}
                 const localName = declaration.id.name;
+                this.assertUniqueExportName(localName, declaration.id.start);
                 this.exports.set(localName, { identifier: null, localName });
             }
         }
@@ -14568,6 +14676,7 @@ class Module {
                 // except for reexports, local must be an Identifier
                 const localName = local.name;
                 const exportedName = exported instanceof Identifier ? exported.name : exported.value;
+                this.assertUniqueExportName(exportedName, exported.start);
                 this.exports.set(exportedName, { identifier: null, localName });
             }
         }
@@ -14576,6 +14685,10 @@ class Module {
         const source = node.source.value;
         this.addSource(source, node);
         for (const specifier of node.specifiers) {
+            const localName = specifier.local.name;
+            if (this.scope.variables.has(localName) || this.importDescriptions.has(localName)) {
+                this.error(parseAst_js.logRedeclarationError(localName), specifier.local.start);
+            }
             const name = specifier instanceof ImportDefaultSpecifier
                 ? 'default'
                 : specifier instanceof ImportNamespaceSpecifier
@@ -14583,7 +14696,7 @@ class Module {
                     : specifier.imported instanceof Identifier
                         ? specifier.imported.name
                         : specifier.imported.value;
-            this.importDescriptions.set(specifier.local.name, {
+            this.importDescriptions.set(localName, {
                 module: null,
                 name,
                 source,