webpack 5.55.0 → 5.57.0

package/lib/AsyncDependenciesBlock.js

@@ -66,9 +66,10 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		if (this._stringifiedGroupOptions === undefined) {
 			this._stringifiedGroupOptions = JSON.stringify(this.groupOptions);
 		}
-		hash.update(this._stringifiedGroupOptions);
 		const chunkGroup = chunkGraph.getBlockChunkGroup(this);
-		hash.update(chunkGroup ? chunkGroup.id : "");
+		hash.update(
+			`${this._stringifiedGroupOptions}${chunkGroup ? chunkGroup.id : ""}`
+		);
 		super.updateHash(hash, context);
 	}
 

package/lib/Chunk.js

@@ -539,9 +539,9 @@ class Chunk {
 	 * @returns {void}
 	 */
 	updateHash(hash, chunkGraph) {
-		hash.update(`${this.id} `);
-		hash.update(this.ids ? this.ids.join(",") : "");
-		hash.update(`${this.name || ""} `);
+		hash.update(
+			`${this.id} ${this.ids ? this.ids.join() : ""} ${this.name || ""} `
+		);
 		const xor = new StringXor();
 		for (const m of chunkGraph.getChunkModulesIterable(this)) {
 			xor.add(chunkGraph.getModuleHash(m, this.runtime));
@@ -550,9 +550,7 @@ class Chunk {
 		const entryModules =
 			chunkGraph.getChunkEntryModulesWithChunkGroupIterable(this);
 		for (const [m, chunkGroup] of entryModules) {
-			hash.update("entry");
-			hash.update(`${chunkGraph.getModuleId(m)}`);
-			hash.update(chunkGroup.id);
+			hash.update(`entry${chunkGraph.getModuleId(m)}${chunkGroup.id}`);
 		}
 	}
 

package/lib/ChunkGraph.js

@@ -1499,8 +1499,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		}
 		const graphHash = cgm.graphHashes.provide(runtime, () => {
 			const hash = createHash(this._hashFunction);
-			hash.update(`${cgm.id}`);
-			hash.update(`${this.moduleGraph.isAsync(module)}`);
+			hash.update(`${cgm.id}${this.moduleGraph.isAsync(module)}`);
 			this.moduleGraph.getExportsInfo(module).updateHash(hash, runtime);
 			return BigInt(`0x${/** @type {string} */ (hash.digest("hex"))}`);
 		});

package/lib/Compilation.js

@@ -78,7 +78,7 @@ const {
 	createFakeHook
 } = require("./util/deprecation");
 const processAsyncTree = require("./util/processAsyncTree");
-const { getRuntimeKey, RuntimeSpecMap } = require("./util/runtime");
+const { getRuntimeKey } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
 /** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
@@ -917,8 +917,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
-		/** @type {WeakMap<Module, WeakTupleMap<any, any>> | undefined} */
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
 		this.moduleMemCaches = undefined;
+		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		this.moduleMemCaches2 = undefined;
 		this.moduleGraph = new ModuleGraph();
 		/** @type {ChunkGraph} */
 		this.chunkGraph = undefined;
@@ -2169,7 +2171,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		const moduleMemCacheCache = this.compiler.moduleMemCaches;
 		if (!moduleMemCacheCache) return;
 		if (!this.moduleMemCaches) {
-			this.moduleMemCaches = new WeakMap();
+			this.moduleMemCaches = new Map();
 			this.moduleGraph.setModuleMemCaches(this.moduleMemCaches);
 		}
 		const { moduleGraph, moduleMemCaches } = this;
@@ -2178,43 +2180,96 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		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
-					const memCache = new WeakTupleMap();
-					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++;
+		let statReferencesChanged = 0;
+		let statWithoutBuild = 0;
+
+		const computeReferences = module => {
+			/** @type {WeakMap<Dependency, Module>} */
+			let references = undefined;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				const m = connection.module;
+				if (!d || !m || unsafeCacheDependencies.has(d)) continue;
+				if (references === undefined) references = new WeakMap();
+				references.set(d, m);
+			}
+			return references;
+		};
+
+		/**
+		 * @param {Module} module the module
+		 * @param {WeakMap<Dependency, Module>} references references
+		 * @returns {boolean} true, when the references differ
+		 */
+		const compareReferences = (module, references) => {
+			if (references === undefined) return true;
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				const d = connection.dependency;
+				if (!d) continue;
+				const entry = references.get(d);
+				if (entry === undefined) continue;
+				if (entry !== connection.module) return false;
+			}
+			return true;
+		};
+
+		const modulesWithoutCache = new Set(modules);
+		for (const [module, cachedMemCache] of moduleMemCacheCache) {
+			if (modulesWithoutCache.has(module)) {
+				const buildInfo = module.buildInfo;
+				if (buildInfo) {
+					if (cachedMemCache.buildInfo !== buildInfo) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.buildInfo = buildInfo;
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statChanged++;
+					} else if (!compareReferences(module, cachedMemCache.references)) {
+						// use a new one
+						const memCache = new WeakTupleMap();
+						moduleMemCaches.set(module, memCache);
+						affectedModules.add(module);
+						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.memCache = memCache;
+						statReferencesChanged++;
+					} else {
+						// keep the old mem cache
+						moduleMemCaches.set(module, cachedMemCache.memCache);
+						statUnchanged++;
+					}
 				} else {
-					// use a new one
-					const memCache = new WeakTupleMap();
-					moduleMemCacheCache.set(module, {
-						hash: hash,
-						memCache
-					});
-					moduleMemCaches.set(module, memCache);
-					affectedModules.add(module);
-					cachedMemCache.hash = hash;
-					cachedMemCache.memCache = memCache;
-					statChanged++;
+					infectedModules.add(module);
+					moduleMemCacheCache.delete(module);
+					statWithoutBuild++;
 				}
+				modulesWithoutCache.delete(module);
+			} else {
+				moduleMemCacheCache.delete(module);
+			}
+		}
+
+		for (const module of modulesWithoutCache) {
+			const buildInfo = module.buildInfo && module.buildInfo.buildInfo;
+			if (buildInfo) {
+				// create a new entry
+				const memCache = new WeakTupleMap();
+				moduleMemCacheCache.set(module, {
+					buildInfo,
+					references: computeReferences(module),
+					memCache
+				});
+				moduleMemCaches.set(module, memCache);
+				affectedModules.add(module);
+				statNew++;
 			} else {
 				infectedModules.add(module);
-				statWithoutHash++;
+				statWithoutBuild++;
 			}
 		}
