webpack 5.93.0 → 5.95.0

package/lib/Compilation.js

@@ -94,6 +94,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Cache")} Cache */
 /** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Compiler").CompilationParams} CompilationParams */
@@ -116,6 +117,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./util/Hash")} Hash */
 /**
  * @template T
@@ -133,7 +135,7 @@ const { isSourceEqual } = require("./util/source");
 /**
  * @callback ModuleCallback
  * @param {(WebpackError | null)=} err
- * @param {Module=} result
+ * @param {(Module | null)=} result
  * @returns {void}
  */
 
@@ -153,7 +155,7 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @callback ExecuteModuleCallback
- * @param {(WebpackError | null)=} err
+ * @param {WebpackError | null} err
  * @param {ExecuteModuleResult=} result
  * @returns {void}
  */
@@ -246,7 +248,7 @@ const { isSourceEqual } = require("./util/source");
 /**
  * @typedef {object} LogEntry
  * @property {string} type
- * @property {any[]} args
+ * @property {any[]=} args
  * @property {number} time
  * @property {string[]=} trace
  */
@@ -269,6 +271,8 @@ const { isSourceEqual } = require("./util/source");
 
 /** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
 
+/** @typedef {{ path: string, info: AssetInfo }} InterpolatedPathAndAssetInfo */
+
 /**
  * @typedef {object} Asset
  * @property {string} name the filename of the asset
@@ -350,7 +354,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean=} forToString
  */
 
-/** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
+/** @typedef {Record<string, any> & KnownCreateStatsOptionsContext} CreateStatsOptionsContext */
 
 /** @typedef {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} CodeGenerationJobs */
 
@@ -358,6 +362,8 @@ const { isSourceEqual } = require("./util/source");
 
 /** @typedef {Set<Module>} NotCodeGeneratedModules */
 
+/** @typedef {string | Set<string> | undefined} ValueCacheVersion */
+
 /** @type {AssetInfo} */
 const EMPTY_ASSET_INFO = Object.freeze({});
 
@@ -369,9 +375,8 @@ const deprecatedNormalModuleLoaderHook = util.deprecate(
 	 * @param {Compilation} compilation compilation
 	 * @returns {NormalModuleCompilationHooks["loader"]} hooks
 	 */
-	compilation => {
-		return require("./NormalModule").getCompilationHooks(compilation).loader;
-	},
+	compilation =>
+		require("./NormalModule").getCompilationHooks(compilation).loader,
 	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
 	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
 );
