webpack 5.59.0 → 5.94.0

package/lib/Compilation.js

@@ -43,11 +43,13 @@ const Module = require("./Module");
 const ModuleDependencyError = require("./ModuleDependencyError");
 const ModuleDependencyWarning = require("./ModuleDependencyWarning");
 const ModuleGraph = require("./ModuleGraph");
+const ModuleHashingError = require("./ModuleHashingError");
 const ModuleNotFoundError = require("./ModuleNotFoundError");
 const ModuleProfile = require("./ModuleProfile");
 const ModuleRestoreError = require("./ModuleRestoreError");
 const ModuleStoreError = require("./ModuleStoreError");
 const ModuleTemplate = require("./ModuleTemplate");
+const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const RuntimeTemplate = require("./RuntimeTemplate");
 const Stats = require("./Stats");
@@ -60,7 +62,7 @@ const StatsPrinter = require("./stats/StatsPrinter");
 const { equals: arrayEquals } = require("./util/ArrayHelpers");
 const AsyncQueue = require("./util/AsyncQueue");
 const LazySet = require("./util/LazySet");
-const { provide } = require("./util/MapHelpers");
+const { getOrInsert } = require("./util/MapHelpers");
 const WeakTupleMap = require("./util/WeakTupleMap");
 const { cachedCleverMerge } = require("./util/cleverMerge");
 const {
@@ -86,11 +88,13 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
 /** @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("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
 /** @typedef {import("./Cache")} Cache */
 /** @typedef {import("./CacheFacade")} CacheFacade */
+/** @typedef {import("./Chunk").ChunkId} ChunkId */
 /** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Compiler").CompilationParams} CompilationParams */
@@ -99,8 +103,11 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("./DependencyTemplate")} DependencyTemplate */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
+/** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./ModuleFactory")} ModuleFactory */
+/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
 /** @typedef {import("./RequestShortener")} RequestShortener */
@@ -110,40 +117,45 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsModule} StatsModule */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("./util/Hash")} Hash */
-/** @template T @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<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=} err
+ * @param {(WebpackError | null)=} err
  * @returns {void}
  */
 
 /**
  * @callback ModuleCallback
- * @param {WebpackError=} err
- * @param {Module=} result
+ * @param {(WebpackError | null)=} err
+ * @param {(Module | null)=} result
  * @returns {void}
  */
 
 /**
  * @callback ModuleFactoryResultCallback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @param {ModuleFactoryResult=} result
  * @returns {void}
  */
 
 /**
  * @callback ModuleOrFactoryResultCallback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @param {Module | ModuleFactoryResult=} result
  * @returns {void}
  */
 
 /**
  * @callback ExecuteModuleCallback
- * @param {WebpackError=} err
+ * @param {WebpackError | null} err
  * @param {ExecuteModuleResult=} result
  * @returns {void}
  */
@@ -158,20 +170,20 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {Record<string, Source>} CompilationAssets */
 
 /**
- * @typedef {Object} AvailableModulesChunkGroupMapping
+ * @typedef {object} AvailableModulesChunkGroupMapping
  * @property {ChunkGroup} chunkGroup
  * @property {Set<Module>} availableModules
  * @property {boolean} needCopy
  */
 
 /**
- * @typedef {Object} DependenciesBlockLike
+ * @typedef {object} DependenciesBlockLike
  * @property {Dependency[]} dependencies
  * @property {AsyncDependenciesBlock[]} blocks
  */
 
 /**
- * @typedef {Object} ChunkPathData
+ * @typedef {object} ChunkPathData
  * @property {string|number} id
  * @property {string=} name
  * @property {string} hash
@@ -181,25 +193,26 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
- * @typedef {Object} ChunkHashContext
+ * @typedef {object} ChunkHashContext
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
  * @property {ModuleGraph} moduleGraph the module graph
  * @property {ChunkGraph} chunkGraph the chunk graph
  */
 
 /**
- * @typedef {Object} RuntimeRequirementsContext
+ * @typedef {object} RuntimeRequirementsContext
  * @property {ChunkGraph} chunkGraph the chunk graph
  * @property {CodeGenerationResults} codeGenerationResults the code generation results
  */
 
 /**
- * @typedef {Object} ExecuteModuleOptions
+ * @typedef {object} ExecuteModuleOptions
  * @property {EntryOptions=} entryOptions
  */
 
 /**
- * @typedef {Object} ExecuteModuleResult
+ * @typedef {object} ExecuteModuleResult
  * @property {any} exports
  * @property {boolean} cacheable
  * @property {Map<string, { source: Source, info: AssetInfo }>} assets
@@ -210,7 +223,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
- * @typedef {Object} ExecuteModuleArgument
+ * @typedef {object} ExecuteModuleArgument
  * @property {Module} module
  * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
  * @property {any} preparedInfo
@@ -218,7 +231,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
- * @typedef {Object} ExecuteModuleContext
+ * @typedef {object} ExecuteModuleContext
  * @property {Map<string, { source: Source, info: AssetInfo }>} assets
  * @property {Chunk} chunk
  * @property {ChunkGraph} chunkGraph
@@ -226,22 +239,22 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
- * @typedef {Object} EntryData
+ * @typedef {object} EntryData
  * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup
  * @property {Dependency[]} includeDependencies dependencies of the entrypoint that should be included but not evaluated
  * @property {EntryOptions} options options of the entrypoint
  */
 
 /**
- * @typedef {Object} LogEntry
+ * @typedef {object} LogEntry
  * @property {string} type
- * @property {any[]} args
+ * @property {any[]=} args
  * @property {number} time
  * @property {string[]=} trace
  */
 
 /**
- * @typedef {Object} KnownAssetInfo
+ * @typedef {object} KnownAssetInfo
  * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)
  * @property {boolean=} minimized whether the asset is minimized
  * @property {string | string[]=} fullhash the value(s) of the full hash used for this asset
@@ -258,22 +271,24 @@ const { isSourceEqual } = require("./util/source");
 
 /** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
 
+/** @typedef {{ path: string, info: AssetInfo }} InterpolatedPathAndAssetInfo */
+
 /**
- * @typedef {Object} Asset
+ * @typedef {object} Asset
  * @property {string} name the filename of the asset
  * @property {Source} source source of the asset
  * @property {AssetInfo} info info about the asset
  */
 
 /**
- * @typedef {Object} ModulePathData
+ * @typedef {object} ModulePathData
  * @property {string|number} id
  * @property {string} hash
  * @property {function(number): string=} hashWithLength
  */
 
 /**
- * @typedef {Object} PathData
+ * @typedef {object} PathData
  * @property {ChunkGraph=} chunkGraph
  * @property {string=} hash
  * @property {function(number): string=} hashWithLength
@@ -291,7 +306,7 @@ const { isSourceEqual } = require("./util/source");
  */
 
 /**
- * @typedef {Object} KnownNormalizedStatsOptions
+ * @typedef {object} KnownNormalizedStatsOptions
  * @property {string} context
  * @property {RequestShortener} requestShortener
  * @property {string} chunksSort
@@ -335,26 +350,41 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, any>} NormalizedStatsOptions */
 
 /**
- * @typedef {Object} KnownCreateStatsOptionsContext
+ * @typedef {object} KnownCreateStatsOptionsContext
  * @property {boolean=} forToString
  */
 
-/** @typedef {KnownCreateStatsOptionsContext & Record<string, any>} CreateStatsOptionsContext */
+/** @typedef {Record<string, any> & KnownCreateStatsOptionsContext} CreateStatsOptionsContext */
+
+/** @typedef {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} CodeGenerationJobs */
+
+/** @typedef {{javascript: ModuleTemplate}} ModuleTemplates */
+
+/** @typedef {Set<Module>} NotCodeGeneratedModules */
+
+/** @typedef {string | Set<string> | undefined} ValueCacheVersion */
 
 /** @type {AssetInfo} */
 const EMPTY_ASSET_INFO = Object.freeze({});
 
 const esmDependencyCategory = "esm";
+
 // TODO webpack 6: remove
 const deprecatedNormalModuleLoaderHook = util.deprecate(
-	compilation => {
-		return require("./NormalModule").getCompilationHooks(compilation).loader;
-	},
+	/**
+	 * @param {Compilation} compilation compilation
+	 * @returns {NormalModuleCompilationHooks["loader"]} hooks
+	 */
+	compilation =>
+		require("./NormalModule").getCompilationHooks(compilation).loader,
 	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
 	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
 );
 
 // TODO webpack 6: remove
