webpack 5.106.2 → 5.107.1

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");
 
@@ -46,24 +46,77 @@ const addToList = (itemOrItems, list) => {
 };
 
 /**
- * Map and deduplicate buffers.
+ * 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;
 };
@@ -437,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/SideEffectsFlagPlugin.js

@@ -14,18 +14,19 @@ const {
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
-const formatLocation = require("../formatLocation");
+const formatLocation = require("../util/formatLocation");
+const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
 /** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
 /** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
 /** @typedef {import("estree").Statement} Statement */
+/** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../NormalModuleFactory").ModuleSettings} ModuleSettings */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
@@ -63,6 +64,24 @@ const globToRegexp = (glob, cache) => {
 	return regexp;
 };
 
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {number} start start position
+ * @param {number} end end position
+ * @returns {boolean} if annotation is found in the range
+ */
+const hasNoSideEffectsNotation = (parser, start, end) => {
+	// Fast path
+	if (end - start < 18) return false;
+
+	const comments = parser.getComments([start, end]);
+	return comments.some(
+		(c) =>
+			c.type === "Block" &&
+			CompilerHintNotationRegExp.NoSideEffects.test(c.value)
+	);
+};
+
 const PLUGIN_NAME = "SideEffectsFlagPlugin";
 
 class SideEffectsFlagPlugin {
@@ -114,7 +133,7 @@ class SideEffectsFlagPlugin {
 					return module;
 				});
 				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
