@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -6,8 +6,8 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const formatLocation = require("../formatLocation");
 const { evaluateToString } = require("../javascript/JavascriptParserHelpers");
+const formatLocation = require("../util/formatLocation");
 const { propertyAccess } = require("../util/property");
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
 const CommonJsExportsDependency = require("./CommonJsExportsDependency");
@@ -19,7 +19,9 @@ const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
 /** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").Super} Super */
+/** @typedef {import("estree").ThisExpression} ThisExpression */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
@@ -29,7 +31,7 @@ const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
 /** @typedef {import("../javascript/JavascriptParser").StatementPath} StatementPath */
 /** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 
 /**
  * This function takes a generic expression and detects whether it is an ObjectExpression.
@@ -59,6 +61,55 @@ const getValueOfPropertyDescription = (expr) => {
 	}
 };
 
+/**
+ * Extracts the re-exportable expression from a property descriptor, handling
+ * both the eager `{ value: <expr> }` form and the lazy
+ * `{ get: () => <expr> }` / `{ get() { return <expr>; } }` accessor form used
+ * by barrel files (e.g. webpack's own `lib/index.js`). A `set` accessor cannot
+ * be reproduced by the rewritten descriptor, so descriptors with a setter are
+ * left to the generic handler (which keeps the descriptor verbatim).
+ * @param {Expression} expr property descriptor expression
+ * @returns {{ expr: Expression, getter: boolean } | undefined} the value expression and whether it is a lazy getter
+ */
+const getReexportOfPropertyDescriptor = (expr) => {
+	if (expr.type !== "ObjectExpression") return;
+	/** @type {Expression | undefined} */
+	let valueExpr;
+	/** @type {Expression | undefined} */
+	let getFn;
+	for (const property of expr.properties) {
+		if (property.type === "SpreadElement" || property.computed) continue;
+		const key = property.key;
+		if (key.type !== "Identifier") continue;
+		// A setter would be silently dropped by the rewrite — bail out.
+		if (key.name === "set") return;
+		if (key.name === "value") {
+			valueExpr = /** @type {Expression} */ (property.value);
+		} else if (key.name === "get") {
+			getFn = /** @type {Expression} */ (property.value);
+		}
+	}
+	if (valueExpr) return { expr: valueExpr, getter: false };
+	if (
+		getFn &&
+		(getFn.type === "FunctionExpression" ||
+			getFn.type === "ArrowFunctionExpression")
+	) {
+		// Arrow with expression body: `() => require("./x")`.
+		if (getFn.body.type !== "BlockStatement") {
+			return { expr: /** @type {Expression} */ (getFn.body), getter: true };
+		}
+		// Function body must be exactly `return <expr>;`.
+		if (
+			getFn.body.body.length === 1 &&
+			getFn.body.body[0].type === "ReturnStatement" &&
+			getFn.body.body[0].argument
+		) {
+			return { expr: getFn.body.body[0].argument, getter: true };
+		}
+	}
+};
+
 /**
  * The purpose of this function is to check whether an expression is a truthy literal or not. This is
  * useful when parsing CommonJS exports, because CommonJS modules can export any value, including falsy
@@ -94,6 +145,7 @@ const isFalsyLiteral = (expr) => {
 };
 
 /**
+ * Parses require call.
  * @param {JavascriptParser} parser the parser
  * @param {Expression} expr expression
  * @returns {{ argument: BasicEvaluatedExpression, ids: ExportInfoName[] } | undefined} parsed call
@@ -128,17 +180,119 @@ const parseRequireCall = (parser, expr) => {
 	return { argument: argValue, ids: ids.reverse() };
 };
 
+/**
+ * Checks if a value is an AST node.
+ * @param {unknown} value candidate
+ * @returns {value is Node} true when the value is an AST node
+ */
+const isNode = (value) =>
+	typeof value === "object" &&
+	value !== null &&
+	typeof (/** @type {{ type?: unknown }} */ (value).type) === "string";
+
+/** Positional/metadata keys that never hold child AST nodes. */
+const NON_CHILD_KEYS = new Set([
+	"type",
+	"start",
+	"end",
+	"loc",
+	"range",
+	"leadingComments",
+	"trailingComments"
+]);
+
+/** @type {Map<string, string[]>} per node type: own keys that may hold child nodes */
+const childKeysByType = new Map();
+
+/**
+ * Returns the keys of a node that may hold child nodes, excluding positional
+ * metadata. Computed once per node type and cached: acorn initializes every
+ * field of a given type (to `null` when absent), so the key set is stable, and
+ * the cache stays allocation-free on the hot path after the first node of each
+ * type is seen.
+ * @param {Node} node node
+ * @returns {string[]} candidate child keys
+ */
+const getChildKeys = (node) => {
+	let keys = childKeysByType.get(node.type);
+	if (keys === undefined) {
+		keys = Object.keys(node).filter((key) => !NON_CHILD_KEYS.has(key));
+		childKeysByType.set(node.type, keys);
+	}
+	return keys;
+};
+
+/**
+ * Searches for a `this` belonging to the scanned function's own `this`-scope.
+ * Descends into arrow functions, but not into nested functions, static blocks
+ * and class field values, which have their own `this`. Class method bodies are
+ * function expressions and are skipped by the same rule, while computed keys
+ * and `extends` clauses evaluate in the outer scope and are searched. The
+ * `this`-scope boundary is enforced when a node is popped, so the generic
+ * branch may enumerate any child without crossing it.
+ * @param {Node[]} initialNodes nodes to search
+ * @returns {ThisExpression | undefined} first own `this` expression
+ */
+const findOwnThisExpression = (initialNodes) => {
+	const stack = [...initialNodes];
+	let node;
+	while ((node = stack.pop()) !== undefined) {
+		switch (node.type) {
+			case "ThisExpression":
+				return node;
+			case "FunctionExpression":
+			case "FunctionDeclaration":
+			case "StaticBlock":
+				break;
+			case "PropertyDefinition":
+				if (node.computed) stack.push(node.key);
+				break;
+			default: {
+				const children =
+					/** @type {Record<string, unknown>} */
+					(/** @type {unknown} */ (node));
+				const keys = getChildKeys(node);
+				for (let i = 0; i < keys.length; i++) {
+					const value = children[keys[i]];
+					if (Array.isArray(value)) {
+						for (const item of value) {
+							if (isNode(item)) stack.push(item);
+						}
+					} else if (isNode(value)) {
+						stack.push(value);
+					}
+				}
+			}
+		}
+	}
+};
+
+/**
+ * Returns the own `this` of a function-expression export value. When such a
+ * function is called as a method of the exports object, `this` is the exports
+ * object and may reach any sibling export (#21178).
+ * @param {Node} expr the exported value
+ * @returns {ThisExpression | undefined} first own `this` expression
+ */
+const getThisAccessInExportedValue = (expr) =>
+	expr.type === "FunctionExpression"
+		? findOwnThisExpression([...expr.params, expr.body])
+		: undefined;
+
 const PLUGIN_NAME = "CommonJsExportsParserPlugin";
 
 class CommonJsExportsParserPlugin {
 	/**
+	 * Creates an instance of CommonJsExportsParserPlugin.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 */
 	constructor(moduleGraph) {
+		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
@@ -148,6 +302,7 @@ class CommonJsExportsParserPlugin {
 		};
 
 		/**
+		 * Checks namespace.
 		 * @param {boolean} topLevel true, when the export is on top level
 		 * @param {Members} members members of the export
 		 * @param {Expression | undefined} valueExpr expression for the value
@@ -164,6 +319,7 @@ class CommonJsExportsParserPlugin {
 			}
 		};
 		/**
+		 * Processes the provided reason.
 		 * @param {string=} reason reason
 		 */
 		const bailout = (reason) => {
@@ -171,6 +327,7 @@ class CommonJsExportsParserPlugin {
 			if (reason) bailoutHint(reason);
 		};
 		/**
+		 * Processes the provided reason.
 		 * @param {string} reason reason
 		 */
 		const bailoutHint = (reason) => {
@@ -178,6 +335,36 @@ class CommonJsExportsParserPlugin {
 				.getOptimizationBailout(parser.state.module)
 				.push(`CommonJS bailout: ${reason}`);
 		};
+		/** @type {unknown} */
+		let keptAllExportsForState;
+		/**
+		 * An exported function accessing its own `this` may reach any export
+		 * through it when called as a method of the exports object, so the
+		 * whole exports object must be kept (#21178).
+		 * @param {Node} valueExpr the exported value
+		 * @param {CommonJSDependencyBaseKeywords} base commonjs base keywords
+		 * @returns {void}
+		 */
+		const keepAllExportsOnThisAccess = (valueExpr, base) => {
+			// One bailout per module is enough
+			if (keptAllExportsForState === parser.state) return;
+			const thisExpr = getThisAccessInExportedValue(valueExpr);
+			if (thisExpr === undefined) return;
+			keptAllExportsForState = parser.state;
+			bailoutHint(
+				`this in exported function may access any export, so all exports are kept, at ${formatLocation(
+					parser.getLocation(thisExpr)
+				)}`
+			);
+			const dep = new CommonJsSelfReferenceDependency(
+				/** @type {Range} */ (thisExpr.range),
+				base,
+				[],
+				false
+			);
+			dep.loc = parser.getLocation(thisExpr);
+			parser.state.module.addDependency(dep);
+		};
 
 		// metadata //
 		parser.hooks.evaluateTypeof
@@ -190,6 +377,7 @@ class CommonJsExportsParserPlugin {
 		// exporting //
 
 		/**
+		 * Handle assign export.
 		 * @param {AssignmentExpression} expr expression
 		 * @param {CommonJSDependencyBaseKeywords} base commonjs base keywords
 		 * @param {Members} members members of the export
@@ -216,10 +404,10 @@ class CommonJsExportsParserPlugin {
 					requireCall.ids,
 					!parser.isStatementLevelExpression(expr)
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.module.addDependency(dep);
-				/** @type {BuildMeta} */ (
+				/** @type {JavascriptModuleBuildMeta} */ (
 					parser.state.module.buildMeta
 				).treatAsCommonJs = true;
 
@@ -241,10 +429,12 @@ class CommonJsExportsParserPlugin {
 				base,
 				remainingMembers
 			);
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			parser.state.module.addDependency(dep);
-			/** @type {BuildMeta} */ (parser.state.module.buildMeta).treatAsCommonJs =
-				true;
+			/** @type {JavascriptModuleBuildMeta} */ (
+				parser.state.module.buildMeta
+			).treatAsCommonJs = true;
+			keepAllExportsOnThisAccess(expr.right, base);
 			parser.walkExpression(expr.right);
 			return true;
 		};
@@ -288,6 +478,33 @@ class CommonJsExportsParserPlugin {
 				if (typeof property !== "string") return;
 				enableStructuredExports();
 				const descArg = expr.arguments[2];
+				// Handle reexporting: `Object.defineProperty(exports, "x", { value: require("./y")[.z] })`
+				// and the lazy getter form `{ get: () => require("./y")[.z] }`.
+				if (property !== "__esModule") {
+					const reexport = getReexportOfPropertyDescriptor(descArg);
+					const requireCall =
+						reexport && parseRequireCall(parser, reexport.expr);
+					if (reexport && requireCall && requireCall.argument.isString()) {
+						const dep = new CommonJsExportRequireDependency(
+							/** @type {Range} */ (expr.range),
+							/** @type {Range} */ (reexport.expr.range),
+							`Object.defineProperty(${exportsArg.identifier})`,
+							[property],
+							/** @type {string} */ (requireCall.argument.string),
+							requireCall.ids,
+							false
+						);
+						dep.getter = reexport.getter;
+						dep.loc = parser.getLocation(expr);
+						dep.optional = Boolean(parser.scope.inTry);
+						parser.state.module.addDependency(dep);
+						/** @type {JavascriptModuleBuildMeta} */ (
+							parser.state.module.buildMeta
+						).treatAsCommonJs = true;
+
+						return true;
+					}
+				}
 				checkNamespace(
 					/** @type {StatementPath} */
 					(parser.statementPath).length === 1,
@@ -300,12 +517,24 @@ class CommonJsExportsParserPlugin {
 					`Object.defineProperty(${exportsArg.identifier})`,
 					[property]
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
-				/** @type {BuildMeta} */ (
+				/** @type {JavascriptModuleBuildMeta} */ (
 					parser.state.module.buildMeta
 				).treatAsCommonJs = true;
 
+				if (descArg.type === "ObjectExpression") {
+					// `value`, `get` and `set` descriptor functions are all called
+					// with the exports object as `this`
+					for (const descProperty of descArg.properties) {
+						if (descProperty.type === "SpreadElement") continue;
+						keepAllExportsOnThisAccess(
+							descProperty.value,
+							/** @type {CommonJSDependencyBaseKeywords} */
+							(exportsArg.identifier)
+						);
+					}
+				}
 				parser.walkExpression(expr.arguments[2]);
 				return true;
 			});
@@ -313,6 +542,7 @@ class CommonJsExportsParserPlugin {
 		// Self reference //
 
 		/**
+		 * Handle access export.
 		 * @param {Expression | Super} expr expression
 		 * @param {CommonJSDependencyBaseKeywords} base commonjs base keywords
 		 * @param {Members} members members of the export
@@ -324,7 +554,7 @@ class CommonJsExportsParserPlugin {
 			if (members.length === 0) {
 				bailout(
 					`${base} is used directly at ${formatLocation(
-						/** @type {DependencyLocation} */ (expr.loc)
+						parser.getLocation(expr)
 					)}`
 				);
 			}
@@ -333,7 +563,7 @@ class CommonJsExportsParserPlugin {
 					`${base}${propertyAccess(
 						members
 					)}(...) prevents optimization as ${base} is passed as call context at ${formatLocation(
-						/** @type {DependencyLocation} */ (expr.loc)
+						parser.getLocation(expr)
 					)}`
 				);
 			}
@@ -343,10 +573,11 @@ class CommonJsExportsParserPlugin {
 				members,
 				Boolean(call)
 			);
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			parser.state.module.addDependency(dep);
-			/** @type {BuildMeta} */ (parser.state.module.buildMeta).treatAsCommonJs =
-				true;
+			/** @type {JavascriptModuleBuildMeta} */ (
+				parser.state.module.buildMeta
+			).treatAsCommonJs = true;
 
 			if (call) {
 				parser.walkExpressions(call.arguments);
@@ -415,7 +646,7 @@ class CommonJsExportsParserPlugin {
 					: RuntimeGlobals.nodeModuleDecorator,
 				!isHarmony
 			);
-			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.loc = parser.getLocation(expr);
 			parser.state.module.addDependency(dep);
 			return true;
 		});

package/lib/dependencies/CommonJsFullRequireDependency.js

@@ -9,23 +9,34 @@ const Template = require("../Template");
 const { equals } = require("../util/ArrayHelpers");
 const { getTrimmedIdsAndRange } = require("../util/chainedImports");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const { propertyAccess } = require("../util/property");
+const {
+	ESM_MODULE_EXPORTS_NAME,
+	getRequireEsmModuleExportsAccess,
+	isRequireEsmModuleExportsModule
+} = require("./CommonJsDependencyHelpers");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
+/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectSerializerContext */
+
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
 
 class CommonJsFullRequireDependency extends ModuleDependency {
 	/**
+	 * Creates an instance of CommonJsFullRequireDependency.
 	 * @param {string} request the request string
 	 * @param {Range} range location in source code
 	 * @param {ExportInfoName[]} names accessed properties on module
@@ -39,12 +50,28 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	) {
 		super(request);
 		this.range = range;
+		/** @type {string[]} */
 		this.names = names;
+		/** @type {IdRanges | undefined} */
 		this.idRanges = idRanges;
 		/** @type {boolean} */
 		this.call = false;
 		/** @type {undefined | boolean} */
 		this.asiSafe = undefined;
+		/** @type {DependencyGuard[] | undefined} */
+		this.branchGuards = undefined;
+	}
+
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		const guards = this.branchGuards;
+		if (guards === undefined) return null;
+		return (connection, runtime) =>
+			!getHarmonyImportGuard().isDeadByGuards(guards, moduleGraph, runtime);
 	}
 
 	/**
@@ -54,40 +81,56 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		if (this.call) {
-			const importedModule = moduleGraph.getModule(this);
-			if (
-				!importedModule ||
-				importedModule.getExportsType(moduleGraph, false) !== "namespace"
-			) {
-				return [this.names.slice(0, -1)];
-			}
+		const importedModule = moduleGraph.getModule(this);
+		// CommonJS property access is never rewritten to a literal, so it can't inline
+		if (
+			importedModule &&
+			isRequireEsmModuleExportsModule(importedModule, moduleGraph)
+		) {
+			// When `require(esm)` unwraps a `"module.exports"` named export, the
+			// user's property access lands on that value (which webpack does not
+			// model), so only the "module.exports" export itself is referenced.
+			return [{ name: [ESM_MODULE_EXPORTS_NAME], canInline: false }];
+		}
+		if (
+			this.call &&
+			(!importedModule ||
+				importedModule.getExportsType(moduleGraph, false) !== "namespace")
+		) {
+			return [{ name: this.names.slice(0, -1), canInline: false }];
 		}
-		return [this.names];
+		return [{ name: this.names, canInline: false }];
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.names);
-		write(this.idRanges);
-		write(this.call);
-		write(this.asiSafe);
+		context
+			.write(this.names)
+			.write(this.idRanges)
+			.write(this.call)
+			.write(this.asiSafe)
+			.write(this.branchGuards);
 		super.serialize(context);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.names = read();
-		this.idRanges = read();
-		this.call = read();
-		this.asiSafe = read();
-		super.deserialize(context);
+		this.names = context.read();
+		const c1 = context.rest;
+		this.idRanges = c1.read();
+		const c2 = c1.rest;
+		this.call = c2.read();
+		const c3 = c2.rest;
+		this.asiSafe = c3.read();
+		const c4 = c3.rest;
+		this.branchGuards = c4.read();
+		super.deserialize(c4.rest);
 	}
 
 	get type() {
@@ -103,6 +146,7 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 	ModuleDependency.Template
 ) {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Dependency} dependency the dependency for which the template should be applied
 	 * @param {ReplaceSource} source the current replace source which can be modified
 	 * @param {DependencyTemplateContext} templateContext the context object
@@ -115,6 +159,13 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 	) {
 		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
 		if (!dep.range) return;
+		const connection = moduleGraph.getConnection(dep);
+		// Dead branch: module is excluded and has no id; code is never executed.
+		if (connection && !connection.isTargetActive(runtime)) {
+			// Replaces the whole member chain, so no property access is left dangling
+			source.replace(dep.range[0], dep.range[1] - 1, "null /* dead branch */");
+			return;
+		}
 		const importedModule = moduleGraph.getModule(dep);
 		let requireExpr = runtimeTemplate.moduleExports({
 			module: importedModule,
@@ -124,6 +175,10 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			runtimeRequirements
 		});
 
+		const esmRequireAccess = importedModule
+			? getRequireEsmModuleExportsAccess(importedModule, moduleGraph, runtime)
+			: null;
+
 		const {
 			trimmedRange: [trimmedRangeStart, trimmedRangeEnd],
 			trimmedIds
@@ -135,15 +190,24 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			dep
 		);
 
-		if (importedModule) {
-			const usedImported = moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(trimmedIds, runtime);
+		if (esmRequireAccess !== null) {
+			const access = `${esmRequireAccess}${propertyAccess(trimmedIds)}`;
+			requireExpr =
+				dep.asiSafe === true
+					? `(${requireExpr}${access})`
+					: `${requireExpr}${access}`;
+		} else if (importedModule) {
+			// CJS exports are never inlined
+			const usedImported = /** @type {string | string[] | false} */ (
+				moduleGraph
+					.getExportsInfo(importedModule)
+					.getUsedName(trimmedIds, runtime)
+			);
 			if (usedImported) {
 				const comment = equals(usedImported, trimmedIds)
 					? ""
 					: `${Template.toNormalComment(propertyAccess(trimmedIds))} `;
-				const access = `${comment}${propertyAccess(usedImported)}`;
+				const access = `${comment}${propertyAccess(/** @type {string[]} */ (usedImported))}`;
 				requireExpr =
 					dep.asiSafe === true
 						? `(${requireExpr}${access})`