+/**
+ * @param {ModuleTemplates | undefined} moduleTemplates module templates
+ */
 const defineRemovedModuleTemplates = moduleTemplates => {
 	Object.defineProperties(moduleTemplates, {
 		asset: {
@@ -379,30 +409,11 @@ const defineRemovedModuleTemplates = moduleTemplates => {
 	moduleTemplates = undefined;
 };
 
-const byId = compareSelect(
-	/**
-	 * @param {Chunk} c chunk
-	 * @returns {number | string} id
-	 */ c => c.id,
-	compareIds
-);
+const byId = compareSelect(c => c.id, compareIds);
 
 const byNameOrHash = concatComparators(
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} name
-		 */
-		c => c.name,
-		compareIds
-	),
-	compareSelect(
-		/**
-		 * @param {Compilation} c compilation
-		 * @returns {string} hash
-		 */ c => c.fullHash,
-		compareIds
-	)
+	compareSelect(c => c.name, compareIds),
+	compareSelect(c => c.fullHash, compareIds)
 );
 
 const byMessage = compareSelect(err => `${err.message}`, compareStringsNumeric);
@@ -429,14 +440,20 @@ class Compilation {
 	 * @param {CompilationParams} params the compilation parameters
 	 */
 	constructor(compiler, params) {
+		this._backCompat = compiler._backCompat;
+
 		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
 		/** @typedef {{ additionalAssets?: true | Function }} ProcessAssetsAdditionalOptions */
 		/** @type {AsyncSeriesHook<[CompilationAssets], ProcessAssetsAdditionalOptions>} */
 		const processAssetsHook = new AsyncSeriesHook(["assets"]);
 
 		let savedAssets = new Set();
+		/**
+		 * @param {CompilationAssets} assets assets
+		 * @returns {CompilationAssets} new assets
+		 */
 		const popNewAssets = assets => {
-			let newAssets = undefined;
+			let newAssets;
 			for (const file of Object.keys(assets)) {
 				if (savedAssets.has(file)) continue;
 				if (newAssets === undefined) {
@@ -472,8 +489,8 @@ class Compilation {
 							fn: (assets, callback) => {
 								try {
 									fn(assets);
-								} catch (e) {
-									return callback(e);
+								} catch (err) {
+									return callback(err);
 								}
 								if (processedAssets !== undefined)
 									processedAssets.add(this.assets);
@@ -559,6 +576,11 @@ class Compilation {
 		 * @returns {FakeHook<Pick<AsyncSeriesHook<T>, "tap" | "tapAsync" | "tapPromise" | "name">>} fake hook which redirects
 		 */
 		const createProcessAssetsHook = (name, stage, getArgs, code) => {
+			if (!this._backCompat && code) return;
+			/**
+			 * @param {string} reason reason
+			 * @returns {string} error message
+			 */
 			const errorMessage =
 				reason => `Can't automatically convert plugin using Compilation.hooks.${name} to Compilation.hooks.processAssets because ${reason}.
 BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a single Compilation.hooks.processAssets hook.`;
@@ -567,7 +589,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (options.stage) {
 					throw new Error(errorMessage("it's using the 'stage' option"));
 				}
-				return { ...options, stage: stage };
+				return { ...options, stage };
 			};
 			return createFakeHook(
 				{
@@ -641,22 +663,27 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			/** @type {SyncHook<[]>} */
 			beforeChunks: new SyncHook([]),
-			/** @type {SyncHook<[Iterable<Chunk>]>} */
+			/**
+			 * The `afterChunks` hook is called directly after the chunks and module graph have
+			 * been created and before the chunks and modules have been optimized. This hook is useful to
+			 * inspect, analyze, and/or modify the chunk graph.
+			 * @type {SyncHook<[Iterable<Chunk>]>}
+			 */
 			afterChunks: new SyncHook(["chunks"]),
 
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			/** @type {SyncBailHook<[Iterable<Module>], boolean | void>} */
 			optimizeDependencies: new SyncBailHook(["modules"]),
 			/** @type {SyncHook<[Iterable<Module>]>} */
 			afterOptimizeDependencies: new SyncHook(["modules"]),
 
 			/** @type {SyncHook<[]>} */
 			optimize: new SyncHook([]),
-			/** @type {SyncBailHook<[Iterable<Module>]>} */
+			/** @type {SyncBailHook<[Iterable<Module>], boolean | void>} */
 			optimizeModules: new SyncBailHook(["modules"]),
 			/** @type {SyncHook<[Iterable<Module>]>} */
 			afterOptimizeModules: new SyncHook(["modules"]),
 
-			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]]>} */
+			/** @type {SyncBailHook<[Iterable<Chunk>, ChunkGroup[]], boolean | void>} */
 			optimizeChunks: new SyncBailHook(["chunks", "chunkGroups"]),
 			/** @type {SyncHook<[Iterable<Chunk>, ChunkGroup[]]>} */
 			afterOptimizeChunks: new SyncHook(["chunks", "chunkGroups"]),
@@ -666,11 +693,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
 			afterOptimizeTree: new SyncHook(["chunks", "modules"]),
 
-			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>]>} */
+			/** @type {AsyncSeriesBailHook<[Iterable<Chunk>, Iterable<Module>], void>} */
 			optimizeChunkModules: new AsyncSeriesBailHook(["chunks", "modules"]),
 			/** @type {SyncHook<[Iterable<Chunk>, Iterable<Module>]>} */
 			afterOptimizeChunkModules: new SyncHook(["chunks", "modules"]),
-			/** @type {SyncBailHook<[], boolean>} */
+			/** @type {SyncBailHook<[], boolean | undefined>} */
 			shouldRecord: new SyncBailHook([]),
 
 			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
@@ -679,7 +706,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInChunk: new HookMap(
 				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
@@ -689,7 +716,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
+			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInModule: new HookMap(
 				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
 			),
@@ -699,7 +726,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtimeRequirements",
 				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext], void>>} */
 			runtimeRequirementInTree: new HookMap(
 				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
@@ -813,7 +840,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
 			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
-			/** @type {SyncBailHook<[], boolean>} */
+			/** @type {SyncBailHook<[], boolean | undefined>} */
 			needAdditionalSeal: new SyncBailHook([]),
 			/** @type {AsyncSeriesHook<[]>} */
 			afterSeal: new AsyncSeriesHook([]),
@@ -831,7 +858,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]>} */
+			/** @type {SyncWaterfallHook<[string, object, AssetInfo | undefined]>} */
 			assetPath: new SyncWaterfallHook(["path", "options", "assetInfo"]),
 
 			/** @type {SyncBailHook<[], boolean>} */
@@ -867,13 +894,19 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 		/** @type {string=} */
 		this.name = undefined;
+		/** @type {number | undefined} */
 		this.startTime = undefined;
+		/** @type {number | undefined} */
 		this.endTime = undefined;
 		/** @type {Compiler} */
 		this.compiler = compiler;
 		this.resolverFactory = compiler.resolverFactory;
-		this.inputFileSystem = compiler.inputFileSystem;
+		/** @type {InputFileSystem} */
+		this.inputFileSystem =
+			/** @type {InputFileSystem} */
+			(compiler.inputFileSystem);
 		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
+			unmanagedPaths: compiler.unmanagedPaths,
 			managedPaths: compiler.managedPaths,
 			immutablePaths: compiler.immutablePaths,
 			logger: this.getLogger("webpack.FileSystemInfo"),
@@ -888,14 +921,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				true
 			);
 		}
-		/** @type {Map<string, string | Set<string>>} */
+		/** @type {Map<string, ValueCacheVersion>} */
 		this.valueCacheVersions = new Map();
 		this.requestShortener = compiler.requestShortener;
 		this.compilerPath = compiler.compilerPath;
 
 		this.logger = this.getLogger("webpack.Compilation");
 
-		const options = compiler.options;
+		const options = /** @type {WebpackOptions} */ (compiler.options);
 		this.options = options;
 		this.outputOptions = options && options.output;
 		/** @type {boolean} */
@@ -911,7 +944,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.outputOptions,
 			this.requestShortener
 		);
-		/** @type {{javascript: ModuleTemplate}} */
+		/** @type {ModuleTemplates} */
 		this.moduleTemplates = {
 			javascript: new ModuleTemplate(this.runtimeTemplate, this)
 		};
@@ -983,7 +1016,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.asyncEntrypoints = [];
 		/** @type {Set<Chunk>} */
 		this.chunks = new Set();
-		arrayToSetDeprecation(this.chunks, "Compilation.chunks");
 		/** @type {ChunkGroup[]} */
 		this.chunkGroups = [];
 		/** @type {Map<string, ChunkGroup>} */
@@ -992,8 +1024,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.namedChunks = new Map();
 		/** @type {Set<Module>} */
 		this.modules = new Set();
-		arrayToSetDeprecation(this.modules, "Compilation.modules");
-		/** @private @type {Map<string, Module>} */
+		if (this._backCompat) {
+			arrayToSetDeprecation(this.chunks, "Compilation.chunks");
+			arrayToSetDeprecation(this.modules, "Compilation.modules");
+		}
+		/**
+		 * @private
+		 * @type {Map<string, Module>}
+		 */
 		this._modules = new Map();
 		this.records = null;
 		/** @type {string[]} */
@@ -1015,7 +1053,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {Map<DepConstructor, ModuleFactory>} */
 		this.dependencyFactories = new Map();
 		/** @type {DependencyTemplates} */
-		this.dependencyTemplates = new DependencyTemplates();
+		this.dependencyTemplates = new DependencyTemplates(
+			this.outputOptions.hashFunction
+		);
+		/** @type {Record<string, number>} */
 		this.childrenCounters = {};
 		/** @type {Set<number|string>} */
 		this.usedChunkIds = null;
@@ -1033,7 +1074,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.codeGeneratedModules = new WeakSet();
 		/** @type {WeakSet<Module>} */
 		this.buildTimeExecutedModules = new WeakSet();
-		/** @private @type {Map<Module, Callback[]>} */
+		/**
+		 * @private
+		 * @type {Map<Module, Callback[]>}
+		 */
 		this._rebuildingModules = new Map();
 		/** @type {Set<string>} */
 		this.emittedAssets = new Set();
@@ -1050,6 +1094,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		// TODO webpack 6 remove
 		this.compilationDependencies = {
 			add: util.deprecate(
+				/**
+				 * @param {string} item item
+				 * @returns {LazySet<string>} file dependencies
+				 */
 				item => this.fileDependencies.add(item),
 				"Compilation.compilationDependencies is deprecated (used Compilation.fileDependencies instead)",
 				"DEP_WEBPACK_COMPILATION_COMPILATION_DEPENDENCIES"
@@ -1061,7 +1109,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
 
 		const unsafeCache = options.module.unsafeCache;
-		this._unsafeCache = !!unsafeCache;
+		this._unsafeCache = Boolean(unsafeCache);
 		this._unsafeCachePredicate =
 			typeof unsafeCache === "function" ? unsafeCache : () => true;
 	}
@@ -1071,15 +1119,16 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
-	 * @param {StatsOptions | string} optionsOrPreset stats option value
-	 * @param {CreateStatsOptionsContext} context context
+	 * @param {string | boolean | StatsOptions | undefined} optionsOrPreset stats option value
+	 * @param {CreateStatsOptionsContext=} context context
 	 * @returns {NormalizedStatsOptions} normalized options
 	 */
 	createStatsOptions(optionsOrPreset, context = {}) {
-		if (
-			typeof optionsOrPreset === "boolean" ||
-			typeof optionsOrPreset === "string"
-		) {
+		if (typeof optionsOrPreset === "boolean") {
+			optionsOrPreset = {
+				preset: optionsOrPreset === false ? "none" : "normal"
+			};
+		} else if (typeof optionsOrPreset === "string") {
 			optionsOrPreset = { preset: optionsOrPreset };
 		}
 		if (typeof optionsOrPreset === "object" && optionsOrPreset !== null) {
@@ -1087,28 +1136,36 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			// properties in the prototype chain
 			/** @type {Partial<NormalizedStatsOptions>} */
 			const options = {};
+			// eslint-disable-next-line guard-for-in
 			for (const key in optionsOrPreset) {
-				options[key] = optionsOrPreset[key];
+				options[key] = optionsOrPreset[/** @type {keyof StatsOptions} */ (key)];
 			}
 			if (options.preset !== undefined) {
 				this.hooks.statsPreset.for(options.preset).call(options, context);
 			}
 			this.hooks.statsNormalize.call(options, context);
 			return /** @type {NormalizedStatsOptions} */ (options);
-		} else {
-			/** @type {Partial<NormalizedStatsOptions>} */
-			const options = {};
-			this.hooks.statsNormalize.call(options, context);
-			return /** @type {NormalizedStatsOptions} */ (options);
 		}
+		/** @type {Partial<NormalizedStatsOptions>} */
+		const options = {};
+		this.hooks.statsNormalize.call(options, context);
+		return /** @type {NormalizedStatsOptions} */ (options);
 	}
 
+	/**
+	 * @param {NormalizedStatsOptions} options options
+	 * @returns {StatsFactory} the stats factory
+	 */
 	createStatsFactory(options) {
 		const statsFactory = new StatsFactory();
 		this.hooks.statsFactory.call(statsFactory, options);
 		return statsFactory;
 	}
 
+	/**
+	 * @param {NormalizedStatsOptions} options options
+	 * @returns {StatsPrinter} the stats printer
+	 */
 	createStatsPrinter(options) {
 		const statsPrinter = new StatsPrinter();
 		this.hooks.statsPrinter.call(statsPrinter, options);
@@ -1148,7 +1205,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					case LogType.warn:
 					case LogType.error:
 					case LogType.trace:
-						trace = ErrorHelpers.cutOffLoaderExecution(new Error("Trace").stack)
+						trace = ErrorHelpers.cutOffLoaderExecution(
+							/** @type {string} */ (new Error("Trace").stack)
+						)
 							.split("\n")
 							.slice(3);
 						break;
@@ -1161,12 +1220,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					trace
 				};
 				if (this.hooks.log.call(name, logEntry) === undefined) {
-					if (logEntry.type === LogType.profileEnd) {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						if (typeof console.profileEnd === "function") {
-							// eslint-disable-next-line node/no-unsupported-features/node-builtins
-							console.profileEnd(`[${name}] ${logEntry.args[0]}`);
-						}
+					if (
+						logEntry.type === LogType.profileEnd &&
+						typeof console.profileEnd === "function"
+					) {
+						console.profileEnd(
+							`[${name}] ${/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]}`
+						);
 					}
 					if (logEntries === undefined) {
 						logEntries = this.logging.get(name);
@@ -1176,12 +1236,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						}
 					}
 					logEntries.push(logEntry);
-					if (logEntry.type === LogType.profile) {
-						// eslint-disable-next-line node/no-unsupported-features/node-builtins
-						if (typeof console.profile === "function") {
-							// eslint-disable-next-line node/no-unsupported-features/node-builtins
-							console.profile(`[${name}] ${logEntry.args[0]}`);
-						}
+					if (
+						logEntry.type === LogType.profile &&
+						typeof console.profile === "function"
+					) {
+						console.profile(
+							`[${name}] ${/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]}`
+						);
 					}
 				}
 			},
@@ -1207,36 +1268,33 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							}
 							return `${name}/${childName}`;
 						});
-					} else {
-						return this.getLogger(() => {
-							if (typeof name === "function") {
-								name = name();
-								if (!name) {
-									throw new TypeError(
-										"Compilation.getLogger(name) called with a function not returning a name"
-									);
-								}
-							}
-							return `${name}/${childName}`;
-						});
 					}