+
 		const reduceAffectType = connections => {
 			let affected = false;
 			for (const { dependency } of connections) {
@@ -2261,7 +2316,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					affectedModules.add(referencingModule);
 				}
 				const memCache = new WeakTupleMap();
-				const cache = moduleMemCacheCache.get(module);
+				const cache = moduleMemCacheCache.get(referencingModule);
 				cache.memCache = memCache;
 				moduleMemCaches.set(referencingModule, memCache);
 			}
@@ -2275,10 +2330,103 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				infectedModules.size
 			} infected of ${
 				this.modules.size
-			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statUnchanged} unchanged, ${statWithoutHash} without hash)`
+			}) modules flagged as affected (${statNew} new modules, ${statChanged} changed, ${statReferencesChanged} references changed, ${statUnchanged} unchanged, ${statWithoutBuild} were not built)`
 		);
 	}
 
+	_updateAffectedModulesWithIds() {
+		const { moduleMemCaches } = this;
+		if (!moduleMemCaches) return;
+		const moduleMemCaches2 = (this.moduleMemCaches2 = new Map());
+		const { moduleGraph, chunkGraph } = this;
+		const key = "memCache2";
+		/**
+		 * @param {Module} module module
+		 * @returns {{ modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
+		 */
+		const computeReferences = module => {
+			/** @type {Map<Module, string | number | undefined>} */
+			let modules = undefined;
+			/** @type {(string | number)[] | undefined} */
+			let blocks = undefined;
+			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
+			if (outgoing !== undefined) {
+				for (const m of outgoing.keys()) {
+					if (!m) continue;
+					if (modules === undefined) modules = new Map();
+					modules.set(m, chunkGraph.getModuleId(module));
+				}
+			}
+			if (module.blocks.length > 0) {
+				blocks = [];
+				const queue = Array.from(module.blocks);
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							blocks.push(chunk.id);
+						}
+					} else {
+						blocks.push(null);
+					}
+					queue.push.apply(queue, block.blocks);
+				}
+			}
+			return { modules, blocks };
+		};
+		/**
+		 * @param {Module} module module
+		 * @param {Object} references references
+		 * @param {Map<Module, string | number>=} references.modules modules
+		 * @param {(string | number)[]=} references.blocks blocks
+		 * @returns {boolean} ok?
+		 */
+		const compareReferences = (module, { modules, blocks }) => {
+			if (modules !== undefined) {
+				for (const [module, id] of modules) {
+					if (chunkGraph.getModuleId(module) !== id) return false;
+				}
+			}
+			if (blocks !== undefined) {
+				const queue = Array.from(module.blocks);
+				let i = 0;
+				for (const block of queue) {
+					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+					if (chunkGroup) {
+						for (const chunk of chunkGroup.chunks) {
+							if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
+						}
+					} else {
+						if (i >= blocks.length || blocks[i++] !== null) return false;
+					}
+					queue.push.apply(queue, block.blocks);
+				}
+				if (i !== blocks.length) return false;
+			}
+			return true;
+		};
+
+		for (const [module, memCache] of moduleMemCaches) {
+			/** @type {{ references: { modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
+			const cache = memCache.get(key);
+			if (cache === undefined) {
+				const memCache2 = new WeakTupleMap();
+				memCache.set(key, {
+					references: computeReferences(module),
+					memCache: memCache2
+				});
+				moduleMemCaches2.set(module, memCache2);
+			} else if (!compareReferences(module, cache.references)) {
+				const memCache = new WeakTupleMap();
+				cache.references = computeReferences(module);
+				cache.memCache = memCache;
+				moduleMemCaches2.set(module, memCache);
+			} else {
+				moduleMemCaches2.set(module, cache.memCache);
+			}
+		}
+	}
+
 	finish(callback) {
 		this.factorizeQueue.clear();
 		if (this.profile) {
@@ -2523,6 +2671,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo.clear();
 		this.moduleGraph.removeAllModuleAttributes();
 		this.moduleGraph.unfreeze();
+		this.moduleMemCaches2 = undefined;
 	}
 
 	/**
@@ -2740,6 +2889,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 					this.assignRuntimeIds();
 
+					this._updateAffectedModulesWithIds();
+
 					this.sortItemsWithChunkIds();
 
 					if (shouldRecord) {
@@ -3083,28 +3234,19 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		chunkGraphEntries = this._getChunkGraphEntries()
 	} = {}) {
 		const context = { chunkGraph, codeGenerationResults };
-		const { moduleMemCaches } = this;
+		const { moduleMemCaches2 } = 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(
-						"moduleRuntimeRequirements",
-						() => new RuntimeSpecMap()
-					);
+				const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-					if (moduleRuntimeRequirementsMemCache) {
-						const cached = moduleRuntimeRequirementsMemCache.get(runtime);
+					if (memCache) {
+						const cached = memCache.get(
+							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`
+						);
 						if (cached !== undefined) {
 							if (cached !== null) {
 								chunkGraph.addModuleRuntimeRequirements(
@@ -3125,8 +3267,11 @@ 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);
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
 						}
 						continue;
 					}
@@ -3137,12 +3282,18 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						if (hook !== undefined) hook.call(module, set, context);
 					}
 					if (set.size === 0) {
-						if (moduleRuntimeRequirementsMemCache) {
-							moduleRuntimeRequirementsMemCache.set(runtime, null);
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								null
+							);
 						}
 					} else {
-						if (moduleRuntimeRequirementsMemCache) {
-							moduleRuntimeRequirementsMemCache.set(runtime, set);
+						if (memCache) {
+							memCache.set(
+								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+								set
+							);
 							chunkGraph.addModuleRuntimeRequirements(
 								module,
 								runtime,
@@ -3547,21 +3698,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	createModuleHashes() {
 		let statModulesHashed = 0;
 		let statModulesFromCache = 0;
-		const { chunkGraph, runtimeTemplate, moduleMemCaches } = this;
+		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = 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("moduleHashes", () => new RuntimeSpecMap());
+			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-				if (moduleHashesMemCache) {
-					const digest = moduleHashesMemCache.get(runtime);
+				if (memCache) {
+					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,
@@ -3583,8 +3726,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					hashDigest,
 					hashDigestLength
 				);
-				if (moduleHashesMemCache) {
-					moduleHashesMemCache.set(runtime, digest);
+				if (memCache) {
+					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
 				}
 			}
 		}

package/lib/Compiler.js

@@ -40,6 +40,7 @@ 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 */
@@ -248,7 +249,7 @@ class Compiler {
 
 		this.cache = new Cache();
 
-		/** @type {WeakMap<Module, { hash: string, memCache: WeakTupleMap }> | undefined} */
+		/** @type {Map<Module, { buildInfo: object, references: WeakMap<Dependency, Module>, memCache: WeakTupleMap }> | undefined} */
 		this.moduleMemCaches = undefined;
 
 		this.compilerPath = "";

package/lib/DefinePlugin.js

@@ -13,7 +13,7 @@ const {
 	evaluateToString,
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
-const { provide } = require("./util/MapHelpers");
+const createHash = require("./util/createHash");
 
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
@@ -250,7 +250,7 @@ const toCacheVersion = code => {
 };
 
 const VALUE_DEP_PREFIX = "webpack/DefinePlugin ";
-const VALUE_DEP_MAIN = "webpack/DefinePlugin";
+const VALUE_DEP_MAIN = "webpack/DefinePlugin_hash";
 
 class DefinePlugin {
 	/**
@@ -286,12 +286,11 @@ class DefinePlugin {
 				);
 				const { runtimeTemplate } = compilation;
 
-				const mainValue = /** @type {Set<string>} */ (
-					provide(
-						compilation.valueCacheVersions,
-						VALUE_DEP_MAIN,
-						() => new Set()
-					)
+				const mainHash = createHash(compilation.outputOptions.hashFunction);
+				mainHash.update(
+					/** @type {string} */ (
+						compilation.valueCacheVersions.get(VALUE_DEP_MAIN)
+					) || ""
 				);
 
 				/**
@@ -300,6 +299,7 @@ class DefinePlugin {
 				 * @returns {void}
 				 */
 				const handler = parser => {
+					const mainValue = compilation.valueCacheVersions.get(VALUE_DEP_MAIN);
 					parser.hooks.program.tap("DefinePlugin", () => {
 						const { buildInfo } = parser.state.module;
 						if (!buildInfo.valueDependencies)
@@ -565,7 +565,7 @@ class DefinePlugin {
 						const code = definitions[key];
 						const version = toCacheVersion(code);
 						const name = VALUE_DEP_PREFIX + prefix + key;
-						mainValue.add(name);
+						mainHash.update("|" + prefix + key);
 						const oldVersion = compilation.valueCacheVersions.get(name);
 						if (oldVersion === undefined) {
 							compilation.valueCacheVersions.set(name, version);
@@ -589,6 +589,11 @@ class DefinePlugin {
 				};
 
 				walkDefinitionsForValues(definitions, "");
+
+				compilation.valueCacheVersions.set(
+					VALUE_DEP_MAIN,
+					/** @type {string} */ (mainHash.digest("hex").slice(0, 8))
+				);
 			}
 		);
 	}

package/lib/DependencyTemplates.js

@@ -48,8 +48,7 @@ class DependencyTemplates {
 	 */
 	updateHash(part) {
 		const hash = createHash(this._hashFunction);
-		hash.update(this._hash);
-		hash.update(part);
+		hash.update(`${this._hash}${part}`);
 		this._hash = /** @type {string} */ (hash.digest("hex"));
 	}
 

package/lib/DllModule.js

@@ -117,8 +117,7 @@ class DllModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		hash.update("dll module");
-		hash.update(this.name || "");
+		hash.update(`dll module${this.name || ""}`);
 		super.updateHash(hash, context);
 	}
 

package/lib/ExportsInfo.js

@@ -1412,10 +1412,11 @@ class ExportInfo {
 	}
 
 	_updateHash(hash, runtime, alreadyVisitedExportsInfo) {
-		hash.update(`${this._usedName || this.name}`);
-		hash.update(`${this.getUsed(runtime)}`);
-		hash.update(`${this.provided}`);
-		hash.update(`${this.terminalBinding}`);
+		hash.update(
+			`${this._usedName || this.name}${this.getUsed(runtime)}${this.provided}${
+				this.terminalBinding
+			}`
+		);
 		if (this.exportsInfo && !alreadyVisitedExportsInfo.has(this.exportsInfo)) {
 			this.exportsInfo._updateHash(hash, runtime, alreadyVisitedExportsInfo);
 		}

package/lib/ExternalModule.js

@@ -32,6 +32,7 @@ const { register } = require("./util/serialization");
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("./Module").LibIdentOptions} LibIdentOptions */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
@@ -497,6 +498,10 @@ class ExternalModule extends Module {
 		callback();
 	}
 
+	restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory) {
+		this._restoreFromUnsafeCache(unsafeCacheData, normalModuleFactory);
+	}
+
 	/**
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
@@ -679,10 +684,10 @@ class ExternalModule extends Module {
 	 */
 	updateHash(hash, context) {
 		const { chunkGraph } = context;
-		hash.update(this.externalType);
-		hash.update(JSON.stringify(this.request));
 		hash.update(
-			JSON.stringify(Boolean(this.isOptional(chunkGraph.moduleGraph)))
+			`${this.externalType}${JSON.stringify(this.request)}${this.isOptional(
+				chunkGraph.moduleGraph
+			)}`
 		);
 		super.updateHash(hash, context);
 	}

package/lib/FlagDependencyUsagePlugin.js

@@ -46,10 +46,15 @@ class FlagDependencyUsagePlugin {
 					stage: STAGE_DEFAULT
 				},
 				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.usedExports can't be used with cacheUnaffected as export usage is a global effect"
+						);
+					}
+
 					const logger = compilation.getLogger(
 						"webpack.FlagDependencyUsagePlugin"
 					);
-
 					/** @type {Map<ExportsInfo, Module>} */
 					const exportInfoToModuleMap = new Map();
 

package/lib/ModuleGraph.js

@@ -29,7 +29,7 @@ const EMPTY_SET = new Set();
 
 /**
  * @param {SortableSet<ModuleGraphConnection>} set input
- * @returns {readonly Map<Module, readonly ModuleGraphConnection[]>} mapped by origin module
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by origin module
  */
 const getConnectionsByOriginModule = set => {
 	const map = new Map();
@@ -57,11 +57,41 @@ const getConnectionsByOriginModule = set => {
 	return map;
 };
 
+/**
+ * @param {SortableSet<ModuleGraphConnection>} set input
+ * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} mapped by module
+ */
+const getConnectionsByModule = set => {
+	const map = new Map();
+	/** @type {Module | 0} */
+	let lastModule = 0;
+	/** @type {ModuleGraphConnection[]} */
+	let lastList = undefined;
+	for (const connection of set) {
+		const { module } = connection;
+		if (lastModule === module) {
+			lastList.push(connection);
+		} else {
+			lastModule = module;
+			const list = map.get(module);
+			if (list !== undefined) {
+				lastList = list;
+				list.push(connection);
+			} else {
+				const list = [connection];
+				lastList = list;
+				map.set(module, list);
+			}
+		}
+	}
+	return map;
+};
+
 class ModuleGraphModule {
 	constructor() {
 		/** @type {SortableSet<ModuleGraphConnection>} */
 		this.incomingConnections = new SortableSet();
-		/** @type {Set<ModuleGraphConnection> | undefined} */
+		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
 		this.outgoingConnections = undefined;
 		/** @type {Module | null} */
 		this.issuer = undefined;
@@ -104,7 +134,7 @@ class ModuleGraph {
 		/** @type {WeakTupleMap<any[], any>} */
 		this._cache = undefined;
 
-		/** @type {WeakMap<Module, WeakTupleMap<any, any>>} */
+		/** @type {Map<Module, WeakTupleMap<any, any>>} */
 		this._moduleMemCaches = undefined;
 	}
 
@@ -180,7 +210,7 @@ class ModuleGraph {
 			}
 			mgm._unassignedConnections.push(connection);
 			if (mgm.outgoingConnections === undefined) {
-				mgm.outgoingConnections = new Set();
+				mgm.outgoingConnections = new SortableSet();
 			}
 			mgm.outgoingConnections.add(connection);
 		} else {
@@ -282,7 +312,7 @@ class ModuleGraph {
 		const oldConnections = oldMgm.outgoingConnections;
 		if (oldConnections !== undefined) {
 			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new Set();
+				newMgm.outgoingConnections = new SortableSet();
 			}
 			const newConnections = newMgm.outgoingConnections;
 			for (const connection of oldConnections) {
@@ -319,7 +349,7 @@ class ModuleGraph {
 		const oldConnections = oldMgm.outgoingConnections;
 		if (oldConnections !== undefined) {
 			if (newMgm.outgoingConnections === undefined) {
-				newMgm.outgoingConnections = new Set();
+				newMgm.outgoingConnections = new SortableSet();
 			}
 			const newConnections = newMgm.outgoingConnections;
 			for (const connection of oldConnections) {
@@ -434,13 +464,24 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {readonly Map<Module, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
 	 */
 	getIncomingConnectionsByOriginModule(module) {
 		const connections = this._getModuleGraphModule(module).incomingConnections;
 		return connections.getFromUnorderedCache(getConnectionsByOriginModule);
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]> | undefined} connections to modules, in a map by module
+	 */
+	getOutgoingConnectionsByModule(module) {
+		const connections = this._getModuleGraphModule(module).outgoingConnections;
+		return connections === undefined
+			? undefined
+			: connections.getFromUnorderedCache(getConnectionsByModule);
+	}
+
 	/**
 	 * @param {Module} module the module
 	 * @returns {ModuleProfile | null} the module profile
@@ -728,7 +769,7 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {WeakMap<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
+	 * @param {Map<Module, WeakTupleMap<any, any>>} moduleMemCaches mem caches for modules for better caching
 	 */
 	setModuleMemCaches(moduleMemCaches) {
 		this._moduleMemCaches = moduleMemCaches;

package/lib/WebpackOptionsApply.js

@@ -550,7 +550,7 @@ class WebpackOptionsApply extends OptionsApply {
 								"'cache.cacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
 							);
 						}
-						compiler.moduleMemCaches = new WeakMap();
+						compiler.moduleMemCaches = new Map();
 					}
 					break;
 				}
@@ -577,7 +577,7 @@ class WebpackOptionsApply extends OptionsApply {
 								"'cache.memoryCacheUnaffected: true' is only allowed when 'experiments.cacheUnaffected' is enabled"
 							);
 						}
-						compiler.moduleMemCaches = new WeakMap();
+						compiler.moduleMemCaches = new Map();
 					}
 					switch (cacheOptions.store) {
 						case "pack": {

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -137,11 +137,9 @@ class ArrayPushCallbackChunkFormatPlugin {
 					"ArrayPushCallbackChunkFormatPlugin",
 					(chunk, hash, { chunkGraph, runtimeTemplate }) => {
 						if (chunk.hasRuntime()) return;
-						hash.update("ArrayPushCallbackChunkFormatPlugin");
-						hash.update("1");
-						hash.update(`${runtimeTemplate.outputOptions.chunkLoadingGlobal}`);
-						hash.update(`${runtimeTemplate.outputOptions.hotUpdateGlobal}`);
-						hash.update(`${runtimeTemplate.outputOptions.globalObject}`);
+						hash.update(
+							`ArrayPushCallbackChunkFormatPlugin1${runtimeTemplate.outputOptions.chunkLoadingGlobal}${runtimeTemplate.outputOptions.hotUpdateGlobal}${runtimeTemplate.outputOptions.globalObject}`
+						);
 						const entries = Array.from(
 							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
 						);

package/lib/optimize/MangleExportsPlugin.js

@@ -157,6 +157,11 @@ class MangleExportsPlugin {
 			compilation.hooks.optimizeCodeGeneration.tap(
 				"MangleExportsPlugin",
 				modules => {
+					if (compilation.moduleMemCaches) {
+						throw new Error(
+							"optimization.mangleExports can't be used with cacheUnaffected as export mangling is a global effect"
+						);
+					}
 					for (const module of modules) {
 						const isNamespace =
 							module.buildMeta && module.buildMeta.exportsType === "namespace";

package/lib/util/StringXor.js

@@ -8,41 +8,47 @@
 class StringXor {
 	constructor() {
 		this._value = undefined;
-		this._buffer = undefined;
 	}
 
+	/**
+	 * @param {string} str string
+	 * @returns {void}
+	 */
 	add(str) {
-		let buf = this._buffer;
-		let value;
-		if (buf === undefined) {
-			buf = this._buffer = Buffer.from(str, "latin1");
-			this._value = Buffer.from(buf);
+		const len = str.length;
+		const value = this._value;
+		if (value === undefined) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			for (let i = 0; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
+			}
 			return;
-		} else if (buf.length !== str.length) {
-			value = this._value;
-			buf = this._buffer = Buffer.from(str, "latin1");
-			if (value.length < buf.length) {
-				this._value = Buffer.allocUnsafe(buf.length);
-				value.copy(this._value);
-				this._value.fill(0, value.length);
-				value = this._value;
+		}
+		const valueLen = value.length;
+		if (valueLen < len) {
+			const newValue = (this._value = Buffer.allocUnsafe(len));
+			let i;
+			for (i = 0; i < valueLen; i++) {
+				newValue[i] = value[i] ^ str.charCodeAt(i);
+			}
+			for (; i < len; i++) {
+				newValue[i] = str.charCodeAt(i);
 			}
 		} else {
-			value = this._value;
-			buf.write(str, "latin1");
-		}
-		const len = buf.length;
-		for (let i = 0; i < len; i++) {
-			value[i] = value[i] ^ buf[i];
+			for (let i = 0; i < len; i++) {
+				value[i] = value[i] ^ str.charCodeAt(i);
+			}
 		}
 	}
 
 	toString() {
-		return this._value === undefined ? "" : this._value.toString("latin1");
+		const value = this._value;
+		return value === undefined ? "" : value.toString("latin1");
 	}
 
 	updateHash(hash) {
-		if (this._value !== undefined) hash.update(this._value);
+		const value = this._value;
+		if (value !== undefined) hash.update(value);
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.55.0",
+  "version": "5.57.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",

package/types.d.ts

@@ -1460,7 +1460,8 @@ declare class Compilation {
 	chunkTemplate: ChunkTemplate;
 	runtimeTemplate: RuntimeTemplate;
 	moduleTemplates: { javascript: ModuleTemplate };
-	moduleMemCaches?: WeakMap<Module, WeakTupleMap<any, any>>;
+	moduleMemCaches?: Map<Module, WeakTupleMap<any, any>>;
+	moduleMemCaches2?: Map<Module, WeakTupleMap<any, any>>;
 	moduleGraph: ModuleGraph;
 	chunkGraph: ChunkGraph;
 	codeGenerationResults: CodeGenerationResults;
@@ -1907,9 +1908,13 @@ declare class Compiler {
 	context: string;
 	requestShortener: RequestShortener;
 	cache: Cache;
-	moduleMemCaches?: WeakMap<
+	moduleMemCaches?: Map<
 		Module,
-		{ hash: string; memCache: WeakTupleMap<any, any> }
+		{
+			buildInfo: object;
+			references: WeakMap<Dependency, Module>;
+			memCache: WeakTupleMap<any, any>;
+		}
 	>;
 	compilerPath: string;
 	running: boolean;
@@ -3737,6 +3742,10 @@ declare class ExternalModule extends Module {
 	request: string | string[] | Record<string, string | string[]>;
 	externalType: string;
 	userRequest: string;
+	restoreFromUnsafeCache(
+		unsafeCacheData?: any,
+		normalModuleFactory?: any
+	): void;
 }
 declare interface ExternalModuleInfo {
 	index: number;
@@ -6695,7 +6704,10 @@ declare class ModuleGraph {
 	getOutgoingConnections(module: Module): Iterable<ModuleGraphConnection>;
 	getIncomingConnectionsByOriginModule(
 		module: Module
-	): Map<Module, ReadonlyArray<ModuleGraphConnection>>;
+	): Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
+	getOutgoingConnectionsByModule(
+		module: Module
+	): undefined | Map<undefined | Module, ReadonlyArray<ModuleGraphConnection>>;
 	getProfile(module: Module): null | ModuleProfile;
 	setProfile(module: Module, profile: null | ModuleProfile): void;
 	getIssuer(module: Module): null | Module;
@@ -6736,7 +6748,7 @@ declare class ModuleGraph {
 		...args: T
 	): V;
 	setModuleMemCaches(
-		moduleMemCaches: WeakMap<Module, WeakTupleMap<any, any>>
+		moduleMemCaches: Map<Module, WeakTupleMap<any, any>>
 	): void;
 	dependencyCacheProvide(dependency: Dependency, ...args: any[]): any;
 	static getModuleGraphForModule(