webpack 5.106.1 → 5.107.0

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -7,10 +7,11 @@
 
 const asyncLib = require("neo-async");
 const ChunkGraph = require("../ChunkGraph");
+const Dependency = require("../Dependency");
+const Module = require("../Module");
 const ModuleGraph = require("../ModuleGraph");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
-const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const {
 	filterRuntime,
@@ -23,7 +24,6 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -31,6 +31,7 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @typedef {Module | ((requestShortener: RequestShortener) => string)} Problem */
 
 /**
+ * Defines the statistics type used by this module.
  * @typedef {object} Statistics
  * @property {number} cached
  * @property {number} alreadyInConfig
@@ -45,6 +46,7 @@ const ConcatenatedModule = require("./ConcatenatedModule");
  */
 
 /**
+ * Format bailout reason.
  * @param {string} msg message
  * @returns {string} formatted message
  */
@@ -54,7 +56,7 @@ const PLUGIN_NAME = "ModuleConcatenationPlugin";
 
 class ModuleConcatenationPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -71,6 +73,7 @@ class ModuleConcatenationPlugin {
 			const bailoutReasonMap = new Map();
 
 			/**
+			 * Sets bailout reason.
 			 * @param {Module} module the module
 			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
 			 */
@@ -86,6 +89,7 @@ class ModuleConcatenationPlugin {
 			};
 
 			/**
+			 * Sets inner bailout reason.
 			 * @param {Module} module the module
 			 * @param {string | ((requestShortener: RequestShortener) => string)} reason the reason
 			 */
@@ -94,6 +98,7 @@ class ModuleConcatenationPlugin {
 			};
 
 			/**
+			 * Gets inner bailout reason.
 			 * @param {Module} module the module
 			 * @param {RequestShortener} requestShortener the request shortener
 			 * @returns {string | ((requestShortener: RequestShortener) => string) | undefined} the reason
@@ -105,6 +110,7 @@ class ModuleConcatenationPlugin {
 			};
 
 			/**
+			 * Format bailout warning.
 			 * @param {Module} module the module
 			 * @param {Problem} problem the problem
 			 * @returns {(requestShortener: RequestShortener) => string} the reason
@@ -222,6 +228,12 @@ class ModuleConcatenationPlugin {
 							canBeRoot = false;
 						}
 
+						// TODO: ConcatenatedModule.getSourceTypes only javascript now
+						const basicTypes = Module.getSourceBasicTypes(module);
+						if (basicTypes.size !== 1 || !basicTypes.has(JAVASCRIPT_TYPE)) {
+							canBeRoot = false;
+						}
+
 						// Module must not be an entry point
 						if (chunkGraph.isEntryModule(module)) {
 							setInnerBailoutReason(module, "Module is an entry point");
@@ -454,7 +466,8 @@ class ModuleConcatenationPlugin {
 											(c) =>
 												c.originModule === m &&
 												!(
-													c.dependency instanceof HarmonyImportDependency &&
+													c.dependency &&
+													Dependency.canConcatenate(c.dependency) &&
 													modules.has(c.module)
 												)
 										);
@@ -497,7 +510,8 @@ class ModuleConcatenationPlugin {
 										const otherModule =
 											c.module === rootModule ? c.originModule : c.module;
 										const innerConnection =
-											c.dependency instanceof HarmonyImportDependency &&
+											c.dependency &&
+											Dependency.canConcatenate(c.dependency) &&
 											modules.has(/** @type {Module} */ (otherModule));
 										return !innerConnection;
 									}