-				} else {
-					if (typeof childName === "function") {
-						return this.getLogger(() => {
-							if (typeof childName === "function") {
-								childName = childName();
-								if (!childName) {
-									throw new TypeError(
-										"Logger.getChildLogger(name) called with a function not returning a name"
-									);
-								}
+					return this.getLogger(() => {
+						if (typeof name === "function") {
+							name = name();
+							if (!name) {
+								throw new TypeError(
+									"Compilation.getLogger(name) called with a function not returning a name"
+								);
 							}
-							return `${name}/${childName}`;
-						});
-					} else {
-						return this.getLogger(`${name}/${childName}`);
-					}
+						}
+						return `${name}/${childName}`;
+					});
+				}
+				if (typeof childName === "function") {
+					return this.getLogger(() => {
+						if (typeof childName === "function") {
+							childName = childName();
+							if (!childName) {
+								throw new TypeError(
+									"Logger.getChildLogger(name) called with a function not returning a name"
+								);
+							}
+						}
+						return `${name}/${childName}`;
+					});
 				}
+				return this.getLogger(`${name}/${childName}`);
 			}
 		);
 	}
@@ -1286,7 +1344,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 			this._modules.set(identifier, module);
 			this.modules.add(module);
-			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+			if (this._backCompat)
+				ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 			if (currentProfile !== undefined) {
 				currentProfile.markIntegrationEnd();
 			}
@@ -1301,7 +1360,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 */
 	getModule(module) {
 		const identifier = module.identifier();
-		return this._modules.get(identifier);
+		return /** @type {Module} */ (this._modules.get(identifier));
 	}
 
 	/**
@@ -1315,7 +1374,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 	/**
 	 * Schedules a build of the module object
-	 *
 	 * @param {Module} module module to be built
 	 * @param {ModuleCallback} callback the callback
 	 * @returns {void}
@@ -1326,7 +1384,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 	/**
 	 * Builds the module object
-	 *
 	 * @param {Module} module module to be built
 	 * @param {ModuleCallback} callback the callback
 	 * @returns {void}
@@ -1362,7 +1419,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.options,
 					this,
 					this.resolverFactory.get("normal", module.resolveOptions),
-					this.inputFileSystem,
+					/** @type {InputFileSystem} */ (this.inputFileSystem),
 					err => {
 						if (currentProfile !== undefined) {
 							currentProfile.markBuildingEnd();
@@ -1379,7 +1436,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								currentProfile.markStoringEnd();
 							}
 							if (err) {
-								this.hooks.failedModule.call(module, err);
+								this.hooks.failedModule.call(
+									module,
+									/** @type {WebpackError} */ (err)
+								);
 								return callback(new ModuleStoreError(module, err));
 							}
 							this.hooks.succeedModule.call(module);
@@ -1405,6 +1465,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	processModuleDependenciesNonRecursive(module) {
+		/**
+		 * @param {DependenciesBlock} block block
+		 */
 		const processDependenciesBlock = block => {
 			if (block.dependencies) {
 				let i = 0;
@@ -1426,7 +1489,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
+		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], context: string|undefined, originModule: Module|null}>} */
 		const sortedDependencies = [];
 
 		/** @type {DependenciesBlock} */
@@ -1450,6 +1513,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let inProgressSorting = 1;
 		let inProgressTransitive = 1;
 
+		/**
+		 * @param {WebpackError=} err error
+		 * @returns {void}
+		 */
 		const onDependenciesSorted = err => {
 			if (err) return callback(err);
 
@@ -1463,6 +1530,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			for (const item of sortedDependencies) {
 				inProgressTransitive++;
+				// eslint-disable-next-line no-loop-func
 				this.handleModuleCreation(item, err => {
 					// In V8, the Error objects keep a reference to the functions on the stack. These warnings &
 					// errors are created inside closures that keep a reference to the Compilation, so errors are
@@ -1481,6 +1549,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			if (--inProgressTransitive === 0) onTransitiveTasksFinished();
 		};
 
+		/**
+		 * @param {WebpackError=} err error
+		 * @returns {void}
+		 */
 		const onTransitiveTasksFinished = err => {
 			if (err) return callback(err);
 			this.processDependenciesQueue.decreaseParallelism();
@@ -1528,7 +1600,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							if (err) {
 								if (inProgressSorting <= 0) return;
 								inProgressSorting = -1;
-								onDependenciesSorted(err);
+								onDependenciesSorted(/** @type {WebpackError} */ (err));
 								return;
 							}
 							try {
@@ -1583,15 +1655,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							} catch (err) {
 								if (inProgressSorting <= 0) return;
 								inProgressSorting = -1;
-								onDependenciesSorted(err);
+								onDependenciesSorted(/** @type {WebpackError} */ (err));
 								return;
 							}
 							if (--inProgressSorting === 0) onDependenciesSorted();
 						});
 						return;
 					}
-				} catch (e) {
-					console.error(e);
+				} catch (err) {
+					console.error(err);
 				}
 			}
 			processDependencyForResolving(dep);
@@ -1658,6 +1730,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					sortedDependencies.push({
 						factory: factoryCacheKey2,
 						dependencies: list,
+						context: dep.getContext(),
 						originModule: module
 					});
 				}
@@ -1672,7 +1745,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {DependenciesBlock[]} */
 			const queue = [module];
 			do {
-				const block = queue.pop();
+				const block = /** @type {DependenciesBlock} */ (queue.pop());
 				if (block.dependencies) {
 					currentBlock = block;
 					let i = 0;
@@ -1682,13 +1755,20 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					for (const b of block.blocks) queue.push(b);
 				}
 			} while (queue.length !== 0);
-		} catch (e) {
-			return callback(e);
+		} catch (err) {
+			return callback(err);
 		}
 
 		if (--inProgressSorting === 0) onDependenciesSorted();
 	}
 
+	/**
+	 * @private
+	 * @param {Module} originModule original module
+	 * @param {Dependency} dependency dependency
+	 * @param {Module} module cached module
+	 * @param {Callback} callback callback
+	 */
 	_handleNewModuleFromUnsafeCache(originModule, dependency, module, callback) {
 		const moduleGraph = this.moduleGraph;
 
@@ -1701,16 +1781,24 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		this._modules.set(module.identifier(), module);
 		this.modules.add(module);
-		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 
 		this._handleModuleBuildAndDependencies(
 			originModule,
 			module,
 			true,
+			false,
 			callback
 		);
 	}
 
