webpack 5.99.8 → 5.100.0

package/lib/ConcatenationScope.js

@@ -15,13 +15,14 @@ const {
 /** @typedef {import("./optimize/ConcatenatedModule").ModuleInfo} ModuleInfo */
 
 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 {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
  */
 
@@ -90,21 +91,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 +131,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/ConstPlugin.js

@@ -68,6 +68,7 @@ const collectDeclaration = (declarations, pattern) => {
  * @returns {Array<string>} hoisted declarations
  */
 const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
+	/** @type {Set<string>} */
 	const declarations = new Set();
 	/** @type {Array<Statement | null | undefined>} */
 	const stack = [branch];
@@ -129,7 +130,7 @@ const getHoistedDeclarations = (branch, includeFunctionDeclarations) => {
 				break;
 		}
 	}
-	return Array.from(declarations);
+	return [...declarations];
 };
 
 const PLUGIN_NAME = "ConstPlugin";
@@ -159,7 +160,7 @@ class ConstPlugin {
 				 * @param {JavascriptParser} parser the parser
 				 */
 				const handler = parser => {
-					parser.hooks.terminate.tap(PLUGIN_NAME, statement => true);
+					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);
@@ -179,53 +180,22 @@ 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);
 							}
 							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);
+						return true;
+					});
 					parser.hooks.expressionConditionalOperator.tap(
 						PLUGIN_NAME,
 						expression => {
@@ -534,6 +504,56 @@ class ConstPlugin {
 			}
 		);
 	}
