webpack 5.92.1 → 5.94.0

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const ConditionalInitFragment = require("../ConditionalInitFragment");
 const Dependency = require("../Dependency");
 const { UsageState } = require("../ExportsInfo");
 const HarmonyLinkingError = require("../HarmonyLinkingError");
@@ -16,7 +17,11 @@ const { first, combine } = require("../util/SetHelpers");
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
 const { propertyName } = require("../util/propertyName");
-const { getRuntimeKey, keyToRuntime } = require("../util/runtime");
+const {
+	getRuntimeKey,
+	keyToRuntime,
+	filterRuntime
+} = require("../util/runtime");
 const HarmonyExportInitFragment = require("./HarmonyExportInitFragment");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const processExportInfo = require("./processExportInfo");
@@ -31,6 +36,7 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ExportsInfo")} ExportsInfo */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @typedef {import("../ExportsInfo").UsedName} UsedName */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
@@ -45,6 +51,7 @@ const processExportInfo = require("./processExportInfo");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./processExportInfo").ReferencedExports} ReferencedExports */
 
 /** @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 */
 
@@ -69,6 +76,9 @@ class NormalReexportItem {
 	}
 }
 
+/** @typedef {Set<string>} ExportModeIgnored */
+/** @typedef {Set<string>} ExportModeHidden */
+
 class ExportMode {
 	/**
 	 * @param {ExportModeType} type type of the mode
@@ -88,11 +98,11 @@ class ExportMode {
 		this.partialNamespaceExportInfo = null;
 
 		// for "dynamic-reexport":
-		/** @type {Set<string> | null} */
+		/** @type {ExportModeIgnored | null} */
 		this.ignored = null;
 
 		// for "dynamic-reexport" | "empty-star":
-		/** @type {Set<string> | null} */
+		/** @type {ExportModeHidden | null} */
 		this.hidden = null;
 
 		// for "missing":
@@ -306,7 +316,8 @@ const getMode = (moduleGraph, dep, runtimeKey) => {
 				exportName,
 				[exportName],
 				exportsInfo.getReadOnlyExportInfo(exportName),
-				checked.has(exportName),
+				/** @type {Set<string>} */
+				(checked).has(exportName),
 				false
 			)
 	);
@@ -327,11 +338,17 @@ const getMode = (moduleGraph, dep, runtimeKey) => {
 	return mode;
 };
 
+/** @typedef {string[]} Ids */
+/** @typedef {Set<string>} Exports */
+/** @typedef {Set<string>} Checked */
+/** @typedef {Set<string>} Hidden */
+/** @typedef {Set<string>} IgnoredExports */
+
 class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	/**
 	 * @param {string} request the request string
 	 * @param {number} sourceOrder the order in the original source file
-	 * @param {string[]} ids the requested export name of the imported module
+	 * @param {Ids} ids the requested export name of the imported module
 	 * @param {string | null} name the export name of for this module
 	 * @param {Set<string>} activeExports other named exports in the module
 	 * @param {ReadonlyArray<HarmonyExportImportedSpecifierDependency> | Iterable<HarmonyExportImportedSpecifierDependency> | null} otherStarExports other star exports in the module before this import
@@ -388,7 +405,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @returns {string[]} the imported id
+	 * @returns {Ids} the imported id
 	 */
 	getIds(moduleGraph) {
 		return moduleGraph.getMeta(this)[idsSymbol] || this.ids;
@@ -396,7 +413,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string[]} ids the imported ids
+	 * @param {Ids} ids the imported ids
 	 * @returns {void}
 	 */
 	setIds(moduleGraph, ids) {
@@ -421,7 +438,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?: Set<string>, checked?: Set<string>, ignoredExports: Set<string>, hidden?: Set<string>}} information
+	 * @returns {{exports?: Exports, checked?: Checked, ignoredExports: IgnoredExports, hidden?: Hidden}} information
 	 */
 	getStarReexports(
 		moduleGraph,
@@ -439,7 +456,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 
 		const ignoredExports = new Set(["default", ...this.activeExports]);
 
-		let hiddenExports = undefined;
+		let hiddenExports;
 		const otherStarExports =
 			this._discoverActiveExportsFromOtherStarExports(moduleGraph);
 		if (otherStarExports !== undefined) {
@@ -457,11 +474,11 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 			};
 		}
 