+	/**
+	 * @private
+	 * @param {Module} originModule original modules
+	 * @param {Dependency} dependency dependency
+	 * @param {Module} module cached module
+	 */
 	_handleExistingModuleFromUnsafeCache(originModule, dependency, module) {
 		const moduleGraph = this.moduleGraph;
 
@@ -1718,7 +1806,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
-	 * @typedef {Object} HandleModuleCreationOptions
+	 * @typedef {object} HandleModuleCreationOptions
 	 * @property {ModuleFactory} factory
 	 * @property {Dependency[]} dependencies
 	 * @property {Module | null} originModule
@@ -1726,6 +1814,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @property {string=} context
 	 * @property {boolean=} recursive recurse into dependencies of the created module
 	 * @property {boolean=} connectOrigin connect the resolved module with the origin module
+	 * @property {boolean=} checkCycle check the cycle dependencies of the created module
 	 */
 
 	/**
@@ -1741,7 +1830,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			contextInfo,
 			context,
 			recursive = true,
-			connectOrigin = recursive
+			connectOrigin = recursive,
+			checkCycle = !recursive
 		},
 		callback
 	) {
@@ -1778,10 +1868,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					if (dependencies.every(d => d.optional)) {
 						this.warnings.push(err);
 						return callback();
-					} else {
-						this.errors.push(err);
-						return callback(err);
 					}
+					this.errors.push(err);
+					return callback(err);
 				}
 
 				const newModule = factoryResult.module;
@@ -1795,27 +1884,30 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					moduleGraph.setProfile(newModule, currentProfile);
 				}
 
-				this.addModule(newModule, (err, module) => {
+				this.addModule(newModule, (err, _module) => {
 					if (err) {
 						applyFactoryResultDependencies();
 						if (!err.module) {
-							err.module = module;
+							err.module = _module;
 						}
 						this.errors.push(err);
 
 						return callback(err);
 					}
 
+					const module =
+						/** @type {Module & { restoreFromUnsafeCache?: Function }} */
+						(_module);
+
 					if (
 						this._unsafeCache &&
 						factoryResult.cacheable !== false &&
-						/** @type {any} */ (module).restoreFromUnsafeCache &&
+						module.restoreFromUnsafeCache &&
 						this._unsafeCachePredicate(module)
 					) {
 						const unsafeCacheableModule =
-							/** @type {Module & { restoreFromUnsafeCache: Function }} */ (
-								module
-							);
+							/** @type {Module & { restoreFromUnsafeCache: Function }} */
+							(module);
 						for (let i = 0; i < dependencies.length; i++) {
 							const dependency = dependencies[i];
 							moduleGraph.setResolvedModule(
@@ -1847,14 +1939,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						module,
 						originModule !== undefined ? originModule : null
 					);
-					if (module !== newModule) {
-						if (currentProfile !== undefined) {
-							const otherProfile = moduleGraph.getProfile(module);
-							if (otherProfile !== undefined) {
-								currentProfile.mergeInto(otherProfile);
-							} else {
-								moduleGraph.setProfile(module, currentProfile);
-							}
+					if (module !== newModule && currentProfile !== undefined) {
+						const otherProfile = moduleGraph.getProfile(module);
+						if (otherProfile !== undefined) {
+							currentProfile.mergeInto(otherProfile);
+						} else {
+							moduleGraph.setProfile(module, currentProfile);
 						}
 					}
 
@@ -1862,6 +1952,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						originModule,
 						module,
 						recursive,
+						checkCycle,
 						callback
 					);
 				});
@@ -1869,10 +1960,26 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
-	_handleModuleBuildAndDependencies(originModule, module, recursive, callback) {
+	/**
+	 * @private
+	 * @param {Module} 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
+	 * @param {ModuleCallback} callback callback
+	 * @returns {void}
+	 */
+	_handleModuleBuildAndDependencies(
+		originModule,
+		module,
+		recursive,
+		checkCycle,
+		callback
+	) {
 		// Check for cycles when build is trigger inside another build
-		let creatingModuleDuringBuildSet = undefined;
-		if (!recursive && this.buildQueue.isProcessing(originModule)) {
+		/** @type {Set<Module> | undefined} */
+		let creatingModuleDuringBuildSet;
+		if (checkCycle && this.buildQueue.isProcessing(originModule)) {
 			// Track build dependency
 			creatingModuleDuringBuildSet =
 				this.creatingModuleDuringBuild.get(originModule);
@@ -1926,7 +2033,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			// This avoids deadlocks for circular dependencies
 			if (this.processDependenciesQueue.isProcessing(module)) {
-				return callback();
+				return callback(null, module);
 			}
 
 			this.processModuleDependencies(module, err => {
@@ -1967,12 +2074,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					...contextInfo
 				},
 				resolveOptions: originModule ? originModule.resolveOptions : undefined,
-				context: context
-					? context
-					: originModule
-					? originModule.context
-					: this.compiler.context,
-				dependencies: dependencies
+				context:
+					context ||
+					(originModule ? originModule.context : this.compiler.context),
+				dependencies
 			},
 			(err, result) => {
 				if (result) {
@@ -2004,7 +2109,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					const notFoundError = new ModuleNotFoundError(
 						originModule,
 						err,
-						dependencies.map(d => d.loc).filter(Boolean)[0]
+						dependencies.map(d => d.loc).find(Boolean)
 					);
 					return callback(notFoundError, factoryResult ? result : undefined);
 				}
@@ -2032,7 +2137,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	}
 
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {string} options.context context string path
 	 * @param {Dependency} options.dependency dependency used to create Module chain
 	 * @param {Partial<ModuleFactoryCreateDataContextInfo>=} options.contextInfo additional context info for the root module
@@ -2139,7 +2244,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 			};
 			entryData[target].push(entry);
-			this.entries.set(name, entryData);
+			this.entries.set(
+				/** @type {NonNullable<EntryOptions["name"]>} */ (name),
+				entryData
+			);
 		} else {
 			entryData[target].push(entry);
 			for (const key of Object.keys(options)) {
@@ -2179,7 +2287,11 @@ 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);
 			}
 		);
@@ -2239,6 +2351,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 	}
 
+	/**
+	 * @private
+	 * @param {Set<Module>} modules modules
+	 */
 	_computeAffectedModules(modules) {
 		const moduleMemCacheCache = this.compiler.moduleMemCaches;
 		if (!moduleMemCacheCache) return;
@@ -2255,9 +2371,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statReferencesChanged = 0;
 		let statWithoutBuild = 0;
 
+		/**
+		 * @param {Module} module module
+		 * @returns {References | undefined} references
+		 */
 		const computeReferences = module => {
-			/** @type {WeakMap<Dependency, Module>} */
-			let references = undefined;
+			/** @type {References | undefined} */
+			let references;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
 				const m = connection.module;
@@ -2270,7 +2390,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		/**
 		 * @param {Module} module the module
-		 * @param {WeakMap<Dependency, Module>} references references
+		 * @param {References | undefined} references references
 		 * @returns {boolean} true, when the references differ
 		 */
 		const compareReferences = (module, references) => {
@@ -2342,6 +2462,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 		}
 
+		/**
+		 * @param {readonly ModuleGraphConnection[]} connections connections
+		 * @returns {symbol|boolean} result
+		 */
 		const reduceAffectType = connections => {
 			let affected = false;
 			for (const { dependency } of connections) {
@@ -2417,13 +2541,14 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statNew = 0;
 		/**
 		 * @param {Module} module module
-		 * @returns {{ modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[] }} references
+		 * @returns {{ id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[] }} references
 		 */
 		const computeReferences = module => {
-			/** @type {Map<Module, string | number | undefined>} */
-			let modules = undefined;
-			/** @type {(string | number)[] | undefined} */
-			let blocks = undefined;
+			const id = chunkGraph.getModuleId(module);
+			/** @type {Map<Module, string | number | undefined> | undefined} */
+			let modules;
+			/** @type {(string | number | null)[] | undefined} */
+			let blocks;
 			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
 			if (outgoing !== undefined) {
 				for (const m of outgoing.keys()) {
@@ -2444,19 +2569,22 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					} else {
 						blocks.push(null);
 					}
+					// eslint-disable-next-line prefer-spread
 					queue.push.apply(queue, block.blocks);
 				}
 			}
-			return { modules, blocks };
+			return { id, modules, blocks };
 		};
 		/**
 		 * @param {Module} module module
-		 * @param {Object} references references
-		 * @param {Map<Module, string | number>=} references.modules modules
-		 * @param {(string | number)[]=} references.blocks blocks
+		 * @param {object} references references
+		 * @param {string | number} references.id id
+		 * @param {Map<Module, string | number | undefined>=} references.modules modules
+		 * @param {(string | number | null)[]=} references.blocks blocks
 		 * @returns {boolean} ok?
 		 */
-		const compareReferences = (module, { modules, blocks }) => {
+		const compareReferences = (module, { id, modules, blocks }) => {
+			if (id !== chunkGraph.getModuleId(module)) return false;
 			if (modules !== undefined) {
 				for (const [module, id] of modules) {
 					if (chunkGraph.getModuleId(module) !== id) return false;
@@ -2471,9 +2599,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						for (const chunk of chunkGroup.chunks) {
 							if (i >= blocks.length || blocks[i++] !== chunk.id) return false;
 						}
-					} else {
-						if (i >= blocks.length || blocks[i++] !== null) return false;
+					} else if (i >= blocks.length || blocks[i++] !== null) {
+						return false;
 					}
+					// eslint-disable-next-line prefer-spread
 					queue.push.apply(queue, block.blocks);
 				}
 				if (i !== blocks.length) return false;
@@ -2482,7 +2611,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		};
 
 		for (const [module, memCache] of moduleMemCaches) {
-			/** @type {{ references: { modules?: Map<Module, string | number | undefined>, blocks?: (string | number)[]}, memCache: WeakTupleMap<any[], any> }} */
+			/** @type {{ references: { id: string | number, modules?: Map<Module, string | number | undefined>, blocks?: (string | number | null)[]}, memCache: WeakTupleMap<any[], any> }} */
 			const cache = memCache.get(key);
 			if (cache === undefined) {
 				const memCache2 = new WeakTupleMap();
@@ -2511,6 +2640,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
+	/**
+	 * @param {Callback} callback callback
+	 */
 	finish(callback) {
 		this.factorizeQueue.clear();
 		if (this.profile) {
@@ -2518,6 +2650,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			const ParallelismFactorCalculator = require("./util/ParallelismFactorCalculator");
 			const p = new ParallelismFactorCalculator();
 			const moduleGraph = this.moduleGraph;
+			/** @type {Map<Module, ModuleProfile>} */
 			const modulesWithProfiles = new Map();
 			for (const module of this.modules) {
 				const profile = moduleGraph.getProfile(module);
@@ -2563,6 +2696,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			p.calculate();
 
 			const logger = this.getLogger("webpack.Compilation.ModuleProfile");
+			// Avoid coverage problems due indirect changes
+			/**
+			 * @param {number} value value
+			 * @param {string} msg message
+			 */
+			/* istanbul ignore next */
 			const logByValue = (value, msg) => {
 				if (value > 1000) {
 					logger.error(msg);
@@ -2576,6 +2715,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					logger.debug(msg);
 				}
 			};
+			/**
+			 * @param {string} category a category
+			 * @param {(profile: ModuleProfile) => number} getDuration get duration callback
+			 * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback
+			 */
 			const logNormalSummary = (category, getDuration, getParallelism) => {
 				let sum = 0;
 				let max = 0;
@@ -2600,12 +2744,17 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					`${Math.round(sum)} ms ${category}`
 				);
 			};
+			/**
+			 * @param {string} category a category
+			 * @param {(profile: ModuleProfile) => number} getDuration get duration callback
+			 * @param {(profile: ModuleProfile) => number} getParallelism get parallelism callback
+			 */
 			const logByLoadersSummary = (category, getDuration, getParallelism) => {
 				const map = new Map();
 				for (const [module, profile] of modulesWithProfiles) {
-					const list = provide(
+					const list = getOrInsert(
 						map,
-						module.type + "!" + module.identifier().replace(/(!|^)[^!]*$/, ""),
+						`${module.type}!${module.identifier().replace(/(!|^)[^!]*$/, "")}`,
 						() => []
 					);
 					list.push({ module, profile });
@@ -2645,9 +2794,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							loaders
 								? `${
 										modules.length
-								  } x ${moduleType} with ${this.requestShortener.shorten(
+									} x ${moduleType} with ${this.requestShortener.shorten(
 										loaders
-								  )}`
+									)}`
 								: `${modules.length} x ${moduleType}`
 						}`
 					);
@@ -2698,7 +2847,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		const { modules, moduleMemCaches } = this;
 		this.hooks.finishModules.callAsync(modules, err => {
 			this.logger.timeEnd("finish modules");
-			if (err) return callback(err);
+			if (err) return callback(/** @type {WebpackError} */ (err));
 
 			// extract warnings and errors from modules
 			this.moduleGraph.freeze("dependency errors");
@@ -2763,6 +2912,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	seal(callback) {
+		/**
+		 * @param {WebpackError=} err err
+		 * @returns {void}
+		 */
 		const finalCallback = err => {
 			this.factorizeQueue.clear();
 			this.buildQueue.clear();
@@ -2777,8 +2930,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 		this.chunkGraph = chunkGraph;
 
-		for (const module of this.modules) {
-			ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+		if (this._backCompat) {
+			for (const module of this.modules) {
+				ChunkGraph.setChunkGraphForModule(module, chunkGraph);
+			}
 		}
 
 		this.hooks.seal.call();
@@ -2830,11 +2985,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			this.assignDepths(entryModules);
 
+			/**
+			 * @param {Dependency[]} deps deps
+			 * @returns {Module[]} sorted deps
+			 */
 			const mapAndSort = deps =>
-				deps
-					.map(dep => this.moduleGraph.getModule(dep))
-					.filter(Boolean)
-					.sort(compareModulesByIdentifier);
+				/** @type {Module[]} */
+				(deps.map(dep => this.moduleGraph.getModule(dep)).filter(Boolean)).sort(
+					compareModulesByIdentifier
+				);
 			const includedModules = [
 				...mapAndSort(this.globalEntry.includeDependencies),
 				...mapAndSort(includeDependencies)
@@ -2862,12 +3021,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 Entrypoints that depend on other entrypoints do not have their own runtime.
 They will use the runtime(s) from referenced entrypoints instead.
 Remove the 'runtime' option from the entrypoint.`);
-				const entry = this.entrypoints.get(name);
+				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
 				err.chunk = entry.getEntrypointChunk();
 				this.errors.push(err);
 			}
 			if (dependOn) {
-				const entry = this.entrypoints.get(name);
+				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
 				const referencedChunks = entry
 					.getEntrypointChunk()
 					.getAllReferencedChunks();
@@ -2895,7 +3054,7 @@ Remove the 'runtime' option from the entrypoint.`);
 					connectChunkGroupParentAndChild(dependency, entry);
 				}
 			} else if (runtime) {
-				const entry = this.entrypoints.get(name);
+				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
 				let chunk = this.namedChunks.get(runtime);
 				if (chunk) {
 					if (!runtimeChunks.has(chunk)) {
@@ -2906,7 +3065,9 @@ Did you mean to use 'dependOn: ${JSON.stringify(
 								runtime
 							)}' instead to allow using entrypoint '${name}' within the runtime of entrypoint '${runtime}'? For this '${runtime}' must always be loaded when '${name}' is used.
 Or do you want to use the entrypoints '${name}' and '${runtime}' independently on the same page with a shared runtime? In this case give them both the same value for the 'runtime' option. It must be a name not already used by an entrypoint.`);
-						const entryChunk = entry.getEntrypointChunk();
+						const entryChunk =
+							/** @type {Chunk} */
+							(entry.getEntrypointChunk());
 						err.chunk = entryChunk;
 						this.errors.push(err);
 						entry.setRuntimeChunk(entryChunk);
@@ -3045,13 +3206,17 @@ 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 = 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)
 									);
 
 									this.summarizeDependencies();
@@ -3138,12 +3303,15 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		return hasProblems;
 	}
 
+	/**
+	 * @param {Callback} callback callback
+	 */
 	codeGeneration(callback) {
 		const { chunkGraph } = this;
 		this.codeGenerationResults = new CodeGenerationResults(
 			this.outputOptions.hashFunction
 		);
-		/** @type {{module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}[]} */
+		/** @type {CodeGenerationJobs} */
 		const jobs = [];
 		for (const module of this.modules) {
 			const runtimes = chunkGraph.getModuleRuntimes(module);
@@ -3172,54 +3340,111 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		this._runCodeGenerationJobs(jobs, callback);
 	}
 
+	/**
+	 * @private
+	 * @param {CodeGenerationJobs} jobs code generation jobs
+	 * @param {Callback} callback callback
+	 * @returns {void}
+	 */
 	_runCodeGenerationJobs(jobs, callback) {
+		if (jobs.length === 0) {
+			return callback();
+		}
 		let statModulesFromCache = 0;
 		let statModulesGenerated = 0;
 		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
 			this;
 		const results = this.codeGenerationResults;
+		/** @type {WebpackError[]} */
 		const errors = [];
-		asyncLib.eachLimit(
-			jobs,
-			this.options.parallelism,
-			({ module, hash, runtime, runtimes }, callback) => {
-				this._codeGenerationModule(
-					module,
-					runtime,
-					runtimes,
-					hash,
-					dependencyTemplates,
-					chunkGraph,
-					moduleGraph,
-					runtimeTemplate,
-					errors,
-					results,
-					(err, codeGenerated) => {
-						if (codeGenerated) statModulesGenerated++;
-						else statModulesFromCache++;
-						callback(err);
+		/** @type {NotCodeGeneratedModules | undefined} */
+		let notCodeGeneratedModules;
+		const runIteration = () => {
+			/** @type {CodeGenerationJobs} */
+			let delayedJobs = [];
+			let delayedModules = new Set();
+			asyncLib.eachLimit(
+				jobs,
+				/** @type {number} */
+				(this.options.parallelism),
+				(job, callback) => {
+					const { module } = job;
+					const { codeGenerationDependencies } = module;
+					if (
+						codeGenerationDependencies !== undefined &&
+						(notCodeGeneratedModules === undefined ||
+							codeGenerationDependencies.some(dep => {
+								const referencedModule = /** @type {Module} */ (
+									moduleGraph.getModule(dep)
+								);
+								return /** @type {NotCodeGeneratedModules} */ (
+									notCodeGeneratedModules
+								).has(referencedModule);
+							}))
+					) {
+						delayedJobs.push(job);
+						delayedModules.add(module);
+						return callback();
 					}
-				);
-			},
-			err => {
-				if (err) return callback(err);
-				if (errors.length > 0) {
-					errors.sort(
-						compareSelect(err => err.module, compareModulesByIdentifier)
+					const { hash, runtime, runtimes } = job;
+					this._codeGenerationModule(
+						module,
+						runtime,
+						runtimes,
+						hash,
+						dependencyTemplates,
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						errors,
+						results,
+						(err, codeGenerated) => {
+							if (codeGenerated) statModulesGenerated++;
+							else statModulesFromCache++;
+							callback(err);
+						}
 					);
-					for (const error of errors) {
-						this.errors.push(error);
+				},
+				err => {
+					if (err) return callback(err);
+					if (delayedJobs.length > 0) {
+						if (delayedJobs.length === jobs.length) {
+							return callback(
+								/** @type {WebpackError} */ (
+									new Error(
+										`Unable to make progress during code generation because of circular code generation dependency: ${Array.from(
+											delayedModules,
+											m => m.identifier()
+										).join(", ")}`
+									)
+								)
+							);
+						}
+						jobs = delayedJobs;
+						delayedJobs = [];
+						notCodeGeneratedModules = delayedModules;
+						delayedModules = new Set();
+						return runIteration();
+					}
+					if (errors.length > 0) {
+						errors.sort(
+							compareSelect(err => err.module, compareModulesByIdentifier)
+						);
+						for (const error of errors) {
+							this.errors.push(error);
+						}
 					}
+					this.logger.log(
+						`${Math.round(
+							(100 * statModulesGenerated) /
+								(statModulesGenerated + statModulesFromCache)
+						)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
+					);
+					callback();
 				}
-				this.logger.log(
-					`${Math.round(
-						(100 * statModulesGenerated) /
-							(statModulesGenerated + statModulesFromCache)
-					)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
-				);
-				callback();
-			}
-		);
+			);
+		};
+		runIteration();
 	}
 
 	/**
@@ -3233,7 +3458,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=, boolean=): void} callback callback
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback
 	 */
 	_codeGenerationModule(
 		module,
@@ -3258,7 +3483,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			)
 		);
 		cache.get((err, cachedResult) => {
-			if (err) return callback(err);
+			if (err) return callback(/** @type {WebpackError} */ (err));
 			let result;
 			if (!cachedResult) {
 				try {
@@ -3269,10 +3494,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						moduleGraph,
 						dependencyTemplates,
 						runtimeTemplate,
-						runtime
+						runtime,
+						codeGenerationResults: results,
+						compilation: this
 					});
 				} catch (err) {
-					errors.push(new CodeGenerationError(module, err));
+					errors.push(
+						new CodeGenerationError(module, /** @type {Error} */ (err))
+					);
 					result = cachedResult = {
 						sources: new Map(),
 						runtimeRequirements: null
@@ -3285,7 +3514,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				results.add(module, runtime, result);
 			}
 			if (!cachedResult) {
-				cache.store(result, err => callback(err, codeGenerated));
+				cache.store(result, err =>
+					callback(/** @type {WebpackError} */ (err), codeGenerated)
+				);
 			} else {
 				callback(null, codeGenerated);
 			}
@@ -3307,7 +3538,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {ChunkGraph=} options.chunkGraph the chunk graph
 	 * @param {Iterable<Module>=} options.modules modules
 	 * @param {Iterable<Chunk>=} options.chunks chunks
@@ -3377,21 +3608,19 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 								null
 							);
 						}
+					} else if (memCache) {
+						memCache.set(
+							`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
+							set
+						);
+						chunkGraph.addModuleRuntimeRequirements(
+							module,
+							runtime,
+							set,
+							false
+						);
 					} else {
-						if (memCache) {
-							memCache.set(
-								`moduleRuntimeRequirements-${getRuntimeKey(runtime)}`,
-								set
-							);
-							chunkGraph.addModuleRuntimeRequirements(
-								module,
-								runtime,
-								set,
-								false
-							);
-						} else {
-							chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
-						}
+						chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
 					}
 				}
 			}
@@ -3453,7 +3682,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 */
 	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
 		// Deprecated ModuleGraph association
-		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
+		if (this._backCompat)
+			ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 
 		// add it to the list
 		this.modules.add(module);
@@ -3497,10 +3727,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
+	 * If `module` is passed, `loc` and `request` must also be passed.
 	 * @param {string | ChunkGroupOptions} groupOptions options for the chunk group
-	 * @param {Module} module the module the references the chunk group
-	 * @param {DependencyLocation} loc the location from with the chunk group is referenced (inside of module)
-	 * @param {string} request the request from which the the chunk group is referenced
+	 * @param {Module=} module the module the references the chunk group
+	 * @param {DependencyLocation=} loc the location from with the chunk group is referenced (inside of module)
+	 * @param {string=} request the request from which the the chunk group is referenced
 	 * @returns {ChunkGroup} the new or existing chunk group
 	 */
 	addChunkInGroup(groupOptions, module, loc, request) {
@@ -3514,13 +3745,24 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			if (chunkGroup !== undefined) {
 				chunkGroup.addOptions(groupOptions);
 				if (module) {
-					chunkGroup.addOrigin(module, loc, request);
+					chunkGroup.addOrigin(
+						module,
+						/** @type {DependencyLocation} */
+						(loc),
+						request
+					);
 				}
 				return chunkGroup;
 			}
 		}
 		const chunkGroup = new ChunkGroup(groupOptions);
-		if (module) chunkGroup.addOrigin(module, loc, request);
+		if (module)
+			chunkGroup.addOrigin(
+				module,
+				/** @type {DependencyLocation} */
+				(loc),
+				request
+			);
 		const chunk = this.addChunk(name);
 
 		connectChunkGroupAndChunk(chunkGroup, chunk);
@@ -3578,7 +3820,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	/**
 	 * This method first looks to see if a name is provided for a new chunk,
 	 * and first looks to see if any named chunks already exist and reuse that chunk instead.
-	 *
 	 * @param {string=} name optional chunk name to be provided
 	 * @returns {Chunk} create a chunk (invoked during seal event)
 	 */
@@ -3589,9 +3830,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				return chunk;
 			}
 		}
-		const chunk = new Chunk(name);
+		const chunk = new Chunk(name, this._backCompat);
 		this.chunks.add(chunk);
-		ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
+		if (this._backCompat)
+			ChunkGraph.setChunkGraphForChunk(chunk, this.chunkGraph);
 		if (name) {
 			this.namedChunks.set(name, chunk);
 		}
@@ -3607,6 +3849,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const moduleGraph = this.moduleGraph;
 
 		const queue = new Set([module]);
+		/** @type {number} */
 		let depth;
 
 		moduleGraph.setDepth(module, 0);
@@ -3622,7 +3865,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 		for (module of queue) {
 			queue.delete(module);
-			depth = moduleGraph.getDepth(module) + 1;
+			depth = /** @type {number} */ (moduleGraph.getDepth(module)) + 1;
 
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const refModule = connection.module;
@@ -3683,7 +3926,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	}
 
 	/**
-	 *
 	 * @param {Module} module module relationship for removal
 	 * @param {DependenciesBlockLike} block //TODO: good description
 	 * @returns {void}
@@ -3722,16 +3964,16 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		if (!module.hasReasons(this.moduleGraph, chunk.runtime)) {
 			this.removeReasonsOfDependencyBlock(module, module);
 		}
-		if (!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph)) {
-			if (this.chunkGraph.isModuleInChunk(module, chunk)) {
-				this.chunkGraph.disconnectChunkAndModule(chunk, module);
-				this.removeChunkFromDependencies(module, chunk);
-			}
+		if (
+			!module.hasReasonForChunk(chunk, this.moduleGraph, this.chunkGraph) &&
+			this.chunkGraph.isModuleInChunk(module, chunk)
+		) {
+			this.chunkGraph.disconnectChunkAndModule(chunk, module);
+			this.removeChunkFromDependencies(module, chunk);
 		}
 	}
 
 	/**
-	 *
 	 * @param {DependenciesBlock} block block tie for Chunk
 	 * @param {Chunk} chunk chunk to remove from dep
 	 * @returns {void}
@@ -3751,7 +3993,9 @@ 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];
-			const chunkGroup = this.chunkGraph.getBlockChunkGroup(asyncBlock);
+			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
@@ -3822,6 +4066,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		let statModulesFromCache = 0;
 		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
 		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
+		/** @type {WebpackError[]} */
+		const errors = [];
 		for (const module of this.modules) {
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
@@ -3832,7 +4078,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 							module,
 							runtime,
 							digest,
-							digest.substr(0, hashDigestLength)
+							digest.slice(0, hashDigestLength)
 						);
 						statModulesFromCache++;
 						continue;
@@ -3846,13 +4092,20 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					hashFunction,
 					runtimeTemplate,
 					hashDigest,
-					hashDigestLength
+					hashDigestLength,
+					errors
 				);
 				if (memCache) {
 					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
 				}
 			}
 		}
+		if (errors.length > 0) {
+			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			for (const error of errors) {
+				this.errors.push(error);
+			}
+		}
 		this.logger.log(
 			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
 				Math.round(
@@ -3862,6 +4115,18 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		);
 	}
 
+	/**
+	 * @private
+	 * @param {Module} module module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {RuntimeSpec} runtime runtime
+	 * @param {OutputOptions["hashFunction"]} hashFunction hash function
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @param {OutputOptions["hashDigest"]} hashDigest hash digest
+	 * @param {OutputOptions["hashDigestLength"]} hashDigestLength hash digest length
+	 * @param {WebpackError[]} errors errors
+	 * @returns {string} module hash digest
+	 */
 	_createModuleHash(
 		module,
 		chunkGraph,
@@ -3869,29 +4134,34 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		hashFunction,
 		runtimeTemplate,
 		hashDigest,
-		hashDigestLength
+		hashDigestLength,
+		errors
 	) {
-		const moduleHash = createHash(hashFunction);
-		module.updateHash(moduleHash, {
-			chunkGraph,
-			runtime,
-			runtimeTemplate
-		});
-		const moduleHashDigest = /** @type {string} */ (
-			moduleHash.digest(hashDigest)
-		);
+		let moduleHashDigest;
+		try {
+			const moduleHash = createHash(hashFunction);
+			module.updateHash(moduleHash, {
+				chunkGraph,
+				runtime,
+				runtimeTemplate
+			});
+			moduleHashDigest = /** @type {string} */ (moduleHash.digest(hashDigest));
+		} catch (err) {
+			errors.push(new ModuleHashingError(module, /** @type {Error} */ (err)));
+			moduleHashDigest = "XXXXXX";
+		}
 		chunkGraph.setModuleHashes(
 			module,
 			runtime,
 			moduleHashDigest,
-			moduleHashDigest.substr(0, hashDigestLength)
+			moduleHashDigest.slice(0, hashDigestLength)
 		);
 		return moduleHashDigest;
 	}
 
 	createHash() {
 		this.logger.time("hashing: initialize hash");
-		const chunkGraph = this.chunkGraph;
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const runtimeTemplate = this.runtimeTemplate;
 		const outputOptions = this.outputOptions;
 		const hashFunction = outputOptions.hashFunction;
@@ -3986,7 +4256,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			for (const chunk of runtimeChunks) {
 				const hasFullHashModules =
 					chunkGraph.getNumberOfChunkFullHashModules(chunk) !== 0;
-				const info = runtimeChunksMap.get(chunk);
+				const info =
+					/** @type {RuntimeChunkInfo} */
+					(runtimeChunksMap.get(chunk));
 				for (const otherInfo of info.referencedBy) {
 					if (hasFullHashModules) {
 						chunkGraph.upgradeDependentToFullHashModules(otherInfo.chunk);
@@ -4006,7 +4278,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		// If there are still remaining references we have cycles and want to create a warning
 		if (remaining > 0) {
-			let circularRuntimeChunkInfo = [];
+			const circularRuntimeChunkInfo = [];
 			for (const info of runtimeChunksMap.values()) {
 				if (info.remaining !== 0) {
 					circularRuntimeChunkInfo.push(info);
@@ -4030,7 +4302,12 @@ This prevents using hashes of each other and should be avoided.`);
 		const codeGenerationJobs = [];
 		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
 		const codeGenerationJobsMap = new Map();
+		/** @type {WebpackError[]} */
+		const errors = [];
 
+		/**
+		 * @param {Chunk} chunk chunk
+		 */
 		const processChunk = chunk => {
 			// Last minute module hash generation for modules that depend on chunk hashes
 			this.logger.time("hashing: hash runtime modules");
@@ -4044,7 +4321,8 @@ This prevents using hashes of each other and should be avoided.`);
 						hashFunction,
 						runtimeTemplate,
 						hashDigest,
-						hashDigestLength
+						hashDigestLength,
+						errors
 					);
 					let hashMap = codeGenerationJobsMap.get(hash);
 					if (hashMap) {
@@ -4068,15 +4346,16 @@ This prevents using hashes of each other and should be avoided.`);
 				}
 			}
 			this.logger.timeAggregate("hashing: hash runtime modules");
-			this.logger.time("hashing: hash chunks");
-			const chunkHash = createHash(hashFunction);
 			try {
+				this.logger.time("hashing: hash chunks");
+				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,
 					moduleGraph: this.moduleGraph,
 					runtimeTemplate: this.runtimeTemplate
 				});
@@ -4085,7 +4364,7 @@ This prevents using hashes of each other and should be avoided.`);
 				);
 				hash.update(chunkHashDigest);
 				chunk.hash = chunkHashDigest;
-				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+				chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 				const fullHashModules =
 					chunkGraph.getChunkFullHashModulesIterable(chunk);
 				if (fullHashModules) {
@@ -4094,24 +4373,34 @@ This prevents using hashes of each other and should be avoided.`);
 					this.hooks.contentHash.call(chunk);
 				}
 			} catch (err) {
-				this.errors.push(new ChunkRenderError(chunk, "", err));
+				this.errors.push(
+					new ChunkRenderError(chunk, "", /** @type {Error} */ (err))
+				);
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
 		};
-		otherChunks.forEach(processChunk);
+		for (const chunk of otherChunks) processChunk(chunk);
 		for (const chunk of runtimeChunks) processChunk(chunk);
+		if (errors.length > 0) {
+			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			for (const error of errors) {
+				this.errors.push(error);
+			}
+		}
 
 		this.logger.timeAggregateEnd("hashing: hash runtime modules");
 		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.hash = this.fullHash.substr(0, hashDigestLength);
+		this.hash = this.fullHash.slice(0, hashDigestLength);
 		this.logger.timeEnd("hashing: hash digest");
 
 		this.logger.time("hashing: process full hash modules");
 		for (const chunk of fullHashChunks) {
-			for (const module of chunkGraph.getChunkFullHashModulesIterable(chunk)) {
+			for (const module of /** @type {Iterable<RuntimeModule>} */ (
+				chunkGraph.getChunkFullHashModulesIterable(chunk)
+			)) {
 				const moduleHash = createHash(hashFunction);
 				module.updateHash(moduleHash, {
 					chunkGraph,
@@ -4126,18 +4415,18 @@ This prevents using hashes of each other and should be avoided.`);
 					module,
 					chunk.runtime,
 					moduleHashDigest,
-					moduleHashDigest.substr(0, hashDigestLength)
+					moduleHashDigest.slice(0, hashDigestLength)
 				);
 				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
 			}
 			const chunkHash = createHash(hashFunction);
 			chunkHash.update(chunk.hash);
 			chunkHash.update(this.hash);
-			const chunkHashDigest = /** @type {string} */ (
-				chunkHash.digest(hashDigest)
-			);
+			const chunkHashDigest =
+				/** @type {string} */
+				(chunkHash.digest(hashDigest));
 			chunk.hash = chunkHashDigest;
-			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+			chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 			this.hooks.contentHash.call(chunk);
 		}
 		this.logger.timeEnd("hashing: process full hash modules");
@@ -4155,7 +4444,11 @@ This prevents using hashes of each other and should be avoided.`);
 			if (!isSourceEqual(this.assets[file], source)) {
 				this.errors.push(
 					new WebpackError(
-						`Conflict: Multiple assets emit different content to the same filename ${file}`
+						`Conflict: Multiple assets emit different content to the same filename ${file}${
+							assetInfo.sourceFilename
+								? `. Original source ${assetInfo.sourceFilename}`
+								: ""
+						}`
 					)
 				);
 				this.assets[file] = source;
@@ -4163,7 +4456,7 @@ This prevents using hashes of each other and should be avoided.`);
 				return;
 			}
 			const oldInfo = this.assetsInfo.get(file);
-			const newInfo = Object.assign({}, oldInfo, assetInfo);
+			const newInfo = { ...oldInfo, ...assetInfo };
 			this._setAssetInfo(file, newInfo, oldInfo);
 			return;
 		}
@@ -4181,6 +4474,9 @@ This prevents using hashes of each other and should be avoided.`);
 		const newRelated = newInfo && newInfo.related;
 		if (oldRelated) {
 			for (const key of Object.keys(oldRelated)) {
+				/**
+				 * @param {string} name name
+				 */
 				const remove = name => {
 					const relatedIn = this._assetsRelatedIn.get(name);
 					if (relatedIn === undefined) return;
@@ -4193,7 +4489,9 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 				const entry = oldRelated[key];
 				if (Array.isArray(entry)) {
-					entry.forEach(remove);
+					for (const name of entry) {
+						remove(name);
+					}
 				} else if (entry) {
 					remove(entry);
 				}
@@ -4201,6 +4499,9 @@ This prevents using hashes of each other and should be avoided.`);
 		}
 		if (newRelated) {
 			for (const key of Object.keys(newRelated)) {
+				/**
+				 * @param {string} name name
+				 */
 				const add = name => {
 					let relatedIn = this._assetsRelatedIn.get(name);
 					if (relatedIn === undefined) {
@@ -4214,7 +4515,9 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 				const entry = newRelated[key];
 				if (Array.isArray(entry)) {
-					entry.forEach(add);
+					for (const name of entry) {
+						add(name);
+					}
 				} else if (entry) {
 					add(entry);
 				}
@@ -4225,7 +4528,7 @@ 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} assetInfoUpdateOrFunction new asset info or function converting old to new
+	 * @param {(AssetInfo | function(AssetInfo | undefined): AssetInfo) | undefined} assetInfoUpdateOrFunction new asset info or function converting old to new
 	 */
 	updateAsset(
 		file,
@@ -4237,11 +4540,10 @@ This prevents using hashes of each other and should be avoided.`);
 				`Called Compilation.updateAsset for not existing filename ${file}`
 			);
 		}
-		if (typeof newSourceOrFunction === "function") {
-			this.assets[file] = newSourceOrFunction(this.assets[file]);
-		} else {
-			this.assets[file] = newSourceOrFunction;
-		}
+		this.assets[file] =
+			typeof newSourceOrFunction === "function"
+				? newSourceOrFunction(this.assets[file])
+				: newSourceOrFunction;
 		if (assetInfoUpdateOrFunction !== undefined) {
 			const oldInfo = this.assetsInfo.get(file) || EMPTY_ASSET_INFO;
 			if (typeof assetInfoUpdateOrFunction === "function") {
@@ -4256,6 +4558,10 @@ This prevents using hashes of each other and should be avoided.`);
 		}
 	}
 
+	/**
+	 * @param {string} file file name
+	 * @param {string} newFile the new name of file
+	 */
 	renameAsset(file, newFile) {
 		const source = this.assets[file];
 		if (!source) {
@@ -4263,14 +4569,12 @@ This prevents using hashes of each other and should be avoided.`);
 				`Called Compilation.renameAsset for not existing filename ${file}`
 			);
 		}
-		if (this.assets[newFile]) {
-			if (!isSourceEqual(this.assets[file], source)) {
-				this.errors.push(
-					new WebpackError(
-						`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
-					)
-				);
-			}
+		if (this.assets[newFile] && !isSourceEqual(this.assets[file], source)) {
+			this.errors.push(
+				new WebpackError(
+					`Conflict: Called Compilation.renameAsset for already existing filename ${newFile} with different content`
+				)
+			);
 		}
 		const assetInfo = this.assetsInfo.get(file);
 		// Update related in all other assets
@@ -4334,6 +4638,9 @@ This prevents using hashes of each other and should be avoided.`);
 		const related = assetInfo && assetInfo.related;
 		if (related) {
 			for (const key of Object.keys(related)) {
+				/**
+				 * @param {string} file file
+				 */
 				const checkUsedAndDelete = file => {
 					if (!this._assetsRelatedIn.has(file)) {
 						this.deleteAsset(file);
@@ -4341,7 +4648,9 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 				const items = related[key];
 				if (Array.isArray(items)) {
-					items.forEach(checkUsedAndDelete);
+					for (const file of items) {
+						checkUsedAndDelete(file);
+					}
 				} else if (items) {
 					checkUsedAndDelete(items);
 				}
@@ -4375,8 +4684,7 @@ This prevents using hashes of each other and should be avoided.`);
 	 * @returns {Readonly<Asset> | undefined} the asset or undefined when not found
 	 */
 	getAsset(name) {
-		if (!Object.prototype.hasOwnProperty.call(this.assets, name))
-			return undefined;
+		if (!Object.prototype.hasOwnProperty.call(this.assets, name)) return;
 		return {
 			name,
 			source: this.assets[name],
@@ -4394,9 +4702,10 @@ This prevents using hashes of each other and should be avoided.`);
 	createModuleAssets() {
 		const { chunkGraph } = this;
 		for (const module of this.modules) {
-			if (module.buildInfo.assets) {
-				const assetsInfo = module.buildInfo.assetsInfo;
-				for (const assetName of Object.keys(module.buildInfo.assets)) {
+			const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+			if (buildInfo.assets) {
+				const assetsInfo = buildInfo.assetsInfo;
+				for (const assetName of Object.keys(buildInfo.assets)) {
 					const fileName = this.getPath(assetName, {
 						chunkGraph: this.chunkGraph,
 						module
@@ -4406,7 +4715,7 @@ This prevents using hashes of each other and should be avoided.`);
 					}
 					this.emitAsset(
 						fileName,
-						module.buildInfo.assets[assetName],
+						buildInfo.assets[assetName],
 						assetsInfo ? assetsInfo.get(assetName) : undefined
 					);
 					this.hooks.moduleAsset.call(module, fileName);