@@ -448,7 +453,7 @@ class Compilation {
 		 * @returns {CompilationAssets} new assets
 		 */
 		const popNewAssets = assets => {
-			let newAssets = undefined;
+			let newAssets;
 			for (const file of Object.keys(assets)) {
 				if (savedAssets.has(file)) continue;
 				if (newAssets === undefined) {
@@ -484,8 +489,8 @@ class Compilation {
 							fn: (assets, callback) => {
 								try {
 									fn(assets);
-								} catch (e) {
-									return callback(e);
+								} catch (err) {
+									return callback(err);
 								}
 								if (processedAssets !== undefined)
 									processedAssets.add(this.assets);
@@ -571,7 +576,11 @@ class Compilation {
 		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
 		 */
 		const createProcessAssetsHook = (name, stage, getArgs, code) => {
-			if (!this._backCompat && code) return undefined;
+			if (!this._backCompat && code) return;
+			/**
+			 * @param {string} reason reason
+			 * @returns {string} error message
+			 */
 			const errorMessage =
 				reason => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
@@ -580,7 +589,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (options.stage) {
 					throw new Error(errorMessage("it's using the 'stage' option"));
 				}
-				return { ...options, stage: stage };
+				return { ...options, stage };
 			};
 			return createFakeHook(
 				{
@@ -662,14 +671,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			 */
 			afterChunks: new SyncHook(["chunks"]),
 
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			/** @type {SyncBailHook<[Iterable<Module>], boolean | void>} */
 			optimizeDependencies: new SyncBailHook(["modules"]),
 			/** @type {SyncHook<[Iterable<Module>]>} */
 			afterOptimizeDependencies: new SyncHook(["modules"]),
 
 			/** @type {SyncHook<[]>} */
 			optimize: new SyncHook([]),
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			/** @type {SyncBailHook<[Iterable<Module>], boolean | void>} */
 			optimizeModules: new SyncBailHook(["modules"]),
 			/** @type {SyncHook<[Iterable<Module>]>} */
 			afterOptimizeModules: new SyncHook(["modules"]),
@@ -707,7 +716,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
+			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInModule: new HookMap(
 				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
 			),
@@ -717,7 +726,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInTree: new HookMap(
 				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
@@ -912,7 +921,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				true
 			);
 		}
-		/** @type {Map<string, string | Set<string>>} */
+		/** @type {Map<string, ValueCacheVersion>} */
 		this.valueCacheVersions = new Map();
 		this.requestShortener = compiler.requestShortener;
 		this.compilerPath = compiler.compilerPath;
@@ -1047,6 +1056,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.dependencyTemplates = new DependencyTemplates(
 			this.outputOptions.hashFunction
 		);
+		/** @type {Record<string, number>} */
 		this.childrenCounters = {};
 		/** @type {Set<number|string>} */
 		this.usedChunkIds = null;
@@ -1099,7 +1109,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
 
 		const unsafeCache = options.module.unsafeCache;
-		this._unsafeCache = !!unsafeCache;
+		this._unsafeCache = Boolean(unsafeCache);
 		this._unsafeCachePredicate =
 			typeof unsafeCache === "function" ? unsafeCache : () => true;
 	}
@@ -1110,14 +1120,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 	/**
 	 * @param {string | boolean | StatsOptions | undefined} optionsOrPreset stats option value
-	 * @param {CreateStatsOptionsContext} context context
+	 * @param {CreateStatsOptionsContext=} context context
 	 * @returns {NormalizedStatsOptions} normalized options
 	 */
 	createStatsOptions(optionsOrPreset, context = {}) {
-		if (
-			typeof optionsOrPreset === "boolean" ||
-			typeof optionsOrPreset === "string"
-		) {
+		if (typeof optionsOrPreset === "boolean") {
+			optionsOrPreset = {
+				preset: optionsOrPreset === false ? "none" : "normal"
+			};
+		} else if (typeof optionsOrPreset === "string") {
 			optionsOrPreset = { preset: optionsOrPreset };
 		}
 		if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) {
@@ -1125,20 +1136,20 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			// properties in the prototype chain
 			/** @type {Partial<NormalizedStatsOptions>} */
 			const options = {};
+			// eslint-disable-next-line guard-for-in
 			for (const key in optionsOrPreset) {
-				options[key] = optionsOrPreset[key];
+				options[key] = optionsOrPreset[/** @type {keyof StatsOptions} */ (key)];
 			}
 			if (options.preset !== undefined) {
 				this.hooks.statsPreset.for(options.preset).call(options, context);
 			}
 			this.hooks.statsNormalize.call(options, context);
 			return /** @type {NormalizedStatsOptions} */ (options);
-		} else {
-			/** @type {Partial<NormalizedStatsOptions>} */
-			const options = {};
-			this.hooks.statsNormalize.call(options, context);
-			return /** @type {NormalizedStatsOptions} */ (options);
 		}
+		/** @type {Partial<NormalizedStatsOptions>} */
+		const options = {};
+		this.hooks.statsNormalize.call(options, context);
+		return /** @type {NormalizedStatsOptions} */ (options);
 	}
 
 	/**
@@ -1209,10 +1220,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					trace
 				};
 				if (this.hooks.log.call(name, logEntry) === undefined) {
-					if (logEntry.type === LogType.profileEnd) {
-						if (typeof console.profileEnd === "function") {
-							console.profileEnd(`[${name}] ${logEntry.args[0]}`);
-						}
+					if (
+						logEntry.type === LogType.profileEnd &&
+						typeof console.profileEnd === "function"
+					) {
+						console.profileEnd(
+							`[${name}] ${/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]}`
+						);
 					}
 					if (logEntries === undefined) {
 						logEntries = this.logging.get(name);
@@ -1222,10 +1236,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						}
 					}
 					logEntries.push(logEntry);
-					if (logEntry.type === LogType.profile) {
-						if (typeof console.profile === "function") {
-							console.profile(`[${name}] ${logEntry.args[0]}`);
-						}
+					if (
+						logEntry.type === LogType.profile &&
+						typeof console.profile === "function"
+					) {
+						console.profile(
+							`[${name}] ${/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]}`
+						);
 					}
 				}
 			},
@@ -1251,36 +1268,33 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							}
 							return `${name}/${childName}`;
 						});
-					} else {
-						return this.getLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compilation.getLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
 					}
-				} else {
-					if (typeof childName === "function") {
-						return this.getLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
+					return this.getLogger(() => {
+						if (typeof name === "function") {
+							name = name();
+							if (!name) {
+								throw new TypeError(
+									"Compilation.getLogger(name) called with a function not returning a name"
+								);
 							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getLogger(`${name}/${childName}`);
-					}
+						}
+						return `${name}/${childName}`;
+					});
 				}
+				if (typeof childName === "function") {
+					return this.getLogger(() => {
+						if (typeof childName === "function") {
+							childName = childName();
+							if (!childName) {
+								throw new TypeError(
+									"Logger.getChildLogger(name) called with a function not returning a name"
+								);
+							}
+						}
+						return `${name}/${childName}`;
+					});
+				}
+				return this.getLogger(`${name}/${childName}`);
 			}
 		);
 	}
@@ -1360,7 +1374,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 	/**
 	 * Schedules a build of the module object
-	 *
 	 * @param {Module} module module to be built
 	 * @param {ModuleCallback} callback the callback
 	 * @returns {void}
@@ -1371,7 +1384,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 	/**
 	 * Builds the module object
-	 *
 	 * @param {Module} module module to be built
 	 * @param {ModuleCallback} callback the callback
 	 * @returns {void}
@@ -1518,6 +1530,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			for (const item of sortedDependencies) {
 				inProgressTransitive++;
+				// eslint-disable-next-line no-loop-func
 				this.handleModuleCreation(item, err => {
 					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
 					// errors are created inside closures that keep a reference to the Compilation, so errors are
@@ -1649,8 +1662,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						});
 						return;
 					}
-				} catch (e) {
-					console.error(e);
+				} catch (err) {
+					console.error(err);
 				}
 			}
 			processDependencyForResolving(dep);
@@ -1742,8 +1755,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					for (const b of block.blocks) queue.push(b);
 				}
 			} while (queue.length !== 0);
-		} catch (e) {
-			return callback(e);
+		} catch (err) {
+			return callback(err);
 		}
 
 		if (--inProgressSorting === 0) onDependenciesSorted();
@@ -1855,10 +1868,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					if (dependencies.every(d => d.optional)) {
 						this.warnings.push(err);
 						return callback();
-					} else {
-						this.errors.push(err);
-						return callback(err);
 					}
+					this.errors.push(err);
+					return callback(err);
 				}
 
 				const newModule = factoryResult.module;
@@ -1927,14 +1939,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						module,
 						originModule !== undefined ? originModule : null
 					);
-					if (module !== newModule) {
-						if (currentProfile !== undefined) {
-							const otherProfile = moduleGraph.getProfile(module);
-							if (otherProfile !== undefined) {
-								currentProfile.mergeInto(otherProfile);
-							} else {
-								moduleGraph.setProfile(module, currentProfile);
-							}
+					if (module !== newModule && currentProfile !== undefined) {
+						const otherProfile = moduleGraph.getProfile(module);
+						if (otherProfile !== undefined) {
+							currentProfile.mergeInto(otherProfile);
+						} else {
+							moduleGraph.setProfile(module, currentProfile);
 						}
 					}
 
@@ -1967,7 +1977,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		callback
 	) {
 		// Check for cycles when build is trigger inside another build
-		let creatingModuleDuringBuildSet = undefined;
+		/** @type {Set<Module> | undefined} */
+		let creatingModuleDuringBuildSet;
 		if (checkCycle && this.buildQueue.isProcessing(originModule)) {
 			// Track build dependency
 			creatingModuleDuringBuildSet =
@@ -2063,12 +2074,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					...contextInfo
 				},
 				resolveOptions: originModule ? originModule.resolveOptions : undefined,
-				context: context
-					? context
-					: originModule
-						? originModule.context
-						: this.compiler.context,
-				dependencies: dependencies
+				context:
+					context ||
+					(originModule ? originModule.context : this.compiler.context),
+				dependencies
 			},
 			(err, result) => {
 				if (result) {
@@ -2100,7 +2109,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					const notFoundError = new ModuleNotFoundError(
 						originModule,
 						err,
-						dependencies.map(d => d.loc).filter(Boolean)[0]
+						dependencies.map(d => d.loc).find(Boolean)
 					);
 					return callback(notFoundError, factoryResult ? result : undefined);
 				}
@@ -2368,7 +2377,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 */
 		const computeReferences = module => {
 			/** @type {References | undefined} */
-			let references = undefined;
+			let references;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
 				const m = connection.module;
@@ -2537,9 +2546,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		const computeReferences = module => {
 			const id = chunkGraph.getModuleId(module);
 			/** @type {Map<Module, string | number | undefined> | undefined} */
-			let modules = undefined;
+			let modules;
 			/** @type {(string | number | null)[] | undefined} */
-			let blocks = undefined;
+			let blocks;
 			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
 			if (outgoing !== undefined) {
 				for (const m of outgoing.keys()) {
@@ -2560,6 +2569,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					} else {
 						blocks.push(null);
 					}
+					// eslint-disable-next-line prefer-spread
 					queue.push.apply(queue, block.blocks);
 				}
 			}
@@ -2589,9 +2599,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						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;
+					} else if (i >= blocks.length || blocks[i++] !== null) {
+						return false;
 					}
+					// eslint-disable-next-line prefer-spread
 					queue.push.apply(queue, block.blocks);
 				}
 				if (i !== blocks.length) return false;
@@ -2686,6 +2697,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
 			// Avoid coverage problems due indirect changes
+			/**
+			 * @param {number} value value
+			 * @param {string} msg message
+			 */
 			/* istanbul ignore next */
 			const logByValue = (value, msg) => {
 				if (value > 1000) {
@@ -2739,7 +2754,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				for (const [module, profile] of modulesWithProfiles) {
 					const list = getOrInsert(
 						map,
-						module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
+						`${module.type}!${module.identifier().replace(/(!|^)[^!]*$/, "")}`,
 						() => []
 					);
 					list.push({ module, profile });
@@ -2897,6 +2912,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	seal(callback) {
+		/**
+		 * @param {WebpackError=} err err
+		 * @returns {void}
+		 */
 		const finalCallback = err => {
 			this.factorizeQueue.clear();
 			this.buildQueue.clear();
@@ -2966,11 +2985,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			this.assignDepths(entryModules);
 
+			/**
+			 * @param {Dependency[]} deps deps
+			 * @returns {Module[]} sorted deps
+			 */
 			const mapAndSort = deps =>
-				deps
-					.map(dep => this.moduleGraph.getModule(dep))
-					.filter(Boolean)
-					.sort(compareModulesByIdentifier);
+				/** @type {Module[]} */
+				(deps.map(dep => this.moduleGraph.getModule(dep)).filter(Boolean)).sort(
+					compareModulesByIdentifier
+				);
 			const includedModules = [
 				...mapAndSort(this.globalEntry.includeDependencies),
 				...mapAndSort(includeDependencies)
@@ -3335,20 +3358,21 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		/** @type {WebpackError[]} */
 		const errors = [];
 		/** @type {NotCodeGeneratedModules | undefined} */
-		let notCodeGeneratedModules = undefined;
+		let notCodeGeneratedModules;
 		const runIteration = () => {
 			/** @type {CodeGenerationJobs} */
 			let delayedJobs = [];
 			let delayedModules = new Set();
 			asyncLib.eachLimit(
 				jobs,
-				this.options.parallelism,
+				/** @type {number} */
+				(this.options.parallelism),
 				(job, callback) => {
 					const { module } = job;
 					const { codeGenerationDependencies } = module;
-					if (codeGenerationDependencies !== undefined) {
-						if (
-							notCodeGeneratedModules === undefined ||
+					if (
+						codeGenerationDependencies !== undefined &&
+						(notCodeGeneratedModules === undefined ||
 							codeGenerationDependencies.some(dep => {
 								const referencedModule = /** @type {Module} */ (
 									moduleGraph.getModule(dep)
@@ -3356,12 +3380,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 								return /** @type {NotCodeGeneratedModules} */ (
 									notCodeGeneratedModules
 								).has(referencedModule);
-							})
-						) {
-							delayedJobs.push(job);
-							delayedModules.add(module);
-							return callback();
-						}
+							}))
+					) {
+						delayedJobs.push(job);
+						delayedModules.add(module);
+						return callback();
 					}
 					const { hash, runtime, runtimes } = job;
 					this._codeGenerationModule(
@@ -3585,21 +3608,19 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 								null
 							);
 						}
+					} else if (memCache) {
+						memCache.set(
+							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+							set
+						);
+						chunkGraph.addModuleRuntimeRequirements(
+							module,
+							runtime,
+							set,
+							false
+						);
 					} else {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								set
-							);
-							chunkGraph.addModuleRuntimeRequirements(
-								module,
-								runtime,
-								set,
-								false
-							);
-						} else {
-							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
-						}
+						chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
 					}
 				}
 			}
@@ -3724,13 +3745,24 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			if (chunkGroup !== undefined) {
 				chunkGroup.addOptions(groupOptions);
 				if (module) {
-					chunkGroup.addOrigin(module, loc, request);
+					chunkGroup.addOrigin(
+						module,
+						/** @type {DependencyLocation} */
+						(loc),
+						request
+					);
 				}
 				return chunkGroup;
 			}
 		}
 		const chunkGroup = new ChunkGroup(groupOptions);
-		if (module) chunkGroup.addOrigin(module, loc, request);
+		if (module)
+			chunkGroup.addOrigin(
+				module,
+				/** @type {DependencyLocation} */
+				(loc),
+				request
+			);
 		const chunk = this.addChunk(name);
 
 		connectChunkGroupAndChunk(chunkGroup, chunk);
@@ -3788,7 +3820,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	/**
 	 * This method first looks to see if a name is provided for a new chunk,
 	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
-	 *
 	 * @param {string=} name optional chunk name to be provided
 	 * @returns {Chunk} create a chunk (invoked during seal event)
 	 */
@@ -3818,6 +3849,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const moduleGraph = this.moduleGraph;
 
 		const queue = new Set([module]);
+		/** @type {number} */
 		let depth;
 
 		moduleGraph.setDepth(module, 0);
@@ -3833,7 +3865,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 		for (module of queue) {
 			queue.delete(module);
-			depth = moduleGraph.getDepth(module) + 1;
+			depth = /** @type {number} */ (moduleGraph.getDepth(module)) + 1;
 
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const refModule = connection.module;
@@ -3894,7 +3926,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
-	 *
 	 * @param {Module} module module relationship for removal
 	 * @param {DependenciesBlockLike} block //TODO: good description
 	 * @returns {void}
@@ -3933,16 +3964,16 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		if (!module.hasReasons(this.moduleGraph, chunk.runtime)) {
 			this.removeReasonsOfDependencyBlock(module, module);
 		}
-		if (!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph)) {
-			if (this.chunkGraph.isModuleInChunk(module, chunk)) {
-				this.chunkGraph.disconnectChunkAndModule(chunk, module);
-				this.removeChunkFromDependencies(module, chunk);
-			}
+		if (
+			!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph) &&
+			this.chunkGraph.isModuleInChunk(module, chunk)
+		) {
+			this.chunkGraph.disconnectChunkAndModule(chunk, module);
+			this.removeChunkFromDependencies(module, chunk);
 		}
 	}
 
 	/**
-	 *
 	 * @param {DependenciesBlock} block block tie for Chunk
 	 * @param {Chunk} chunk chunk to remove from dep
 	 * @returns {void}
@@ -4247,7 +4278,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		// If there are still remaining references we have cycles and want to create a warning
 		if (remaining > 0) {
-			let circularRuntimeChunkInfo = [];
+			const circularRuntimeChunkInfo = [];
 			for (const info of runtimeChunksMap.values()) {
 				if (info.remaining !== 0) {
 					circularRuntimeChunkInfo.push(info);
@@ -4342,11 +4373,13 @@ This prevents using hashes of each other and should be avoided.`);
 					this.hooks.contentHash.call(chunk);
 				}
 			} catch (err) {
-				this.errors.push(new ChunkRenderError(chunk, "", err));
+				this.errors.push(
+					new ChunkRenderError(chunk, "", /** @type {Error} */ (err))
+				);
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
 		};
-		otherChunks.forEach(processChunk);
+		for (const chunk of otherChunks) processChunk(chunk);
 		for (const chunk of runtimeChunks) processChunk(chunk);
 		if (errors.length > 0) {
 			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
@@ -4389,9 +4422,9 @@ This prevents using hashes of each other and should be avoided.`);
 			const chunkHash = createHash(hashFunction);
 			chunkHash.update(chunk.hash);
 			chunkHash.update(this.hash);
-			const chunkHashDigest = /** @type {string} */ (
-				chunkHash.digest(hashDigest)
-			);
+			const chunkHashDigest =
+				/** @type {string} */
+				(chunkHash.digest(hashDigest));
 			chunk.hash = chunkHashDigest;
 			chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 			this.hooks.contentHash.call(chunk);
@@ -4423,7 +4456,7 @@ This prevents using hashes of each other and should be avoided.`);
 				return;
 			}
 			const oldInfo = this.assetsInfo.get(file);
-			const newInfo = Object.assign({}, oldInfo, assetInfo);
+			const newInfo = { ...oldInfo, ...assetInfo };
 			this._setAssetInfo(file, newInfo, oldInfo);
 			return;
 		}
@@ -4456,7 +4489,9 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 				const entry = oldRelated[key];
 				if (Array.isArray(entry)) {
-					entry.forEach(remove);
+					for (const name of entry) {
+						remove(name);
+					}
 				} else if (entry) {
 					remove(entry);
 				}
@@ -4480,7 +4515,9 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 				const entry = newRelated[key];
 				if (Array.isArray(entry)) {
-					entry.forEach(add);
+					for (const name of entry) {
+						add(name);
+					}
 				} else if (entry) {
 					add(entry);
 				}
@@ -4503,11 +4540,10 @@ This prevents using hashes of each other and should be avoided.`);
 				`Called Compilation.updateAsset for not existing filename ${file}`
 			);
 		}
-		if (typeof newSourceOrFunction === "function") {
-			this.assets[file] = newSourceOrFunction(this.assets[file]);
-		} else {
-			this.assets[file] = newSourceOrFunction;
-		}
+		this.assets[file] =
+			typeof newSourceOrFunction === "function"
+				? newSourceOrFunction(this.assets[file])
+				: newSourceOrFunction;
 		if (assetInfoUpdateOrFunction !== undefined) {
 			const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO;
 			if (typeof assetInfoUpdateOrFunction === "function") {
@@ -4533,14 +4569,12 @@ This prevents using hashes of each other and should be avoided.`);
 				`Called Compilation.renameAsset for not existing filename ${file}`
 			);
 		}
-		if (this.assets[newFile]) {
-			if (!isSourceEqual(this.assets[file], source)) {
-				this.errors.push(
-					new WebpackError(
-						`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
-					)
-				);
-			}
+		if (this.assets[newFile] && !isSourceEqual(this.assets[file], source)) {
+			this.errors.push(
+				new WebpackError(
+					`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
+				)
+			);
 		}
 		const assetInfo = this.assetsInfo.get(file);
 		// Update related in all other assets
@@ -4604,6 +4638,9 @@ This prevents using hashes of each other and should be avoided.`);
 		const related = assetInfo && assetInfo.related;
 		if (related) {
 			for (const key of Object.keys(related)) {
+				/**
+				 * @param {string} file file
+				 */
 				const checkUsedAndDelete = file => {
 					if (!this._assetsRelatedIn.has(file)) {
 						this.deleteAsset(file);
@@ -4611,7 +4648,9 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 				const items = related[key];
 				if (Array.isArray(items)) {
-					items.forEach(checkUsedAndDelete);
+					for (const file of items) {
+						checkUsedAndDelete(file);
+					}
 				} else if (items) {
 					checkUsedAndDelete(items);
 				}
@@ -4645,8 +4684,7 @@ This prevents using hashes of each other and should be avoided.`);
 	 * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
 	 */
 	getAsset(name) {
-		if (!Object.prototype.hasOwnProperty.call(this.assets, name))
-			return undefined;
+		if (!Object.prototype.hasOwnProperty.call(this.assets, name)) return;
 		return {
 			name,
 			source: this.assets[name],
@@ -4729,7 +4767,7 @@ This prevents using hashes of each other and should be avoided.`);
 					);
 					return callback();
 				}
-				asyncLib.forEach(
+				asyncLib.each(
 					manifest,
 					(fileManifest, callback) => {
 						const ident = fileManifest.identifier;
@@ -4741,7 +4779,7 @@ This prevents using hashes of each other and should be avoided.`);
 						);
 
 						assetCacheItem.get((err, sourceFromCache) => {
-							/** @type {string | function(PathData, AssetInfo=): string} */
+							/** @type {TemplatePath} */
 							let filenameTemplate;
 							/** @type {string} */
 							let file;
@@ -4803,9 +4841,8 @@ This prevents using hashes of each other and should be avoided.`);
 													` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`
 											)
 										);
-									} else {
-										source = alreadyWritten.source;
 									}
+									source = alreadyWritten.source;
 								} else if (!source) {
 									// render the asset
 									source = fileManifest.render();
@@ -4846,7 +4883,7 @@ This prevents using hashes of each other and should be avoided.`);
 								}
 							} catch (err) {
 								if (!inTry) throw err;
-								errorAndCallback(err);
+								errorAndCallback(/** @type {Error} */ (err));
 							}
 						});
 					},
@@ -4858,7 +4895,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
 	 * @returns {string} interpolated path
 	 */
@@ -4873,9 +4910,9 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
 	getPathWithInfo(filename, data = {}) {
 		if (!data.hash) {
@@ -4888,7 +4925,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
 	 * @returns {string} interpolated path
 	 */
@@ -4901,9 +4938,9 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
 	getAssetPathWithInfo(filename, data) {
 		const assetInfo = {};
@@ -4928,7 +4965,6 @@ This prevents using hashes of each other and should be avoided.`);
 	 * This function allows you to run another instance of webpack inside of webpack however as
 	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
 	 * from parent (or top level compiler) and creates a child Compilation
-	 *
 	 * @param {string} name name of the child compiler
 	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
 	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
@@ -4957,12 +4993,6 @@ This prevents using hashes of each other and should be avoided.`);
 		processAsyncTree(
 			modules,
 			10,
-			/**
-			 * @param {Module} module the module
-			 * @param {function(Module): void} push push more jobs
-			 * @param {Callback} callback callback
-			 * @returns {void}
-			 */
 			(module, push, callback) => {
 				this.buildQueue.waitFor(module, err => {
 					if (err) return callback(err);
@@ -4993,7 +5023,7 @@ This prevents using hashes of each other and should be avoided.`);
 				const runtimeTemplate = this.runtimeTemplate;
 
 				const chunk = new Chunk("build time chunk", this._backCompat);
-				chunk.id = chunk.name;
+				chunk.id = /** @type {ChunkId} */ (chunk.name);
 				chunk.ids = [chunk.id];
 				chunk.runtime = runtime;
 
@@ -5223,7 +5253,7 @@ This prevents using hashes of each other and should be avoided.`);
 									 * @returns {any} exports
 									 */
 									const __webpack_require_module__ = (moduleArgument, id) => {
-										var execOptions = {
+										const execOptions = {
 											id,
 											module: {
 												id,
@@ -5233,9 +5263,9 @@ This prevents using hashes of each other and should be avoided.`);
 											},
 											require: __webpack_require__
 										};
-										interceptModuleExecution.forEach(handler =>
-											handler(execOptions)
-										);
+										for (const handler of interceptModuleExecution) {
+											handler(execOptions);
+										}
 										const module = moduleArgument.module;
 										this.buildTimeExecutedModules.add(module);
 										const moduleObject = execOptions.module;
@@ -5253,14 +5283,14 @@ This prevents using hashes of each other and should be avoided.`);
 											);
 											moduleObject.loaded = true;
 											return moduleObject.exports;
-										} catch (e) {
+										} catch (execErr) {
 											if (strictModuleExceptionHandling) {
 												if (id) delete moduleCache[id];
 											} else if (strictModuleErrorHandling) {
-												moduleObject.error = e;
+												moduleObject.error = execErr;
 											}
-											if (!e.module) e.module = module;
-											throw e;
+											if (!execErr.module) execErr.module = module;
+											throw execErr;
 										}
 									};
 
@@ -5273,14 +5303,14 @@ This prevents using hashes of each other and should be avoided.`);
 										);
 									}
 									exports = __webpack_require__(module.identifier());
-								} catch (e) {
+								} catch (execErr) {
 									const err = new WebpackError(
 										`Execution of module code from module graph (${module.readableIdentifier(
 											this.requestShortener
-										)}) failed: ${e.message}`
+										)}) failed: ${execErr.message}`
 									);
-									err.stack = e.stack;
-									err.module = e.module;
+									err.stack = execErr.stack;
+									err.module = execErr.module;
 									return callback(err);
 								}
 
@@ -5360,6 +5390,7 @@ This prevents using hashes of each other and should be avoided.`);
  */
 
 // Workaround for typescript as it doesn't support function overloading in jsdoc within a class
+/* eslint-disable jsdoc/require-asterisk-prefix */
 Compilation.prototype.factorizeModule = /**
 	 @type {{
 	(options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
@@ -5369,6 +5400,7 @@ Compilation.prototype.factorizeModule = /**
 		this.factorizeQueue.add(options, callback);
 	}
 );
+/* eslint-enable jsdoc/require-asterisk-prefix */
 
 // Hide from typescript
 const compilationPrototype = Compilation.prototype;