webpack 5.51.2 → 5.54.0

package/lib/AsyncDependenciesBlock.js

@@ -35,6 +35,7 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		this.request = request;
 		/** @type {DependenciesBlock} */
 		this.parent = undefined;
+		this._stringifiedGroupOptions = undefined;
 	}
 
 	/**
@@ -49,7 +50,10 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 	 * @returns {void}
 	 */
 	set chunkName(value) {
-		this.groupOptions.name = value;
+		if (this.groupOptions.name !== value) {
+			this.groupOptions.name = value;
+			this._stringifiedGroupOptions = undefined;
+		}
 	}
 
 	/**
@@ -59,7 +63,10 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 	 */
 	updateHash(hash, context) {
 		const { chunkGraph } = context;
-		hash.update(JSON.stringify(this.groupOptions));
+		if (this._stringifiedGroupOptions === undefined) {
+			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
+		}
+		hash.update(this._stringifiedGroupOptions);
 		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
 		hash.update(chunkGroup ? chunkGroup.id : "");
 		super.updateHash(hash, context);

package/lib/CacheFacade.js

@@ -13,6 +13,7 @@ const mergeEtags = require("./cache/mergeEtags");
 /** @typedef {import("./Cache").Etag} Etag */
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
+/** @typedef {typeof import("./util/Hash")} HashConstructor */
 
 /**
  * @template T
@@ -198,10 +199,12 @@ class CacheFacade {
 	/**
 	 * @param {Cache} cache the root cache
 	 * @param {string} name the child cache name
+	 * @param {string | HashConstructor} hashFunction the hash function to use
 	 */
-	constructor(cache, name) {
+	constructor(cache, name, hashFunction) {
 		this._cache = cache;
 		this._name = name;
+		this._hashFunction = hashFunction;
 	}
 
 	/**
@@ -209,7 +212,11 @@ class CacheFacade {
 	 * @returns {CacheFacade} child cache
 	 */
 	getChildCache(name) {
-		return new CacheFacade(this._cache, `${this._name}|${name}`);
+		return new CacheFacade(
+			this._cache,
+			`${this._name}|${name}`,
+			this._hashFunction
+		);
 	}
 
 	/**
@@ -230,7 +237,7 @@ class CacheFacade {
 	 * @returns {Etag} an etag that is lazy hashed
 	 */
 	getLazyHashedEtag(obj) {
-		return getLazyHashedEtag(obj);
+		return getLazyHashedEtag(obj, this._hashFunction);
 	}
 
 	/**

package/lib/ChunkGraph.js

@@ -34,6 +34,7 @@ const {
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @type {ReadonlySet<string>} */
@@ -217,8 +218,9 @@ class ChunkGraphChunk {
 class ChunkGraph {
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {string | Hash} hashFunction the hash function to use
 	 */
-	constructor(moduleGraph) {
+	constructor(moduleGraph, hashFunction = "md4") {
 		/** @private @type {WeakMap<Module, ChunkGraphModule>} */
 		this._modules = new WeakMap();
 		/** @private @type {WeakMap<Chunk, ChunkGraphChunk>} */
@@ -230,6 +232,8 @@ class ChunkGraph {
 		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 
+		this._hashFunction = hashFunction;
+
 		this._getGraphRoots = this._getGraphRoots.bind(this);
 
 		// Caching
@@ -1372,22 +1376,29 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	/**
 	 * @param {Module} module the module
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph)
+	 * @param {Set<string>} items runtime requirements to be added (ownership of this Set is given to ChunkGraph when transferOwnership not false)
+	 * @param {boolean} transferOwnership true: transfer ownership of the items object, false: items is immutable and shared and won't be modified
 	 * @returns {void}
 	 */
-	addModuleRuntimeRequirements(module, runtime, items) {
+	addModuleRuntimeRequirements(
+		module,
+		runtime,
+		items,
+		transferOwnership = true
+	) {
 		const cgm = this._getChunkGraphModule(module);
 		const runtimeRequirementsMap = cgm.runtimeRequirements;
 		if (runtimeRequirementsMap === undefined) {
 			const map = new RuntimeSpecMap();
-			map.set(runtime, items);
+			// TODO avoid cloning item and track ownership instead
+			map.set(runtime, transferOwnership ? items : new Set(items));
 			cgm.runtimeRequirements = map;
 			return;
 		}
 		runtimeRequirementsMap.update(runtime, runtimeRequirements => {
 			if (runtimeRequirements === undefined) {
-				return items;
-			} else if (runtimeRequirements.size >= items.size) {
+				return transferOwnership ? items : new Set(items);
+			} else if (!transferOwnership || runtimeRequirements.size >= items.size) {
 				for (const item of items) runtimeRequirements.add(item);
 				return runtimeRequirements;
 			} else {
@@ -1487,7 +1498,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			cgm.graphHashes = new RuntimeSpecMap();
 		}
 		const graphHash = cgm.graphHashes.provide(runtime, () => {
-			const hash = createHash("md4");
+			const hash = createHash(this._hashFunction);
 			hash.update(`${cgm.id}`);
 			hash.update(`${this.moduleGraph.isAsync(module)}`);
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
@@ -1575,7 +1586,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 				connectedModules.size > 1
 					? Array.from(connectedModules).sort(([a], [b]) => (a < b ? -1 : 1))
 					: connectedModules;
-			const hash = createHash("md4");
+			const hash = createHash(this._hashFunction);
 			const addModuleToHash = module => {
 				hash.update(
 					this._getModuleGraphHashBigInt(

package/lib/CodeGenerationResults.js

@@ -13,12 +13,17 @@ const { runtimeToString, RuntimeSpecMap } = require("./util/runtime");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 class CodeGenerationResults {
-	constructor() {
+	/**
+	 * @param {string | Hash} hashFunction the hash function to use
+	 */
+	constructor(hashFunction = "md4") {
 		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
 		this.map = new Map();
+		this._hashFunction = hashFunction;
 	}
 
 	/**
@@ -124,7 +129,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	getHash(module, runtime) {
 		const info = this.get(module, runtime);
 		if (info.hash !== undefined) return info.hash;
-		const hash = createHash("md4");
+		const hash = createHash(this._hashFunction);
 		for (const [type, source] of info.sources) {
 			hash.update(type);
 			source.updateHash(hash);

package/lib/Compilation.js

@@ -38,6 +38,7 @@ const {
 	tryRunOrWebpackError
 } = require("./HookWebpackError");
 const MainTemplate = require("./MainTemplate");
+const MemCache = require("./MemCache");
 const Module = require("./Module");
 const ModuleDependencyError = require("./ModuleDependencyError");
 const ModuleDependencyWarning = require("./ModuleDependencyWarning");
@@ -76,7 +77,7 @@ const {
 	createFakeHook
 } = require("./util/deprecation");
 const processAsyncTree = require("./util/processAsyncTree");
-const { getRuntimeKey } = require("./util/runtime");
+const { getRuntimeKey, RuntimeSpecMap } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
 /** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
@@ -852,7 +853,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
 			managedPaths: compiler.managedPaths,
 			immutablePaths: compiler.immutablePaths,
-			logger: this.getLogger("webpack.FileSystemInfo")
+			logger: this.getLogger("webpack.FileSystemInfo"),
+			hashFunction: compiler.options.output.hashFunction
 		});
 		if (compiler.fileTimestamps) {
 			this.fileSystemInfo.addFileTimestamps(compiler.fileTimestamps, true);
@@ -891,6 +893,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
+		/** @type {MemCache | undefined} */
+		this.memCache = undefined;
+		/** @type {WeakMap<Module, MemCache> | undefined} */
+		this.moduleMemCaches = undefined;
 		this.moduleGraph = new ModuleGraph();
 		/** @type {ChunkGraph} */
 		this.chunkGraph = undefined;
@@ -2011,6 +2017,79 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 	}
 
+	_computeAffectedModules(modules) {
+		const moduleMemCacheCache = this.compiler.moduleMemCaches;
+		if (!moduleMemCacheCache) return;
+		if (!this.moduleMemCaches) this.moduleMemCaches = new WeakMap();
+		if (!this.memCache) this.memCache = new MemCache();
+		const { moduleGraph, memCache, moduleMemCaches } = this;
+		const affectedModules = new Set();
+		const infectedModules = new Set();
+		let statNew = 0;
+		let statChanged = 0;
+		let statUnchanged = 0;
+		let statWithoutHash = 0;
+		for (const module of modules) {
+			const hash = module.buildInfo && module.buildInfo.hash;
+			if (typeof hash === "string") {
+				const cachedMemCache = moduleMemCacheCache.get(module);
+				if (cachedMemCache === undefined) {
+					// create a new entry
+					moduleMemCacheCache.set(module, {
+						hash: hash,
+						memCache
+					});
+					moduleMemCaches.set(module, memCache);
+					affectedModules.add(module);
+					statNew++;
+				} else if (cachedMemCache.hash === hash) {
+					// keep the old mem cache
+					moduleMemCaches.set(module, cachedMemCache.memCache);
+					statUnchanged++;
+				} else {
+					// use a new one
+					moduleMemCaches.set(module, memCache);
+					affectedModules.add(module);
+					cachedMemCache.hash = hash;
+					cachedMemCache.memCache = memCache;
+					statChanged++;
+				}
+			} else {
+				infectedModules.add(module);
+				statWithoutHash++;
+			}
+		}
+		for (const module of infectedModules) {
+			for (const referencingModule of moduleGraph
+				.getIncomingConnectionsByOriginModule(module)
+				.keys()) {
+				if (infectedModules.has(referencingModule)) continue;
+				infectedModules.add(referencingModule);
+			}
+		}
+		for (const module of affectedModules) {
+			for (const referencingModule of moduleGraph
+				.getIncomingConnectionsByOriginModule(module)
+				.keys()) {
+				if (!referencingModule) continue;
+				if (infectedModules.has(referencingModule)) continue;
+				if (affectedModules.has(referencingModule)) continue;
+				affectedModules.add(referencingModule);
+				moduleMemCaches.set(referencingModule, memCache);
+			}
+		}
+		this.logger.log(
+			`${Math.round(
+				(100 * (affectedModules.size + infectedModules.size)) /
+					this.modules.size
+			)}% (${affectedModules.size} affected + ${
+				infectedModules.size
+			} infected of ${
+				this.modules.size
+			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged, ${statWithoutHash} without hash)`
+		);
+	}
+
 	finish(callback) {
 		this.factorizeQueue.clear();
 		if (this.profile) {
@@ -2191,17 +2270,29 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			);
 			this.logger.timeEnd("finish module profiles");
 		}
+		this.logger.time("compute affected modules");
+		this._computeAffectedModules(this.modules);
+		this.logger.timeEnd("compute affected modules");
 		this.logger.time("finish modules");
-		const { modules } = this;
+		const { modules, moduleMemCaches } = this;
 		this.hooks.finishModules.callAsync(modules, err => {
 			this.logger.timeEnd("finish modules");
 			if (err) return callback(err);
 
 			// extract warnings and errors from modules
-			this.logger.time("report dependency errors and warnings");
 			this.moduleGraph.freeze();
+			// TODO keep a cacheToken (= {}) for each module in the graph
+			// create a new one per compilation and flag all updated files
+			// and parents with it
+			this.logger.time("report dependency errors and warnings");
 			for (const module of modules) {
-				this.reportDependencyErrorsAndWarnings(module, [module]);
+				// TODO only run for modules with changed cacheToken
+				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
+				const memCache = moduleMemCaches && moduleMemCaches.get(module);
+				if (memCache && memCache.get(module, "noWarningsOrErrors")) continue;
+				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
+					module
+				]);
 				const errors = module.getErrors();
 				if (errors !== undefined) {
 					for (const error of errors) {
@@ -2209,6 +2300,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							error.module = module;
 						}
 						this.errors.push(error);
+						hasProblems = true;
 					}
 				}
 				const warnings = module.getWarnings();
@@ -2218,8 +2310,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							warning.module = module;
 						}
 						this.warnings.push(warning);
+						hasProblems = true;
 					}
 				}
+				if (!hasProblems && memCache)
+					memCache.set(module, "noWarningsOrErrors", true);
 			}
 			this.moduleGraph.unfreeze();
 			this.logger.timeEnd("report dependency errors and warnings");
@@ -2255,7 +2350,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.addModuleQueue.clear();
 			return callback(err);
 		};
-		const chunkGraph = new ChunkGraph(this.moduleGraph);
+		const chunkGraph = new ChunkGraph(
+			this.moduleGraph,
+			this.outputOptions.hashFunction
+		);
 		this.chunkGraph = chunkGraph;
 
 		for (const module of this.modules) {
@@ -2573,9 +2671,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	/**
 	 * @param {Module} module module to report from
 	 * @param {DependenciesBlock[]} blocks blocks to report from
-	 * @returns {void}
+	 * @returns {boolean} true, when it has warnings or errors
 	 */
 	reportDependencyErrorsAndWarnings(module, blocks) {
+		let hasProblems = false;
 		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
 			const block = blocks[indexBlock];
 			const dependencies = block.dependencies;
@@ -2590,6 +2689,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 						const warning = new ModuleDependencyWarning(module, w, d.loc);
 						this.warnings.push(warning);
+						hasProblems = true;
 					}
 				}
 				const errors = d.getErrors(this.moduleGraph);
@@ -2599,17 +2699,22 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 						const error = new ModuleDependencyError(module, e, d.loc);
 						this.errors.push(error);
+						hasProblems = true;
 					}
 				}
 			}
 
-			this.reportDependencyErrorsAndWarnings(module, block.blocks);
+			if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
+				hasProblems = true;
 		}
+		return hasProblems;
 	}
 
 	codeGeneration(callback) {
 		const { chunkGraph } = this;
-		this.codeGenerationResults = new CodeGenerationResults();
+		this.codeGenerationResults = new CodeGenerationResults(
+			this.outputOptions.hashFunction
+		);
 		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
 		const jobs = [];
 		for (const module of this.modules) {
@@ -2790,12 +2895,41 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		chunkGraphEntries = this._getChunkGraphEntries()
 	} = {}) {
 		const context = { chunkGraph, codeGenerationResults };
+		const { moduleMemCaches } = this;
+		this.logger.time("runtime requirements.modules");
 		const additionalModuleRuntimeRequirements =
 			this.hooks.additionalModuleRuntimeRequirements;
 		const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
 		for (const module of modules) {
 			if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
+				const memCache =
+					moduleMemCaches &&
+					// modules with async blocks depend on the chunk graph and can't be cached that way
+					module.blocks.length === 0 &&
+					moduleMemCaches.get(module);
+				/** @type {RuntimeSpecMap<Set<string>>} */
+				const moduleRuntimeRequirementsMemCache =
+					memCache &&
+					memCache.provide(
+						module,
+						"moduleRuntimeRequirements",
+						() => new RuntimeSpecMap()
+					);
 				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+					if (moduleRuntimeRequirementsMemCache) {
+						const cached = moduleRuntimeRequirementsMemCache.get(runtime);
+						if (cached !== undefined) {
+							if (cached !== null) {
+								chunkGraph.addModuleRuntimeRequirements(
+									module,
+									runtime,
+									cached,
+									false
+								);
+							}
+							continue;
+						}
+					}
 					let set;
 					const runtimeRequirements =
 						codeGenerationResults.getRuntimeRequirements(module, runtime);
@@ -2804,6 +2938,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					} else if (additionalModuleRuntimeRequirements.isUsed()) {
 						set = new Set();
 					} else {
+						if (moduleRuntimeRequirementsMemCache) {
+							moduleRuntimeRequirementsMemCache.set(runtime, null);
+						}
 						continue;
 					}
 					additionalModuleRuntimeRequirements.call(module, set, context);
@@ -2812,11 +2949,29 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						const hook = runtimeRequirementInModule.get(r);
 						if (hook !== undefined) hook.call(module, set, context);
 					}
-					chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
+					if (set.size === 0) {
+						if (moduleRuntimeRequirementsMemCache) {
+							moduleRuntimeRequirementsMemCache.set(runtime, null);
+						}
+					} else {
+						if (moduleRuntimeRequirementsMemCache) {
+							moduleRuntimeRequirementsMemCache.set(runtime, set);
+							chunkGraph.addModuleRuntimeRequirements(
+								module,
+								runtime,
+								set,
+								false
+							);
+						} else {
+							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
+						}
+					}
 				}
 			}
 		}
+		this.logger.timeEnd("runtime requirements.modules");
 
+		this.logger.time("runtime requirements.chunks");
 		for (const chunk of chunks) {
 			const set = new Set();
 			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
@@ -2834,7 +2989,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 			chunkGraph.addChunkRuntimeRequirements(chunk, set);
 		}
+		this.logger.timeEnd("runtime requirements.chunks");
 
+		this.logger.time("runtime requirements.entries");
 		for (const treeEntry of chunkGraphEntries) {
 			const set = new Set();
 			for (const chunk of treeEntry.getAllReferencedChunks()) {
@@ -2857,6 +3014,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 			chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
 		}
+		this.logger.timeEnd("runtime requirements.entries");
 	}
 
 	// TODO webpack 6 make chunkGraph argument non-optional
@@ -3201,12 +3359,35 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	createModuleHashes() {
 		let statModulesHashed = 0;
-		const { chunkGraph, runtimeTemplate } = this;
+		let statModulesFromCache = 0;
+		const { chunkGraph, runtimeTemplate, moduleMemCaches } = this;
 		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
 		for (const module of this.modules) {
+			const memCache =
+				moduleMemCaches &&
+				// modules with async blocks depend on the chunk graph and can't be cached that way
+				module.blocks.length === 0 &&
+				moduleMemCaches.get(module);
+			/** @type {RuntimeSpecMap<string>} */
+			const moduleHashesMemCache =
+				memCache &&
+				memCache.provide(module, "moduleHashes", () => new RuntimeSpecMap());
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+				if (moduleHashesMemCache) {
+					const digest = moduleHashesMemCache.get(runtime);
+					if (digest !== undefined) {
+						chunkGraph.setModuleHashes(
+							module,
+							runtime,
+							digest,
+							digest.substr(0, hashDigestLength)
+						);
+						statModulesFromCache++;
+						continue;
+					}
+				}
 				statModulesHashed++;
-				this._createModuleHash(
+				const digest = this._createModuleHash(
 					module,
 					chunkGraph,
 					runtime,
@@ -3215,11 +3396,16 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					hashDigest,
 					hashDigestLength
 				);
+				if (moduleHashesMemCache) {
+					moduleHashesMemCache.set(runtime, digest);
+				}
 			}
 		}
 		this.logger.log(
-			`${statModulesHashed} modules hashed (${
-				Math.round((100 * statModulesHashed) / this.modules.size) / 100
+			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
+				Math.round(
+					(100 * (statModulesHashed + statModulesFromCache)) / this.modules.size
+				) / 100
 			} variants per module in average)`
 		);
 	}
@@ -4071,7 +4257,10 @@ This prevents using hashes of each other and should be avoided.`);
 				if (err) return callback(err);
 
 				// Create new chunk graph, chunk and entrypoint for the build time execution
-				const chunkGraph = new ChunkGraph(this.moduleGraph);
+				const chunkGraph = new ChunkGraph(
+					this.moduleGraph,
+					this.outputOptions.hashFunction
+				);
 				const runtime = "build time";
 				const { hashFunction, hashDigest, hashDigestLength } =
 					this.outputOptions;
@@ -4114,7 +4303,9 @@ This prevents using hashes of each other and should be avoided.`);
 					);
 				}
 
-				const codeGenerationResults = new CodeGenerationResults();
+				const codeGenerationResults = new CodeGenerationResults(
+					this.outputOptions.hashFunction
+				);
 				/** @type {WebpackError[]} */
 				const errors = [];
 				/**

package/lib/Compiler.js

@@ -41,6 +41,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Chunk")} Chunk */
 /** @typedef {import("./FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("./MemCache")} MemCache */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("./util/fs").IntermediateFileSystem} IntermediateFileSystem */
@@ -247,6 +248,9 @@ class Compiler {
 
 		this.cache = new Cache();
 
+		/** @type {WeakMap<Module, { hash: string, memCache: MemCache }> | undefined} */
+		this.moduleMemCaches = undefined;
+
 		this.compilerPath = "";
 
 		/** @type {boolean} */
@@ -276,7 +280,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
+		);
 	}
 
 	/**

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