webpack 5.97.1 → 5.104.1

package/lib/Compilation.js

@@ -5,17 +5,17 @@
 
 "use strict";
 
+const util = require("util");
 const asyncLib = require("neo-async");
 const {
+	AsyncParallelHook,
+	AsyncSeriesBailHook,
+	AsyncSeriesHook,
 	HookMap,
-	SyncHook,
 	SyncBailHook,
-	SyncWaterfallHook,
-	AsyncSeriesHook,
-	AsyncSeriesBailHook,
-	AsyncParallelHook
+	SyncHook,
+	SyncWaterfallHook
 } = require("tapable");
-const util = require("util");
 const { CachedSource } = require("webpack-sources");
 const { MultiItemCache } = require("./CacheFacade");
 const Chunk = require("./Chunk");
@@ -32,7 +32,8 @@ const ErrorHelpers = require("./ErrorHelpers");
 const FileSystemInfo = require("./FileSystemInfo");
 const {
 	connectChunkGroupAndChunk,
-	connectChunkGroupParentAndChild
+	connectChunkGroupParentAndChild,
+	connectEntrypointAndDependOn
 } = require("./GraphHelpers");
 const {
 	makeWebpackError,
@@ -56,7 +57,7 @@ const Stats = require("./Stats");
 const WebpackError = require("./WebpackError");
 const buildChunkGraph = require("./buildChunkGraph");
 const BuildCycleError = require("./errors/BuildCycleError");
-const { Logger, LogType } = require("./logging/Logger");
+const { LogType, Logger } = require("./logging/Logger");
 const StatsFactory = require("./stats/StatsFactory");
 const StatsPrinter = require("./stats/StatsPrinter");
 const { equals: arrayEquals } = require("./util/ArrayHelpers");
@@ -66,53 +67,63 @@ const { getOrInsert } = require("./util/MapHelpers");
 const WeakTupleMap = require("./util/WeakTupleMap");
 const { cachedCleverMerge } = require("./util/cleverMerge");
 const {
+	compareIds,
 	compareLocations,
-	concatComparators,
+	compareModulesByIdentifier,
 	compareSelect,
-	compareIds,
 	compareStringsNumeric,
-	compareModulesByIdentifier
+	concatComparators
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const {
 	arrayToSetDeprecation,
-	soonFrozenObjectDeprecation,
-	createFakeHook
+	createFakeHook,
+	soonFrozenObjectDeprecation
 } = require("./util/deprecation");
 const processAsyncTree = require("./util/processAsyncTree");
 const { getRuntimeKey } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
-/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
+/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
+/** @typedef {import("../declarations/WebpackOptions").HashDigest} HashDigest */
+/** @typedef {import("../declarations/WebpackOptions").HashDigestLength} HashDigestLength */
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("../declarations/WebpackOptions").Plugins} Plugins */
+/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
+/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptionsWithDefaults */
 /** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Cache")} Cache */
 /** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./Chunk").ChunkName} ChunkName */
 /** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Compiler").CompilationParams} CompilationParams */
+/** @typedef {import("./Compiler").MemCache} MemCache */
+/** @typedef {import("./Compiler").WeakReferences} WeakReferences */
 /** @typedef {import("./Compiler").ModuleMemCachesItem} ModuleMemCachesItem */
+/** @typedef {import("./Compiler").Records} Records */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
-/** @typedef {import("./DependencyTemplate")} DependencyTemplate */
+/** @typedef {import("./Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module").NameForCondition} NameForCondition */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
+/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
 /** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
+/** @typedef {import("./Module").FactoryMeta} FactoryMeta */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModule").ParserOptions} ParserOptions */
+/** @typedef {import("./NormalModule").GeneratorOptions} GeneratorOptions */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
@@ -122,14 +133,19 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
 /** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/createHash").Algorithm} Algorithm */
+
+/**
+ * @template T
+ * @typedef {import("tapable").AsArray<T>} AsArray<T>
+ */
+
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
  */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {WeakMap<Dependency, Module>} References */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
 /**
  * @callback Callback
  * @param {(WebpackError | null)=} err
@@ -138,39 +154,33 @@ const { isSourceEqual } = require("./util/source");
 
 /**
  * @callback ModuleCallback
- * @param {(WebpackError | null)=} err
- * @param {(Module | null)=} result
+ * @param {WebpackError | null=} err
+ * @param {Module | null=} result
  * @returns {void}
  */
 
 /**
  * @callback ModuleFactoryResultCallback
- * @param {(WebpackError | null)=} err
- * @param {ModuleFactoryResult=} result
+ * @param {WebpackError | null=} err
+ * @param {ModuleFactoryResult | null=} result
  * @returns {void}
  */
 
 /**
- * @callback ModuleOrFactoryResultCallback
- * @param {(WebpackError | null)=} err
- * @param {Module | ModuleFactoryResult=} result
+ * @callback ModuleOrModuleFactoryResultCallback
+ * @param {WebpackError | null=} err
+ * @param {Module | ModuleFactoryResult | null=} result
  * @returns {void}
  */
 
 /**
  * @callback ExecuteModuleCallback
- * @param {WebpackError | null} err
- * @param {ExecuteModuleResult=} result
+ * @param {WebpackError | null=} err
+ * @param {ExecuteModuleResult | null=} result
  * @returns {void}
  */
 
-/**
- * @callback DepBlockVarDependenciesCallback
- * @param {Dependency} dependency
- * @returns {any}
- */
-
-/** @typedef {new (...args: any[]) => Dependency} DepConstructor */
+/** @typedef {new (...args: EXPECTED_ANY[]) => Dependency} DependencyConstructor */
 
 /** @typedef {Record<string, Source>} CompilationAssets */
 
@@ -187,14 +197,16 @@ const { isSourceEqual } = require("./util/source");
  * @property {AsyncDependenciesBlock[]} blocks
  */
 
+/** @typedef {Set<Chunk>} Chunks */
+
 /**
  * @typedef {object} ChunkPathData
- * @property {string|number} id
+ * @property {string | number} id
  * @property {string=} name
  * @property {string} hash
- * @property {function(number): string=} hashWithLength
+ * @property {HashWithLengthFunction=} hashWithLength
  * @property {(Record<string, string>)=} contentHash
- * @property {(Record<string, (length: number) => string>)=} contentHashWithLength
+ * @property {(Record<string, HashWithLengthFunction>)=} contentHashWithLength
  */
 
 /**
@@ -216,34 +228,53 @@ const { isSourceEqual } = require("./util/source");
  * @property {EntryOptions=} entryOptions
  */
 
+/** @typedef {LazySet<string>} FileSystemDependencies */
+
+/** @typedef {EXPECTED_ANY} ExecuteModuleExports */
+
 /**
  * @typedef {object} ExecuteModuleResult
- * @property {any} exports
+ * @property {ExecuteModuleExports} exports
  * @property {boolean} cacheable
- * @property {Map<string, { source: Source, info: AssetInfo }>} assets
- * @property {LazySet<string>} fileDependencies
- * @property {LazySet<string>} contextDependencies
- * @property {LazySet<string>} missingDependencies
- * @property {LazySet<string>} buildDependencies
+ * @property {ExecuteModuleAssets} assets
+ * @property {FileSystemDependencies} fileDependencies
+ * @property {FileSystemDependencies} contextDependencies
+ * @property {FileSystemDependencies} missingDependencies
+ * @property {FileSystemDependencies} buildDependencies
+ */
+
+/**
+ * @typedef {object} ExecuteModuleObject
+ * @property {string=} id module id
+ * @property {ExecuteModuleExports} exports exports
+ * @property {boolean} loaded is loaded
+ * @property {Error=} error error
  */
 
 /**
- * @typedef {{ id: string, exports: any, loaded: boolean }} ModuleObject
- *
- * /**
  * @typedef {object} ExecuteModuleArgument
  * @property {Module} module
- * @property {ModuleObject=} moduleObject
- * @property {any} preparedInfo
+ * @property {ExecuteModuleObject=} moduleObject
  * @property {CodeGenerationResult} codeGenerationResult
  */
 
+/** @typedef {((id: string) => ExecuteModuleExports) & { i?: ((options: ExecuteOptions) => void)[], c?: Record<string, ExecuteModuleObject> }} WebpackRequire */
+
+/**
+ * @typedef {object} ExecuteOptions
+ * @property {string=} id module id
+ * @property {ExecuteModuleObject} module module
+ * @property {WebpackRequire} require require function
+ */
+
+/** @typedef {Map<string, { source: Source, info: AssetInfo | undefined }>} ExecuteModuleAssets */
+
 /**
  * @typedef {object} ExecuteModuleContext
- * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {ExecuteModuleAssets} assets
  * @property {Chunk} chunk
  * @property {ChunkGraph} chunkGraph
- * @property {function(string): any=} __webpack_require__
+ * @property {WebpackRequire=} __webpack_require__
  */
 
 /**
@@ -256,7 +287,7 @@ const { isSourceEqual } = require("./util/source");
 /**
  * @typedef {object} LogEntry
  * @property {string} type
- * @property {any[]=} args
+ * @property {EXPECTED_ANY[]=} args
  * @property {number} time
  * @property {string[]=} trace
  */
@@ -274,10 +305,11 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
  * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
  * @property {boolean=} javascriptModule true, when asset is javascript and an ESM
- * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
+ * @property {boolean=} manifest true, when file is a manifest
+ * @property {Record<string, null | string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
  */
 
-/** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
+/** @typedef {KnownAssetInfo & Record<string, EXPECTED_ANY>} AssetInfo */
 
 /** @typedef {{ path: string, info: AssetInfo }} InterpolatedPathAndAssetInfo */
 
@@ -288,40 +320,47 @@ const { isSourceEqual } = require("./util/source");
  * @property {AssetInfo} info info about the asset
  */
 
+/** @typedef {(length: number) => string} HashWithLengthFunction */
+
 /**
  * @typedef {object} ModulePathData
- * @property {string|number} id
+ * @property {string | number} id
  * @property {string} hash
- * @property {function(number): string=} hashWithLength
+ * @property {HashWithLengthFunction=} hashWithLength
  */
 
+/** @typedef {(id: string | number) => string | number} PrepareIdFunction */
+
 /**
  * @typedef {object} PathData
  * @property {ChunkGraph=} chunkGraph
  * @property {string=} hash
- * @property {function(number): string=} hashWithLength
- * @property {(Chunk|ChunkPathData)=} chunk
- * @property {(Module|ModulePathData)=} module
+ * @property {HashWithLengthFunction=} hashWithLength
+ * @property {(Chunk | ChunkPathData)=} chunk
+ * @property {(Module | ModulePathData)=} module
  * @property {RuntimeSpec=} runtime
  * @property {string=} filename
  * @property {string=} basename
  * @property {string=} query
  * @property {string=} contentHashType
  * @property {string=} contentHash
- * @property {function(number): string=} contentHashWithLength
+ * @property {HashWithLengthFunction=} contentHashWithLength
  * @property {boolean=} noChunkHash
  * @property {string=} url
+ * @property {PrepareIdFunction=} prepareId
  */
 
+/** @typedef {"module" | "chunk" | "root-of-chunk" | "nested"} ExcludeModulesType */
+
 /**
  * @typedef {object} KnownNormalizedStatsOptions
  * @property {string} context
  * @property {RequestShortener} requestShortener
- * @property {string} chunksSort
- * @property {string} modulesSort
- * @property {string} chunkModulesSort
- * @property {string} nestedModulesSort
- * @property {string} assetsSort
+ * @property {string | false} chunksSort
+ * @property {string | false} modulesSort
+ * @property {string | false} chunkModulesSort
+ * @property {string | false} nestedModulesSort
+ * @property {string | false} assetsSort
  * @property {boolean} ids
  * @property {boolean} cachedAssets
  * @property {boolean} groupAssetsByEmitStatus
@@ -329,7 +368,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {boolean} groupAssetsByExtension
  * @property {number} assetsSpace
  * @property {((value: string, asset: StatsAsset) => boolean)[]} excludeAssets
- * @property {((name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean)[]} excludeModules
+ * @property {((name: string, module: StatsModule, type: ExcludeModulesType) => boolean)[]} excludeModules
  * @property {((warning: StatsError, textValue: string) => boolean)[]} warningsFilter
  * @property {boolean} cachedModules
  * @property {boolean} orphanModules
@@ -349,22 +388,24 @@ const { isSourceEqual } = require("./util/source");
  * @property {number} modulesSpace
  * @property {number} chunkModulesSpace
  * @property {number} nestedModulesSpace
- * @property {false|"none"|"error"|"warn"|"info"|"log"|"verbose"} logging
+ * @property {false | "none" | "error" | "warn" | "info" | "log" | "verbose"} logging
  * @property {((value: string) => boolean)[]} loggingDebug
  * @property {boolean} loggingTrace
- * @property {any} _env
+ * @property {EXPECTED_ANY} _env
  */
 
-/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
+/** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, EXPECTED_ANY>} NormalizedStatsOptions */
 
 /**
  * @typedef {object} KnownCreateStatsOptionsContext
  * @property {boolean=} forToString
  */
 
-/** @typedef {Record<string, any> & KnownCreateStatsOptionsContext} CreateStatsOptionsContext */
+/** @typedef {KnownCreateStatsOptionsContext & Record<string, EXPECTED_ANY>} CreateStatsOptionsContext */
+
+/** @typedef {{ module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}} CodeGenerationJob */
 
-/** @typedef {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} CodeGenerationJobs */
+/** @typedef {CodeGenerationJob[]} CodeGenerationJobs */
 
 /** @typedef {{javascript: ModuleTemplate}} ModuleTemplates */
 
@@ -381,7 +422,7 @@ const deprecatedNormalModuleLoaderHook = util.deprecate(
 	 * @param {Compilation} compilation compilation
 	 * @returns {NormalModuleCompilationHooks["loader"]} hooks
 	 */
-	compilation =>
+	(compilation) =>
 		require("./NormalModule").getCompilationHooks(compilation).loader,
 	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
 	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
@@ -391,7 +432,7 @@ const deprecatedNormalModuleLoaderHook = util.deprecate(
 /**
  * @param {ModuleTemplates | undefined} moduleTemplates module templates
  */
-const defineRemovedModuleTemplates = moduleTemplates => {
+const defineRemovedModuleTemplates = (moduleTemplates) => {
 	Object.defineProperties(moduleTemplates, {
 		asset: {
 			enumerable: false,
@@ -415,30 +456,50 @@ const defineRemovedModuleTemplates = moduleTemplates => {
 	moduleTemplates = undefined;
 };
 
-const byId = compareSelect(c => c.id, compareIds);
+const byId = compareSelect((c) => c.id, compareIds);
 
 const byNameOrHash = concatComparators(
-	compareSelect(c => c.name, compareIds),
-	compareSelect(c => c.fullHash, compareIds)
+	compareSelect((c) => c.name, compareIds),
+	compareSelect((c) => c.fullHash, compareIds)
 );
 
-const byMessage = compareSelect(err => `${err.message}`, compareStringsNumeric);
+const byMessage = compareSelect(
+	(err) => `${err.message}`,
+	compareStringsNumeric
+);
 
 const byModule = compareSelect(
-	err => (err.module && err.module.identifier()) || "",
+	(err) => (err.module && err.module.identifier()) || "",
 	compareStringsNumeric
 );
 
-const byLocation = compareSelect(err => err.loc, compareLocations);
+const byLocation = compareSelect((err) => err.loc, compareLocations);
 
 const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
-/** @type {WeakMap<Dependency, Module & { restoreFromUnsafeCache: Function } | null>} */
+/**
+ * @typedef {object} KnownUnsafeCacheData
+ * @property {FactoryMeta=} factoryMeta factory meta
+ * @property {ResolveOptions=} resolveOptions resolve options
+ * @property {ParserOptions=} parserOptions
+ * @property {GeneratorOptions=} generatorOptions
+ */
+
+/** @typedef {KnownUnsafeCacheData & Record<string, EXPECTED_ANY>} UnsafeCacheData */
+
+/**
+ * @typedef {Module & { restoreFromUnsafeCache?: (unsafeCacheData: UnsafeCacheData, moduleFactory: ModuleFactory, compilationParams: CompilationParams) => void }} ModuleWithRestoreFromUnsafeCache
+ */
+
+/** @type {WeakMap<Dependency, ModuleWithRestoreFromUnsafeCache | null>} */
 const unsafeCacheDependencies = new WeakMap();
 
-/** @type {WeakMap<Module & { restoreFromUnsafeCache: Function }, object>} */
+/** @type {WeakMap<ModuleWithRestoreFromUnsafeCache, UnsafeCacheData>} */
 const unsafeCacheData = new WeakMap();
 
+/** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, blocks?: (ChunkId | null)[] }} References */
+/** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */
+
 class Compilation {
 	/**
 	 * Creates an instance of Compilation.
@@ -449,7 +510,7 @@ class Compilation {
 		this._backCompat = compiler._backCompat;
 
 		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
-		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
+		/** @typedef {{ additionalAssets?: boolean | ((assets: CompilationAssets) => void) }} ProcessAssetsAdditionalOptions */
 		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
 		const processAssetsHook = new AsyncSeriesHook(["assets"]);
 
@@ -458,7 +519,7 @@ class Compilation {
 		 * @param {CompilationAssets} assets assets
 		 * @returns {CompilationAssets} new assets
 		 */
-		const popNewAssets = assets => {
+		const popNewAssets = (assets) => {
 			let newAssets;
 			for (const file of Object.keys(assets)) {
 				if (savedAssets.has(file)) continue;
@@ -475,31 +536,59 @@ class Compilation {
 			call: () => {
 				savedAssets = new Set(Object.keys(this.assets));
 			},
-			register: tap => {
+			register: (tap) => {
 				const { type, name } = tap;
 				const { fn, additionalAssets, ...remainingTap } = tap;
 				const additionalAssetsFn =
 					additionalAssets === true ? fn : additionalAssets;
+				/** @typedef {WeakSet<CompilationAssets>} ProcessedAssets */
+
+				/** @type {ProcessedAssets | undefined} */
 				const processedAssets = additionalAssetsFn ? new WeakSet() : undefined;
+				/**
+				 * @param {CompilationAssets} assets to be processed by additionalAssetsFn
+				 * @returns {CompilationAssets} available assets
+				 */
+				const getAvailableAssets = (assets) => {
+					/** @type {CompilationAssets} */
+					const availableAssets = {};
+					for (const file of Object.keys(assets)) {
+						// https://github.com/webpack-contrib/compression-webpack-plugin/issues/390
+						if (this.assets[file]) {
+							availableAssets[file] = assets[file];
+						}
+					}
+					return availableAssets;
+				};
 				switch (type) {
 					case "sync":
 						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tap(name, assets => {
-								if (processedAssets.has(this.assets))
-									additionalAssetsFn(assets);
+							this.hooks.processAdditionalAssets.tap(name, (assets) => {
+								if (
+									/** @type {ProcessedAssets} */
+									(processedAssets).has(this.assets)
+								) {
+									additionalAssetsFn(getAvailableAssets(assets));
+								}
 							});
 						}
 						return {
 							...remainingTap,
 							type: "async",
+							/**
+							 * @param {CompilationAssets} assets assets
+							 * @param {(err?: Error | null, result?: void) => void} callback callback
+							 * @returns {void}
+							 */
 							fn: (assets, callback) => {
 								try {
 									fn(assets);
 								} catch (err) {
-									return callback(err);
+									return callback(/** @type {Error} */ (err));
 								}
-								if (processedAssets !== undefined)
+								if (processedAssets !== undefined) {
 									processedAssets.add(this.assets);
+								}
 								const newAssets = popNewAssets(assets);
 								if (newAssets !== undefined) {
 									this.hooks.processAdditionalAssets.callAsync(
@@ -516,47 +605,76 @@ class Compilation {
 							this.hooks.processAdditionalAssets.tapAsync(
 								name,
 								(assets, callback) => {
-									if (processedAssets.has(this.assets))
-										return additionalAssetsFn(assets, callback);
+									if (
+										/** @type {ProcessedAssets} */
+										(processedAssets).has(this.assets)
+									) {
+										return additionalAssetsFn(
+											getAvailableAssets(assets),
+											callback
+										);
+									}
 									callback();
 								}
 							);
 						}
 						return {
 							...remainingTap,
+							/**
+							 * @param {CompilationAssets} assets assets
+							 * @param {(err?: Error | null, result?: void) => void} callback callback
+							 * @returns {void}
+							 */
 							fn: (assets, callback) => {
-								fn(assets, err => {
-									if (err) return callback(err);
-									if (processedAssets !== undefined)
-										processedAssets.add(this.assets);
-									const newAssets = popNewAssets(assets);
-									if (newAssets !== undefined) {
-										this.hooks.processAdditionalAssets.callAsync(
-											newAssets,
-											callback
-										);
-										return;
+								fn(
+									assets,
+									/**
+									 * @param {Error} err err
+									 * @returns {void}
+									 */
+									(err) => {
+										if (err) return callback(err);
+										if (processedAssets !== undefined) {
+											processedAssets.add(this.assets);
+										}
+										const newAssets = popNewAssets(assets);
+										if (newAssets !== undefined) {
+											this.hooks.processAdditionalAssets.callAsync(
+												newAssets,
+												callback
+											);
+											return;
+										}
+										callback();
 									}
-									callback();
-								});
+								);
 							}
 						};
 					case "promise":
 						if (additionalAssetsFn) {
-							this.hooks.processAdditionalAssets.tapPromise(name, assets => {
-								if (processedAssets.has(this.assets))
-									return additionalAssetsFn(assets);
+							this.hooks.processAdditionalAssets.tapPromise(name, (assets) => {
+								if (
+									/** @type {ProcessedAssets} */
+									(processedAssets).has(this.assets)
+								) {
+									return additionalAssetsFn(getAvailableAssets(assets));
+								}
 								return Promise.resolve();
 							});
 						}
 						return {
 							...remainingTap,
-							fn: assets => {
+							/**
+							 * @param {CompilationAssets} assets assets
+							 * @returns {Promise<CompilationAssets>} result
+							 */
+							fn: (assets) => {
 								const p = fn(assets);
 								if (!p || !p.then) return p;
 								return p.then(() => {
-									if (processedAssets !== undefined)
+									if (processedAssets !== undefined) {
 										processedAssets.add(this.assets);
+									}
 									const newAssets = popNewAssets(assets);
 									if (newAssets !== undefined) {
 										return this.hooks.processAdditionalAssets.promise(
@@ -577,9 +695,9 @@ class Compilation {
 		 * @template T
 		 * @param {string} name name of the hook
 		 * @param {number} stage new stage
-		 * @param {function(): AsArray<T>} getArgs get old hook function args
+		 * @param {() => AsArray<T>} getArgs get old hook function args
 		 * @param {string=} code deprecation code (not deprecated when unset)
-		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
+		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">> | undefined} fake hook which redirects
 		 */
 		const createProcessAssetsHook = (name, stage, getArgs, code) => {
 			if (!this._backCompat && code) return;
@@ -587,10 +705,15 @@ class Compilation {
 			 * @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}.
+			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.`;
-			const getOptions = options => {
+			/**
+			 * @param {string | (import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions)} options hook options
+			 * @returns {import("tapable").TapOptions & { name: string } & ProcessAssetsAdditionalOptions} modified options
+			 */
+			const getOptions = (options) => {
 				if (typeof options === "string") options = { name: options };
 				if (options.stage) {
 					throw new Error(errorMessage("it's using the 'stage' option"));
@@ -601,7 +724,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				{
 					name,
 					/** @type {AsyncSeriesHook<T>["intercept"]} */
-					intercept(interceptor) {
+					intercept(_interceptor) {
 						throw new Error(errorMessage("it's using 'intercept'"));
 					},
 					/** @type {AsyncSeriesHook<T>["tap"]} */
@@ -613,7 +736,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						processAssetsHook.tapAsync(
 							getOptions(options),
 							(assets, callback) =>
-								/** @type {any} */ (fn)(...getArgs(), callback)
+								/** @type {EXPECTED_ANY} */ (fn)(...getArgs(), callback)
 						);
 					},
 					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
@@ -646,7 +769,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[Dependency, EntryOptions, Module]>} */
 			succeedEntry: new SyncHook(["entry", "options", "module"]),
 
-			/** @type {SyncWaterfallHook<[(string[] | ReferencedExport)[], Dependency, RuntimeSpec]>} */
+			/** @type {SyncWaterfallHook<[ReferencedExports, Dependency, RuntimeSpec]>} */
 			dependencyReferencedExports: new SyncWaterfallHook([
 				"referencedExports",
 				"dependency",
@@ -706,33 +829,33 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncBailHook<[], boolean | void>} */
 			shouldRecord: new SyncBailHook([]),
 
-			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+			/** @type {SyncHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext]>} */
 			additionalChunkRuntimeRequirements: new SyncHook([
 				"chunk",
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInChunk: new HookMap(
 				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
-			/** @type {SyncHook<[Module, Set<string>, RuntimeRequirementsContext]>} */
+			/** @type {SyncHook<[Module, RuntimeRequirements, RuntimeRequirementsContext]>} */
 			additionalModuleRuntimeRequirements: new SyncHook([
 				"module",
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], void>>} */
+			/** @type {HookMap<SyncBailHook<[Module, RuntimeRequirements, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInModule: new HookMap(
 				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
 			),
-			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
+			/** @type {SyncHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext]>} */
 			additionalTreeRuntimeRequirements: new SyncHook([
 				"chunk",
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, RuntimeRequirements, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInTree: new HookMap(
 				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
@@ -740,7 +863,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[RuntimeModule, Chunk]>} */
 			runtimeModule: new SyncHook(["module", "chunk"]),
 
-			/** @type {SyncHook<[Iterable<Module>, any]>} */
+			/** @type {SyncHook<[Iterable<Module>, Records]>} */
 			reviveModules: new SyncHook(["modules", "records"]),
 			/** @type {SyncHook<[Iterable<Module>]>} */
 			beforeModuleIds: new SyncHook(["modules"]),
@@ -751,7 +874,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[Iterable<Module>]>} */
 			afterOptimizeModuleIds: new SyncHook(["modules"]),
 
-			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
+			/** @type {SyncHook<[Iterable<Chunk>, Records]>} */
 			reviveChunks: new SyncHook(["chunks", "records"]),
 			/** @type {SyncHook<[Iterable<Chunk>]>} */
 			beforeChunkIds: new SyncHook(["chunks"]),
@@ -762,9 +885,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[Iterable<Chunk>]>} */
 			afterOptimizeChunkIds: new SyncHook(["chunks"]),
 
-			/** @type {SyncHook<[Iterable<Module>, any]>} */
+			/** @type {SyncHook<[Iterable<Module>, Records]>} */
 			recordModules: new SyncHook(["modules", "records"]),
-			/** @type {SyncHook<[Iterable<Chunk>, any]>} */
+			/** @type {SyncHook<[Iterable<Chunk>, Records]>} */
 			recordChunks: new SyncHook(["chunks", "records"]),
 
 			/** @type {SyncHook<[Iterable<Module>]>} */
@@ -791,9 +914,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			contentHash: new SyncHook(["chunk"]),
 			/** @type {SyncHook<[]>} */
 			afterHash: new SyncHook([]),
-			/** @type {SyncHook<[any]>} */
+			/** @type {SyncHook<[Records]>} */
 			recordHash: new SyncHook(["records"]),
-			/** @type {SyncHook<[Compilation, any]>} */
+			/** @type {SyncHook<[Compilation, Records]>} */
 			record: new SyncHook(["compilation", "records"]),
 
 			/** @type {SyncHook<[]>} */
@@ -804,36 +927,52 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			beforeChunkAssets: new SyncHook([]),
 			// TODO webpack 6 remove
 			/** @deprecated */
-			additionalChunkAssets: createProcessAssetsHook(
-				"additionalChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"
-			),
+			additionalChunkAssets:
+				/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
+				(
+					createProcessAssetsHook(
+						"additionalChunkAssets",
+						Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+						() => [this.chunks],
+						"DEP_WEBPACK_COMPILATION_ADDITIONAL_CHUNK_ASSETS"
+					)
+				),
 
 			// TODO webpack 6 deprecate
 			/** @deprecated */
-			additionalAssets: createProcessAssetsHook(
-				"additionalAssets",
-				Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-				() => []
-			),
+			additionalAssets:
+				/** @type {FakeHook<Pick<AsyncSeriesHook<[]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
+				(
+					createProcessAssetsHook(
+						"additionalAssets",
+						Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+						() => []
+					)
+				),
 			// TODO webpack 6 remove
 			/** @deprecated */
-			optimizeChunkAssets: createProcessAssetsHook(
-				"optimizeChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
-			),
+			optimizeChunkAssets:
+				/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
+				(
+					createProcessAssetsHook(
+						"optimizeChunkAssets",
+						Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE,
+						() => [this.chunks],
+						"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
+					)
+				),
 			// TODO webpack 6 remove
 			/** @deprecated */
-			afterOptimizeChunkAssets: createProcessAssetsHook(
-				"afterOptimizeChunkAssets",
-				Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,
-				() => [this.chunks],
-				"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"
-			),
+			afterOptimizeChunkAssets:
+				/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
+				(
+					createProcessAssetsHook(
+						"afterOptimizeChunkAssets",
+						Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE + 1,
+						() => [this.chunks],
+						"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"
+					)
+				),
 			// TODO webpack 6 deprecate
 			/** @deprecated */
 			optimizeAssets: processAssetsHook,
@@ -864,7 +1003,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[Chunk, string]>} */
 			chunkAsset: new SyncHook(["chunk", "filename"]),
 
-			/** @type {SyncWaterfallHook<[string, object, AssetInfo | undefined]>} */
+			/** @type {SyncWaterfallHook<[string, PathData, AssetInfo | undefined]>} */
 			assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
 
 			/** @type {SyncBailHook<[], boolean | void>} */
@@ -880,9 +1019,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncBailHook<[string, LogEntry], boolean | void>} */
 			log: new SyncBailHook(["origin", "logEntry"]),
 
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processWarnings: new SyncWaterfallHook(["warnings"]),
-			/** @type {SyncWaterfallHook<[WebpackError[]]>} */
+			/** @type {SyncWaterfallHook<[Error[]]>} */
 			processErrors: new SyncWaterfallHook(["errors"]),
 
 			/** @type {HookMap<SyncHook<[Partial<NormalizedStatsOptions>, CreateStatsOptionsContext]>>} */
@@ -936,7 +1075,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		const options = /** @type {WebpackOptions} */ (compiler.options);
 		this.options = options;
-		this.outputOptions = options && options.output;
+		this.outputOptions =
+			/** @type {OutputOptionsWithDefaults} */
+			(options && options.output);
 		/** @type {boolean} */
 		this.bail = (options && options.bail) || false;
 		/** @type {boolean} */
@@ -956,14 +1097,19 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 		defineRemovedModuleTemplates(this.moduleTemplates);
 
-		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		// We need to think how implement types here
+		/** @type {ModuleMemCaches | undefined} */
 		this.moduleMemCaches = undefined;
-		/** @type {Map<Module, WeakTupleMap<any, any>> | undefined} */
+		/** @type {ModuleMemCaches | undefined} */
 		this.moduleMemCaches2 = undefined;
+		/** @type {ModuleGraph} */
 		this.moduleGraph = new ModuleGraph();
 		/** @type {ChunkGraph} */
-		this.chunkGraph = undefined;
-		/** @type {CodeGenerationResults} */
+		this.chunkGraph = new ChunkGraph(
+			this.moduleGraph,
+			this.outputOptions.hashFunction
+		);
+		/** @type {CodeGenerationResults | undefined} */
 		this.codeGenerationResults = undefined;
 
 		/** @type {AsyncQueue<Module, Module, Module>} */
@@ -976,7 +1122,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.addModuleQueue = new AsyncQueue({
 			name: "addModule",
 			parent: this.processDependenciesQueue,
-			getKey: module => module.identifier(),
+			getKey: (module) => module.identifier(),
 			processor: this._addModule.bind(this)
 		});
 		/** @type {AsyncQueue<FactorizeModuleOptions, string, Module | ModuleFactoryResult>} */
@@ -1006,7 +1152,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 */
 		this.creatingModuleDuringBuild = new WeakMap();
 
-		/** @type {Map<string, EntryData>} */
+		/** @type {Map<Exclude<ChunkName, null>, EntryData>} */
 		this.entries = new Map();
 		/** @type {EntryData} */
 		this.globalEntry = {
@@ -1020,7 +1166,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.entrypoints = new Map();
 		/** @type {Entrypoint[]} */
 		this.asyncEntrypoints = [];
-		/** @type {Set<Chunk>} */
+		/** @type {Chunks} */
 		this.chunks = new Set();
 		/** @type {ChunkGroup[]} */
 		this.chunkGroups = [];
@@ -1039,6 +1185,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @type {Map<string, Module>}
 		 */
 		this._modules = new Map();
+		/** @type {Records | null} */
 		this.records = null;
 		/** @type {string[]} */
 		this.additionalChunkAssets = [];
@@ -1048,15 +1195,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo = new Map();
 		/** @type {Map<string, Map<string, Set<string>>>} */
 		this._assetsRelatedIn = new Map();
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.errors = [];
-		/** @type {WebpackError[]} */
+		/** @type {Error[]} */
 		this.warnings = [];
 		/** @type {Compilation[]} */
 		this.children = [];
 		/** @type {Map<string, LogEntry[]>} */
 		this.logging = new Map();
-		/** @type {Map<DepConstructor, ModuleFactory>} */
+		/** @type {Map<DependencyConstructor, ModuleFactory>} */
 		this.dependencyFactories = new Map();
 		/** @type {DependencyTemplates} */
 		this.dependencyTemplates = new DependencyTemplates(
@@ -1064,15 +1211,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 		/** @type {Record<string, number>} */
 		this.childrenCounters = {};
-		/** @type {Set<number|string>} */
+		/** @type {Set<number> | null} */
 		this.usedChunkIds = null;
-		/** @type {Set<number>} */
+		/** @type {Set<number> | null} */
 		this.usedModuleIds = null;
 		/** @type {boolean} */
 		this.needAdditionalPass = false;
-		/** @type {Set<Module & { restoreFromUnsafeCache: Function }>} */
+		/** @type {Set<ModuleWithRestoreFromUnsafeCache>} */
 		this._restoredUnsafeCacheModuleEntries = new Set();
-		/** @type {Map<string, Module & { restoreFromUnsafeCache: Function }>} */
+		/** @type {Map<string, ModuleWithRestoreFromUnsafeCache>} */
 		this._restoredUnsafeCacheEntries = new Map();
 		/** @type {WeakSet<Module>} */
 		this.builtModules = new WeakSet();
@@ -1084,22 +1231,22 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.emittedAssets = new Set();
 		/** @type {Set<string>} */
 		this.comparedForEmitAssets = new Set();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.fileDependencies = new LazySet();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.contextDependencies = new LazySet();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.missingDependencies = new LazySet();
-		/** @type {LazySet<string>} */
+		/** @type {FileSystemDependencies} */
 		this.buildDependencies = new LazySet();
 		// TODO webpack 6 remove
 		this.compilationDependencies = {
 			add: util.deprecate(
 				/**
 				 * @param {string} item item
-				 * @returns {LazySet<string>} file dependencies
+				 * @returns {FileSystemDependencies} file dependencies
 				 */
-				item => this.fileDependencies.add(item),
+				(item) => this.fileDependencies.add(item),
 				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
 				"DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
 			)
@@ -1137,7 +1284,6 @@ 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[/** @type {keyof StatsOptions} */ (key)];
 			}
@@ -1182,7 +1328,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
-	 * @param {string | (function(): string)} name name of the logger, or function called once to get the logger name
+	 * @param {string | (() => string)} name name of the logger, or function called once to get the logger name
 	 * @returns {Logger} a logger with that name
 	 */
 	getLogger(name) {
@@ -1220,6 +1366,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					args,
 					trace
 				};
+				/* eslint-disable no-console */
 				if (this.hooks.log.call(name, logEntry) === undefined) {
 					if (
 						logEntry.type === LogType.profileEnd &&
@@ -1248,9 +1395,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							}`
 						);
 					}
+					/* eslint-enable no-console */
 				}
 			},
-			childName => {
+			(childName) => {
 				if (typeof name === "function") {
 					if (typeof childName === "function") {
 						return this.getLogger(() => {
@@ -1348,8 +1496,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 			this._modules.set(identifier, module);
 			this.modules.add(module);
-			if (this._backCompat)
+			if (this._backCompat) {
 				ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+			}
 			if (currentProfile !== undefined) {
 				currentProfile.markIntegrationEnd();
 			}
@@ -1423,8 +1572,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.options,
 					this,
 					this.resolverFactory.get("normal", module.resolveOptions),
-					/** @type {InputFileSystem} */ (this.inputFileSystem),
-					err => {
+					/** @type {InputFileSystem} */
+					(this.inputFileSystem),
+					(err) => {
 						if (currentProfile !== undefined) {
 							currentProfile.markBuildingEnd();
 						}
@@ -1435,20 +1585,25 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						if (currentProfile !== undefined) {
 							currentProfile.markStoringStart();
 						}
-						this._modulesCache.store(module.identifier(), null, module, err => {
-							if (currentProfile !== undefined) {
-								currentProfile.markStoringEnd();
-							}
-							if (err) {
-								this.hooks.failedModule.call(
-									module,
-									/** @type {WebpackError} */ (err)
-								);
-								return callback(new ModuleStoreError(module, err));
+						this._modulesCache.store(
+							module.identifier(),
+							null,
+							module,
+							(err) => {
+								if (currentProfile !== undefined) {
+									currentProfile.markStoringEnd();
+								}
+								if (err) {
+									this.hooks.failedModule.call(
+										module,
+										/** @type {WebpackError} */ (err)
+									);
+									return callback(new ModuleStoreError(module, err));
+								}
+								this.hooks.succeedModule.call(module);
+								return callback();
 							}
-							this.hooks.succeedModule.call(module);
-							return callback();
-						});
+						);
 					}
 				);
 			}
@@ -1472,7 +1627,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/**
 		 * @param {DependenciesBlock} block block
 		 */
-		const processDependenciesBlock = block => {
+		const processDependenciesBlock = (block) => {
 			if (block.dependencies) {
 				let i = 0;
 				for (const dep of block.dependencies) {
@@ -1493,15 +1648,19 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], context: string|undefined, originModule: Module|null}>} */
+		/** @type {{ factory: ModuleFactory, dependencies: Dependency[], context: string | undefined, originModule: Module | null }[]} */
 		const sortedDependencies = [];
+		/** @type {boolean} */
+		const hasLowPriorityDependencies = module.dependencies.some(
+			Dependency.isLowPriorityDependency
+		);
 
 		/** @type {DependenciesBlock} */
 		let currentBlock;
 
 		/** @type {Map<ModuleFactory, Map<string, Dependency[]>>} */
 		let dependencies;
-		/** @type {DepConstructor} */
+		/** @type {DependencyConstructor} */
 		let factoryCacheKey;
 		/** @type {ModuleFactory} */
 		let factoryCacheKey2;
@@ -1522,7 +1681,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @param {WebpackError=} err error
 		 * @returns {void}
 		 */
-		const onDependenciesSorted = err => {
+		const onDependenciesSorted = (err) => {
 			if (err) return callback(err);
 
 			// early exit without changing parallelism back and forth
@@ -1536,7 +1695,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 => {
+				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
 					// leaking the Compilation object.
@@ -1558,7 +1717,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @param {WebpackError=} err error
 		 * @returns {void}
 		 */
-		const onTransitiveTasksFinished = err => {
+		const onTransitiveTasksFinished = (err) => {
 			if (err) return callback(err);
 			this.processDependenciesQueue.decreaseParallelism();
 
@@ -1635,14 +1794,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 											module,
 											dep,
 											cachedModule,
-											err => {
+											(err) => {
 												if (err) {
 													if (inProgressTransitive <= 0) return;
 													inProgressTransitive = -1;
 													onTransitiveTasksFinished(err);
 												}
-												if (--inProgressTransitive === 0)
+												if (--inProgressTransitive === 0) {
 													return onTransitiveTasksFinished();
+												}
 											}
 										);
 										if (--inProgressSorting === 0) onDependenciesSorted();
@@ -1668,6 +1828,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						return;
 					}
 				} catch (err) {
+					// eslint-disable-next-line no-console
 					console.error(err);
 				}
 			}
@@ -1678,11 +1839,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @param {Dependency} dep dependency
 		 * @returns {void}
 		 */
-		const processDependencyForResolving = dep => {
+		const processDependencyForResolving = (dep) => {
 			const resourceIdent = dep.getResourceIdentifier();
 			if (resourceIdent !== undefined && resourceIdent !== null) {
 				const category = dep.category;
-				const constructor = /** @type {DepConstructor} */ (dep.constructor);
+				const constructor =
+					/** @type {DependencyConstructor} */
+					(dep.constructor);
 				if (factoryCacheKey === constructor) {
 					// Fast path 1: same constructor as prev item
 					if (listCacheKey1 === category && listCacheKey2 === resourceIdent) {
@@ -1738,12 +1901,29 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (list === undefined) {
 					/** @type {FactoryCacheValue} */
 					(factoryCacheValue).set(cacheKey, (list = []));
-					sortedDependencies.push({
+					const newItem = {
 						factory: factoryCacheKey2,
 						dependencies: list,
 						context: dep.getContext(),
 						originModule: module
-					});
+					};
+					if (hasLowPriorityDependencies) {
+						let insertIndex = sortedDependencies.length;
+						while (insertIndex > 0) {
+							const item = sortedDependencies[insertIndex - 1];
+							const isAllLowPriorityDependencies = item.dependencies.every(
+								Dependency.isLowPriorityDependency
+							);
+							if (isAllLowPriorityDependencies) {
+								insertIndex--;
+							} else {
+								break;
+							}
+						}
+						sortedDependencies.splice(insertIndex, 0, newItem);
+					} else {
+						sortedDependencies.push(newItem);
+					}
 				}
 				list.push(dep);
 				listCacheKey1 = category;
@@ -1792,8 +1972,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		this._modules.set(module.identifier(), module);
 		this.modules.add(module);
-		if (this._backCompat)
+		if (this._backCompat) {
 			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+		}
 
 		this._handleModuleBuildAndDependencies(
 			originModule,
@@ -1816,6 +1997,116 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		moduleGraph.setResolvedModule(originModule, dependency, module);
 	}
 
+	/**
+	 * @param {FactorizeModuleOptions} options options
+	 * @param {ModuleOrModuleFactoryResultCallback} callback callback
+	 * @returns {void}
+	 */
+	_factorizeModule(
+		{
+			currentProfile,
+			factory,
+			dependencies,
+			originModule,
+			factoryResult,
+			contextInfo,
+			context
+		},
+		callback
+	) {
+		if (currentProfile !== undefined) {
+			currentProfile.markFactoryStart();
+		}
+		factory.create(
+			{
+				contextInfo: {
+					issuer: originModule
+						? /** @type {NameForCondition} */ (originModule.nameForCondition())
+						: "",
+					issuerLayer: originModule ? originModule.layer : null,
+					compiler: this.compiler.name,
+					...contextInfo
+				},
+				resolveOptions: originModule ? originModule.resolveOptions : undefined,
+				context:
+					context ||
+					(originModule
+						? /** @type {string} */ (originModule.context)
+						: this.compiler.context),
+				dependencies
+			},
+			(err, result) => {
+				if (result) {
+					// TODO webpack 6: remove
+					// For backward-compat
+					if (result.module === undefined && result instanceof Module) {
+						result = {
+							module: result
+						};
+					}
+					if (!factoryResult) {
+						const {
+							fileDependencies,
+							contextDependencies,
+							missingDependencies
+						} = result;
+						if (fileDependencies) {
+							this.fileDependencies.addAll(fileDependencies);
+						}
+						if (contextDependencies) {
+							this.contextDependencies.addAll(contextDependencies);
+						}
+						if (missingDependencies) {
+							this.missingDependencies.addAll(missingDependencies);
+						}
+					}
+				}
+				if (err) {
+					const notFoundError = new ModuleNotFoundError(
+						originModule,
+						err,
+						/** @type {DependencyLocation} */
+						(dependencies.map((d) => d.loc).find(Boolean))
+					);
+					return callback(notFoundError, factoryResult ? result : undefined);
+				}
+				if (!result) {
+					return callback();
+				}
+
+				if (currentProfile !== undefined) {
+					currentProfile.markFactoryEnd();
+				}
+
+				callback(null, factoryResult ? result : result.module);
+			}
+		);
+	}
+
+	/**
+	 * @overload
+	 * @param {FactorizeModuleOptions & { factoryResult?: false }} options options
+	 * @param {ModuleCallback} callback callback
+	 * @returns {void}
+	 */
+	/**
+	 * @overload
+	 * @param {FactorizeModuleOptions & { factoryResult: true }} options options
+	 * @param {ModuleFactoryResultCallback} callback callback
+	 * @returns {void}
+	 */
+	/**
+	 * @param {FactorizeModuleOptions & { factoryResult?: false } | FactorizeModuleOptions & { factoryResult: true }} options options
+	 * @param {ModuleCallback | ModuleFactoryResultCallback} callback callback
+	 */
+	factorizeModule(options, callback) {
+		this.factorizeQueue.add(
+			options,
+			/** @type {ModuleOrModuleFactoryResultCallback} */
+			(callback)
+		);
+	}
+
 	/**
 	 * @typedef {object} HandleModuleCreationOptions
 	 * @property {ModuleFactory} factory
@@ -1876,7 +2167,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				};
 				if (err) {
 					if (factoryResult) applyFactoryResultDependencies();
-					if (dependencies.every(d => d.optional)) {
+					if (dependencies.every((d) => d.optional)) {
 						this.warnings.push(err);
 						return callback();
 					}
@@ -1909,7 +2200,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					}
 
 					const module =
-						/** @type {Module & { restoreFromUnsafeCache?: Function }} */
+						/** @type {ModuleWithRestoreFromUnsafeCache} */
 						(_module);
 
 					if (
@@ -1920,10 +2211,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						this._unsafeCachePredicate(module)
 					) {
 						const unsafeCacheableModule =
-							/** @type {Module & { restoreFromUnsafeCache: Function }} */
+							/** @type {ModuleWithRestoreFromUnsafeCache} */
 							(module);
-						for (let i = 0; i < dependencies.length; i++) {
-							const dependency = dependencies[i];
+						for (const dependency of dependencies) {
 							moduleGraph.setResolvedModule(
 								connectOrigin ? originModule : null,
 								dependency,
@@ -1939,8 +2229,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						}
 					} else {
 						applyFactoryResultDependencies();
-						for (let i = 0; i < dependencies.length; i++) {
-							const dependency = dependencies[i];
+						for (const dependency of dependencies) {
 							moduleGraph.setResolvedModule(
 								connectOrigin ? originModule : null,
 								dependency,
@@ -1976,7 +2265,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 	/**
 	 * @private
-	 * @param {Module} originModule original module
+	 * @param {Module | null} originModule original module
 	 * @param {Module} module module
 	 * @param {boolean} recursive true if make it recursive, otherwise false
 	 * @param {boolean} checkCycle true if need to check cycle, otherwise false
@@ -1993,14 +2282,20 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		// Check for cycles when build is trigger inside another build
 		/** @type {Set<Module> | undefined} */
 		let creatingModuleDuringBuildSet;
-		if (checkCycle && this.buildQueue.isProcessing(originModule)) {
+		if (
+			checkCycle &&
+			this.buildQueue.isProcessing(/** @type {Module} */ (originModule))
+		) {
 			// Track build dependency
-			creatingModuleDuringBuildSet =
-				this.creatingModuleDuringBuild.get(originModule);
+			creatingModuleDuringBuildSet = this.creatingModuleDuringBuild.get(
+				/** @type {Module} */
+				(originModule)
+			);
 			if (creatingModuleDuringBuildSet === undefined) {
 				creatingModuleDuringBuildSet = new Set();
 				this.creatingModuleDuringBuild.set(
-					originModule,
+					/** @type {Module} */
+					(originModule),
 					creatingModuleDuringBuildSet
 				);
 			}
@@ -2026,7 +2321,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 		}
 
-		this.buildModule(module, err => {
+		this.buildModule(module, (err) => {
 			if (creatingModuleDuringBuildSet !== undefined) {
 				creatingModuleDuringBuildSet.delete(module);
 			}
@@ -2050,7 +2345,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				return callback(null, module);
 			}
 
-			this.processModuleDependencies(module, err => {
+			this.processModuleDependencies(module, (err) => {
 				if (err) {
 					return callback(err);
 				}
@@ -2059,88 +2354,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 	}
 
-	/**
-	 * @param {FactorizeModuleOptions} options options object
-	 * @param {ModuleOrFactoryResultCallback} callback callback
-	 * @returns {void}
-	 */
-	_factorizeModule(
-		{
-			currentProfile,
-			factory,
-			dependencies,
-			originModule,
-			factoryResult,
-			contextInfo,
-			context
-		},
-		callback
-	) {
-		if (currentProfile !== undefined) {
-			currentProfile.markFactoryStart();
-		}
-		factory.create(
-			{
-				contextInfo: {
-					issuer: originModule ? originModule.nameForCondition() : "",
-					issuerLayer: originModule ? originModule.layer : null,
-					compiler: this.compiler.name,
-					...contextInfo
-				},
-				resolveOptions: originModule ? originModule.resolveOptions : undefined,
-				context:
-					context ||
-					(originModule ? originModule.context : this.compiler.context),
-				dependencies
-			},
-			(err, result) => {
-				if (result) {
-					// TODO webpack 6: remove
-					// For backward-compat
-					if (result.module === undefined && result instanceof Module) {
-						result = {
-							module: result
-						};
-					}
-					if (!factoryResult) {
-						const {
-							fileDependencies,
-							contextDependencies,
-							missingDependencies
-						} = result;
-						if (fileDependencies) {
-							this.fileDependencies.addAll(fileDependencies);
-						}
-						if (contextDependencies) {
-							this.contextDependencies.addAll(contextDependencies);
-						}
-						if (missingDependencies) {
-							this.missingDependencies.addAll(missingDependencies);
-						}
-					}
-				}
-				if (err) {
-					const notFoundError = new ModuleNotFoundError(
-						originModule,
-						err,
-						/** @type {DependencyLocation} */
-						(dependencies.map(d => d.loc).find(Boolean))
-					);
-					return callback(notFoundError, factoryResult ? result : undefined);
-				}
-				if (!result) {
-					return callback();
-				}
-
-				if (currentProfile !== undefined) {
-					currentProfile.markFactoryEnd();
-				}
-
-				callback(null, factoryResult ? result : result.module);
-			}
-		);
-	}
-
 	/**
 	 * @param {string} context context string path
 	 * @param {Dependency} dependency dependency used to create Module chain
@@ -2169,7 +2382,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				new WebpackError("Parameter 'dependency' must be a Dependency")
 			);
 		}
-		const Dep = /** @type {DepConstructor} */ (dependency.constructor);
+		const Dep =
+			/** @type {DependencyConstructor} */
+			(dependency.constructor);
 		const moduleFactory = this.dependencyFactories.get(Dep);
 		if (!moduleFactory) {
 			return callback(
@@ -2247,6 +2462,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 */
 	_addEntryItem(context, entry, target, options, callback) {
 		const { name } = options;
+		/** @type {EntryData | undefined} */
 		let entryData =
 			name !== undefined ? this.entries.get(name) : this.globalEntry;
 		if (entryData === undefined) {
@@ -2260,12 +2476,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			};
 			entryData[target].push(entry);
 			this.entries.set(
-				/** @type {NonNullable<EntryOptions["name"]>} */ (name),
+				/** @type {NonNullable<EntryOptions["name"]>} */
+				(name),
 				entryData
 			);
 		} else {
 			entryData[target].push(entry);
-			for (const key of Object.keys(options)) {
+			for (const key_ of Object.keys(options)) {
+				const key = /** @type {keyof EntryOptions} */ (key_);
 				if (options[key] === undefined) continue;
 				if (entryData.options[key] === options[key]) continue;
 				if (
@@ -2276,7 +2494,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					continue;
 				}
 				if (entryData.options[key] === undefined) {
-					entryData.options[key] = options[key];
+					/** @type {EntryOptions[keyof EntryOptions]} */
+					(entryData.options[key]) = options[key];
 				} else {
 					return callback(
 						new WebpackError(
@@ -2302,7 +2521,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.hooks.failedEntry.call(entry, options, err);
 					return callback(err);
 				}
-				this.hooks.succeedEntry.call(entry, options, module);
+				this.hooks.succeedEntry.call(
+					entry,
+					options,
+					/** @type {Module} */
+					(module)
+				);
 				return callback(null, module);
 			}
 		);
@@ -2324,13 +2548,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 */
 	_rebuildModule(module, callback) {
 		this.hooks.rebuildModule.call(module);
-		const oldDependencies = module.dependencies.slice();
-		const oldBlocks = module.blocks.slice();
+		const oldDependencies = [...module.dependencies];
+		const oldBlocks = [...module.blocks];
 		module.invalidateBuild();
 		this.buildQueue.invalidate(module);
-		this.buildModule(module, err => {
+		this.buildModule(module, (err) => {
 			if (err) {
-				return this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+				return this.hooks.finishRebuildingModule.callAsync(module, (err2) => {
 					if (err2) {
 						callback(
 							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
@@ -2343,13 +2567,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			this.processDependenciesQueue.invalidate(module);
 			this.moduleGraph.unfreeze();
-			this.processModuleDependencies(module, err => {
+			this.processModuleDependencies(module, (err) => {
 				if (err) return callback(err);
 				this.removeReasonsOfDependencyBlock(module, {
 					dependencies: oldDependencies,
 					blocks: oldBlocks
 				});
-				this.hooks.finishRebuildingModule.callAsync(module, err2 => {
+				this.hooks.finishRebuildingModule.callAsync(module, (err2) => {
 					if (err2) {
 						callback(
 							makeWebpackError(err2, "Compilation.hooks.finishRebuildingModule")
@@ -2384,10 +2608,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module module
-		 * @returns {References | undefined} references
+		 * @returns {WeakReferences | undefined} references
 		 */
-		const computeReferences = module => {
-			/** @type {References | undefined} */
+		const computeReferences = (module) => {
+			/** @type {WeakReferences | undefined} */
 			let references;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
@@ -2401,7 +2625,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module the module
-		 * @param {References | undefined} references references
+		 * @param {WeakReferences | undefined} references references
 		 * @returns {boolean} true, when the references differ
 		 */
 		const compareReferences = (module, references) => {
@@ -2423,6 +2647,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (buildInfo) {
 					if (cachedMemCache.buildInfo !== buildInfo) {
 						// use a new one
+						/** @type {MemCache} */
 						const memCache = new WeakTupleMap();
 						moduleMemCaches.set(module, memCache);
 						affectedModules.add(module);
@@ -2432,6 +2657,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						statChanged++;
 					} else if (!compareReferences(module, cachedMemCache.references)) {
 						// use a new one
+						/** @type {MemCache} */
 						const memCache = new WeakTupleMap();
 						moduleMemCaches.set(module, memCache);
 						affectedModules.add(module);
@@ -2474,10 +2700,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		}
 
 		/**
-		 * @param {readonly ModuleGraphConnection[]} connections connections
-		 * @returns {symbol|boolean} result
+		 * @param {Readonly<ModuleGraphConnection[]>} connections connections
+		 * @returns {symbol | boolean} result
 		 */
-		const reduceAffectType = connections => {
+		const reduceAffectType = (connections) => {
 			let affected = false;
 			for (const { dependency } of connections) {
 				if (!dependency) continue;
@@ -2522,6 +2748,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				} else {
 					affectedModules.add(referencingModule);
 				}
+				/** @type {MemCache} */
 				const memCache = new WeakTupleMap();
 				const cache =
 					/** @type {ModuleMemCachesItem} */
@@ -2554,13 +2781,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statNew = 0;
 		/**
 		 * @param {Module} module module
-		 * @returns {{ id: ModuleId, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} references
+		 * @returns {References} references
 		 */
-		const computeReferences = module => {
+		const computeReferences = (module) => {
 			const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
-			/** @type {Map<Module, string | number | undefined> | undefined} */
+			/** @type {Map<Module, ModuleId> | undefined} */
 			let modules;
-			/** @type {(string | number | null)[] | undefined} */
+			/** @type {(ChunkId | null)[] | undefined} */
 			let blocks;
 			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
 			if (outgoing !== undefined) {
@@ -2572,7 +2799,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 			if (module.blocks.length > 0) {
 				blocks = [];
-				const queue = Array.from(module.blocks);
+				const queue = [...module.blocks];
 				for (const block of queue) {
 					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
 					if (chunkGroup) {
@@ -2604,7 +2831,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 			}
 			if (blocks !== undefined) {
-				const queue = Array.from(module.blocks);
+				const queue = [...module.blocks];
 				let i = 0;
 				for (const block of queue) {
 					const chunkGroup = chunkGraph.getBlockChunkGroup(block);
@@ -2624,9 +2851,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[]}, memCache: WeakTupleMap<any[], any> }} */
+			/** @type {{ references: References, memCache: MemCache } | undefined} */
 			const cache = memCache.get(key);
 			if (cache === undefined) {
+				/** @type {WeakTupleMap<Module[], RuntimeRequirements | null> | undefined} */
 				const memCache2 = new WeakTupleMap();
 				memCache.set(key, {
 					references: computeReferences(module),
@@ -2635,6 +2863,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				moduleMemCaches2.set(module, memCache2);
 				statNew++;
 			} else if (!compareReferences(module, cache.references)) {
+				/** @type {WeakTupleMap<Module[], RuntimeRequirements | null> | undefined} */
 				const memCache = new WeakTupleMap();
 				cache.references = computeReferences(module);
 				cache.memCache = memCache;
@@ -2660,7 +2889,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.factorizeQueue.clear();
 		if (this.profile) {
 			this.logger.time("finish module profiles");
+
 			const ParallelismFactorCalculator = require("./util/ParallelismFactorCalculator");
+
 			const p = new ParallelismFactorCalculator();
 			const moduleGraph = this.moduleGraph;
 			/** @type {Map<Module, ModuleProfile>} */
@@ -2672,27 +2903,27 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				p.range(
 					profile.buildingStartTime,
 					profile.buildingEndTime,
-					f => (profile.buildingParallelismFactor = f)
+					(f) => (profile.buildingParallelismFactor = f)
 				);
 				p.range(
 					profile.factoryStartTime,
 					profile.factoryEndTime,
-					f => (profile.factoryParallelismFactor = f)
+					(f) => (profile.factoryParallelismFactor = f)
 				);
 				p.range(
 					profile.integrationStartTime,
 					profile.integrationEndTime,
-					f => (profile.integrationParallelismFactor = f)
+					(f) => (profile.integrationParallelismFactor = f)
 				);
 				p.range(
 					profile.storingStartTime,
 					profile.storingEndTime,
-					f => (profile.storingParallelismFactor = f)
+					(f) => (profile.storingParallelismFactor = f)
 				);
 				p.range(
 					profile.restoringStartTime,
 					profile.restoringEndTime,
-					f => (profile.restoringParallelismFactor = f)
+					(f) => (profile.restoringParallelismFactor = f)
 				);
 				if (profile.additionalFactoryTimes) {
 					for (const { start, end } of profile.additionalFactoryTimes) {
@@ -2700,7 +2931,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						p.range(
 							start,
 							end,
-							f =>
+							(f) =>
 								(profile.additionalFactoriesParallelismFactor += f * influence)
 						);
 					}
@@ -2823,33 +3054,33 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			};
 			logNormalSummary(
 				"resolve to new modules",
-				p => p.factory,
-				p => p.factoryParallelismFactor
+				(p) => p.factory,
+				(p) => p.factoryParallelismFactor
 			);
 			logNormalSummary(
 				"resolve to existing modules",
-				p => p.additionalFactories,
-				p => p.additionalFactoriesParallelismFactor
+				(p) => p.additionalFactories,
+				(p) => p.additionalFactoriesParallelismFactor
 			);
 			logNormalSummary(
 				"integrate modules",
-				p => p.restoring,
-				p => p.restoringParallelismFactor
+				(p) => p.restoring,
+				(p) => p.restoringParallelismFactor
 			);
 			logByLoadersSummary(
 				"build modules",
-				p => p.building,
-				p => p.buildingParallelismFactor
+				(p) => p.building,
+				(p) => p.buildingParallelismFactor
 			);
 			logNormalSummary(
 				"store modules",
-				p => p.storing,
-				p => p.storingParallelismFactor
+				(p) => p.storing,
+				(p) => p.storingParallelismFactor
 			);
 			logNormalSummary(
 				"restore modules",
-				p => p.restoring,
-				p => p.restoringParallelismFactor
+				(p) => p.restoring,
+				(p) => p.restoringParallelismFactor
 			);
 			this.logger.timeEnd("finish module profiles");
 		}
@@ -2858,7 +3089,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.logger.timeEnd("compute affected modules");
 		this.logger.time("finish modules");
 		const { modules, moduleMemCaches } = this;
-		this.hooks.finishModules.callAsync(modules, err => {
+		this.hooks.finishModules.callAsync(modules, (err) => {
 			this.logger.timeEnd("finish modules");
 			if (err) return callback(/** @type {WebpackError} */ (err));
 
@@ -2929,7 +3160,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @param {WebpackError=} err err
 		 * @returns {void}
 		 */
-		const finalCallback = err => {
+		const finalCallback = (err) => {
 			this.factorizeQueue.clear();
 			this.buildQueue.clear();
 			this.rebuildQueue.clear();
@@ -2937,15 +3168,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.addModuleQueue.clear();
 			return callback(err);
 		};
-		const chunkGraph = new ChunkGraph(
-			this.moduleGraph,
-			this.outputOptions.hashFunction
-		);
-		this.chunkGraph = chunkGraph;
 
 		if (this._backCompat) {
 			for (const module of this.modules) {
-				ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+				ChunkGraph.setChunkGraphForModule(module, this.chunkGraph);
 			}
 		}
 
@@ -2981,11 +3207,16 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			const entryModules = new Set();
 			for (const dep of [...this.globalEntry.dependencies, ...dependencies]) {
-				entrypoint.addOrigin(null, { name }, /** @type {any} */ (dep).request);
+				entrypoint.addOrigin(
+					null,
+					{ name },
+					/** @type {Dependency & { request: string }} */
+					(dep).request
+				);
 
 				const module = this.moduleGraph.getModule(dep);
 				if (module) {
-					chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+					this.chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
 					entryModules.add(module);
 					const modulesList = chunkGraphInit.get(entrypoint);
 					if (modulesList === undefined) {
@@ -3002,11 +3233,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			 * @param {Dependency[]} deps deps
 			 * @returns {Module[]} sorted deps
 			 */
-			const mapAndSort = deps =>
+			const mapAndSort = (deps) =>
 				/** @type {Module[]} */
-				(deps.map(dep => this.moduleGraph.getModule(dep)).filter(Boolean)).sort(
-					compareModulesByIdentifier
-				);
+				(
+					deps.map((dep) => this.moduleGraph.getModule(dep)).filter(Boolean)
+				).sort(compareModulesByIdentifier);
 			const includedModules = [
 				...mapAndSort(this.globalEntry.includeDependencies),
 				...mapAndSort(includeDependencies)
@@ -3043,7 +3274,6 @@ Remove the 'runtime' option from the entrypoint.`);
 				const referencedChunks = entry
 					.getEntrypointChunk()
 					.getAllReferencedChunks();
-				const dependOnEntries = [];
 				for (const dep of dependOn) {
 					const dependency = this.entrypoints.get(dep);
 					if (!dependency) {
@@ -3061,9 +3291,7 @@ Remove the 'runtime' option from the entrypoint.`);
 						entry.setRuntimeChunk(entryChunk);
 						continue outer;
 					}
-					dependOnEntries.push(dependency);
-				}
-				for (const dependency of dependOnEntries) {
+					connectEntrypointAndDependOn(entry, dependency);
 					connectChunkGroupParentAndChild(dependency, entry);
 				}
 			} else if (runtime) {
@@ -3096,6 +3324,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				entry.setRuntimeChunk(chunk);
 			}
 		}
+
 		buildChunkGraph(this, chunkGraphInit);
 		this.hooks.afterChunks.call(this.chunks);
 		this.logger.timeEnd("create chunks");
@@ -3113,7 +3342,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
 
-		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, err => {
+		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, (err) => {
 			if (err) {
 				return finalCallback(
 					makeWebpackError(err, "Compilation.hooks.optimizeTree")
@@ -3125,7 +3354,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			this.hooks.optimizeChunkModules.callAsync(
 				this.chunks,
 				this.modules,
-				err => {
+				(err) => {
 					if (err) {
 						return finalCallback(
 							makeWebpackError(err, "Compilation.hooks.optimizeChunkModules")
@@ -3136,13 +3365,21 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 					const shouldRecord = this.hooks.shouldRecord.call() !== false;
 
-					this.hooks.reviveModules.call(this.modules, this.records);
+					this.hooks.reviveModules.call(
+						this.modules,
+						/** @type {Records} */
+						(this.records)
+					);
 					this.hooks.beforeModuleIds.call(this.modules);
 					this.hooks.moduleIds.call(this.modules);
 					this.hooks.optimizeModuleIds.call(this.modules);
 					this.hooks.afterOptimizeModuleIds.call(this.modules);
 
-					this.hooks.reviveChunks.call(this.chunks, this.records);
+					this.hooks.reviveChunks.call(
+						this.chunks,
+						/** @type {Records} */
+						(this.records)
+					);
 					this.hooks.beforeChunkIds.call(this.chunks);
 					this.hooks.chunkIds.call(this.chunks);
 					this.hooks.optimizeChunkIds.call(this.chunks);
@@ -3157,8 +3394,16 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					this.sortItemsWithChunkIds();
 
 					if (shouldRecord) {
-						this.hooks.recordModules.call(this.modules, this.records);
-						this.hooks.recordChunks.call(this.chunks, this.records);
+						this.hooks.recordModules.call(
+							this.modules,
+							/** @type {Records} */
+							(this.records)
+						);
+						this.hooks.recordChunks.call(
+							this.chunks,
+							/** @type {Records} */
+							(this.records)
+						);
 					}
 
 					this.hooks.optimizeCodeGeneration.call(this.modules);
@@ -3172,7 +3417,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 					this.logger.time("code generation");
 					this.hooks.beforeCodeGeneration.call();
-					this.codeGeneration(err => {
+					this.codeGeneration((err) => {
 						if (err) {
 							return finalCallback(err);
 						}
@@ -3191,14 +3436,17 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						this.hooks.afterHash.call();
 						this.logger.timeEnd("hashing");
 
-						this._runCodeGenerationJobs(codeGenerationJobs, err => {
+						this._runCodeGenerationJobs(codeGenerationJobs, (err) => {
 							if (err) {
 								return finalCallback(err);
 							}
 
 							if (shouldRecord) {
 								this.logger.time("record hash");
-								this.hooks.recordHash.call(this.records);
+								this.hooks.recordHash.call(
+									/** @type {Records} */
+									(this.records)
+								);
 								this.logger.timeEnd("record hash");
 							}
 
@@ -3211,7 +3459,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 							const cont = () => {
 								this.logger.time("process assets");
-								this.hooks.processAssets.callAsync(this.assets, err => {
+								this.hooks.processAssets.callAsync(this.assets, (err) => {
 									if (err) {
 										return finalCallback(
 											makeWebpackError(err, "Compilation.hooks.processAssets")
@@ -3219,29 +3467,35 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 									}
 									this.hooks.afterProcessAssets.call(this.assets);
 									this.logger.timeEnd("process assets");
-									this.assets = /** @type {CompilationAssets} */ (
-										this._backCompat
-											? soonFrozenObjectDeprecation(
-													this.assets,
-													"Compilation.assets",
-													"DEP_WEBPACK_COMPILATION_ASSETS",
-													`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
+									this.assets =
+										/** @type {CompilationAssets} */
+										(
+											this._backCompat
+												? soonFrozenObjectDeprecation(
+														this.assets,
+														"Compilation.assets",
+														"DEP_WEBPACK_COMPILATION_ASSETS",
+														`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
 	Do changes to assets earlier, e. g. in Compilation.hooks.processAssets.
 	Make sure to select an appropriate stage from Compilation.PROCESS_ASSETS_STAGE_*.`
-												)
-											: Object.freeze(this.assets)
-									);
+													)
+												: Object.freeze(this.assets)
+										);
 
 									this.summarizeDependencies();
 									if (shouldRecord) {
-										this.hooks.record.call(this, this.records);
+										this.hooks.record.call(
+											this,
+											/** @type {Records} */
+											(this.records)
+										);
 									}
 
 									if (this.hooks.needAdditionalSeal.call()) {
 										this.unseal();
 										return this.seal(callback);
 									}
-									return this.hooks.afterSeal.callAsync(err => {
+									return this.hooks.afterSeal.callAsync((err) => {
 										if (err) {
 											return finalCallback(
 												makeWebpackError(err, "Compilation.hooks.afterSeal")
@@ -3256,7 +3510,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 							this.logger.time("create chunk assets");
 							if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
 								this.hooks.beforeChunkAssets.call();
-								this.createChunkAssets(err => {
+								this.createChunkAssets((err) => {
 									this.logger.timeEnd("create chunk assets");
 									if (err) {
 										return finalCallback(err);
@@ -3281,18 +3535,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 */
 	reportDependencyErrorsAndWarnings(module, blocks) {
 		let hasProblems = false;
-		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
-			const block = blocks[indexBlock];
+		for (const block of blocks) {
 			const dependencies = block.dependencies;
 
-			for (let indexDep = 0; indexDep < dependencies.length; indexDep++) {
-				const d = dependencies[indexDep];
-
+			for (const d of dependencies) {
 				const warnings = d.getWarnings(this.moduleGraph);
 				if (warnings) {
-					for (let indexWar = 0; indexWar < warnings.length; indexWar++) {
-						const w = warnings[indexWar];
-
+					for (const w of warnings) {
 						const warning = new ModuleDependencyWarning(module, w, d.loc);
 						this.warnings.push(warning);
 						hasProblems = true;
@@ -3300,9 +3549,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				}
 				const errors = d.getErrors(this.moduleGraph);
 				if (errors) {
-					for (let indexErr = 0; indexErr < errors.length; indexErr++) {
-						const e = errors[indexErr];
-
+					for (const e of errors) {
 						const error = new ModuleDependencyError(module, e, d.loc);
 						this.errors.push(error);
 						hasProblems = true;
@@ -3310,8 +3557,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				}
 			}
 
-			if (this.reportDependencyErrorsAndWarnings(module, block.blocks))
+			if (this.reportDependencyErrorsAndWarnings(module, block.blocks)) {
 				hasProblems = true;
+			}
 		}
 		return hasProblems;
 	}
@@ -3367,7 +3615,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		let statModulesGenerated = 0;
 		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
 			this;
-		const results = this.codeGenerationResults;
+		const results =
+			/** @type {CodeGenerationResults} */
+			(this.codeGenerationResults);
 		/** @type {WebpackError[]} */
 		const errors = [];
 		/** @type {NotCodeGeneratedModules | undefined} */
@@ -3378,15 +3628,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			let delayedModules = new Set();
 			asyncLib.eachLimit(
 				jobs,
-				/** @type {number} */
-				(this.options.parallelism),
+				this.options.parallelism,
 				(job, callback) => {
 					const { module } = job;
 					const { codeGenerationDependencies } = module;
 					if (
 						codeGenerationDependencies !== undefined &&
 						(notCodeGeneratedModules === undefined ||
-							codeGenerationDependencies.some(dep => {
+							codeGenerationDependencies.some((dep) => {
 								const referencedModule = /** @type {Module} */ (
 									moduleGraph.getModule(dep)
 								);
@@ -3418,7 +3667,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						}
 					);
 				},
-				err => {
+				(err) => {
 					if (err) return callback(err);
 					if (delayedJobs.length > 0) {
 						if (delayedJobs.length === jobs.length) {
@@ -3427,7 +3676,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 									new Error(
 										`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
 											delayedModules,
-											m => m.identifier()
+											(m) => m.identifier()
 										).join(", ")}`
 									)
 								)
@@ -3441,7 +3690,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					}
 					if (errors.length > 0) {
 						errors.sort(
-							compareSelect(err => err.module, compareModulesByIdentifier)
+							compareSelect((err) => err.module, compareModulesByIdentifier)
 						);
 						for (const error of errors) {
 							this.errors.push(error);
@@ -3471,7 +3720,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
 	 * @param {WebpackError[]} errors errors
 	 * @param {CodeGenerationResults} results results
-	 * @param {function((WebpackError | null)=, boolean=): void} callback callback
+	 * @param {(err?: WebpackError | null, result?: boolean) => void} callback callback
 	 */
 	_codeGenerationModule(
 		module,
@@ -3488,7 +3737,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	) {
 		let codeGenerated = false;
 		const cache = new MultiItemCache(
-			runtimes.map(runtime =>
+			runtimes.map((runtime) =>
 				this._codeGenerationCache.getItemCache(
 					`${module.identifier()}|${getRuntimeKey(runtime)}`,
 					`${hash}|${dependencyTemplates.getHash()}`
@@ -3508,6 +3757,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						dependencyTemplates,
 						runtimeTemplate,
 						runtime,
+						runtimes,
 						codeGenerationResults: results,
 						compilation: this
 					});
@@ -3527,7 +3777,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				results.add(module, runtime, result);
 			}
 			if (!cachedResult) {
-				cache.store(result, err =>
+				cache.store(result, (err) =>
 					callback(/** @type {WebpackError} */ (err), codeGenerated)
 				);
 			} else {
@@ -3563,7 +3813,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		chunkGraph = this.chunkGraph,
 		modules = this.modules,
 		chunks = this.chunks,
-		codeGenerationResults = this.codeGenerationResults,
+		codeGenerationResults = /** @type {CodeGenerationResults} */ (
+			this.codeGenerationResults
+		),
 		chunkGraphEntries = this._getChunkGraphEntries()
 	} = {}) {
 		const context = { chunkGraph, codeGenerationResults };
@@ -3585,7 +3837,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 								chunkGraph.addModuleRuntimeRequirements(
 									module,
 									runtime,
-									cached,
+									/** @type {RuntimeRequirements} */
+									(cached),
 									false
 								);
 							}
@@ -3642,6 +3895,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 		this.logger.time("runtime requirements.chunks");
 		for (const chunk of chunks) {
+			/** @type {RuntimeRequirements} */
 			const set = new Set();
 			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
@@ -3662,6 +3916,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 		this.logger.time("runtime requirements.entries");
 		for (const treeEntry of chunkGraphEntries) {
+			/** @type {RuntimeRequirements} */
 			const set = new Set();
 			for (const chunk of treeEntry.getAllReferencedChunks()) {
 				const runtimeRequirements =
@@ -3695,8 +3950,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 */
 	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
 		// Deprecated ModuleGraph association
-		if (this._backCompat)
+		if (this._backCompat) {
 			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+		}
 
 		// add it to the list
 		this.modules.add(module);
@@ -3752,7 +4008,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			groupOptions = { name: groupOptions };
 		}
 		const name = groupOptions.name;
-
 		if (name) {
 			const chunkGroup = this.namedChunkGroups.get(name);
 			if (chunkGroup !== undefined) {
@@ -3761,20 +4016,23 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						module,
 						/** @type {DependencyLocation} */
 						(loc),
-						request
+						/** @type {string} */
+						(request)
 					);
 				}
 				return chunkGroup;
 			}
 		}
 		const chunkGroup = new ChunkGroup(groupOptions);
-		if (module)
+		if (module) {
 			chunkGroup.addOrigin(
 				module,
 				/** @type {DependencyLocation} */
 				(loc),
-				request
+				/** @type {string} */
+				(request)
 			);
+		}
 		const chunk = this.addChunk(name);
 
 		connectChunkGroupAndChunk(chunkGroup, chunk);
@@ -3798,12 +4056,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		if (name) {
 			const entrypoint = this.namedChunkGroups.get(name);
 			if (entrypoint instanceof Entrypoint) {
-				if (entrypoint !== undefined) {
-					if (module) {
-						entrypoint.addOrigin(module, loc, request);
-					}
-					return entrypoint;
+				if (module) {
+					entrypoint.addOrigin(module, loc, request);
 				}
+				return entrypoint;
 			} else if (entrypoint) {
 				throw new Error(
 					`Cannot add an async entrypoint with the name '${name}', because there is already an chunk group with this name`
@@ -3832,7 +4088,7 @@ 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
+	 * @param {ChunkName=} name optional chunk name to be provided
 	 * @returns {Chunk} create a chunk (invoked during seal event)
 	 */
 	addChunk(name) {
@@ -3844,8 +4100,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		const chunk = new Chunk(name, this._backCompat);
 		this.chunks.add(chunk);
-		if (this._backCompat)
+		if (this._backCompat) {
 			ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
+		}
 		if (name) {
 			this.namedChunks.set(name, chunk);
 		}
@@ -3870,7 +4127,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		 * @param {Module} module module for processing
 		 * @returns {void}
 		 */
-		const processModule = module => {
+		const processModule = (module) => {
 			if (!moduleGraph.setDepthIfLower(module, depth)) return;
 			queue.add(module);
 		};
@@ -3895,35 +4152,37 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	assignDepths(modules) {
 		const moduleGraph = this.moduleGraph;
 
-		/** @type {Set<Module | number>} */
+		/** @type {Set<Module>} */
 		const queue = new Set(modules);
-		queue.add(1);
+		// Track these in local variables so that queue only has one data type
+		let nextDepthAt = queue.size;
 		let depth = 0;
 
 		let i = 0;
 		for (const module of queue) {
-			i++;
-			if (typeof module === "number") {
-				depth = module;
-				if (queue.size === i) return;
-				queue.add(depth + 1);
-			} else {
-				moduleGraph.setDepth(module, depth);
-				for (const { module: refModule } of moduleGraph.getOutgoingConnections(
-					module
-				)) {
-					if (refModule) {
-						queue.add(refModule);
-					}
+			moduleGraph.setDepth(module, depth);
+			// Some of these results come from cache, which speeds this up
+			const connections = moduleGraph.getOutgoingConnectionsByModule(module);
+			// connections will be undefined if there are no outgoing connections
+			if (connections) {
+				for (const refModule of connections.keys()) {
+					if (refModule) queue.add(refModule);
 				}
 			}
+			i++;
+			// Since this is a breadth-first search, all modules added to the queue
+			// while at depth N will be depth N+1
+			if (i >= nextDepthAt) {
+				depth++;
+				nextDepthAt = queue.size;
+			}
 		}
 	}
 
 	/**
 	 * @param {Dependency} dependency the dependency
 	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getDependencyReferencedExports(dependency, runtime) {
 		const referencedExports = dependency.getReferencedExports(
@@ -3939,7 +4198,7 @@ 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
+	 * @param {DependenciesBlockLike} block dependencies block
 	 * @returns {void}
 	 */
 	removeReasonsOfDependencyBlock(module, block) {
@@ -3994,7 +4253,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		/**
 		 * @param {Dependency} d dependency to (maybe) patch up
 		 */
-		const iteratorDependency = d => {
+		const iteratorDependency = (d) => {
 			const depModule = this.moduleGraph.getModule(d);
 			if (!depModule) {
 				return;
@@ -4003,16 +4262,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		};
 
 		const blocks = block.blocks;
-		for (let indexBlock = 0; indexBlock < blocks.length; indexBlock++) {
-			const asyncBlock = blocks[indexBlock];
+		for (const asyncBlock of blocks) {
 			const chunkGroup =
 				/** @type {ChunkGroup} */
 				(this.chunkGraph.getBlockChunkGroup(asyncBlock));
 			// Grab all chunks from the first Block's AsyncDepBlock
 			const chunks = chunkGroup.chunks;
 			// For each chunk in chunkGroup
-			for (let indexChunk = 0; indexChunk < chunks.length; indexChunk++) {
-				const iteratedChunk = chunks[indexChunk];
+			for (const iteratedChunk of chunks) {
 				chunkGroup.removeChunk(iteratedChunk);
 				// Recurse
 				this.removeChunkFromDependencies(block, iteratedChunk);
@@ -4029,7 +4286,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		/**
 		 * @param {Entrypoint} ep an entrypoint
 		 */
-		const processEntrypoint = ep => {
+		const processEntrypoint = (ep) => {
 			const runtime = /** @type {string} */ (ep.options.runtime || ep.name);
 			const chunk = /** @type {Chunk} */ (ep.getRuntimeChunk());
 			chunkGraph.setRuntimeId(runtime, /** @type {ChunkId} */ (chunk.id));
@@ -4053,13 +4310,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	summarizeDependencies() {
-		for (
-			let indexChildren = 0;
-			indexChildren < this.children.length;
-			indexChildren++
-		) {
-			const child = this.children[indexChildren];
-
+		for (const child of this.children) {
 			this.fileDependencies.addAll(child.fileDependencies);
 			this.contextDependencies.addAll(child.contextDependencies);
 			this.missingDependencies.addAll(child.missingDependencies);
@@ -4087,7 +4338,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
 				if (memCache) {
-					const digest = memCache.get(`moduleHash-${getRuntimeKey(runtime)}`);
+					const digest =
+						/** @type {string} */
+						(memCache.get(`moduleHash-${getRuntimeKey(runtime)}`));
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,
@@ -4116,7 +4369,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			}
 		}
 		if (errors.length > 0) {
-			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			errors.sort(
+				compareSelect((err) => err.module, compareModulesByIdentifier)
+			);
 			for (const error of errors) {
 				this.errors.push(error);
 			}
@@ -4135,10 +4390,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * @param {Module} module module
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {RuntimeSpec} runtime runtime
-	 * @param {OutputOptions["hashFunction"]} hashFunction hash function
+	 * @param {HashFunction} hashFunction hash function
 	 * @param {RuntimeTemplate} runtimeTemplate runtime template
-	 * @param {OutputOptions["hashDigest"]} hashDigest hash digest
-	 * @param {OutputOptions["hashDigestLength"]} hashDigestLength hash digest length
+	 * @param {HashDigest} hashDigest hash digest
+	 * @param {HashDigestLength} hashDigestLength hash digest length
 	 * @param {WebpackError[]} errors errors
 	 * @returns {string} module hash digest
 	 */
@@ -4154,13 +4409,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	) {
 		let moduleHashDigest;
 		try {
-			const moduleHash = createHash(/** @type {Algorithm} */ (hashFunction));
+			const moduleHash = createHash(hashFunction);
 			module.updateHash(moduleHash, {
 				chunkGraph,
 				runtime,
 				runtimeTemplate
 			});
-			moduleHashDigest = /** @type {string} */ (moduleHash.digest(hashDigest));
+			moduleHashDigest = moduleHash.digest(hashDigest);
 		} catch (err) {
 			errors.push(new ModuleHashingError(module, /** @type {Error} */ (err)));
 			moduleHashDigest = "XXXXXX";
@@ -4182,7 +4437,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const hashFunction = outputOptions.hashFunction;
 		const hashDigest = outputOptions.hashDigest;
 		const hashDigestLength = outputOptions.hashDigestLength;
-		const hash = createHash(/** @type {Algorithm} */ (hashFunction));
+		const hash = createHash(hashFunction);
 		if (outputOptions.hashSalt) {
 			hash.update(outputOptions.hashSalt);
 		}
@@ -4223,16 +4478,21 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		/** @type {Chunk[]} */
 		const unorderedRuntimeChunks = [];
 		/** @type {Chunk[]} */
-		const otherChunks = [];
+		const initialChunks = [];
+		/** @type {Chunk[]} */
+		const asyncChunks = [];
 		for (const c of this.chunks) {
 			if (c.hasRuntime()) {
 				unorderedRuntimeChunks.push(c);
+			} else if (c.canBeInitial()) {
+				initialChunks.push(c);
 			} else {
-				otherChunks.push(c);
+				asyncChunks.push(c);
 			}
 		}
 		unorderedRuntimeChunks.sort(byId);
-		otherChunks.sort(byId);
+		initialChunks.sort(byId);
+		asyncChunks.sort(byId);
 
 		/** @typedef {{ chunk: Chunk, referencedBy: RuntimeChunkInfo[], remaining: number }} RuntimeChunkInfo */
 		/** @type {Map<Chunk, RuntimeChunkInfo>} */
@@ -4247,8 +4507,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		let remaining = 0;
 		for (const info of runtimeChunksMap.values()) {
 			for (const other of new Set(
-				Array.from(info.chunk.getAllReferencedAsyncEntrypoints()).map(
-					e => e.chunks[e.chunks.length - 1]
+				[...info.chunk.getAllReferencedAsyncEntrypoints()].map(
+					(e) => e.chunks[e.chunks.length - 1]
 				)
 			)) {
 				const otherInfo =
@@ -4301,11 +4561,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					circularRuntimeChunkInfo.push(info);
 				}
 			}
-			circularRuntimeChunkInfo.sort(compareSelect(i => i.chunk, byId));
+			circularRuntimeChunkInfo.sort(compareSelect((i) => i.chunk, byId));
 			const err =
 				new WebpackError(`Circular dependency between chunks with runtime (${Array.from(
 					circularRuntimeChunkInfo,
-					c => c.chunk.name || c.chunk.id
+					(c) => c.chunk.name || c.chunk.id
 				).join(", ")})
 This prevents using hashes of each other and should be avoided.`);
 			err.chunk = circularRuntimeChunkInfo[0].chunk;
@@ -4315,9 +4575,9 @@ This prevents using hashes of each other and should be avoided.`);
 		this.logger.timeEnd("hashing: sort chunks");
 
 		const fullHashChunks = new Set();
-		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		/** @type {CodeGenerationJobs} */
 		const codeGenerationJobs = [];
-		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
+		/** @type {Map<string, Map<Module, CodeGenerationJob>>} */
 		const codeGenerationJobsMap = new Map();
 		/** @type {WebpackError[]} */
 		const errors = [];
@@ -4325,7 +4585,7 @@ This prevents using hashes of each other and should be avoided.`);
 		/**
 		 * @param {Chunk} chunk chunk
 		 */
-		const processChunk = chunk => {
+		const processChunk = (chunk) => {
 			// Last minute module hash generation for modules that depend on chunk hashes
 			this.logger.time("hashing: hash runtime modules");
 			const runtime = chunk.runtime;
@@ -4365,20 +4625,20 @@ This prevents using hashes of each other and should be avoided.`);
 			this.logger.timeAggregate("hashing: hash runtime modules");
 			try {
 				this.logger.time("hashing: hash chunks");
-				const chunkHash = createHash(/** @type {Algorithm} */ (hashFunction));
+				const chunkHash = createHash(hashFunction);
 				if (outputOptions.hashSalt) {
 					chunkHash.update(outputOptions.hashSalt);
 				}
 				chunk.updateHash(chunkHash, chunkGraph);
 				this.hooks.chunkHash.call(chunk, chunkHash, {
 					chunkGraph,
-					codeGenerationResults: this.codeGenerationResults,
+					codeGenerationResults:
+						/** @type {CodeGenerationResults} */
+						(this.codeGenerationResults),
 					moduleGraph: this.moduleGraph,
 					runtimeTemplate: this.runtimeTemplate
 				});
-				const chunkHashDigest = /** @type {string} */ (
-					chunkHash.digest(hashDigest)
-				);
+				const chunkHashDigest = chunkHash.digest(hashDigest);
 				hash.update(chunkHashDigest);
 				chunk.hash = chunkHashDigest;
 				chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
@@ -4396,10 +4656,13 @@ This prevents using hashes of each other and should be avoided.`);
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
 		};
-		for (const chunk of otherChunks) processChunk(chunk);
+		for (const chunk of asyncChunks) processChunk(chunk);
 		for (const chunk of runtimeChunks) processChunk(chunk);
+		for (const chunk of initialChunks) processChunk(chunk);
 		if (errors.length > 0) {
-			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			errors.sort(
+				compareSelect((err) => err.module, compareModulesByIdentifier)
+			);
 			for (const error of errors) {
 				this.errors.push(error);
 			}
@@ -4409,7 +4672,7 @@ This prevents using hashes of each other and should be avoided.`);
 		this.logger.timeAggregateEnd("hashing: hash chunks");
 		this.logger.time("hashing: hash digest");
 		this.hooks.fullHash.call(hash);
-		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
+		this.fullHash = hash.digest(hashDigest);
 		this.hash = this.fullHash.slice(0, hashDigestLength);
 		this.logger.timeEnd("hashing: hash digest");
 
@@ -4418,15 +4681,13 @@ This prevents using hashes of each other and should be avoided.`);
 			for (const module of /** @type {Iterable<RuntimeModule>} */ (
 				chunkGraph.getChunkFullHashModulesIterable(chunk)
 			)) {
-				const moduleHash = createHash(/** @type {Algorithm} */ (hashFunction));
+				const moduleHash = createHash(hashFunction);
 				module.updateHash(moduleHash, {
 					chunkGraph,
 					runtime: chunk.runtime,
 					runtimeTemplate
 				});
-				const moduleHashDigest = /** @type {string} */ (
-					moduleHash.digest(hashDigest)
-				);
+				const moduleHashDigest = moduleHash.digest(hashDigest);
 				const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
 				chunkGraph.setModuleHashes(
 					module,
@@ -4434,14 +4695,16 @@ This prevents using hashes of each other and should be avoided.`);
 					moduleHashDigest,
 					moduleHashDigest.slice(0, hashDigestLength)
 				);
-				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
+				/** @type {CodeGenerationJob} */
+				(
+					/** @type {Map<Module, CodeGenerationJob>} */
+					(codeGenerationJobsMap.get(oldHash)).get(module)
+				).hash = moduleHashDigest;
 			}
-			const chunkHash = createHash(/** @type {Algorithm} */ (hashFunction));
+			const chunkHash = createHash(hashFunction);
 			chunkHash.update(chunk.hash);
 			chunkHash.update(this.hash);
-			const chunkHashDigest =
-				/** @type {string} */
-				(chunkHash.digest(hashDigest));
+			const chunkHashDigest = chunkHash.digest(hashDigest);
 			chunk.hash = chunkHashDigest;
 			chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 			this.hooks.contentHash.call(chunk);
@@ -4484,7 +4747,7 @@ This prevents using hashes of each other and should be avoided.`);
 	/**
 	 * @private
 	 * @param {string} file file name
-	 * @param {AssetInfo} newInfo new asset information
+	 * @param {AssetInfo=} newInfo new asset information
 	 * @param {AssetInfo=} oldInfo old asset information
 	 */
 	_setAssetInfo(file, newInfo, oldInfo = this.assetsInfo.get(file)) {
@@ -4500,7 +4763,7 @@ This prevents using hashes of each other and should be avoided.`);
 				/**
 				 * @param {string} name name
 				 */
-				const remove = name => {
+				const remove = (name) => {
 					const relatedIn = this._assetsRelatedIn.get(name);
 					if (relatedIn === undefined) return;
 					const entry = relatedIn.get(key);
@@ -4525,7 +4788,7 @@ This prevents using hashes of each other and should be avoided.`);
 				/**
 				 * @param {string} name name
 				 */
-				const add = name => {
+				const add = (name) => {
 					let relatedIn = this._assetsRelatedIn.get(name);
 					if (relatedIn === undefined) {
 						this._assetsRelatedIn.set(name, (relatedIn = new Map()));
@@ -4550,8 +4813,8 @@ This prevents using hashes of each other and should be avoided.`);
 
 	/**
 	 * @param {string} file file name
-	 * @param {Source | function(Source): Source} newSourceOrFunction new asset source or function converting old to new
-	 * @param {(AssetInfo | function(AssetInfo | undefined): AssetInfo) | undefined} assetInfoUpdateOrFunction new asset info or function converting old to new
+	 * @param {Source | ((source: Source) => Source)} newSourceOrFunction new asset source or function converting old to new
+	 * @param {(AssetInfo | ((assetInfo?: AssetInfo) => AssetInfo | undefined)) | undefined} assetInfoUpdateOrFunction new asset info or function converting old to new
 	 */
 	updateAsset(
 		file,
@@ -4612,10 +4875,12 @@ This prevents using hashes of each other and should be avoided.`);
 					const entry = related[key];
 					let newEntry;
 					if (Array.isArray(entry)) {
-						newEntry = entry.map(x => (x === file ? newFile : x));
+						newEntry = entry.map((x) => (x === file ? newFile : x));
 					} else if (entry === file) {
 						newEntry = newFile;
-					} else continue;
+					} else {
+						continue;
+					}
 					this.assetsInfo.set(name, {
 						...info,
 						related: {
@@ -4664,7 +4929,7 @@ This prevents using hashes of each other and should be avoided.`);
 				/**
 				 * @param {string} file file
 				 */
-				const checkUsedAndDelete = file => {
+				const checkUsedAndDelete = (file) => {
 					if (!this._assetsRelatedIn.has(file)) {
 						this.deleteAsset(file);
 					}
@@ -4777,7 +5042,9 @@ This prevents using hashes of each other and should be avoided.`);
 						hash: /** @type {string} */ (this.hash),
 						fullHash: /** @type {string} */ (this.fullHash),
 						outputOptions,
-						codeGenerationResults: this.codeGenerationResults,
+						codeGenerationResults:
+							/** @type {CodeGenerationResults} */
+							(this.codeGenerationResults),
 						moduleTemplates: this.moduleTemplates,
 						dependencyTemplates: this.dependencyTemplates,
 						chunkGraph: this.chunkGraph,
@@ -4794,7 +5061,7 @@ This prevents using hashes of each other and should be avoided.`);
 					manifest,
 					(fileManifest, callback) => {
 						const ident = fileManifest.identifier;
-						const usedHash = fileManifest.hash;
+						const usedHash = /** @type {string} */ (fileManifest.hash);
 
 						const assetCacheItem = this._assetsCache.getItemCache(
 							ident,
@@ -4814,7 +5081,7 @@ This prevents using hashes of each other and should be avoided.`);
 							 * @param {Error} err error
 							 * @returns {void}
 							 */
-							const errorAndCallback = err => {
+							const errorAndCallback = (err) => {
 								const filename =
 									file ||
 									(typeof file === "string"
@@ -4895,7 +5162,7 @@ This prevents using hashes of each other and should be avoided.`);
 									chunk
 								});
 								if (source !== sourceFromCache) {
-									assetCacheItem.store(source, err => {
+									assetCacheItem.store(source, (err) => {
 										if (err) return errorAndCallback(err);
 										inTry = false;
 										return callback();
@@ -4990,7 +5257,7 @@ This prevents using hashes of each other and should be avoided.`);
 	 * from parent (or top level compiler) and creates a child Compilation
 	 * @param {string} name name of the child compiler
 	 * @param {Partial<OutputOptions>=} outputOptions // Need to convert config schema to types for this
-	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
+	 * @param {Plugins=} plugins webpack plugins that will be applied
 	 * @returns {Compiler} creates a child Compiler instance
 	 */
 	createChildCompiler(name, outputOptions, plugins) {
@@ -5017,9 +5284,9 @@ This prevents using hashes of each other and should be avoided.`);
 			modules,
 			10,
 			(module, push, callback) => {
-				this.buildQueue.waitFor(module, err => {
+				this.buildQueue.waitFor(module, (err) => {
 					if (err) return callback(err);
-					this.processDependenciesQueue.waitFor(module, err => {
+					this.processDependenciesQueue.waitFor(module, (err) => {
 						if (err) return callback(err);
 						for (const { module: m } of this.moduleGraph.getOutgoingConnections(
 							module
@@ -5032,7 +5299,7 @@ This prevents using hashes of each other and should be avoided.`);
 					});
 				});
 			},
-			err => {
+			(err) => {
 				if (err) return callback(/** @type {WebpackError} */ (err));
 
 				// Create new chunk graph, chunk and entrypoint for the build time execution
@@ -5106,7 +5373,7 @@ This prevents using hashes of each other and should be avoided.`);
 						runtimeTemplate,
 						errors,
 						codeGenerationResults,
-						(err, codeGenerated) => {
+						(err, _codeGenerated) => {
 							callback(err);
 						}
 					);
@@ -5115,7 +5382,7 @@ This prevents using hashes of each other and should be avoided.`);
 				const reportErrors = () => {
 					if (errors.length > 0) {
 						errors.sort(
-							compareSelect(err => err.module, compareModulesByIdentifier)
+							compareSelect((err) => err.module, compareModulesByIdentifier)
 						);
 						for (const error of errors) {
 							this.errors.push(error);
@@ -5125,7 +5392,7 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 
 				// Generate code for all aggregated modules
-				asyncLib.eachLimit(modules, 10, codeGen, err => {
+				asyncLib.eachLimit(modules, 10, codeGen, (err) => {
 					if (err) return callback(err);
 					reportErrors();
 
@@ -5161,7 +5428,7 @@ This prevents using hashes of each other and should be avoided.`);
 					}
 
 					// Generate code for all runtime modules
-					asyncLib.eachLimit(runtimeModules, 10, codeGen, err => {
+					asyncLib.eachLimit(runtimeModules, 10, codeGen, (err) => {
 						if (err) return callback(err);
 						reportErrors();
 
@@ -5205,7 +5472,6 @@ This prevents using hashes of each other and should be avoided.`);
 								const moduleArgument = {
 									module,
 									codeGenerationResult,
-									preparedInfo: undefined,
 									moduleObject: undefined
 								};
 								moduleArgumentsMap.set(module, moduleArgument);
@@ -5237,45 +5503,58 @@ This prevents using hashes of each other and should be avoided.`);
 									callback
 								);
 							},
-							err => {
+							(err) => {
 								if (err) return callback(err);
 
+								/** @type {ExecuteModuleExports | undefined} */
 								let exports;
 								try {
 									const {
 										strictModuleErrorHandling,
 										strictModuleExceptionHandling
 									} = this.outputOptions;
-									const __webpack_require__ = id => {
+
+									/** @type {WebpackRequire} */
+									const __webpack_require__ = (id) => {
 										const cached = moduleCache[id];
 										if (cached !== undefined) {
 											if (cached.error) throw cached.error;
 											return cached.exports;
 										}
 										const moduleArgument = moduleArgumentsById.get(id);
-										return __webpack_require_module__(moduleArgument, id);
+										return __webpack_require_module__(
+											/** @type {ExecuteModuleArgument} */
+											(moduleArgument),
+											id
+										);
 									};
 									const interceptModuleExecution = (__webpack_require__[
-										RuntimeGlobals.interceptModuleExecution.replace(
-											`${RuntimeGlobals.require}.`,
-											""
+										/** @type {"i"} */
+										(
+											RuntimeGlobals.interceptModuleExecution.replace(
+												`${RuntimeGlobals.require}.`,
+												""
+											)
 										)
-									] = []);
+									] = /** @type {NonNullable<WebpackRequire["i"]>} */ ([]));
 									const moduleCache = (__webpack_require__[
-										RuntimeGlobals.moduleCache.replace(
-											`${RuntimeGlobals.require}.`,
-											""
+										/** @type {"c"} */ (
+											RuntimeGlobals.moduleCache.replace(
+												`${RuntimeGlobals.require}.`,
+												""
+											)
 										)
-									] = {});
+									] = /** @type {NonNullable<WebpackRequire["c"]>} */ ({}));
 
 									context.__webpack_require__ = __webpack_require__;
 
 									/**
 									 * @param {ExecuteModuleArgument} moduleArgument the module argument
 									 * @param {string=} id id
-									 * @returns {any} exports
+									 * @returns {ExecuteModuleExports} exports
 									 */
 									const __webpack_require_module__ = (moduleArgument, id) => {
+										/** @type {ExecuteOptions} */
 										const execOptions = {
 											id,
 											module: {
@@ -5310,9 +5589,14 @@ This prevents using hashes of each other and should be avoided.`);
 											if (strictModuleExceptionHandling) {
 												if (id) delete moduleCache[id];
 											} else if (strictModuleErrorHandling) {
-												moduleObject.error = execErr;
+												moduleObject.error =
+													/** @type {WebpackError} */
+													(execErr);
+											}
+											if (!(/** @type {WebpackError} */ (execErr).module)) {
+												/** @type {WebpackError} */
+												(execErr).module = module;
 											}
-											if (!execErr.module) execErr.module = module;
 											throw execErr;
 										}
 									};
@@ -5325,15 +5609,21 @@ This prevents using hashes of each other and should be avoided.`);
 											(moduleArgumentsMap.get(runtimeModule))
 										);
 									}
+
 									exports = __webpack_require__(module.identifier());
 								} catch (execErr) {
+									const { message, stack, module } =
+										/** @type {WebpackError} */
+										(execErr);
 									const err = new WebpackError(
-										`Execution of module code from module graph (${module.readableIdentifier(
-											this.requestShortener
-										)}) failed: ${execErr.message}`
+										`Execution of module code from module graph (${
+											/** @type {Module} */
+											(module).readableIdentifier(this.requestShortener)
+										}) failed: ${message}`,
+										{ cause: execErr }
 									);
-									err.stack = execErr.stack;
-									err.module = execErr.module;
+									err.stack = stack;
+									err.module = module;
 									return callback(err);
 								}
 
@@ -5357,7 +5647,7 @@ This prevents using hashes of each other and should be avoided.`);
 	checkConstraints() {
 		const chunkGraph = this.chunkGraph;
 
-		/** @type {Set<number|string>} */
+		/** @type {Set<ModuleId>} */
 		const usedIds = new Set();
 
 		for (const module of this.modules) {
@@ -5412,19 +5702,6 @@ This prevents using hashes of each other and should be avoided.`);
  * @returns {void}
  */
 
-// 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;
-	(options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
-}} */ (
-	function (options, callback) {
-		this.factorizeQueue.add(options, callback);
-	}
-);
-/* eslint-enable jsdoc/require-asterisk-prefix */
-
 // Hide from typescript
 const compilationPrototype = Compilation.prototype;
 
@@ -5449,7 +5726,7 @@ Object.defineProperty(compilationPrototype, "cache", {
 		 * @this {Compilation} the compilation
 		 * @returns {Cache} the cache
 		 */
-		function () {
+		function cache() {
 			return this.compiler.cache;
 		},
 		"Compilation.cache was removed in favor of Compilation.getCache()",
@@ -5457,9 +5734,9 @@ Object.defineProperty(compilationPrototype, "cache", {
 	),
 	set: util.deprecate(
 		/**
-		 * @param {any} v value
+		 * @param {EXPECTED_ANY} _v value
 		 */
-		v => {},
+		(_v) => {},
 		"Compilation.cache was removed in favor of Compilation.getCache()",
 		"DEP_WEBPACK_COMPILATION_CACHE"
 	)