-					const settings = /** @type {ModuleSettings} */ (data.settings);
+					const settings = data.settings;
 					if (typeof settings.sideEffects === "boolean") {
 						if (module.factoryMeta === undefined) {
 							module.factoryMeta = {};
@@ -129,7 +148,7 @@ class SideEffectsFlagPlugin {
 					 * @param {JavascriptParser} parser the parser
 					 * @returns {void}
 					 */
-					const parserHandler = (parser) => {
+					const applySideEffectsStmtHandler = (parser) => {
 						/** @type {undefined | Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
 						let sideEffectsStatement;
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
@@ -260,6 +279,91 @@ class SideEffectsFlagPlugin {
 							}
 						});
 					};
+
+					/**
+					 * @param {JavascriptParser} parser the parser
+					 * @returns {void}
+					 */
+					const applyNoSideEffectsNotationHandler = (parser) => {
+						/** @type {Set<string>} */
+						let noSideEffectsFnNames;
+
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
+							noSideEffectsFnNames = new Set();
+						});
+
+						// Detect on function declarations
+						// Covers:
+						// 	1. function foo
+						//  2. export function foo
+						//  3. export default function foo
+						parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
+							if (parser.scope.topLevelScope !== true) return;
+							if (statement.type !== "FunctionDeclaration" || !statement.id) {
+								return;
+							}
+							const commentsStart = parser.prevStatement
+								? /** @type {Range} */ (parser.prevStatement.range)[1]
+								: 0;
+							if (
+								hasNoSideEffectsNotation(
+									parser,
+									commentsStart,
+									/** @type {Range} */ (statement.range)[0]
+								)
+							) {
+								noSideEffectsFnNames.add(statement.id.name);
+							}
+						});
+
+						// Detect on variable declarations with function init
+						parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+							if (parser.scope.topLevelScope !== true) return;
+							if (!decl.init || decl.id.type !== "Identifier") return;
+							if (!decl.init.type.endsWith("FunctionExpression")) return;
+
+							let hasAnnotation = false;
+							// Before the VariableDeclaration (only for const)
+							if (statement.kind === "const") {
+								const commentsStart = parser.prevStatement
+									? /** @type {Range} */ (parser.prevStatement.range)[1]
+									: 0;
+								hasAnnotation = hasNoSideEffectsNotation(
+									parser,
+									commentsStart,
+									/** @type {Range} */ (statement.range)[0]
+								);
+							}
+
+							if (!hasAnnotation) {
+								hasAnnotation = hasNoSideEffectsNotation(
+									parser,
+									/** @type {Range} */ (decl.id.range)[1],
+									/** @type {Range} */ (decl.init.range)[0]
+								);
+							}
+							if (hasAnnotation) {
+								noSideEffectsFnNames.add(decl.id.name);
+							}
+						});
+
+						// Mark calls to annotated functions as pure
+						parser.hooks.isPure
+							.for("CallExpression")
+							.tap(PLUGIN_NAME, (expression, commentsStartPos) => {
+								const expr = /** @type {CallExpression} */ (expression);
+								if (expr.callee.type !== "Identifier") return;
+								if (!noSideEffectsFnNames.has(expr.callee.name)) return;
+								commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
+								for (const arg of expr.arguments) {
+									if (arg.type === "SpreadElement") return;
+									if (!parser.isPure(arg, commentsStartPos)) return;
+									commentsStartPos = /** @type {Range} */ (arg.range)[1];
+								}
+								return true;
+							});
+					};
+
 					for (const key of [
 						JAVASCRIPT_MODULE_TYPE_AUTO,
 						JAVASCRIPT_MODULE_TYPE_ESM,
@@ -267,7 +371,10 @@ class SideEffectsFlagPlugin {
 					]) {
 						normalModuleFactory.hooks.parser
 							.for(key)
-							.tap(PLUGIN_NAME, parserHandler);
+							.tap(PLUGIN_NAME, (parser) => {
+								applyNoSideEffectsNotationHandler(parser);
+								applySideEffectsStmtHandler(parser);
+							});
 					}
 				}
 				compilation.hooks.optimizeDependencies.tap(

package/lib/optimize/SplitChunksPlugin.js

@@ -7,7 +7,7 @@
 
 const Chunk = require("../Chunk");
 const { STAGE_ADVANCED } = require("../OptimizationStages");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { requestToId } = require("../ids/IdHelpers");
 const { isSubset } = require("../util/SetHelpers");
 const SortableSet = require("../util/SortableSet");
@@ -32,7 +32,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").SourceType} SourceType */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
 /** @typedef {import("../util/deterministicGrouping").Sizes} Sizes */
@@ -78,7 +78,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {CountOfChunk=} minChunks
  * @property {CountOfRequest=} maxAsyncRequests
  * @property {CountOfRequest=} maxInitialRequests
- * @property {TemplatePath=} filename
+ * @property {ChunkFilenameTemplate=} filename
  * @property {string=} idHint
  * @property {string=} automaticNameDelimiter
  * @property {boolean=} reuseExistingChunk
@@ -101,7 +101,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {CountOfChunk} minChunks
  * @property {CountOfRequest} maxAsyncRequests
  * @property {CountOfRequest} maxInitialRequests
- * @property {TemplatePath=} filename
+ * @property {ChunkFilenameTemplate=} filename
  * @property {string} idHint
  * @property {string} automaticNameDelimiter
  * @property {boolean} reuseExistingChunk
@@ -163,7 +163,7 @@ const MinMaxSizeWarning = require("./MinMaxSizeWarning");
  * @property {CountOfRequest} maxAsyncRequests
  * @property {CountOfRequest} maxInitialRequests
  * @property {boolean} hidePathInfo
- * @property {TemplatePath=} filename
+ * @property {ChunkFilenameTemplate=} filename
  * @property {string} automaticNameDelimiter
  * @property {GetCacheGroups} getCacheGroups
  * @property {GetNameFn} getName

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const { formatSize } = require("../SizeFormatHelpers");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
+const formatSize = require("../util/formatSize");
 
 /** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
 

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const { formatSize } = require("../SizeFormatHelpers");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
+const formatSize = require("../util/formatSize");
 
 /** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
 

package/lib/performance/NoAsyncChunksWarning.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 
-module.exports = class NoAsyncChunksWarning extends WebpackError {
+class NoAsyncChunksWarning extends WebpackError {
 	constructor() {
 		super(
 			"webpack performance recommendations: \n" +
@@ -18,4 +18,6 @@ module.exports = class NoAsyncChunksWarning extends WebpackError {
 		/** @type {string} */
 		this.name = "NoAsyncChunksWarning";
 	}