@@ -4453,10 +4762,12 @@ This prevents using hashes of each other and should be avoided.`);
 						runtimeTemplate: this.runtimeTemplate
 					});
 				} catch (err) {
-					this.errors.push(new ChunkRenderError(chunk, "", err));
+					this.errors.push(
+						new ChunkRenderError(chunk, "", /** @type {Error} */ (err))
+					);
 					return callback();
 				}
-				asyncLib.forEach(
+				asyncLib.each(
 					manifest,
 					(fileManifest, callback) => {
 						const ident = fileManifest.identifier;
@@ -4468,7 +4779,7 @@ This prevents using hashes of each other and should be avoided.`);
 						);
 
 						assetCacheItem.get((err, sourceFromCache) => {
-							/** @type {string | function(PathData, AssetInfo=): string} */
+							/** @type {TemplatePath} */
 							let filenameTemplate;
 							/** @type {string} */
 							let file;
@@ -4476,14 +4787,18 @@ This prevents using hashes of each other and should be avoided.`);
 							let assetInfo;
 
 							let inTry = true;
+							/**
+							 * @param {Error} err error
+							 * @returns {void}
+							 */
 							const errorAndCallback = err => {
 								const filename =
 									file ||
 									(typeof file === "string"
 										? file
 										: typeof filenameTemplate === "string"
-										? filenameTemplate
-										: "");
+											? filenameTemplate
+											: "");
 
 								this.errors.push(new ChunkRenderError(chunk, filename, err));
 								inTry = false;
@@ -4505,7 +4820,7 @@ This prevents using hashes of each other and should be avoided.`);
 										? {
 												...pathAndInfo.info,
 												...fileManifest.info
-										  }
+											}
 										: pathAndInfo.info;
 								}
 