@@ -521,6 +535,7 @@ class ModuleConcatenationPlugin {
 	}
 
 	/**
+	 * Returns the imported modules.
 	 * @param {Compilation} compilation the compilation
 	 * @param {Module} module the module to be added
 	 * @param {RuntimeSpec} runtime the runtime scope
@@ -531,8 +546,8 @@ class ModuleConcatenationPlugin {
 		/** @type {Set<Module>} */
 		const set = new Set();
 		for (const dep of module.dependencies) {
-			// Get reference info only for harmony Dependencies
-			if (!(dep instanceof HarmonyImportDependency)) continue;
+			// Get reference info only for dependencies that support concatenation
+			if (!Dependency.canConcatenate(dep)) continue;
 
 			const connection = moduleGraph.getConnection(dep);
 			// Reference is valid and has a module
@@ -562,6 +577,7 @@ class ModuleConcatenationPlugin {
 	}
 
 	/**
+	 * Returns the problematic module.
 	 * @param {Compilation} compilation webpack compilation
 	 * @param {ConcatConfiguration} config concat configuration (will be modified when added)
 	 * @param {Module} module the module to be added
@@ -613,6 +629,7 @@ class ModuleConcatenationPlugin {
 		].filter((chunk) => !chunkGraph.isModuleInChunk(module, chunk));
 		if (missingChunks.length > 0) {
 			/**
+			 * Returns problem description.
 			 * @param {RequestShortener} requestShortener request shortener
 			 * @returns {string} problem description
 			 */
@@ -656,6 +673,7 @@ class ModuleConcatenationPlugin {
 				);
 			if (activeNonModulesConnections.length > 0) {
 				/**
+				 * Returns problem description.
 				 * @param {RequestShortener} requestShortener request shortener
 				 * @returns {string} problem description
 				 */
@@ -722,6 +740,7 @@ class ModuleConcatenationPlugin {
 		});
 		if (otherChunkModules.length > 0) {
 			/**
+			 * Returns problem description.
 			 * @param {RequestShortener} requestShortener request shortener
 			 * @returns {string} problem description
 			 */
@@ -746,7 +765,7 @@ class ModuleConcatenationPlugin {
 			const selected = connections.filter(
 				(connection) =>
 					!connection.dependency ||
-					!(connection.dependency instanceof HarmonyImportDependency)
+					!Dependency.canConcatenate(connection.dependency)
 			);
 			if (selected.length > 0) {
 				nonHarmonyConnections.set(originModule, connections);
@@ -754,6 +773,7 @@ class ModuleConcatenationPlugin {
 		}
 		if (nonHarmonyConnections.size > 0) {
 			/**
+			 * Returns problem description.
 			 * @param {RequestShortener} requestShortener request shortener
 			 * @returns {string} problem description
 			 */
@@ -815,6 +835,7 @@ class ModuleConcatenationPlugin {
 			}
 			if (otherRuntimeConnections.length > 0) {
 				/**
+				 * Returns problem description.
 				 * @param {RequestShortener} requestShortener request shortener
 				 * @returns {string} problem description
 				 */
@@ -885,6 +906,7 @@ class ModuleConcatenationPlugin {
 
 class ConcatConfiguration {
 	/**
+	 * Creates an instance of ConcatConfiguration.
 	 * @param {Module} rootModule the root module
 	 * @param {RuntimeSpec} runtime the runtime
 	 */
@@ -901,6 +923,7 @@ class ConcatConfiguration {
 	}
 
 	/**
+	 * Processes the provided module.
 	 * @param {Module} module the module
 	 */
 	add(module) {
@@ -908,6 +931,7 @@ class ConcatConfiguration {
 	}
 
 	/**
+	 * Returns true, when the module is in the module set.
 	 * @param {Module} module the module
 	 * @returns {boolean} true, when the module is in the module set
 	 */
@@ -920,6 +944,7 @@ class ConcatConfiguration {
 	}
 
 	/**
+	 * Adds the provided module to the concat configuration.
 	 * @param {Module} module the module
 	 * @param {Problem} problem the problem
 	 */
@@ -928,6 +953,7 @@ class ConcatConfiguration {
 	}
 
 	/**
+	 * Gets warnings sorted.
 	 * @returns {Warnings} warnings
 	 */
 	getWarningsSorted() {
@@ -943,6 +969,7 @@ class ConcatConfiguration {
 	}
 
 	/**
+	 * Returns modules as set.
 	 * @returns {Set<Module>} modules as set
 	 */
 	getModules() {
@@ -954,6 +981,7 @@ class ConcatConfiguration {
 	}
 
 	/**
+	 * Processes the provided snapshot.
 	 * @param {number} snapshot snapshot
 	 */
 	rollback(snapshot) {

package/lib/optimize/RealContentHashPlugin.js

@@ -8,7 +8,7 @@
 const { SyncBailHook } = require("tapable");
 const { CachedSource, CompatSource, RawSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
@@ -21,6 +21,7 @@ const createHash = require("../util/createHash");
 /** @typedef {typeof import("../util/Hash")} Hash */
 
 /**
+ * Defines the comparator type used by this module.
  * @template T
  * @typedef {import("../util/comparators").Comparator<T>} Comparator
  */
@@ -29,6 +30,7 @@ const createHash = require("../util/createHash");
 const EMPTY_SET = new Set();
 
 /**
+ * Adds the provided item or item to this object.
  * @template T
  * @param {T | T[]} itemOrItems item or items
  * @param {Set<T>} list list
@@ -44,23 +46,77 @@ const addToList = (itemOrItems, list) => {
 };
 
 /**
+ * Compares two non-empty buffer chunk arrays for byte-equality without
+ * allocating a concatenated buffer.
+ * @param {Buffer[]} a first chunk array
+ * @param {Buffer[]} b second chunk array
+ * @returns {boolean} true if the concatenations are byte-equal
+ */
+const bufferArraysEqual = (a, b) => {
+	let aIdx = 0;
+	let aOff = 0;
+	let bIdx = 0;
+	let bOff = 0;
+	while (aIdx < a.length && bIdx < b.length) {
+		const aBuf = a[aIdx];
+		const bBuf = b[bIdx];
+		const len = Math.min(aBuf.length - aOff, bBuf.length - bOff);
+		if (aBuf.compare(bBuf, bOff, bOff + len, aOff, aOff + len) !== 0) {
+			return false;
+		}
+		aOff += len;
+		bOff += len;
+		if (aOff === aBuf.length) {
+			aIdx++;
+			aOff = 0;
+		}
+		if (bOff === bBuf.length) {
+			bIdx++;
+			bOff = 0;
+		}
+	}
+	return aIdx === a.length && bIdx === b.length;
+};
+
+/**
+ * Map sources to their buffer chunks and deduplicate by total byte content,
+ * grouping by total length first to avoid full comparisons.
  * @template T
  * @param {T[]} input list
- * @param {(item: T) => Buffer} fn map function
- * @returns {Buffer[]} buffers without duplicates
+ * @param {(item: T) => Source} fn map function returning a Source
+ * @returns {Buffer[][]} unique chunk arrays
  */
-const mapAndDeduplicateBuffers = (input, fn) => {
-	// Buffer.equals compares size first so this should be efficient enough
-	// If it becomes a performance problem we can use a map and group by size
-	// instead of looping over all assets.
-	/** @type {Buffer[]} */
+const mapAndDeduplicateSourceBuffers = (input, fn) => {
+	/** @type {Map<number, Buffer[][]>} */
+	const bySize = new Map();
+	/** @type {Buffer[][]} */
 	const result = [];
-	outer: for (const value of input) {
-		const buf = fn(value);
-		for (const other of result) {
-			if (buf.equals(other)) continue outer;
+	for (const value of input) {
+		const source = fn(value);
+		// TODO webpack 6: drop the `buffers` check, require webpack-sources >= 3.4
+		// and call `source.buffers()` unconditionally.
+		const chunks =
+			// TODO remove in webpack 6, this is protection against authors who directly use `webpack-sources` outdated version
+			typeof source.buffers === "function"
+				? source.buffers()
+				: [source.buffer()];
+		let total = 0;
+		for (const c of chunks) total += c.length;
+		const sameSize = bySize.get(total);
+		if (sameSize) {
+			let duplicate = false;
+			for (const other of sameSize) {
+				if (bufferArraysEqual(chunks, other)) {
+					duplicate = true;
+					break;
+				}
+			}
+			if (duplicate) continue;
+			sameSize.push(chunks);
+		} else {
+			bySize.set(total, [chunks]);
 		}
-		result.push(buf);
+		result.push(chunks);
 	}
 	return result;
 };
@@ -76,6 +132,7 @@ const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 const cachedSourceMap = new WeakMap();
 
 /**
+ * Returns cached source.
  * @param {Source} source source
  * @returns {CachedSource} cached source
  */
@@ -93,6 +150,7 @@ const toCachedSource = (source) => {
 /** @typedef {Set<string>} Hashes */
 
 /**
+ * Defines the asset info for real content hash type used by this module.
  * @typedef {object} AssetInfoForRealContentHash
  * @property {string} name
  * @property {AssetInfo} info
@@ -108,6 +166,7 @@ const toCachedSource = (source) => {
  */
 
 /**
+ * Defines the compilation hooks type used by this module.
  * @typedef {object} CompilationHooks
  * @property {SyncBailHook<[Buffer[], string], string | void>} updateHash
  */
@@ -116,6 +175,7 @@ const toCachedSource = (source) => {
 const compilationHooksMap = new WeakMap();
 
 /**
+ * Defines the real content hash plugin options type used by this module.
  * @typedef {object} RealContentHashPluginOptions
  * @property {HashFunction} hashFunction the hash function to use
  * @property {HashDigest} hashDigest the hash digest to use
@@ -125,6 +185,7 @@ const PLUGIN_NAME = "RealContentHashPlugin";
 
 class RealContentHashPlugin {
 	/**
+	 * Returns the attached hooks.
 	 * @param {Compilation} compilation the compilation
 	 * @returns {CompilationHooks} the attached hooks
 	 */
@@ -145,6 +206,7 @@ class RealContentHashPlugin {
 	}
 
 	/**
+	 * Creates an instance of RealContentHashPlugin.
 	 * @param {RealContentHashPluginOptions} options options
 	 */
 	constructor({ hashFunction, hashDigest }) {
@@ -155,7 +217,7 @@ class RealContentHashPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -247,6 +309,7 @@ class RealContentHashPlugin {
 						})
 					);
 					/**
+					 * Returns the referenced hashes.
 					 * @param {string} hash the hash
 					 * @returns {undefined | Hashes} the referenced hashes
 					 */
@@ -287,6 +350,7 @@ ${referencingAssets
 						return hashes;
 					};
 					/**
+					 * Returns the hash info.
 					 * @param {string} hash the hash
 					 * @returns {string} the hash info
 					 */
@@ -301,6 +365,7 @@ ${referencingAssets
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
 						/**
+						 * Processes the provided hash.
 						 * @param {string} hash the hash
 						 * @param {Set<string>} stack stack of hashes
 						 */
@@ -329,6 +394,7 @@ ${referencingAssets
 					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
 					/**
+					 * Returns etag.
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Etag} etag
 					 */
@@ -341,6 +407,7 @@ ${referencingAssets
 							).join("|")
 						);
 					/**
+					 * Compute new content.
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Promise<void>}
 					 */
@@ -370,6 +437,7 @@ ${referencingAssets
 						})());
 					};
 					/**
+					 * Compute new content without own.
 					 * @param {AssetInfoForRealContentHash} asset asset info
 					 * @returns {Promise<void>}
 					 */
@@ -422,24 +490,34 @@ ${referencingAssets
 									: computeNewContent(asset)
 							)
 						);
-						const assetsContent = mapAndDeduplicateBuffers(assets, (asset) => {
-							if (/** @type {Hashes} */ (asset.ownHashes).has(oldHash)) {
-								return asset.newSourceWithoutOwn
-									? asset.newSourceWithoutOwn.buffer()
-									: asset.source.buffer();
+						const uniqueChunkArrays = mapAndDeduplicateSourceBuffers(
+							assets,
+							(asset) => {
+								if (/** @type {Hashes} */ (asset.ownHashes).has(oldHash)) {
+									return asset.newSourceWithoutOwn || asset.source;
+								}
+								return asset.newSource || asset.source;
 							}
-							return asset.newSource
-								? asset.newSource.buffer()
-								: asset.source.buffer();
-						});
-						let newHash = hooks.updateHash.call(assetsContent, oldHash);
+						);
+						/** @type {string | undefined} */
+						let newHash;
+						// Only materialize the public `Buffer[]` (one entry per unique
+						// asset) when something is tapped; otherwise the hot path feeds
+						// chunks into the hash directly, avoiding per-asset Buffer.concat.
+						if (hooks.updateHash.isUsed()) {
+							const assetsContent = uniqueChunkArrays.map((chunks) =>
+								chunks.length === 1 ? chunks[0] : Buffer.concat(chunks)
+							);
+							newHash =
+								hooks.updateHash.call(assetsContent, oldHash) || undefined;
+						}
 						if (!newHash) {
 							const hash = createHash(this._hashFunction);
 							if (compilation.outputOptions.hashSalt) {
 								hash.update(compilation.outputOptions.hashSalt);
 							}
-							for (const content of assetsContent) {
-								hash.update(content);
+							for (const chunks of uniqueChunkArrays) {
+								for (const c of chunks) hash.update(c);
 							}
 							const digest = hash.digest(this._hashDigest);
 							newHash = digest.slice(0, oldHash.length);

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -14,13 +14,14 @@ const PLUGIN_NAME = "RemoveEmptyChunksPlugin";
 
 class RemoveEmptyChunksPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
+			 * Handles the hook callback for this code path.
 			 * @param {Iterable<Chunk>} chunks the chunks array
 			 * @returns {void}
 			 */

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -63,12 +63,14 @@ const PLUGIN_NAME = "RemoveParentModulesPlugin";
 
 class RemoveParentModulesPlugin {
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			/**
+			 * Handles the hook callback for this code path.
 			 * @param {Iterable<Chunk>} chunks the chunks
 			 * @param {ChunkGroup[]} chunkGroups the chunk groups
 			 */
@@ -86,7 +88,7 @@ class RemoveParentModulesPlugin {
 				const ordinalModules = [];
 
 				/**
-				 * Gets or creates a unique mask for a module
+				 * Gets or create module mask.
 				 * @param {Module} mod the module to get the mask for
 				 * @returns {bigint} the module mask to uniquely identify the module
 				 */

package/lib/optimize/RuntimeChunkPlugin.js

@@ -14,6 +14,7 @@ const PLUGIN_NAME = "RuntimeChunkPlugin";
 
 class RuntimeChunkPlugin {
 	/**
+	 * Creates an instance of RuntimeChunkPlugin.
 	 * @param {{ name?: RuntimeChunkFunction }=} options options
 	 */
 	constructor(options = {}) {
@@ -25,7 +26,7 @@ class RuntimeChunkPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */