webpack 4.35.3 → 4.38.0

package/lib/Compilation.js

@@ -27,15 +27,16 @@ const HotUpdateChunkTemplate = require("./HotUpdateChunkTemplate");
 const ModuleTemplate = require("./ModuleTemplate");
 const RuntimeTemplate = require("./RuntimeTemplate");
 const ChunkRenderError = require("./ChunkRenderError");
-const AsyncDependencyToInitialChunkError = require("./AsyncDependencyToInitialChunkError");
 const Stats = require("./Stats");
 const Semaphore = require("./util/Semaphore");
 const createHash = require("./util/createHash");
-const Queue = require("./util/Queue");
 const SortableSet = require("./util/SortableSet");
 const GraphHelpers = require("./GraphHelpers");
 const ModuleDependency = require("./dependencies/ModuleDependency");
 const compareLocations = require("./compareLocations");
+const { Logger, LogType } = require("./logging/Logger");
+const ErrorHelpers = require("./ErrorHelpers");
+const buildChunkGraph = require("./buildChunkGraph");
 
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./Compiler")} Compiler */
@@ -95,6 +96,14 @@ const compareLocations = require("./compareLocations");
  * @property {DependenciesBlockVariable[]} variables
  */
 
+/**
+ * @typedef {Object} LogEntry
+ * @property {string} type
+ * @property {any[]} args
+ * @property {number} time
+ * @property {string[]=} trace
+ */
+
 /**
  * @param {Chunk} a first chunk to sort by id
  * @param {Chunk} b second chunk to sort by id
@@ -155,16 +164,6 @@ const byNameOrHash = (a, b) => {
 	return 0;
 };
 
-/**
- * @template T
- * @param {Set<T>} a first set
- * @param {Set<T>} b second set
- * @returns {number} cmp
- */
-const bySetSize = (a, b) => {
-	return a.size - b.size;
-};
-
 /**
  * @param {DependenciesBlockVariable[]} variables DepBlock Variables to iterate over
  * @param {DepBlockVarDependenciesCallback} fn callback to apply on iterated elements
@@ -384,6 +383,9 @@ class Compilation extends Tapable {
 				"compilerIndex"
 			]),
 
+			/** @type {SyncBailHook<string, LogEntry>} */
+			log: new SyncBailHook(["origin", "logEntry"]),
+
 			// TODO the following hooks are weirdly located here
 			// TODO move them for webpack 5
 			/** @type {SyncHook<object, Module>} */
@@ -469,6 +471,8 @@ class Compilation extends Tapable {
 		this.warnings = [];
 		/** @type {Compilation[]} */
 		this.children = [];
+		/** @type {Map<string, LogEntry[]>} */
+		this.logging = new Map();
 		/** @type {Map<DepConstructor, ModuleFactory>} */
 		this.dependencyFactories = new Map();
 		/** @type {Map<DepConstructor, DependencyTemplate>} */
@@ -499,6 +503,69 @@ class Compilation extends Tapable {
 		return new Stats(this);
 	}
 
+	/**
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
+	 */
+	getLogger(name) {
+		if (!name) {
+			throw new TypeError("Compilation.getLogger(name) called without a name");
+		}
+		/** @type {LogEntry[] | undefined} */
+		let logEntries;
+		return new Logger((type, args) => {
+			if (typeof name === "function") {
+				name = name();
+				if (!name) {
+					throw new TypeError(
+						"Compilation.getLogger(name) called with a function not returning a name"
+					);
+				}
+			}
+			let trace;
+			switch (type) {
+				case LogType.warn:
+				case LogType.error:
+				case LogType.trace:
+					trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
+						.split("\n")
+						.slice(3);
+					break;
+			}
+			/** @type {LogEntry} */
+			const logEntry = {
+				time: Date.now(),
+				type,
+				args,
+				trace
+			};
+			if (this.hooks.log.call(name, logEntry) === undefined) {
+				if (logEntry.type === LogType.profileEnd) {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					if (typeof console.profileEnd === "function") {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						console.profileEnd(`[${name}] ${logEntry.args[0]}`);
+					}
+				}
+				if (logEntries === undefined) {
+					logEntries = this.logging.get(name);
+					if (logEntries === undefined) {
+						logEntries = [];
+						this.logging.set(name, logEntries);
+					}
+				}
+				logEntries.push(logEntry);
+				if (logEntry.type === LogType.profile) {
+					// eslint-disable-next-line node/no-unsupported-features/node-builtins
+					if (typeof console.profile === "function") {
+						// eslint-disable-next-line node/no-unsupported-features/node-builtins
+						console.profile(`[${name}] ${logEntry.args[0]}`);
+					}
+				}
+			}
+		});
+	}
+
 	/**
 	 * @typedef {Object} AddModuleResult
 	 * @property {Module} module the added or existing module
@@ -1217,7 +1284,10 @@ class Compilation extends Tapable {
 
 			this.assignDepth(module);
 		}
-		this.processDependenciesBlocksForChunkGroups(this.chunkGroups.slice());
+		buildChunkGraph(
+			this,
+			/** @type {Entrypoint[]} */ (this.chunkGroups.slice())
+		);
 		this.sortModules(this.modules);
 		this.hooks.afterChunks.call(this.chunks);
 
@@ -1505,460 +1575,6 @@ class Compilation extends Tapable {
 		return this.hooks.dependencyReference.call(ref, dependency, module);
 	}
 
-	/**
-	 * This method creates the Chunk graph from the Module graph
-	 * @private
-	 * @param {TODO[]} inputChunkGroups chunk groups which are processed
-	 * @returns {void}
-	 */
-	processDependenciesBlocksForChunkGroups(inputChunkGroups) {
-		// Process is splitting into two parts:
-		// Part one traverse the module graph and builds a very basic chunks graph
-		//   in chunkDependencies.
-		// Part two traverse every possible way through the basic chunk graph and
-		//   tracks the available modules. While traversing it connects chunks with
-		//   eachother and Blocks with Chunks. It stops traversing when all modules
-		//   for a chunk are already available. So it doesn't connect unneeded chunks.
-
-		/** @type {Map<ChunkGroup, {block: AsyncDependenciesBlock, chunkGroup: ChunkGroup, couldBeFiltered: boolean}[]>} */
-		const chunkDependencies = new Map();
-		const allCreatedChunkGroups = new Set();
-
-		// PREPARE
-		/** @type {Map<DependenciesBlock, { modules: Module[], blocks: AsyncDependenciesBlock[]}>} */
-		const blockInfoMap = new Map();
-
-		/**
-		 * @param {Dependency} d dependency to iterate over
-		 * @returns {void}
-		 */
-		const iteratorDependency = d => {
-			// We skip Dependencies without Reference
-			const ref = this.getDependencyReference(currentModule, d);
-			if (!ref) {
-				return;
-			}
-			// We skip Dependencies without Module pointer
-			const refModule = ref.module;
-			if (!refModule) {
-				return;
-			}
-			// We skip weak Dependencies
-			if (ref.weak) {
-				return;
-			}
-
-			blockInfoModules.add(refModule);
-		};
-
-		/**
-		 * @param {AsyncDependenciesBlock} b blocks to prepare
-		 * @returns {void}
-		 */
-		const iteratorBlockPrepare = b => {
-			blockInfoBlocks.push(b);
-			blockQueue.push(b);
-		};
-
-		/** @type {Module} */
-		let currentModule;
-		/** @type {DependenciesBlock} */
-		let block;
-		/** @type {DependenciesBlock[]} */
-		let blockQueue;
-		/** @type {Set<Module>} */
-		let blockInfoModules;
-		/** @type {AsyncDependenciesBlock[]} */
-		let blockInfoBlocks;
-
-		for (const module of this.modules) {
-			blockQueue = [module];
-			currentModule = module;
-			while (blockQueue.length > 0) {
-				block = blockQueue.pop();
-				blockInfoModules = new Set();
-				blockInfoBlocks = [];
-
-				if (block.variables) {
-					iterationBlockVariable(block.variables, iteratorDependency);
-				}
-
-				if (block.dependencies) {
-					iterationOfArrayCallback(block.dependencies, iteratorDependency);
-				}
-
-				if (block.blocks) {
-					iterationOfArrayCallback(block.blocks, iteratorBlockPrepare);
-				}
-
-				const blockInfo = {
-					modules: Array.from(blockInfoModules),
-					blocks: blockInfoBlocks
-				};
-				blockInfoMap.set(block, blockInfo);
-			}
-		}
-
-		// PART ONE
-
-		/** @type {Map<ChunkGroup, { index: number, index2: number }>} */
-		const chunkGroupCounters = new Map();
-		for (const chunkGroup of inputChunkGroups) {
-			chunkGroupCounters.set(chunkGroup, { index: 0, index2: 0 });
-		}
-
-		let nextFreeModuleIndex = 0;
-		let nextFreeModuleIndex2 = 0;
-
-		/** @type {Map<DependenciesBlock, ChunkGroup>} */
-		const blockChunkGroups = new Map();
-
-		/** @type {Set<DependenciesBlock>} */
-		const blocksWithNestedBlocks = new Set();
-
-		const ADD_AND_ENTER_MODULE = 0;
-		const ENTER_MODULE = 1;
-		const PROCESS_BLOCK = 2;
-		const LEAVE_MODULE = 3;
-
-		/**
-		 * @typedef {Object} QueueItem
-		 * @property {number} action
-		 * @property {DependenciesBlock} block
-		 * @property {Module} module
-		 * @property {Chunk} chunk
-		 * @property {ChunkGroup} chunkGroup
-		 */
-
-		/**
-		 * @param {ChunkGroup} chunkGroup chunk group
-		 * @returns {QueueItem} queue item
-		 */
-		const chunkGroupToQueueItem = chunkGroup => ({
-			action: ENTER_MODULE,
-			block: chunkGroup.chunks[0].entryModule,
-			module: chunkGroup.chunks[0].entryModule,
-			chunk: chunkGroup.chunks[0],
-			chunkGroup
-		});
-
-		// Start with the provided modules/chunks
-		/** @type {QueueItem[]} */
-		let queue = inputChunkGroups.map(chunkGroupToQueueItem).reverse();
-		/** @type {QueueItem[]} */
-		let queueDelayed = [];
-
-		/** @type {Module} */
-		let module;
-		/** @type {Chunk} */
-		let chunk;
-		/** @type {ChunkGroup} */
-		let chunkGroup;
-
-		// For each async Block in graph
-		/**
-		 * @param {AsyncDependenciesBlock} b iterating over each Async DepBlock
-		 * @returns {void}
-		 */
-		const iteratorBlock = b => {
-			// 1. We create a chunk for this Block
-			// but only once (blockChunkGroups map)
-			let c = blockChunkGroups.get(b);
-			if (c === undefined) {
-				c = this.namedChunkGroups.get(b.chunkName);
-				if (c && c.isInitial()) {
-					this.errors.push(
-						new AsyncDependencyToInitialChunkError(b.chunkName, module, b.loc)
-					);
-					c = chunkGroup;
-				} else {
-					c = this.addChunkInGroup(
-						b.groupOptions || b.chunkName,
-						module,
-						b.loc,
-						b.request
-					);
-					chunkGroupCounters.set(c, { index: 0, index2: 0 });
-					blockChunkGroups.set(b, c);
-					allCreatedChunkGroups.add(c);
-				}
-			} else {
-				// TODO webpack 5 remove addOptions check
-				if (c.addOptions) c.addOptions(b.groupOptions);
-				c.addOrigin(module, b.loc, b.request);
-			}
-
-			// 2. We store the Block+Chunk mapping as dependency for the chunk
-			let deps = chunkDependencies.get(chunkGroup);
-			if (!deps) chunkDependencies.set(chunkGroup, (deps = []));
-			deps.push({
-				block: b,
-				chunkGroup: c,
-				couldBeFiltered: true
-			});
-
-			// 3. We enqueue the DependenciesBlock for traversal
-			queueDelayed.push({
-				action: PROCESS_BLOCK,
-				block: b,
-				module: module,
-				chunk: c.chunks[0],
-				chunkGroup: c
-			});
-		};
-
-		// Iterative traversal of the Module graph
-		// Recursive would be simpler to write but could result in Stack Overflows
-		while (queue.length) {
-			while (queue.length) {
-				const queueItem = queue.pop();
-				module = queueItem.module;
-				block = queueItem.block;
-				chunk = queueItem.chunk;
-				chunkGroup = queueItem.chunkGroup;
-
-				switch (queueItem.action) {
-					case ADD_AND_ENTER_MODULE: {
-						// We connect Module and Chunk when not already done
-						if (chunk.addModule(module)) {
-							module.addChunk(chunk);
-						} else {
-							// already connected, skip it
-							break;
-						}
-					}
-					// fallthrough
-					case ENTER_MODULE: {
-						if (chunkGroup !== undefined) {
-							const index = chunkGroup.getModuleIndex(module);
-							if (index === undefined) {
-								chunkGroup.setModuleIndex(
-									module,
-									chunkGroupCounters.get(chunkGroup).index++
-								);
-							}
-						}
-
-						if (module.index === null) {
-							module.index = nextFreeModuleIndex++;
-						}
-
-						queue.push({
-							action: LEAVE_MODULE,
-							block,
-							module,
-							chunk,
-							chunkGroup
-						});
-					}
-					// fallthrough
-					case PROCESS_BLOCK: {
-						// get prepared block info
-						const blockInfo = blockInfoMap.get(block);
-
-						// Traverse all referenced modules
-						for (let i = blockInfo.modules.length - 1; i >= 0; i--) {
-							const refModule = blockInfo.modules[i];
-							if (chunk.containsModule(refModule)) {
-								// skip early if already connected
-								continue;
-							}
-							// enqueue the add and enter to enter in the correct order
-							// this is relevant with circular dependencies
-							queue.push({
-								action: ADD_AND_ENTER_MODULE,
-								block: refModule,
-								module: refModule,
-								chunk,
-								chunkGroup
-							});
-						}
-
-						// Traverse all Blocks
-						iterationOfArrayCallback(blockInfo.blocks, iteratorBlock);
-
-						if (blockInfo.blocks.length > 0 && module !== block) {
-							blocksWithNestedBlocks.add(block);
-						}
-						break;
-					}
-					case LEAVE_MODULE: {
-						if (chunkGroup !== undefined) {
-							const index = chunkGroup.getModuleIndex2(module);
-							if (index === undefined) {
-								chunkGroup.setModuleIndex2(
-									module,
-									chunkGroupCounters.get(chunkGroup).index2++
-								);
-							}
-						}
-
-						if (module.index2 === null) {
-							module.index2 = nextFreeModuleIndex2++;
-						}
-						break;
-					}
-				}
-			}
-			const tempQueue = queue;
-			queue = queueDelayed.reverse();
-			queueDelayed = tempQueue;
-		}
-
-		// PART TWO
-		/** @type {Set<Module>} */
-		let newAvailableModules;
-
-		/**
-		 * @typedef {Object} ChunkGroupInfo
-		 * @property {Set<Module>} minAvailableModules current minimal set of modules available at this point
-		 * @property {Set<Module>[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
-		 */
-
-		/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
-		const chunkGroupInfoMap = new Map();
-
-		/** @type {Queue<ChunkGroup>} */
-		const queue2 = new Queue(inputChunkGroups);
-
-		for (const chunkGroup of inputChunkGroups) {
-			chunkGroupInfoMap.set(chunkGroup, {
-				minAvailableModules: undefined,
-				availableModulesToBeMerged: [new Set()]
-			});
-		}
-
-		/**
-		 * Helper function to check if all modules of a chunk are available
-		 *
-		 * @param {ChunkGroup} chunkGroup the chunkGroup to scan
-		 * @param {Set<Module>} availableModules the comparitor set
-		 * @returns {boolean} return true if all modules of a chunk are available
-		 */
-		const areModulesAvailable = (chunkGroup, availableModules) => {
-			for (const chunk of chunkGroup.chunks) {
-				for (const module of chunk.modulesIterable) {
-					if (!availableModules.has(module)) return false;
-				}
-			}
-			return true;
-		};
-
-		// For each edge in the basic chunk graph
-		/**
-		 * @param {TODO} dep the dependency used for filtering
-		 * @returns {boolean} used to filter "edges" (aka Dependencies) that were pointing
-		 * to modules that are already available. Also filters circular dependencies in the chunks graph
-		 */
-		const filterFn = dep => {
-			const depChunkGroup = dep.chunkGroup;
-			if (!dep.couldBeFiltered) return true;
-			if (blocksWithNestedBlocks.has(dep.block)) return true;
-			if (areModulesAvailable(depChunkGroup, newAvailableModules)) {
-				return false; // break all modules are already available
-			}
-			dep.couldBeFiltered = false;
-			return true;
-		};
-
-		// Iterative traversing of the basic chunk graph
-		while (queue2.length) {
-			chunkGroup = queue2.dequeue();
-			const info = chunkGroupInfoMap.get(chunkGroup);
-			const availableModulesToBeMerged = info.availableModulesToBeMerged;
-			let minAvailableModules = info.minAvailableModules;
-
-			// 1. Get minimal available modules
-			// It doesn't make sense to traverse a chunk again with more available modules.
-			// This step calculates the minimal available modules and skips traversal when
-			// the list didn't shrink.
-			availableModulesToBeMerged.sort(bySetSize);
-			let changed = false;
-			for (const availableModules of availableModulesToBeMerged) {
-				if (minAvailableModules === undefined) {
-					minAvailableModules = new Set(availableModules);
-					info.minAvailableModules = minAvailableModules;
-					changed = true;
-				} else {
-					for (const m of minAvailableModules) {
-						if (!availableModules.has(m)) {
-							minAvailableModules.delete(m);
-							changed = true;
-						}
-					}
-				}
-			}
-			availableModulesToBeMerged.length = 0;
-			if (!changed) continue;
-
-			// 2. Get the edges at this point of the graph
-			const deps = chunkDependencies.get(chunkGroup);
-			if (!deps) continue;
-			if (deps.length === 0) continue;
-
-			// 3. Create a new Set of available modules at this points
-			newAvailableModules = new Set(minAvailableModules);
-			for (const chunk of chunkGroup.chunks) {
-				for (const m of chunk.modulesIterable) {
-					newAvailableModules.add(m);
-				}
-			}
-
-			// 4. Foreach remaining edge
-			const nextChunkGroups = new Set();
-			for (let i = 0; i < deps.length; i++) {
-				const dep = deps[i];
-
-				// Filter inline, rather than creating a new array from `.filter()`
-				if (!filterFn(dep)) {
-					continue;
-				}
-				const depChunkGroup = dep.chunkGroup;
-				const depBlock = dep.block;
-
-				// 5. Connect block with chunk
-				GraphHelpers.connectDependenciesBlockAndChunkGroup(
-					depBlock,
-					depChunkGroup
-				);
-
-				// 6. Connect chunk with parent
-				GraphHelpers.connectChunkGroupParentAndChild(chunkGroup, depChunkGroup);
-
-				nextChunkGroups.add(depChunkGroup);
-			}
-
-			// 7. Enqueue further traversal
-			for (const nextChunkGroup of nextChunkGroups) {
-				let nextInfo = chunkGroupInfoMap.get(nextChunkGroup);
-				if (nextInfo === undefined) {
-					nextInfo = {
-						minAvailableModules: undefined,
-						availableModulesToBeMerged: []
-					};
-					chunkGroupInfoMap.set(nextChunkGroup, nextInfo);
-				}
-				nextInfo.availableModulesToBeMerged.push(newAvailableModules);
-
-				// As queue deduplicates enqueued items this makes sure that a ChunkGroup
-				// is not enqueued twice
-				queue2.enqueue(nextChunkGroup);
-			}
-		}
-
-		// Remove all unconnected chunk groups
-		for (const chunkGroup of allCreatedChunkGroups) {
-			if (chunkGroup.getNumberOfParents() === 0) {
-				for (const chunk of chunkGroup.chunks) {
-					const idx = this.chunks.indexOf(chunk);
-					if (idx >= 0) this.chunks.splice(idx, 1);
-					chunk.remove("unconnected");
-				}
-				chunkGroup.remove("unconnected");
-			}
-		}
-	}
-
 	/**
 	 *
 	 * @param {Module} module module relationship for removal
@@ -2294,7 +1910,7 @@ class Compilation extends Tapable {
 			const module = modules[i];
 			const moduleHash = createHash(hashFunction);
 			module.updateHash(moduleHash);
-			module.hash = moduleHash.digest(hashDigest);
+			module.hash = /** @type {string} */ (moduleHash.digest(hashDigest));
 			module.renderedHash = module.hash.substr(0, hashDigestLength);
 		}
 		// clone needed as sort below is inplace mutation
@@ -2329,7 +1945,7 @@ class Compilation extends Tapable {
 					this.dependencyTemplates
 				);
 				this.hooks.chunkHash.call(chunk, chunkHash);
-				chunk.hash = chunkHash.digest(hashDigest);
+				chunk.hash = /** @type {string} */ (chunkHash.digest(hashDigest));
 				hash.update(chunk.hash);
 				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
 				this.hooks.contentHash.call(chunk);
@@ -2337,7 +1953,7 @@ class Compilation extends Tapable {
 				this.errors.push(new ChunkRenderError(chunk, "", err));
 			}
 		}
-		this.fullHash = hash.digest(hashDigest);
+		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
 		this.hash = this.fullHash.substr(0, hashDigestLength);
 	}
 
@@ -2353,7 +1969,7 @@ class Compilation extends Tapable {
 		const hash = createHash(hashFunction);
 		hash.update(this.fullHash);
 		hash.update(update);
-		this.fullHash = hash.digest(hashDigest);
+		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
 		this.hash = this.fullHash.substr(0, hashDigestLength);
 	}
 

package/lib/Compiler.js

@@ -27,6 +27,7 @@ const ResolverFactory = require("./ResolverFactory");
 const RequestShortener = require("./RequestShortener");
 const { makePathsRelative } = require("./util/identifier");
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
+const { Logger } = require("./logging/Logger");
 
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
@@ -84,6 +85,9 @@ class Compiler extends Tapable {
 			/** @type {SyncHook} */
 			watchClose: new SyncHook([]),
 
+			/** @type {SyncBailHook<string, string, any[]>} */
+			infrastructurelog: new SyncBailHook(["origin", "type", "args"]),
+
 			// TODO the following hooks are weirdly located here
 			// TODO move them for webpack 5
 			/** @type {SyncHook} */
@@ -137,6 +141,8 @@ class Compiler extends Tapable {
 		/** @type {ResolverFactory} */
 		this.resolverFactory = new ResolverFactory();
 
+		this.infrastructureLogger = undefined;
+
 		// TODO remove in webpack 5
 		this.resolvers = {
 			normal: {
@@ -196,6 +202,33 @@ class Compiler extends Tapable {
 		this._assetEmittingWrittenFiles = new Map();
 	}
 
+	/**
+	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @returns {Logger} a logger with that name
+	 */
+	getInfrastructureLogger(name) {
+		if (!name) {
+			throw new TypeError(
+				"Compiler.getInfrastructureLogger(name) called without a name"
+			);
+		}
+		return new Logger((type, args) => {
+			if (typeof name === "function") {
+				name = name();
+				if (!name) {
+					throw new TypeError(
+						"Compiler.getInfrastructureLogger(name) called with a function not returning a name"
+					);
+				}
+			}
+			if (this.hooks.infrastructurelog.call(name, type, args) === undefined) {
+				if (this.infrastructureLogger !== undefined) {
+					this.infrastructureLogger(name, type, args);
+				}
+			}
+		});
+	}
+
 	watch(watchOptions, handler) {
 		if (this.running) return handler(new ConcurrentCompilationError());
 

package/lib/HashedModuleIdsPlugin.js

@@ -45,7 +45,9 @@ class HashedModuleIdsPlugin {
 							});
 							const hash = createHash(options.hashFunction);
 							hash.update(id);
-							const hashId = hash.digest(options.hashDigest);
+							const hashId = /** @type {string} */ (hash.digest(
+								options.hashDigest
+							));
 							let len = options.hashDigestLength;
 							while (usedIds.has(hashId.substr(0, len))) len++;
 							module.id = hashId.substr(0, len);