@@ -4526,9 +4841,8 @@ This prevents using hashes of each other and should be avoided.`);
 													` (chunks ${alreadyWritten.chunk.id} and ${chunk.id})`
 											)
 										);
-									} else {
-										source = alreadyWritten.source;
 									}
+									source = alreadyWritten.source;
 								} else if (!source) {
 									// render the asset
 									source = fileManifest.render();
@@ -4569,7 +4883,7 @@ This prevents using hashes of each other and should be avoided.`);
 								}
 							} catch (err) {
 								if (!inTry) throw err;
-								errorAndCallback(err);
+								errorAndCallback(/** @type {Error} */ (err));
 							}
 						});
 					},
@@ -4581,7 +4895,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
 	 * @returns {string} interpolated path
 	 */
@@ -4596,9 +4910,9 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
 	getPathWithInfo(filename, data = {}) {
 		if (!data.hash) {
@@ -4611,7 +4925,7 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
 	 * @returns {string} interpolated path
 	 */
@@ -4624,9 +4938,9 @@ This prevents using hashes of each other and should be avoided.`);
 	}
 
 	/**
-	 * @param {string | function(PathData, AssetInfo=): string} filename used to get asset path with hash
+	 * @param {TemplatePath} filename used to get asset path with hash
 	 * @param {PathData} data context data
-	 * @returns {{ path: string, info: AssetInfo }} interpolated path and asset info
+	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
 	getAssetPathWithInfo(filename, data) {
 		const assetInfo = {};
@@ -4651,7 +4965,6 @@ This prevents using hashes of each other and should be avoided.`);
 	 * This function allows you to run another instance of webpack inside of webpack however as
 	 * a child with different settings and configurations (if desired) applied. It copies all hooks, plugins
 	 * from parent (or top level compiler) and creates a child Compilation
-	 *
 	 * @param {string} name name of the child compiler
 	 * @param {OutputOptions=} outputOptions // Need to convert config schema to types for this
 	 * @param {Array<WebpackPluginInstance | WebpackPluginFunction>=} plugins webpack plugins that will be applied
@@ -4680,12 +4993,6 @@ This prevents using hashes of each other and should be avoided.`);
 		processAsyncTree(
 			modules,
 			10,
-			/**
-			 * @param {Module} module the module
-			 * @param {function(Module): void} push push more jobs
-			 * @param {Callback} callback callback
-			 * @returns {void}
-			 */
 			(module, push, callback) => {
 				this.buildQueue.waitFor(module, err => {
 					if (err) return callback(err);
@@ -4703,7 +5010,7 @@ This prevents using hashes of each other and should be avoided.`);
 				});
 			},
 			err => {
-				if (err) return callback(err);
+				if (err) return callback(/** @type {WebpackError} */ (err));
 
 				// Create new chunk graph, chunk and entrypoint for the build time execution
 				const chunkGraph = new ChunkGraph(
@@ -4715,8 +5022,8 @@ This prevents using hashes of each other and should be avoided.`);
 					this.outputOptions;
 				const runtimeTemplate = this.runtimeTemplate;
 
-				const chunk = new Chunk("build time chunk");
-				chunk.id = chunk.name;
+				const chunk = new Chunk("build time chunk", this._backCompat);
+				chunk.id = /** @type {ChunkId} */ (chunk.name);
 				chunk.ids = [chunk.id];
 				chunk.runtime = runtime;
 
@@ -4739,6 +5046,9 @@ This prevents using hashes of each other and should be avoided.`);
 					chunkGraph.connectChunkAndModule(chunk, module);
 				}
 
