webpack 5.104.1 → 5.105.1

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -21,6 +21,7 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
 
 class HarmonyExportExpressionDependency extends NullDependency {
 	/**
@@ -120,6 +121,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 		const { declarationId } = dep;
 		const exportsName = module.exportsArgument;
 		if (declarationId) {
+			/** @type {string} */
 			let name;
 			if (typeof declarationId === "string") {
 				name = declarationId;
@@ -139,6 +141,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 					.getExportsInfo(module)
 					.getUsedName("default", runtime);
 				if (used) {
+					/** @type {ExportMap} */
 					const map = new Map();
 					map.set(used, `/* export default binding */ ${name}`);
 					initFragments.push(new HarmonyExportInitFragment(exportsName, map));
@@ -164,6 +167,7 @@ HarmonyExportExpressionDependency.Template = class HarmonyExportDependencyTempla
 						.getUsedName("default", runtime);
 					if (used) {
 						runtimeRequirements.add(RuntimeGlobals.exports);
+						/** @type {ExportMap} */
 						const map = new Map();
 						map.set(used, name);
 						initFragments.push(new HarmonyExportInitFragment(exportsName, map));

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -58,6 +58,7 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
 /** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
+/** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
 /** @typedef {import("../dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
 
 /** @typedef {"missing" | "unused" | "empty-star" | "reexport-dynamic-default" | "reexport-named-default" | "reexport-namespace-object" | "reexport-fake-namespace-object" | "reexport-undefined" | "normal-reexport" | "dynamic-reexport"} ExportModeType */
@@ -264,6 +265,7 @@ const getMode = (moduleGraph, dep, runtimeKey) => {
 
 	// reexporting with a fixed name
 	if (name) {
+		/** @type {ExportMode} */
 		let mode;
 		const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
 
@@ -464,7 +466,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {ExportsInfo} exportsInfo exports info about the current module (optional)
 	 * @param {Module} importedModule the imported module (optional)
-	 * @returns {{exports?: Exports, checked?: Checked, ignoredExports: IgnoredExports, hidden?: Hidden}} information
+	 * @returns {{ exports?: Exports, checked?: Checked, ignoredExports: IgnoredExports, hidden?: Hidden }} information
 	 */
 	getStarReexports(
 		moduleGraph,
@@ -480,8 +482,10 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		const noExtraImports =
 			exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused;
 
+		/** @type {IgnoredExports} */
 		const ignoredExports = new Set(["default", ...this.activeExports]);
 
+		/** @type {Hidden | undefined} */
 		let hiddenExports;
 		const otherStarExports =
 			this._discoverActiveExportsFromOtherStarExports(moduleGraph);
@@ -1300,6 +1304,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 
+		/** @type {ExportMap} */
 		const map = new Map();
 		map.set(key, `/* ${comment} */ ${returnValue}`);
 
@@ -1325,6 +1330,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 		runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 
+		/** @type {ExportMap} */
 		const map = new Map();
 		map.set(
 			key,
@@ -1365,6 +1371,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
 		runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
 
+		/** @type {ExportMap} */
 		const map = new Map();
 		const moduleId = JSON.stringify(chunkGraph.getModuleId(module));
 		const mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -12,6 +12,7 @@ const { propertyName } = require("../util/propertyName");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../ExportsInfo").UsedName} UsedName */
 
 /**
  * @param {Iterable<string>} iterable iterable strings
@@ -33,7 +34,12 @@ const joinIterableWithComma = (iterable) => {
 	return str;
 };
 
+/** @typedef {Map<UsedName, string>} ExportMap */
+/** @typedef {Set<string>} UnusedExports */
+
+/** @type {ExportMap} */
 const EMPTY_MAP = new Map();
+/** @type {UnusedExports} */
 const EMPTY_SET = new Set();
 
 /**
@@ -42,8 +48,8 @@ const EMPTY_SET = new Set();
 class HarmonyExportInitFragment extends InitFragment {
 	/**
 	 * @param {string} exportsArgument the exports identifier
-	 * @param {Map<string, string>} exportMap mapping from used name to exposed variable name
-	 * @param {Set<string>} unusedExports list of unused export names
+	 * @param {ExportMap} exportMap mapping from used name to exposed variable name
+	 * @param {UnusedExports} unusedExports list of unused export names
 	 */
 	constructor(
 		exportsArgument,
@@ -51,8 +57,11 @@ class HarmonyExportInitFragment extends InitFragment {
 		unusedExports = EMPTY_SET
 	) {
 		super(undefined, InitFragment.STAGE_HARMONY_EXPORTS, 1, "harmony-exports");
+		/** @type {string} */
 		this.exportsArgument = exportsArgument;
+		/** @type {ExportMap} */
 		this.exportMap = exportMap;
+		/** @type {UnusedExports} */
 		this.unusedExports = unusedExports;
 	}
 
@@ -61,8 +70,10 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @returns {HarmonyExportInitFragment} merged fragment
 	 */
 	mergeAll(fragments) {
+		/** @type {undefined | ExportMap} */
 		let exportMap;
 		let exportMapOwned = false;
+		/** @type {undefined | UnusedExports} */
 		let unusedExports;
 		let unusedExportsOwned = false;
 
@@ -108,6 +119,7 @@ class HarmonyExportInitFragment extends InitFragment {
 	 * @returns {HarmonyExportInitFragment} merged result
 	 */
 	merge(other) {
+		/** @type {ExportMap} */
 		let exportMap;
 		if (this.exportMap.size === 0) {
 			exportMap = other.exportMap;
@@ -119,6 +131,7 @@ class HarmonyExportInitFragment extends InitFragment {
 				if (!exportMap.has(key)) exportMap.set(key, value);
 			}
 		}
+		/** @type {UnusedExports} */
 		let unusedExports;
 		if (this.unusedExports.size === 0) {
 			unusedExports = other.unusedExports;
@@ -153,6 +166,7 @@ class HarmonyExportInitFragment extends InitFragment {
 				: this.unusedExports.size > 0
 					? `/* unused harmony export ${first(this.unusedExports)} */\n`
 					: "";
+		/** @type {string[]} */
 		const definitions = [];
 		const orderedExportMap = [...this.exportMap].sort(([a], [b]) =>
 			a < b ? -1 : 1
@@ -160,7 +174,7 @@ class HarmonyExportInitFragment extends InitFragment {
 		for (const [key, value] of orderedExportMap) {
 			definitions.push(
 				`\n/* harmony export */   ${propertyName(
-					key
+					/** @type {string} */ (key)
 				)}: ${runtimeTemplate.returningFunction(value)}`
 			);
 		}

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -17,6 +17,8 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./HarmonyExportInitFragment").UnusedExports} UnusedExports */
+/** @typedef {import("./HarmonyExportInitFragment").ExportMap} ExportMap */
 
 class HarmonyExportSpecifierDependency extends NullDependency {
 	/**
@@ -104,6 +106,7 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			.getExportsInfo(module)
 			.getUsedName(dep.name, runtime);
 		if (!used) {
+			/** @type {UnusedExports} */
 			const set = new Set();
 			set.add(dep.name || "namespace");
 			initFragments.push(
@@ -112,6 +115,7 @@ HarmonyExportSpecifierDependency.Template = class HarmonyExportSpecifierDependen
 			return;
 		}
 
+		/** @type {ExportMap} */
 		const map = new Map();
 		map.set(used, `/* binding */ ${dep.id}`);
 		initFragments.push(

package/lib/dependencies/HarmonyImportDependency.js

@@ -29,7 +29,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {0 | 1 | 2 | 3 | false} ExportPresenceMode */
+/** @typedef {0 | 1 | 2 | 3} ExportPresenceMode */
 
 const ExportPresenceModes = {
 	NONE: /** @type {ExportPresenceMode} */ (0),

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -12,6 +12,7 @@ const {
 	getImportAttributes
 } = require("../javascript/JavascriptParser");
 const InnerGraph = require("../optimize/InnerGraph");
+const AppendOnlyStackedSet = require("../util/AppendOnlyStackedSet");
 const ConstDependency = require("./ConstDependency");
 const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
@@ -36,9 +37,18 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
 /** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
 /** @typedef {import("./HarmonyImportDependency").Ids} Ids */
+/** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
+/**
+ * @typedef {object} HarmonySpecifierGuards
+ * @property {AppendOnlyStackedSet<string> | undefined} guards
+ */
+
+/** @typedef {Map<string, Set<string>>} Guards Map of import root to guarded member keys */
+
 const harmonySpecifierTag = Symbol("harmony import");
+const harmonySpecifierGuardTag = Symbol("harmony import guard");
 
 /**
  * @typedef {object} HarmonySettings
@@ -53,12 +63,25 @@ const harmonySpecifierTag = Symbol("harmony import");
 
 const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 
+/** @type {(members: Members) => string} */
+const getMembersKey = (members) => members.join(".");
+
+/**
+ * Strip the root binding name if needed
+ * @param {HarmonySettings} settings settings
+ * @param {Ids} ids ids
+ * @returns {Ids} ids for presence check
+ */
+const getIdsForPresence = (settings, ids) =>
+	settings.ids.length ? ids.slice(1) : ids;
+
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
 		this.options = options;
+		/** @type {ExportPresenceMode} */
 		this.exportPresenceMode =
 			options.importExportsPresence !== undefined
 				? ExportPresenceModes.fromUserOption(options.importExportsPresence)
@@ -70,13 +93,30 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Ids} ids ids
+	 * @returns {ExportPresenceMode} exportPresenceMode
+	 */
+	getExportPresenceMode(parser, ids) {
+		const harmonySettings = /** @type {HarmonySettings=} */ (
+			parser.currentTagData
+		);
+		if (!harmonySettings) return this.exportPresenceMode;
+
+		const data = /** @type {HarmonySpecifierGuards=} */ (
+			parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
+		);
+		return data && data.guards && data.guards.has(getMembersKey(ids))
+			? ExportPresenceModes.NONE
+			: this.exportPresenceMode;
+	}
+
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		const { exportPresenceMode } = this;
-
 		const getImportPhase = createGetImportPhase(this.options.deferImport);
 
 		/**
@@ -228,6 +268,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
@@ -235,7 +276,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					settings.name,
 					/** @type {Range} */
 					(expr.range),
-					exportPresenceMode,
+					this.getExportPresenceMode(
+						parser,
+						getIdsForPresence(settings, settings.ids)
+					),
 					settings.phase,
 					settings.attributes,
 					[]
@@ -285,7 +329,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						settings.name,
 						/** @type {Range} */
 						(expr.range),
-						exportPresenceMode,
+						this.getExportPresenceMode(
+							parser,
+							getIdsForPresence(settings, ids)
+						),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -335,7 +382,10 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						ids,
 						settings.name,
 						/** @type {Range} */ (expr.range),
-						exportPresenceMode,
+						this.getExportPresenceMode(
+							parser,
+							getIdsForPresence(settings, ids)
+						),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -402,7 +452,221 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				parser.state.module.addDependency(dep);
 			}
 		});
+
+		/**
+		 * @param {Expression} expression expression
+		 * @returns {{ root: string, members: Members } | undefined} info
+		 */
+		const getHarmonyImportInfo = (expression) => {
+			const nameInfo = parser.getNameForExpression(expression);
+			if (!nameInfo) return;
+
+			const rootInfo = nameInfo.rootInfo;
+			const root =
+				typeof rootInfo === "string"
+					? rootInfo
+					: rootInfo instanceof VariableInfo
+						? rootInfo.name
+						: undefined;
+			if (!root) return;
+			if (!parser.getTagData(root, harmonySpecifierTag)) return;
+			return { root, members: nameInfo.getMembers() };
+		};
+
+		/**
+		 * @param {Guards} guards guards
+		 * @param {string} root root name
+		 * @param {Members} members members
+		 */
+		const addToGuards = (guards, root, members) => {
+			const membersKey = getMembersKey(members);
+			const guardedMembers = guards.get(root);
+			if (guardedMembers) {
+				guardedMembers.add(membersKey);
+				return;
+			}
+
+			guards.set(
+				root,
+				// Adding `foo.bar` implies guarding `foo` as well
+				membersKey === "" ? new Set([""]) : new Set([membersKey, ""])
+			);
+		};
+
+		/**
+		 * @param {Expression} expression expression
+		 * @param {Guards} guards guards
+		 * @param {boolean} needTruthy need to be truthy
+		 */
+		const collect = (expression, guards, needTruthy) => {
+			// !foo
+			if (
+				expression.type === "UnaryExpression" &&
+				expression.operator === "!"
+			) {
+				collect(expression.argument, guards, !needTruthy);
+				return;
+			} else if (expression.type === "LogicalExpression" && needTruthy) {
+				// foo && bar
+				if (expression.operator === "&&") {
+					collect(expression.left, guards, true);
+					collect(expression.right, guards, true);
+				}
+				// falsy || foo
+				else if (expression.operator === "||") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					const leftBool = leftEvaluation.asBool();
+					if (leftBool === false) {
+						collect(expression.right, guards, true);
+					}
+				}
+				// nullish ?? foo
+				else if (expression.operator === "??") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					const leftNullish = leftEvaluation.asNullish();
+					if (leftNullish === true) {
+						collect(expression.right, guards, true);
+					}
+				}
+				return;
+			}
+			if (!needTruthy) return;
+
+			/**
+			 * @param {Expression} targetExpression expression
+			 * @returns {boolean} is added
+			 */
+			const addGuardForExpression = (targetExpression) => {
+				const info = getHarmonyImportInfo(targetExpression);
+				if (!info) return false;
+				addToGuards(guards, info.root, info.members);
+				return true;
+			};
+
+			/**
+			 * @param {Expression} left left expression
+			 * @param {Expression} right right expression
+			 * @param {(evaluation: ReturnType<JavascriptParser["evaluateExpression"]>) => boolean} matcher matcher
+			 * @returns {boolean} is added
+			 */
+			const addGuardForNullishCompare = (left, right, matcher) => {
+				const leftEval = parser.evaluateExpression(left);
+				if (leftEval && matcher(leftEval)) {
+					return addGuardForExpression(right);
+				}
+				const rightEval = parser.evaluateExpression(right);
+				if (rightEval && matcher(rightEval)) {
+					return addGuardForExpression(/** @type {Expression} */ (left));
+				}
+				return false;
+			};
+
+			if (expression.type === "BinaryExpression") {
+				// "bar" in foo
+				if (expression.operator === "in") {
+					const leftEvaluation = parser.evaluateExpression(expression.left);
+					if (leftEvaluation.couldHaveSideEffects()) return;
+					const propertyName = leftEvaluation.asString();
+					if (!propertyName) return;
+					parser.evaluateExpression(expression.right);
+					const info = getHarmonyImportInfo(expression.right);
+					if (!info) return;
+
+					if (info.members.length) {
+						for (const member of info.members) {
+							addToGuards(guards, info.root, [member]);
+						}
+					}
+					addToGuards(guards, info.root, [...info.members, propertyName]);
+					return;
+				}
+				// foo !== undefined
+				else if (
+					expression.operator === "!==" &&
+					addGuardForNullishCompare(
+						/** @type {Expression} */ (expression.left),
+						expression.right,
+						(evaluation) => evaluation.isUndefined()
+					)
+				) {
+					return;
+				}
+				// foo != undefined
+				// foo != null
+				else if (
+					expression.operator === "!=" &&
+					addGuardForNullishCompare(
+						/** @type {Expression} */ (expression.left),
+						expression.right,
+						(evaluation) => Boolean(evaluation.asNullish())
+					)
+				) {
+					return;
+				}
+			}
+			addGuardForExpression(expression);
+		};
+
+		/**
+		 * @param {Guards} guards guards
+		 * @param {() => void} walk walk callback
+		 * @returns {void}
+		 */
+		const withGuards = (guards, walk) => {
+			const applyGuards = () => {
+				/** @type {(() => void)[]} */
+				const restoreFns = [];
+
+				for (const [rootName, members] of guards) {
+					const previous = parser.getVariableInfo(rootName);
+					const exist = /** @type {HarmonySpecifierGuards=} */ (
+						parser.getTagData(rootName, harmonySpecifierGuardTag)
+					);
+
+					const mergedGuards =
+						exist && exist.guards
+							? exist.guards.createChild()
+							: new AppendOnlyStackedSet();
+
+					for (const memberKey of members) mergedGuards.add(memberKey);
+					parser.tagVariable(rootName, harmonySpecifierGuardTag, {
+						guards: mergedGuards
+					});
+					restoreFns.push(() => {
+						parser.setVariable(rootName, previous);
+					});
+				}
+
+				return () => {
+					for (const restore of restoreFns) {
+						restore();
+					}
+				};
+			};
+
+			const restore = applyGuards();
+			try {
+				walk();
+			} finally {
+				restore();
+			}
+		};
+
+		if (this.exportPresenceMode !== ExportPresenceModes.NONE) {
+			parser.hooks.collectGuards.tap(PLUGIN_NAME, (expression) => {
+				if (parser.scope.isAsmJs) return;
+				/** @type {Guards} */
+				const guards = new Map();
+				collect(expression, guards, true);
+
+				if (guards.size === 0) return;
+				return (walk) => {
+					withGuards(guards, walk);
+				};
+			});
+		}
 	}
 };
 
+module.exports.harmonySpecifierGuardTag = harmonySpecifierGuardTag;
 module.exports.harmonySpecifierTag = harmonySpecifierTag;

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const Dependency = require("../Dependency");
+const InitFragment = require("../InitFragment");
 const Template = require("../Template");
 const {
 	getDependencyUsedByExportsCondition
@@ -72,10 +73,15 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.range = range;
 		this.idRanges = idRanges;
 		this.exportPresenceMode = exportPresenceMode;
+		/** @type {undefined | boolean} */
 		this.namespaceObjectAsContext = false;
+		/** @type {undefined | boolean} */
 		this.call = undefined;
+		/** @type {undefined | boolean} */
 		this.directImport = undefined;
+		/** @type {undefined | boolean | string} */
 		this.shorthand = undefined;
+		/** @type {undefined | boolean} */
 		this.asiSafe = undefined;
 		/** @type {UsedByExports | undefined} */
 		this.usedByExports = undefined;
@@ -336,10 +342,22 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {HarmonyImportSpecifierDependency} */ (dependency);
-		const { moduleGraph, runtime } = templateContext;
+		const { moduleGraph, runtime, initFragments } = templateContext;
 		const connection = moduleGraph.getConnection(dep);
-		// Skip rendering depending when dependency is conditional
-		if (connection && !connection.isTargetActive(runtime)) return;
+
+		// Only render declaration for import specifier when the dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) {
+			initFragments.push(
+				new InitFragment(
+					`/* unused harmony import specifier */ var ${dep.name};\n`,
+					InitFragment.STAGE_HARMONY_IMPORTS,
+					0,
+					`unused import specifier ${dep.name}`
+				)
+			);
+
+			return;
+		}
 
 		const ids = dep.getIds(moduleGraph);
 		const {
@@ -431,6 +449,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 		const { moduleGraph, module, runtime, concatenationScope } =
 			templateContext;
 		const connection = moduleGraph.getConnection(dep);
+		/** @type {string} */
 		let exportExpr;
 		if (
 			connection &&

package/lib/dependencies/ImportDependency.js

@@ -67,6 +67,7 @@ class ImportDependency extends ModuleDependency {
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		if (!this.referencedExports) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		/** @type {ReferencedExports} */
 		const refs = [];
 		for (const referencedExport of this.referencedExports) {
 			if (referencedExport[0] === "default") {

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -84,6 +84,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 				);
 				if (!requestExpr.isString()) return;
 				const request = /** @type {string} */ (requestExpr.string);
+				/** @type {WebpackError[]} */
 				const errors = [];
 				let regExp = /^\.\/.*$/;
 				let recursive = true;