webpack 5.107.2 → 5.108.0

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -16,9 +16,9 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, HarmonyAcceptImportDependency[], boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, HarmonyAcceptImportDependency[], boolean]>} ObjectSerializerContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").ModuleId} ModuleId */
 
@@ -32,7 +32,9 @@ class HarmonyAcceptDependency extends NullDependency {
 	constructor(range, dependencies, hasCallback) {
 		super();
 		this.range = range;
+		/** @type {HarmonyAcceptImportDependency[]} */
 		this.dependencies = dependencies;
+		/** @type {boolean} */
 		this.hasCallback = hasCallback;
 	}
 
@@ -45,10 +47,7 @@ class HarmonyAcceptDependency extends NullDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.dependencies);
-		write(this.hasCallback);
+		context.write(this.range).write(this.dependencies).write(this.hasCallback);
 		super.serialize(context);
 	}
 
@@ -57,11 +56,12 @@ class HarmonyAcceptDependency extends NullDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.dependencies = read();
-		this.hasCallback = read();
-		super.deserialize(context);
+		this.range = context.read();
+		const c1 = context.rest;
+		this.dependencies = c1.read();
+		const c2 = c1.rest;
+		this.hasCallback = c2.read();
+		super.deserialize(c2.rest);
 	}
 }
 

package/lib/dependencies/HarmonyAcceptImportDependency.js

@@ -17,6 +17,7 @@ class HarmonyAcceptImportDependency extends HarmonyImportDependency {
 	 */
 	constructor(request) {
 		super(request, Infinity, ImportPhase.Evaluation);
+		/** @type {boolean} */
 		this.weak = true;
 	}
 

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -10,6 +10,7 @@ const EnvironmentNotSupportAsyncWarning = require("../errors/EnvironmentNotSuppo
 const DynamicExports = require("./DynamicExports");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
 const HarmonyExports = require("./HarmonyExports");
+const { IMPORT_META_NAMES } = require("./ImportMetaPlugin");
 
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
@@ -23,6 +24,33 @@ module.exports = class HarmonyDetectionParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
+		// `import.meta`/top-level `await` only parse as modules, so their presence
+		// alone marks the module as ESM (matching Node.js syntax detection).
+		/**
+		 * @param {boolean} isStrictHarmony strict harmony mode should be enabled
+		 * @returns {void}
+		 */
+		const enableHarmony = (isStrictHarmony) => {
+			if (HarmonyExports.isEnabled(parser.state)) return;
+			const module = parser.state.module;
+			const compatDep = new HarmonyCompatibilityDependency();
+			compatDep.loc = {
+				start: {
+					line: -1,
+					column: 0
+				},
+				end: {
+					line: -1,
+					column: 0
+				},
+				index: -3
+			};
+			module.addPresentationalDependency(compatDep);
+			DynamicExports.bailout(parser.state);
+			HarmonyExports.enable(parser.state, isStrictHarmony);
+			parser.scope.isStrict = true;
+		};
+
 		parser.hooks.program.tap(PLUGIN_NAME, (ast) => {
 			const isStrictHarmony =
 				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
@@ -36,33 +64,13 @@ module.exports = class HarmonyDetectionParserPlugin {
 						statement.type === "ExportAllDeclaration"
 				);
 			if (isHarmony) {
-				const module = parser.state.module;
-				const compatDep = new HarmonyCompatibilityDependency();
-				compatDep.loc = {
-					start: {
-						line: -1,
-						column: 0
-					},
-					end: {
-						line: -1,
-						column: 0
-					},
-					index: -3
-				};
-				module.addPresentationalDependency(compatDep);
-				DynamicExports.bailout(parser.state);
-				HarmonyExports.enable(parser.state, isStrictHarmony);
-				parser.scope.isStrict = true;
+				enableHarmony(isStrictHarmony);
 			}
 		});
 
 		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, () => {
 			const module = parser.state.module;
-			if (!HarmonyExports.isEnabled(parser.state)) {
-				throw new Error(
-					"Top-level-await is only supported in EcmaScript Modules"
-				);
-			}
+			enableHarmony(false);
 			/** @type {BuildMeta} */
 			(module.buildMeta).async = true;
 			EnvironmentNotSupportAsyncWarning.check(
@@ -72,6 +80,23 @@ module.exports = class HarmonyDetectionParserPlugin {
 			);
 		});
 
+		// Using `import.meta` only parses as a module, so it marks the module ESM.
+		// Non-bailing and run before ImportMetaPlugin so its handling still runs;
+		// unknown members go through `unhandledExpressionMemberChain`.
+		const onImportMeta = () => {
+			enableHarmony(false);
+		};
+		for (const name of IMPORT_META_NAMES) {
+			parser.hooks.expression.for(name).tap(PLUGIN_NAME, onImportMeta);
+			parser.hooks.typeof.for(name).tap(PLUGIN_NAME, onImportMeta);
+		}
+		parser.hooks.expressionMemberChain
+			.for("import.meta")
+			.tap(PLUGIN_NAME, onImportMeta);
+		parser.hooks.unhandledExpressionMemberChain
+			.for("import.meta")
+			.tap(PLUGIN_NAME, onImportMeta);
+
 		/**
 		 * Returns true if in harmony.
 		 * @returns {boolean | undefined} true if in harmony

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const { InlinedUsedName } = require("../optimize/InlineExports");
+const {
+	getDependencyUsedByExportsCondition
+} = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const { ExportPresenceModes } = require("./HarmonyImportDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
@@ -12,13 +16,15 @@ const { ImportPhase } = require("./ImportPhase");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<string[]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<string[]>} ObjectSerializerContext */
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
 
 /**
@@ -51,6 +57,7 @@ class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDe
 			attributes,
 			[]
 		);
+		/** @type {string} */
 		this.operator = operator;
 	}
 
@@ -58,6 +65,17 @@ class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDe
 		return `evaluated X ${this.operator} harmony import specifier`;
 	}
 
