webpack 5.97.1 → 5.104.1

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -13,28 +13,31 @@ const {
 const { getTrimmedIdsAndRange } = require("../util/chainedImports");
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
+const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const { ImportPhaseUtils } = require("./ImportPhase");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../optimize/InnerGraph").UsedByExports} UsedByExports */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
+/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
+/** @typedef {HarmonyImportDependency.Ids} Ids */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
 
@@ -44,12 +47,13 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	/**
 	 * @param {string} request request
 	 * @param {number} sourceOrder source order
-	 * @param {string[]} ids ids
+	 * @param {Ids} ids ids
 	 * @param {string} name name
 	 * @param {Range} range range
-	 * @param {TODO} exportPresenceMode export presence mode
+	 * @param {ExportPresenceMode} exportPresenceMode export presence mode
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes | undefined} attributes import attributes
-	 * @param {Range[] | undefined} idRanges ranges for members of ids; the two arrays are right-aligned
+	 * @param {IdRanges | undefined} idRanges ranges for members of ids; the two arrays are right-aligned
 	 */
 	constructor(
 		request,
@@ -58,10 +62,11 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		name,
 		range,
 		exportPresenceMode,
+		phase,
 		attributes,
 		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
 	) {
-		super(request, sourceOrder, attributes);
+		super(request, sourceOrder, phase, attributes);
 		this.ids = ids;
 		this.name = name;
 		this.range = range;
@@ -72,9 +77,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.directImport = undefined;
 		this.shorthand = undefined;
 		this.asiSafe = undefined;
-		/** @type {Set<string> | boolean | undefined} */
+		/** @type {UsedByExports | undefined} */
 		this.usedByExports = undefined;
-		/** @type {Set<DestructuringAssignmentProperty> | undefined} */
+		/** @type {DestructuringAssignmentProperties | undefined} */
 		this.referencedPropertiesInDestructuring = undefined;
 	}
 
@@ -99,23 +104,22 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported ids
+	 * @returns {Ids} the imported ids
 	 */
 	getIds(moduleGraph) {
 		const meta = moduleGraph.getMetaIfExisting(this);
 		if (meta === undefined) return this.ids;
-		const ids = meta[/** @type {keyof object} */ (idsSymbol)];
+		const ids = meta[idsSymbol];
 		return ids !== undefined ? ids : this.ids;
 	}
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
+	 * @param {Ids} ids the imported ids
 	 * @returns {void}
 	 */
 	setIds(moduleGraph, ids) {
-		/** @type {TODO} */
-		(moduleGraph.getMeta(this))[idsSymbol] = ids;
+		moduleGraph.getMeta(this)[idsSymbol] = ids;
 	}
 
 	/**
@@ -142,7 +146,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		let ids = this.getIds(moduleGraph);
@@ -164,8 +168,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;
@@ -187,15 +192,21 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	}
 
 	/**
-	 * @param {string[]=} ids ids
-	 * @returns {string[][]} referenced exports
+	 * @param {Ids=} ids ids
+	 * @returns {RawReferencedExports} referenced exports
 	 */
 	_getReferencedExportsInDestructuring(ids) {
 		if (this.referencedPropertiesInDestructuring) {
-			/** @type {string[][]} */
+			/** @type {RawReferencedExports} */
+			const refsInDestructuring = [];
+			traverseDestructuringAssignmentProperties(
+				this.referencedPropertiesInDestructuring,
+				(stack) => refsInDestructuring.push(stack.map((p) => p.id))
+			);
+			/** @type {RawReferencedExports} */
 			const refs = [];
-			for (const { id } of this.referencedPropertiesInDestructuring) {
-				refs.push(ids ? ids.concat([id]) : [id]);
+			for (const idsInDestructuring of refsInDestructuring) {
+				refs.push(ids ? [...ids, ...idsInDestructuring] : idsInDestructuring);
 			}
 			return refs;
 		}
@@ -204,11 +215,12 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {number} effective mode
+	 * @returns {ExportPresenceMode} effective mode
 	 */
 	_getEffectiveExportPresenceLevel(moduleGraph) {
-		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
+		if (this.exportPresenceMode !== ExportPresenceModes.AUTO) {
 			return this.exportPresenceMode;
+		}
 		const buildMeta =
 			/** @type {BuildMeta} */
 			(
@@ -371,12 +383,23 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				}
 			}
 
-			for (const {
-				id,
-				shorthand,
-				range
-			} of dep.referencedPropertiesInDestructuring) {
-				const concatedIds = prefixedIds.concat([id]);
+			/** @type {{ ids: Ids, range: Range, shorthand: boolean | string }[]} */
+			const replacementsInDestructuring = [];
+			traverseDestructuringAssignmentProperties(
+				dep.referencedPropertiesInDestructuring,
+				undefined,
+				(stack) => {
+					const property = stack[stack.length - 1];
+					replacementsInDestructuring.push({
+						ids: stack.map((p) => p.id),
+						range: property.range,
+						shorthand: property.shorthand
+					});
+				}
+			);
+			for (const { ids, shorthand, range } of replacementsInDestructuring) {
+				/** @type {Ids} */
+				const concatedIds = [...prefixedIds, ...ids];
 				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 				const used = moduleGraph
 					.getExportsInfo(module)
@@ -389,10 +412,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				const comment = `${Template.toNormalComment(name)} `;
 				const key = comment + JSON.stringify(newName);
 				source.replace(
-					/** @type {Range} */
-					(range)[0],
-					/** @type {Range} */
-					(range)[1] - 1,
+					range[0],
+					range[1] - 1,
 					shorthand ? `${key}: ${name}` : `${key}`
 				);
 			}
@@ -403,7 +424,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	 * @param {HarmonyImportSpecifierDependency} dep dependency
 	 * @param {ReplaceSource} source source
 	 * @param {DependencyTemplateContext} templateContext context
-	 * @param {string[]} ids ids
+	 * @param {Ids} ids ids
 	 * @returns {string} generated code
 	 */
 	_getCodeForIds(dep, source, templateContext, ids) {
@@ -420,13 +441,15 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				exportExpr = concatenationScope.createModuleReference(
 					connection.module,
 					{
-						asiSafe: dep.asiSafe
+						asiSafe: dep.asiSafe,
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
 			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
 				exportExpr =
 					concatenationScope.createModuleReference(connection.module, {
-						asiSafe: dep.asiSafe
+						asiSafe: dep.asiSafe,
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}) + propertyAccess(ids);
 			} else {
 				exportExpr = concatenationScope.createModuleReference(
@@ -435,7 +458,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 						ids,
 						call: dep.call,
 						directImport: dep.directImport,
-						asiSafe: dep.asiSafe
+						asiSafe: dep.asiSafe,
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
 			}
@@ -448,6 +472,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 +483,8 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				importVar: dep.getImportVar(moduleGraph),
 				initFragments,
 				runtime,
-				runtimeRequirements
+				runtimeRequirements,
+				dependency: dep
 			});
 		}
 		return exportExpr;
@@ -466,3 +492,4 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 };
 
 module.exports = HarmonyImportSpecifierDependency;
+module.exports.idsSymbol = idsSymbol;

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -5,33 +5,36 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
 const HarmonyCompatibilityDependency = require("./HarmonyCompatibilityDependency");
+const HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin");
 const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
+const HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin");
 const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDependency");
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
 const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
 
-const {
-	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("../ModuleTypeConstants");
-const HarmonyDetectionParserPlugin = require("./HarmonyDetectionParserPlugin");
-const HarmonyExportDependencyParserPlugin = require("./HarmonyExportDependencyParserPlugin");
-const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
 const HarmonyTopLevelThisParserPlugin = require("./HarmonyTopLevelThisParserPlugin");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 
-const PLUGIN_NAME = "HarmonyModulesPlugin";
+/**
+ * @typedef {object} HarmonyModulesPluginOptions
+ * @property {boolean=} deferImport
+ */
 
-/** @typedef {{ topLevelAwait?: boolean }} HarmonyModulesPluginOptions */
+const PLUGIN_NAME = "HarmonyModulesPlugin";
 
 class HarmonyModulesPlugin {
 	/**
@@ -127,10 +130,11 @@ class HarmonyModulesPlugin {
 				 */
 				const handler = (parser, parserOptions) => {
 					// TODO webpack 6: rename harmony to esm or module
-					if (parserOptions.harmony !== undefined && !parserOptions.harmony)
+					if (parserOptions.harmony !== undefined && !parserOptions.harmony) {
 						return;
+					}
 
-					new HarmonyDetectionParserPlugin(this.options).apply(parser);
+					new HarmonyDetectionParserPlugin().apply(parser);
 					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyTopLevelThisParserPlugin().apply(parser);
@@ -146,4 +150,5 @@ class HarmonyModulesPlugin {
 		);
 	}
 }
+
 module.exports = HarmonyModulesPlugin;

package/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -12,27 +12,27 @@ const HarmonyExports = require("./HarmonyExports");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";
+
 class HarmonyTopLevelThisParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.expression
-			.for("this")
-			.tap("HarmonyTopLevelThisParserPlugin", node => {
-				if (!parser.scope.topLevelScope) return;
-				if (HarmonyExports.isEnabled(parser.state)) {
-					const dep = new ConstDependency(
-						"undefined",
-						/** @type {Range} */ (node.range),
-						null
-					);
-					dep.loc = /** @type {DependencyLocation} */ (node.loc);
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
-			});
+		parser.hooks.expression.for("this").tap(PLUGIN_NAME, (node) => {
+			if (!parser.scope.topLevelScope) return;
+			if (HarmonyExports.isEnabled(parser.state)) {
+				const dep = new ConstDependency(
+					"undefined",
+					/** @type {Range} */ (node.range),
+					null
+				);
+				dep.loc = /** @type {DependencyLocation} */ (node.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		});
 	}
 }
 

package/lib/dependencies/ImportContextDependency.js

@@ -12,10 +12,11 @@ const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTempl
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class ImportContextDependency extends ContextDependency {
 	/**
-	 * @param {TODO} options options
+	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 * @param {Range} valueRange value range
 	 */
@@ -34,6 +35,19 @@ class ImportContextDependency extends ContextDependency {
 		return "esm";
 	}
 
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = super.getResourceIdentifier();
+
+		if (this.options.attributes) {
+			str += `|importAttributes${JSON.stringify(this.options.attributes)}`;
+		}
+
+		return str;
+	}
+
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */

package/lib/dependencies/ImportDependency.js

@@ -11,7 +11,8 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
@@ -21,19 +22,22 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportDependency extends ModuleDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
+	constructor(request, range, referencedExports, phase, attributes) {
 		super(request);
 		this.range = range;
 		this.referencedExports = referencedExports;
-		this.assertions = attributes;
+		this.phase = phase;
+		this.attributes = attributes;
 	}
 
 	get type() {
@@ -44,11 +48,22 @@ class ImportDependency extends ModuleDependency {
 		return "esm";
 	}
 
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		let str = super.getResourceIdentifier();
+		if (this.attributes) {
+			str += `|importAttributes${JSON.stringify(this.attributes)}`;
+		}
+		return str;
+	}
+
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		if (!this.referencedExports) return Dependency.EXPORTS_OBJECT_REFERENCED;
@@ -87,7 +102,8 @@ class ImportDependency extends ModuleDependency {
 	serialize(context) {
 		context.write(this.range);
 		context.write(this.referencedExports);
-		context.write(this.assertions);
+		context.write(this.phase);
+		context.write(this.attributes);
 		super.serialize(context);
 	}
 
@@ -97,7 +113,8 @@ class ImportDependency extends ModuleDependency {
 	deserialize(context) {
 		this.range = context.read();
 		this.referencedExports = context.read();
-		this.assertions = context.read();
+		this.phase = context.read();
+		this.attributes = context.read();
 		super.deserialize(context);
 	}
 }
@@ -128,6 +145,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
+			dependency: dep,
 			message: "import()",
 			runtimeRequirements
 		});

package/lib/dependencies/ImportEagerDependency.js

@@ -10,23 +10,24 @@ const ImportDependency = require("./ImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportEagerDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {(string[][] | null)=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
-		super(request, range, referencedExports, attributes);
+	constructor(request, range, referencedExports, phase, attributes) {
+		super(request, range, referencedExports, phase, attributes);
 	}
 
 	get type() {
@@ -64,6 +65,7 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() eager",
+			dependency: dep,
 			runtimeRequirements
 		});
 

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -14,26 +14,32 @@ const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
 /** @typedef {import("estree").Property} Property */
-/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../ContextModule").ContextModuleOptions} ContextModuleOptions */
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
+/** @typedef {import("../Chunk").ChunkName} ChunkName */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
+/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {Pick<ContextModuleOptions, 'mode'|'recursive'|'regExp'|'include'|'exclude'|'chunkName'>&{groupOptions: RawChunkGroupOptions, exports?: ContextModuleOptions["referencedExports"]}} ImportMetaContextOptions */
+
+/** @typedef {Pick<ContextModuleOptions, "mode" | "recursive" | "regExp" | "include" | "exclude" | "chunkName"> & { groupOptions: RawChunkGroupOptions, exports?: RawReferencedExports }} ImportMetaContextOptions */
 
 /**
- * @param {TODO} prop property
+ * @param {Property} prop property
  * @param {string} expect except message
  * @returns {WebpackError} error
  */
 function createPropertyParseError(prop, expect) {
 	return createError(
 		`Parsing import.meta.webpackContext options failed. Unknown value for property ${JSON.stringify(
-			prop.key.name
+			/** @type {Identifier} */
+			(prop.key).name
 		)}, expected type ${expect}.`,
-		prop.value.loc
+		/** @type {DependencyLocation} */
+		(prop.value.loc)
 	);
 }
 
@@ -49,6 +55,8 @@ function createError(msg, loc) {
 	return error;
 }
 
+const PLUGIN_NAME = "ImportMetaContextDependencyParserPlugin";
+
 module.exports = class ImportMetaContextDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
@@ -57,7 +65,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 	apply(parser) {
 		parser.hooks.evaluateIdentifier
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr =>
+			.tap(PLUGIN_NAME, (expr) =>
 				evaluateToIdentifier(
 					"import.meta.webpackContext",
 					"import.meta",
@@ -67,7 +75,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 			);
 		parser.hooks.call
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr => {
+			.tap(PLUGIN_NAME, (expr) => {
 				if (expr.arguments.length < 1 || expr.arguments.length > 2) return;
 				const [directoryNode, optionsNode] = expr.arguments;
 				if (optionsNode && optionsNode.type !== "ObjectExpression") return;
@@ -79,7 +87,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 				const errors = [];
 				let regExp = /^\.\/.*$/;
 				let recursive = true;
-				/** @type {ContextModuleOptions["mode"]} */
+				/** @type {ContextMode} */
 				let mode = "sync";
 				/** @type {ContextModuleOptions["include"]} */
 				let include;
@@ -87,9 +95,9 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 				let exclude;
 				/** @type {RawChunkGroupOptions} */
 				const groupOptions = {};
-				/** @type {ContextModuleOptions["chunkName"]} */
+				/** @type {ChunkName | undefined} */
 				let chunkName;
-				/** @type {ContextModuleOptions["referencedExports"]} */
+				/** @type {RawReferencedExports | undefined} */
 				let exports;
 				if (optionsNode) {
 					for (const prop of /** @type {ObjectExpression} */ (optionsNode)
@@ -98,7 +106,8 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 							errors.push(
 								createError(
 									"Parsing import.meta.webpackContext options failed.",
-									/** @type {DependencyLocation} */ (optionsNode.loc)
+									/** @type {DependencyLocation} */
+									(optionsNode.loc)
 								)
 							);
 							break;
@@ -172,14 +181,15 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 										/** @type {BasicEvaluatedExpression[]} */
 										(expr.items);
 									if (
-										items.every(i => {
+										items.every((i) => {
 											if (!i.isArray()) return false;
 											const innerItems =
 												/** @type {BasicEvaluatedExpression[]} */ (i.items);
-											return innerItems.every(i => i.isString());
+											return innerItems.every((i) => i.isString());
 										})
 									) {
 										exports = [];
+
 										for (const i1 of items) {
 											/** @type {string[]} */
 											const export_ = [];

package/lib/dependencies/ImportMetaContextPlugin.js

@@ -14,7 +14,6 @@ const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 const ImportMetaContextDependencyParserPlugin = require("./ImportMetaContextDependencyParserPlugin");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 
@@ -52,8 +51,9 @@ class ImportMetaContextPlugin {
 					if (
 						parserOptions.importMetaContext !== undefined &&
 						!parserOptions.importMetaContext
-					)
+					) {
 						return;
+					}
 
 					new ImportMetaContextDependencyParserPlugin().apply(parser);
 				};