+				/** @type {WebpackError[]} */
+				const errors = [];
+
 				// Hash modules
 				for (const module of modules) {
 					this._createModuleHash(
@@ -4748,15 +5058,14 @@ This prevents using hashes of each other and should be avoided.`);
 						hashFunction,
 						runtimeTemplate,
 						hashDigest,
-						hashDigestLength
+						hashDigestLength,
+						errors
 					);
 				}
 
 				const codeGenerationResults = new CodeGenerationResults(
 					this.outputOptions.hashFunction
 				);
-				/** @type {WebpackError[]} */
-				const errors = [];
 				/**
 				 * @param {Module} module the module
 				 * @param {Callback} callback callback
@@ -4823,7 +5132,8 @@ This prevents using hashes of each other and should be avoided.`);
 							hashFunction,
 							runtimeTemplate,
 							hashDigest,
-							hashDigestLength
+							hashDigestLength,
+							errors
 						);
 					}
 
@@ -4883,7 +5193,10 @@ This prevents using hashes of each other and should be avoided.`);
 									missingDependencies,
 									buildDependencies
 								);
-								if (module.buildInfo.cacheable === false) {
+								if (
+									/** @type {BuildInfo} */ (module.buildInfo).cacheable ===
+									false
+								) {
 									cacheable = false;
 								}
 								if (module.buildInfo && module.buildInfo.assets) {
@@ -4921,13 +5234,13 @@ This prevents using hashes of each other and should be avoided.`);
 									};
 									const interceptModuleExecution = (__webpack_require__[
 										RuntimeGlobals.interceptModuleExecution.replace(
-											"__webpack_require__.",
+											`${RuntimeGlobals.require}.`,
 											""
 										)
 									] = []);
 									const moduleCache = (__webpack_require__[
 										RuntimeGlobals.moduleCache.replace(
-											"__webpack_require__.",
+											`${RuntimeGlobals.require}.`,
 											""
 										)
 									] = {});
