webpack 5.52.1 → 5.55.1

package/lib/Compiler.js

@@ -40,8 +40,10 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Chunk")} Chunk */
+/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./util/WeakTupleMap")} WeakTupleMap */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./util/fs").OutputFileSystem} OutputFileSystem */
@@ -247,6 +249,9 @@ class Compiler {
 
 		this.cache = new Cache();
 
+		/** @type {WeakMap<Module, { hash: string, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
+		this.moduleMemCaches = undefined;
+
 		this.compilerPath = "";
 
 		/** @type {boolean} */
@@ -276,7 +281,11 @@ class Compiler {
 	 * @returns {CacheFacade} the cache facade instance
 	 */
 	getCache(name) {
-		return new CacheFacade(this.cache, `${this.compilerPath}${name}`);
+		return new CacheFacade(
+			this.cache,
+			`${this.compilerPath}${name}`,
+			this.options.output.hashFunction
+		);
 	}
 
 	/**
@@ -1027,9 +1036,9 @@ ${other}`);
 		return !!this.parentCompilation;
 	}
 
-	createCompilation() {
+	createCompilation(params) {
 		this._cleanupLastCompilation();
-		return (this._lastCompilation = new Compilation(this));
+		return (this._lastCompilation = new Compilation(this, params));
 	}
 
 	/**
@@ -1037,7 +1046,7 @@ ${other}`);
 	 * @returns {Compilation} the created compilation
 	 */
 	newCompilation(params) {
-		const compilation = this.createCompilation();
+		const compilation = this.createCompilation(params);
 		compilation.name = this.name;
 		compilation.records = this.records;
 		this.hooks.thisCompilation.call(compilation, params);

package/lib/Dependency.js

@@ -78,6 +78,8 @@ const memoize = require("./util/memoize");
  * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
  */
 
+const TRANSITIVE = Symbol("transitive");
+
 const getIgnoredModule = memoize(() => {
 	const RawModule = require("./RawModule");
 	return new RawModule("/* (ignored) */", `ignored`, `(ignored)`);
@@ -175,6 +177,13 @@ class Dependency {
 		return null;
 	}
 
+	/**
+	 * @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 TRANSITIVE;
+	}
+
 	/**
 	 * Returns the referenced module and export
 	 * @deprecated
@@ -322,4 +331,6 @@ Object.defineProperty(Dependency.prototype, "disconnect", {
 	}
 });
 
+Dependency.TRANSITIVE = TRANSITIVE;
+
 module.exports = Dependency;

package/lib/DependencyTemplates.js

@@ -9,14 +9,20 @@ const createHash = require("./util/createHash");
 
 /** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {typeof import("./util/Hash")} Hash */
+
 /** @typedef {new (...args: any[]) => Dependency} DependencyConstructor */
 
 class DependencyTemplates {
-	constructor() {
+	/**
+	 * @param {string | Hash} hashFunction the hash function to use
+	 */
+	constructor(hashFunction = "md4") {
 		/** @type {Map<Function, DependencyTemplate>} */
 		this._map = new Map();
 		/** @type {string} */
 		this._hash = "31d6cfe0d16ae931b73c59d7e0c089c0";
+		this._hashFunction = hashFunction;
 	}
 
 	/**
@@ -41,7 +47,7 @@ class DependencyTemplates {
 	 * @returns {void}
 	 */
 	updateHash(part) {
-		const hash = createHash("md4");
+		const hash = createHash(this._hashFunction);
 		hash.update(this._hash);
 		hash.update(part);
 		this._hash = /** @type {string} */ (hash.digest("hex"));

package/lib/EvalDevToolModulePlugin.js

@@ -61,7 +61,8 @@ class EvalDevToolModulePlugin {
 						},
 						{
 							requestShortener: runtimeTemplate.requestShortener,
-							chunkGraph
+							chunkGraph,
+							hashFunction: compilation.outputOptions.hashFunction
 						}
 					);
 					const footer =

package/lib/EvalSourceMapDevToolPlugin.js

@@ -138,7 +138,8 @@ class EvalSourceMapDevToolPlugin {
 								},
 								{
 									requestShortener: runtimeTemplate.requestShortener,
-									chunkGraph
+									chunkGraph,
+									hashFunction: compilation.outputOptions.hashFunction
 								}
 							);
 						});

package/lib/ExternalModule.js

@@ -38,6 +38,7 @@ const { register } = require("./util/serialization");
 /** @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 */
 
@@ -160,11 +161,16 @@ const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
 };
 
 class ModuleExternalInitFragment extends InitFragment {
-	constructor(request, ident) {
+	/**
+	 * @param {string} request import source
+	 * @param {string=} ident recomputed ident
+	 * @param {string | HashConstructor=} hashFunction the hash function to use
+	 */
+	constructor(request, ident, hashFunction = "md4") {
 		if (ident === undefined) {
 			ident = Template.toIdentifier(request);
 			if (ident !== request) {
-				ident += `_${createHash("md4")
+				ident += `_${createHash(hashFunction)
 					.update(request)
 					.digest("hex")
 					.slice(0, 8)}`;
@@ -230,21 +236,25 @@ const generateModuleRemapping = (input, exportsInfo, runtime) => {
 };
 
 /**
- * @param {string|number} id the module id
  * @param {string|string[]} moduleAndSpecifiers the module request
  * @param {ExportsInfo} exportsInfo exports info of this module
  * @param {RuntimeSpec} runtime the runtime
+ * @param {string | HashConstructor=} hashFunction the hash function to use
  * @returns {SourceData} the generated source
  */
 const getSourceForModuleExternal = (
-	id,
 	moduleAndSpecifiers,
 	exportsInfo,
-	runtime
+	runtime,
+	hashFunction
 ) => {
 	if (!Array.isArray(moduleAndSpecifiers))
 		moduleAndSpecifiers = [moduleAndSpecifiers];
-	const initFragment = new ModuleExternalInitFragment(moduleAndSpecifiers[0]);
+	const initFragment = new ModuleExternalInitFragment(
+		moduleAndSpecifiers[0],
+		undefined,
+		hashFunction
+	);
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
 		moduleAndSpecifiers,
 		1
@@ -566,12 +576,11 @@ class ExternalModule extends Module {
 						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
 					);
 				}
-				const id = chunkGraph.getModuleId(this);
 				return getSourceForModuleExternal(
-					id !== null ? id : this.identifier(),
 					request,
 					moduleGraph.getExportsInfo(this),
-					runtime
+					runtime,
+					runtimeTemplate.outputOptions.hashFunction
 				);
 			}
 			case "var":