webpack 5.105.3 → 5.105.4

package/lib/Compilation.js

@@ -4019,7 +4019,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
 	 * @param {Module=} module the module the references the chunk group
 	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string=} request the request from which the the chunk group is referenced
+	 * @param {string=} request the request from which the chunk group is referenced
 	 * @returns {ChunkGroup} the new or existing chunk group
 	 */
 	addChunkInGroup(groupOptions, module, loc, request) {
@@ -4067,7 +4067,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @param {EntryOptions} options options for the entrypoint
 	 * @param {Module} module the module the references the chunk group
 	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string} request the request from which the the chunk group is referenced
+	 * @param {string} request the request from which the chunk group is referenced
 	 * @returns {Entrypoint} the new or existing entrypoint
 	 */
 	addAsyncEntrypoint(options, module, loc, request) {

package/lib/Module.js

@@ -80,6 +80,8 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {KnownSourceType | string} SourceType */
 /** @typedef {ReadonlySet<SourceType>} SourceTypes */
 
+/** @typedef {ReadonlySet<typeof JAVASCRIPT_TYPE | string>} BasicSourceTypes */
+
 // TODO webpack 6: compilation will be required in CodeGenerationContext
 /**
  * @typedef {object} CodeGenerationContext
@@ -966,6 +968,19 @@ class Module extends DependenciesBlock {
 		return JAVASCRIPT_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return this.getSourceTypes();
+	}
+
 	/**
 	 * @abstract
 	 * @deprecated Use codeGeneration() instead

package/lib/MultiStats.js

@@ -8,6 +8,7 @@
 const identifierUtils = require("./util/identifier");
 
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").StatsValue} StatsValue */
 /** @typedef {import("./Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */
 /** @typedef {import("./Compilation").NormalizedStatsOptions} NormalizedStatsOptions */
 /** @typedef {import("./Stats")} Stats */
@@ -25,8 +26,7 @@ const indent = (str, prefix) => {
 	return prefix + rem;
 };
 
-/** @typedef {undefined | string | boolean | StatsOptions} ChildrenStatsOptions */
-/** @typedef {Omit<StatsOptions, "children"> & { children?: ChildrenStatsOptions | ChildrenStatsOptions[] }} MultiStatsOptions */
+/** @typedef {StatsOptions} MultiStatsOptions */
 /** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
 
 class MultiStats {
@@ -56,7 +56,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {undefined | string | boolean | MultiStatsOptions} options stats options
+	 * @param {undefined | StatsValue} options stats options
 	 * @param {CreateStatsOptionsContext} context context
 	 * @returns {ChildOptions} context context
 	 */
@@ -109,7 +109,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
@@ -184,7 +184,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {string} string output
 	 */
 	toString(options) {

package/lib/RuntimeModule.js

@@ -8,7 +8,10 @@
 const { RawSource } = require("webpack-sources");
 const OriginalSource = require("webpack-sources").OriginalSource;
 const Module = require("./Module");
-const { RUNTIME_TYPES } = require("./ModuleSourceTypeConstants");
+const {
+	JAVASCRIPT_TYPES,
+	RUNTIME_TYPES
+} = require("./ModuleSourceTypeConstants");
 const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 
 /** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
@@ -29,6 +32,7 @@ const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./Module").BasicSourceTypes} BasicSourceTypes */
 
 class RuntimeModule extends Module {
 	/**
@@ -138,6 +142,19 @@ class RuntimeModule extends Module {
 		return RUNTIME_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
 	/**
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result

package/lib/Stats.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
+/** @typedef {import("../declarations/WebpackOptions").StatsValue} StatsValue */
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */
 
@@ -50,7 +51,7 @@ class Stats {
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
@@ -66,7 +67,7 @@ class Stats {
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {StatsValue=} options stats options
 	 * @returns {string} string output
 	 */
 	toString(options) {

package/lib/container/RemoteModule.js

@@ -7,7 +7,10 @@
 
 const { RawSource } = require("webpack-sources");
 const Module = require("../Module");
-const { REMOTE_AND_SHARE_INIT_TYPES } = require("../ModuleSourceTypeConstants");
+const {
+	JAVASCRIPT_TYPES,
+	REMOTE_AND_SHARE_INIT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const { WEBPACK_MODULE_TYPE_REMOTE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
@@ -34,6 +37,7 @@ const RemoteToExternalDependency = require("./RemoteToExternalDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("../Module").BasicSourceTypes} BasicSourceTypes */
 
 const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
 
@@ -137,6 +141,19 @@ class RemoteModule extends Module {
 		return REMOTE_AND_SHARE_INIT_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {boolean | undefined} strict the importing module is strict

package/lib/css/CssGenerator.js

@@ -19,6 +19,7 @@ const {
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CssImportDependency = require("../dependencies/CssImportDependency");
+const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
 const { getUndoPath } = require("../util/identifier");
 const memoize = require("../util/memoize");
 
@@ -469,6 +470,7 @@ class CssGenerator extends Generator {
 	getTypes(module) {
 		const exportType = /** @type {BuildMeta} */ (module.buildMeta).exportType;
 		const sourceTypes = new Set();
+
 		const connections = this._moduleGraph.getIncomingConnections(module);
 
 		for (const connection of connections) {
@@ -478,9 +480,17 @@ class CssGenerator extends Generator {
 			) {
 				continue;
 			}
+
+			// when no hmr required, css module js output contains no sideEffects at all
+			// js sideeffect connection doesn't require js type output
+			if (connection.dependency instanceof HarmonyImportSideEffectDependency) {
+				continue;
+			}
+
 			if (!connection.originModule) {
 				continue;
 			}
+
 			if (connection.originModule.type.split("/")[0] !== CSS_TYPE) {
 				sourceTypes.add(JAVASCRIPT_TYPE);
 			} else {

package/lib/dependencies/CreateRequireParserPlugin.js

@@ -328,6 +328,17 @@ class CreateRequireParserPlugin {
 					return processResolve(expr, false);
 				}
 			});
+		parser.hooks.expression
+			.for(createRequireSpecifierTag)
+			.tap(PLUGIN_NAME, (expr) => {
+				const clearDep = new ConstDependency(
+					"/* createRequire */ undefined",
+					/** @type {Range} */ (expr.range)
+				);
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
+				parser.state.module.addPresentationalDependency(clearDep);
+				return true;
+			});
 		parser.hooks.call
 			.for(createRequireSpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -27,6 +27,7 @@ const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDepend
 const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -66,17 +67,44 @@ const harmonySpecifierGuardTag = Symbol("harmony import guard");
 
 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
+ * @param {JavascriptParser} parser the parser
+ * @param {PrivateIdentifier | Expression} left left expression
+ * @param {Expression} right right expression
+ * @returns {{ leftPart: string, members: Members, settings: HarmonySettings } | undefined} info
  */
-const getIdsForPresence = (settings, ids) =>
-	settings.ids.length ? ids.slice(1) : ids;
+const getInOperatorHarmonyImportInfo = (parser, left, right) => {
+	const leftPartEvaluated = parser.evaluateExpression(left);
+	if (leftPartEvaluated.couldHaveSideEffects()) return;
+	/** @type {string | undefined} */
+	const leftPart = leftPartEvaluated.asString();
+	if (!leftPart) return;
+
+	const rightPart = parser.evaluateExpression(right);
+	if (!rightPart.isIdentifier()) return;
+
+	const rootInfo = rightPart.rootInfo;
+	const root =
+		typeof rootInfo === "string"
+			? rootInfo
+			: rootInfo instanceof VariableInfo
+				? rootInfo.name
+				: undefined;
+	if (!root) return;
+
+	const settings = /** @type {HarmonySettings | undefined} */ (
+		parser.getTagData(root, harmonySpecifierTag)
+	);
+	if (!settings) {
+		return;
+	}
+
+	return {
+		leftPart,
+		members: /** @type {(() => Members)} */ (rightPart.getMembers)(),
+		settings
+	};
+};
 
 module.exports = class HarmonyImportDependencyParserPlugin {
 	/**
@@ -94,10 +122,14 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 
 	/**
 	 * @param {JavascriptParser} parser the parser
+	 * @param {HarmonySettings} settings settings
 	 * @param {Ids} ids ids
 	 * @returns {ExportPresenceMode} exportPresenceMode
 	 */
-	getExportPresenceMode(parser, ids) {
+	getExportPresenceMode(parser, settings, ids) {
+		// Guards only apply to namespace imports
+		if (settings.ids.length) return this.exportPresenceMode;
+
 		const harmonySettings = /** @type {HarmonySettings=} */ (
 			parser.currentTagData
 		);
@@ -106,9 +138,12 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		const data = /** @type {HarmonySpecifierGuards=} */ (
 			parser.getTagData(harmonySettings.name, harmonySpecifierGuardTag)
 		);
-		return data && data.guards && data.guards.has(getMembersKey(ids))
-			? ExportPresenceModes.NONE
-			: this.exportPresenceMode;
+
+		if (data && data.guards && data.guards.has(ids[0])) {
+			return ExportPresenceModes.NONE;
+		}
+
+		return this.exportPresenceMode;
 	}
 
 	/**
@@ -195,31 +230,14 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 		);
 		parser.hooks.binaryExpression.tap(PLUGIN_NAME, (expression) => {
 			if (expression.operator !== "in") return;
+			const info = getInOperatorHarmonyImportInfo(
+				parser,
+				expression.left,
+				expression.right
+			);
+			if (!info) return;
 
-			const leftPartEvaluated = parser.evaluateExpression(expression.left);
-			if (leftPartEvaluated.couldHaveSideEffects()) return;
-			/** @type {string | undefined} */
-			const leftPart = leftPartEvaluated.asString();
-			if (!leftPart) return;
-
-			const rightPart = parser.evaluateExpression(expression.right);
-			if (!rightPart.isIdentifier()) return;
-
-			const rootInfo = rightPart.rootInfo;
-			if (
-				typeof rootInfo === "string" ||
-				!rootInfo ||
-				!rootInfo.tagInfo ||
-				rootInfo.tagInfo.tag !== harmonySpecifierTag
-			) {
-				return;
-			}
-			const settings =
-				/** @type {HarmonySettings} */
-				(rootInfo.tagInfo.data);
-			const members =
-				/** @type {(() => Members)} */
-				(rightPart.getMembers)();
+			const { leftPart, members, settings } = info;
 			const dep = new HarmonyEvaluatedImportSpecifierDependency(
 				settings.source,
 				settings.sourceOrder,
@@ -264,10 +282,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 					settings.name,
 					/** @type {Range} */
 					(expr.range),
-					this.getExportPresenceMode(
-						parser,
-						getIdsForPresence(settings, settings.ids)
-					),
+					this.exportPresenceMode,
 					settings.phase,
 					settings.attributes,
 					[]
@@ -317,10 +332,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						settings.name,
 						/** @type {Range} */
 						(expr.range),
-						this.getExportPresenceMode(
-							parser,
-							getIdsForPresence(settings, ids)
-						),
+						this.getExportPresenceMode(parser, settings, ids),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -370,10 +382,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 						ids,
 						settings.name,
 						/** @type {Range} */ (expr.range),
-						this.getExportPresenceMode(
-							parser,
-							getIdsForPresence(settings, ids)
-						),
+						this.getExportPresenceMode(parser, settings, ids),
 						settings.phase,
 						settings.attributes,
 						ranges
@@ -441,160 +450,6 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 			}
 		});
 
-		/**
-		 * @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
@@ -645,7 +500,68 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 				if (parser.scope.isAsmJs) return;
 				/** @type {Guards} */
 				const guards = new Map();
-				collect(expression, guards, true);
+
+				/**
+				 * @param {Expression} expression expression
+				 * @param {boolean} needTruthy need to be truthy
+				 */
+				const collect = (expression, needTruthy) => {
+					if (
+						expression.type === "UnaryExpression" &&
+						expression.operator === "!"
+					) {
+						collect(expression.argument, !needTruthy);
+						return;
+					} else if (expression.type === "LogicalExpression" && needTruthy) {
+						if (expression.operator === "&&") {
+							collect(expression.left, true);
+							collect(expression.right, true);
+						} else if (expression.operator === "||") {
+							const leftEvaluation = parser.evaluateExpression(expression.left);
+							const leftBool = leftEvaluation.asBool();
+							if (leftBool === false) {
+								collect(expression.right, true);
+							}
+						} else if (expression.operator === "??") {
+							const leftEvaluation = parser.evaluateExpression(expression.left);
+							const leftNullish = leftEvaluation.asNullish();
+							if (leftNullish === true) {
+								collect(expression.right, true);
+							}
+						}
+						return;
+					}
+					if (!needTruthy) return;
+
+					// Direct `"x" in ns` guards
+					if (
+						expression.type === "BinaryExpression" &&
+						expression.operator === "in"
+					) {
+						if (expression.right.type !== "Identifier") {
+							return;
+						}
+						const info = getInOperatorHarmonyImportInfo(
+							parser,
+							expression.left,
+							expression.right
+						);
+						if (!info) return;
+
+						const { settings, leftPart, members } = info;
+						// Only direct namespace guards
+						if (members.length > 0) return;
+						const guarded = guards.get(settings.name);
+						if (guarded) {
+							guarded.add(leftPart);
+							return;
+						}
+
+						guards.set(settings.name, new Set([leftPart]));
+					}
+				};
+
+				collect(expression, true);
 
 				if (guards.size === 0) return;
 				return (walk) => {

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 
@@ -72,11 +73,16 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 	 */
 	apply(dependency, source, templateContext) {
 		const { moduleGraph, concatenationScope } = templateContext;
-		if (concatenationScope) {
-			const module = /** @type {Module} */ (moduleGraph.getModule(dependency));
-			if (concatenationScope.isModuleInScope(module)) {
-				return;
-			}
+
+		const module = /** @type {Module} */ (moduleGraph.getModule(dependency));
+
+		if (module && !module.getSourceBasicTypes().has(JAVASCRIPT_TYPE)) {
+			// no need to render import
+			return;
+		}
+
+		if (concatenationScope && concatenationScope.isModuleInScope(module)) {
+			return;
 		}
 		super.apply(dependency, source, templateContext);
 	}

package/lib/optimize/ConcatenatedModule.js

@@ -1004,6 +1004,9 @@ class ConcatenatedModule extends Module {
 					if (!(connection.dependency instanceof HarmonyImportDependency)) {
 						return false;
 					}
+					if (!connection.module.getSourceBasicTypes().has(JAVASCRIPT_TYPE)) {
+						return false;
+					}
 					return (
 						connection &&
 						connection.resolvedOriginModule === module &&

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -466,7 +466,10 @@ class ModuleConcatenationPlugin {
 												chunk,
 												m
 											);
-											if (sourceTypes.size === 1) {
+											if (
+												sourceTypes.size === 1 &&
+												sourceTypes.has(JAVASCRIPT_TYPE)
+											) {
 												chunkGraph.disconnectChunkAndModule(chunk, m);
 											} else {
 												const newSourceTypes = new Set(sourceTypes);

package/lib/sharing/ConsumeSharedModule.js

@@ -8,7 +8,10 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
-const { CONSUME_SHARED_TYPES } = require("../ModuleSourceTypeConstants");
+const {
+	CONSUME_SHARED_TYPES,
+	JAVASCRIPT_TYPES
+} = require("../ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
 } = require("../ModuleTypeConstants");
@@ -41,6 +44,7 @@ const fallbackModuleCache = new WeakMap();
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
+/** @typedef {import("../Module").BasicSourceTypes} BasicSourceTypes */
 
 /**
  * @typedef {object} ConsumeOptions
@@ -159,6 +163,19 @@ class ConsumeSharedModule extends Module {
 		return CONSUME_SHARED_TYPES;
 	}
 
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 *
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 * @returns {BasicSourceTypes} types available (do not mutate)
+	 */
+	getSourceBasicTypes() {
+		return JAVASCRIPT_TYPES;
+	}
+
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {Module | null} fallback module

package/lib/util/AppendOnlyStackedSet.js

@@ -43,7 +43,9 @@ class AppendOnlyStackedSet {
 
 	clear() {
 		this._sets = [];
-		if (this._current) this._current.clear();
+		if (this._current) {
+			this._current = undefined;
+		}
 	}
 
 	/**
@@ -52,6 +54,25 @@ class AppendOnlyStackedSet {
 	createChild() {
 		return new AppendOnlyStackedSet(this._sets.length ? [...this._sets] : []);
 	}
+
+	/**
+	 * @returns {Iterator<T>} iterable iterator
+	 */
+	[Symbol.iterator]() {
+		const iterators = this._sets.map((map) => map[Symbol.iterator]());
+		let current = iterators.pop();
+		return {
+			next() {
+				if (!current) return { done: true, value: undefined };
+				let result = current.next();
+				while (result.done && iterators.length > 0) {
+					current = /** @type {SetIterator<T>} */ (iterators.pop());
+					result = current.next();
+				}
+				return result;
+			}
+		};
+	}
 }
 
 module.exports = AppendOnlyStackedSet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.105.3",
+  "version": "5.105.4",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",
@@ -95,7 +95,7 @@
     "acorn-import-phases": "^1.0.3",
     "browserslist": "^4.28.1",
     "chrome-trace-event": "^1.0.2",
-    "enhanced-resolve": "^5.19.0",
+    "enhanced-resolve": "^5.20.0",
     "es-module-lexer": "^2.0.0",
     "eslint-scope": "5.1.1",
     "events": "^3.2.0",
@@ -107,7 +107,7 @@
     "neo-async": "^2.6.2",
     "schema-utils": "^4.3.3",
     "tapable": "^2.3.0",
-    "terser-webpack-plugin": "^5.3.16",
+    "terser-webpack-plugin": "^5.3.17",
     "watchpack": "^2.5.1",
     "webpack-sources": "^3.3.4"
   },

package/types.d.ts

@@ -311,6 +311,7 @@ declare abstract class AppendOnlyStackedSet<T> {
 	has(el: T): boolean;
 	clear(): void;
 	createChild(): AppendOnlyStackedSet<T>;
+	[Symbol.iterator](): Iterator<T>;
 }
 declare interface Argument {
 	description?: string;
@@ -1285,7 +1286,6 @@ declare interface CallbackWebpackFunction_2<T, R = void> {
 	(err: null | Error, result?: T): R;
 }
 type Cell<T> = undefined | T;
-type ChildrenStatsOptions = undefined | string | boolean | StatsOptions;
 declare class Chunk {
 	constructor(name?: null | string, backCompat?: boolean);
 	id: null | string | number;
@@ -10647,6 +10647,15 @@ declare class Module extends DependenciesBlock {
 		callback: (err?: WebpackError) => void
 	): void;
 	getSourceTypes(): ReadonlySet<string>;
+
+	/**
+	 * Basic source types are high-level categories like javascript, css, webassembly, etc.
+	 * We only have built-in knowledge about the javascript basic type here; other basic types may be
+	 * added or changed over time by generators and do not need to be handled or detected here.
+	 * Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init"
+	 * from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.
+	 */
+	getSourceBasicTypes(): ReadonlySet<string>;
 	source(
 		dependencyTemplates: DependencyTemplates,
 		runtimeTemplate: RuntimeTemplate,
@@ -11583,12 +11592,33 @@ declare abstract class MultiStats {
 	get hash(): string;
 	hasErrors(): boolean;
 	hasWarnings(): boolean;
-	toJson(options?: string | boolean | MultiStatsOptions): StatsCompilation;
-	toString(options?: string | boolean | MultiStatsOptions): string;
+	toJson(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): StatsCompilation;
+	toString(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): string;
 }
-type MultiStatsOptions = Omit<StatsOptions, "children"> & {
-	children?: string | boolean | StatsOptions | ChildrenStatsOptions[];
-};
 declare abstract class MultiWatching {
 	watchings: Watching[];
 	compiler: MultiCompiler;
@@ -12274,43 +12304,43 @@ declare interface NormalizedModules {
 type NormalizedStatsOptions = KnownNormalizedStatsOptions &
 	Omit<
 		StatsOptions,
-		| "assetsSort"
-		| "assetsSpace"
-		| "cachedAssets"
-		| "cachedModules"
-		| "chunkGroupAuxiliary"
-		| "chunkGroupChildren"
-		| "chunkGroupMaxAssets"
+		| "context"
 		| "chunkGroups"
-		| "chunkModulesSpace"
+		| "requestShortener"
 		| "chunksSort"
-		| "context"
-		| "dependentModules"
-		| "entrypoints"
-		| "excludeAssets"
-		| "excludeModules"
+		| "modulesSort"
+		| "chunkModulesSort"
+		| "nestedModulesSort"
+		| "assetsSort"
+		| "ids"
+		| "cachedAssets"
 		| "groupAssetsByEmitStatus"
-		| "groupAssetsByExtension"
 		| "groupAssetsByPath"
-		| "groupModulesByAttributes"
+		| "groupAssetsByExtension"
+		| "assetsSpace"
+		| "excludeAssets"
+		| "excludeModules"
+		| "warningsFilter"
+		| "cachedModules"
+		| "orphanModules"
+		| "dependentModules"
+		| "runtimeModules"
 		| "groupModulesByCacheStatus"
-		| "groupModulesByExtension"
 		| "groupModulesByLayer"
+		| "groupModulesByAttributes"
 		| "groupModulesByPath"
+		| "groupModulesByExtension"
 		| "groupModulesByType"
-		| "ids"
+		| "entrypoints"
+		| "chunkGroupAuxiliary"
+		| "chunkGroupChildren"
+		| "chunkGroupMaxAssets"
+		| "modulesSpace"
+		| "chunkModulesSpace"
+		| "nestedModulesSpace"
 		| "logging"
 		| "loggingDebug"
 		| "loggingTrace"
-		| "modulesSort"
-		| "modulesSpace"
-		| "nestedModulesSpace"
-		| "orphanModules"
-		| "runtimeModules"
-		| "warningsFilter"
-		| "requestShortener"
-		| "chunkModulesSort"
-		| "nestedModulesSort"
 		| "_env"
 	> &
 	Record<string, any>;
@@ -14145,7 +14175,7 @@ declare class ProgressPlugin {
 	showModules?: boolean;
 	showDependencies?: boolean;
 	showActiveModules?: boolean;
-	percentBy?: null | "modules" | "entries" | "dependencies";
+	percentBy?: null | "entries" | "modules" | "dependencies";
 	apply(compiler: MultiCompiler | Compiler): void;
 	static getReporter(
 		compiler: Compiler
@@ -14210,7 +14240,7 @@ declare interface ProgressPluginOptions {
 	/**
 	 * Collect percent algorithm. By default it calculates by a median from modules, entries and dependencies percent.
 	 */
-	percentBy?: null | "modules" | "entries" | "dependencies";
+	percentBy?: null | "entries" | "modules" | "dependencies";
 
 	/**
 	 * Collect profile data for progress steps. Default: false.
@@ -17768,8 +17798,32 @@ declare class Stats {
 	get endTime(): number;
 	hasWarnings(): boolean;
 	hasErrors(): boolean;
-	toJson(options?: string | boolean | StatsOptions): StatsCompilation;
-	toString(options?: string | boolean | StatsOptions): string;
+	toJson(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): StatsCompilation;
+	toString(
+		options?:
+			| boolean
+			| StatsOptions
+			| "none"
+			| "summary"
+			| "errors-only"
+			| "errors-warnings"
+			| "minimal"
+			| "normal"
+			| "detailed"
+			| "verbose"
+	): string;
 }
 type StatsAsset = KnownStatsAsset & Record<string, any>;
 type StatsChunk = KnownStatsChunk & Record<string, any>;
@@ -18522,6 +18576,11 @@ declare interface TsconfigOptions {
 	 * References to other tsconfig files. 'auto' inherits from TypeScript config, or an array of relative/absolute paths
 	 */
 	references?: string[] | "auto";
+
+	/**
+	 * Override baseUrl from tsconfig.json. If provided, this value will be used instead of the baseUrl in the tsconfig file
+	 */
+	baseUrl?: string;
 }
 declare interface TsconfigPathsData {
 	/**
@@ -20110,7 +20169,7 @@ declare namespace exports {
 		MultiCompilerOptions,
 		MultiConfiguration,
 		MultiStats,
-		MultiStatsOptions,
+		StatsOptions as MultiStatsOptions,
 		ResolveData,
 		ParserState,
 		ResolvePluginInstance,