@rollup/wasm-node 4.55.3 → 4.57.0

package/dist/es/shared/node-entry.js

@@ -1,13 +1,13 @@
 /*
   @license
-	Rollup.js v4.55.3
-	Wed, 21 Jan 2026 05:27:01 GMT - commit 6764d548225c5fe11be33a1e286a01eb6e71f843
+	Rollup.js v4.57.0
+	Tue, 27 Jan 2026 07:16:05 GMT - commit 743d0546f59799a8f7e4e2f4e1ad167f7dae333d
 
 	https://github.com/rollup/rollup
 
 	Released under the MIT License.
 */
-import { EMPTY_OBJECT, ExportDefaultDeclaration as ExportDefaultDeclaration$1, CallExpression as CallExpression$1, EMPTY_ARRAY, LOGLEVEL_WARN, logUnusedExternalImports, ANNOTATION_KEY, INVALID_ANNOTATION_KEY, ArrowFunctionExpression as ArrowFunctionExpression$1, FunctionExpression as FunctionExpression$1, MemberExpression as MemberExpression$1, Identifier as Identifier$1, ImportExpression as ImportExpression$1, AwaitExpression as AwaitExpression$1, ObjectExpression as ObjectExpression$1, Property as Property$1, Program as Program$1, logIllegalImportReassignment, BLANK, logRedeclarationError, StaticBlock as StaticBlock$1, CatchClause as CatchClause$1, logDuplicateArgumentNameError, logModuleLevelDirective, ReturnStatement as ReturnStatement$1, VariableDeclarator as VariableDeclarator$1, ExpressionStatement as ExpressionStatement$1, logMissingExport, normalize, getImportPath, logMissingNodeBuiltins, logReservedNamespace, error, logIllegalIdentifierAsName, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, RestElement as RestElement$1, logConstVariableReassignError, EMPTY_SET, logCannotCallNamespace, logEval, BlockStatement as BlockStatement$1, getRollupError, logModuleParseError, logParseError, LOGLEVEL_INFO, logFirstSideEffect, locate, logInvalidAnnotation, logThisIsUndefined, getAstBuffer, convertAnnotations, FIXED_STRINGS, convertNode as convertNode$1, logImportAttributeIsInvalid, logImportOptionsAreInvalid, logSyntheticNamedExportsNeedNamespaceExport, logMissingEntryExport, logDuplicateExportError, logInvalidSourcemapForError, augmentCodeLocation, logInconsistentImportAttributes, logMissingJsxExport, logNamespaceConflict, logAmbiguousExternalNamespaces, logShimmedExport, parseAst, logInvalidFormatForTopLevelAwait, TemplateLiteral as TemplateLiteral$1, Literal as Literal$1, logCircularReexport, logAddonNotGenerated, logIncompatibleExportOptionValue, logMixedExport, logFailedValidation, isPathFragment, logCyclicCrossChunkReexport, getAliasName, logUnexpectedNamedImport, isAbsolute as isAbsolute$1, relative as relative$1, logUnexpectedNamespaceReexport, logEmptyChunk, logMissingGlobalName, logOptimizeChunkStatus, logSourcemapBroken, logConflictingSourcemapSources, logChunkInvalid, logInvalidOption, URL_OUTPUT_FORMAT, URL_OUTPUT_DIR, URL_OUTPUT_SOURCEMAPFILE, URL_OUTPUT_AMD_ID, logCannotAssignModuleToChunk, logCircularChunk, logAnonymousPluginCache, logDuplicatePluginName, logUnknownOption, LOGLEVEL_ERROR, logLevelPriority, LOGLEVEL_DEBUG, printQuotedStringList, logInvalidSetAssetSourceCall, logPluginError, logNoTransformMapOrAstWithoutCode, relativeId, logBadLoader, logExternalModulesCannotBeTransformedToModules, logInternalIdCannotBeExternal, isRelative, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logExternalSyntheticExports, logUnresolvedEntry, logUnresolvedImplicitDependant, logExternalModulesCannotBeIncludedInManualChunks, logEntryCannotBeExternal, logImplicitDependantCannotBeExternal, logNoAssetSourceSet, logFileReferenceIdNotFoundForFilename, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logInvalidRollupPhaseForChunkEmission, warnDeprecation, logChunkNotGeneratedForFileName, logAssetNotFinalisedForFileName, logFileNameConflict, URL_GENERATEBUNDLE, logInvalidLogPosition, logInputHookInOutputPlugin, logInvalidAddonPluginHook, logInvalidFunctionPluginHook, logImplicitDependantIsNotIncluded, logCircularDependency, augmentLogMessage, URL_JSX, URL_TREESHAKE_MODULESIDEEFFECTS, URL_TREESHAKE, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_PRESERVEENTRYSIGNATURES, URL_OUTPUT_GENERATEDCODE, isValidUrl, addTrailingSlashIfMissed, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_MANUALCHUNKS, logInvalidExportOptionValue, URL_OUTPUT_AMD_BASEPATH, URL_OUTPUT_INTEROP, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, logAlreadyClosed, logMissingFileOrDirOption, logCannotEmitFromOptionsHook, URL_WATCH } from './parseAst.js';
+import { EMPTY_OBJECT, ExportDefaultDeclaration as ExportDefaultDeclaration$1, CallExpression as CallExpression$1, EMPTY_ARRAY, LOGLEVEL_WARN, logUnusedExternalImports, ANNOTATION_KEY, INVALID_ANNOTATION_KEY, ExpressionStatement as ExpressionStatement$1, AwaitExpression as AwaitExpression$1, MemberExpression as MemberExpression$1, Identifier as Identifier$1, FunctionExpression as FunctionExpression$1, ArrowFunctionExpression as ArrowFunctionExpression$1, ObjectExpression as ObjectExpression$1, Property as Property$1, Program as Program$1, logIllegalImportReassignment, BLANK, logRedeclarationError, StaticBlock as StaticBlock$1, CatchClause as CatchClause$1, logDuplicateArgumentNameError, logModuleLevelDirective, ReturnStatement as ReturnStatement$1, VariableDeclarator as VariableDeclarator$1, logMissingExport, normalize, getImportPath, logMissingNodeBuiltins, logReservedNamespace, error, logIllegalIdentifierAsName, logMissingNameOptionForIifeExport, logMissingNameOptionForUmdExport, RestElement as RestElement$1, logConstVariableReassignError, EMPTY_SET, logCannotCallNamespace, logEval, BlockStatement as BlockStatement$1, getRollupError, logModuleParseError, logParseError, LOGLEVEL_INFO, logFirstSideEffect, locate, logInvalidAnnotation, logThisIsUndefined, getAstBuffer, convertAnnotations, FIXED_STRINGS, convertNode as convertNode$1, logImportAttributeIsInvalid, logImportOptionsAreInvalid, logMissingEntryExport, logSyntheticNamedExportsNeedNamespaceExport, logDuplicateExportError, logInvalidSourcemapForError, augmentCodeLocation, logInconsistentImportAttributes, logMissingJsxExport, logNamespaceConflict, logAmbiguousExternalNamespaces, logShimmedExport, parseAst, TemplateLiteral as TemplateLiteral$1, Literal as Literal$1, logCircularReexport, logInvalidFormatForTopLevelAwait, logAddonNotGenerated, logIncompatibleExportOptionValue, logMixedExport, logFailedValidation, isPathFragment, logCyclicCrossChunkReexport, getAliasName, logUnexpectedNamedImport, isAbsolute as isAbsolute$1, relative as relative$1, logUnexpectedNamespaceReexport, logEmptyChunk, logMissingGlobalName, logOptimizeChunkStatus, logSourcemapBroken, logConflictingSourcemapSources, logChunkInvalid, logInvalidOption, URL_OUTPUT_FORMAT, URL_OUTPUT_DIR, URL_OUTPUT_SOURCEMAPFILE, URL_OUTPUT_AMD_ID, logCannotAssignModuleToChunk, logCircularChunk, logUnknownOption, printQuotedStringList, LOGLEVEL_ERROR, logLevelPriority, LOGLEVEL_DEBUG, logAnonymousPluginCache, logDuplicatePluginName, logInvalidSetAssetSourceCall, logPluginError, logNoTransformMapOrAstWithoutCode, warnDeprecation, URL_TRANSFORM, relativeId, logBadLoader, logInternalIdCannotBeExternal, isRelative, logUnresolvedImport, logUnresolvedImportTreatedAsExternal, logExternalSyntheticExports, logUnresolvedEntry, logUnresolvedImplicitDependant, logExternalModulesCannotBeIncludedInManualChunks, logEntryCannotBeExternal, logImplicitDependantCannotBeExternal, logExternalModulesCannotBeTransformedToModules, URL_LOAD, logNoAssetSourceSet, logFileReferenceIdNotFoundForFilename, logAssetReferenceIdNotFoundForSetSource, logAssetSourceAlreadySet, logInvalidRollupPhaseForChunkEmission, logChunkNotGeneratedForFileName, logAssetNotFinalisedForFileName, logFileNameConflict, URL_GENERATEBUNDLE, logInvalidLogPosition, logInputHookInOutputPlugin, logInvalidAddonPluginHook, logInvalidFunctionPluginHook, logImplicitDependantIsNotIncluded, logCircularDependency, augmentLogMessage, URL_JSX, URL_TREESHAKE, URL_TREESHAKE_MODULESIDEEFFECTS, URL_OUTPUT_INLINEDYNAMICIMPORTS, URL_PRESERVEENTRYSIGNATURES, URL_OUTPUT_GENERATEDCODE, isValidUrl, addTrailingSlashIfMissed, URL_OUTPUT_SOURCEMAPBASEURL, URL_OUTPUT_MANUALCHUNKS, logInvalidExportOptionValue, URL_OUTPUT_AMD_BASEPATH, URL_OUTPUT_INTEROP, URL_OUTPUT_EXTERNALIMPORTATTRIBUTES, logAlreadyClosed, logMissingFileOrDirOption, logCannotEmitFromOptionsHook, URL_WATCH } from './parseAst.js';
 import { relative, dirname, basename, extname, resolve as resolve$1 } from 'node:path';
 import { posix, isAbsolute, resolve, win32 } from 'path';
 import { parseAsync, xxhashBase16, xxhashBase64Url, xxhashBase36 } from '../../native.js';
