webpack 5.93.0 → 5.95.0

package/lib/buildChunkGraph.js

@@ -38,6 +38,7 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @typedef {object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
+ * @property {boolean} initialized is this chunk group initialized
  * @property {bigint | undefined} minAvailableModules current minimal set of modules available at this point
  * @property {bigint[]} 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)
@@ -209,7 +210,7 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					const merged = /** @type {ConnectionState} */ (modules[idx]);
 					/** @type {ModuleGraphConnection[]} */
 					(/** @type {unknown} */ (modules[idx + 1])).push(connection);
-					if (merged === true) continue outer;
+					if (merged === true) continue;
 					modules[idx] = ModuleGraphConnection.addConnectionStates(
 						merged,
 						state
@@ -234,7 +235,6 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 };
 
 /**
- *
  * @param {Logger} logger a logger
  * @param {Compilation} compilation the compilation
  * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules
@@ -286,7 +286,6 @@ const visitModules = (
 	}
 
 	/**
-	 *
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
 	 * @returns {BlockModulesInFlattenTuples} block modules in flatten tuples
@@ -316,15 +315,14 @@ const visitModules = (
 			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 =
-				/** @type {BlockModulesInFlattenTuples} */
-				(blockModulesMap.get(block));
-			logger.timeAggregate("visitModules: prepare");
-			return blockModules;
 		}
+		logger.time("visitModules: prepare");
+		extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
+		blockModules =
+			/** @type {BlockModulesInFlattenTuples} */
+			(blockModulesMap.get(block));
+		logger.timeAggregate("visitModules: prepare");
+		return blockModules;
 	};
 
 	let statProcessedQueueItems = 0;
