webpack 5.99.9 → 5.100.1

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -5,7 +5,10 @@
 
 "use strict";
 
+const CommentCompilationWarning = require("../CommentCompilationWarning");
 const HotModuleReplacementPlugin = require("../HotModuleReplacementPlugin");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const WebpackError = require("../WebpackError");
 const { getImportAttributes } = require("../javascript/JavascriptParser");
 const InnerGraph = require("../optimize/InnerGraph");
 const ConstDependency = require("./ConstDependency");
@@ -49,13 +52,17 @@ const harmonySpecifierTag = Symbol("harmony import");
  * @property {string} name
  * @property {boolean} await
  * @property {ImportAttributes=} attributes
+ * @property {boolean | undefined} defer
  */
 
+const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
+
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options options
+	 * @param {boolean | undefined} deferImport defer import enabled
 	 */
-	constructor(options) {
+	constructor(options, deferImport) {
 		this.exportPresenceMode =
 			options.importExportsPresence !== undefined
 				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
@@ -65,6 +72,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						? ExportPresenceModes.ERROR
 						: ExportPresenceModes.AUTO;
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
+		this.deferImport = deferImport;
 	}
 
 	/**
@@ -86,141 +94,159 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		}
 
 		/**
-		 * @param {TODO} node member expression
+		 * @param {MemberExpression} node member expression
 		 * @param {number} count count
 		 * @returns {Expression} member expression
 		 */
 		function getNonOptionalMemberChain(node, count) {
-			while (count--) node = node.object;
+			while (count--) node = /** @type {MemberExpression} */ (node.object);
 			return node;
 		}
 
-		parser.hooks.isPure
-			.for("Identifier")
-			.tap("HarmonyImportDependencyParserPlugin", expression => {
-				const expr = /** @type {Identifier} */ (expression);
-				if (
-					parser.isVariableDefined(expr.name) ||
-					parser.getTagData(expr.name, harmonySpecifierTag)
-				) {
-					return true;
-				}
-			});
-		parser.hooks.import.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(statement, source) => {
-				parser.state.lastHarmonyImportOrder =
-					(parser.state.lastHarmonyImportOrder || 0) + 1;
-				const clearDep = new ConstDependency(
-					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
-						? ";"
-						: "",
-					/** @type {Range} */ (statement.range)
-				);
-				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
-				const attributes = getImportAttributes(statement);
-				const sideEffectDep = new HarmonyImportSideEffectDependency(
-					/** @type {string} */ (source),
-					parser.state.lastHarmonyImportOrder,
-					attributes
-				);
-				sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
-				parser.state.module.addDependency(sideEffectDep);
+		parser.hooks.isPure.for("Identifier").tap(PLUGIN_NAME, expression => {
+			const expr = /** @type {Identifier} */ (expression);
+			if (
+				parser.isVariableDefined(expr.name) ||
+				parser.getTagData(expr.name, harmonySpecifierTag)
+			) {
 				return true;
 			}
-		);
+		});
+		parser.hooks.import.tap(PLUGIN_NAME, (statement, source) => {
+			parser.state.lastHarmonyImportOrder =
+				(parser.state.lastHarmonyImportOrder || 0) + 1;
+			const clearDep = new ConstDependency(
+				parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+					? ";"
+					: "",
+				/** @type {Range} */ (statement.range)
+			);
+			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			parser.state.module.addPresentationalDependency(clearDep);
+			parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
+			const attributes = getImportAttributes(statement);
+			const { defer } = getImportMode(
+				parser,
+				statement,
+				this.deferImport,
+				true
+			);
+			if (
+				defer &&
+				(statement.specifiers.length !== 1 ||
+					statement.specifiers[0].type !== "ImportNamespaceSpecifier")
+			) {
+				const error = new WebpackError(
+					"Deferred import can only be used with `import * as namespace from '...'` syntax."
+				);
+				error.loc = statement.loc || undefined;
+				parser.state.current.addError(error);
+			}
+			const sideEffectDep = new HarmonyImportSideEffectDependency(
+				/** @type {string} */ (source),
+				parser.state.lastHarmonyImportOrder,
+				attributes,
+				defer
+			);
+			sideEffectDep.loc = /** @type {DependencyLocation} */ (statement.loc);
+			parser.state.module.addDependency(sideEffectDep);
+			return true;
+		});
 		parser.hooks.importSpecifier.tap(
-			"HarmonyImportDependencyParserPlugin",
+			PLUGIN_NAME,
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
+				const { defer } = getImportMode(
+					parser,
+					statement,
+					this.deferImport,
+					false
+				);
 				parser.tagVariable(name, harmonySpecifierTag, {
 					name,
 					source,
 					ids,
 					sourceOrder: parser.state.lastHarmonyImportOrder,
-					attributes: getImportAttributes(statement)
+					attributes: getImportAttributes(statement),
+					defer
 				});
 				return true;
 			}
 		);