@@ -27,7 +27,7 @@ function _mergeNamespaces(n, m) {
   return Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' });
 }
 
-var version = "4.55.3";
+var version = "4.57.0";
 
 // src/vlq.ts
 var comma = ",".charCodeAt(0);
@@ -3027,15 +3027,15 @@ function isCallExpressionNode(node) {
 function isMemberExpressionNode(node) {
     return node instanceof NodeBase && node.type === MemberExpression$1;
 }
-function isImportExpressionNode(node) {
-    return node instanceof NodeBase && node.type === ImportExpression$1;
-}
 function isAwaitExpressionNode(node) {
     return node instanceof NodeBase && node.type === AwaitExpression$1;
 }
 function isIdentifierNode(node) {
     return node instanceof NodeBase && node.type === Identifier$1;
 }
+function isExpressionStatementNode(node) {
+    return node instanceof NodeBase && node.type === ExpressionStatement$1;
+}
 
 function assembleMemberDescriptions(memberDescriptions, inheritedDescriptions = null) {
     return Object.create(inheritedDescriptions, memberDescriptions);
@@ -5193,21 +5193,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) {
@@ -7367,6 +7352,7 @@ function getStringFromPath(path) {
 class MemberExpression extends NodeBase {
     constructor() {
         super(...arguments);
+        this.promiseHandler = null;
         this.variable = null;
         this.expressionsToBeDeoptimized = [];
     }
@@ -7422,7 +7408,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) {
@@ -7612,25 +7601,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() {
@@ -7678,7 +7656,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();
         }
@@ -7803,7 +7781,7 @@ class MetaProperty extends NodeBase {
     render(code, renderOptions) {
         const { format, pluginDriver, snippets } = renderOptions;
         const { scope: { context: { module } }, meta: { name }, metaProperty, parent, preliminaryChunkId, referenceId, start, end } = this;
-        const { id: moduleId } = module;
+        const { id: moduleId, info: { attributes } } = module;
         if (name !== IMPORT)
             return;
         const chunkId = preliminaryChunkId;
@@ -7812,14 +7790,14 @@ class MetaProperty extends NodeBase {
             const relativePath = normalize(relative(dirname(chunkId), fileName));
             const isUrlObject = !!metaProperty?.startsWith(FILE_OBJ_PREFIX);
             const replacement = pluginDriver.hookFirstSync('resolveFileUrl', [
-                { chunkId, fileName, format, moduleId, referenceId, relativePath }
+                { attributes, chunkId, fileName, format, moduleId, referenceId, relativePath }
             ]) || relativeUrlMechanisms[format](relativePath, isUrlObject);
             code.overwrite(parent.start, parent.end, replacement, { contentOnly: true });
             return;
         }
         let replacement = pluginDriver.hookFirstSync('resolveImportMeta', [
             metaProperty,
-            { chunkId, format, moduleId }
+            { attributes, chunkId, format, moduleId }
         ]);
         if (!replacement) {
             replacement = importMetaMechanisms[format]?.(metaProperty, { chunkId, snippets });
@@ -7986,8 +7964,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;
@@ -8001,7 +7980,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);
@@ -8012,7 +7994,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);
+                }
             }
         }
     }
@@ -8022,22 +8010,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) {
@@ -8051,13 +8023,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) {
@@ -8066,9 +8056,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 [
@@ -8114,8 +8104,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) {
@@ -8151,7 +8155,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);
@@ -11832,6 +11836,9 @@ class AssignmentPattern extends NodeBase {
 }
 
 class AwaitExpression extends NodeBase {
+    deoptimizePath(path) {
+        this.argument.deoptimizePath(path);
+    }
     hasEffects() {
         if (!this.deoptimized)
             this.applyDeoptimizations();
@@ -12234,11 +12241,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();
@@ -13096,95 +13102,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 ? BLANK : { renderedSurroundingElement: ExpressionStatement$1 });
-        }
-        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() };
@@ -13193,12 +13145,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() {
@@ -13208,84 +13159,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 EMPTY_ARRAY;
-        }
-        if (parent1 instanceof AwaitExpression) {
-            const parent2 = parent1.parent;
-            // Side effect only: await import('bar')
-            if (parent2 instanceof ExpressionStatement) {
-                return 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 EMPTY_ARRAY;
-            }
-            if (memberName !== 'then')
-                return;
-            // Side-effect only: import('bar').then()
-            if (callExpression.arguments.length === 0) {
-                return 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 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;
@@ -13294,30 +13226,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();
@@ -13367,16 +13300,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);
         }
