webpack 5.100.2 → 5.101.1

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const Template = require("../Template");
+const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const NullDependency = require("./NullDependency");
@@ -17,6 +18,8 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./HarmonyAcceptImportDependency")} HarmonyAcceptImportDependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ModuleId} ModuleId */
 
 class HarmonyAcceptDependency extends NullDependency {
 	/**
@@ -82,8 +85,75 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 			moduleGraph,
 			chunkGraph
 		} = templateContext;
-		const content = dep.dependencies
-			.map(dependency => {
+
+		/**
+		 * @param {Dependency} dependency the dependency to get module id for
+		 * @returns {ModuleId | null} the module id or null if not found
+		 */
+		const getDependencyModuleId = (dependency) =>
+			chunkGraph.getModuleId(
+				/** @type {Module} */ (moduleGraph.getModule(dependency))
+			);
+
+		/**
+		 * @param {Dependency} a the first dependency
+		 * @param {Dependency} b the second dependency
+		 * @returns {boolean} true if the dependencies are related
+		 */
+		const isRelatedHarmonyImportDependency = (a, b) =>
+			a !== b &&
+			b instanceof HarmonyImportDependency &&
+			getDependencyModuleId(a) === getDependencyModuleId(b);
+
+		/**
+		 * HarmonyAcceptImportDependency lacks a lot of information, such as the defer property.
+		 * One HarmonyAcceptImportDependency may need to generate multiple ImportStatements.
+		 * Therefore, we find its original HarmonyImportDependency for code generation.
+		 * @param {HarmonyAcceptImportDependency} dependency the dependency to get harmony import dependencies for
+		 * @returns {HarmonyImportDependency[]} array of related harmony import dependencies
+		 */
+		const getHarmonyImportDependencies = (dependency) => {
+			const result = [];
+			let deferDependency = null;
+			let noDeferredDependency = null;
+
+			for (const d of module.dependencies) {
+				if (deferDependency && noDeferredDependency) break;
+				if (isRelatedHarmonyImportDependency(dependency, d)) {
+					if (d.defer) {
+						deferDependency = /** @type {HarmonyImportDependency} */ (d);
+					} else {
+						noDeferredDependency = /** @type {HarmonyImportDependency} */ (d);
+					}
+				}
+			}
+			if (deferDependency) result.push(deferDependency);
+			if (noDeferredDependency) result.push(noDeferredDependency);
+			if (result.length === 0) {
+				// fallback to the original dependency
+				result.push(dependency);
+			}
+			return result;
+		};
+
+		/** @type {HarmonyImportDependency[]} */
+		const syncDeps = [];
+
+		/** @type {HarmonyAcceptImportDependency[]} */
+		const asyncDeps = [];
+
+		for (const dependency of dep.dependencies) {
+			const connection = moduleGraph.getConnection(dependency);
+
+			if (connection && moduleGraph.isAsync(connection.module)) {
+				asyncDeps.push(dependency);
+			} else {
+				syncDeps.push(...getHarmonyImportDependencies(dependency));
+			}
+		}
+
+		let content = syncDeps
+			.map((dependency) => {
 				const referencedModule = moduleGraph.getModule(dependency);
 				return {
 					dependency,
@@ -112,17 +182,33 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 			})
 			.join("");
 
+		const promises = new Map(
+			asyncDeps.map((dependency) => [
+				dependency.getImportVar(moduleGraph),
+				dependency.getModuleExports(templateContext)
+			])
+		);
+
+		let optAsync = "";
+		if (promises.size !== 0) {
+			optAsync = "async ";
+			content += new AwaitDependenciesInitFragment(promises).getContent({
+				...templateContext,
+				type: "javascript"
+			});
+		}
+
 		if (dep.hasCallback) {
 			if (runtimeTemplate.supportsArrowFunction()) {
 				source.insert(
 					dep.range[0],
-					`__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content}(`
+					`${optAsync}__WEBPACK_OUTDATED_DEPENDENCIES__ => { ${content} return (`
 				);
 				source.insert(dep.range[1], ")(__WEBPACK_OUTDATED_DEPENDENCIES__); }");
 			} else {
 				source.insert(
 					dep.range[0],
-					`function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content}(`
+					`${optAsync}function(__WEBPACK_OUTDATED_DEPENDENCIES__) { ${content} return (`
 				);
 				source.insert(
 					dep.range[1],
@@ -135,7 +221,7 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 		const arrow = runtimeTemplate.supportsArrowFunction();
 		source.insert(
 			dep.range[1] - 0.5,
-			`, ${arrow ? "() =>" : "function()"} { ${content} }`
+			`, ${arrow ? `${optAsync}() =>` : `${optAsync}function()`} { ${content} }`
 		);
 	}
 };

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -31,13 +31,13 @@ module.exports = class HarmonyDetectionParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.program.tap(PLUGIN_NAME, ast => {
+		parser.hooks.program.tap(PLUGIN_NAME, (ast) => {
 			const isStrictHarmony =
 				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
 			const isHarmony =
 				isStrictHarmony ||
 				ast.body.some(
-					statement =>
+					(statement) =>
 						statement.type === "ImportDeclaration" ||
 						statement.type === "ExportDefaultDeclaration" ||
 						statement.type === "ExportNamedDeclaration" ||

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -33,9 +33,8 @@ const PLUGIN_NAME = "HarmonyExportDependencyParserPlugin";
 module.exports = class HarmonyExportDependencyParserPlugin {
 	/**
 	 * @param {import("../../declarations/WebpackOptions").JavascriptParserOptions} options options
-	 * @param {boolean=} deferImport defer import enabled
 	 */
-	constructor(options, deferImport) {
+	constructor(options) {
 		this.exportPresenceMode =
 			options.reexportExportsPresence !== undefined
 				? ExportPresenceModes.fromUserOption(options.reexportExportsPresence)
@@ -44,7 +43,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 					: options.strictExportPresence
 						? ExportPresenceModes.ERROR
 						: ExportPresenceModes.AUTO;
-		this.deferImport = deferImport;
+		this.deferImport = options.deferImport;
 	}
 
 	/**
@@ -53,7 +52,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 	 */
 	apply(parser) {
 		const { exportPresenceMode } = this;
-		parser.hooks.export.tap(PLUGIN_NAME, statement => {
+		parser.hooks.export.tap(PLUGIN_NAME, (statement) => {
 			const dep = new HarmonyExportHeaderDependency(
 				/** @type {Range | false} */ (
 					statement.declaration && statement.declaration.range
@@ -77,13 +76,16 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
 			clearDep.loc.index = -1;
 			parser.state.module.addPresentationalDependency(clearDep);
-			const { defer } = getImportMode(parser, statement);
-			if (defer) {
-				const error = new WebpackError(
-					"Deferred re-export (`export defer * as namespace from '...'`) is not a part of the Import Defer proposal.\nUse the following code instead:\n    import defer * as namespace from '...';\n    export { namespace };"
-				);
-				error.loc = statement.loc || undefined;
-				parser.state.current.addError(error);
+			let defer = false;
+			if (this.deferImport) {
+				({ defer } = getImportMode(parser, statement));
+				if (defer) {
+					const error = new WebpackError(
+						"Deferred re-export (`export defer * as namespace from '...'`) is not a part of the Import Defer proposal.\nUse the following code instead:\n    import defer * as namespace from '...';\n    export { namespace };"
+					);
+					error.loc = statement.loc || undefined;
+					parser.state.current.addError(error);
+				}
 			}
 			const sideEffectDep = new HarmonyImportSideEffectDependency(
 				/** @type {string} */ (source),
@@ -107,7 +109,7 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 				exprRange,
 				statementRange,
 				comments
-					.map(c => {
+					.map((c) => {
 						switch (c.type) {
 							case "Block":
 								return `/*${c.value}*/`;
@@ -202,7 +204,9 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						parser.state.harmonyStarExports || new HarmonyStarExportsList();
 				}
 				const attributes = getImportAttributes(statement);
-				const { defer } = getImportMode(parser, statement);
+				const defer = this.deferImport
+					? getImportMode(parser, statement).defer
+					: false;
 				const dep = new HarmonyExportImportedSpecifierDependency(
 					/** @type {string} */
 					(source),

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -334,7 +334,7 @@ const getMode = (moduleGraph, dep, runtimeKey) => {
 
 	mode.items = Array.from(
 		exports,
-		exportName =>
+		(exportName) =>
 			new NormalReexportItem(
 				exportName,
 				[exportName],
@@ -378,7 +378,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @param {ExportPresenceMode} exportPresenceMode mode of checking export names
 	 * @param {HarmonyStarExportsList | null} allStarExports all star exports in the module
 	 * @param {ImportAttributes=} attributes import attributes
-	 * @param {boolean=} deferEvaluation defer evaluation
+	 * @param {boolean=} defer is defer phase
 	 */
 	constructor(
 		request,
@@ -390,9 +390,9 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		exportPresenceMode,
 		allStarExports,
 		attributes,
-		deferEvaluation
+		defer
 	) {
-		super(request, sourceOrder, attributes);
+		super(request, sourceOrder, attributes, defer);
 
 		this.ids = ids;
 		this.name = name;
@@ -400,7 +400,6 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		this.otherStarExports = otherStarExports;
 		this.exportPresenceMode = exportPresenceMode;
 		this.allStarExports = allStarExports;
-		this.defer = deferEvaluation;
 	}
 
 	/**
@@ -722,7 +721,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				return {
 					exports: Array.from(
 						/** @type {NormalReexportItem[]} */ (mode.items),
-						item => ({
+						(item) => ({
 							name: item.name,
 							from,
 							export: item.ids,
@@ -930,7 +929,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 								}' contains conflicting star exports for the ${
 									exports.length > 1 ? "names" : "name"
 								} ${exports
-									.map(e => `'${e}'`)
+									.map((e) => `'${e}'`)
 									.join(", ")} with the previous requested module '${request}'`
 							)
 						);
@@ -1190,7 +1189,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 						const runtimeCondition = dep.weak
 							? false
 							: connection
-								? filterRuntime(runtime, r => connection.isTargetActive(r))
+								? filterRuntime(runtime, (r) => connection.isTargetActive(r))
 								: true;
 						initFragments.push(
 							new ConditionalInitFragment(

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -17,7 +17,7 @@ const { propertyName } = require("../util/propertyName");
  * @param {Iterable<string>} iterable iterable strings
  * @returns {string} result
  */
-const joinIterableWithComma = iterable => {
+const joinIterableWithComma = (iterable) => {
 	// This is more performant than Array.from().join(", ")
 	// as it doesn't create an array
 	let str = "";

package/lib/dependencies/HarmonyExports.js

@@ -40,7 +40,7 @@ module.exports.enable = (parserState, isStrictHarmony) => {
  * @param {ParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */
-module.exports.isEnabled = parserState => {
+module.exports.isEnabled = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
 	return value === true;
 };

package/lib/dependencies/HarmonyImportDependency.js

@@ -64,11 +64,13 @@ class HarmonyImportDependency extends ModuleDependency {
 	 * @param {string} request request string
 	 * @param {number} sourceOrder source order
 	 * @param {ImportAttributes=} attributes import attributes
+	 * @param {boolean=} defer import attributes
 	 */
-	constructor(request, sourceOrder, attributes) {
+	constructor(request, sourceOrder, attributes, defer) {
 		super(request);
 		this.sourceOrder = sourceOrder;
 		this.assertions = attributes;
+		this.defer = defer;
 	}
 
 	get category() {
@@ -112,6 +114,24 @@ class HarmonyImportDependency extends ModuleDependency {
 		return importVar;
 	}
 
+	/**
+	 * @param {DependencyTemplateContext} context the template context
+	 * @returns {string} the expression
+	 */
+	getModuleExports({
+		runtimeTemplate,
+		moduleGraph,
+		chunkGraph,
+		runtimeRequirements
+	}) {
+		return runtimeTemplate.moduleExports({
+			module: moduleGraph.getModule(this),
+			chunkGraph,
+			request: this.request,
+			runtimeRequirements
+		});
+	}
+
 	/**
 	 * @param {boolean} update create new variables or update existing one
 	 * @param {DependencyTemplateContext} templateContext the template context
@@ -183,7 +203,7 @@ class HarmonyImportDependency extends ModuleDependency {
 							new HarmonyLinkingError(
 								`export ${ids
 									.slice(0, pos)
-									.map(id => `'${id}'`)
+									.map((id) => `'${id}'`)
 									.join(".")} ${additionalMessage} was not found in '${
 									this.userRequest
 								}'${moreInfo}`
@@ -199,7 +219,7 @@ class HarmonyImportDependency extends ModuleDependency {
 				return [
 					new HarmonyLinkingError(
 						`export ${ids
-							.map(id => `'${id}'`)
+							.map((id) => `'${id}'`)
 							.join(".")} ${additionalMessage} was not found in '${
 							this.userRequest
 						}'`
@@ -215,7 +235,7 @@ class HarmonyImportDependency extends ModuleDependency {
 					return [
 						new HarmonyLinkingError(
 							`Can't import the named export ${ids
-								.map(id => `'${id}'`)
+								.map((id) => `'${id}'`)
 								.join(
 									"."
 								)} ${additionalMessage} from default-exporting module (only default export is available)`
@@ -236,7 +256,7 @@ class HarmonyImportDependency extends ModuleDependency {
 					return [
 						new HarmonyLinkingError(
 							`Should not import the named export ${ids
-								.map(id => `'${id}'`)
+								.map((id) => `'${id}'`)
 								.join(
 									"."
 								)} ${additionalMessage} from default-exporting module (only default export is available soon)`
@@ -310,7 +330,7 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 		const runtimeCondition = dep.weak
 			? false
 			: connection
-				? filterRuntime(runtime, r => connection.isTargetActive(r))
+				? filterRuntime(runtime, (r) => connection.isTargetActive(r))
 				: true;
 
 		if (module && referencedModule) {
@@ -348,10 +368,9 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 					runtimeCondition
 				)
 			);
+			const importVar = dep.getImportVar(templateContext.moduleGraph);
 			templateContext.initFragments.push(
-				new AwaitDependenciesInitFragment(
-					new Set([dep.getImportVar(templateContext.moduleGraph)])
-				)
+				new AwaitDependenciesInitFragment(new Map([[importVar, importVar]]))
 			);
 			templateContext.initFragments.push(
 				new ConditionalInitFragment(

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -59,9 +59,8 @@ const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options options
-	 * @param {boolean | undefined} deferImport defer import enabled
 	 */
-	constructor(options, deferImport) {
+	constructor(options) {
 		this.exportPresenceMode =
 			options.importExportsPresence !== undefined
 				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
@@ -71,7 +70,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						? ExportPresenceModes.ERROR
 						: ExportPresenceModes.AUTO;
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
-		this.deferImport = deferImport;
+		this.deferImport = options.deferImport;
 	}
 
 	/**
@@ -102,7 +101,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			return node;
 		}
 
-		parser.hooks.isPure.for("Identifier").tap(PLUGIN_NAME, expression => {
+		parser.hooks.isPure.for("Identifier").tap(PLUGIN_NAME, (expression) => {
 			const expr = /** @type {Identifier} */ (expression);
 			if (
 				parser.isVariableDefined(expr.name) ||
@@ -124,17 +123,20 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			parser.state.module.addPresentationalDependency(clearDep);
 			parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
 			const attributes = getImportAttributes(statement);
-			const { defer } = getImportMode(parser, statement);
-			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);
+			let defer = false;
+			if (this.deferImport) {
+				({ defer } = getImportMode(parser, statement));
+				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),
@@ -150,7 +152,9 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			PLUGIN_NAME,
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
-				const { defer } = getImportMode(parser, statement);
+				const defer = this.deferImport
+					? getImportMode(parser, statement).defer
+					: false;
 				parser.tagVariable(name, harmonySpecifierTag, {
 					name,
 					source,
@@ -162,7 +166,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				return true;
 			}
 		);
-		parser.hooks.binaryExpression.tap(PLUGIN_NAME, expression => {
+		parser.hooks.binaryExpression.tap(PLUGIN_NAME, (expression) => {
 			if (expression.operator !== "in") return;
 
 			const leftPartEvaluated = parser.evaluateExpression(expression.left);
@@ -204,34 +208,38 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			);
 			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));
+			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(
@@ -277,7 +285,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
-					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
 					return true;
 				}
 			);
@@ -331,7 +339,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
 					if (args) parser.walkExpressions(args);
-					InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+					InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
 					return true;
 				}
 			);
@@ -342,7 +350,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				// This is not a harmony module, skip it
 				return;
 			}
-			const dependencies = requests.map(request => {
+			const dependencies = requests.map((request) => {
 				const dep = new HarmonyAcceptImportDependency(request);
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addDependency(dep);
@@ -364,7 +372,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				// This is not a harmony module, skip it
 				return;
 			}
-			const dependencies = requests.map(request => {
+			const dependencies = requests.map((request) => {
 				const dep = new HarmonyAcceptImportDependency(request);
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addDependency(dep);
@@ -387,7 +395,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 /**
  * @param {JavascriptParser} parser parser
  * @param {ExportNamedDeclaration | ExportAllDeclaration | ImportDeclaration} node node
- * @returns {{defer: boolean}} import attributes
+ * @returns {{ defer: boolean }} import attributes
  */
 function getImportMode(parser, node) {
 	const result = { defer: "phase" in node && node.phase === "defer" };

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -26,11 +26,10 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	 * @param {string} request the request string
 	 * @param {number} sourceOrder source order
 	 * @param {ImportAttributes=} attributes import attributes
-	 * @param {boolean=} deferred deferred
+	 * @param {boolean=} defer is defer phase
 	 */
-	constructor(request, sourceOrder, attributes, deferred) {
-		super(request, sourceOrder, attributes);
-		this.defer = deferred;
+	constructor(request, sourceOrder, attributes, defer) {
+		super(request, sourceOrder, attributes, defer);
 	}
 
 	get type() {
@@ -42,7 +41,7 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
-		return connection => {
+		return (connection) => {
 			const refModule = connection.resolvedModule;
 			if (!refModule) return true;
 			return refModule.getSideEffectsConnectionState(moduleGraph);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -51,7 +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
+	 * @param {boolean=} defer is defer phase
 	 */
 	constructor(
 		request,
@@ -62,9 +62,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		exportPresenceMode,
 		attributes,
 		idRanges, // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
-		deferred
+		defer
 	) {
-		super(request, sourceOrder, attributes);
+		super(request, sourceOrder, attributes, defer);
 		this.ids = ids;
 		this.name = name;
 		this.range = range;
@@ -79,7 +79,6 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.usedByExports = undefined;
 		/** @type {Set<DestructuringAssignmentProperty> | undefined} */
 		this.referencedPropertiesInDestructuring = undefined;
-		this.defer = deferred;
 	}
 
 	// TODO webpack 6 remove

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -135,14 +135,8 @@ class HarmonyModulesPlugin {
 					}
 
 					new HarmonyDetectionParserPlugin(this.options).apply(parser);
-					new HarmonyImportDependencyParserPlugin(
-						parserOptions,
-						this.options.deferImport
-					).apply(parser);
-					new HarmonyExportDependencyParserPlugin(
-						parserOptions,
-						this.options.deferImport
-					).apply(parser);
+					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyTopLevelThisParserPlugin().apply(parser);
 				};
 

package/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -20,7 +20,7 @@ class HarmonyTopLevelThisParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.expression.for("this").tap(PLUGIN_NAME, node => {
+		parser.hooks.expression.for("this").tap(PLUGIN_NAME, (node) => {
 			if (!parser.scope.topLevelScope) return;
 			if (HarmonyExports.isEnabled(parser.state)) {
 				const dep = new ConstDependency(