webpack 5.56.0 → 5.58.0

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;
@@ -93,18 +123,10 @@ class ModuleGraph {
 		/** @type {WeakMap<any, Object>} */
 		this._metaMap = new WeakMap();
 
-		// Caching
-		this._cacheModuleGraphModuleKey1 = undefined;
-		this._cacheModuleGraphModuleValue1 = undefined;
-		this._cacheModuleGraphModuleKey2 = undefined;
-		this._cacheModuleGraphModuleValue2 = undefined;
-		this._cacheModuleGraphDependencyKey = undefined;
-		this._cacheModuleGraphDependencyValue = undefined;
-
 		/** @type {WeakTupleMap<any[], any>} */
 		this._cache = undefined;
 
-		/** @type {WeakMap<Module, WeakTupleMap<any, any>>} */
+		/** @type {Map<Module, WeakTupleMap<any, any>>} */
 		this._moduleMemCaches = undefined;
 	}
 
@@ -113,19 +135,11 @@ class ModuleGraph {
 	 * @returns {ModuleGraphModule} the internal module
 	 */
 	_getModuleGraphModule(module) {
-		if (this._cacheModuleGraphModuleKey1 === module)
-			return this._cacheModuleGraphModuleValue1;
-		if (this._cacheModuleGraphModuleKey2 === module)
-			return this._cacheModuleGraphModuleValue2;
 		let mgm = this._moduleMap.get(module);
 		if (mgm === undefined) {
 			mgm = new ModuleGraphModule();
 			this._moduleMap.set(module, mgm);
 		}
-		this._cacheModuleGraphModuleKey2 = this._cacheModuleGraphModuleKey1;
-		this._cacheModuleGraphModuleValue2 = this._cacheModuleGraphModuleValue1;
-		this._cacheModuleGraphModuleKey1 = module;
-		this._cacheModuleGraphModuleValue1 = mgm;
 		return mgm;
 	}
 
@@ -133,9 +147,11 @@ class ModuleGraph {
 	 * @param {Dependency} dependency the dependency
 	 * @param {DependenciesBlock} block parent block
 	 * @param {Module} module parent module
+	 * @param {number=} indexInBlock position in block
 	 * @returns {void}
 	 */
-	setParents(dependency, block, module) {
+	setParents(dependency, block, module, indexInBlock = -1) {
+		dependency._parentDependenciesBlockIndex = indexInBlock;
 		dependency._parentDependenciesBlock = block;
 		dependency._parentModule = module;
 	}
@@ -156,6 +172,14 @@ class ModuleGraph {
 		return dependency._parentDependenciesBlock;
 	}
 
+	/**
+	 * @param {Dependency} dependency the dependency
+	 * @returns {number} index
+	 */
+	getParentBlockIndex(dependency) {
+		return dependency._parentDependenciesBlockIndex;
+	}
+
 	/**
 	 * @param {Module} originModule the referencing module
 	 * @param {Dependency} dependency the referencing dependency
@@ -180,7 +204,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 +306,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 +343,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 +458,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 +763,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/NormalModule.js

@@ -37,6 +37,7 @@ const {
 	keepOriginalOrder
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
+const { createFakeHook } = require("./util/deprecation");
 const { join } = require("./util/fs");
 const {
 	contextify,
@@ -187,6 +188,7 @@ makeSerializable(
  * @property {SyncHook<[object, NormalModule]>} loader
  * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
  * @property {HookMap<AsyncSeriesBailHook<[string, NormalModule], string | Buffer>>} readResourceForScheme
+ * @property {HookMap<AsyncSeriesBailHook<[object], string | Buffer>>} readResource
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
@@ -209,8 +211,28 @@ class NormalModule extends Module {
 			hooks = {
 				loader: new SyncHook(["loaderContext", "module"]),
 				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-				readResourceForScheme: new HookMap(
-					() => new AsyncSeriesBailHook(["resource", "module"])
+				// TODO webpack 6 deprecate
+				readResourceForScheme: new HookMap(scheme => {
+					const hook = hooks.readResource.for(scheme);
+					return createFakeHook(
+						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer>} */ ({
+							tap: (options, fn) =>
+								hook.tap(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								),
+							tapAsync: (options, fn) =>
+								hook.tapAsync(options, (loaderContext, callback) =>
+									fn(loaderContext.resource, loaderContext._module, callback)
+								),
+							tapPromise: (options, fn) =>
+								hook.tapPromise(options, loaderContext =>
+									fn(loaderContext.resource, loaderContext._module)
+								)
+						})
+					);
+				}),
+				readResource: new HookMap(
+					() => new AsyncSeriesBailHook(["loaderContext"])
 				),
 				needBuild: new AsyncSeriesBailHook(["module", "context"])
 			};