@@ -13387,11 +13319,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)
@@ -13418,15 +13351,16 @@ 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
+                targetModuleAttributes: resolution && typeof resolution !== 'string' ? resolution.info.attributes : {},
+                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 &&
@@ -13516,15 +13450,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 {
 }
@@ -14519,7 +14444,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 = getRollupError(logParseError(this.message));
@@ -14531,7 +14456,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 = getRollupError(logParseError(this.message, pos));
@@ -14990,9 +14915,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();
@@ -15112,12 +15034,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(logRedeclarationError(identifier.name), identifier.start);
         }
         return super.addDeclaration(identifier, context, init, destructuredInitPath, kind);
@@ -15429,6 +15352,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) {
@@ -15614,6 +15541,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 ? BLANK : { renderedSurroundingElement: ExpressionStatement$1 });
+        }
+        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))
@@ -16901,27 +16914,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,
@@ -16940,7 +16952,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);
                 }
@@ -16951,7 +16963,7 @@ class Module {
             },
             get exports() {
                 return [
-                    ...exports$1.keys(),
+                    ...exportDescriptions.keys(),
                     ...reexportDescriptions.keys(),
                     ...[...exportAllSources].map(() => '*')
                 ];
@@ -16961,7 +16973,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() {
@@ -17034,28 +17046,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;
@@ -17067,10 +17057,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);
                 }
             }
         }