-		parser.hooks.binaryExpression.tap(
-			"HarmonyImportDependencyParserPlugin",
-			expression => {
-				if (expression.operator !== "in") return;
+		parser.hooks.binaryExpression.tap(PLUGIN_NAME, expression => {
+			if (expression.operator !== "in") return;
 
-				const leftPartEvaluated = parser.evaluateExpression(expression.left);
-				if (leftPartEvaluated.couldHaveSideEffects()) return;
-				const leftPart = leftPartEvaluated.asString();
-				if (!leftPart) return;
+			const leftPartEvaluated = parser.evaluateExpression(expression.left);
+			if (leftPartEvaluated.couldHaveSideEffects()) return;
+			/** @type {string | undefined} */
+			const leftPart = leftPartEvaluated.asString();
+			if (!leftPart) return;
 
-				const rightPart = parser.evaluateExpression(expression.right);
-				if (!rightPart.isIdentifier()) return;
+			const rightPart = parser.evaluateExpression(expression.right);
+			if (!rightPart.isIdentifier()) return;
 
-				const rootInfo = rightPart.rootInfo;
-				if (
-					typeof rootInfo === "string" ||
-					!rootInfo ||
-					!rootInfo.tagInfo ||
-					rootInfo.tagInfo.tag !== harmonySpecifierTag
-				)
-					return;
-				const settings = /** @type {TagData} */ (rootInfo.tagInfo.data);
-				const members =
-					/** @type {(() => string[])} */
-					(rightPart.getMembers)();
-				const dep = new HarmonyEvaluatedImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					settings.ids.concat(members).concat([leftPart]),
-					settings.name,
-					/** @type {Range} */ (expression.range),
-					settings.attributes,
-					"in"
-				);
-				dep.directImport = members.length === 0;
-				dep.asiSafe = !parser.isAsiPosition(
-					/** @type {Range} */ (expression.range)[0]
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expression.loc);
-				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
+			const rootInfo = rightPart.rootInfo;
+			if (
+				typeof rootInfo === "string" ||
+				!rootInfo ||
+				!rootInfo.tagInfo ||
+				rootInfo.tagInfo.tag !== harmonySpecifierTag
+			) {
+				return;
 			}
-		);
-		parser.hooks.expression
-			.for(harmonySpecifierTag)
-			.tap("HarmonyImportDependencyParserPlugin", expr => {
-				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
-				const dep = new HarmonyImportSpecifierDependency(
-					settings.source,
-					settings.sourceOrder,
-					settings.ids,
-					settings.name,
-					/** @type {Range} */
-					(expr.range),
-					exportPresenceMode,
-					settings.attributes,
-					[]
-				);
-				dep.referencedPropertiesInDestructuring =
-					parser.destructuringAssignmentPropertiesFor(expr);
-				dep.shorthand = parser.scope.inShorthand;
-				dep.directImport = true;
-				dep.asiSafe = !parser.isAsiPosition(
-					/** @type {Range} */ (expr.range)[0]
-				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.call = parser.scope.inTaggedTemplateTag;
-				parser.state.module.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-				return true;
-			});
+			const settings =
+				/** @type {TagData} */
+				(rootInfo.tagInfo.data);
+			const members =
+				/** @type {(() => string[])} */
+				(rightPart.getMembers)();
+			const dep = new HarmonyEvaluatedImportSpecifierDependency(
+				settings.source,
+				settings.sourceOrder,
+				[...settings.ids, ...members, leftPart],
+				settings.name,
+				/** @type {Range} */ (expression.range),
+				settings.attributes,
+				"in"
+			);
+			dep.directImport = members.length === 0;
+			dep.asiSafe = !parser.isAsiPosition(
+				/** @type {Range} */ (expression.range)[0]
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expression.loc);
+			parser.state.module.addDependency(dep);
+			InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+			return true;
+		});
+		parser.hooks.expression.for(harmonySpecifierTag).tap(PLUGIN_NAME, expr => {
+			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+			const dep = new HarmonyImportSpecifierDependency(
+				settings.source,
+				settings.sourceOrder,
+				settings.ids,
+				settings.name,
+				/** @type {Range} */
+				(expr.range),
+				exportPresenceMode,
+				settings.attributes,
+				[],
+				settings.defer
+			);
+			dep.referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(expr);
+			dep.shorthand = parser.scope.inShorthand;
+			dep.directImport = true;
+			dep.asiSafe = !parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.call = parser.scope.inTaggedTemplateTag;
+			parser.state.module.addDependency(dep);
+			InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+			return true;
+		});
 		parser.hooks.expressionMemberChain
 			.for(harmonySpecifierTag)
 			.tap(
-				"HarmonyImportDependencyParserPlugin",
+				PLUGIN_NAME,
 				(expression, members, membersOptionals, memberRanges) => {
 					const settings =
 						/** @type {HarmonySettings} */
@@ -241,7 +267,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 									members.length - nonOptionalMembers.length
 								)
 							: expression;
-					const ids = settings.ids.concat(nonOptionalMembers);
+					const ids = [...settings.ids, ...nonOptionalMembers];
 					const dep = new HarmonyImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
@@ -251,7 +277,8 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						(expr.range),
 						exportPresenceMode,
 						settings.attributes,
-						ranges
+						ranges,
+						settings.defer
 					);
 					dep.referencedPropertiesInDestructuring =
 						parser.destructuringAssignmentPropertiesFor(expr);
@@ -268,9 +295,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		parser.hooks.callMemberChain
 			.for(harmonySpecifierTag)
 			.tap(
-				"HarmonyImportDependencyParserPlugin",
+				PLUGIN_NAME,
 				(expression, members, membersOptionals, memberRanges) => {
-					const { arguments: args, callee } = expression;
+					const { arguments: args } = expression;
+					const callee = /** @type {MemberExpression} */ (expression.callee);
 					const settings = /** @type {HarmonySettings} */ (
 						parser.currentTagData
 					);
@@ -290,7 +318,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 									members.length - nonOptionalMembers.length
 								)
 							: callee;
-					const ids = settings.ids.concat(nonOptionalMembers);
+					const ids = [...settings.ids, ...nonOptionalMembers];
 					const dep = new HarmonyImportSpecifierDependency(
 						settings.source,
 						settings.sourceOrder,
@@ -299,7 +327,8 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						/** @type {Range} */ (expr.range),
 						exportPresenceMode,
 						settings.attributes,
-						ranges
+						ranges,
+						settings.defer
 					);
 					dep.directImport = members.length === 0;
 					dep.call = true;
@@ -319,57 +348,104 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			);
 		const { hotAcceptCallback, hotAcceptWithoutCallback } =
 			HotModuleReplacementPlugin.getParserHooks(parser);
-		hotAcceptCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						/** @type {Range} */
-						(expr.range),
-						dependencies,
-						true
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-				}
+		hotAcceptCallback.tap(PLUGIN_NAME, (expr, requests) => {
+			if (!HarmonyExports.isEnabled(parser.state)) {
+				// This is not a harmony module, skip it
+				return;
 			}
-		);
-		hotAcceptWithoutCallback.tap(
-			"HarmonyImportDependencyParserPlugin",
-			(expr, requests) => {
-				if (!HarmonyExports.isEnabled(parser.state)) {
-					// This is not a harmony module, skip it
-					return;
-				}
-				const dependencies = requests.map(request => {
-					const dep = new HarmonyAcceptImportDependency(request);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-					return dep;
-				});
-				if (dependencies.length > 0) {
-					const dep = new HarmonyAcceptDependency(
-						/** @type {Range} */
-						(expr.range),
-						dependencies,
-						false
-					);
-					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					parser.state.module.addDependency(dep);
-				}
+			const dependencies = requests.map(request => {
+				const dep = new HarmonyAcceptImportDependency(request);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
+				return dep;
+			});
+			if (dependencies.length > 0) {
+				const dep = new HarmonyAcceptDependency(
+					/** @type {Range} */
+					(expr.range),
+					dependencies,
+					true
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
 			}
-		);
+		});
+		hotAcceptWithoutCallback.tap(PLUGIN_NAME, (expr, requests) => {
+			if (!HarmonyExports.isEnabled(parser.state)) {
+				// This is not a harmony module, skip it
+				return;
+			}
+			const dependencies = requests.map(request => {
+				const dep = new HarmonyAcceptImportDependency(request);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
+				return dep;
+			});
+			if (dependencies.length > 0) {
+				const dep = new HarmonyAcceptDependency(
+					/** @type {Range} */
+					(expr.range),
+					dependencies,
+					false
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addDependency(dep);
+			}
+		});
 	}
 };
 
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {ExportNamedDeclaration | ExportAllDeclaration | ImportDeclaration} node node
+ * @param {boolean | undefined} deferImportEnabled defer import enabled
+ * @param {boolean} reportSyntaxError report syntax error
+ * @returns {{defer: boolean}} import attributes
+ */
+function getImportMode(parser, node, deferImportEnabled, reportSyntaxError) {
+	const result = { defer: false };
+	if ("phase" in node && node.phase === "defer") {
+		if (deferImportEnabled) {
+			result.defer = true;
+		} else if (reportSyntaxError) {
+			const error = new WebpackError(
+				"Deferred import syntax (`import defer * as namespace from '...'`) cannot be used unless experimental.deferImport is true."
+			);
+			error.loc = node.loc || undefined;
+			parser.state.current.addError(error);
+		}
+	}
+	if (!node.range) {
+		return result;
+	}
+	const { options, errors } = parser.parseCommentOptions(node.range);
+	if (errors) {
+		for (const e of errors) {
+			const { comment } = e;
+			if (!comment.loc) continue;
+			parser.state.module.addWarning(
+				new CommentCompilationWarning(
+					`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+					comment.loc
+				)
+			);
+		}
+	}
+	if (!options) return result;
+	if (options.webpackDefer) {
+		if (typeof options.webpackDefer === "boolean") {
+			result.defer = options.webpackDefer;
+		} else if (node.loc) {
+			parser.state.module.addWarning(
+				new UnsupportedFeatureWarning(
+					"webpackDefer magic comment expected a boolean value.",
+					node.loc
+				)
+			);
+		}
+	}
+	return result;
+}
+
+module.exports.getImportMode = getImportMode;
 module.exports.harmonySpecifierTag = harmonySpecifierTag;

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -16,6 +16,7 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -25,9 +26,11 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	 * @param {string} request the request string
 	 * @param {number} sourceOrder source order
 	 * @param {ImportAttributes=} attributes import attributes
+	 * @param {boolean=} deferred deferred
 	 */
-	constructor(request, sourceOrder, attributes) {
+	constructor(request, sourceOrder, attributes, deferred) {
 		super(request, sourceOrder, attributes);
+		this.defer = deferred;
 	}
 
 	get type() {

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -51,6 +51,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @param {ExportPresenceMode} exportPresenceMode export presence mode
 	 * @param {ImportAttributes | undefined} attributes import attributes
 	 * @param {Range[] | undefined} idRanges ranges for members of ids; the two arrays are right-aligned
+	 * @param {boolean=} deferred deferred
 	 */
 	constructor(
 		request,
@@ -60,7 +61,8 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		range,
 		exportPresenceMode,
 		attributes,
-		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
+		idRanges, // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
+		deferred
 	) {
 		super(request, sourceOrder, attributes);
 		this.ids = ids;
@@ -77,6 +79,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.usedByExports = undefined;
 		/** @type {Set<DestructuringAssignmentProperty> | undefined} */
 		this.referencedPropertiesInDestructuring = undefined;
+		this.defer = deferred;
 	}
 
 	// TODO webpack 6 remove
@@ -164,8 +167,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			) {
 				case "default-only":
 				case "default-with-named":
-					if (ids.length === 1)
+					if (ids.length === 1) {
 						return this._getReferencedExportsInDestructuring();
+					}
 					ids = ids.slice(1);
 					namespaceObjectAsContext = true;
 					break;
@@ -195,7 +199,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			/** @type {string[][]} */
 			const refs = [];
 			for (const { id } of this.referencedPropertiesInDestructuring) {
-				refs.push(ids ? ids.concat([id]) : [id]);
+				refs.push(ids ? [...ids, id] : [id]);
 			}
 			return refs;
 		}
@@ -207,8 +211,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {ExportPresenceMode} effective mode
 	 */
 	_getEffectiveExportPresenceLevel(moduleGraph) {
-		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO) {
 			return this.exportPresenceMode;
+		}
 		const buildMeta =
 			/** @type {BuildMeta} */
 			(
@@ -376,7 +381,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				shorthand,
 				range
 			} of dep.referencedPropertiesInDestructuring) {
-				const concatedIds = prefixedIds.concat([id]);
+				/** @type {string[]} */
+				const concatedIds = [...prefixedIds, id];
 				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 				const used = moduleGraph
 					.getExportsInfo(module)
@@ -420,13 +426,15 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				exportExpr = concatenationScope.createModuleReference(
 					connection.module,
 					{
-						asiSafe: dep.asiSafe
+						asiSafe: dep.asiSafe,
+						deferredImport: dep.defer
 					}
 				);
 			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
 				exportExpr =
 					concatenationScope.createModuleReference(connection.module, {
-						asiSafe: dep.asiSafe
+						asiSafe: dep.asiSafe,
+						deferredImport: dep.defer
 					}) + propertyAccess(ids);
 			} else {
 				exportExpr = concatenationScope.createModuleReference(
@@ -435,7 +443,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 						ids,
 						call: dep.call,
 						directImport: dep.directImport,
-						asiSafe: dep.asiSafe
+						asiSafe: dep.asiSafe,
+						deferredImport: dep.defer
 					}
 				);
 			}
@@ -448,6 +457,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 			exportExpr = runtimeTemplate.exportFromImport({
 				moduleGraph,
 				module: /** @type {Module} */ (moduleGraph.getModule(dep)),
+				chunkGraph: templateContext.chunkGraph,
 				request: dep.request,
 				exportName: ids,
 				originModule: module,
@@ -458,7 +468,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				importVar: dep.getImportVar(moduleGraph),
 				initFragments,
 				runtime,
-				runtimeRequirements
+				runtimeRequirements,
+				defer: dep.defer
 			});
 		}
 		return exportExpr;