webpack 5.51.2 → 5.54.0

package/lib/dependencies/ConstDependency.js

@@ -30,6 +30,7 @@ class ConstDependency extends NullDependency {
 		this.runtimeRequirements = runtimeRequirements
 			? new Set(runtimeRequirements)
 			: null;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -39,10 +40,17 @@ class ConstDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.range + "");
-		hash.update(this.expression + "");
-		if (this.runtimeRequirements)
-			hash.update(Array.from(this.runtimeRequirements).join() + "");
+		if (this._hashUpdate === undefined) {
+			let hashUpdate = "" + this.range + "|" + this.expression;
+			if (this.runtimeRequirements) {
+				for (const item of this.runtimeRequirements) {
+					hashUpdate += "|";
+					hashUpdate += item;
+				}
+			}
+			this._hashUpdate = hashUpdate;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	/**

package/lib/dependencies/JsonExportsDependency.js

@@ -47,6 +47,7 @@ class JsonExportsDependency extends NullDependency {
 	constructor(exports) {
 		super();
 		this.exports = exports;
+		this._hashUpdate = undefined;
 	}
 
 	get type() {
@@ -72,7 +73,12 @@ class JsonExportsDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.exports ? JSON.stringify(this.exports) : "undefined");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.exports
+				? JSON.stringify(this.exports)
+				: "undefined";
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

package/lib/dependencies/LoaderPlugin.js

@@ -37,11 +37,9 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 class LoaderPlugin {
 	/**
 	 * @param {Object} options options
-	 * @param {boolean=} options.enableExecuteModule execute module enabled
 	 */
-	constructor(options = {}) {
-		this._enableExecuteModule = !!options.enableExecuteModule;
-	}
+	constructor(options = {}) {}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -155,106 +153,104 @@ class LoaderPlugin {
 						);
 					};
 
-					if (this._enableExecuteModule) {
-						/**
-						 * @param {string} request the request string to load the module from
-						 * @param {ImportModuleOptions=} options options
-						 * @param {ImportModuleCallback=} callback callback returning the exports
-						 * @returns {void}
-						 */
-						const importModule = (request, options, callback) => {
-							const dep = new LoaderImportDependency(request);
-							dep.loc = {
-								name: request
-							};
-							const factory = compilation.dependencyFactories.get(
-								/** @type {DepConstructor} */ (dep.constructor)
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions=} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {void}
+					 */
+					const importModule = (request, options, callback) => {
+						const dep = new LoaderImportDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
 							);
-							if (factory === undefined) {
-								return callback(
-									new Error(
-										`No module factory available for dependency type: ${dep.constructor.name}`
-									)
-								);
-							}
-							compilation.buildQueue.increaseParallelism();
-							compilation.handleModuleCreation(
-								{
-									factory,
-									dependencies: [dep],
-									originModule: loaderContext._module,
-									contextInfo: {
-										issuerLayer: options.layer
-									},
-									context: loaderContext.context,
-									connectOrigin: false
+						}
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule: loaderContext._module,
+								contextInfo: {
+									issuerLayer: options.layer
 								},
-								err => {
-									compilation.buildQueue.decreaseParallelism();
-									if (err) {
-										return callback(err);
-									}
-									const referencedModule = moduleGraph.getModule(dep);
-									if (!referencedModule) {
-										return callback(new Error("Cannot load the module"));
-									}
-									compilation.executeModule(
-										referencedModule,
-										{
-											entryOptions: {
-												publicPath: options.publicPath
-											}
-										},
-										(err, result) => {
-											if (err) return callback(err);
-											for (const d of result.fileDependencies) {
-												loaderContext.addDependency(d);
-											}
-											for (const d of result.contextDependencies) {
-												loaderContext.addContextDependency(d);
-											}
-											for (const d of result.missingDependencies) {
-												loaderContext.addMissingDependency(d);
-											}
-											for (const d of result.buildDependencies) {
-												loaderContext.addBuildDependency(d);
-											}
-											if (result.cacheable === false)
-												loaderContext.cacheable(false);
-											for (const [name, { source, info }] of result.assets) {
-												const { buildInfo } = loaderContext._module;
-												if (!buildInfo.assets) {
-													buildInfo.assets = Object.create(null);
-													buildInfo.assetsInfo = new Map();
-												}
-												buildInfo.assets[name] = source;
-												buildInfo.assetsInfo.set(name, info);
+								context: loaderContext.context,
+								connectOrigin: false
+							},
+							err => {
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								compilation.executeModule(
+									referencedModule,
+									{
+										entryOptions: {
+											publicPath: options.publicPath
+										}
+									},
+									(err, result) => {
+										if (err) return callback(err);
+										for (const d of result.fileDependencies) {
+											loaderContext.addDependency(d);
+										}
+										for (const d of result.contextDependencies) {
+											loaderContext.addContextDependency(d);
+										}
+										for (const d of result.missingDependencies) {
+											loaderContext.addMissingDependency(d);
+										}
+										for (const d of result.buildDependencies) {
+											loaderContext.addBuildDependency(d);
+										}
+										if (result.cacheable === false)
+											loaderContext.cacheable(false);
+										for (const [name, { source, info }] of result.assets) {
+											const { buildInfo } = loaderContext._module;
+											if (!buildInfo.assets) {
+												buildInfo.assets = Object.create(null);
+												buildInfo.assetsInfo = new Map();
 											}
-											callback(null, result.exports);
+											buildInfo.assets[name] = source;
+											buildInfo.assetsInfo.set(name, info);
 										}
-									);
-								}
-							);
-						};
+										callback(null, result.exports);
+									}
+								);
+							}
+						);
+					};
 