@@ -17102,18 +17091,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 error(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);
@@ -17126,36 +17153,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 };
     }
@@ -17198,7 +17203,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];
@@ -17249,63 +17254,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 error(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
@@ -17384,14 +17355,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),
@@ -17406,7 +17374,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) {
@@ -17507,10 +17475,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(logDuplicateExportError(name), nodeStart);
         }
     }
@@ -17518,7 +17486,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'
             });
@@ -17565,7 +17533,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 });
                     }
                 }
             }
@@ -17573,7 +17541,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 {
@@ -17583,7 +17551,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 });
             }
         }
     }
@@ -17757,7 +17725,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);
@@ -17767,15 +17735,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) {
@@ -17785,21 +17744,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();
             }
         }
     }
@@ -17812,7 +17767,7 @@ class Module {
     }
     shimMissingExport(name) {
         this.options.onLog(LOGLEVEL_WARN, logShimmedExport(this.id, name));
-        this.exports.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
+        this.exportDescriptions.set(name, MISSING_EXPORT_SHIM_DESCRIPTION);
     }
     tryParse() {
         try {
@@ -17842,6 +17797,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);
@@ -18333,6 +18289,8 @@ class Chunk {
                         includedNamespaces.add(module);
                         this.exports.add(module.namespace);
                     }
+                    // This only needs to run once
+                    break;
                 }
             }
             if (module.implicitlyLoadedAfter.size > 0) {
@@ -18970,10 +18928,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),
@@ -19231,13 +19190,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);
             }
         }
     }
@@ -19290,8 +19249,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);
                 }