+
+	/**
+	 * Eliminate an unused statement.
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Statement} statement the statement to remove
+	 * @returns {void}
+	 */
+	eliminateUnusedStatement(parser, statement) {
+		// 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 replacement =
+			declarations.length > 0 ? `{ var ${declarations.join(", ")}; }` : "{}";
+		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/ContextModule.js

@@ -16,15 +16,15 @@ const Template = require("./Template");
 const WebpackError = require("./WebpackError");
 const {
 	compareLocations,
-	concatComparators,
+	compareModulesById,
 	compareSelect,
-	keepOriginalOrder,
-	compareModulesById
+	concatComparators,
+	keepOriginalOrder
 } = require("./util/comparators");
 const {
 	contextify,
-	parseResource,
-	makePathsRelative
+	makePathsRelative,
+	parseResource
 } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 
@@ -412,8 +412,9 @@ class ContextModule extends Module {
 		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
 
 		// always build when we have no snapshot and context
-		if (!buildInfo.snapshot)
+		if (!buildInfo.snapshot) {
 			return callback(null, Boolean(this.context || this.options.resource));
+		}
 
 		fileSystemInfo.checkSnapshotValid(buildInfo.snapshot, (err, valid) => {
 			callback(err, !valid);
@@ -996,10 +997,11 @@ module.exports = webpackAsyncContext;`;
 				if (hasFakeMap) {
 					arrayStart.push(fakeMap[moduleId]);
 				}
-				map[item.userRequest] = arrayStart.concat(
-					/** @type {Chunk[]} */
+				map[item.userRequest] = [
+					...arrayStart,
+					.../** @type {Chunk[]} */
 					(item.chunks).map(chunk => /** @type {ChunkId} */ (chunk.id))
-				);
+				];
 			}
 		}
 
@@ -1186,11 +1188,13 @@ module.exports = webpackEmptyAsyncContext;`;
 		const set = new Set();
 		const allDeps =
 			this.dependencies.length > 0
-				? /** @type {ContextElementDependency[]} */ (this.dependencies).slice()
+				? /** @type {ContextElementDependency[]} */ [...this.dependencies]
 				: [];
-		for (const block of this.blocks)
-			for (const dep of block.dependencies)
+		for (const block of this.blocks) {
+			for (const dep of block.dependencies) {
 				allDeps.push(/** @type {ContextElementDependency} */ (dep));
+			}
+		}
 		set.add(RuntimeGlobals.module);
 		set.add(RuntimeGlobals.hasOwnProperty);
 		if (allDeps.length > 0) {

package/lib/ContextModuleFactory.js

@@ -344,14 +344,15 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 				const processedFiles = cmf.hooks.contextModuleFiles.call(
 					/** @type {string[]} */ (files).map(file => file.normalize("NFC"))
 				);
-				if (!processedFiles || processedFiles.length === 0)
+				if (!processedFiles || processedFiles.length === 0) {
 					return callback(null, []);
+				}
 				asyncLib.map(
 					processedFiles.filter(p => p.indexOf(".") !== 0),
 					(segment, callback) => {
 						const subResource = join(fs, directory, segment);
 
-						if (!exclude || !subResource.match(exclude)) {
+						if (!exclude || !exclude.test(subResource)) {
 							fs.stat(subResource, (err, _stat) => {
 								if (err) {
 									if (err.code === "ENOENT") {
@@ -369,7 +370,7 @@ module.exports = class ContextModuleFactory extends ModuleFactory {
 									addSubDirectory(ctx, subResource, callback);
 								} else if (
 									stat.isFile() &&
-									(!include || subResource.match(include))
+									(!include || include.test(subResource))
 								) {
 									/** @type {{ context: string, request: string }} */
 									const obj = {

package/lib/ContextReplacementPlugin.js

@@ -131,7 +131,8 @@ class ContextReplacementPlugin {
 							result.resource = newContentResource;
 						} else {
 							result.resource = join(
-								/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+								/** @type {InputFileSystem} */
+								(compiler.inputFileSystem),
 								result.resource,
 								newContentResource
 							);
@@ -159,7 +160,8 @@ class ContextReplacementPlugin {
 						) {
 							// When the function changed it to an relative path
 							result.resource = join(
-								/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+								/** @type {InputFileSystem} */
+								(compiler.inputFileSystem),
 								origResource,
 								result.resource
 							);

package/lib/CssModule.js

@@ -18,9 +18,9 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {string | undefined} Supports */
 /** @typedef {string | undefined} Media */
 /** @typedef {[CssLayer, Supports, Media]} InheritanceItem */
-/** @typedef {Array<InheritanceItem>} Inheritance */
+/** @typedef {InheritanceItem[]} Inheritance */
 
-/** @typedef {NormalModuleCreateData & { cssLayer: CssLayer, supports: Supports, media: Media, inheritance: Inheritance }} CSSModuleCreateData */
+/** @typedef {NormalModuleCreateData & { cssLayer: CssLayer, supports: Supports, media: Media, inheritance?: Inheritance }} CSSModuleCreateData */
 
 class CssModule extends NormalModule {
 	/**
@@ -158,7 +158,6 @@ class CssModule extends NormalModule {
 
 	/**
 	 * @param {ObjectDeserializerContext} context context
-	 * @returns {TODO} Module
 	 */
 	deserialize(context) {
 		const { read } = context;

package/lib/DefinePlugin.js

@@ -7,8 +7,8 @@
 
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const WebpackError = require("./WebpackError");
@@ -356,6 +356,16 @@ class DefinePlugin {
 	 */
 	apply(compiler) {
 		const definitions = this.definitions;
+
+		/**
+		 * @type {Map<string, Set<string>>}
+		 */
+		const finalByNestedKey = new Map();
+		/**
+		 * @type {Map<string, Set<string>>}
+		 */
+		const nestedByFinalKey = new Map();
+
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
@@ -381,6 +391,7 @@ class DefinePlugin {
 				 * @returns {void}
 				 */
 				const handler = parser => {
+					const hooked = new Set();
 					const mainValue =
 						/** @type {ValueCacheVersion} */
 						(compilation.valueCacheVersions.get(VALUE_DEP_MAIN));
@@ -388,8 +399,9 @@ class DefinePlugin {
 						const buildInfo = /** @type {BuildInfo} */ (
 							parser.state.module.buildInfo
 						);
-						if (!buildInfo.valueDependencies)
+						if (!buildInfo.valueDependencies) {
 							buildInfo.valueDependencies = new Map();
+						}
 						buildInfo.valueDependencies.set(VALUE_DEP_MAIN, mainValue);
 					});
 
@@ -469,6 +481,61 @@ class DefinePlugin {
 								return true;
 							});
 						}
+						if (prefix === "") {
+							const final = splittedKey[splittedKey.length - 1];
+							const nestedSet = nestedByFinalKey.get(final);
+							if (!nestedSet || nestedSet.size <= 0) return;
+							for (const nested of /** @type {Set<string>} */ (nestedSet)) {
+								if (nested && !hooked.has(nested)) {
+									// only detect the same nested key once
+									hooked.add(nested);
+									parser.hooks.expression.for(nested).tap(
+										{
+											name: PLUGIN_NAME,
+											// why 100? Ensures it runs after object define
+											stage: 100
+										},
+										expr => {
+											const destructed =
+												parser.destructuringAssignmentPropertiesFor(expr);
+											if (destructed === undefined) {
+												return;
+											}
+											/** @type {Record<string, CodeValue>} */
+											const obj = {};
+											const finalSet = finalByNestedKey.get(nested);
+											for (const { id } of destructed) {
+												const fullKey = `${nested}.${id}`;
+												if (
+													!finalSet ||
+													!finalSet.has(id) ||
+													!definitions[fullKey]
+												) {
+													return;
+												}
+												obj[id] = definitions[fullKey];
+											}
+											let strCode = stringifyObj(
+												obj,
+												parser,
+												compilation.valueCacheVersions,
+												key,
+												runtimeTemplate,
+												logger,
+												!parser.isAsiPosition(
+													/** @type {Range} */ (expr.range)[0]
+												),
+												getObjKeys(destructed)
+											);
+											if (parser.scope.inShorthand) {
+												strCode = `${parser.scope.inShorthand}:${strCode}`;
+											}
+											return toConstantDependency(parser, strCode)(expr);
+										}
+									);
+								}
+							}
+						}
 					};
 
 					/**
@@ -707,6 +774,46 @@ class DefinePlugin {
 					}
 				};
 
+				/**
+				 * @param {Record<string, CodeValue>} definitions Definitions map
+				 * @returns {void}
+				 */
+				const walkDefinitionsForKeys = definitions => {
+					/**
+					 * @param {Map<string, Set<string>>} map Map
+					 * @param {string} key key
+					 * @param {string} value v
+					 * @returns {void}
+					 */
+					const addToMap = (map, key, value) => {
+						if (map.has(key)) {
+							/** @type {Set<string>} */
+							(map.get(key)).add(value);
+						} else {
+							map.set(key, new Set([value]));
+						}
+					};
+					for (const key of Object.keys(definitions)) {
+						const code = definitions[key];
+						if (
+							!code ||
+							typeof code === "object" ||
+							TYPEOF_OPERATOR_REGEXP.test(key)
+						) {
+							continue;
+						}
+						const idx = key.lastIndexOf(".");
+						if (idx <= 0 || idx >= key.length - 1) {
+							continue;
+						}
+						const nested = key.slice(0, idx);
+						const final = key.slice(idx + 1);
+						addToMap(finalByNestedKey, nested, final);
+						addToMap(nestedByFinalKey, final, nested);
+					}
+				};
+
+				walkDefinitionsForKeys(definitions);
 				walkDefinitionsForValues(definitions, "");
 
 				compilation.valueCacheVersions.set(
@@ -717,4 +824,5 @@ class DefinePlugin {
 		);
 	}
 }
+
 module.exports = DefinePlugin;

package/lib/DelegatedModuleFactoryPlugin.js

@@ -25,6 +25,8 @@ const DelegatedModule = require("./DelegatedModule");
  * @property {AssociatedObjectForCache=} associatedObjectForCache object for caching
  */
 
+const PLUGIN_NAME = "DelegatedModuleFactoryPlugin";
+
 class DelegatedModuleFactoryPlugin {
 	/**
 	 * @param {Options} options options
@@ -43,7 +45,7 @@ class DelegatedModuleFactoryPlugin {
 		const scope = this.options.scope;
 		if (scope) {
 			normalModuleFactory.hooks.factorize.tapAsync(
-				"DelegatedModuleFactoryPlugin",
+				PLUGIN_NAME,
 				(data, callback) => {
 					const [dependency] = data.dependencies;
 					const { request } = dependency;
@@ -90,25 +92,23 @@ class DelegatedModuleFactoryPlugin {
 				}
 			);
 		} else {
-			normalModuleFactory.hooks.module.tap(
-				"DelegatedModuleFactoryPlugin",
-				module => {
-					const request = module.libIdent(this.options);
-					if (request && request in this.options.content) {
-						const resolved = this.options.content[request];
-						return new DelegatedModule(
-							this.options.source,
-							resolved,
-							/** @type {DelegatedModuleType} */
-							(this.options.type),
-							request,
-							module
-						);
-					}
-					return module;
+			normalModuleFactory.hooks.module.tap(PLUGIN_NAME, module => {
+				const request = module.libIdent(this.options);
+				if (request && request in this.options.content) {
+					const resolved = this.options.content[request];
+					return new DelegatedModule(
+						this.options.source,
+						resolved,
+						/** @type {DelegatedModuleType} */
+						(this.options.type),
+						request,
+						module
+					);
 				}
-			);
+				return module;
+			});
 		}
 	}
 }
+
 module.exports = DelegatedModuleFactoryPlugin;

package/lib/Dependency.js

@@ -101,7 +101,10 @@ class Dependency {
 		/** @type {boolean} */
 		this.weak = false;
 		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
+		/** @type {boolean | undefined} */
+		this.defer = false;
+		// TODO check if this can be moved into ModuleDependency
+		/** @type {boolean | undefined} */
 		this.optional = false;
 		this._locSL = 0;
 		this._locSC = 0;
@@ -131,23 +134,22 @@ class Dependency {
 	 */
 	get loc() {
 		if (this._loc !== undefined) return this._loc;
+
 		/** @type {SyntheticDependencyLocation & RealDependencyLocation} */
-		const loc = {
-			start: { line: 0, column: 0 },
-			end: { line: 0, column: 0 },
-			name: "",
-			index: -1
-		};
+		const loc = {};
+
 		if (this._locSL > 0) {
 			loc.start = { line: this._locSL, column: this._locSC };
 		}
 		if (this._locEL > 0) {
 			loc.end = { line: this._locEL, column: this._locEC };
 		}
-
-		loc.name = this._locN;
-
-		loc.index = this._locI;
+		if (this._locN !== undefined) {
+			loc.name = this._locN;
+		}
+		if (this._locI !== undefined) {
+			loc.index = this._locI;
+		}
 
 		return (this._loc = loc);
 	}
@@ -292,7 +294,7 @@ class Dependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module | null} a module
+	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
 		return getIgnoredModule();
@@ -310,6 +312,7 @@ class Dependency {
 		write(this._locEC);
 		write(this._locI);
 		write(this._locN);
+		write(this.defer);
 	}
 
 	/**
@@ -324,6 +327,7 @@ class Dependency {
 		this._locEC = read();
 		this._locI = read();
 		this._locN = read();
+		this.defer = read();
 	}
 }
 

package/lib/DependencyTemplate.js

@@ -62,6 +62,7 @@ class DependencyTemplate {
 	 */
 	apply(dependency, source, templateContext) {
 		const AbstractMethodError = require("./AbstractMethodError");
+
 		throw new AbstractMethodError();
 	}
 }

package/lib/DllEntryPlugin.js

@@ -10,8 +10,10 @@ const DllEntryDependency = require("./dependencies/DllEntryDependency");
 const EntryDependency = require("./dependencies/EntryDependency");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+
 /** @typedef {string[]} Entries */
-/** @typedef {{ name: string, filename: TODO }} Options */
+/** @typedef {EntryOptions & { name: string }} Options */
 
 const PLUGIN_NAME = "DllEntryPlugin";
 

package/lib/DllPlugin.js

@@ -16,7 +16,7 @@ const createSchemaValidation = require("./util/create-schema-validation");
 /** @typedef {import("./DllEntryPlugin").Options} Options */
 
 const validate = createSchemaValidation(
-	require("../schemas/plugins/DllPlugin.check.js"),
+	require("../schemas/plugins/DllPlugin.check"),
 	() => require("../schemas/plugins/DllPlugin.json"),
 	{
 		name: "Dll Plugin",
@@ -48,10 +48,11 @@ class DllPlugin {
 			if (typeof entry !== "function") {
 				for (const name of Object.keys(entry)) {
 					/** @type {Options} */
-					const options = { name, filename: entry.filename };
+					const options = { name };
 					new DllEntryPlugin(
 						context,
-						/** @type {Entries} */ (entry[name].import),
+						/** @type {Entries} */
+						(entry[name].import),
 						options
 					).apply(compiler);
 				}