webpack 5.97.1 → 5.104.1

package/lib/ConcatenationScope.js

@@ -10,18 +10,21 @@ const {
 	NAMESPACE_OBJECT_EXPORT
 } = require("./util/concatenate");
 
+/** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./optimize/ConcatenatedModule").ConcatenatedModuleInfo} ConcatenatedModuleInfo */
 /** @typedef {import("./optimize/ConcatenatedModule").ModuleInfo} ModuleInfo */
+/** @typedef {import("./optimize/ConcatenatedModule").ExportName} Ids */
 
 const MODULE_REFERENCE_REGEXP =
-	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(?:_asiSafe(\d))?__$/;
+	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(?:_asiSafe(\d))?__$/;
 
 /**
  * @typedef {object} ModuleReferenceOptions
- * @property {string[]} ids the properties/exports of the module
+ * @property {Ids} ids the properties/exports of the module
  * @property {boolean} call true, when this referenced export is called
  * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
+ * @property {boolean} deferredImport true, when this referenced export is deferred
  * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
  */
 
@@ -29,8 +32,9 @@ class ConcatenationScope {
 	/**
 	 * @param {ModuleInfo[] | Map<Module, ModuleInfo>} modulesMap all module info by module
 	 * @param {ConcatenatedModuleInfo} currentModule the current module info
+	 * @param {Set<string>} usedNames all used names
 	 */
-	constructor(modulesMap, currentModule) {
+	constructor(modulesMap, currentModule, usedNames) {
 		this._currentModule = currentModule;
 		if (Array.isArray(modulesMap)) {
 			const map = new Map();
@@ -39,6 +43,7 @@ class ConcatenationScope {
 			}
 			modulesMap = map;
 		}
+		this.usedNames = usedNames;
 		this._modulesMap = modulesMap;
 	}
 
@@ -76,6 +81,30 @@ class ConcatenationScope {
 		}
 	}
 
+	/**
+	 * @param {string} exportName name of the export
+	 * @returns {string | undefined} the expression of the export
+	 */
+	getRawExport(exportName) {
+		if (!this._currentModule.rawExportMap) {
+			return undefined;
+		}
+		return this._currentModule.rawExportMap.get(exportName);
+	}
+
+	/**
+	 * @param {string} exportName name of the export
+	 * @param {string} expression expression to be used
+	 */
+	setRawExportMap(exportName, expression) {
+		if (!this._currentModule.rawExportMap) {
+			this._currentModule.rawExportMap = new Map();
+		}
+		if (this._currentModule.rawExportMap.has(exportName)) {
+			this._currentModule.rawExportMap.set(exportName, expression);
+		}
+	}
+
 	/**
 	 * @param {string} symbol identifier of the export in source code
 	 */
@@ -90,21 +119,28 @@ class ConcatenationScope {
 	 */
 	createModuleReference(
 		module,
-		{ ids = undefined, call = false, directImport = false, asiSafe = false }
+		{
+			ids = undefined,
+			call = false,
+			directImport = false,
+			deferredImport = false,
+			asiSafe = false
+		}
 	) {
 		const info = /** @type {ModuleInfo} */ (this._modulesMap.get(module));
 		const callFlag = call ? "_call" : "";
 		const directImportFlag = directImport ? "_directImport" : "";
+		const deferredImportFlag = deferredImport ? "_deferredImport" : "";
 		const asiSafeFlag = asiSafe
 			? "_asiSafe1"
 			: asiSafe === false
 				? "_asiSafe0"
 				: "";
 		const exportData = ids
-			? Buffer.from(JSON.stringify(ids), "utf-8").toString("hex")
+			? Buffer.from(JSON.stringify(ids), "utf8").toString("hex")
 			: "ns";
 		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
-		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${asiSafeFlag}__._`;
+		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${asiSafeFlag}__._`;
 	}
 
 	/**
@@ -123,15 +159,16 @@ class ConcatenationScope {
 		const match = MODULE_REFERENCE_REGEXP.exec(name);
 		if (!match) return null;
 		const index = Number(match[1]);
-		const asiSafe = match[5];
+		const asiSafe = match[6];
 		return {
 			index,
 			ids:
 				match[2] === "ns"
 					? []
-					: JSON.parse(Buffer.from(match[2], "hex").toString("utf-8")),
+					: JSON.parse(Buffer.from(match[2], "hex").toString("utf8")),
 			call: Boolean(match[3]),
 			directImport: Boolean(match[4]),
+			deferredImport: Boolean(match[5]),
 			asiSafe: asiSafe ? asiSafe === "1" : undefined
 		};
 	}

package/lib/ConditionalInitFragment.js

@@ -78,7 +78,7 @@ class ConditionalInitFragment extends InitFragment {
 
 	/**
 	 * @param {GenerateContext} context context
-	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
 	 */
 	getEndContent(context) {
 		if (this.runtimeCondition === false || !this.endContent) return "";

package/lib/ConstPlugin.js

@@ -22,13 +22,15 @@ const { parseResource } = require("./util/identifier");
 /** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("estree").Super} Super */
+/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
+/** @typedef {Set<string>} Declarations */
+
 /**
- * @param {Set<string>} declarations set of declarations
+ * @param {Declarations} declarations set of declarations
  * @param {Identifier | Pattern} pattern pattern to collect declarations from
  */
 const collectDeclaration = (declarations, pattern) => {
@@ -64,11 +66,12 @@ const collectDeclaration = (declarations, pattern) => {
 /**
  * @param {Statement} branch branch to get hoisted declarations from
  * @param {boolean} includeFunctionDeclarations whether to include function declarations
- * @returns {Array<string>} hoisted declarations
+ * @returns {string[]} hoisted declarations
  */
 const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
+	/** @type {Declarations} */
 	const declarations = new Set();
-	/** @type {Array<TODO | null | undefined>} */
+	/** @type {(Statement | null | undefined)[]} */
 	const stack = [branch];
 	while (stack.length > 0) {
 		const node = stack.pop();
@@ -87,12 +90,12 @@ const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
 				stack.push(node.alternate);
 				break;
 			case "ForStatement":
-				stack.push(node.init);
+				stack.push(/** @type {VariableDeclaration} */ (node.init));
 				stack.push(node.body);
 				break;
 			case "ForInStatement":
 			case "ForOfStatement":
-				stack.push(node.left);
+				stack.push(/** @type {VariableDeclaration} */ (node.left));
 				stack.push(node.body);
 				break;
 			case "DoWhileStatement":
@@ -128,7 +131,7 @@ const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
 				break;
 		}
 	}
-	return Array.from(declarations);
+	return [...declarations];
 };
 
 const PLUGIN_NAME = "ConstPlugin";
@@ -157,8 +160,9 @@ class ConstPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 */
-				const handler = parser => {
-					parser.hooks.statementIf.tap(PLUGIN_NAME, statement => {
+				const handler = (parser) => {
+					parser.hooks.terminate.tap(PLUGIN_NAME, (_statement) => true);
+					parser.hooks.statementIf.tap(PLUGIN_NAME, (statement) => {
 						if (parser.scope.isAsmJs) return;
 						const param = parser.evaluateExpression(statement.test);
 						const bool = param.asBool();
@@ -177,56 +181,25 @@ class ConstPlugin {
 								? statement.alternate
 								: statement.consequent;
 							if (branchToRemove) {
-								// Before removing the dead branch, the hoisted declarations
-								// must be collected.
-								//
-								// Given the following code:
-								//
-								//     if (true) f() else g()
-								//     if (false) {
-								//       function f() {}
-								//       const g = function g() {}
-								//       if (someTest) {
-								//         let a = 1
-								//         var x, {y, z} = obj
-								//       }
-								//     } else {
-								//       …
-								//     }
-								//
-								// the generated code is:
-								//
-								//     if (true) f() else {}
-								//     if (false) {
-								//       var f, x, y, z;   (in loose mode)
-								//       var x, y, z;      (in strict mode)
-								//     } else {
-								//       …
-								//     }
-								//
-								// NOTE: When code runs in strict mode, `var` declarations
-								// are hoisted but `function` declarations don't.
-								//
-								const declarations = parser.scope.isStrict
-									? getHoistedDeclarations(branchToRemove, false)
-									: getHoistedDeclarations(branchToRemove, true);
-								const replacement =
-									declarations.length > 0
-										? `{ var ${declarations.join(", ")}; }`
-										: "{}";
-								const dep = new ConstDependency(
-									replacement,
-									/** @type {Range} */ (branchToRemove.range)
-								);
-								dep.loc = /** @type {SourceLocation} */ (branchToRemove.loc);
-								parser.state.module.addPresentationalDependency(dep);
+								this.eliminateUnusedStatement(parser, branchToRemove, true);
 							}
 							return bool;
 						}
 					});
+					parser.hooks.unusedStatement.tap(PLUGIN_NAME, (statement) => {
+						if (
+							parser.scope.isAsmJs ||
+							// Check top level scope here again
+							parser.scope.topLevelScope === true
+						) {
+							return;
+						}
+						this.eliminateUnusedStatement(parser, statement, false);
+						return true;
+					});
 					parser.hooks.expressionConditionalOperator.tap(
 						PLUGIN_NAME,
-						expression => {
+						(expression) => {
 							if (parser.scope.isAsmJs) return;
 							const param = parser.evaluateExpression(expression.test);
 							const bool = param.asBool();
@@ -267,7 +240,7 @@ class ConstPlugin {
 					);
 					parser.hooks.expressionLogicalOperator.tap(
 						PLUGIN_NAME,
-						expression => {
+						(expression) => {
 							if (parser.scope.isAsmJs) return;
 							if (
 								expression.operator === "&&" ||
@@ -409,7 +382,7 @@ class ConstPlugin {
 							}
 						}
 					);
-					parser.hooks.optionalChaining.tap(PLUGIN_NAME, expr => {
+					parser.hooks.optionalChaining.tap(PLUGIN_NAME, (expr) => {
 						/** @type {Expression[]} */
 						const optionalExpressionsStack = [];
 						/** @type {Expression | Super} */
@@ -469,7 +442,7 @@ class ConstPlugin {
 					});
 					parser.hooks.evaluateIdentifier
 						.for("__resourceQuery")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							return evaluateToString(
@@ -478,7 +451,7 @@ class ConstPlugin {
 						});
 					parser.hooks.expression
 						.for("__resourceQuery")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							const dep = new CachedConstDependency(
@@ -495,7 +468,7 @@ class ConstPlugin {
 
 					parser.hooks.evaluateIdentifier
 						.for("__resourceFragment")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							return evaluateToString(
@@ -504,7 +477,7 @@ class ConstPlugin {
 						});
 					parser.hooks.expression
 						.for("__resourceFragment")
-						.tap(PLUGIN_NAME, expr => {
+						.tap(PLUGIN_NAME, (expr) => {
 							if (parser.scope.isAsmJs) return;
 							if (!parser.state.module) return;
 							const dep = new CachedConstDependency(
@@ -532,6 +505,63 @@ class ConstPlugin {
 			}
 		);
 	}
+
+	/**
+	 * Eliminate an unused statement.
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Statement} statement the statement to remove
+	 * @param {boolean} alwaysInBlock whether to always generate curly brackets
+	 * @returns {void}
+	 */
+	eliminateUnusedStatement(parser, statement, alwaysInBlock) {
+		// Before removing the unused branch, the hoisted declarations
+		// must be collected.
+		//
+		// Given the following code:
+		//
+		//     if (true) f() else g()
+		//     if (false) {
+		//       function f() {}
+		//       const g = function g() {}
+		//       if (someTest) {
+		//         let a = 1
+		//         var x, {y, z} = obj
+		//       }
+		//     } else {
+		//       …
+		//     }
+		//
+		// the generated code is:
+		//
+		//     if (true) f() else {}
+		//     if (false) {
+		//       var f, x, y, z;   (in loose mode)
+		//       var x, y, z;      (in strict mode)
+		//     } else {
+		//       …
+		//     }
+		//
+		// NOTE: When code runs in strict mode, `var` declarations
+		// are hoisted but `function` declarations don't.
+		//
+		const declarations = parser.scope.isStrict
+			? getHoistedDeclarations(statement, false)
+			: getHoistedDeclarations(statement, true);
+
+		const inBlock = alwaysInBlock || statement.type === "BlockStatement";
+
+		let replacement = inBlock ? "{" : "";
+		replacement +=
+			declarations.length > 0 ? ` var ${declarations.join(", ")}; ` : "";
+		replacement += inBlock ? "}" : "";
+
+		const dep = new ConstDependency(
+			`// removed by dead control flow\n${replacement}`,
+			/** @type {Range} */ (statement.range)
+		);
+		dep.loc = /** @type {SourceLocation} */ (statement.loc);
+		parser.state.module.addPresentationalDependency(dep);
+	}
 }
 
 module.exports = ConstPlugin;

package/lib/ContextExclusionPlugin.js

@@ -5,7 +5,8 @@
 "use strict";
 
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./ContextModuleFactory")} ContextModuleFactory */
+
+const PLUGIN_NAME = "ContextExclusionPlugin";
 
 class ContextExclusionPlugin {
 	/**
@@ -21,9 +22,9 @@ class ContextExclusionPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.contextModuleFactory.tap("ContextExclusionPlugin", cmf => {
-			cmf.hooks.contextModuleFiles.tap("ContextExclusionPlugin", files =>
-				files.filter(filePath => !this.negativeMatcher.test(filePath))
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => {
+			cmf.hooks.contextModuleFiles.tap(PLUGIN_NAME, (files) =>
+				files.filter((filePath) => !this.negativeMatcher.test(filePath))
 			);
 		});
 	}