@@ -332,12 +330,12 @@ const visitModules = (
 	let statConnectedChunkGroups = 0;
 	let statProcessedChunkGroupsForMerging = 0;
 	let statMergedAvailableModuleSets = 0;
-	let statForkedAvailableModules = 0;
-	let statForkedAvailableModulesCount = 0;
-	let statForkedAvailableModulesCountPlus = 0;
-	let statForkedMergedModulesCount = 0;
-	let statForkedMergedModulesCountPlus = 0;
-	let statForkedResultModulesCount = 0;
+	const statForkedAvailableModules = 0;
+	const statForkedAvailableModulesCount = 0;
+	const statForkedAvailableModulesCountPlus = 0;
+	const statForkedMergedModulesCount = 0;
+	const statForkedMergedModulesCountPlus = 0;
+	const statForkedResultModulesCount = 0;
 	let statChunkGroupInfoUpdated = 0;
 	let statChildChunkGroupsReconnected = 0;
 
@@ -348,8 +346,8 @@ const visitModules = (
 	/** @type {Map<DependenciesBlock, ChunkGroupInfo>} */
 	const blockChunkGroups = new Map();
 
-	/** @type {Map<ChunkGroupInfo, DependenciesBlock>} */
-	const blockByChunkGroups = new Map();
+	/** @type {Map<ChunkGroupInfo, Set<DependenciesBlock>>} */
+	const blocksByChunkGroups = new Map();
 
 	/** @type {Map<string, ChunkGroupInfo>} */
 	const namedChunkGroups = new Map();
@@ -370,7 +368,7 @@ const visitModules = (
 	/** @type {QueueItem[]} */
 	let queue = [];
 
-	/** @type {Map<ChunkGroupInfo, Set<ChunkGroupInfo>>} */
+	/** @type {Map<ChunkGroupInfo, Set<[ChunkGroupInfo, QueueItem | null]>>} */
 	const queueConnect = new Map();
 	/** @type {Set<ChunkGroupInfo>} */
 	const chunkGroupsForCombining = new Set();
@@ -385,6 +383,7 @@ const visitModules = (
 		);
 		/** @type {ChunkGroupInfo} */
 		const chunkGroupInfo = {
+			initialized: false,
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
@@ -455,7 +454,7 @@ const visitModules = (
 
 	/** @type {Set<ChunkGroupInfo>} */
 	const outdatedChunkGroupInfo = new Set();
-	/** @type {Set<ChunkGroupInfo>} */
+	/** @type {Set<[ChunkGroupInfo, QueueItem]>} */
 	const chunkGroupsForMerging = new Set();
 	/** @type {QueueItem[]} */
 	let queueDelayed = [];
@@ -508,6 +507,7 @@ const visitModules = (
 					entrypoint.index = nextChunkGroupIndex++;
 					cgi = {
 						chunkGroup: entrypoint,
+						initialized: false,
 						runtime: entrypoint.options.runtime || entrypoint.name,
 						minAvailableModules: ZERO_BIGINT,
 						availableModulesToBeMerged: [],
@@ -575,6 +575,7 @@ const visitModules = (
 					maskByChunk.set(c.chunks[0], ZERO_BIGINT);
 					c.index = nextChunkGroupIndex++;
 					cgi = {
+						initialized: false,
 						chunkGroup: c,
 						runtime: chunkGroupInfo.runtime,
 						minAvailableModules: undefined,
@@ -617,7 +618,6 @@ const visitModules = (
 				blockConnections.set(b, []);
 			}
 			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
-			blockByChunkGroups.set(/** @type {ChunkGroupInfo} */ (cgi), b);
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -639,19 +639,17 @@ const visitModules = (
 				connectList = new Set();
 				queueConnect.set(chunkGroupInfo, connectList);
 			}
-			connectList.add(/** @type {ChunkGroupInfo} */ (cgi));
-
-			// TODO check if this really need to be done for each traversal
-			// or if it is enough when it's queued when created
-			// 4. We enqueue the DependenciesBlock for traversal
-			queueDelayed.push({
-				action: PROCESS_BLOCK,
-				block: b,
-				module,
-				chunk: c.chunks[0],
-				chunkGroup: c,
-				chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
-			});
+			connectList.add([
+				cgi,
+				{
+					action: PROCESS_BLOCK,
+					block: b,
+					module,
+					chunk: c.chunks[0],
+					chunkGroup: c,
+					chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
+				}
+			]);
 		} else if (entrypoint !== undefined) {
 			chunkGroupInfo.chunkGroup.addAsyncEntrypoint(entrypoint);
 		}
@@ -904,11 +902,10 @@ const visitModules = (
 		for (const [chunkGroupInfo, targets] of queueConnect) {
 			// 1. Add new targets to the list of children
 			if (chunkGroupInfo.children === undefined) {
-				chunkGroupInfo.children = targets;
-			} else {
-				for (const target of targets) {
-					chunkGroupInfo.children.add(target);
-				}
+				chunkGroupInfo.children = new Set();
+			}
+			for (const [target] of targets) {
+				chunkGroupInfo.children.add(target);
 			}
 
 			// 2. Calculate resulting available modules
@@ -918,9 +915,9 @@ const visitModules = (
 			const runtime = chunkGroupInfo.runtime;
 
 			// 3. Update chunk group info
-			for (const target of targets) {
+			for (const [target, processBlock] of targets) {
 				target.availableModulesToBeMerged.push(resultingAvailableModules);
-				chunkGroupsForMerging.add(target);
+				chunkGroupsForMerging.add([target, processBlock]);
 				const oldRuntime = target.runtime;
 				const newRuntime = mergeRuntime(oldRuntime, runtime);
 				if (oldRuntime !== newRuntime) {
@@ -938,7 +935,7 @@ const visitModules = (
 		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
 
 		// Execute the merge
-		for (const info of chunkGroupsForMerging) {
+		for (const [info, processBlock] of chunkGroupsForMerging) {
 			const availableModulesToBeMerged = info.availableModulesToBeMerged;
 			const cachedMinAvailableModules = info.minAvailableModules;
 			let minAvailableModules = cachedMinAvailableModules;
@@ -961,6 +958,27 @@ const visitModules = (
 				info.resultingAvailableModules = undefined;
 				outdatedChunkGroupInfo.add(info);
 			}
+
+			if (processBlock) {
+				let blocks = blocksByChunkGroups.get(info);
+				if (!blocks) {
+					blocksByChunkGroups.set(info, (blocks = new Set()));
+				}
+
+				// Whether to walk block depends on minAvailableModules and input block.
+				// We can treat creating chunk group as a function with 2 input, entry block and minAvailableModules
+				// If input is the same, we can skip re-walk
+				let needWalkBlock = !info.initialized || changed;
+				if (!blocks.has(processBlock.block)) {
+					needWalkBlock = true;
+					blocks.add(processBlock.block);
+				}
+
+				if (needWalkBlock) {
+					info.initialized = true;
+					queueDelayed.push(processBlock);
+				}
+			}
 		}
 		chunkGroupsForMerging.clear();
 	};
@@ -1060,7 +1078,7 @@ const visitModules = (
 						connectList = new Set();
 						queueConnect.set(info, connectList);
 					}
-					connectList.add(cgi);
+					connectList.add([cgi, null]);
 				}
 			}
 
@@ -1120,48 +1138,44 @@ const visitModules = (
 	for (const info of outdatedOrderIndexChunkGroups) {
 		const { chunkGroup, runtime } = info;
 
-		const block = blockByChunkGroups.get(info);
+		const blocks = blocksByChunkGroups.get(info);
 
-		if (!block) {
+		if (!blocks) {
 			continue;
 		}
 
-		let preOrderIndex = 0;
-		let postOrderIndex = 0;
-
-		/**
-		 * @param {DependenciesBlock} current current
-		 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
-		 */
-		const process = (current, visited) => {
-			const blockModules = getBlockModules(current, runtime);
-			if (blockModules === undefined) {
-				return;
-			}
-
-			for (let i = 0, len = blockModules.length; i < len; i += 3) {
-				const activeState = /** @type {ConnectionState} */ (
-					blockModules[i + 1]
-				);
-				if (activeState === false) {
-					continue;
-				}
-				const refModule = /** @type {Module} */ (blockModules[i]);
-				if (visited.has(refModule)) {
-					continue;
-				}
+		for (const block of blocks) {
+			let preOrderIndex = 0;
+			let postOrderIndex = 0;
+			/**
+			 * @param {DependenciesBlock} current current
+			 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
+			 */
+			const process = (current, visited) => {
+				const blockModules = getBlockModules(current, runtime);
+				for (let i = 0, len = blockModules.length; i < len; i += 3) {
+					const activeState = /** @type {ConnectionState} */ (
+						blockModules[i + 1]
+					);
+					if (activeState === false) {
+						continue;
+					}
+					const refModule = /** @type {Module} */ (blockModules[i]);
+					if (visited.has(refModule)) {
+						continue;
+					}
 
-				visited.add(refModule);
+					visited.add(refModule);
 
-				if (refModule) {
-					chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
-					process(refModule, visited);
-					chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+					if (refModule) {
+						chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
+						process(refModule, visited);
+						chunkGroup.setModulePostOrderIndex(refModule, postOrderIndex++);
+					}
 				}
-			}
-		};
-
-		process(block, new Set());
+			};
+			process(block, new Set());
+		}
 	}
 	outdatedOrderIndexChunkGroups.clear();
 	ordinalByModule.clear();
@@ -1179,7 +1193,6 @@ const visitModules = (
 };
 
 /**
- *
  * @param {Compilation} compilation the compilation
  * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks
  * @param {BlockConnections} blockConnections connection for blocks
@@ -1195,7 +1208,6 @@ const connectChunkGroups = (
 
 	/**
 	 * Helper function to check if all modules of a chunk are available
-	 *
 	 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
 	 * @param {bigint} availableModules the comparator set
 	 * @returns {boolean} return true if all modules of a chunk are available

package/lib/cache/IdleFileCachePlugin.js

@@ -11,7 +11,7 @@ const ProgressPlugin = require("../ProgressPlugin");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
 
-const BUILD_DEPENDENCIES_KEY = Symbol();
+const BUILD_DEPENDENCIES_KEY = Symbol("build dependencies key");
 
 class IdleFileCachePlugin {
 	/**
@@ -38,7 +38,7 @@ class IdleFileCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		let strategy = this.strategy;
+		const strategy = this.strategy;
 		const idleTimeout = this.idleTimeout;
 		const idleTimeoutForInitialStore = Math.min(
 			idleTimeout,
@@ -119,7 +119,7 @@ class IdleFileCachePlugin {
 				currentIdlePromise = promise.then(() => strategy.afterAllStored());
 				if (reportProgress) {
 					currentIdlePromise = currentIdlePromise.then(() => {
-						reportProgress(1, `stored`);
+						reportProgress(1, "stored");
 					});
 				}
 				return currentIdlePromise.then(() => {
@@ -175,7 +175,7 @@ class IdleFileCachePlugin {
 			}
 		};
 		/** @type {ReturnType<typeof setTimeout> | undefined} */
-		let idleTimer = undefined;
+		let idleTimer;
 		compiler.cache.hooks.beginIdle.tap(
 			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
 			() => {

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -20,6 +20,7 @@ class MemoryWithGcCachePlugin {
 	constructor({ maxGenerations }) {
 		this._maxGenerations = maxGenerations;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -106,12 +107,11 @@ class MemoryWithGcCachePlugin {
 						oldCache.delete(identifier);
 						cache.set(identifier, cacheEntry);
 						return null;
-					} else {
-						if (cacheEntry.etag !== etag) return null;
-						oldCache.delete(identifier);
-						cache.set(identifier, cacheEntry);
-						return cacheEntry.data;
 					}
+					if (cacheEntry.etag !== etag) return null;
+					oldCache.delete(identifier);
+					cache.set(identifier, cacheEntry);
+					return cacheEntry.data;
 				}
 				gotHandlers.push((result, callback) => {
 					if (result === undefined) {

package/lib/cache/PackFileCacheStrategy.js

@@ -160,19 +160,18 @@ class Pack {
 		const info = this.itemInfo.get(identifier);
 		this._addRequest(identifier);
 		if (info === undefined) {
-			return undefined;
+			return;
 		}
 		if (info.etag !== etag) return null;
 		info.lastAccess = Date.now();
 		const loc = info.location;
 		if (loc === -1) {
 			return info.freshValue;
-		} else {
-			if (!this.content[loc]) {
-				return undefined;
-			}
-			return /** @type {PackContent} */ (this.content[loc]).get(identifier);
 		}
+		if (!this.content[loc]) {
+			return;
+		}
+		return /** @type {PackContent} */ (this.content[loc]).get(identifier);
 	}
 
 	/**
@@ -528,7 +527,7 @@ class Pack {
 	 */
 	_gcOldestContent() {
 		/** @type {PackItemInfo | undefined} */
-		let oldest = undefined;
+		let oldest;
 		for (const info of this.itemInfo.values()) {
 			if (oldest === undefined || info.lastAccess < oldest.lastAccess) {
 				oldest = info;
@@ -677,16 +676,16 @@ class PackContentItems {
 							logger.log(`Serialization of '${key}': ${duration} ms`);
 						else logger.debug(`Serialization of '${key}': ${duration} ms`);
 					}
-				} catch (e) {
+				} catch (err) {
 					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
+					if (err === NOT_SERIALIZABLE) continue;
 					const msg = "Skipped not serializable cache item";
-					if (e.message.includes("ModuleBuildError")) {
-						logger.log(`${msg} (in build error): ${e.message}`);
-						logger.debug(`${msg} '${key}' (in build error): ${e.stack}`);
+					if (err.message.includes("ModuleBuildError")) {
+						logger.log(`${msg} (in build error): ${err.message}`);
+						logger.debug(`${msg} '${key}' (in build error): ${err.stack}`);
 					} else {
-						logger.warn(`${msg}: ${e.message}`);
-						logger.debug(`${msg} '${key}': ${e.stack}`);
+						logger.warn(`${msg}: ${err.message}`);
+						logger.debug(`${msg} '${key}': ${err.stack}`);
 					}
 				}
 			}
@@ -698,7 +697,7 @@ class PackContentItems {
 		try {
 			write(true);
 			write(this.map);
-		} catch (e) {
+		} catch (_err) {
 			rollback(s);
 
 			// Try to serialize each item on it's own
@@ -708,13 +707,13 @@ class PackContentItems {
 				try {
 					write(key);
 					write(value);
-				} catch (e) {
+				} catch (err) {
 					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
+					if (err === NOT_SERIALIZABLE) continue;
 					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
+						`Skipped not serializable cache item '${key}': ${err.message}`
 					);
-					logger.debug(e.stack);
+					logger.debug(err.stack);
 				}
 			}
 			write(null);
@@ -817,6 +816,7 @@ class PackContent {
 			return this.content.get(identifier);
 		}
 
+		const logger = /** @type {Logger} */ (this.logger);
 		// We are in state B
 		const { lazyName } = this;
 		/** @type {string | undefined} */
@@ -827,35 +827,35 @@ class PackContent {
 			timeMessage = `restore cache content ${lazyName} (${formatSize(
 				this.getSize()
 			)})`;
-			this.logger.log(
+			logger.log(
 				`starting to restore cache content ${lazyName} (${formatSize(
 					this.getSize()
 				)}) because of request to: ${identifier}`
 			);
-			this.logger.time(timeMessage);
+			logger.time(timeMessage);
 		}
 		const value = this.lazy();
 		if ("then" in value) {
 			return value.then(data => {
 				const map = data.map;
 				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
+					logger.timeEnd(timeMessage);
 				}
 				// Move to state C
 				this.content = map;
 				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 				return map.get(identifier);
 			});
-		} else {
-			const map = value.map;
-			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
-			}
-			// Move to state C
-			this.content = map;
-			this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
-			return map.get(identifier);
 		}
+
+		const map = value.map;
+		if (timeMessage) {
+			logger.timeEnd(timeMessage);
+		}
+		// Move to state C
+		this.content = map;
+		this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+		return map.get(identifier);
 	}
 
 	/**
@@ -865,6 +865,7 @@ class PackContent {
 	unpack(reason) {
 		if (this.content) return;
 
+		const logger = /** @type {Logger} */ (this.logger);
 		// Move from state B to C
 		if (this.lazy) {
 			const { lazyName } = this;
@@ -876,27 +877,26 @@ class PackContent {
 				timeMessage = `unpack cache content ${lazyName} (${formatSize(
 					this.getSize()
 				)})`;
-				this.logger.log(
+				logger.log(
 					`starting to unpack cache content ${lazyName} (${formatSize(
 						this.getSize()
 					)}) because ${reason}`
 				);
-				this.logger.time(timeMessage);
+				logger.time(timeMessage);
 			}
 			const value = this.lazy();
 			if ("then" in value) {
 				return value.then(data => {
 					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
+						logger.timeEnd(timeMessage);
 					}
 					this.content = data.map;
 				});
-			} else {
-				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
-				}
-				this.content = value.map;
 			}
+			if (timeMessage) {
+				logger.timeEnd(timeMessage);
+			}
+			this.content = value.map;
 		}
 	}
 
@@ -957,6 +957,7 @@ class PackContent {
 			);
 			return;
 		}
+		const logger = /** @type {Logger} */ (this.logger);
 		// State B2
 		const { lazyName } = this;
 		/** @type {string | undefined} */
@@ -967,12 +968,12 @@ class PackContent {
 			timeMessage = `unpack cache content ${lazyName} (${formatSize(
 				this.getSize()
 			)})`;
-			this.logger.log(
+			logger.log(
 				`starting to unpack cache content ${lazyName} (${formatSize(
 					this.getSize()
 				)}) because it's outdated and need to be serialized`
 			);
-			this.logger.time(timeMessage);
+			logger.time(timeMessage);
 		}
 		const value = this.lazy();
 		this.outdated = false;
@@ -981,7 +982,7 @@ class PackContent {
 			this.lazy = write(() =>
 				value.then(data => {
 					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
+						logger.timeEnd(timeMessage);
 					}
 					const oldMap = data.map;
 					/** @type {Map<string, any>} */
@@ -999,7 +1000,7 @@ class PackContent {
 		} else {
 			// Move to state C1
 			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
+				logger.timeEnd(timeMessage);
 			}
 			const oldMap = value.map;
 			/** @type {Map<string, any>} */
@@ -1148,19 +1149,19 @@ class PackFileCacheStrategy {
 			})
 			.then(packContainer => {
 				logger.timeEnd("restore cache container");
-				if (!packContainer) return undefined;
+				if (!packContainer) return;
 				if (!(packContainer instanceof PackContainer)) {
 					logger.warn(
 						`Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
 						packContainer
 					);
-					return undefined;
+					return;
 				}
 				if (packContainer.version !== version) {
 					logger.log(
 						`Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
 					);
-					return undefined;
+					return;
 				}
 				logger.time("check build dependencies");
 				return Promise.all([
@@ -1321,7 +1322,7 @@ class PackFileCacheStrategy {
 				pack.stopCapturingRequests();
 				if (!pack.invalid) return;
 				this.packPromise = undefined;
-				this.logger.log(`Storing pack...`);
+				this.logger.log("Storing pack...");
 				let promise;
 				const newBuildDependencies = new Set();
 				for (const dep of this.newBuildDependencies) {
@@ -1439,7 +1440,7 @@ class PackFileCacheStrategy {
 				}
 				return promise.then(() => {
 					if (reportProgress) reportProgress(0.8, "serialize pack");
-					this.logger.time(`store pack`);
+					this.logger.time("store pack");
 					const updatedBuildDependencies = new Set(this.buildDependencies);
 					for (const dep of newBuildDependencies) {
 						updatedBuildDependencies.add(dep);
@@ -1464,7 +1465,7 @@ class PackFileCacheStrategy {
 								this.buildDependencies.add(dep);
 							}
 							this.newBuildDependencies.clear();
-							this.logger.timeEnd(`store pack`);
+							this.logger.timeEnd("store pack");
 							const stats = pack.getContentStats();
 							this.logger.log(
 								"Stored pack (%d items, %d files, %d MiB)",
@@ -1474,7 +1475,7 @@ class PackFileCacheStrategy {
 							);
 						})
 						.catch(err => {
-							this.logger.timeEnd(`store pack`);
+							this.logger.timeEnd("store pack");
 							this.logger.warn(`Caching failed for pack: ${err}`);
 							this.logger.debug(err.stack);
 						});

package/lib/cache/ResolverCachePlugin.js

@@ -59,11 +59,10 @@ const objectToString = (object, excludeContext) => {
 	for (const key in object) {
 		if (excludeContext && key === "context") continue;
 		const value = object[key];
-		if (typeof value === "object" && value !== null) {
-			str += `|${key}=[${objectToString(value, false)}|]`;
-		} else {
-			str += `|${key}=|${value}`;
-		}
+		str +=
+			typeof value === "object" && value !== null
+				? `|${key}=[${objectToString(value, false)}|]`
+				: `|${key}=|${value}`;
 	}
 	return str;
 };
@@ -241,7 +240,8 @@ class ResolverCachePlugin {
 									}
 								}
 								const itemCache = cache.getItemCache(identifier, null);
-								let callbacks, yields;
+								let callbacks;
+								let yields;
 								const done = withYield
 									? (err, result) => {
 											if (callbacks === undefined) {