@@ -19322,8 +19280,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)) {
@@ -19554,7 +19512,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)) {
@@ -20095,9 +20053,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 {
@@ -20893,7 +20851,7 @@ class GlobalScope extends Scope {
     }
 }
 
-function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes) {
+function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes, importerAttributes) {
     let skipped = null;
     let replaceContext = null;
     if (skip) {
@@ -20905,7 +20863,7 @@ function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolve
         }
         replaceContext = (pluginContext, plugin) => ({
             ...pluginContext,
-            resolve: (source, importer, { attributes, custom, isEntry, skipSelf } = BLANK) => {
+            resolve: (source, importer, { attributes, custom, isEntry, skipSelf, importerAttributes } = BLANK) => {
                 skipSelf ??= true;
                 if (skipSelf &&
                     skip.findIndex(skippedCall => {
@@ -20917,15 +20875,15 @@ function resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolve
                     // Thus returning Promise.resolve(null) in purpose of fallback to default behavior of `resolveId` plugin hook.
                     return Promise.resolve(null);
                 }
-                return moduleLoaderResolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, skipSelf ? [...skip, { importer, plugin, source }] : skip);
+                return moduleLoaderResolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, importerAttributes, skipSelf ? [...skip, { importer, plugin, source }] : skip);
             }
         });
     }
-    return pluginDriver.hookFirstAndGetPlugin('resolveId', [source, importer, { attributes, custom: customOptions, isEntry }], replaceContext, skipped);
+    return pluginDriver.hookFirstAndGetPlugin('resolveId', [source, importer, { attributes, custom: customOptions, importerAttributes, isEntry }], replaceContext, skipped);
 }
 