+	/**
+	 * 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) {
+		// Existence check is independent of inlining; skip the base class's
+		// inline-sensitivity, which would wrongly deactivate the connection.
+		return getDependencyUsedByExportsCondition(this, moduleGraph);
+	}
+
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
@@ -149,6 +167,14 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 		} else {
 			const usedName = exportsInfo.getUsedName(ids, runtime);
 
+			if (usedName instanceof InlinedUsedName) {
+				// Inlined exports only work with ESM export dependency
+				// which only existed in modules with `namespace` exportsType.
+				throw new Error(
+					"Evaluated import specifier dependency has inlined export name: This should not happen"
+				);
+			}
+
 			const code = this._getCodeForIds(
 				dep,
 				source,

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -8,7 +8,9 @@
 const CompatibilityPlugin = require("../CompatibilityPlugin");
 const WebpackError = require("../errors/WebpackError");
 const { getImportAttributes } = require("../javascript/JavascriptParser");
-const InnerGraph = require("../optimize/InnerGraph");
+const { CONST_BINDING_TAG } = require("../optimize/ConstExportsPlugin");
+const { toInlinedValue } = require("../optimize/InlineExports");
+const { getInnerGraphUtils } = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
 const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
@@ -21,6 +23,7 @@ const {
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
@@ -40,6 +43,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
+		/** @type {JavascriptParserOptions} */
 		this.options = options;
 		this.exportPresenceMode = ExportPresenceModes.resolveFromOptions(
 			options.reexportExportsPresence,
@@ -66,10 +70,10 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				),
 				/** @type {Range} */ (statement.range)
 			);
-			dep.loc = Object.create(
-				/** @type {DependencyLocation} */ (statement.loc)
+			dep.setLocWithIndex(
+				/** @type {DependencyLocation} */ (statement.loc),
+				-1
 			);
-			dep.loc.index = -1;
 			parser.state.module.addPresentationalDependency(dep);
 			return true;
 		});
@@ -80,8 +84,10 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				"",
 				/** @type {Range} */ (statement.range)
 			);