@@ -4940,7 +5253,7 @@ This prevents using hashes of each other and should be avoided.`);
 									 * @returns {any} exports
 									 */
 									const __webpack_require_module__ = (moduleArgument, id) => {
-										var execOptions = {
+										const execOptions = {
 											id,
 											module: {
 												id,
@@ -4950,9 +5263,9 @@ This prevents using hashes of each other and should be avoided.`);
 											},
 											require: __webpack_require__
 										};
-										interceptModuleExecution.forEach(handler =>
-											handler(execOptions)
-										);
+										for (const handler of interceptModuleExecution) {
+											handler(execOptions);
+										}
 										const module = moduleArgument.module;
 										this.buildTimeExecutedModules.add(module);
 										const moduleObject = execOptions.module;
@@ -4970,14 +5283,14 @@ This prevents using hashes of each other and should be avoided.`);
 											);
 											moduleObject.loaded = true;
 											return moduleObject.exports;
-										} catch (e) {
+										} catch (execErr) {
 											if (strictModuleExceptionHandling) {
 												if (id) delete moduleCache[id];
 											} else if (strictModuleErrorHandling) {
-												moduleObject.error = e;
+												moduleObject.error = execErr;
 											}
-											if (!e.module) e.module = module;
-											throw e;
+											if (!execErr.module) execErr.module = module;
+											throw execErr;
 										}
 									};
 
@@ -4985,18 +5298,19 @@ This prevents using hashes of each other and should be avoided.`);
 										chunk
 									)) {
 										__webpack_require_module__(
-											moduleArgumentsMap.get(runtimeModule)
+											/** @type {ExecuteModuleArgument} */
+											(moduleArgumentsMap.get(runtimeModule))
 										);
 									}
 									exports = __webpack_require__(module.identifier());
-								} catch (e) {
+								} catch (execErr) {
 									const err = new WebpackError(
 										`Execution of module code from module graph (${module.readableIdentifier(
 											this.requestShortener
-										)}) failed: ${e.message}`
+										)}) failed: ${execErr.message}`
 									);
-									err.stack = e.stack;
-									err.module = e.module;
+									err.stack = execErr.stack;
+									err.module = execErr.module;
 									return callback(err);
 								}
 
@@ -5024,7 +5338,7 @@ This prevents using hashes of each other and should be avoided.`);
 		const usedIds = new Set();
 
 		for (const module of this.modules) {
-			if (module.type === "runtime") continue;
+			if (module.type === WEBPACK_MODULE_TYPE_RUNTIME) continue;
 			const moduleId = chunkGraph.getModuleId(module);
 			if (moduleId === null) continue;
 			if (usedIds.has(moduleId)) {
@@ -5059,7 +5373,7 @@ This prevents using hashes of each other and should be avoided.`);
 }
 
 /**
- * @typedef {Object} FactorizeModuleOptions
+ * @typedef {object} FactorizeModuleOptions
  * @property {ModuleProfile} currentProfile
  * @property {ModuleFactory} factory
  * @property {Dependency[]} dependencies
@@ -5076,7 +5390,9 @@ This prevents using hashes of each other and should be avoided.`);
  */
 
 // Workaround for typescript as it doesn't support function overloading in jsdoc within a class
-Compilation.prototype.factorizeModule = /** @type {{
+/* eslint-disable jsdoc/require-asterisk-prefix */
+Compilation.prototype.factorizeModule = /**
+	 @type {{
 	(options: FactorizeModuleOptions & { factoryResult?: false }, callback: ModuleCallback): void;
 	(options: FactorizeModuleOptions & { factoryResult: true }, callback: ModuleFactoryResultCallback): void;
 }} */ (
@@ -5084,6 +5400,7 @@ Compilation.prototype.factorizeModule = /** @type {{
 		this.factorizeQueue.add(options, callback);
 	}
 );
+/* eslint-enable jsdoc/require-asterisk-prefix */
 
 // Hide from typescript
 const compilationPrototype = Compilation.prototype;
@@ -5116,6 +5433,9 @@ Object.defineProperty(compilationPrototype, "cache", {
 		"DEP_WEBPACK_COMPILATION_CACHE"
 	),
 	set: util.deprecate(
+		/**
+		 * @param {any} v value
+		 */
 		v => {},
 		"Compilation.cache was removed in favor of Compilation.getCache()",
 		"DEP_WEBPACK_COMPILATION_CACHE"