-async function resolveId(source, importer, preserveSymlinks, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes, fs) {
-    const pluginResult = await resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes);
+async function resolveId(source, importer, preserveSymlinks, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes, importerAttributes, fs) {
+    const pluginResult = await resolveIdViaPlugins(source, importer, pluginDriver, moduleLoaderResolveId, skip, customOptions, isEntry, attributes, importerAttributes);
     if (pluginResult != null) {
         const [resolveIdResult, plugin] = pluginResult;
         if (typeof resolveIdResult === 'object' && !resolveIdResult.resolvedBy) {
@@ -20982,89 +20940,6 @@ function stripBom(content) {
     return content;
 }
 
-const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
-const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';
-
-function createPluginCache(cache) {
-    return {
-        delete(id) {
-            return delete cache[id];
-        },
-        get(id) {
-            const item = cache[id];
-            if (!item)
-                return;
-            item[0] = 0;
-            return item[1];
-        },
-        has(id) {
-            const item = cache[id];
-            if (!item)
-                return false;
-            item[0] = 0;
-            return true;
-        },
-        set(id, value) {
-            cache[id] = [0, value];
-        }
-    };
-}
-function getTrackedPluginCache(pluginCache, onUse) {
-    return {
-        delete(id) {
-            onUse();
-            return pluginCache.delete(id);
-        },
-        get(id) {
-            onUse();
-            return pluginCache.get(id);
-        },
-        has(id) {
-            onUse();
-            return pluginCache.has(id);
-        },
-        set(id, value) {
-            onUse();
-            return pluginCache.set(id, value);
-        }
-    };
-}
-const NO_CACHE = {
-    delete() {
-        return false;
-    },
-    get() {
-        return undefined;
-    },
-    has() {
-        return false;
-    },
-    set() { }
-};
-function uncacheablePluginError(pluginName) {
-    if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
-        pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
-        return error(logAnonymousPluginCache());
-    }
-    return error(logDuplicatePluginName(pluginName));
-}
-function getCacheForUncacheablePlugin(pluginName) {
-    return {
-        delete() {
-            return uncacheablePluginError(pluginName);
-        },
-        get() {
-            return uncacheablePluginError(pluginName);
-        },
-        has() {
-            return uncacheablePluginError(pluginName);
-        },
-        set() {
-            return uncacheablePluginError(pluginName);
-        }
-    };
-}
-
 async function asyncFlatten(array) {
     do {
         array = (await Promise.all(array)).flat(Infinity);
@@ -21227,7 +21102,90 @@ const getOptionWithPreset = (value, presets, optionName, urlSnippet, additionalV
 };
 const normalizePluginOption = async (plugins) => (await asyncFlatten([plugins])).filter(Boolean);
 
-async function transform(source, module, pluginDriver, log) {
+const ANONYMOUS_PLUGIN_PREFIX = 'at position ';
+const ANONYMOUS_OUTPUT_PLUGIN_PREFIX = 'at output position ';
+
+function createPluginCache(cache) {
+    return {
+        delete(id) {
+            return delete cache[id];
+        },
+        get(id) {
+            const item = cache[id];
+            if (!item)
+                return;
+            item[0] = 0;
+            return item[1];
+        },
+        has(id) {
+            const item = cache[id];
+            if (!item)
+                return false;
+            item[0] = 0;
+            return true;
+        },
+        set(id, value) {
+            cache[id] = [0, value];
+        }
+    };
+}
+function getTrackedPluginCache(pluginCache, onUse) {
+    return {
+        delete(id) {
+            onUse();
+            return pluginCache.delete(id);
+        },
+        get(id) {
+            onUse();
+            return pluginCache.get(id);
+        },
+        has(id) {
+            onUse();
+            return pluginCache.has(id);
+        },
+        set(id, value) {
+            onUse();
+            return pluginCache.set(id, value);
+        }
+    };
+}
+const NO_CACHE = {
+    delete() {
+        return false;
+    },
+    get() {
+        return undefined;
+    },
+    has() {
+        return false;
+    },
+    set() { }
+};
+function uncacheablePluginError(pluginName) {
+    if (pluginName.startsWith(ANONYMOUS_PLUGIN_PREFIX) ||
+        pluginName.startsWith(ANONYMOUS_OUTPUT_PLUGIN_PREFIX)) {
+        return error(logAnonymousPluginCache());
+    }
+    return error(logDuplicatePluginName(pluginName));
+}
+function getCacheForUncacheablePlugin(pluginName) {
+    return {
+        delete() {
+            return uncacheablePluginError(pluginName);
+        },
+        get() {
+            return uncacheablePluginError(pluginName);
+        },
+        has() {
+            return uncacheablePluginError(pluginName);
+        },
+        set() {
+            return uncacheablePluginError(pluginName);
+        }
+    };
+}
+
+async function transform(source, module, pluginDriver, options) {
     const id = module.id;
     const sourcemapChain = [];
     let originalSourcemap = source.map === null ? null : decodedSourcemap(source.map);
@@ -21249,10 +21207,13 @@ async function transform(source, module, pluginDriver, log) {
             module.updateOptions(result);
             if (result.code == null) {
                 if (result.map || result.ast) {
-                    log(LOGLEVEL_WARN, logNoTransformMapOrAstWithoutCode(plugin.name));
+                    options.onLog(LOGLEVEL_WARN, logNoTransformMapOrAstWithoutCode(plugin.name));
                 }
                 return previousCode;
             }
+            if (result.attributes) {
+                warnDeprecation('Returning attributes from the "transform" hook is forbidden.', URL_TRANSFORM, false, options);
+            }
             ({ code, map, ast } = result);
         }
         else {
@@ -21279,7 +21240,13 @@ async function transform(source, module, pluginDriver, log) {
     };
     let code;
     try {
-        code = await pluginDriver.hookReduceArg0('transform', [currentSource, id], transformReducer, (pluginContext, plugin) => {
+        code = await pluginDriver.hookReduceArg0('transform', [
+            currentSource,
+            id,
+            {
+                attributes: module.info.attributes
+            }
+        ], transformReducer, (pluginContext, plugin) => {
             pluginName = plugin.name;
             return {
                 ...pluginContext,
@@ -21305,7 +21272,7 @@ async function transform(source, module, pluginDriver, log) {
                     return pluginContext.error(error_);
                 },
                 getCombinedSourcemap() {
-                    const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, log);
+                    const combinedMap = collapseSourcemap(id, originalCode, originalSourcemap, sourcemapChain, options.onLog);
                     if (!combinedMap) {
                         const magicString = new MagicString(originalCode);
                         return magicString.generateMap({ hires: true, includeContent: true, source: id });
@@ -21360,15 +21327,15 @@ class ModuleLoader {
         this.modulesWithLoadedDependencies = new Set();
         this.nextChunkNamePriority = 0;
         this.nextEntryModuleIndex = 0;
-        this.resolveId = async (source, importer, customOptions, isEntry, attributes, skip = null) => this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(this.options.external(source, importer, false)
+        this.resolveId = async (source, importer, customOptions, isEntry, attributes, importerAttributes, skip = null) => this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(this.options.external(source, importer, false)
             ? false
-            : await resolveId(source, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, skip, customOptions, typeof isEntry === 'boolean' ? isEntry : !importer, attributes, this.options.fs), importer, source), attributes);
+            : await resolveId(source, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, skip, customOptions, typeof isEntry === 'boolean' ? isEntry : !importer, attributes, importerAttributes, this.options.fs), importer, source), attributes);
         this.hasModuleSideEffects = options.treeshake
             ? options.treeshake.moduleSideEffects
             : () => true;
     }
     async addAdditionalModules(unresolvedModules, isAddForManualChunks) {
-        const result = this.extendLoadModulesPromise(Promise.all(unresolvedModules.map(id => this.loadEntryModule(id, false, undefined, null, isAddForManualChunks))));
+        const result = this.extendLoadModulesPromise(Promise.all(unresolvedModules.map(id => this.loadEntryModule(id, false, undefined, null, isAddForManualChunks, undefined))));
         await this.awaitLoadModulesPromise();
         return result;
     }
@@ -21377,7 +21344,7 @@ class ModuleLoader {
         this.nextEntryModuleIndex += unresolvedEntryModules.length;
         const firstChunkNamePriority = this.nextChunkNamePriority;
         this.nextChunkNamePriority += unresolvedEntryModules.length;
-        const newEntryModules = await this.extendLoadModulesPromise(Promise.all(unresolvedEntryModules.map(({ id, importer }) => this.loadEntryModule(id, true, importer, null))).then(entryModules => {
+        const newEntryModules = await this.extendLoadModulesPromise(Promise.all(unresolvedEntryModules.map(({ id, importer }) => this.loadEntryModule(id, true, importer, null, undefined, undefined))).then(entryModules => {
             for (const [index, entryModule] of entryModules.entries()) {
                 entryModule.isUserDefinedEntryPoint =
                     entryModule.isUserDefinedEntryPoint || isUserDefined;
@@ -21424,10 +21391,10 @@ class ModuleLoader {
     }
     addEntryWithImplicitDependants(unresolvedModule, implicitlyLoadedAfter) {
         const chunkNamePriority = this.nextChunkNamePriority++;
-        return this.extendLoadModulesPromise(this.loadEntryModule(unresolvedModule.id, false, unresolvedModule.importer, null).then(async (entryModule) => {
+        return this.extendLoadModulesPromise(this.loadEntryModule(unresolvedModule.id, false, unresolvedModule.importer, null, undefined, undefined).then(async (entryModule) => {
             addChunkNamesToModule(entryModule, unresolvedModule, false, chunkNamePriority);
             if (!entryModule.info.isEntry) {
-                const implicitlyLoadedAfterModules = await Promise.all(implicitlyLoadedAfter.map(id => this.loadEntryModule(id, false, unresolvedModule.importer, entryModule.id)));
+                const implicitlyLoadedAfterModules = await Promise.all(implicitlyLoadedAfter.map(id => this.loadEntryModule(id, false, unresolvedModule.importer, entryModule.id, undefined, undefined)));
                 // We need to check again if this is still an entry module as these
                 // changes need to be performed atomically to avoid race conditions
                 // if the same module is re-emitted as an entry module.
@@ -21449,9 +21416,16 @@ class ModuleLoader {
         let source;
         try {
             source = await this.graph.fileOperationQueue.run(async () => {
-                const content = await this.pluginDriver.hookFirst('load', [id]);
-                if (content !== null)
+                const content = await this.pluginDriver.hookFirst('load', [
+                    id,
+                    { attributes: module.info.attributes }
+                ]);
+                if (content !== null) {
+                    if (typeof content === 'object' && content.attributes) {
+                        warnDeprecation('Returning attributes from the "load" hook is forbidden.', URL_LOAD, false, this.options);
+                    }
                     return content;
+                }
                 this.graph.watchFiles[id] = true;
                 return (await this.options.fs.readFile(id, { encoding: 'utf8' }));
             });
@@ -21477,6 +21451,7 @@ class ModuleLoader {
             !(await this.pluginDriver.hookFirst('shouldTransformCachedModule', [
                 {
                     ast: cachedModule.ast,
+                    attributes: cachedModule.attributes,
                     code: cachedModule.code,
                     id: cachedModule.id,
                     meta: cachedModule.meta,
@@ -21493,7 +21468,7 @@ class ModuleLoader {
         }
         else {
             module.updateOptions(sourceDescription);
-            await module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options.onLog));
+            await module.setSource(await transform(sourceDescription, module, this.pluginDriver, this.options));
         }
     }
     async awaitLoadModulesPromise() {
@@ -21514,14 +21489,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(relativeId(resolvedId.id), module.id, resolvedId));
+            return (node.resolution = await this.fetchResolvedDependency(relativeId(resolvedId.id), module.id, resolvedId));
         })));
         for (const dependency of dependencies) {
             if (dependency) {
@@ -21666,7 +21641,7 @@ class ModuleLoader {
             source,
             (module.resolvedIds[source] =
                 module.resolvedIds[source] ||
-                    this.handleInvalidResolvedId(await this.resolveId(source, module.id, EMPTY_OBJECT, false, attributes), source, module.id, attributes))
+                    this.handleInvalidResolvedId(await this.resolveId(source, module.id, EMPTY_OBJECT, false, attributes, module.info.attributes), source, module.id, attributes))
         ]);
     }
     getResolvedIdWithDefaults(resolvedId, attributes) {
@@ -21724,8 +21699,8 @@ class ModuleLoader {
         }
         return resolvedId;
     }
-    async loadEntryModule(unresolvedId, isEntry, importer, implicitlyLoadedBefore, isLoadForManualChunks = false) {
-        const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, EMPTY_OBJECT, true, EMPTY_OBJECT, this.options.fs);
+    async loadEntryModule(unresolvedId, isEntry, importer, implicitlyLoadedBefore, isLoadForManualChunks = false, importerAttributes) {
+        const resolveIdResult = await resolveId(unresolvedId, importer, this.options.preserveSymlinks, this.pluginDriver, this.resolveId, null, EMPTY_OBJECT, true, EMPTY_OBJECT, importerAttributes, this.options.fs);
         if (resolveIdResult == null) {
             return error(implicitlyLoadedBefore === null
                 ? logUnresolvedEntry(unresolvedId)
@@ -21747,7 +21722,7 @@ class ModuleLoader {
         const resolution = await this.pluginDriver.hookFirst('resolveDynamicImport', [
             specifier,
             importer,
-            { attributes }
+            { attributes, importerAttributes: module.info.attributes }
         ]);
         if (typeof specifier !== 'string') {
             if (typeof resolution === 'string') {
@@ -21766,7 +21741,7 @@ class ModuleLoader {
                 }
                 return existingResolution;
             }
-            return (module.resolvedIds[specifier] = this.handleInvalidResolvedId(await this.resolveId(specifier, module.id, EMPTY_OBJECT, false, attributes), specifier, module.id, attributes));
+            return (module.resolvedIds[specifier] = this.handleInvalidResolvedId(await this.resolveId(specifier, module.id, EMPTY_OBJECT, false, attributes, module.info.attributes), specifier, module.id, attributes));
         }
         return this.handleInvalidResolvedId(this.getResolvedIdWithDefaults(this.getNormalizedResolvedIdWithoutDefaults(resolution, importer, specifier), attributes), specifier, importer, attributes);
     }
@@ -22261,9 +22236,9 @@ function getPluginContext(plugin, pluginCache, graph, options, fileEmitter, exis
             watchMode: graph.watchMode
         },
         parse: parseAst,
-        resolve(source, importer, { attributes, custom, isEntry, skipSelf } = BLANK) {
+        resolve(source, importer, { attributes, custom, isEntry, skipSelf, importerAttributes } = BLANK) {
             skipSelf ??= true;
-            return graph.moduleLoader.resolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, skipSelf ? [{ importer, plugin, source }] : null);
+            return graph.moduleLoader.resolveId(source, importer, custom, isEntry, attributes || EMPTY_OBJECT, importerAttributes, skipSelf ? [{ importer, plugin, source }] : null);
         },
         setAssetSource: fileEmitter.setAssetSource,
         warn: getLogHandler(LOGLEVEL_WARN, 'PLUGIN_WARNING', onLog, plugin.name, logLevel)
@@ -22760,7 +22735,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();
@@ -22833,7 +22808,7 @@ class Graph {
                     // the TDZ detection logic
                     for (const module of entryModules) {
                         if (module.preserveSignature !== false) {
-                            module.includeAllExports(false);
+                            module.includeAllExports();
                             this.needsTreeshakingPass = true;
                         }
                     }
@@ -22855,7 +22830,7 @@ class Graph {
             }
         }
     }
-    sortModules() {
+    sortAndBindModules() {
         const { orderedModules, cyclePaths } = analyseModuleExecution(this.entryModules);
         for (const cyclePath of cyclePaths) {
             this.options.onLog(LOGLEVEL_WARN, logCircularDependency(cyclePath));