-			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-			clearDep.loc.index = -1;
+			clearDep.setLocWithIndex(
+				/** @type {DependencyLocation} */ (statement.loc),
+				-1
+			);
 			parser.state.module.addPresentationalDependency(clearDep);
 
 			const phase = getImportPhase(parser, statement);
@@ -98,10 +104,10 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				phase,
 				getImportAttributes(statement)
 			);
-			sideEffectDep.loc = Object.create(
-				/** @type {DependencyLocation} */ (statement.loc)
+			sideEffectDep.setLocWithIndex(
+				/** @type {DependencyLocation} */ (statement.loc),
+				-1
 			);
-			sideEffectDep.loc.index = -1;
 			parser.state.current.addDependency(sideEffectDep);
 			return true;
 		});
@@ -110,6 +116,11 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			const exprRange = /** @type {Range} */ (node.range);
 			const statementRange = /** @type {Range} */ (statement.range);
 			const comments = parser.getComments([statementRange[0], exprRange[0]]);
+			const constValue = node.type.endsWith("Declaration")
+				? undefined
+				: toInlinedValue(
+						parser.evaluateExpression(/** @type {Expression} */ (node))
+					);
 			const dep = new HarmonyExportExpressionDependency(
 				exprRange,
 				statementRange,
@@ -141,7 +152,8 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 								} `,
 								suffix: `(${node.params.length > 0 ? "" : ") "}`
 							}
-						: undefined
+						: undefined,
+				constValue
 			);
 			dep.isAnonymousDefault =
 				this.options.anonymousDefaultExportName !== false &&
@@ -151,12 +163,12 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						node.type === "ClassDeclaration" ||
 						node.type === "ClassExpression") &&
 						!node.id));
-			dep.loc = Object.create(
-				/** @type {DependencyLocation} */ (statement.loc)
+			dep.setLocWithIndex(
+				/** @type {DependencyLocation} */ (statement.loc),
+				-1
 			);
-			dep.loc.index = -1;
 			parser.state.current.addDependency(dep);
-			InnerGraph.addVariableUsage(
+			getInnerGraphUtils(parser.state.compilation).addVariableUsage(
 				parser,
 				node.type.endsWith("Declaration") &&
 					/** @type {FunctionDeclaration | ClassDeclaration} */ (node).id
@@ -187,7 +199,15 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				const harmonyNamedExports = (parser.state.harmonyNamedExports =
 					parser.state.harmonyNamedExports || new Set());
 				harmonyNamedExports.add(name);
-				InnerGraph.addVariableUsage(parser, id, name);
+				getInnerGraphUtils(parser.state.compilation).addVariableUsage(
+					parser,
+					id,
+					name
+				);
+				const tagData = settings
+					? undefined
+					: /** @type {{ value?: import("../optimize/InlineExports").InlinedValue } | undefined} */
+						(parser.getTagData(id, CONST_BINDING_TAG));
 				const dep = settings
 					? new HarmonyExportImportedSpecifierDependency(
 							settings.source,
@@ -201,11 +221,15 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 							settings.phase,
 							settings.attributes
 						)
-					: new HarmonyExportSpecifierDependency(id, name);
-				dep.loc = Object.create(
-					/** @type {DependencyLocation} */ (statement.loc)
+					: new HarmonyExportSpecifierDependency(
+							id,
+							name,
+							tagData ? tagData.value || null : undefined
+						);
+				dep.setLocWithIndex(
+					/** @type {DependencyLocation} */ (statement.loc),
+					/** @type {number} */ (idx)
 				);
-				dep.loc.index = idx;
 				const isAsiSafe = !parser.isAsiPosition(
 					/** @type {Range} */
 					(statement.range)[0]
@@ -249,10 +273,10 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				if (harmonyStarExports) {
 					harmonyStarExports.push(dep);
 				}
-				dep.loc = Object.create(
-					/** @type {DependencyLocation} */ (statement.loc)
+				dep.setLocWithIndex(
+					/** @type {DependencyLocation} */ (statement.loc),
+					/** @type {number} */ (idx)
 				);
-				dep.loc.index = idx;
 				const isAsiSafe = !parser.isAsiPosition(
 					/** @type {Range} */
 					(statement.range)[0]

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -6,23 +6,31 @@
 "use strict";
 
 const ConcatenationScope = require("../ConcatenationScope");
+const Dependency = require("../Dependency");
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { InlinedUsedName } = require("../optimize/InlineExports");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
+const ExportBindingInitFragment = require("./ExportBindingInitFragment");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const NullDependency = require("./NullDependency");
 
+const DEFAULT_EXPORT_NAME = "default";
+
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").LazyUntil} LazyUntil */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../optimize/InlineExports").InlinedValue} InlinedValue */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {string | { id?: string | undefined, range: Range, prefix: string, suffix: string }} DeclarationId */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range, string, DeclarationId | undefined, boolean]>} ObjectSerializerContext */
 /** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
 
 class HarmonyExportExpressionDependency extends NullDependency {
 	/**
@@ -31,13 +39,17 @@ class HarmonyExportExpressionDependency extends NullDependency {
 	 * @param {Range} rangeStatement range statement
 	 * @param {string} prefix prefix
 	 * @param {string | { id?: string | undefined, range: Range, prefix: string, suffix: string }=} declarationId declaration id
+	 * @param {InlinedValue=} constValue inlined primitive when `export default <const>` is inline-eligible
 	 */
-	constructor(range, rangeStatement, prefix, declarationId) {
+	constructor(range, rangeStatement, prefix, declarationId, constValue) {
 		super();
 		this.range = range;
 		this.rangeStatement = rangeStatement;
+		/** @type {string} */
 		this.prefix = prefix;
 		this.declarationId = declarationId;
+		this.constValue = constValue;
+		/** @type {boolean} */
 		this.isAnonymousDefault = false;
 	}
 
@@ -45,14 +57,45 @@ class HarmonyExportExpressionDependency extends NullDependency {
 		return "harmony export expression";
 	}
 
+	/**
+	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
+	 * @returns {LazyUntil | null} lazy classification, null when it must be processed eagerly
+	 */
+	getLazyUntil() {
+		return Dependency.LAZY_UNTIL_LOCAL;
+	}
+
+	/**
+	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 * @returns {string | null} export name, null when not applicable
+	 */
+	getLazyName() {
+		return DEFAULT_EXPORT_NAME;
+	}
+
 	/**
 	 * Returns the exported names
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
+		const module = moduleGraph.getParentModule(this);
+		const pureFunctions =
+			module &&
+			module.buildInfo &&
+			/** @type {JavascriptModuleBuildInfo} */ (module.buildInfo).pureFunctions;
+		const isPure = Boolean(
+			pureFunctions && pureFunctions.has(DEFAULT_EXPORT_NAME)
+		);
+
 		return {
-			exports: ["default"],
+			exports: [
+				{
+					name: DEFAULT_EXPORT_NAME,
+					isPure: isPure || undefined,
+					inlined: this.constValue
+				}
+			],
 			priority: 1,
 			terminalBinding: true,
 			dependencies: undefined
@@ -74,12 +117,13 @@ class HarmonyExportExpressionDependency extends NullDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.rangeStatement);
-		write(this.prefix);
-		write(this.declarationId);
-		write(this.isAnonymousDefault);
+		context
+			.write(this.range)
+			.write(this.rangeStatement)
+			.write(this.prefix)
+			.write(this.declarationId)
+			.write(this.isAnonymousDefault)
+			.write(this.constValue);
 		super.serialize(context);
 	}
 
@@ -88,13 +132,18 @@ class HarmonyExportExpressionDependency extends NullDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.rangeStatement = read();
-		this.prefix = read();
-		this.declarationId = read();
-		this.isAnonymousDefault = read();
-		super.deserialize(context);
+		this.range = context.read();
+		const c1 = context.rest;
+		this.rangeStatement = c1.read();
+		const c2 = c1.rest;
+		this.prefix = c2.read();
+		const c3 = c2.rest;
+		this.declarationId = c3.read();
+		const c4 = c3.rest;
+		this.isAnonymousDefault = c4.read();
+		const c5 = c4.rest;
+		this.constValue = c5.read();
+		super.deserialize(c5.rest);
 	}
 }
 
@@ -145,10 +194,12 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 
 			const used = concatenationScope
 				? undefined
-				: moduleGraph.getExportsInfo(module).getUsedName("default", runtime);
+				: moduleGraph
+						.getExportsInfo(module)
+						.getUsedName(DEFAULT_EXPORT_NAME, runtime);
 
 			if (concatenationScope) {
-				concatenationScope.registerExport("default", name);
+				concatenationScope.registerExport(DEFAULT_EXPORT_NAME, name);
 			} else if (used) {
 				/** @type {ExportMap} */
 				const map = new Map();
@@ -186,30 +237,56 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 			if (runtimeTemplate.supportsConst()) {
 				content = `/* harmony default export */ const ${name} = `;
 				if (concatenationScope) {
-					concatenationScope.registerExport("default", name);
+					concatenationScope.registerExport(DEFAULT_EXPORT_NAME, name);
 				} else {
 					const used = moduleGraph
 						.getExportsInfo(module)
-						.getUsedName("default", runtime);
-					if (used) {
+						.getUsedName(DEFAULT_EXPORT_NAME, runtime);
+					if (used instanceof InlinedUsedName) {
+						content = `/* inlined harmony default export */ const ${name} = `;
+					} else if (used) {
 						defaultIsUsed = true;
 						runtimeRequirements.add(RuntimeGlobals.exports);
-						/** @type {ExportMap} */
-						const map = new Map();
-						map.set(used, name);
-						initFragments.push(new HarmonyExportInitFragment(exportsName, map));
+						// `export default <expr>` binds an immutable const declaration
+						const canUseValueBinding =
+							/** @type {import("../Module").BuildInfo} */ (module.buildInfo)
+								.isCircular === false;
+						if (canUseValueBinding) {
+							initFragments.push(
+								new ExportBindingInitFragment(
+									exportsName,
+									[
+										{
+											name: used,
+											value: `/* export default binding */ ${name}`,
+											bindingType: "value"
+										}
+									],
+									true
+								)
+							);
+						} else {
+							/** @type {ExportMap} */
+							const map = new Map();
+							map.set(used, name);
+							initFragments.push(
+								new HarmonyExportInitFragment(exportsName, map)
+							);
+						}
 					} else {
 						content = `/* unused harmony default export */ var ${name} = `;
 					}
 				}
 			} else if (concatenationScope) {
 				content = `/* harmony default export */ var ${name} = `;
-				concatenationScope.registerExport("default", name);
+				concatenationScope.registerExport(DEFAULT_EXPORT_NAME, name);
 			} else {
 				const used = moduleGraph
 					.getExportsInfo(module)
-					.getUsedName("default", runtime);
-				if (used) {
+					.getUsedName(DEFAULT_EXPORT_NAME, runtime);
+				if (used instanceof InlinedUsedName) {
+					content = `/* inlined harmony default export */ var ${name} = `;
+				} else if (used) {
 					defaultIsUsed = true;
 					runtimeRequirements.add(RuntimeGlobals.exports);
 					// This is a little bit incorrect as TDZ is not correct, but we can't use const.

package/lib/dependencies/HarmonyExportHeaderDependency.js

@@ -12,8 +12,8 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range | false, Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range | false, Range]>} ObjectSerializerContext */
 
 class HarmonyExportHeaderDependency extends NullDependency {
 	/**
@@ -36,9 +36,7 @@ class HarmonyExportHeaderDependency extends NullDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.range);
-		write(this.rangeStatement);
+		context.write(this.range).write(this.rangeStatement);
 		super.serialize(context);
 	}
 
@@ -47,10 +45,10 @@ class HarmonyExportHeaderDependency extends NullDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.range = read();
-		this.rangeStatement = read();
-		super.deserialize(context);
+		this.range = context.read();
+		const c1 = context.rest;
+		this.rangeStatement = c1.read();
+		super.deserialize(c1.rest);
 	}
 }