-						/**
-						 * @param {string} request the request string to load the module from
-						 * @param {ImportModuleOptions} options options
-						 * @param {ImportModuleCallback=} callback callback returning the exports
-						 * @returns {Promise<any> | void} exports
-						 */
-						loaderContext.importModule = (request, options, callback) => {
-							if (!callback) {
-								return new Promise((resolve, reject) => {
-									importModule(request, options || {}, (err, result) => {
-										if (err) reject(err);
-										else resolve(result);
-									});
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {Promise<any> | void} exports
+					 */
+					loaderContext.importModule = (request, options, callback) => {
+						if (!callback) {
+							return new Promise((resolve, reject) => {
+								importModule(request, options || {}, (err, result) => {
+									if (err) reject(err);
+									else resolve(result);
 								});
-							}
-							return importModule(request, options || {}, callback);
-						};
-					}
+							});
+						}
+						return importModule(request, options || {}, callback);
+					};
 				}
 			);
 		});

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -30,6 +30,7 @@ class ModuleDecoratorDependency extends NullDependency {
 		super();
 		this.decorator = decorator;
 		this.allowExportsAccess = allowExportsAccess;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -69,8 +70,10 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.decorator);
-		hash.update(`${this.allowExportsAccess}`);
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = `${this.decorator}${this.allowExportsAccess}`;
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

package/lib/dependencies/ProvidedDependency.js

@@ -34,6 +34,7 @@ class ProvidedDependency extends ModuleDependency {
 		this.identifier = identifier;
 		this.path = path;
 		this.range = range;
+		this._hashUpdate = undefined;
 	}
 
 	get type() {
@@ -51,8 +52,11 @@ class ProvidedDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.identifier);
-		hash.update(this.path ? this.path.join(",") : "null");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate =
+				this.identifier + (this.path ? this.path.join(",") : "null");
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

package/lib/dependencies/PureExpressionDependency.js

@@ -28,6 +28,7 @@ class PureExpressionDependency extends NullDependency {
 		this.range = range;
 		/** @type {Set<string> | false} */
 		this.usedByExports = false;
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -37,7 +38,10 @@ class PureExpressionDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(this.range + "");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = this.range + "";
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	/**

package/lib/dependencies/RuntimeRequirementsDependency.js

@@ -23,6 +23,7 @@ class RuntimeRequirementsDependency extends NullDependency {
 	constructor(runtimeRequirements) {
 		super();
 		this.runtimeRequirements = new Set(runtimeRequirements);
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -32,7 +33,10 @@ class RuntimeRequirementsDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update(Array.from(this.runtimeRequirements).join() + "");
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
+		}
+		hash.update(this._hashUpdate);
 	}
 
 	serialize(context) {

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/node/NodeTargetPlugin.js

@@ -41,6 +41,7 @@ const builtins = [
 	"repl",
 	"stream",
 	"stream/promises",
+	"stream/web",
 	"string_decoder",
 	"sys",
 	"timers",

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");
 	}