webpack 5.53.0 → 5.56.0

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -5,10 +5,12 @@
 
 "use strict";
 
+const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -23,6 +25,13 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 		this.valueType = valueType;
 	}
 
+	/**
+	 * @returns {boolean | TRANSITIVE} true, when changes to the referenced module could affect the referencing module; TRANSITIVE, when changes to the referenced module could affect referencing modules of the referencing module
+	 */
+	couldAffectReferencingModule() {
+		return Dependency.TRANSITIVE;
+	}
+
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph

package/lib/ids/IdHelpers.js

@@ -13,14 +13,16 @@ const numberHash = require("../util/numberHash");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {typeof import("../util/Hash")} Hash */
 
 /**
  * @param {string} str string to hash
  * @param {number} len max length of the hash
+ * @param {string | Hash} hashFunction hash function to use
  * @returns {string} hash
  */
-const getHash = (str, len) => {
-	const hash = createHash("md4");
+const getHash = (str, len, hashFunction) => {
+	const hash = createHash(hashFunction);
 	hash.update(str);
 	const digest = /** @type {string} */ (hash.digest("hex"));
 	return digest.substr(0, len);
@@ -61,12 +63,15 @@ exports.requestToId = requestToId;
 /**
  * @param {string} string the string
  * @param {string} delimiter separator for string and hash
+ * @param {string | Hash} hashFunction hash function to use
  * @returns {string} string with limited max length to 100 chars
  */
-const shortenLongString = (string, delimiter) => {
+const shortenLongString = (string, delimiter, hashFunction) => {
 	if (string.length < 100) return string;
 	return (
-		string.slice(0, 100 - 6 - delimiter.length) + delimiter + getHash(string, 6)
+		string.slice(0, 100 - 6 - delimiter.length) +
+		delimiter +
+		getHash(string, 6, hashFunction)
 	);
 };
 
@@ -92,6 +97,7 @@ exports.getShortModuleName = getShortModuleName;
  * @param {string} shortName the short name
  * @param {Module} module the module
  * @param {string} context context directory
+ * @param {string | Hash} hashFunction hash function to use
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} long module name
  */
@@ -99,10 +105,11 @@ const getLongModuleName = (
 	shortName,
 	module,
 	context,
+	hashFunction,
 	associatedObjectForCache
 ) => {
 	const fullName = getFullModuleName(module, context, associatedObjectForCache);
-	return `${shortName}?${getHash(fullName, 4)}`;
+	return `${shortName}?${getHash(fullName, 4, hashFunction)}`;
 };
 exports.getLongModuleName = getLongModuleName;
 
@@ -126,6 +133,7 @@ exports.getFullModuleName = getFullModuleName;
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
+ * @param {string | Hash} hashFunction hash function to use
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
@@ -134,6 +142,7 @@ const getShortChunkName = (
 	chunkGraph,
 	context,
 	delimiter,
+	hashFunction,
 	associatedObjectForCache
 ) => {
 	const modules = chunkGraph.getChunkRootModules(chunk);
@@ -145,7 +154,7 @@ const getShortChunkName = (
 		.concat(shortModuleNames)
 		.filter(Boolean)
 		.join(delimiter);
-	return shortenLongString(chunkName, delimiter);
+	return shortenLongString(chunkName, delimiter, hashFunction);
 };
 exports.getShortChunkName = getShortChunkName;
 
@@ -154,6 +163,7 @@ exports.getShortChunkName = getShortChunkName;
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
+ * @param {string | Hash} hashFunction hash function to use
  * @param {Object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
@@ -162,6 +172,7 @@ const getLongChunkName = (
 	chunkGraph,
 	context,
 	delimiter,
+	hashFunction,
 	associatedObjectForCache
 ) => {
 	const modules = chunkGraph.getChunkRootModules(chunk);
@@ -169,14 +180,16 @@ const getLongChunkName = (
 		requestToId(getShortModuleName(m, context, associatedObjectForCache))
 	);
 	const longModuleNames = modules.map(m =>
-		requestToId(getLongModuleName("", m, context, associatedObjectForCache))
+		requestToId(
+			getLongModuleName("", m, context, hashFunction, associatedObjectForCache)
+		)
 	);
 	chunk.idNameHints.sort();
 	const chunkName = Array.from(chunk.idNameHints)
 		.concat(shortModuleNames, longModuleNames)
 		.filter(Boolean)
 		.join(delimiter);
-	return shortenLongString(chunkName, delimiter);
+	return shortenLongString(chunkName, delimiter, hashFunction);
 };
 exports.getLongChunkName = getLongChunkName;
 

package/lib/ids/NamedChunkIdsPlugin.js

@@ -31,6 +31,7 @@ class NamedChunkIdsPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
+			const { hashFunction } = compilation.outputOptions;
 			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.context ? this.context : compiler.context;
@@ -50,6 +51,7 @@ class NamedChunkIdsPlugin {
 							chunkGraph,
 							context,
 							delimiter,
+							hashFunction,
 							compiler.root
 						),
 					chunk =>
@@ -58,6 +60,7 @@ class NamedChunkIdsPlugin {
 							chunkGraph,
 							context,
 							delimiter,
+							hashFunction,
 							compiler.root
 						),
 					compareChunksNatural(chunkGraph),

package/lib/ids/NamedModuleIdsPlugin.js

@@ -30,6 +30,7 @@ class NamedModuleIdsPlugin {
 	apply(compiler) {
 		const { root } = compiler;
 		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
+			const { hashFunction } = compilation.outputOptions;
 			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", modules => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
@@ -43,7 +44,8 @@ class NamedModuleIdsPlugin {
 						return chunkGraph.getModuleId(module) === null;
 					}),
 					m => getShortModuleName(m, context, root),
-					(m, shortName) => getLongModuleName(shortName, m, context, root),
+					(m, shortName) =>
+						getLongModuleName(shortName, m, context, hashFunction, root),
 					compareModulesByIdentifier,
 					getUsedModuleIds(compilation),
 					(m, name) => chunkGraph.setModuleId(m, name)

package/lib/index.js

@@ -394,6 +394,9 @@ module.exports = mergeExports(fn, {
 				"DEP_WEBPACK_AGGRESSIVE_SPLITTING_PLUGIN"
 			)();
 		},
+		get InnerGraph() {
+			return require("./optimize/InnerGraph");
+		},
 		get LimitChunkCountPlugin() {
 			return require("./optimize/LimitChunkCountPlugin");
 		},
@@ -535,6 +538,9 @@ module.exports = mergeExports(fn, {
 		get comparators() {
 			return require("./util/comparators");
 		},
+		get runtime() {
+			return require("./util/runtime");
+		},
 		get serialization() {
 			return require("./util/serialization");
 		},

package/lib/javascript/BasicEvaluatedExpression.js

@@ -417,6 +417,9 @@ class BasicEvaluatedExpression {
 
 	setNullish(value) {
 		this.nullish = value;
+
+		if (value) return this.setFalsy();
+
 		return this;
 	}
 

package/lib/javascript/JavascriptParser.js

@@ -417,23 +417,41 @@ class JavascriptParser extends Parser {
 
 				const left = this.evaluateExpression(expr.left);
 				if (!left) return;
+				let returnRight = false;
+				/** @type {boolean|undefined} */
+				let allowedRight;
 				if (expr.operator === "&&") {
 					const leftAsBool = left.asBool();
 					if (leftAsBool === false) return left.setRange(expr.range);
-					if (leftAsBool !== true) return;
+					returnRight = leftAsBool === true;
+					allowedRight = false;
 				} else if (expr.operator === "||") {
 					const leftAsBool = left.asBool();
 					if (leftAsBool === true) return left.setRange(expr.range);
-					if (leftAsBool !== false) return;
+					returnRight = leftAsBool === false;
+					allowedRight = true;
 				} else if (expr.operator === "??") {
 					const leftAsNullish = left.asNullish();
 					if (leftAsNullish === false) return left.setRange(expr.range);
 					if (leftAsNullish !== true) return;
+					returnRight = true;
 				} else return;
 				const right = this.evaluateExpression(expr.right);
 				if (!right) return;
-				if (left.couldHaveSideEffects()) right.setSideEffects();
-				return right.setRange(expr.range);
+				if (returnRight) {
+					if (left.couldHaveSideEffects()) right.setSideEffects();
+					return right.setRange(expr.range);
+				}
+
+				const asBool = right.asBool();
+
+				if (allowedRight === true && asBool === true) {
+					return new BasicEvaluatedExpression()
+						.setRange(expr.range)
+						.setTruthy();
+				} else if (allowedRight === false && asBool === false) {
+					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
+				}
 			});
 
 		const valueAsExpression = (value, expr, sideEffects) => {

package/lib/javascript/JavascriptParserHelpers.js

@@ -76,10 +76,8 @@ exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 		switch (truthy) {
 			case true:
 				evaluatedExpression.setTruthy();
-				evaluatedExpression.setNullish(false);
 				break;
 			case null:
-				evaluatedExpression.setFalsy();
 				evaluatedExpression.setNullish(true);
 				break;
 			case false:

package/lib/optimize/ConcatenatedModule.js

@@ -58,6 +58,7 @@ const {
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {typeof import("../util/Hash")} HashConstructor */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -647,13 +648,21 @@ class ConcatenatedModule extends Module {
 	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
 	 * @param {RuntimeSpec} runtime the runtime
 	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {string | HashConstructor=} hashFunction hash function to use
 	 * @returns {ConcatenatedModule} the module
 	 */
-	static create(rootModule, modules, runtime, associatedObjectForCache) {
+	static create(
+		rootModule,
+		modules,
+		runtime,
+		associatedObjectForCache,
+		hashFunction = "md4"
+	) {
 		const identifier = ConcatenatedModule._createIdentifier(
 			rootModule,
 			modules,
-			associatedObjectForCache
+			associatedObjectForCache,
+			hashFunction
 		);
 		return new ConcatenatedModule({
 			identifier,
@@ -1010,7 +1019,19 @@ class ConcatenatedModule extends Module {
 		return list;
 	}
 
-	static _createIdentifier(rootModule, modules, associatedObjectForCache) {
+	/**
+	 * @param {Module} rootModule the root module of the concatenation
+	 * @param {Set<Module>} modules all modules in the concatenation (including the root module)
+	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {string | HashConstructor=} hashFunction hash function to use
+	 * @returns {string} the identifier
+	 */
+	static _createIdentifier(
+		rootModule,
+		modules,
+		associatedObjectForCache,
+		hashFunction = "md4"
+	) {
 		const cachedMakePathsRelative = makePathsRelative.bindContextCache(
 			rootModule.context,
 			associatedObjectForCache
@@ -1020,7 +1041,7 @@ class ConcatenatedModule extends Module {
 			identifiers.push(cachedMakePathsRelative(module.identifier()));
 		}
 		identifiers.sort();
-		const hash = createHash("md4");
+		const hash = createHash(hashFunction);
 		hash.update(identifiers.join(" "));
 		return rootModule.identifier() + "|" + hash.digest("hex");
 	}

package/lib/optimize/InnerGraph.js

@@ -16,7 +16,7 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-/** @typedef {Map<TopLevelSymbol, Set<string | TopLevelSymbol> | true>} InnerGraph */
+/** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true>} InnerGraph */
 /** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
 
 /**
@@ -75,7 +75,7 @@ exports.isEnabled = parserState => {
 
 /**
  * @param {ParserState} state parser state
- * @param {TopLevelSymbol} symbol the symbol
+ * @param {TopLevelSymbol | null} symbol the symbol, or null for all symbols
  * @param {string | TopLevelSymbol | true} usage usage data
  * @returns {void}
  */
@@ -172,6 +172,26 @@ exports.inferDependencyUsage = state => {
 			}
 			if (isTerminal) {
 				nonTerminal.delete(key);
+
+				// For the global key, merge with all other keys
+				if (key === null) {
+					const globalValue = innerGraph.get(null);
+					if (globalValue) {
+						for (const [key, value] of innerGraph) {
+							if (key !== null && value !== true) {
+								if (globalValue === true) {
+									innerGraph.set(key, true);
+								} else {
+									const newSet = new Set(value);
+									for (const item of globalValue) {
+										newSet.add(item);
+									}
+									innerGraph.set(key, newSet);
+								}
+							}
+						}
+					}
+				}
 			}
 		}
 	}

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -366,7 +366,8 @@ class ModuleConcatenationPlugin {
 								rootModule,
 								modules,
 								concatConfiguration.runtime,
-								compiler.root
+								compiler.root,
+								compilation.outputOptions.hashFunction
 							);
 
 							const build = () => {

package/lib/schemes/HttpUriPlugin.js

@@ -311,8 +311,7 @@ class HttpUriPlugin {
 						: lockfileLocation + ".data";
 				const upgrade = this._upgrade || false;
 				const frozen = this._frozen || false;
-				const hashFunction =
-					this._hashFunction || compilation.outputOptions.hashFunction;
+				const hashFunction = this._hashFunction || "sha512";
 				const hashDigest =
 					this._hashDigest || compilation.outputOptions.hashDigest;
 				const hashDigestLength =

package/lib/serialization/BinaryMiddleware.js

@@ -299,12 +299,21 @@ class BinaryMiddleware extends SerializerMiddleware {
 						writeU8(STRING_HEADER);
 						writeU32(len);
 						currentBuffer.write(thing, currentPosition);
-					} else {
+						currentPosition += len;
+					} else if (len >= 70) {
 						allocate(len + HEADER_SIZE);
 						writeU8(SHORT_STRING_HEADER | len);
+
 						currentBuffer.write(thing, currentPosition, "latin1");
+						currentPosition += len;
+					} else {
+						allocate(len + HEADER_SIZE);
+						writeU8(SHORT_STRING_HEADER | len);
+
+						for (let i = 0; i < len; i++) {
+							currentBuffer[currentPosition++] = thing.charCodeAt(i);
+						}
 					}
-					currentPosition += len;
 					break;
 				}
 				case "number": {

package/lib/serialization/FileMiddleware.js

@@ -18,6 +18,7 @@ const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
+/** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 
@@ -39,8 +40,14 @@ Section -> Buffer
 
 // "wpc" + 1 in little-endian
 const VERSION = 0x01637077;
-const hashForName = buffers => {
-	const hash = createHash("md4");
+
+/**
+ * @param {Buffer[]} buffers buffers
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
+ */
+const hashForName = (buffers, hashFunction) => {
+	const hash = createHash(hashFunction);
 	for (const buf of buffers) hash.update(buf);
 	return /** @type {string} */ (hash.digest("hex"));
 };
@@ -81,9 +88,16 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
  * @param {BufferSerializableType[] | Promise<BufferSerializableType[]>} data data to be serialized
  * @param {string | boolean} name file base name
  * @param {function(string | false, Buffer[]): Promise<void>} writeFile writes a file
+ * @param {string | Hash} hashFunction hash function to use
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
-const serialize = async (middleware, data, name, writeFile) => {
+const serialize = async (
+	middleware,
+	data,
+	name,
+	writeFile,
+	hashFunction = "md4"
+) => {
 	/** @type {(Buffer[] | Buffer | SerializeResult | Promise<SerializeResult>)[]} */
 	const processedData = [];
 	/** @type {WeakMap<SerializeResult, function(): any | Promise<any>>} */
@@ -118,7 +132,8 @@ const serialize = async (middleware, data, name, writeFile) => {
 							middleware,
 							content,
 							(options && options.name) || true,
-							writeFile
+							writeFile,
+							hashFunction
 						).then(result => {
 							/** @type {any} */ (item).options.size = result.size;
 							resultToLazy.set(result, item);
@@ -195,7 +210,7 @@ const serialize = async (middleware, data, name, writeFile) => {
 		}
 	}
 	if (name === true) {
-		name = hashForName(buf);
+		name = hashForName(buf, hashFunction);
 	}
 	backgroundJobs.push(writeFile(name, buf));
 	let size = 0;
@@ -386,10 +401,12 @@ const deserialize = async (middleware, name, readFile) => {
 class FileMiddleware extends SerializerMiddleware {
 	/**
 	 * @param {IntermediateFileSystem} fs filesystem
+	 * @param {string | Hash} hashFunction hash function to use
 	 */
-	constructor(fs) {
+	constructor(fs, hashFunction = "md4") {
 		super();
 		this.fs = fs;
+		this._hashFunction = hashFunction;
 	}
 	/**
 	 * @param {DeserializedType} data data
@@ -446,7 +463,7 @@ class FileMiddleware extends SerializerMiddleware {
 				};
 
 				resolve(
-					serialize(this, data, false, writeFile).then(
+					serialize(this, data, false, writeFile, this._hashFunction).then(
 						async ({ backgroundJob }) => {
 							await backgroundJob;
 

package/lib/serialization/ObjectMiddleware.js

@@ -15,6 +15,7 @@ const RegExpObjectSerializer = require("./RegExpObjectSerializer");
 const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
+/** @typedef {typeof import("../util/Hash")} Hash */
 /** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
@@ -76,8 +77,13 @@ const setMapSize = (map, size) => {
 	}
 };
 
-const toHash = buffer => {
-	const hash = createHash("md4");
+/**
+ * @param {Buffer} buffer buffer
+ * @param {string | Hash} hashFunction hash function to use
+ * @returns {string} hash
+ */
+const toHash = (buffer, hashFunction) => {
+	const hash = createHash(hashFunction);
 	hash.update(buffer);
 	return /** @type {string} */ (hash.digest("latin1"));
 };
@@ -149,9 +155,14 @@ const loaders = new Map();
  * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
  */
 class ObjectMiddleware extends SerializerMiddleware {
-	constructor(extendContext) {
+	/**
+	 * @param {function(any): void} extendContext context extensions
+	 * @param {string | Hash} hashFunction hash function to use
+	 */
+	constructor(extendContext, hashFunction = "md4") {
 		super();
 		this.extendContext = extendContext;
+		this._hashFunction = hashFunction;
 	}
 	/**
 	 * @param {RegExp} regExp RegExp for which the request is tested
@@ -275,11 +286,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 					bufferDedupeMap.set(len, [entry, buf]);
 					return buf;
 				} else {
-					const hash = toHash(entry);
+					const hash = toHash(entry, this._hashFunction);
 					const newMap = new Map();
 					newMap.set(hash, entry);
 					bufferDedupeMap.set(len, newMap);
-					const hashBuf = toHash(buf);
+					const hashBuf = toHash(buf, this._hashFunction);
 					if (hash === hashBuf) {
 						return entry;
 					}
@@ -296,10 +307,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					return buf;
 				} else {
 					const newMap = new Map();
-					const hash = toHash(buf);
+					const hash = toHash(buf, this._hashFunction);
 					let found;
 					for (const item of entry) {
-						const itemHash = toHash(item);
+						const itemHash = toHash(item, this._hashFunction);
 						newMap.set(itemHash, item);
 						if (found === undefined && itemHash === hash) found = item;
 					}
@@ -312,7 +323,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 				}
 			} else {
-				const hash = toHash(buf);
+				const hash = toHash(buf, this._hashFunction);
 				const item = entry.get(hash);
 				if (item !== undefined) {
 					return item;