@rollup/wasm-node 4.55.3 → 4.56.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.55.3
-	Wed, 21 Jan 2026 05:27:01 GMT - commit 6764d548225c5fe11be33a1e286a01eb6e71f843
+	Rollup.js v4.56.0
+	Thu, 22 Jan 2026 05:37:20 GMT - commit 1cbac18d9fb153db123d8f266947c5a5acfa387f
 
 	https://github.com/rollup/rollup
 
@@ -42,7 +42,7 @@ function _mergeNamespaces(n, m) {
 
 const promises__namespace = /*#__PURE__*/_interopNamespaceDefault(promises);
 
-var version = "4.55.3";
+var version = "4.56.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -6816,15 +6816,15 @@ function isCallExpressionNode(node) {
 function isMemberExpressionNode(node) {
     return node instanceof NodeBase && node.type === parseAst_js.MemberExpression;
 }
-function isImportExpressionNode(node) {
-    return node instanceof NodeBase && node.type === parseAst_js.ImportExpression;
-}
 function isAwaitExpressionNode(node) {
     return node instanceof NodeBase && node.type === parseAst_js.AwaitExpression;
 }
 function isIdentifierNode(node) {
     return node instanceof NodeBase && node.type === parseAst_js.Identifier;
 }
+function isExpressionStatementNode(node) {
+    return node instanceof NodeBase && node.type === parseAst_js.ExpressionStatement;
+}
 
 function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
     return Object.create(inheritedDescriptions, memberDescriptions);
@@ -8982,21 +8982,6 @@ class LocalVariable extends Variable {
                         break;
                     node = node.parent;
                 }
-                /**
-                 * import('foo').then(m => {
-                 *   console.log(m.foo)
-                 * })
-                 */
-                if (this.kind === 'parameter' &&
-                    (isArrowFunctionExpressionNode(declaration.parent) ||
-                        isFunctionExpressionNode(declaration.parent)) &&
-                    isCallExpressionNode(declaration.parent.parent) &&
-                    isMemberExpressionNode(declaration.parent.parent.callee) &&
-                    isIdentifierNode(declaration.parent.parent.callee.property) &&
-                    declaration.parent.parent.callee.property.name === 'then' &&
-                    isImportExpressionNode(declaration.parent.parent.callee.object)) {
-                    declaration.parent.parent.callee.object.includePath(path, context);
-                }
             }
             // We need to make sure we include the correct path of the init
             if (path.length > 0) {
@@ -11144,6 +11129,7 @@ function getStringFromPath(path) {
 class MemberExpression extends NodeBase {
     constructor() {
         super(...arguments);
+        this.promiseHandler = null;
         this.variable = null;
         this.expressionsToBeDeoptimized = [];
     }
@@ -11199,7 +11185,10 @@ class MemberExpression extends NodeBase {
         }
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
-        if (this.variable) {
+        if (this.promiseHandler) {
+            this.promiseHandler.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
+        }
+        else if (this.variable) {
             this.variable.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
         }
         else if (!this.isUndefined) {
@@ -11389,25 +11378,14 @@ class MemberExpression extends NodeBase {
         this.property.include(context, includeChildrenRecursively);
     }
     includeCallArguments(interaction, context) {
-        if (this.variable) {
+        if (this.promiseHandler) {
+            this.promiseHandler.includeCallArguments(interaction, context);
+        }
+        else if (this.variable) {
             this.variable.includeCallArguments(interaction, context);
         }
         else {
-            if (isImportExpressionNode(this.object) ||
-                /**
-                 * const c = await import('foo')
-                 * c.foo();
-                 */
-                (this.object.variable &&
-                    !this.object.variable.isReassigned &&
-                    this.object.variable instanceof LocalVariable &&
-                    isAwaitExpressionNode(this.object.variable.init) &&
-                    isImportExpressionNode(this.object.variable.init.argument))) {
-                includeInteractionWithoutThis(interaction, context);
-            }
-            else {
-                includeInteraction(interaction, context);
-            }
+            includeInteraction(interaction, context);
         }
     }
     includeDestructuredIfNecessary() {
@@ -11455,7 +11433,7 @@ class MemberExpression extends NodeBase {
         // Namespaces are not bound and should not be deoptimized
         this.bound &&
             propertyReadSideEffects &&
-            !(this.variable || this.isUndefined)) {
+            !(this.variable || this.isUndefined || this.promiseHandler)) {
             this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [this.propertyKey], SHARED_RECURSION_TRACKER);
             this.scope.context.requestTreeshakingPass();
         }
@@ -11763,8 +11741,9 @@ class ExportDefaultVariable extends LocalVariable {
 class NamespaceVariable extends Variable {
     constructor(context) {
         super(context.getModuleName());
-        this.memberVariables = null;
+        this.areAllMembersDeoptimized = false;
         this.mergedNamespaces = [];
+        this.nonExplicitNamespacesIncluded = false;
         this.referencedEarly = false;
         this.references = [];
         this.context = context;
@@ -11778,7 +11757,10 @@ class NamespaceVariable extends Variable {
         if (path.length > 1 || (path.length === 1 && interaction.type === INTERACTION_CALLED)) {
             const key = path[0];
             if (typeof key === 'string') {
-                this.getMemberVariables()[key]?.deoptimizeArgumentsOnInteractionAtPath(interaction, path.slice(1), recursionTracker);
+                this.module
+                    .getExportedVariablesByName()
+                    .get(key)
+                    ?.deoptimizeArgumentsOnInteractionAtPath(interaction, path.slice(1), recursionTracker);
             }
             else {
                 deoptimizeInteraction(interaction);
@@ -11789,7 +11771,13 @@ class NamespaceVariable extends Variable {
         if (path.length > 1) {
             const key = path[0];
             if (typeof key === 'string') {
-                this.getMemberVariables()[key]?.deoptimizePath(path.slice(1));
+                this.module.getExportedVariablesByName().get(key)?.deoptimizePath(path.slice(1));
+            }
+            else if (!this.areAllMembersDeoptimized) {
+                this.areAllMembersDeoptimized = true;
+                for (const variable of this.module.getExportedVariablesByName().values()) {
+                    variable.deoptimizePath(UNKNOWN_PATH);
+                }
             }
         }
     }
@@ -11799,22 +11787,6 @@ class NamespaceVariable extends Variable {
         }
         return UnknownValue;
     }
-    getMemberVariables() {
-        if (this.memberVariables) {
-            return this.memberVariables;
-        }
-        const memberVariables = Object.create(null);
-        const sortedExports = [...this.context.getExports(), ...this.context.getReexports()].sort();
-        for (const name of sortedExports) {
-            if (name[0] !== '*' && name !== this.module.info.syntheticNamedExports) {
-                const [exportedVariable] = this.context.traceExport(name);
-                if (exportedVariable) {
-                    memberVariables[name] = exportedVariable;
-                }
-            }
-        }
-        return (this.memberVariables = memberVariables);
-    }
     hasEffectsOnInteractionAtPath(path, interaction, context) {
         const { type } = interaction;
         if (path.length === 0) {
@@ -11828,13 +11800,31 @@ class NamespaceVariable extends Variable {
         if (typeof key !== 'string') {
             return true;
         }
-        const memberVariable = this.getMemberVariables()[key];
+        const memberVariable = this.module.getExportedVariablesByName().get(key);
         return (!memberVariable ||
             memberVariable.hasEffectsOnInteractionAtPath(path.slice(1), interaction, context));
     }
     includePath(path, context) {
         super.includePath(path, context);
-        this.context.includeAllExports();
+        this.includeMemberPath(path, context);
+    }
+    includeMemberPath(path, context) {
+        if (path.length > 0) {
+            const [name, ...remainingPath] = path;
+            if (typeof name === 'string') {
+                const variable = this.module.getExportedVariablesByName().get(name);
+                if (variable) {
+                    this.context.includeVariableInModule(variable, remainingPath, context);
+                }
+                else {
+                    this.includeNonExplicitNamespaces();
+                }
+            }
+            else if (name) {
+                this.module.includeAllExports();
+                this.includeNonExplicitNamespaces();
+            }
+        }
     }
     prepare(accessedGlobalsByScope) {
         if (this.mergedNamespaces.length > 0) {
@@ -11843,9 +11833,9 @@ class NamespaceVariable extends Variable {
     }
     renderBlock(options) {
         const { exportNamesByVariable, format, freeze, indent: t, symbols, snippets: { _, cnst, getObject, getPropertyAccess, n, s } } = options;
-        const memberVariables = this.getMemberVariables();
-        const members = Object.entries(memberVariables)
-            .filter(([_, variable]) => variable.included)
+        const memberVariables = this.module.getExportedVariablesByName();
+        const members = [...memberVariables.entries()]
+            .filter(([name, variable]) => !name.startsWith('*') && variable.included)
             .map(([name, variable]) => {
             if (this.referencedEarly || variable.isReassigned || variable === this) {
                 return [
@@ -11891,8 +11881,22 @@ class NamespaceVariable extends Variable {
             }
         }
     }
+    includeNonExplicitNamespaces() {
+        if (!this.nonExplicitNamespacesIncluded) {
+            this.nonExplicitNamespacesIncluded = true;
+            this.setMergedNamespaces(this.module.includeAndGetAdditionalMergedNamespaces());
+        }
+    }
 }
 NamespaceVariable.prototype.isNamespace = true;
+// This is a proxy that does not include the namespace object when a path is included
+const getDynamicNamespaceVariable = (namespace) => Object.create(namespace, {
+    includePath: {
+        value(path, context) {
+            namespace.includeMemberPath(path, context);
+        }
+    }
+});
 
 class SyntheticNamedExportVariable extends Variable {
     constructor(context, name, syntheticNamespace) {
@@ -11928,7 +11932,7 @@ class SyntheticNamedExportVariable extends Variable {
     }
     includePath(path, context) {
         super.includePath(path, context);
-        this.context.includeVariableInModule(this.syntheticNamespace, path, context);
+        this.context.includeVariableInModule(this.syntheticNamespace, [this.name, ...path], context);
     }
     setRenderNames(baseName, name) {
         super.setRenderNames(baseName, name);
@@ -13442,6 +13446,9 @@ class AssignmentPattern extends NodeBase {
 }
 
 class AwaitExpression extends NodeBase {
+    deoptimizePath(path) {
+        this.argument.deoptimizePath(path);
+    }
     hasEffects() {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -13844,11 +13851,10 @@ class CallExpression extends CallExpressionBase {
             this.callee.includeCallArguments(this.interaction, context);
         }
     }
-    includeNode(context) {
+    includeNode(_context) {
         this.included = true;
         if (!this.deoptimized)
             this.applyDeoptimizations();
-        this.callee.includePath(UNKNOWN_PATH, context);
     }
     initialise() {
         super.initialise();
@@ -14706,95 +14712,41 @@ class ImportDefaultSpecifier extends NodeBase {
 ImportDefaultSpecifier.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
 ImportDefaultSpecifier.prototype.applyDeoptimizations = doNotDeoptimize;
 
-function isReassignedExportsMember(variable, exportNamesByVariable) {
-    return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
-}
-
-class VariableDeclarator extends NodeBase {
-    declareDeclarator(kind) {
-        this.isUsingDeclaration = kind === 'using';
-        this.isAsyncUsingDeclaration = kind === 'await using';
-        this.id.declare(kind, EMPTY_PATH, this.init || UNDEFINED_EXPRESSION);
-    }
-    deoptimizePath(path) {
-        this.id.deoptimizePath(path);
-    }
-    hasEffects(context) {
-        const initEffect = this.init?.hasEffects(context);
-        this.id.markDeclarationReached();
-        return (initEffect ||
-            this.isUsingDeclaration ||
-            this.isAsyncUsingDeclaration ||
-            this.id.hasEffects(context) ||
-            (this.scope.context.options.treeshake
-                .propertyReadSideEffects &&
-                this.id.hasEffectsWhenDestructuring(context, EMPTY_PATH, this.init || UNDEFINED_EXPRESSION)));
+class ObjectPromiseHandler {
+    constructor(resolvedVariable) {
+        this.interaction = {
+            args: [null, resolvedVariable],
+            type: INTERACTION_CALLED,
+            withNew: false
+        };
     }
-    include(context, includeChildrenRecursively) {
-        const { id, init } = this;
-        if (!this.included)
-            this.includeNode(context);
-        init?.include(context, includeChildrenRecursively);
-        id.markDeclarationReached();
-        if (includeChildrenRecursively) {
-            id.include(context, includeChildrenRecursively);
-        }
-        else {
-            id.includeDestructuredIfNecessary(context, EMPTY_PATH, init || UNDEFINED_EXPRESSION);
+    deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
+        deoptimizeInteraction(interaction);
+        if (interaction.type === INTERACTION_CALLED &&
+            path.length === 0 &&
+            (isFunctionExpressionNode(interaction.args[1]) ||
+                isArrowFunctionExpressionNode(interaction.args[1]))) {
+            interaction.args[1].deoptimizeArgumentsOnInteractionAtPath(this.interaction, [], recursionTracker);
         }
     }
-    removeAnnotations(code) {
-        this.init?.removeAnnotations(code);
-    }
-    render(code, options) {
-        const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
-        const { end, id, init, start } = this;
-        const renderId = id.included || this.isUsingDeclaration || this.isAsyncUsingDeclaration;
-        if (renderId) {
-            id.render(code, options);
-        }
-        else {
-            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', id.end);
-            code.remove(start, findNonWhiteSpace(code.original, operatorPos + 1));
-        }
-        if (init) {
-            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
-                const renderedVariable = id.variable.getName(getPropertyAccess);
-                if (renderedVariable !== id.name) {
-                    code.appendLeft(init.start + 5, ` ${id.name}`);
-                }
-            }
-            init.render(code, options, renderId ? parseAst_js.BLANK : { renderedSurroundingElement: parseAst_js.ExpressionStatement });
-        }
-        else if (id instanceof Identifier &&
-            isReassignedExportsMember(id.variable, exportNamesByVariable)) {
-            code.appendLeft(end, `${_}=${_}void 0`);
+    includeCallArguments(interaction, context) {
+        // This includes the function call itself
+        includeInteractionWithoutThis(interaction, context);
+        if (interaction.type === INTERACTION_CALLED &&
+            (isFunctionExpressionNode(interaction.args[1]) ||
+                isArrowFunctionExpressionNode(interaction.args[1]))) {
+            interaction.args[1].includeCallArguments(this.interaction, context);
         }
     }
-    includeNode(context) {
-        this.included = true;
-        const { id, init } = this;
-        if (init) {
-            if (this.isUsingDeclaration) {
-                init.includePath(SYMBOL_DISPOSE_PATH, context);
-            }
-            else if (this.isAsyncUsingDeclaration) {
-                init.includePath(SYMBOL_ASYNC_DISPOSE_PATH, context);
-            }
-            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
-                const { name, variable } = id;
-                for (const accessedVariable of init.scope.accessedOutsideVariables.values()) {
-                    if (accessedVariable !== variable) {
-                        accessedVariable.forbidName(name);
-                    }
-                }
-            }
-        }
+}
+class EmptyPromiseHandler {
+    deoptimizeArgumentsOnInteractionAtPath(interaction) {
+        deoptimizeInteraction(interaction);
+    }
+    includeCallArguments(interaction, context) {
+        includeInteractionWithoutThis(interaction, context);
     }
 }
-VariableDeclarator.prototype.applyDeoptimizations = doNotDeoptimize;
-const SYMBOL_DISPOSE_PATH = [SymbolDispose];
-const SYMBOL_ASYNC_DISPOSE_PATH = [SymbolAsyncDispose];
 
 function getChunkInfoWithPath(chunk) {
     return { fileName: chunk.getFileName(), ...chunk.getPreRenderedChunkInfo() };
@@ -14803,12 +14755,11 @@ class ImportExpression extends NodeBase {
     constructor() {
         super(...arguments);
         this.inlineNamespace = null;
-        this.hasUnknownAccessedKey = false;
-        this.accessedPropKey = new Set();
+        this.resolution = null;
         this.attributes = null;
         this.mechanism = null;
         this.namespaceExportName = undefined;
-        this.resolution = null;
+        this.localResolution = null;
         this.resolutionString = null;
     }
     get shouldIncludeDynamicAttributes() {
@@ -14818,84 +14769,65 @@ class ImportExpression extends NodeBase {
         this.flags = setFlag(this.flags, 268435456 /* Flag.shouldIncludeDynamicAttributes */, value);
     }
     bind() {
-        this.source.bind();
-        this.options?.bind();
-    }
-    /**
-     * Get imported variables for deterministic usage, valid cases are:
-     *
-     * 1. `const { foo } = await import('bar')`.
-     * 2. `(await import('bar')).foo`
-     * 3. `import('bar').then(({ foo }) => {})`
-     *
-     * Returns empty array if it's side-effect only import.
-     * Returns undefined if it's not fully deterministic.
-     */
-    getDeterministicImportedNames() {
-        const parent1 = this.parent;
-        // Side-effect only: import('bar')
-        if (parent1 instanceof ExpressionStatement) {
-            return parseAst_js.EMPTY_ARRAY;
-        }
-        if (parent1 instanceof AwaitExpression) {
-            const parent2 = parent1.parent;
-            // Side effect only: await import('bar')
-            if (parent2 instanceof ExpressionStatement) {
-                return parseAst_js.EMPTY_ARRAY;
-            }
-            // Case 1: const { foo } / module = await import('bar')
-            if (parent2 instanceof VariableDeclarator) {
-                const declaration = parent2.id;
-                if (declaration instanceof Identifier) {
-                    return this.hasUnknownAccessedKey ? undefined : [...this.accessedPropKey];
-                }
-                if (declaration instanceof ObjectPattern) {
-                    return getDeterministicObjectDestructure(declaration);
-                }
-            }
-            // Case 2: (await import('bar')).foo
-            if (parent2 instanceof MemberExpression) {
-                const id = parent2.property;
-                if (!parent2.computed && id instanceof Identifier) {
-                    return [id.name];
-                }
-            }
+        const { options, parent, resolution, source } = this;
+        source.bind();
+        options?.bind();
+        // Check if we resolved to a Module without using instanceof
+        if (typeof resolution !== 'object' || !resolution || !('namespace' in resolution)) {
             return;
         }
-        if (parent1 instanceof MemberExpression) {
-            const callExpression = parent1.parent;
-            const property = parent1.property;
-            if (!(callExpression instanceof CallExpression) || !(property instanceof Identifier)) {
-                return;
-            }
-            const memberName = property.name;
-            // side-effect only, when only chaining .catch or .finally
-            if (callExpression.parent instanceof ExpressionStatement &&
-                ['catch', 'finally'].includes(memberName)) {
-                return parseAst_js.EMPTY_ARRAY;
-            }
-            if (memberName !== 'then')
-                return;
-            // Side-effect only: import('bar').then()
-            if (callExpression.arguments.length === 0) {
-                return parseAst_js.EMPTY_ARRAY;
-            }
-            const thenCallback = callExpression.arguments[0];
-            if (callExpression.arguments.length !== 1 ||
-                !(thenCallback instanceof ArrowFunctionExpression ||
-                    thenCallback instanceof FunctionExpression)) {
-                return;
+        // In these cases, we can track exactly what is included or deoptimized:
+        // * import('foo'); // as statement
+        // * await import('foo') // use as awaited expression in any way
+        // * import('foo').then(n => {...}) // only if .then is called directly on the import()
+        if (isExpressionStatementNode(parent) || isAwaitExpressionNode(parent)) {
+            this.localResolution = { resolution, tracked: true };
+            return;
+        }
+        if (!isMemberExpressionNode(parent)) {
+            this.localResolution = { resolution, tracked: false };
+            return;
+        }
+        let currentParent = parent;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let callExpression = this;
+        while (true) {
+            if (currentParent.computed ||
+                currentParent.object !== callExpression ||
+                !isIdentifierNode(currentParent.property) ||
+                !isCallExpressionNode(currentParent.parent)) {
+                break;
             }
-            // Side-effect only: import('bar').then(() => {})
-            if (thenCallback.params.length === 0) {
-                return parseAst_js.EMPTY_ARRAY;
+            const propertyName = currentParent.property.name;
+            callExpression = currentParent.parent;
+            if (propertyName === 'then') {
+                const firstArgument = callExpression.arguments[0];
+                if (firstArgument === undefined ||
+                    isFunctionExpressionNode(firstArgument) ||
+                    isArrowFunctionExpressionNode(firstArgument)) {
+                    currentParent.promiseHandler = new ObjectPromiseHandler(getDynamicNamespaceVariable(resolution.namespace));
+                    this.localResolution = { resolution, tracked: true };
+                    return;
+                }
             }
-            const declaration = thenCallback.params[0];
-            if (thenCallback.params.length === 1 && declaration instanceof ObjectPattern) {
-                return getDeterministicObjectDestructure(declaration);
+            else if (propertyName === 'catch' || propertyName === 'finally') {
+                if (isMemberExpressionNode(callExpression.parent)) {
+                    currentParent.promiseHandler = new EmptyPromiseHandler();
+                    currentParent = callExpression.parent;
+                    continue;
+                }
+                if (isExpressionStatementNode(callExpression.parent)) {
+                    currentParent.promiseHandler = new EmptyPromiseHandler();
+                    this.localResolution = { resolution, tracked: true };
+                    return;
+                }
             }
-            return this.hasUnknownAccessedKey ? undefined : [...this.accessedPropKey];
+            break;
         }
+        this.localResolution = { resolution, tracked: false };
+    }
+    deoptimizePath(path) {
+        this.localResolution?.resolution?.namespace.deoptimizePath(path);
     }
     hasEffects() {
         return true;
@@ -14904,30 +14836,31 @@ class ImportExpression extends NodeBase {
         if (!this.included)
             this.includeNode(context);
         this.source.include(context, includeChildrenRecursively);
-        if (this.shouldIncludeDynamicAttributes)
+        if (this.shouldIncludeDynamicAttributes) {
             this.options?.include(context, includeChildrenRecursively);
+        }
     }
     includeNode(context) {
         this.included = true;
-        if (this.shouldIncludeDynamicAttributes)
+        const { localResolution, scope, shouldIncludeDynamicAttributes } = this;
+        if (shouldIncludeDynamicAttributes) {
             this.options?.includePath(UNKNOWN_PATH, context);
-        this.scope.context.includeDynamicImport(this);
-        this.scope.addAccessedDynamicImport(this);
+        }
+        scope.context.includeDynamicImport(this);
+        scope.addAccessedDynamicImport(this);
+        if (localResolution) {
+            if (localResolution.tracked) {
+                localResolution.resolution.includeModuleInExecution();
+            }
+            else {
+                localResolution.resolution.includeAllExports();
+            }
+        }
     }
     includePath(path, context) {
         if (!this.included)
             this.includeNode(context);
-        // Technically, this is not correct as dynamic imports return a Promise.
-        if (this.hasUnknownAccessedKey)
-            return;
-        if (path[0] === UnknownKey) {
-            this.hasUnknownAccessedKey = true;
-        }
-        else if (typeof path[0] === 'string') {
-            this.accessedPropKey.add(path[0]);
-        }
-        // Update included paths
-        this.scope.context.includeDynamicImport(this);
+        this.localResolution?.resolution?.namespace.includeMemberPath(path, context);
     }
     initialise() {
         super.initialise();
@@ -14977,16 +14910,15 @@ class ImportExpression extends NodeBase {
             }
         }
     }
-    setExternalResolution(exportMode, resolution, options, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, namespaceExportName, attributes, ownChunk, targetChunk) {
+    setExternalResolution(exportMode, options, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, namespaceExportName, attributes, ownChunk, targetChunk) {
         const { format } = options;
         this.inlineNamespace = null;
-        this.resolution = resolution;
         this.resolutionString = resolutionString;
         this.namespaceExportName = namespaceExportName;
         this.attributes = attributes;
         const accessedGlobals = [...(accessedImportGlobals[format] || [])];
         let helper;
-        ({ helper, mechanism: this.mechanism } = this.getDynamicImportMechanismAndHelper(resolution, exportMode, options, snippets, pluginDriver, ownChunk, targetChunk));
+        ({ helper, mechanism: this.mechanism } = this.getDynamicImportMechanismAndHelper(exportMode, options, snippets, pluginDriver, ownChunk, targetChunk));
         if (helper) {
             accessedGlobals.push(helper);
         }
@@ -14997,11 +14929,12 @@ class ImportExpression extends NodeBase {
     setInternalResolution(inlineNamespace) {
         this.inlineNamespace = inlineNamespace;
     }
-    getDynamicImportMechanismAndHelper(resolution, exportMode, { compact, dynamicImportInCjs, format, generatedCode: { arrowFunctions }, interop }, { _, getDirectReturnFunction, getDirectReturnIifeLeft }, pluginDriver, ownChunk, targetChunk) {
+    getDynamicImportMechanismAndHelper(exportMode, { compact, dynamicImportInCjs, format, generatedCode: { arrowFunctions }, interop }, { _, getDirectReturnFunction, getDirectReturnIifeLeft }, pluginDriver, ownChunk, targetChunk) {
+        const { resolution, scope } = this;
         const mechanism = pluginDriver.hookFirstSync('renderDynamicImport', [
             {
                 chunk: getChunkInfoWithPath(ownChunk),
-                customResolution: typeof this.resolution === 'string' ? this.resolution : null,
+                customResolution: typeof resolution === 'string' ? resolution : null,
                 format,
                 getTargetChunkImports() {
                     if (targetChunk === null)
@@ -15028,15 +14961,15 @@ class ImportExpression extends NodeBase {
                     }
                     return chunkInfos;
                 },
-                moduleId: this.scope.context.module.id,
+                moduleId: scope.context.module.id,
                 targetChunk: targetChunk ? getChunkInfoWithPath(targetChunk) : null,
-                targetModuleId: this.resolution && typeof this.resolution !== 'string' ? this.resolution.id : null
+                targetModuleId: resolution && typeof resolution !== 'string' ? resolution.id : null
             }
         ]);
         if (mechanism) {
             return { helper: null, mechanism };
         }
-        const hasDynamicTarget = !this.resolution || typeof this.resolution === 'string';
+        const hasDynamicTarget = !resolution || typeof resolution === 'string';
         switch (format) {
             case 'cjs': {
                 if (dynamicImportInCjs &&
@@ -15126,15 +15059,6 @@ const accessedImportGlobals = {
     cjs: ['require'],
     system: ['module']
 };
-function getDeterministicObjectDestructure(objectPattern) {
-    const variables = [];
-    for (const property of objectPattern.properties) {
-        if (property.type === 'RestElement' || property.computed || property.key.type !== 'Identifier')
-            return;
-        variables.push(property.key.name);
-    }
-    return variables;
-}
 
 class ImportNamespaceSpecifier extends NodeBase {
 }
@@ -16129,7 +16053,7 @@ ObjectExpression.prototype.applyDeoptimizations = doNotDeoptimize;
 
 class PanicError extends NodeBase {
     initialise() {
-        const id = this.scope.context.module.id;
+        const { id } = this.scope.context.module;
         // This simulates the current nested error structure. We could also just
         // replace it with a flat error.
         const parseError = parseAst_js.getRollupError(parseAst_js.logParseError(this.message));
@@ -16141,7 +16065,7 @@ class PanicError extends NodeBase {
 class ParseError extends NodeBase {
     initialise() {
         const pos = this.start;
-        const id = this.scope.context.module.id;
+        const { id } = this.scope.context.module;
         // This simulates the current nested error structure. We could also just
         // replace it with a flat error.
         const parseError = parseAst_js.getRollupError(parseAst_js.logParseError(this.message, pos));
@@ -16600,9 +16524,6 @@ class TaggedTemplateExpression extends CallExpressionBase {
     set hasCheckedForWarnings(value) {
         this.flags = setFlag(this.flags, 134217728 /* Flag.checkedForWarnings */, value);
     }
-    bind() {
-        super.bind();
-    }
     hasEffects(context) {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -16722,12 +16643,13 @@ class TemplateLiteral extends NodeBase {
 }
 
 class ModuleScope extends ChildScope {
-    constructor(parent, context) {
+    constructor(parent, context, importDescriptions) {
         super(parent, context);
+        this.importDescriptions = importDescriptions;
         this.variables.set('this', new LocalVariable('this', null, UNDEFINED_EXPRESSION, EMPTY_PATH, context, 'other'));
     }
     addDeclaration(identifier, context, init, destructuredInitPath, kind) {
-        if (this.context.module.importDescriptions.has(identifier.name)) {
+        if (this.importDescriptions.has(identifier.name)) {
             context.error(parseAst_js.logRedeclarationError(identifier.name), identifier.start);
         }
         return super.addDeclaration(identifier, context, init, destructuredInitPath, kind);
@@ -17039,6 +16961,10 @@ class UpdateExpression extends NodeBase {
 }
 UpdateExpression.prototype.includeNode = onlyIncludeSelf;
 
+function isReassignedExportsMember(variable, exportNamesByVariable) {
+    return (variable.renderBaseName !== null && exportNamesByVariable.has(variable) && variable.isReassigned);
+}
+
 class VariableDeclaration extends NodeBase {
     deoptimizePath() {
         for (const declarator of this.declarations) {
@@ -17224,6 +17150,92 @@ function gatherSystemExportsAndGetSingleExport(separatedNodes, options, aggregat
 VariableDeclaration.prototype.includeNode = onlyIncludeSelfNoDeoptimize;
 VariableDeclaration.prototype.applyDeoptimizations = doNotDeoptimize;
 
+class VariableDeclarator extends NodeBase {
+    declareDeclarator(kind) {
+        this.isUsingDeclaration = kind === 'using';
+        this.isAsyncUsingDeclaration = kind === 'await using';
+        this.id.declare(kind, EMPTY_PATH, this.init || UNDEFINED_EXPRESSION);
+    }
+    deoptimizePath(path) {
+        this.id.deoptimizePath(path);
+    }
+    hasEffects(context) {
+        const initEffect = this.init?.hasEffects(context);
+        this.id.markDeclarationReached();
+        return (initEffect ||
+            this.isUsingDeclaration ||
+            this.isAsyncUsingDeclaration ||
+            this.id.hasEffects(context) ||
+            (this.scope.context.options.treeshake
+                .propertyReadSideEffects &&
+                this.id.hasEffectsWhenDestructuring(context, EMPTY_PATH, this.init || UNDEFINED_EXPRESSION)));
+    }
+    include(context, includeChildrenRecursively) {
+        const { id, init } = this;
+        if (!this.included)
+            this.includeNode(context);
+        init?.include(context, includeChildrenRecursively);
+        id.markDeclarationReached();
+        if (includeChildrenRecursively) {
+            id.include(context, includeChildrenRecursively);
+        }
+        else {
+            id.includeDestructuredIfNecessary(context, EMPTY_PATH, init || UNDEFINED_EXPRESSION);
+        }
+    }
+    removeAnnotations(code) {
+        this.init?.removeAnnotations(code);
+    }
+    render(code, options) {
+        const { exportNamesByVariable, snippets: { _, getPropertyAccess } } = options;
+        const { end, id, init, start } = this;
+        const renderId = id.included || this.isUsingDeclaration || this.isAsyncUsingDeclaration;
+        if (renderId) {
+            id.render(code, options);
+        }
+        else {
+            const operatorPos = findFirstOccurrenceOutsideComment(code.original, '=', id.end);
+            code.remove(start, findNonWhiteSpace(code.original, operatorPos + 1));
+        }
+        if (init) {
+            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+                const renderedVariable = id.variable.getName(getPropertyAccess);
+                if (renderedVariable !== id.name) {
+                    code.appendLeft(init.start + 5, ` ${id.name}`);
+                }
+            }
+            init.render(code, options, renderId ? parseAst_js.BLANK : { renderedSurroundingElement: parseAst_js.ExpressionStatement });
+        }
+        else if (id instanceof Identifier &&
+            isReassignedExportsMember(id.variable, exportNamesByVariable)) {
+            code.appendLeft(end, `${_}=${_}void 0`);
+        }
+    }
+    includeNode(context) {
+        this.included = true;
+        const { id, init } = this;
+        if (init) {
+            if (this.isUsingDeclaration) {
+                init.includePath(SYMBOL_DISPOSE_PATH, context);
+            }
+            else if (this.isAsyncUsingDeclaration) {
+                init.includePath(SYMBOL_ASYNC_DISPOSE_PATH, context);
+            }
+            if (id instanceof Identifier && init instanceof ClassExpression && !init.id) {
+                const { name, variable } = id;
+                for (const accessedVariable of init.scope.accessedOutsideVariables.values()) {
+                    if (accessedVariable !== variable) {
+                        accessedVariable.forbidName(name);
+                    }
+                }
+            }
+        }
+    }
+}
+VariableDeclarator.prototype.applyDeoptimizations = doNotDeoptimize;
+const SYMBOL_DISPOSE_PATH = [SymbolDispose];
+const SYMBOL_ASYNC_DISPOSE_PATH = [SymbolAsyncDispose];
+
 class WhileStatement extends NodeBase {
     hasEffects(context) {
         if (this.test.hasEffects(context))
@@ -18504,27 +18516,26 @@ class Module {
         this.needsExportShim = false;
         this.sideEffectDependenciesByVariable = new Map();
         this.sourcesWithAttributes = new Map();
-        this.allExportNames = null;
         this.allExportsIncluded = false;
         this.ast = null;
         this.exportAllModules = [];
         this.exportAllSources = new Set();
+        this.exportDescriptions = new Map();
+        this.exportedVariablesByName = null;
         this.exportNamesByVariable = null;
         this.exportShimVariable = new ExportShimVariable(this);
-        this.exports = new Map();
         this.namespaceReexportsByName = new Map();
         this.reexportDescriptions = new Map();
         this.relevantDependencies = null;
         this.syntheticExports = new Map();
         this.syntheticNamespace = null;
         this.transformDependencies = [];
-        this.transitiveReexports = null;
         this.excludeFromSourcemap = /\0/.test(id);
         this.context = options.moduleContext(id);
         this.preserveSignature = this.options.preserveEntrySignatures;
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const module = this;
-        const { dynamicImports, dynamicImporters, exportAllSources, exports: exports$1, implicitlyLoadedAfter, implicitlyLoadedBefore, importers, reexportDescriptions, sourcesWithAttributes } = this;
+        const { dynamicImports, dynamicImporters, exportAllSources, exportDescriptions, implicitlyLoadedAfter, implicitlyLoadedBefore, importers, reexportDescriptions, sourcesWithAttributes } = this;
         this.info = {
             ast: null,
             attributes,
@@ -18543,7 +18554,7 @@ class Module {
                 return dynamicImporters.sort();
             },
             get exportedBindings() {
-                const exportBindings = { '.': [...exports$1.keys()] };
+                const exportBindings = { '.': [...exportDescriptions.keys()] };
                 for (const [name, { source }] of reexportDescriptions) {
                     (exportBindings[source] ??= []).push(name);
                 }
@@ -18554,7 +18565,7 @@ class Module {
             },
             get exports() {
                 return [
-                    ...exports$1.keys(),
+                    ...exportDescriptions.keys(),
                     ...reexportDescriptions.keys(),
                     ...[...exportAllSources].map(() => '*')
                 ];
@@ -18564,7 +18575,7 @@ class Module {
                 if (!module.ast) {
                     return null;
                 }
-                return module.exports.has('default') || reexportDescriptions.has('default');
+                return module.exportDescriptions.has('default') || reexportDescriptions.has('default');
             },
             id,
             get implicitlyLoadedAfterOneOf() {
@@ -18637,28 +18648,6 @@ class Module {
         }
         return size;
     }
-    getAllExportNames() {
-        if (this.allExportNames) {
-            return this.allExportNames;
-        }
-        this.allExportNames = new Set([...this.exports.keys(), ...this.reexportDescriptions.keys()]);
-        for (const module of this.exportAllModules) {
-            if (module instanceof ExternalModule) {
-                this.allExportNames.add(`*${module.id}`);
-                continue;
-            }
-            for (const name of module.getAllExportNames()) {
-                if (name !== 'default')
-                    this.allExportNames.add(name);
-            }
-        }
-        // We do not count the synthetic namespace as a regular export to hide it
-        // from entry signatures and namespace objects
-        if (typeof this.info.syntheticNamedExports === 'string') {
-            this.allExportNames.delete(this.info.syntheticNamedExports);
-        }
-        return this.allExportNames;
-    }
     getDependenciesToBeIncluded() {
         if (this.relevantDependencies)
             return this.relevantDependencies;
@@ -18670,10 +18659,9 @@ class Module {
             this.includedDynamicImporters.length > 0 ||
             this.namespace.included ||
             this.implicitlyLoadedAfter.size > 0) {
-            for (const exportName of [...this.getReexports(), ...this.getExports()]) {
-                const [exportedVariable] = this.getVariableForExportName(exportName);
-                if (exportedVariable?.included) {
-                    dependencyVariables.add(exportedVariable);
+            for (const variable of this.getExportedVariablesByName().values()) {
+                if (variable.included) {
+                    dependencyVariables.add(variable);
                 }
             }
         }
@@ -18705,18 +18693,56 @@ class Module {
         }
         return this.relevantDependencies;
     }
+    getExportedVariablesByName() {
+        if (this.exportedVariablesByName) {
+            return this.exportedVariablesByName;
+        }
+        const exportedVariablesByName = (this.exportedVariablesByName = new Map());
+        for (const name of this.exportDescriptions.keys()) {
+            // We do not count the synthetic namespace as a regular export to hide it
+            // from entry signatures and namespace objects
+            if (name !== this.info.syntheticNamedExports) {
+                const [exportedVariable] = this.getVariableForExportName(name);
+                if (exportedVariable) {
+                    exportedVariablesByName.set(name, exportedVariable);
+                }
+                else {
+                    return parseAst_js.error(parseAst_js.logMissingEntryExport(name, this.id));
+                }
+            }
+        }
+        for (const name of this.reexportDescriptions.keys()) {
+            const [exportedVariable] = this.getVariableForExportName(name);
+            if (exportedVariable) {
+                exportedVariablesByName.set(name, exportedVariable);
+            }
+        }
+        for (const module of this.exportAllModules) {
+            if (module instanceof ExternalModule) {
+                exportedVariablesByName.set(`*${module.id}`, module.getVariableForExportName('*', {
+                    importChain: [this.id]
+                })[0]);
+                continue;
+            }
+            for (const name of module.getExportedVariablesByName().keys()) {
+                if (name !== 'default' && !exportedVariablesByName.has(name)) {
+                    const [exportedVariable] = this.getVariableForExportName(name);
+                    if (exportedVariable) {
+                        exportedVariablesByName.set(name, exportedVariable);
+                    }
+                }
+            }
+        }
+        return (this.exportedVariablesByName = new Map([...exportedVariablesByName].sort(sortExportedVariables)));
+    }
     getExportNamesByVariable() {
         if (this.exportNamesByVariable) {
             return this.exportNamesByVariable;
         }
         const exportNamesByVariable = new Map();
-        for (const exportName of this.getAllExportNames()) {
-            let [tracedVariable] = this.getVariableForExportName(exportName);
-            if (tracedVariable instanceof ExportDefaultVariable) {
-                tracedVariable = tracedVariable.getOriginalVariable();
-            }
-            if (!tracedVariable ||
-                !(tracedVariable.included || tracedVariable instanceof ExternalVariable)) {
+        for (const [exportName, variable] of this.getExportedVariablesByName().entries()) {
+            const tracedVariable = variable instanceof ExportDefaultVariable ? variable.getOriginalVariable() : variable;
+            if (!variable || !(variable.included || variable instanceof ExternalVariable)) {
                 continue;
             }
             const existingExportNames = exportNamesByVariable.get(tracedVariable);
@@ -18729,36 +18755,14 @@ class Module {
         }
         return (this.exportNamesByVariable = exportNamesByVariable);
     }
-    getExports() {
-        return [...this.exports.keys()];
-    }
-    getReexports() {
-        if (this.transitiveReexports) {
-            return this.transitiveReexports;
-        }
-        // to avoid infinite recursion when using circular `export * from X`
-        this.transitiveReexports = [];
-        const reexports = new Set(this.reexportDescriptions.keys());
-        for (const module of this.exportAllModules) {
-            if (module instanceof ExternalModule) {
-                reexports.add(`*${module.id}`);
-            }
-            else {
-                for (const name of [...module.getReexports(), ...module.getExports()]) {
-                    if (name !== 'default')
-                        reexports.add(name);
-                }
-            }
-        }
-        return (this.transitiveReexports = [...reexports]);
-    }
     getRenderedExports() {
         // only direct exports are counted here, not reexports at all
         const renderedExports = [];
         const removedExports = [];
-        for (const exportName of this.exports.keys()) {
-            const [variable] = this.getVariableForExportName(exportName);
-            (variable?.included ? renderedExports : removedExports).push(exportName);
+        for (const exportName of this.exportDescriptions.keys()) {
+            (this.getExportedVariablesByName().get(exportName)?.included
+                ? renderedExports
+                : removedExports).push(exportName);
         }
         return { removedExports, renderedExports };
     }
@@ -18801,7 +18805,7 @@ class Module {
             }
             return [variable];
         }
-        const exportDeclaration = this.exports.get(name);
+        const exportDeclaration = this.exportDescriptions.get(name);
         if (exportDeclaration) {
             if (exportDeclaration === MISSING_EXPORT_SHIM_DESCRIPTION) {
                 return [this.exportShimVariable];
@@ -18852,63 +18856,29 @@ class Module {
         if (this.ast.shouldBeIncluded(context))
             this.ast.include(context, false);
     }
-    includeAllExports(includeNamespaceMembers) {
-        if (includeNamespaceMembers) {
-            this.namespace.setMergedNamespaces(this.includeAndGetAdditionalMergedNamespaces());
-        }
+    includeAllExports() {
         if (this.allExportsIncluded)
             return;
         this.allExportsIncluded = true;
-        if (!this.isExecuted) {
-            markModuleAndImpureDependenciesAsExecuted(this);
-            this.graph.needsTreeshakingPass = true;
-        }
+        this.includeModuleInExecution();
         const inclusionContext = createInclusionContext();
-        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));
-                }
-                this.includeVariable(variable, UNKNOWN_PATH, inclusionContext);
-                variable.deoptimizePath(UNKNOWN_PATH);
-            }
-        }
-        for (const name of this.getReexports()) {
-            const [variable] = this.getVariableForExportName(name);
-            if (variable) {
-                variable.deoptimizePath(UNKNOWN_PATH);
-                this.includeVariable(variable, UNKNOWN_PATH, inclusionContext);
-                if (variable instanceof ExternalVariable) {
-                    variable.module.reexported = true;
-                }
+        for (const variable of this.getExportedVariablesByName().values()) {
+            this.includeVariable(variable, UNKNOWN_PATH, inclusionContext);
+            variable.deoptimizePath(UNKNOWN_PATH);
+            if (variable instanceof ExternalVariable) {
+                variable.module.reexported = true;
             }
         }
     }
     includeAllInBundle() {
         this.ast.include(createInclusionContext(), true);
-        this.includeAllExports(false);
+        this.includeAllExports();
     }
-    includeExportsByNames(names) {
+    includeModuleInExecution() {
         if (!this.isExecuted) {
             markModuleAndImpureDependenciesAsExecuted(this);
             this.graph.needsTreeshakingPass = true;
         }
-        let includeNamespaceMembers = false;
-        const inclusionContext = createInclusionContext();
-        for (const name of names) {
-            const variable = this.getVariableForExportName(name)[0];
-            if (variable) {
-                variable.deoptimizePath(UNKNOWN_PATH);
-                this.includeVariable(variable, UNKNOWN_PATH, inclusionContext);
-            }
-            if (!this.exports.has(name) && !this.reexportDescriptions.has(name)) {
-                includeNamespaceMembers = true;
-            }
-        }
-        if (includeNamespaceMembers) {
-            this.namespace.setMergedNamespaces(this.includeAndGetAdditionalMergedNamespaces());
-        }
     }
     isIncluded() {
         // Modules where this.ast is missing have been loaded via this.load and are
@@ -18987,14 +18957,11 @@ class Module {
             deoptimizationTracker: this.graph.deoptimizationTracker,
             error: this.error.bind(this),
             fileName, // Needed for warnings
-            getExports: this.getExports.bind(this),
             getImportedJsxFactoryVariable: this.getImportedJsxFactoryVariable.bind(this),
             getModuleExecIndex: () => this.execIndex,
             getModuleName: this.basename.bind(this),
             getNodeConstructor: (name) => nodeConstructors[name] || nodeConstructors.UnknownNode,
-            getReexports: this.getReexports.bind(this),
             importDescriptions: this.importDescriptions,
-            includeAllExports: () => this.includeAllExports(true),
             includeDynamicImport: this.includeDynamicImport.bind(this),
             includeVariableInModule: this.includeVariableInModule.bind(this),
             log: this.log.bind(this),
@@ -19009,7 +18976,7 @@ class Module {
             traceVariable: this.traceVariable.bind(this),
             usesTopLevelAwait: false
         };
-        this.scope = new ModuleScope(this.graph.scope, this.astContext);
+        this.scope = new ModuleScope(this.graph.scope, this.astContext, this.importDescriptions);
         this.namespace = new NamespaceVariable(this.astContext);
         const programParent = { context: this.astContext, type: 'Module' };
         if (ast) {
@@ -19110,10 +19077,10 @@ class Module {
             typeof argument.value === 'string') {
             argument = argument.value;
         }
-        this.dynamicImports.push({ argument, id: null, node, resolution: null });
+        this.dynamicImports.push({ argument, id: null, node });
     }
     assertUniqueExportName(name, nodeStart) {
-        if (this.exports.has(name) || this.reexportDescriptions.has(name)) {
+        if (this.exportDescriptions.has(name) || this.reexportDescriptions.has(name)) {
             this.error(parseAst_js.logDuplicateExportError(name), nodeStart);
         }
     }
@@ -19121,7 +19088,7 @@ class Module {
         if (node instanceof ExportDefaultDeclaration) {
             // export default foo;
             this.assertUniqueExportName('default', node.start);
-            this.exports.set('default', {
+            this.exportDescriptions.set('default', {
                 identifier: node.variable.getAssignedVariableName(),
                 localName: 'default'
             });
@@ -19168,7 +19135,7 @@ class Module {
                 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 });
+                        this.exportDescriptions.set(localName, { identifier: null, localName });
                     }
                 }
             }
@@ -19176,7 +19143,7 @@ class Module {
                 // export function foo () {}
                 const localName = declaration.id.name;
                 this.assertUniqueExportName(localName, declaration.id.start);
-                this.exports.set(localName, { identifier: null, localName });
+                this.exportDescriptions.set(localName, { identifier: null, localName });
             }
         }
         else {
@@ -19186,7 +19153,7 @@ class Module {
                 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 });
+                this.exportDescriptions.set(exportedName, { identifier: null, localName });
             }
         }
     }
@@ -19360,7 +19327,7 @@ class Module {
         return [...syntheticNamespaces, ...externalNamespaces];
     }
     includeDynamicImport(node) {
-        const resolution = this.dynamicImports.find(dynamicImport => dynamicImport.node === node).resolution;
+        const { resolution } = node;
         if (resolution instanceof Module) {
             if (!resolution.includedDynamicImporters.includes(this)) {
                 resolution.includedDynamicImporters.push(this);
@@ -19370,15 +19337,6 @@ class Module {
                     resolution.includedTopLevelAwaitingDynamicImporters.add(this);
                 }
             }
-            const importedNames = this.options.treeshake
-                ? node.getDeterministicImportedNames()
-                : undefined;
-            if (importedNames) {
-                resolution.includeExportsByNames(importedNames);
-            }
-            else {
-                resolution.includeAllExports(true);
-            }
         }
     }
     includeVariable(variable, path, context) {
@@ -19388,21 +19346,17 @@ class Module {
             if (variableModule instanceof Module && variableModule !== this) {
                 getAndExtendSideEffectModules(variable, this);
             }
+            return;
         }
-        else {
-            this.graph.needsTreeshakingPass = true;
-            if (variableModule instanceof Module) {
-                if (!variableModule.isExecuted) {
-                    markModuleAndImpureDependenciesAsExecuted(variableModule);
-                }
-                if (variableModule !== this) {
-                    const sideEffectModules = getAndExtendSideEffectModules(variable, this);
-                    for (const module of sideEffectModules) {
-                        if (!module.isExecuted) {
-                            markModuleAndImpureDependenciesAsExecuted(module);
-                        }
-                    }
-                }
+        this.graph.needsTreeshakingPass = true;
+        if (!(variableModule instanceof Module)) {
+            return;
+        }
+        variableModule.includeModuleInExecution();
+        if (variableModule !== this) {
+            const sideEffectModules = getAndExtendSideEffectModules(variable, this);
+            for (const module of sideEffectModules) {
+                module.includeModuleInExecution();
             }
         }
     }
@@ -19415,7 +19369,7 @@ class Module {
     }
     shimMissingExport(name) {
         this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logShimmedExport(this.id, name));
-        this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
+        this.exportDescriptions.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
     }
     tryParse() {
         try {
@@ -19445,6 +19399,7 @@ function setAlternativeExporterIfCyclic(variable, importer, reexporter) {
 }
 const copyNameToModulesMap = (searchedNamesAndModules) => searchedNamesAndModules &&
     new Map(Array.from(searchedNamesAndModules, ([name, modules]) => [name, new Set(modules)]));
+const sortExportedVariables = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
 
 const concatSeparator = (out, next) => (next ? `${out}\n${next}` : out);
 const concatDblSeparator = (out, next) => (next ? `${out}\n\n${next}` : out);
@@ -19827,6 +19782,8 @@ class Chunk {
                         includedNamespaces.add(module);
                         this.exports.add(module.namespace);
                     }
+                    // This only needs to run once
+                    break;
                 }
             }
             if (module.implicitlyLoadedAfter.size > 0) {
@@ -20464,10 +20421,11 @@ class Chunk {
         }
         const includedDynamicImports = [];
         for (const module of this.orderedModules) {
-            for (const { node, resolution } of module.dynamicImports) {
+            for (const { node } of module.dynamicImports) {
                 if (!node.included) {
                     continue;
                 }
+                const { resolution } = node;
                 includedDynamicImports.push(resolution instanceof Module
                     ? {
                         chunk: this.chunkByModule.get(resolution),
@@ -20725,13 +20683,13 @@ class Chunk {
                     node.setInternalResolution(resolution.namespace);
                 }
                 else {
-                    node.setExternalResolution((facadeChunk || chunk).exportMode, resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, `'${(facadeChunk || chunk).getImportPath(fileName)}'`, !facadeChunk?.strictFacade && chunk.exportNamesByVariable.get(resolution.namespace)[0], null, this, facadeChunk || chunk);
+                    node.setExternalResolution((facadeChunk || chunk).exportMode, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, `'${(facadeChunk || chunk).getImportPath(fileName)}'`, !facadeChunk?.strictFacade && chunk.exportNamesByVariable.get(resolution.namespace)[0], null, this, facadeChunk || chunk);
                 }
             }
             else {
                 const { node, resolution } = resolvedDynamicImport;
                 const [resolutionString, attributes] = this.getDynamicImportStringAndAttributes(resolution, fileName, node);
-                node.setExternalResolution('external', resolution, outputOptions, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, false, attributes, this, null);
+                node.setExternalResolution('external', outputOptions, snippets, pluginDriver, accessedGlobalsByScope, resolutionString, false, attributes, this, null);
             }
         }
     }
@@ -20784,8 +20742,7 @@ class Chunk {
         // when we are not preserving modules, we need to make all namespace variables available for
         // rendering the namespace object
         if (!this.outputOptions.preserveModules && this.includedNamespaces.has(module)) {
-            const memberVariables = module.namespace.getMemberVariables();
-            for (const variable of Object.values(memberVariables)) {
+            for (const variable of module.getExportedVariablesByName().values()) {
                 if (variable.included) {
                     moduleImports.add(variable);
                 }
@@ -20816,8 +20773,8 @@ class Chunk {
             module.includedDynamicImporters.some(importer => this.chunkByModule.get(importer) !== this)) {
             this.ensureReexportsAreAvailableForModule(module);
         }
-        for (const { node, resolution } of module.dynamicImports) {
-            if (node.included &&
+        for (const { node: { included, resolution } } of module.dynamicImports) {
+            if (included &&
                 resolution instanceof Module &&
                 this.chunkByModule.get(resolution) === this &&
                 !this.includedNamespaces.has(resolution)) {
@@ -21048,7 +21005,7 @@ function analyzeModuleGraph(entries) {
                     staticDependencies.add(dependency);
                 }
             }
-            for (const { resolution } of module.dynamicImports) {
+            for (const { node: { resolution } } of module.dynamicImports) {
                 if (resolution instanceof Module &&
                     resolution.includedDynamicImporters.length > 0 &&
                     !allEntriesSet.has(resolution)) {
@@ -21589,9 +21546,9 @@ function analyseModuleExecution(entryModules) {
             for (const dependency of module.implicitlyLoadedBefore) {
                 dynamicImports.add(dependency);
             }
-            for (const { resolution, node } of module.dynamicImports) {
+            for (const { node: { resolution, scope } } of module.dynamicImports) {
                 if (resolution instanceof Module) {
-                    if (node.scope.context.usesTopLevelAwait) {
+                    if (scope.context.usesTopLevelAwait) {
                         handleSyncLoadedModule(resolution, module);
                     }
                     else {
@@ -22743,14 +22700,14 @@ class ModuleLoader {
         return loadNewModulesPromise;
     }
     async fetchDynamicDependencies(module, resolveDynamicImportPromises) {
-        const dependencies = await Promise.all(resolveDynamicImportPromises.map(resolveDynamicImportPromise => resolveDynamicImportPromise.then(async ([dynamicImport, resolvedId]) => {
+        const dependencies = await Promise.all(resolveDynamicImportPromises.map(resolveDynamicImportPromise => resolveDynamicImportPromise.then(async ([{ node }, resolvedId]) => {
             if (resolvedId === null)
                 return null;
             if (typeof resolvedId === 'string') {
-                dynamicImport.resolution = resolvedId;
+                node.resolution = resolvedId;
                 return null;
             }
-            return (dynamicImport.resolution = await this.fetchResolvedDependency(parseAst_js.relativeId(resolvedId.id), module.id, resolvedId));
+            return (node.resolution = await this.fetchResolvedDependency(parseAst_js.relativeId(resolvedId.id), module.id, resolvedId));
         })));
         for (const dependency of dependencies) {
             if (dependency) {
@@ -23132,7 +23089,7 @@ class Graph {
         timeEnd('generate module graph', 2);
         timeStart('sort and bind modules', 2);
         this.phase = BuildPhase.ANALYSE;
-        this.sortModules();
+        this.sortAndBindModules();
         timeEnd('sort and bind modules', 2);
         timeStart('mark included statements', 2);
         this.includeStatements();
@@ -23205,7 +23162,7 @@ class Graph {
                     // the TDZ detection logic
                     for (const module of entryModules) {
                         if (module.preserveSignature !== false) {
-                            module.includeAllExports(false);
+                            module.includeAllExports();
                             this.needsTreeshakingPass = true;
                         }
                     }
@@ -23227,7 +23184,7 @@ class Graph {
             }
         }
     }
-    sortModules() {
+    sortAndBindModules() {
         const { orderedModules, cyclePaths } = analyseModuleExecution(this.entryModules);
         for (const cyclePath of cyclePaths) {
             this.options.onLog(parseAst_js.LOGLEVEL_WARN, parseAst_js.logCircularDependency(cyclePath));