webpack 5.5.1 → 5.9.0

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -33,6 +33,7 @@ module.exports = function () {
 	var currentUpdateApplyHandlers;
 	var queuedInvalidatedModules;
 
+	// eslint-disable-next-line no-unused-vars
 	$hmrModuleData$ = currentModuleData;
 
 	$interceptModuleExecution$.push(function (options) {

package/lib/index.js

@@ -355,6 +355,9 @@ module.exports = mergeExports(fn, {
 		get ModuleConcatenationPlugin() {
 			return require("./optimize/ModuleConcatenationPlugin");
 		},
+		get RealContentHashPlugin() {
+			return require("./optimize/RealContentHashPlugin");
+		},
 		get RuntimeChunkPlugin() {
 			return require("./optimize/RuntimeChunkPlugin");
 		},

package/lib/javascript/JavascriptParser.js

@@ -1551,6 +1551,18 @@ class JavascriptParser extends Parser {
 		this.prevStatement = this.statementPath.pop();
 	}
 
+	/**
+	 * Walks a statements that is nested within a parent statement
+	 * and can potentially be a non-block statement.
+	 * This enforces the nested statement to never be in ASI position.
+	 * @param {StatementNode} statement the nested statement
+	 * @returns {void}
+	 */
+	walkNestedStatement(statement) {
+		this.prevStatement = undefined;
+		this.walkStatement(statement);
+	}
+
 	// Real Statements
 	preWalkBlockStatement(statement) {
 		this.preWalkStatements(statement.body);
@@ -1581,15 +1593,15 @@ class JavascriptParser extends Parser {
 		const result = this.hooks.statementIf.call(statement);
 		if (result === undefined) {
 			this.walkExpression(statement.test);
-			this.walkStatement(statement.consequent);
+			this.walkNestedStatement(statement.consequent);
 			if (statement.alternate) {
-				this.walkStatement(statement.alternate);
+				this.walkNestedStatement(statement.alternate);
 			}
 		} else {
 			if (result) {
-				this.walkStatement(statement.consequent);
+				this.walkNestedStatement(statement.consequent);
 			} else if (statement.alternate) {
-				this.walkStatement(statement.alternate);
+				this.walkNestedStatement(statement.alternate);
 			}
 		}
 	}
@@ -1604,7 +1616,7 @@ class JavascriptParser extends Parser {
 			const result = hook.call(statement);
 			if (result === true) return;
 		}
-		this.walkStatement(statement.body);
+		this.walkNestedStatement(statement.body);
 	}
 
 	preWalkWithStatement(statement) {
@@ -1613,7 +1625,7 @@ class JavascriptParser extends Parser {
 
 	walkWithStatement(statement) {
 		this.walkExpression(statement.object);
-		this.walkStatement(statement.body);
+		this.walkNestedStatement(statement.body);
 	}
 
 	preWalkSwitchStatement(statement) {
@@ -1661,7 +1673,7 @@ class JavascriptParser extends Parser {
 
 	walkWhileStatement(statement) {
 		this.walkExpression(statement.test);
-		this.walkStatement(statement.body);
+		this.walkNestedStatement(statement.body);
 	}
 
 	preWalkDoWhileStatement(statement) {
@@ -1669,7 +1681,7 @@ class JavascriptParser extends Parser {
 	}
 
 	walkDoWhileStatement(statement) {
-		this.walkStatement(statement.body);
+		this.walkNestedStatement(statement.body);
 		this.walkExpression(statement.test);
 	}
 
@@ -1687,6 +1699,7 @@ class JavascriptParser extends Parser {
 			if (statement.init) {
 				if (statement.init.type === "VariableDeclaration") {
 					this.blockPreWalkVariableDeclaration(statement.init);
+					this.prevStatement = undefined;
 					this.walkStatement(statement.init);
 				} else {
 					this.walkExpression(statement.init);
@@ -1706,7 +1719,7 @@ class JavascriptParser extends Parser {
 				this.prevStatement = prev;
 				this.walkStatements(body.body);
 			} else {
-				this.walkStatement(body);
+				this.walkNestedStatement(body);
 			}
 		});
 	}
@@ -1735,7 +1748,7 @@ class JavascriptParser extends Parser {
 				this.prevStatement = prev;
 				this.walkStatements(body.body);
 			} else {
-				this.walkStatement(body);
+				this.walkNestedStatement(body);
 			}
 		});
 	}
@@ -1767,7 +1780,7 @@ class JavascriptParser extends Parser {
 				this.prevStatement = prev;
 				this.walkStatements(body.body);
 			} else {
-				this.walkStatement(body);
+				this.walkNestedStatement(body);
 			}
 		});
 	}
@@ -3376,9 +3389,14 @@ class JavascriptParser extends Parser {
 		const currentStatement = this.statementPath[this.statementPath.length - 1];
 		if (currentStatement === undefined) throw new Error("Not in statement");
 		return (
+			// Either asking directly for the end position of the current statement
 			(currentStatement.range[1] === pos && this.semicolons.has(pos)) ||
+			// Or asking for the start position of the current statement,
+			// here we have to check multiple things
 			(currentStatement.range[0] === pos &&
+				// is there a previous statement which might be relevant?
 				this.prevStatement !== undefined &&
+				// is the end position of the previous statement an ASI position?
 				this.semicolons.has(this.prevStatement.range[1]))
 		);
 	}

package/lib/optimize/RealContentHashPlugin.js

@@ -5,12 +5,15 @@
 
 "use strict";
 
+const { SyncBailHook } = require("tapable");
 const { RawSource, CachedSource, CompatSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
 const WebpackError = require("../WebpackError");
 const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
+/** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("../Compiler")} Compiler */
 
 const EMPTY_SET = new Set();
@@ -47,7 +50,50 @@ const toCachedSource = source => {
 	return newSource;
 };
 
+/**
+ * @typedef {Object} AssetInfoForRealContentHash
+ * @property {string} name
+ * @property {AssetInfo} info
+ * @property {Source} source
+ * @property {RawSource | undefined} newSource
+ * @property {RawSource | undefined} newSourceWithoutOwn
+ * @property {string} content
+ * @property {Set<string>} ownHashes
+ * @property {Promise} contentComputePromise
+ * @property {Promise} contentComputeWithoutOwnPromise
+ * @property {Set<string>} referencedHashes
+ * @property {Set<string>} hashes
+ */
+
+/**
+ * @typedef {Object} CompilationHooks
+ * @property {SyncBailHook<[Buffer[], string], string>} updateHash
+ */
+
+/** @type {WeakMap<Compilation, CompilationHooks>} */
+const compilationHooksMap = new WeakMap();
+
 class RealContentHashPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {CompilationHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				updateHash: new SyncBailHook(["content", "oldHash"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
 	constructor({ hashFunction, hashDigest }) {
 		this._hashFunction = hashFunction;
 		this._hashDigest = hashDigest;
@@ -66,6 +112,7 @@ class RealContentHashPlugin {
 			const cacheGenerate = compilation.getCache(
 				"RealContentHashPlugin|generate"
 			);
+			const hooks = RealContentHashPlugin.getCompilationHooks(compilation);
 			compilation.hooks.processAssets.tapPromise(
 				{
 					name: "RealContentHashPlugin",
@@ -73,6 +120,7 @@ class RealContentHashPlugin {
 				},
 				async () => {
 					const assets = compilation.getAssets();
+					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
 					const hashToAssets = new Map();
 					for (const { source, info, name } of assets) {
@@ -87,9 +135,13 @@ class RealContentHashPlugin {
 							source: cachedSource,
 							/** @type {RawSource | undefined} */
 							newSource: undefined,
+							/** @type {RawSource | undefined} */
+							newSourceWithoutOwn: undefined,
 							content,
-							hasOwnHash: false,
-							contentComputePromise: false,
+							/** @type {Set<string>} */
+							ownHashes: undefined,
+							contentComputePromise: undefined,
+							contentComputeWithoutOwnPromise: undefined,
 							/** @type {Set<string>} */
 							referencedHashes: undefined,
 							hashes
@@ -114,6 +166,7 @@ class RealContentHashPlugin {
 							const { name, source, content, hashes } = asset;
 							if (Buffer.isBuffer(content)) {
 								asset.referencedHashes = EMPTY_SET;
+								asset.ownHashes = EMPTY_SET;
 								return;
 							}
 							const etag = cacheAnalyse.mergeEtags(
@@ -122,21 +175,21 @@ class RealContentHashPlugin {
 							);
 							[
 								asset.referencedHashes,
-								asset.hasOwnHash
+								asset.ownHashes
 							] = await cacheAnalyse.providePromise(name, etag, () => {
 								const referencedHashes = new Set();
-								let hasOwnHash = false;
+								let ownHashes = new Set();
 								const inContent = content.match(hashRegExp);
 								if (inContent) {
 									for (const hash of inContent) {
 										if (hashes.has(hash)) {
-											hasOwnHash = true;
+											ownHashes.add(hash);
 											continue;
 										}
 										referencedHashes.add(hash);
 									}
 								}
-								return [referencedHashes, hasOwnHash];
+								return [referencedHashes, ownHashes];
 							});
 						})
 					);
@@ -163,7 +216,12 @@ ${referencingAssets
 							return undefined;
 						}
 						const hashes = new Set();
-						for (const { referencedHashes } of assets) {
+						for (const { referencedHashes, ownHashes } of assets) {
+							if (!ownHashes.has(hash)) {
+								for (const hash of ownHashes) {
+									hashes.add(hash);
+								}
+							}
 							for (const hash of referencedHashes) {
 								hashes.add(hash);
 							}
@@ -199,32 +257,57 @@ ${referencingAssets
 						add(hash, new Set());
 					}
 					const hashToNewHash = new Map();
-					const computeNewContent = (asset, includeOwn) => {
+					const getEtag = asset =>
+						cacheGenerate.mergeEtags(
+							cacheGenerate.getLazyHashedEtag(asset.source),
+							Array.from(asset.referencedHashes, hash =>
+								hashToNewHash.get(hash)
+							).join("|")
+						);
+					const computeNewContent = asset => {
 						if (asset.contentComputePromise) return asset.contentComputePromise;
 						return (asset.contentComputePromise = (async () => {
 							if (
-								asset.hasOwnHash ||
+								asset.ownHashes.size > 0 ||
 								Array.from(asset.referencedHashes).some(
 									hash => hashToNewHash.get(hash) !== hash
 								)
 							) {
-								const identifier =
-									asset.name +
-									(includeOwn && asset.hasOwnHash ? "|with-own" : "");
-								const etag = cacheGenerate.mergeEtags(
-									cacheGenerate.getLazyHashedEtag(asset.source),
-									Array.from(asset.referencedHashes, hash =>
-										hashToNewHash.get(hash)
-									).join("|")
-								);
+								const identifier = asset.name;
+								const etag = getEtag(asset);
 								asset.newSource = await cacheGenerate.providePromise(
+									identifier,
+									etag,
+									() => {
+										const newContent = asset.content.replace(hashRegExp, hash =>
+											hashToNewHash.get(hash)
+										);
+										return new RawSource(newContent);
+									}
+								);
+							}
+						})());
+					};
+					const computeNewContentWithoutOwn = asset => {
+						if (asset.contentComputeWithoutOwnPromise)
+							return asset.contentComputeWithoutOwnPromise;
+						return (asset.contentComputeWithoutOwnPromise = (async () => {
+							if (
+								asset.ownHashes.size > 0 ||
+								Array.from(asset.referencedHashes).some(
+									hash => hashToNewHash.get(hash) !== hash
+								)
+							) {
+								const identifier = asset.name + "|without-own";
+								const etag = getEtag(asset);
+								asset.newSourceWithoutOwn = await cacheGenerate.providePromise(
 									identifier,
 									etag,
 									() => {
 										const newContent = asset.content.replace(
 											hashRegExp,
 											hash => {
-												if (!includeOwn && asset.hashes.has(hash)) {
+												if (asset.ownHashes.has(hash)) {
 													return "";
 												}
 												return hashToNewHash.get(hash);
@@ -241,25 +324,37 @@ ${referencingAssets
 						const assets = hashToAssets.get(oldHash);
 						assets.sort(comparator);
 						const hash = createHash(this._hashFunction);
-						await Promise.all(assets.map(computeNewContent));
-						for (const asset of assets) {
-							hash.update(
-								asset.newSource
+						await Promise.all(
+							assets.map(asset =>
+								asset.ownHashes.has(oldHash)
+									? computeNewContentWithoutOwn(asset)
+									: computeNewContent(asset)
+							)
+						);
+						const assetsContent = assets.map(asset => {
+							if (asset.ownHashes.has(oldHash)) {
+								return asset.newSourceWithoutOwn
+									? asset.newSourceWithoutOwn.buffer()
+									: asset.source.buffer();
+							} else {
+								return asset.newSource
 									? asset.newSource.buffer()
-									: asset.source.buffer()
-							);
+									: asset.source.buffer();
+							}
+						});
+						let newHash = hooks.updateHash.call(assetsContent, oldHash);
+						if (!newHash) {
+							for (const content of assetsContent) {
+								hash.update(content);
+							}
+							const digest = hash.digest(this._hashDigest);
+							newHash = /** @type {string} */ (digest.slice(0, oldHash.length));
 						}
-						const digest = hash.digest(this._hashDigest);
-						const newHash = digest.slice(0, oldHash.length);
 						hashToNewHash.set(oldHash, newHash);
 					}
 					await Promise.all(
 						assetsWithInfo.map(async asset => {
-							// recomputed content with it's own hash
-							if (asset.hasOwnHash) {
-								asset.contentComputePromise = undefined;
-							}
-							await computeNewContent(asset, true);
+							await computeNewContent(asset);
 							const newName = asset.name.replace(hashRegExp, hash =>
 								hashToNewHash.get(hash)
 							);