-};
+}
+
+module.exports = NoAsyncChunksWarning;

package/lib/performance/SizeLimitsPlugin.js

@@ -16,7 +16,7 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
 /** @typedef {import("../Compilation").Asset} Asset */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 
 /**
  * Defines the asset details type used by this module.

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -39,10 +39,13 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 				`${
 					RuntimeGlobals.ensureChunkHandlers
 				}.prefetch = ${runtimeTemplate.expressionFunction(
+					// Prefetch is best-effort; silence rejections so a failed chunk
+					// load (e.g. chunkLoadTimeout) doesn't surface as an unhandled
+					// rejection through this dangling Promise.all chain.
 					`Promise.all(promises).then(${runtimeTemplate.basicFunction(
 						"",
 						body
-					)})`,
+					)}, ${runtimeTemplate.basicFunction("", "")})`,
 					"chunkId, promises"
 				)};`
 			])

package/lib/rules/UseEffectRulePlugin.js

@@ -13,6 +13,7 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseFunction} RuleSetUseFunction */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 /** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
@@ -82,7 +83,7 @@ class UseEffectRulePlugin {
 					 * Returns effect.
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {Exclude<NonNullable<RuleSetUseItem>, EXPECTED_FUNCTION>} item user provided use value
+					 * @param {Exclude<NonNullable<RuleSetUseItem>, RuleSetUseFunction>} item user provided use value
 					 * @returns {Effect} effect
 					 */
 					const useToEffectRaw = (path, defaultIdent, item) => {
@@ -132,7 +133,7 @@ class UseEffectRulePlugin {
 								useToEffectRaw(
 									`${path}[${idx}]`,
 									"[[missing ident]]",
-									/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+									/** @type {Exclude<RuleSetUseItem, RuleSetUseFunction>} */
 									(item)
 								)
 							);
@@ -141,7 +142,7 @@ class UseEffectRulePlugin {
 							useToEffectRaw(
 								path,
 								"[[missing ident]]",
-								/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+								/** @type {Exclude<RuleSetUseItem, RuleSetUseFunction>} */
 								(items)
 							)
 						];

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -26,14 +26,14 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { scriptType, importMetaName, path, environment } =
 			compilation.outputOptions;
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const chunkName = compilation.getPath(
 			JavascriptModulesPlugin.getChunkFilenameTemplate(
-				/** @type {Chunk} */
-				(this.chunk),
+				chunk,
 				compilation.outputOptions
 			),
 			{
-				chunk: this.chunk,
+				chunk,
 				contentHashType: "javascript"
 			}
 		);

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -14,14 +14,14 @@ const { first } = require("../util/SetHelpers");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").HashWithLengthFunction} HashWithLengthFunction */
-/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	/**
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {(chunk: Chunk) => TemplatePath | false} getFilenameForChunk functor to get the filename or function
+	 * @param {(chunk: Chunk) => ChunkFilenameTemplate | false} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
@@ -30,7 +30,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		this.contentType = contentType;
 		/** @type {string} */
 		this.global = global;
-		/** @type {(chunk: Chunk) => TemplatePath | false} */
+		/** @type {(chunk: Chunk) => ChunkFilenameTemplate | false} */
 		this.getFilenameForChunk = getFilenameForChunk;
 		/** @type {boolean} */
 		this.allChunks = allChunks;
@@ -49,7 +49,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { runtimeTemplate } = compilation;
 
-		/** @type {Map<string | TemplatePath, Set<Chunk>>} */
+		/** @type {Map<ChunkFilenameTemplate, Set<Chunk>>} */
 		const chunkFilenames = new Map();
 		let maxChunks = 0;
 		/** @type {string | undefined} */
@@ -126,7 +126,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 
 		/**
 		 * @param {Chunk} c the chunk
-		 * @param {string | TemplatePath} chunkFilename the filename template for the chunk
+		 * @param {ChunkFilenameTemplate} chunkFilename the filename template for the chunk
 		 * @returns {void}
 		 */
 		const addStaticUrl = (c, chunkFilename) => {