@@ -786,20 +808,15 @@ class NormalModule extends Module {
 				processResource: (loaderContext, resourcePath, callback) => {
 					const resource = loaderContext.resource;
 					const scheme = getScheme(resource);
-					if (scheme) {
-						hooks.readResourceForScheme
-							.for(scheme)
-							.callAsync(resource, this, (err, result) => {
-								if (err) return callback(err);
-								if (typeof result !== "string" && !result) {
-									return callback(new UnhandledSchemeError(scheme, resource));
-								}
-								return callback(null, result);
-							});
-					} else {
-						loaderContext.addDependency(resourcePath);
-						fs.readFile(resourcePath, callback);
-					}
+					hooks.readResource
+						.for(scheme)
+						.callAsync(loaderContext, (err, result) => {
+							if (err) return callback(err);
+							if (typeof result !== "string" && !result) {
+								return callback(new UnhandledSchemeError(scheme, resource));
+							}
+							return callback(null, result);
+						});
 				}
 			},
 			(err, result) => {

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/buildChunkGraph.js

@@ -43,7 +43,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {boolean} minAvailableModulesOwned true, if minAvailableModules is owned and can be modified
  * @property {ModuleSetPlus[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
  * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
- * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
+ * @property {Set<[Module, ConnectionState]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
  * @property {ModuleSetPlus} resultingAvailableModules set of modules available including modules from this chunk group
  * @property {Set<ChunkGroupInfo>} children set of children chunk groups, that will be revisited when availableModules shrink
  * @property {Set<ChunkGroupInfo>} availableSources set of chunk groups that are the source for minAvailableModules
@@ -70,97 +70,106 @@ const bySetSize = (a, b) => {
 	return b.size + b.plus.size - a.size - a.plus.size;
 };
 
-/**
- *
- * @param {ModuleGraphConnection[]} connections list of connections
- * @param {RuntimeSpec} runtime for which runtime
- * @returns {ConnectionState} connection state
- */
-const getActiveStateOfConnections = (connections, runtime) => {
-	let merged = connections[0].getActiveState(runtime);
-	if (merged === true) return true;
-	for (let i = 1; i < connections.length; i++) {
-		const c = connections[i];
-		merged = ModuleGraphConnection.addConnectionStates(
-			merged,
-			c.getActiveState(runtime)
-		);
-		if (merged === true) return true;
+const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
+	let blockCache;
+	let modules;
+
+	const arrays = [];
+
+	const queue = [module];
+	while (queue.length > 0) {
+		const block = queue.pop();
+		const arr = [];
+		arrays.push(arr);
+		blockModulesMap.set(block, arr);
+		for (const b of block.blocks) {
+			queue.push(b);
+		}
 	}
-	return merged;
-};
 
-/**
- * Extracts block to modules mapping from all modules
- * @param {Compilation} compilation the compilation
- * @returns {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} the mapping block to modules
- */
-const extractBlockModulesMap = compilation => {
-	const { moduleGraph } = compilation;
-
-	/** @type {Map<DependenciesBlock, Map<Module, ModuleGraphConnection[]>>} */
-	const blockModulesMap = new Map();
-
-	const blockQueue = new Set();
-
-	for (const module of compilation.modules) {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection>} */
-		let moduleMap;
-
-		for (const connection of moduleGraph.getOutgoingConnections(module)) {
-			const d = connection.dependency;
-			// We skip connections without dependency
-			if (!d) continue;
-			const m = connection.module;
-			// We skip connections without Module pointer
-			if (!m) continue;
-			// We skip weak connections
-			if (connection.weak) continue;
-			const state = connection.getActiveState(undefined);
-			// We skip inactive connections
-			if (state === false) continue;
-			// Store Dependency to Module mapping in local map
-			// to allow to access it faster compared to
-			// moduleGraph.getConnection()
-			if (moduleMap === undefined) {
-				moduleMap = new WeakMap();
-			}
-			moduleMap.set(connection.dependency, connection);
+	for (const connection of moduleGraph.getOutgoingConnections(module)) {
+		const d = connection.dependency;
+		// We skip connections without dependency
+		if (!d) continue;
+		const m = connection.module;
+		// We skip connections without Module pointer
+		if (!m) continue;
+		// We skip weak connections
+		if (connection.weak) continue;
+		const state = connection.getActiveState(runtime);
+		// We skip inactive connections
+		if (state === false) continue;
+
+		const block = moduleGraph.getParentBlock(d);
+		let index = moduleGraph.getParentBlockIndex(d);
+
+		// deprecated fallback
+		if (index < 0) {
+			index = block.dependencies.indexOf(d);
 		}
 
-		blockQueue.clear();
-		blockQueue.add(module);
-		for (const block of blockQueue) {
-			let modules;
-
-			if (moduleMap !== undefined && block.dependencies) {
-				for (const dep of block.dependencies) {
-					const connection = moduleMap.get(dep);
-					if (connection !== undefined) {
-						const { module } = connection;
-						if (modules === undefined) {
-							modules = new Map();
-							blockModulesMap.set(block, modules);
-						}
-						const old = modules.get(module);
-						if (old !== undefined) {
-							old.push(connection);
-						} else {
-							modules.set(module, [connection]);
-						}
+		if (blockCache !== block) {
+			modules = blockModulesMap.get((blockCache = block));
+		}
+
+		const i = index << 2;
+		modules[i] = m;
+		modules[i + 1] = state;
+	}
+
+	for (const modules of arrays) {
+		if (modules.length === 0) continue;
+		let indexMap;
+		let length = 0;
+		outer: for (let j = 0; j < modules.length; j += 2) {
+			const m = modules[j];
+			if (m === undefined) continue;
+			const state = modules[j + 1];
+			if (indexMap === undefined) {
+				let i = 0;
+				for (; i < length; i += 2) {
+					if (modules[i] === m) {
+						const merged = modules[i + 1];
+						if (merged === true) continue outer;
+						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
+							merged,
+							state
+						);
 					}
 				}
-			}
-
-			if (block.blocks) {
-				for (const b of block.blocks) {
-					blockQueue.add(b);
+				modules[length] = m;
+				length++;
+				modules[length] = state;
+				length++;
+				if (length > 30) {
+					// To avoid worse case performance, we will use an index map for
+					// linear cost access, which allows to maintain O(n) complexity
+					// while keeping allocations down to a minimum
+					indexMap = new Map();
+					for (let i = 0; i < length; i += 2) {
+						indexMap.set(modules[i], i + 1);
+					}
+				}
+			} else {
+				const idx = indexMap.get(m);
+				if (idx !== undefined) {
+					const merged = modules[idx];
+					if (merged === true) continue outer;
+					modules[idx] = ModuleGraphConnection.addConnectionStates(
+						merged,
+						state
+					);
+				} else {
+					modules[length] = m;
+					length++;
+					modules[length] = state;
+					indexMap.set(m, length);
+					length++;
 				}
 			}
 		}
+		modules.length = length;
 	}
-
-	return blockModulesMap;
 };
 
 /**
@@ -182,10 +191,55 @@ const visitModules = (
 	blocksWithNestedBlocks,
 	allCreatedChunkGroups
 ) => {
-	const { moduleGraph, chunkGraph } = compilation;
+	const { moduleGraph, chunkGraph, moduleMemCaches } = compilation;
 
-	logger.time("visitModules: prepare");
-	const blockModulesMap = extractBlockModulesMap(compilation);
+	const blockModulesRuntimeMap = new Map();
+
+	/** @type {RuntimeSpec | false} */
+	let blockModulesMapRuntime = false;
+	let blockModulesMap;
+
+	/**
+	 *
+	 * @param {DependenciesBlock} block block
+	 * @param {RuntimeSpec} runtime runtime
+	 * @returns {(Module | ConnectionState)[]} block modules in flatten tuples
+	 */
+	const getBlockModules = (block, runtime) => {
+		if (blockModulesMapRuntime !== runtime) {
+			blockModulesMap = blockModulesRuntimeMap.get(runtime);
+			if (blockModulesMap === undefined) {
+				blockModulesMap = new Map();
+				blockModulesRuntimeMap.set(runtime, blockModulesMap);
+			}
+		}
+		let blockModules = blockModulesMap.get(block);
+		if (blockModules !== undefined) return blockModules;
+		const module = /** @type {Module} */ (block.getRootBlock());
+		const memCache = moduleMemCaches && moduleMemCaches.get(module);
+		if (memCache !== undefined) {
+			const map = memCache.provide(
+				"bundleChunkGraph.blockModules",
+				runtime,
+				() => {
+					logger.time("visitModules: prepare");
+					const map = new Map();
+					extractBlockModules(module, moduleGraph, runtime, map);
+					logger.timeAggregate("visitModules: prepare");
+					return map;
+				}
+			);
+			for (const [block, blockModules] of map)
+				blockModulesMap.set(block, blockModules);
+			return map.get(block);
+		} else {
+			logger.time("visitModules: prepare");
+			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+			blockModules = blockModulesMap.get(block);
+			logger.timeAggregate("visitModules: prepare");
+			return blockModules;
+		}
+	};
 
 	let statProcessedQueueItems = 0;
 	let statProcessedBlocks = 0;
@@ -308,9 +362,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
 
-	logger.timeEnd("visitModules: prepare");
-
-	/** @type {[Module, ModuleGraphConnection[]][]} */
+	/** @type {[Module, ConnectionState][]} */
 	const skipConnectionBuffer = [];
 	/** @type {Module[]} */
 	const skipBuffer = [];
@@ -478,21 +530,23 @@ const visitModules = (
 	const processBlock = block => {
 		statProcessedBlocks++;
 		// get prepared block info
-		const blockModules = blockModulesMap.get(block);
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
-			const { minAvailableModules, runtime } = chunkGroupInfo;
+			const { minAvailableModules } = chunkGroupInfo;
 			// Buffer items because order need to be reversed to get indices correct
 			// Traverse all referenced modules
-			for (const entry of blockModules) {
-				const [refModule, connections] = entry;
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
 				if (chunkGraph.isModuleInChunk(refModule, chunk)) {
 					// skip early if already connected
 					continue;
 				}
-				const activeState = getActiveStateOfConnections(connections, runtime);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
 				if (activeState !== true) {
-					skipConnectionBuffer.push(entry);
+					skipConnectionBuffer.push([refModule, activeState]);
 					if (activeState === false) continue;
 				}
 				if (
@@ -562,12 +616,15 @@ const visitModules = (
 	const processEntryBlock = block => {
 		statProcessedBlocks++;
 		// get prepared block info
-		const blockModules = blockModulesMap.get(block);
+		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
 			// Traverse all referenced modules
-			for (const [refModule, connections] of blockModules) {
-				const activeState = getActiveStateOfConnections(connections, undefined);
+			for (let i = 0; i < blockModules.length; i += 2) {
+				const refModule = /** @type {Module} */ (blockModules[i]);
+				const activeState = /** @type {ConnectionState} */ (
+					blockModules[i + 1]
+				);
 				// enqueue, then add and enter to be in the correct order
 				// this is relevant with circular dependencies
 				queueBuffer.push({
@@ -1059,10 +1116,9 @@ const visitModules = (
 
 			// 2. Reconsider skipped connections
 			if (info.skippedModuleConnections !== undefined) {
-				const { minAvailableModules, runtime } = info;
+				const { minAvailableModules } = info;
 				for (const entry of info.skippedModuleConnections) {
-					const [module, connections] = entry;
-					const activeState = getActiveStateOfConnections(connections, runtime);
+					const [module, activeState] = entry;
 					if (activeState === false) continue;
 					if (activeState === true) {
 						info.skippedModuleConnections.delete(entry);
@@ -1114,6 +1170,7 @@ const visitModules = (
 	while (queue.length || queueConnect.size) {
 		logger.time("visitModules: visiting");
 		processQueue();
+		logger.timeAggregateEnd("visitModules: prepare");
 		logger.timeEnd("visitModules: visiting");
 
 		if (chunkGroupsForCombining.size > 0) {

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/logging/Logger.js

@@ -155,6 +155,7 @@ class WebpackLogger {
 		if (this[TIMERS_AGGREGATES_SYMBOL] === undefined) return;
 		const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
 		if (time === undefined) return;
+		this[TIMERS_AGGREGATES_SYMBOL].delete(label);
 		this[LOG_SYMBOL](LogType.time, [label, ...time]);
 	}
 }

package/lib/node/NodeTargetPlugin.js

@@ -19,6 +19,7 @@ const builtins = [
 	"constants",
 	"crypto",
 	"dgram",
+	"diagnostics_channel",
 	"dns",
 	"dns/promises",
 	"domain",

package/lib/optimize/EnsureChunkConditionsPlugin.js

@@ -30,6 +30,7 @@ class EnsureChunkConditionsPlugin {
 					/** @type {Set<ChunkGroup>} */
 					const chunkGroups = new Set();
 					for (const module of compilation.modules) {
+						if (!module.hasChunkCondition()) continue;
 						for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
 							if (!module.chunkCondition(chunk, compilation)) {
 								sourceChunks.add(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";