-		/** @type {Set<string>} */
+		/** @type {Exports} */
 		const exports = new Set();
-		/** @type {Set<string>} */
+		/** @type {Checked} */
 		const checked = new Set();
-		/** @type {Set<string> | undefined} */
+		/** @type {Hidden | undefined} */
 		const hidden = hiddenExports !== undefined ? new Set() : undefined;
 
 		if (noExtraImports) {
@@ -489,7 +506,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				const exportInfo = exportsInfo.getReadOnlyExportInfo(name);
 				if (exportInfo.getUsed(runtime) === UsageState.Unused) continue;
 				if (hiddenExports !== undefined && hiddenExports.has(name)) {
-					/** @type {Set<string>} */
+					/** @type {ExportModeHidden} */
 					(hidden).add(name);
 					continue;
 				}
@@ -543,7 +560,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 			case "reexport-named-default": {
 				if (!mode.partialNamespaceExportInfo)
 					return Dependency.EXPORTS_OBJECT_REFERENCED;
-				/** @type {string[][]} */
+				/** @type {ReferencedExports} */
 				const referencedExports = [];
 				processExportInfo(
 					runtime,
@@ -558,7 +575,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 			case "reexport-fake-namespace-object": {
 				if (!mode.partialNamespaceExportInfo)
 					return Dependency.EXPORTS_OBJECT_REFERENCED;
-				/** @type {string[][]} */
+				/** @type {ReferencedExports} */
 				const referencedExports = [];
 				processExportInfo(
 					runtime,
@@ -574,6 +591,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				return Dependency.EXPORTS_OBJECT_REFERENCED;
 
 			case "normal-reexport": {
+				/** @type {ReferencedExports} */
 				const referencedExports = [];
 				for (const { ids, exportInfo, hidden } of mode.items) {
 					if (hidden) continue;
@@ -592,13 +610,13 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 	 * @returns {{ names: string[], namesSlice: number, dependencyIndices: number[], dependencyIndex: number } | undefined} exported names and their origin dependency
 	 */
 	_discoverActiveExportsFromOtherStarExports(moduleGraph) {
-		if (!this.otherStarExports) return undefined;
+		if (!this.otherStarExports) return;
 
 		const i =
 			"length" in this.otherStarExports
 				? this.otherStarExports.length
 				: countIterable(this.otherStarExports);
-		if (i === 0) return undefined;
+		if (i === 0) return;
 
 		if (this.allStarExports) {
 			const { names, dependencyIndices } = moduleGraph.cached(
@@ -638,7 +656,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 
 		switch (mode.type) {
 			case "missing":
-				return undefined;
+				return;
 			case "dynamic-reexport": {
 				const from =
 					/** @type {ModuleGraphConnection} */
@@ -648,8 +666,11 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 					from,
 					canMangle: false,
 					excludeExports: mode.hidden
-						? combine(mode.ignored, mode.hidden)
-						: mode.ignored,
+						? combine(
+								/** @type {ExportModeIgnored} */ (mode.ignored),
+								mode.hidden
+							)
+						: /** @type {ExportModeIgnored} */ (mode.ignored),
 					hideExports: mode.hidden,
 					dependencies: [from.module]
 				};
@@ -677,22 +698,20 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				};
 			}
 			case "reexport-dynamic-default": {
-				{
-					const from =
-						/** @type {ModuleGraphConnection} */
-						(moduleGraph.getConnection(this));
-					return {
-						exports: [
-							{
-								name: /** @type {string} */ (mode.name),
-								from,
-								export: ["default"]
-							}
-						],
-						priority: 1,
-						dependencies: [from.module]
-					};
-				}
+				const from =
+					/** @type {ModuleGraphConnection} */
+					(moduleGraph.getConnection(this));
+				return {
+					exports: [
+						{
+							name: /** @type {string} */ (mode.name),
+							from,
+							export: ["default"]
+						}
+					],
+					priority: 1,
+					dependencies: [from.module]
+				};
 			}
 			case "reexport-undefined":
 				return {
@@ -825,6 +844,7 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 				const importedModule = moduleGraph.getModule(this);
 				if (importedModule) {
 					const exportsInfo = moduleGraph.getExportsInfo(importedModule);
+					/** @type {Map<string, string[]>} */
 					const conflicts = new Map();
 					for (const exportInfo of exportsInfo.orderedExports) {
 						if (exportInfo.provided !== true) continue;
@@ -841,12 +861,12 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 						if (!conflictingDependency) continue;
 						const target = exportInfo.getTerminalBinding(moduleGraph);
 						if (!target) continue;
-						const conflictingModule = moduleGraph.getModule(
-							conflictingDependency
-						);
+						const conflictingModule =
+							/** @type {Module} */
+							(moduleGraph.getModule(conflictingDependency));
 						if (conflictingModule === importedModule) continue;
 						const conflictingExportInfo = moduleGraph.getExportInfo(
-							/** @type {Module} */ (conflictingModule),
+							conflictingModule,
 							exportInfo.name
 						);
 						const conflictingTarget =
@@ -944,7 +964,7 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 			switch (mode.type) {
 				case "reexport-undefined":
 					concatenationScope.registerRawExport(
-						mode.name,
+						/** @type {NonNullable<ExportMode["name"]>} */ (mode.name),
 						"/* reexport non-default export from non-harmony */ undefined"
 					);
 			}
@@ -1080,23 +1100,36 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				break;
 
 			case "normal-reexport":
-				for (const { name, ids, checked, hidden } of mode.items) {
+				for (const {
+					name,
+					ids,
+					checked,
+					hidden
+				} of /** @type {NormalReexportItem[]} */ (mode.items)) {
 					if (hidden) continue;
 					if (checked) {
+						const connection = moduleGraph.getConnection(dep);
+						const key = `harmony reexport (checked) ${importVar} ${name}`;
+						const runtimeCondition = dep.weak
+							? false
+							: connection
+								? filterRuntime(runtime, r => connection.isTargetActive(r))
+								: true;
 						initFragments.push(
-							new InitFragment(
-								"/* harmony reexport (checked) */ " +
-									this.getConditionalReexportStatement(
-										module,
-										name,
-										importVar,
-										ids,
-										runtimeRequirements
-									),
+							new ConditionalInitFragment(
+								`/* harmony reexport (checked) */ ${this.getConditionalReexportStatement(
+									module,
+									name,
+									importVar,
+									ids,
+									runtimeRequirements
+								)}`,
 								moduleGraph.isAsync(importedModule)
 									? InitFragment.STAGE_ASYNC_HARMONY_IMPORTS
 									: InitFragment.STAGE_HARMONY_IMPORTS,
-								dep.sourceOrder
+								dep.sourceOrder,
+								key,
+								runtimeCondition
 							)
 						);
 					} else {
@@ -1118,8 +1151,12 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 
 			case "dynamic-reexport": {
 				const ignored = mode.hidden
-					? combine(mode.ignored, mode.hidden)
-					: mode.ignored;
+					? combine(
+							/** @type {ExportModeIgnored} */
+							(mode.ignored),
+							mode.hidden
+						)
+					: /** @type {ExportModeIgnored} */ (mode.ignored);
 				const modern =
 					runtimeTemplate.supportsConst() &&
 					runtimeTemplate.supportsArrowFunction();
@@ -1132,22 +1169,19 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 				// Filter out exports which are defined by other exports
 				// and filter out default export because it cannot be reexported with *
 				if (ignored.size > 1) {
-					content +=
-						"if(" +
-						JSON.stringify(Array.from(ignored)) +
-						".indexOf(__WEBPACK_IMPORT_KEY__) < 0) ";
+					content += `if(${JSON.stringify(
+						Array.from(ignored)
+					)}.indexOf(__WEBPACK_IMPORT_KEY__) < 0) `;
 				} else if (ignored.size === 1) {
 					content += `if(__WEBPACK_IMPORT_KEY__ !== ${JSON.stringify(
 						first(ignored)
 					)}) `;
 				}
 
-				content += `__WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = `;
-				if (modern) {
-					content += `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`;
-				} else {
-					content += `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
-				}
+				content += "__WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = ";
+				content += modern
+					? `() => ${importVar}[__WEBPACK_IMPORT_KEY__]`
+					: `function(key) { return ${importVar}[key]; }.bind(0, __WEBPACK_IMPORT_KEY__)`;
 
 				runtimeRequirements.add(RuntimeGlobals.exports);
 				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
@@ -1170,6 +1204,15 @@ HarmonyExportImportedSpecifierDependency.Template = class HarmonyExportImportedS
 		}
 	}
 
+	/**
+	 * @param {Module} module the current module
+	 * @param {string} comment comment
+	 * @param {UsedName} key key
+	 * @param {string} name name
+	 * @param {string | string[] | null | false} valueKey value key
+	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+	 * @returns {HarmonyExportInitFragment} harmony export init fragment
+	 */
 	getReexportFragment(
 		module,
 		comment,

package/lib/dependencies/HarmonyExports.js

@@ -19,7 +19,7 @@ const parserStateExportsState = new WeakMap();
  * @param {boolean} isStrictHarmony strict harmony mode should be enabled
  * @returns {void}
  */
-exports.enable = (parserState, isStrictHarmony) => {
+module.exports.enable = (parserState, isStrictHarmony) => {
 	const value = parserStateExportsState.get(parserState);
 	if (value === false) return;
 	parserStateExportsState.set(parserState, true);
@@ -40,7 +40,7 @@ exports.enable = (parserState, isStrictHarmony) => {
  * @param {ParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */
-exports.isEnabled = parserState => {
+module.exports.isEnabled = parserState => {
 	const value = parserStateExportsState.get(parserState);
 	return value === true;
 };

package/lib/dependencies/HarmonyImportDependency.js

@@ -59,7 +59,6 @@ const ExportPresenceModes = {
 
 class HarmonyImportDependency extends ModuleDependency {
 	/**
-	 *
 	 * @param {string} request request string
 	 * @param {number} sourceOrder source order
 	 * @param {ImportAttributes=} attributes import attributes
@@ -89,7 +88,7 @@ class HarmonyImportDependency extends ModuleDependency {
 	 * @returns {string} name of the variable for the import
 	 */
 	getImportVar(moduleGraph) {
-		const module = moduleGraph.getParentModule(this);
+		const module = /** @type {Module} */ (moduleGraph.getParentModule(this));
 		const meta = /** @type {TODO} */ (moduleGraph.getMeta(module));
 		let importVarMap = meta.importVarMap;
 		if (!importVarMap) meta.importVarMap = importVarMap = new Map();
@@ -351,7 +350,7 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 					importStatement[1],
 					InitFragment.STAGE_ASYNC_HARMONY_IMPORTS,
 					dep.sourceOrder,
-					key + " compat",
+					`${key} compat`,
 					runtimeCondition
 				)
 			);
@@ -369,7 +368,6 @@ HarmonyImportDependency.Template = class HarmonyImportDependencyTemplate extends
 	}
 
 	/**
-	 *
 	 * @param {Module} module the module
 	 * @param {Module} referencedModule the referenced module
 	 * @returns {RuntimeSpec | boolean} runtimeCondition in which this import has been emitted

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -50,7 +50,7 @@ const harmonySpecifierTag = Symbol("harmony import");
 
 /**
  * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | (ImportExpression & { arguments?: ObjectExpression[] })} node node with assertions
- * @returns {ImportAttributes} import attributes
+ * @returns {ImportAttributes | undefined} import attributes
  */
 function getAttributes(node) {
 	if (
@@ -96,7 +96,7 @@ function getAttributes(node) {
 		? /** @type {{ assertions?: ImportAttributeNode[] }} */ (node).assertions
 		: /** @type {{ attributes?: ImportAttributeNode[] }} */ (node).attributes;
 	if (attributes === undefined) {
-		return undefined;
+		return;
 	}
 	const result = /** @type {ImportAttributes} */ ({});
 	for (const attribute of attributes) {
@@ -138,12 +138,22 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 	apply(parser) {
 		const { exportPresenceMode } = this;
 
+		/**
+		 * @param {string[]} members members
+		 * @param {boolean[]} membersOptionals members Optionals
+		 * @returns {string[]} a non optional part
+		 */
 		function getNonOptionalPart(members, membersOptionals) {
 			let i = 0;
 			while (i < members.length && membersOptionals[i] === false) i++;
 			return i !== members.length ? members.slice(0, i) : members;
 		}
 
+		/**
+		 * @param {TODO} node member expression
+		 * @param {number} count count
+		 * @returns {TODO} member expression
+		 */
 		function getNonOptionalMemberChain(node, count) {
 			while (count--) node = node.object;
 			return node;
@@ -221,7 +231,9 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				)
 					return;
 				const settings = rootInfo.tagInfo.data;
-				const members = rightPart.getMembers();
+				const members =
+					/** @type {(() => string[])} */
+					(rightPart.getMembers)();
 				const dep = new HarmonyEvaluatedImportSpecifierDependency(
 					settings.source,
 					settings.sourceOrder,
@@ -280,6 +292,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						members,
 						membersOptionals
 					);
+					/** @type {Range[]} */
 					const ranges = memberRanges.slice(
 						0,
 						memberRanges.length - (members.length - nonOptionalMembers.length)
@@ -326,6 +339,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						members,
 						membersOptionals
 					);
+					/** @type {Range[]} */
 					const ranges = memberRanges.slice(
 						0,
 						memberRanges.length - (members.length - nonOptionalMembers.length)
@@ -355,7 +369,8 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					);
 					// only in case when we strictly follow the spec we need a special case here
 					dep.namespaceObjectAsContext =
-						members.length > 0 && this.strictThisContextOnImports;
+						members.length > 0 &&
+						/** @type {boolean} */ (this.strictThisContextOnImports);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addDependency(dep);
 					if (args) parser.walkExpressions(args);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -42,7 +42,7 @@ const { ExportPresenceModes } = HarmonyImportDependency;
 
 class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	/**
-	 * @param {TODO} request request
+	 * @param {string} request request
 	 * @param {number} sourceOrder source order
 	 * @param {string[]} ids ids
 	 * @param {string} name name
@@ -67,7 +67,6 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.range = range;
 		this.idRanges = idRanges;
 		this.exportPresenceMode = exportPresenceMode;
-		/** @type {boolean | undefined} */
 		this.namespaceObjectAsContext = false;
 		this.call = undefined;
 		this.directImport = undefined;
@@ -105,7 +104,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	getIds(moduleGraph) {
 		const meta = moduleGraph.getMetaIfExisting(this);
 		if (meta === undefined) return this.ids;
-		const ids = meta[idsSymbol];
+		const ids = meta[/** @type {keyof object} */ (idsSymbol)];
 		return ids !== undefined ? ids : this.ids;
 	}
 
@@ -149,7 +148,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		if (ids.length === 0) return this._getReferencedExportsInDestructuring();
 		let namespaceObjectAsContext = this.namespaceObjectAsContext;
 		if (ids[0] === "default") {
-			const selfModule = moduleGraph.getParentModule(this);
+			const selfModule =
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this));
 			const importedModule =
 				/** @type {Module} */
 				(moduleGraph.getModule(this));
@@ -196,9 +197,8 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 				refs.push(ids ? ids.concat([id]) : [id]);
 			}
 			return refs;
-		} else {
-			return ids ? [ids] : Dependency.EXPORTS_OBJECT_REFERENCED;
 		}
+		return ids ? [ids] : Dependency.EXPORTS_OBJECT_REFERENCED;
 	}
 
 	/**
@@ -208,9 +208,12 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	_getEffectiveExportPresenceLevel(moduleGraph) {
 		if (this.exportPresenceMode !== ExportPresenceModes.AUTO)
 			return this.exportPresenceMode;
-		const buildMeta = /** @type {BuildMeta} */ (
-			moduleGraph.getParentModule(this).buildMeta
-		);
+		const buildMeta =
+			/** @type {BuildMeta} */
+			(
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this)).buildMeta
+			);
 		return buildMeta.strictHarmonyModule
 			? ExportPresenceModes.ERROR
 			: ExportPresenceModes.WARN;
@@ -344,14 +347,34 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 		}
 
 		if (dep.referencedPropertiesInDestructuring) {
-			for (let {
+			let prefixedIds = ids;
+
+			if (ids[0] === "default") {
+				const selfModule = moduleGraph.getParentModule(dep);
+				const importedModule =
+					/** @type {Module} */
+					(moduleGraph.getModule(dep));
+				const exportsType = importedModule.getExportsType(
+					moduleGraph,
+					/** @type {BuildMeta} */
+					(selfModule.buildMeta).strictHarmonyModule
+				);
+				if (
+					(exportsType === "default-only" ||
+						exportsType === "default-with-named") &&
+					ids.length >= 1
+				) {
+					prefixedIds = ids.slice(1);
+				}
+			}
+
+			for (const {
 				id,
 				shorthand,
 				range
 			} of dep.referencedPropertiesInDestructuring) {
-				const concatedIds = ids.concat([id]);
-				if (concatedIds[0] === "default") concatedIds.shift();
-				const module = moduleGraph.getModule(dep);
+				const concatedIds = prefixedIds.concat([id]);
+				const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 				const used = moduleGraph
 					.getExportsInfo(module)
 					.getUsedName(concatedIds, runtime);
@@ -360,11 +383,13 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				const name = concatedIds[concatedIds.length - 1];
 				if (newName === name) continue;
 
-				const comment = Template.toNormalComment(name) + " ";
+				const comment = `${Template.toNormalComment(name)} `;
 				const key = comment + JSON.stringify(newName);
 				source.replace(
-					range[0],
-					range[1] - 1,
+					/** @type {Range} */
+					(range)[0],
+					/** @type {Range} */
+					(range)[1] - 1,
 					shorthand ? `${key}: ${name}` : `${key}`
 				);
 			}

package/lib/dependencies/ImportDependency.js

@@ -124,7 +124,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 		);
 		const content = runtimeTemplate.moduleNamespacePromise({
 			chunkGraph,
-			block: block,
+			block,
 			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -57,14 +57,14 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 	apply(parser) {
 		parser.hooks.evaluateIdentifier
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr => {
-				return evaluateToIdentifier(
+			.tap("ImportMetaContextDependencyParserPlugin", expr =>
+				evaluateToIdentifier(
 					"import.meta.webpackContext",
 					"import.meta",
 					() => ["webpackContext"],
 					true
-				)(expr);
-			});
+				)(expr)
+			);
 		parser.hooks.call
 			.for("import.meta.webpackContext")
 			.tap("ImportMetaContextDependencyParserPlugin", expr => {
@@ -293,7 +293,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 					/** @type {Range} */ (expr.range)
 				);
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = !!parser.scope.inTry;
+				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.current.addDependency(dep);
 				return true;
 			});