webpack 5.94.0 → 5.95.0

package/lib/EnvironmentPlugin.js

@@ -13,15 +13,16 @@ const WebpackError = require("./WebpackError");
 
 class EnvironmentPlugin {
 	/**
-	 * @param {(string | string[] | Record<string, string>)[]} keys keys
+	 * @param {(string | string[] | Record<string, any>)[]} keys keys
 	 */
 	constructor(...keys) {
 		if (keys.length === 1 && Array.isArray(keys[0])) {
+			/** @type {string[]} */
 			this.keys = keys[0];
 			this.defaultValues = {};
 		} else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") {
 			this.keys = Object.keys(keys[0]);
-			this.defaultValues = /** @type {Record<string, string>} */ (keys[0]);
+			this.defaultValues = /** @type {Record<string, any>} */ (keys[0]);
 		} else {
 			this.keys = /** @type {string[]} */ (keys);
 			this.defaultValues = {};

package/lib/ExternalModule.js

@@ -526,7 +526,7 @@ class ExternalModule extends Module {
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
-		return `external ${this.externalType} ${JSON.stringify(this.request)}`;
+		return `external ${this._resolveExternalType(this.externalType)} ${JSON.stringify(this.request)}`;
 	}
 
 	/**
@@ -546,25 +546,6 @@ class ExternalModule extends Module {
 		return callback(null, !this.buildMeta);
 	}
 
-	/**
-	 * @param {string} externalType raw external type
-	 * @returns {string} resolved external type
-	 */
-	getModuleImportType(externalType) {
-		if (externalType === "module-import") {
-			if (
-				this.dependencyMeta &&
-				/** @type {ImportDependencyMeta} */ (this.dependencyMeta).externalType
-			) {
-				return /** @type {ImportDependencyMeta} */ (this.dependencyMeta)
-					.externalType;
-			}
-			return "module";
-		}
-
-		return externalType;
-	}
-
 	/**
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
@@ -597,6 +578,25 @@ class ExternalModule extends Module {
 					canMangle = true;
 				}
 				break;
+			case "module":
+				if (this.buildInfo.module) {
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = true;
+					}
+				} else {
+					this.buildMeta.async = true;
+					EnvironmentNotSupportAsyncWarning.check(
+						this,
+						compilation.runtimeTemplate,
+						"external module"
+					);
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = false;
+					}
+				}
+				break;
 			case "script":
 				this.buildMeta.async = true;
 				EnvironmentNotSupportAsyncWarning.check(
@@ -613,45 +613,18 @@ class ExternalModule extends Module {
 					"external promise"
 				);
 				break;
-			case "module":
 			case "import":
-			case "module-import": {
-				const type = this.getModuleImportType(externalType);
-				if (type === "module") {
-					if (this.buildInfo.module) {
-						if (!Array.isArray(request) || request.length === 1) {
-							this.buildMeta.exportsType = "namespace";
-							canMangle = true;
-						}
-					} else {
-						this.buildMeta.async = true;
-						EnvironmentNotSupportAsyncWarning.check(
-							this,
-							compilation.runtimeTemplate,
-							"external module"
-						);
-						if (!Array.isArray(request) || request.length === 1) {
-							this.buildMeta.exportsType = "namespace";
-							canMangle = false;
-						}
-					}
-				}
-
-				if (type === "import") {
-					this.buildMeta.async = true;
-					EnvironmentNotSupportAsyncWarning.check(
-						this,
-						compilation.runtimeTemplate,
-						"external import"
-					);
-					if (!Array.isArray(request) || request.length === 1) {
-						this.buildMeta.exportsType = "namespace";
-						canMangle = false;
-					}
+				this.buildMeta.async = true;
+				EnvironmentNotSupportAsyncWarning.check(
+					this,
+					compilation.runtimeTemplate,
+					"external import"
+				);
+				if (!Array.isArray(request) || request.length === 1) {
+					this.buildMeta.exportsType = "namespace";
+					canMangle = false;
 				}
-
 				break;
-			}
 		}
 		this.addDependency(new StaticExportsDependency(true, canMangle));
 		callback();
@@ -687,9 +660,31 @@ class ExternalModule extends Module {
 		let { request, externalType } = this;
 		if (typeof request === "object" && !Array.isArray(request))
 			request = request[externalType];
+		externalType = this._resolveExternalType(externalType);
 		return { request, externalType };
 	}
 
+	/**
+	 * Resolve the detailed external type from the raw external type.
+	 * e.g. resolve "module" or "import" from "module-import" type
+	 * @param {string} externalType raw external type
+	 * @returns {string} resolved external type
+	 */
+	_resolveExternalType(externalType) {
+		if (externalType === "module-import") {
+			if (
+				this.dependencyMeta &&
+				/** @type {ImportDependencyMeta} */ (this.dependencyMeta).externalType
+			) {
+				return /** @type {ImportDependencyMeta} */ (this.dependencyMeta)
+					.externalType;
+			}
+			return "module";
+		}
+
+		return externalType;
+	}
+
 	/**
 	 * @private
 	 * @param {string | string[]} request request
@@ -749,52 +744,43 @@ class ExternalModule extends Module {
 					runtimeTemplate
 				);
 			}
+			case "import":
+				return getSourceForImportExternal(
+					request,
+					runtimeTemplate,
+					/** @type {ImportDependencyMeta} */ (dependencyMeta)
+				);
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
-			case "module":
-			case "import":
-			case "module-import": {
-				const type = this.getModuleImportType(externalType);
-				if (type === "import") {
-					return getSourceForImportExternal(
-						request,
-						runtimeTemplate,
-						/** @type {ImportDependencyMeta} */ (dependencyMeta)
-					);
-				}
-
-				if (type === "module") {
-					if (!(/** @type {BuildInfo} */ (this.buildInfo).module)) {
-						if (!runtimeTemplate.supportsDynamicImport()) {
-							throw new Error(
-								`The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script${
-									runtimeTemplate.supportsEcmaScriptModuleSyntax()
-										? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
-										: ""
-								}`
-							);
-						}
-						return getSourceForImportExternal(
-							request,
-							runtimeTemplate,
-							/** @type {ImportDependencyMeta} */ (dependencyMeta)
-						);
-					}
-					if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
+			case "module": {
+				if (!(/** @type {BuildInfo} */ (this.buildInfo).module)) {
+					if (!runtimeTemplate.supportsDynamicImport()) {
 						throw new Error(
-							"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
+							`The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script${
+								runtimeTemplate.supportsEcmaScriptModuleSyntax()
+									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
+									: ""
+							}`
 						);
 					}
-					return getSourceForModuleExternal(
+					return getSourceForImportExternal(
 						request,
-						moduleGraph.getExportsInfo(this),
-						runtime,
 						runtimeTemplate,
 						/** @type {ImportDependencyMeta} */ (dependencyMeta)
 					);
 				}
-
-				break;
+				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
+					throw new Error(
+						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
+					);
+				}
+				return getSourceForModuleExternal(
+					request,
+					moduleGraph.getExportsInfo(this),
+					runtime,
+					runtimeTemplate,
+					/** @type {ImportDependencyMeta} */ (dependencyMeta)
+				);
 			}
 			case "var":
 			case "promise":
@@ -939,7 +925,7 @@ class ExternalModule extends Module {
 	updateHash(hash, context) {
 		const { chunkGraph } = context;
 		hash.update(
-			`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(
+			`${this._resolveExternalType(this.externalType)}${JSON.stringify(this.request)}${this.isOptional(
 				chunkGraph.moduleGraph
 			)}`
 		);

package/lib/NormalModule.js

@@ -777,6 +777,10 @@ class NormalModule extends Module {
 			webpack: true,
 			sourceMap: Boolean(this.useSourceMap),
 			mode: options.mode || "production",
+			hashFunction: options.output.hashFunction,
+			hashDigest: options.output.hashDigest,
+			hashDigestLength: options.output.hashDigestLength,
+			hashSalt: options.output.hashSalt,
 			_module: this,
 			_compilation: compilation,
 			_compiler: compilation.compiler,

package/lib/TemplatedPathPlugin.js

@@ -162,19 +162,25 @@ const replacePathVariables = (path, data, assetInfo) => {
 		if (match) {
 			const ext = mime.extension(match[1]);
 			const emptyReplacer = replacer("", true);
+			// "XXXX" used for `updateHash`, so we don't need it here
+			const contentHash =
+				data.contentHash && !/X+/.test(data.contentHash)
+					? data.contentHash
+					: false;
+			const baseReplacer = contentHash ? replacer(contentHash) : emptyReplacer;
 
 			replacements.set("file", emptyReplacer);
 			replacements.set("query", emptyReplacer);
 			replacements.set("fragment", emptyReplacer);
 			replacements.set("path", emptyReplacer);
-			replacements.set("base", emptyReplacer);
-			replacements.set("name", emptyReplacer);
+			replacements.set("base", baseReplacer);
+			replacements.set("name", baseReplacer);
 			replacements.set("ext", replacer(ext ? `.${ext}` : "", true));
 			// Legacy
 			replacements.set(
 				"filebase",
 				deprecated(
-					emptyReplacer,
+					baseReplacer,
 					"[filebase] is now [base]",
 					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
 				)

package/lib/buildChunkGraph.js

@@ -38,6 +38,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @typedef {object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
+ * @property {boolean} initialized is this chunk group initialized
  * @property {bigint | undefined} minAvailableModules current minimal set of modules available at this point
  * @property {bigint[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
  * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
@@ -345,8 +346,8 @@ const visitModules = (
 	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
 	const blockChunkGroups = new Map();
 
-	/** @type {Map<ChunkGroupInfo, DependenciesBlock>} */
-	const blockByChunkGroups = new Map();
+	/** @type {Map<ChunkGroupInfo, Set<DependenciesBlock>>} */
+	const blocksByChunkGroups = new Map();
 
 	/** @type {Map<string, ChunkGroupInfo>} */
 	const namedChunkGroups = new Map();
@@ -367,7 +368,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queue = [];
 
-	/** @type {Map<ChunkGroupInfo, Set<ChunkGroupInfo>>} */
+	/** @type {Map<ChunkGroupInfo, Set<[ChunkGroupInfo, QueueItem | null]>>} */
 	const queueConnect = new Map();
 	/** @type {Set<ChunkGroupInfo>} */
 	const chunkGroupsForCombining = new Set();
@@ -382,6 +383,7 @@ const visitModules = (
 		);
 		/** @type {ChunkGroupInfo} */
 		const chunkGroupInfo = {
+			initialized: false,
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
@@ -452,7 +454,7 @@ const visitModules = (
 
 	/** @type {Set<ChunkGroupInfo>} */
 	const outdatedChunkGroupInfo = new Set();
-	/** @type {Set<ChunkGroupInfo>} */
+	/** @type {Set<[ChunkGroupInfo, QueueItem]>} */
 	const chunkGroupsForMerging = new Set();
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
@@ -505,6 +507,7 @@ const visitModules = (
 					entrypoint.index = nextChunkGroupIndex++;
 					cgi = {
 						chunkGroup: entrypoint,
+						initialized: false,
 						runtime: entrypoint.options.runtime || entrypoint.name,
 						minAvailableModules: ZERO_BIGINT,
 						availableModulesToBeMerged: [],
@@ -572,6 +575,7 @@ const visitModules = (
 					maskByChunk.set(c.chunks[0], ZERO_BIGINT);
 					c.index = nextChunkGroupIndex++;
 					cgi = {
+						initialized: false,
 						chunkGroup: c,
 						runtime: chunkGroupInfo.runtime,
 						minAvailableModules: undefined,
@@ -614,7 +618,6 @@ const visitModules = (
 				blockConnections.set(b, []);
 			}
 			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
-			blockByChunkGroups.set(/** @type {ChunkGroupInfo} */ (cgi), b);
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -636,19 +639,17 @@ const visitModules = (
 				connectList = new Set();
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
-			connectList.add(/** @type {ChunkGroupInfo} */ (cgi));
-
-			// TODO check if this really need to be done for each traversal
-			// or if it is enough when it's queued when created
-			// 4. We enqueue the DependenciesBlock for traversal
-			queueDelayed.push({
-				action: PROCESS_BLOCK,
-				block: b,
-				module,
-				chunk: c.chunks[0],
-				chunkGroup: c,
-				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
-			});
+			connectList.add([
+				cgi,
+				{
+					action: PROCESS_BLOCK,
+					block: b,
+					module,
+					chunk: c.chunks[0],
+					chunkGroup: c,
+					chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
+				}
+			]);
 		} else if (entrypoint !== undefined) {
 			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
 		}
@@ -901,11 +902,10 @@ const visitModules = (
 		for (const [chunkGroupInfo, targets] of queueConnect) {
 			// 1. Add new targets to the list of children
 			if (chunkGroupInfo.children === undefined) {
-				chunkGroupInfo.children = targets;
-			} else {
-				for (const target of targets) {
-					chunkGroupInfo.children.add(target);
-				}
+				chunkGroupInfo.children = new Set();
+			}
+			for (const [target] of targets) {
+				chunkGroupInfo.children.add(target);
 			}
 
 			// 2. Calculate resulting available modules
@@ -915,9 +915,9 @@ const visitModules = (
 			const runtime = chunkGroupInfo.runtime;
 
 			// 3. Update chunk group info
-			for (const target of targets) {
+			for (const [target, processBlock] of targets) {
 				target.availableModulesToBeMerged.push(resultingAvailableModules);
-				chunkGroupsForMerging.add(target);
+				chunkGroupsForMerging.add([target, processBlock]);
 				const oldRuntime = target.runtime;
 				const newRuntime = mergeRuntime(oldRuntime, runtime);
 				if (oldRuntime !== newRuntime) {
@@ -935,7 +935,7 @@ const visitModules = (
 		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
 
 		// Execute the merge
-		for (const info of chunkGroupsForMerging) {
+		for (const [info, processBlock] of chunkGroupsForMerging) {
 			const availableModulesToBeMerged = info.availableModulesToBeMerged;
 			const cachedMinAvailableModules = info.minAvailableModules;
 			let minAvailableModules = cachedMinAvailableModules;
@@ -958,6 +958,27 @@ const visitModules = (
 				info.resultingAvailableModules = undefined;
 				outdatedChunkGroupInfo.add(info);
 			}
+
+			if (processBlock) {
+				let blocks = blocksByChunkGroups.get(info);
+				if (!blocks) {
+					blocksByChunkGroups.set(info, (blocks = new Set()));
+				}
+
+				// Whether to walk block depends on minAvailableModules and input block.
+				// We can treat creating chunk group as a function with 2 input, entry block and minAvailableModules
+				// If input is the same, we can skip re-walk
+				let needWalkBlock = !info.initialized || changed;
+				if (!blocks.has(processBlock.block)) {
+					needWalkBlock = true;
+					blocks.add(processBlock.block);
+				}
+
+				if (needWalkBlock) {
+					info.initialized = true;
+					queueDelayed.push(processBlock);
+				}
+			}
 		}
 		chunkGroupsForMerging.clear();
 	};
@@ -1057,7 +1078,7 @@ const visitModules = (
 						connectList = new Set();
 						queueConnect.set(info, connectList);
 					}
-					connectList.add(cgi);
+					connectList.add([cgi, null]);
 				}
 			}
 
@@ -1117,48 +1138,44 @@ const visitModules = (
 	for (const info of outdatedOrderIndexChunkGroups) {
 		const { chunkGroup, runtime } = info;
 
-		const block = blockByChunkGroups.get(info);
+		const blocks = blocksByChunkGroups.get(info);
 
-		if (!block) {
+		if (!blocks) {
 			continue;
 		}
 
-		let preOrderIndex = 0;
-		let postOrderIndex = 0;
-
-		/**
-		 * @param {DependenciesBlock} current current
-		 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
-		 */
-		const process = (current, visited) => {
-			const blockModules = getBlockModules(current, runtime);
-			if (blockModules === undefined) {
-				return;
-			}
-
-			for (let i = 0, len = blockModules.length; i < len; i += 3) {
-				const activeState = /** @type {ConnectionState} */ (
-					blockModules[i + 1]
-				);
-				if (activeState === false) {
-					continue;
-				}
-				const refModule = /** @type {Module} */ (blockModules[i]);
-				if (visited.has(refModule)) {
-					continue;
-				}
+		for (const block of blocks) {
+			let preOrderIndex = 0;
+			let postOrderIndex = 0;
+			/**
+			 * @param {DependenciesBlock} current current
+			 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
+			 */
+			const process = (current, visited) => {
+				const blockModules = getBlockModules(current, runtime);
+				for (let i = 0, len = blockModules.length; i < len; i += 3) {
+					const activeState = /** @type {ConnectionState} */ (
+						blockModules[i + 1]
+					);
+					if (activeState === false) {
+						continue;
+					}
+					const refModule = /** @type {Module} */ (blockModules[i]);
+					if (visited.has(refModule)) {
+						continue;
+					}
 
-				visited.add(refModule);
+					visited.add(refModule);
 
-				if (refModule) {
-					chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
-					process(refModule, visited);
-					chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+					if (refModule) {
+						chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
+						process(refModule, visited);
+						chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+					}
 				}
-			}
-		};
-
-		process(block, new Set());
+			};
+			process(block, new Set());
+		}
 	}
 	outdatedOrderIndexChunkGroups.clear();
 	ordinalByModule.clear();

package/lib/config/defaults.js

@@ -1434,6 +1434,7 @@ const applyOptimizationDefaults = (
 	D(optimization, "innerGraph", production);
 	D(optimization, "mangleExports", production);
 	D(optimization, "concatenateModules", production);
+	D(optimization, "avoidEntryIife", production);
 	D(optimization, "runtimeChunk", false);
 	D(optimization, "emitOnErrors", !production);
 	D(optimization, "checkWasmTypes", production);

package/lib/dependencies/ContextDependency.js

@@ -91,7 +91,12 @@ class ContextDependency extends Dependency {
 				this.options.include
 			)} ${regExpToString(this.options.exclude)} ` +
 			`${this.options.mode} ${this.options.chunkName} ` +
-			`${JSON.stringify(this.options.groupOptions)}`
+			`${JSON.stringify(this.options.groupOptions)}` +
+			`${
+				this.options.referencedExports
+					? ` ${JSON.stringify(this.options.referencedExports)}`
+					: ""
+			}`
 		);
 	}
 

package/lib/dependencies/ContextElementDependency.js

@@ -9,7 +9,10 @@ const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
+/** @typedef {import("../ContextModule")} ContextModule */
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -67,12 +70,36 @@ class ContextElementDependency extends ModuleDependency {
 	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		return this.referencedExports
-			? this.referencedExports.map(e => ({
-					name: e,
-					canMangle: false
-				}))
-			: Dependency.EXPORTS_OBJECT_REFERENCED;
+		if (!this.referencedExports) return Dependency.EXPORTS_OBJECT_REFERENCED;
+		const refs = [];
+		for (const referencedExport of this.referencedExports) {
+			if (
+				this._typePrefix === "import()" &&
+				referencedExport[0] === "default"
+			) {
+				const selfModule =
+					/** @type {ContextModule} */
+					(moduleGraph.getParentModule(this));
+				const importedModule =
+					/** @type {Module} */
+					(moduleGraph.getModule(this));
+				const exportsType = importedModule.getExportsType(
+					moduleGraph,
+					selfModule.options.namespaceObject === "strict"
+				);
+				if (
+					exportsType === "default-only" ||
+					exportsType === "default-with-named"
+				) {
+					return Dependency.EXPORTS_OBJECT_REFERENCED;
+				}
+			}
+			refs.push({
+				name: referencedExport,
+				canMangle: false
+			});
+		}
+		return refs;
 	}
 
 	/**