@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/Compilation.js

@@ -11,6 +11,7 @@ const {
 	AsyncParallelHook,
 	AsyncSeriesBailHook,
 	AsyncSeriesHook,
+	AsyncSeriesWaterfallHook,
 	HookMap,
 	SyncBailHook,
 	SyncHook,
@@ -39,19 +40,10 @@ const RuntimeGlobals = require("./RuntimeGlobals");
 const RuntimeTemplate = require("./RuntimeTemplate");
 const Stats = require("./Stats");
 const buildChunkGraph = require("./buildChunkGraph");
-const BuildCycleError = require("./errors/BuildCycleError");
-const ChunkRenderError = require("./errors/ChunkRenderError");
-const CodeGenerationError = require("./errors/CodeGenerationError");
 const {
 	makeWebpackError,
 	tryRunOrWebpackError
 } = require("./errors/HookWebpackError");
-const ModuleDependencyError = require("./errors/ModuleDependencyError");
-const ModuleDependencyWarning = require("./errors/ModuleDependencyWarning");
-const ModuleHashingError = require("./errors/ModuleHashingError");
-const ModuleNotFoundError = require("./errors/ModuleNotFoundError");
-const ModuleRestoreError = require("./errors/ModuleRestoreError");
-const ModuleStoreError = require("./errors/ModuleStoreError");
 const WebpackError = require("./errors/WebpackError");
 const { LogType, Logger } = require("./logging/Logger");
 const StatsFactory = require("./stats/StatsFactory");
@@ -63,11 +55,10 @@ const { getOrInsert } = require("./util/MapHelpers");
 const WeakTupleMap = require("./util/WeakTupleMap");
 const { cachedCleverMerge } = require("./util/cleverMerge");
 const {
+	compareErrors,
 	compareIds,
-	compareLocations,
 	compareModulesByIdentifier,
 	compareSelect,
-	compareStringsNumeric,
 	concatComparators
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
@@ -76,62 +67,124 @@ const {
 	createFakeHook,
 	soonFrozenObjectDeprecation
 } = require("./util/deprecation");
+const memoize = require("./util/memoize");
 const processAsyncTree = require("./util/processAsyncTree");
 const { getRuntimeKey } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/WebpackOptions").OutputNormalized} OutputOptions */
-/** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
-/** @typedef {import("../declarations/WebpackOptions").HashDigest} HashDigest */
-/** @typedef {import("../declarations/WebpackOptions").HashDigestLength} HashDigestLength */
-/** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
-/** @typedef {import("../declarations/WebpackOptions").Plugins} Plugins */
-/** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptionsWithDefaults */
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./CacheFacade")} CacheFacade */
-/** @typedef {import("./Chunk").ChunkName} ChunkName */
-/** @typedef {import("./Chunk").ChunkId} ChunkId */
-/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Compiler").CompilationParams} CompilationParams */
-/** @typedef {import("./Compiler").MemCache} MemCache */
-/** @typedef {import("./Compiler").WeakReferences} WeakReferences */
-/** @typedef {import("./Compiler").ModuleMemCachesItem} ModuleMemCachesItem */
-/** @typedef {import("./Compiler").Records} Records */
-/** @typedef {import("./DependenciesBlock")} DependenciesBlock */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").ReferencedExports} ReferencedExports */
+const getModuleStoreError = memoize(() => require("./errors/ModuleStoreError"));
+
+const getModuleRestoreError = memoize(() =>
+	require("./errors/ModuleRestoreError")
+);
+
+const getModuleNotFoundError = memoize(() =>
+	require("./errors/ModuleNotFoundError")
+);
+
+const getModuleHashingError = memoize(() =>
+	require("./errors/ModuleHashingError")
+);
+
+const getModuleDependencyWarning = memoize(() =>
+	require("./errors/ModuleDependencyWarning")
+);
+
+const getModuleDependencyError = memoize(() =>
+	require("./errors/ModuleDependencyError")
+);
+
+const getCodeGenerationError = memoize(() =>
+	require("./errors/CodeGenerationError")
+);
+
+const getChunkRenderError = memoize(() => require("./errors/ChunkRenderError"));
+
+const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
+
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	OutputNormalized as OutputOptions,
+ * 	HashFunction,
+ * 	HashDigest,
+ * 	HashDigestLength,
+ * 	StatsOptions,
+ * 	Plugins,
+ * 	ResolveOptions
+ * } from "../declarations/WebpackOptions"
+ */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions,
+ * 	OutputNormalizedWithDefaults as OutputOptionsWithDefaults
+ * } from "./config/defaults"
+ */
+/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import Cache from "./Cache" */
+/** @import CacheFacade from "./CacheFacade" */
+/** @import { ChunkName, ChunkId } from "./Chunk" */
+/** @import { ChunkGroupOptions } from "./ChunkGroup" */
+/**
+ * @import Compiler, {
+ * 	CompilationParams,
+ * 	MemCache,
+ * 	WeakReferences,
+ * 	ModuleMemCachesItem,
+ * 	Records
+ * } from "./Compiler"
+ */
+/** @import DependenciesBlock from "./DependenciesBlock" */
+/** @import { DependencyLocation, ReferencedExports } from "./Dependency" */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module").NameForCondition} NameForCondition */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
-/** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
-/** @typedef {import("./Module").FactoryMeta} FactoryMeta */
-/** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("./ModuleFactory")} ModuleFactory */
-/** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("./ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./NormalModule")} NormalModule */
-/** @typedef {import("./NormalModule").AnyLoaderContext} AnyLoaderContext */
-/** @typedef {import("./NormalModule").ParserOptions} ParserOptions */
-/** @typedef {import("./NormalModule").GeneratorOptions} GeneratorOptions */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
-/** @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 */
+/**
+ * @import {
+ * 	NameForCondition,
+ * 	BuildInfo,
+ * 	ValueCacheVersions,
+ * 	RuntimeRequirements,
+ * 	SourceTypes,
+ * 	SourceType,
+ * 	FactoryMeta,
+ * 	CodeGenerationResult
+ * } from "./Module"
+ */
+/**
+ * @import NormalModule, {
+ * 	NormalModuleCompilationHooks,
+ * 	AnyLoaderContext,
+ * 	ParserOptions,
+ * 	GeneratorOptions
+ * } from "./NormalModule"
+ */
+/**
+ * @import ModuleFactory, {
+ * 	ModuleFactoryCreateDataContextInfo,
+ * 	ModuleFactoryResult
+ * } from "./ModuleFactory"
+ */
+/** @import { ModuleId } from "./ChunkGraph" */
+/** @import ModuleGraphConnection from "./ModuleGraphConnection" */
+/** @import RequestShortener from "./RequestShortener" */
+/** @import RuntimeModule from "./RuntimeModule" */
+/** @import { RenderManifestEntry, RenderManifestOptions } from "./Template" */
+
+/**
+ * One language's source embedded in another's output.
+ * @typedef {object} EmbeddedSourceInfo
+ * @property {SourceType} type the embedded source's type, e.g. `"css"` / `"html"`
+ * @property {SourceType} hostType the type of the source it is embedded in, e.g. `"javascript"`
+ * @property {Module} module the module being generated
+ * @property {string=} as which of that language's productions this is, where more than one can be embedded — a `style=""` holds `"block-contents"`, an inline `<style>` a whole `"stylesheet"`. Absent where the language has only one
+ */
+/**
+ * @import {
+ * 	StatsAsset,
+ * 	StatsError,
+ * 	StatsModule
+ * } from "./stats/DefaultStatsFactoryPlugin"
+ */
+/** @import Hash from "./util/Hash" */
 
 /**
  * Defines the shared type used by this module.
@@ -144,8 +197,8 @@ const { isSourceEqual } = require("./util/source");
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
  */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import { InputFileSystem } from "./util/fs" */
 
 /**
  * Defines the callback callback.
@@ -276,7 +329,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {CodeGenerationResult} codeGenerationResult
  */
 
-/** @typedef {((id: string) => ExecuteModuleExports) & { i?: ((options: ExecuteOptions) => void)[], c?: Record<string, ExecuteModuleObject> }} WebpackRequire */
+/** @typedef {((id: string) => ExecuteModuleExports) & { i?: ((options: ExecuteOptions) => void)[], c?: Record<string, ExecuteModuleObject>, p?: string }} WebpackRequire */
 
 /**
  * Defines the execute options type used by this module.
@@ -523,20 +576,6 @@ const byNameOrHash = concatComparators(
 	compareSelect((c) => c.fullHash, compareIds)
 );
 
-const byMessage = compareSelect(
-	(err) => `${err.message}`,
-	compareStringsNumeric
-);
-
-const byModule = compareSelect(
-	(err) => (err.module && err.module.identifier()) || "",
-	compareStringsNumeric
-);
-
-const byLocation = compareSelect((err) => err.loc, compareLocations);
-
-const compareErrors = concatComparators(byModule, byLocation, byMessage);
-
 /**
  * Defines the known unsafe cache data type used by this module.
  * @typedef {object} KnownUnsafeCacheData
@@ -594,6 +633,7 @@ const reduceAffectType = (connections) => {
 
 /** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, blocks?: (ChunkId | null)[], sourceTypes?: SourceTypes }} References */
 /** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */
+/** @typedef {{ chunk: Chunk, load: () => Promise<EXPECTED_ANY>, create: (loaded: EXPECTED_ANY) => RuntimeModule, chunkGraph: ChunkGraph }} PendingRuntimeModule */
 
 class Compilation {
 	/**
@@ -884,9 +924,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtime"
 			]),
 
-			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			/**
+			 * @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>}
+			 * @since 5.32.0
+			 */
 			executeModule: new SyncHook(["options", "context"]),
-			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			/**
+			 * @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>}
+			 * @since 5.33.0
+			 */
 			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
 
 			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
@@ -1090,7 +1136,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			processAssets: processAssetsHook,
 			afterProcessAssets: afterProcessAssetsHook,
-			/** @type {AsyncSeriesHook<[CompilationAssets]>} */
+			/**
+			 * @type {AsyncSeriesHook<[CompilationAssets]>}
+			 * @since 5.8.0
+			 */
 			processAdditionalAssets: new AsyncSeriesHook(["assets"]),
 
 			/** @type {SyncBailHook<[], boolean | void>} */
@@ -1101,6 +1150,27 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncWaterfallHook<[RenderManifestEntry[], RenderManifestOptions]>} */
 			renderManifest: new SyncWaterfallHook(["result", "options"]),
 
+			/**
+			 * Called with source written in one language that a module emits inside
+			 * another — CSS or HTML reaching the bundle as a JavaScript string
+			 * literal today — before it is embedded; return the (possibly
+			 * transformed) source, e.g. a minified one. `info.type` says which
+			 * language it is, so one tap serves every pair; no asset carries this
+			 * source, so an asset-level minimizer cannot reach it.
+			 * @type {AsyncSeriesWaterfallHook<[Source, EmbeddedSourceInfo]>}
+			 * @since 5.110.0
+			 */
+			renderEmbeddedSource: new AsyncSeriesWaterfallHook(["source", "info"]),
+			/**
+			 * Called while hashing a module that embeds such a source. Module hashes
+			 * are taken before code generation, so a `renderEmbeddedSource` tap must
+			 * write whatever it varies on into the hash, or the codegen cache
+			 * replays output from before its options changed.
+			 * @type {SyncHook<[Module, Hash]>}
+			 * @since 5.110.0
+			 */
+			embeddedSourceHash: new SyncHook(["module", "hash"]),
+
 			/** @type {SyncHook<[Hash]>} */
 			fullHash: new SyncHook(["hash"]),
 			/** @type {SyncHook<[Chunk, Hash, ChunkHashContext]>} */
@@ -1231,6 +1301,27 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 		/** @type {CodeGenerationResults | undefined} */
 		this.codeGenerationResults = undefined;
+		/**
+		 * What `renderEmbeddedSource` returned, by module and by language pair and
+		 * text. Never shared between modules: a returned source may carry a map,
+		 * which names the module it came from.
+		 * @type {Map<Module, Map<string, Source>>}
+		 * @private
+		 */
+		this._embeddedSources = new Map();
+		/**
+		 * Embedded source seen this pass that the hook has not been run over yet.
+		 * @type {Map<Module, Map<string, { source: Source, info: EmbeddedSourceInfo, jobModule: Module }>>}
+		 * @private
+		 */
+		this._pendingEmbeddedSources = new Map();
+		/**
+		 * The module whose code generation is currently running — the outer one
+		 * when a generator runs nested, as `ConcatenatedModule` does.
+		 * @type {Module | undefined}
+		 * @private
+		 */
+		this._generatingModule = undefined;
 
 		/** @type {AsyncQueue<Module, Module, Module>} */
 		this.processDependenciesQueue = new AsyncQueue({
@@ -1323,6 +1414,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.errors = [];
 		/** @type {Error[]} */
 		this.warnings = [];
+		// Hints reported with `performance.hints: "stats"` — surfaced in stats
+		// only, so they neither fail the build nor count as warnings.
+		/** @type {Error[]} */
+		this.hints = [];
 		/** @type {Compilation[]} */
 		this.children = [];
 		/** @type {Map<string, LogEntry[]>} */
@@ -1387,6 +1482,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._assetsCache = this.getCache("Compilation/assets");
 		/** @type {CacheFacade} */
 		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
+		/** @type {PendingRuntimeModule[] | undefined} */
+		this._pendingRuntimeModules = undefined;
 
 		const unsafeCache = options.module.unsafeCache;
 		/** @type {boolean} */
@@ -1629,7 +1726,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		}
 
 		this._modulesCache.get(identifier, null, (err, cacheModule) => {
-			if (err) return callback(new ModuleRestoreError(module, err));
+			if (err) return callback(new (getModuleRestoreError())(module, err));
 
 			if (currentProfile !== undefined) {
 				currentProfile.markRestoringEnd();
@@ -1745,7 +1842,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 										module,
 										/** @type {WebpackError} */ (err)
 									);
-									return callback(new ModuleStoreError(module, err));
+									return callback(new (getModuleStoreError())(module, err));
 								}
 								this.hooks.succeedModule.call(module);
 								return callback();
@@ -2249,7 +2346,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					}
 				}
 				if (err) {
-					const notFoundError = new ModuleNotFoundError(
+					const notFoundError = new (getModuleNotFoundError())(
 						originModule,
 						err,
 						/** @type {DependencyLocation} */
@@ -2508,7 +2605,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					if (blockReasons !== undefined) {
 						for (const m of blockReasons) {
 							if (m === module) {
-								return callback(new BuildCycleError(module));
+								return callback(new (getBuildCycleError())(module));
 							}
 							set.add(m);
 						}
@@ -3504,6 +3601,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.addModuleQueue.clear();
 			// lazy barrel only acts during make; release its bookkeeping now
 			this._lazyBarrelController.clear();
+			// unsafe-cache restore tables are only read during make; release them
+			// so they stop pinning restored modules for the rest of the compilation
+			this._restoredUnsafeCacheModuleEntries.clear();
+			this._restoredUnsafeCacheEntries.clear();
 			return callback(err);
 		};
 
@@ -3775,100 +3876,105 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						this.logger.time("runtime requirements");
 						this.hooks.beforeRuntimeRequirements.call();
 						this.processRuntimeRequirements();
-						this.hooks.afterRuntimeRequirements.call();
-						this.logger.timeEnd("runtime requirements");
-
-						this.logger.time("hashing");
-						this.hooks.beforeHash.call();
-						const codeGenerationJobs = this.createHash();
-						this.hooks.afterHash.call();
-						this.logger.timeEnd("hashing");
-
-						this._runCodeGenerationJobs(codeGenerationJobs, (err) => {
+						this._attachPendingRuntimeModules((err) => {
 							if (err) {
 								return finalCallback(err);
 							}
+							this.hooks.afterRuntimeRequirements.call();
+							this.logger.timeEnd("runtime requirements");
 
-							if (shouldRecord) {
-								this.logger.time("record hash");
-								this.hooks.recordHash.call(
-									/** @type {Records} */
-									(this.records)
-								);
-								this.logger.timeEnd("record hash");
-							}
+							this.logger.time("hashing");
+							this.hooks.beforeHash.call();
+							const codeGenerationJobs = this.createHash();
+							this.hooks.afterHash.call();
+							this.logger.timeEnd("hashing");
 
-							this.logger.time("module assets");
-							this.clearAssets();
+							this._runCodeGenerationJobs(codeGenerationJobs, (err) => {
+								if (err) {
+									return finalCallback(err);
+								}
 
-							this.hooks.beforeModuleAssets.call();
-							this.createModuleAssets();
-							this.logger.timeEnd("module assets");
+								if (shouldRecord) {
+									this.logger.time("record hash");
+									this.hooks.recordHash.call(
+										/** @type {Records} */
+										(this.records)
+									);
+									this.logger.timeEnd("record hash");
+								}
 
-							const cont = () => {
-								this.logger.time("process assets");
-								this.hooks.processAssets.callAsync(this.assets, (err) => {
-									if (err) {
-										return finalCallback(
-											makeWebpackError(err, "Compilation.hooks.processAssets")
-										);
-									}
-									this.hooks.afterProcessAssets.call(this.assets);
-									this.logger.timeEnd("process assets");
-									this.assets =
-										/** @type {CompilationAssets} */
-										(
-											this._backCompat
-												? soonFrozenObjectDeprecation(
-														this.assets,
-														"Compilation.assets",
-														"DEP_WEBPACK_COMPILATION_ASSETS",
-														`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
-	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.logger.time("module assets");
+								this.clearAssets();
 
-									this.summarizeDependencies();
-									if (shouldRecord) {
-										this.hooks.record.call(
-											this,
-											/** @type {Records} */
-											(this.records)
-										);
-									}
+								this.hooks.beforeModuleAssets.call();
+								this.createModuleAssets();
+								this.logger.timeEnd("module assets");
 
-									if (this.hooks.needAdditionalSeal.call()) {
-										this.unseal();
-										return this.seal(callback);
-									}
-									return this.hooks.afterSeal.callAsync((err) => {
+								const cont = () => {
+									this.logger.time("process assets");
+									this.hooks.processAssets.callAsync(this.assets, (err) => {
 										if (err) {
 											return finalCallback(
-												makeWebpackError(err, "Compilation.hooks.afterSeal")
+												makeWebpackError(err, "Compilation.hooks.processAssets")
+											);
+										}
+										this.hooks.afterProcessAssets.call(this.assets);
+										this.logger.timeEnd("process assets");
+										this.assets =
+											/** @type {CompilationAssets} */
+											(
+												this._backCompat
+													? soonFrozenObjectDeprecation(
+															this.assets,
+															"Compilation.assets",
+															"DEP_WEBPACK_COMPILATION_ASSETS",
+															`BREAKING CHANGE: No more changes should happen to Compilation.assets after sealing the Compilation.
+		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();
+										if (shouldRecord) {
+											this.hooks.record.call(
+												this,
+												/** @type {Records} */
+												(this.records)
 											);
 										}
-										this.fileSystemInfo.logStatistics();
-										finalCallback();
+
+										if (this.hooks.needAdditionalSeal.call()) {
+											this.unseal();
+											return this.seal(callback);
+										}
+										return this.hooks.afterSeal.callAsync((err) => {
+											if (err) {
+												return finalCallback(
+													makeWebpackError(err, "Compilation.hooks.afterSeal")
+												);
+											}
+											this.fileSystemInfo.logStatistics();
+											finalCallback();
+										});
 									});
-								});
-							};
+								};
 
-							this.logger.time("create chunk assets");
-							if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
-								this.hooks.beforeChunkAssets.call();
-								this.createChunkAssets((err) => {
+								this.logger.time("create chunk assets");
+								if (this.hooks.shouldGenerateChunkAssets.call() !== false) {
+									this.hooks.beforeChunkAssets.call();
+									this.createChunkAssets((err) => {
+										this.logger.timeEnd("create chunk assets");
+										if (err) {
+											return finalCallback(err);
+										}
+										cont();
+									});
+								} else {
 									this.logger.timeEnd("create chunk assets");
-									if (err) {
-										return finalCallback(err);
-									}
 									cont();
-								});
-							} else {
-								this.logger.timeEnd("create chunk assets");
-								cont();
-							}
+								}
+							});
 						});
 					});
 				}
@@ -3894,7 +4000,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						// A consolidated dependency (e.g. CssIcssExportDependency) carries
 						// per-item locations on the error itself; fall back to the
 						// dependency loc for the usual one-loc-per-dependency case.
-						const warning = new ModuleDependencyWarning(
+						const warning = new (getModuleDependencyWarning())(
 							module,
 							w,
 							/** @type {EXPECTED_ANY} */ (w).loc || d.loc
@@ -3906,7 +4012,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				const errors = d.getErrors(this.moduleGraph);
 				if (errors) {
 					for (const e of errors) {
-						const error = new ModuleDependencyError(
+						const error = new (getModuleDependencyError())(
 							module,
 							e,
 							/** @type {EXPECTED_ANY} */ (e).loc || d.loc
@@ -3962,6 +4068,120 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		this._runCodeGenerationJobs(jobs, callback);
 	}
 
+	/**
+	 * Offer source one language embeds in another to `renderEmbeddedSource`. The
+	 * hook is async and generation is not, so the first pass returns the source
+	 * untouched and records it; `_resolveEmbeddedSources` awaits the hook and
+	 * generates those modules again, when the resolved source is waiting here.
+	 * @param {Source} source the embedded source
+	 * @param {EmbeddedSourceInfo} info what it is and where it is going
+	 * @returns {Source} the resolved source, or `source` until it is resolved
+	 */
+	_resolveEmbeddedSource(source, info) {
+		// Untapped, nothing can change: skip reading the text and the second pass.
+		if (this.hooks.renderEmbeddedSource.taps.length === 0) return source;
+		const text = /** @type {string} */ (source.source());
+		// Everything the hook is handed is in the key: a tap answers per language
+		// pair, so identical text offered as two of them is two questions.
+		const key = `${info.type}${info.hostType}${text}`;
+		const resolved = this._embeddedSources.get(info.module);
+		if (resolved !== undefined) {
+			const hit = resolved.get(key);
+			if (hit !== undefined) return hit;
+		}
+		getOrInsert(this._pendingEmbeddedSources, info.module, () => new Map()).set(
+			key,
+			{ source, info, jobModule: this._generatingModule || info.module }
+		);
+		return source;
+	}
+
+	/**
+	 * Run `renderEmbeddedSource` over everything the last pass recorded, then
+	 * generate those modules again so the resolved source is the one embedded.
+	 * @private
+	 * @param {CodeGenerationJobs} jobs the jobs the last pass ran
+	 * @param {Callback} callback callback
+	 * @returns {void}
+	 */
+	_resolveEmbeddedSources(jobs, callback) {
+		if (this._pendingEmbeddedSources.size === 0) return callback();
+		/** @type {{ key: string, source: Source, info: EmbeddedSourceInfo, jobModule: Module }[]} */
+		const pending = [];
+		for (const byKey of this._pendingEmbeddedSources.values()) {
+			for (const [key, entry] of byKey) {
+				pending.push({ key, ...entry });
+			}
+		}
+		this._pendingEmbeddedSources.clear();
+		asyncLib.each(
+			pending,
+			({ key, source, info }, cb) => {
+				this.hooks.renderEmbeddedSource.callAsync(
+					source,
+					info,
+					/**
+					 * @param {(Error | null)=} err error
+					 * @param {Source=} result the resolved source
+					 * @returns {void}
+					 */
+					(err, result) => {
+						if (err) return cb(err);
+						getOrInsert(
+							this._embeddedSources,
+							info.module,
+							() => new Map()
+						).set(key, result || source);
+						cb();
+					}
+				);
+			},
+			(err) => {
+				if (err) return callback(/** @type {WebpackError} */ (err));
+				const affected = new Set(pending.map(({ jobModule }) => jobModule));
+				const redo = jobs.filter(({ module }) => affected.has(module));
+				// Generated directly rather than through the codegen cache: the module
+				// hash is unchanged, so the cache would hand back the first pass again.
+				const results =
+					/** @type {CodeGenerationResults} */
+					(this.codeGenerationResults);
+				for (const { module, runtime, runtimes } of redo) {
+					/** @type {CodeGenerationResult} */
+					let result;
+					try {
+						this._generatingModule = module;
+						result = module.codeGeneration({
+							chunkGraph: this.chunkGraph,
+							moduleGraph: this.moduleGraph,
+							dependencyTemplates: this.dependencyTemplates,
+							runtimeTemplate: this.runtimeTemplate,
+							runtime,
+							runtimes,
+							codeGenerationResults: results,
+							compilation: this
+						});
+					} catch (err) {
+						// Reported and carried on with, as the first pass does: a throw
+						// here would leave the build with no error to show for it.
+						this.errors.push(
+							new (getCodeGenerationError())(module, /** @type {Error} */ (err))
+						);
+						result = {
+							sources: new Map(),
+							runtimeRequirements: null,
+							data: undefined
+						};
+					} finally {
+						this._generatingModule = undefined;
+					}
+					for (const r of runtimes) results.add(module, r, result);
+				}
+				// A tap that changed the source again is resolved on the next round.
+				this._resolveEmbeddedSources(redo, callback);
+			}
+		);
+	}
+
 	/**
 	 * Run code generation jobs.
 	 * @private
@@ -3973,6 +4193,10 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		if (jobs.length === 0) {
 			return callback();
 		}
+		// `jobs` is reassigned per iteration; embedded source is resolved over all.
+		// Untapped nothing is recorded, so the array is not held past its iteration.
+		const allJobs =
+			this.hooks.renderEmbeddedSource.taps.length === 0 ? undefined : jobs;
 		let statModulesFromCache = 0;
 		let statModulesGenerated = 0;
 		const { chunkGraph, moduleGraph, dependencyTemplates, runtimeTemplate } =
@@ -4065,7 +4289,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 								(statModulesGenerated + statModulesFromCache)
 						)}% code generated (${statModulesGenerated} generated, ${statModulesFromCache} from cache)`
 					);
-					callback();
+					this._resolveEmbeddedSources(allJobs || jobs, (err) => {
+						this._embeddedSources.clear();
+						this._pendingEmbeddedSources.clear();
+						callback(err);
+					});
 				}
 			);
 		};
@@ -4109,6 +4337,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			try {
 				codeGenerated = true;
 				this.codeGeneratedModules.add(module);
+				this._generatingModule = module;
 				result = module.codeGeneration({
 					chunkGraph,
 					moduleGraph,
@@ -4121,13 +4350,15 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				});
 			} catch (err) {
 				errors.push(
-					new CodeGenerationError(module, /** @type {Error} */ (err))
+					new (getCodeGenerationError())(module, /** @type {Error} */ (err))
 				);
 				result = {
 					sources: new Map(),
 					runtimeRequirements: null,
 					data: undefined
 				};
+			} finally {
+				this._generatingModule = undefined;
 			}
 			for (const runtime of runtimes) {
 				results.add(module, runtime, result);
@@ -4150,6 +4381,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				try {
 					codeGenerated = true;
 					this.codeGeneratedModules.add(module);
+					this._generatingModule = module;
 					result = module.codeGeneration({
 						chunkGraph,
 						moduleGraph,
@@ -4162,13 +4394,15 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					});
 				} catch (err) {
 					errors.push(
-						new CodeGenerationError(module, /** @type {Error} */ (err))
+						new (getCodeGenerationError())(module, /** @type {Error} */ (err))
 					);
 					result = cachedResult = {
 						sources: new Map(),
 						runtimeRequirements: null,
 						data: undefined
 					};
+				} finally {
+					this._generatingModule = undefined;
 				}
 			} else {
 				result = cachedResult;
@@ -4343,6 +4577,46 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		this.logger.timeEnd("runtime requirements.entries");
 	}
 
+	/**
+	 * Queues a runtime module whose implementation is loaded on demand, for
+	 * `_attachPendingRuntimeModules` to await and build once the requirement pass
+	 * is over. `runtimeRequirementInTree` is a sync hook, so a tap cannot await
+	 * the load itself; anything the tap reads off the requirement set must be
+	 * captured before queueing, since `create` runs later.
+	 * @param {Chunk} chunk target chunk
+	 * @param {() => Promise<EXPECTED_ANY>} load resolves the runtime module implementation
+	 * @param {(loaded: EXPECTED_ANY) => RuntimeModule} create builds the runtime module from it
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	addLazyRuntimeModule(chunk, load, create, chunkGraph = this.chunkGraph) {
+		if (this._pendingRuntimeModules === undefined) {
+			this._pendingRuntimeModules = [];
+		}
+		this._pendingRuntimeModules.push({ chunk, load, create, chunkGraph });
+	}
+
+	/**
+	 * Awaits and attaches everything `addLazyRuntimeModule` queued. The only
+	 * place a deferred runtime module implementation is loaded.
+	 * @param {Callback} callback signals when the call finishes
+	 * @returns {void}
+	 */
+	_attachPendingRuntimeModules(callback) {
+		const pending = this._pendingRuntimeModules;
+		if (pending === undefined) return callback(null);
+		this._pendingRuntimeModules = undefined;
+		Promise.all(pending.map(({ load }) => load()))
+			.then((loaded) => {
+				for (let i = 0; i < pending.length; i++) {
+					const { chunk, create, chunkGraph } = pending[i];
+					this.addRuntimeModule(chunk, create(loaded[i]), chunkGraph);
+				}
+			})
+			// a `runtimeModule` tap may have queued more
+			.then(() => this._attachPendingRuntimeModules(callback), callback);
+	}
+
 	// TODO webpack 6 make chunkGraph argument non-optional
 	/**
 	 * Adds runtime module.
@@ -4723,6 +4997,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 		this.errors.sort(compareErrors);
 		this.warnings.sort(compareErrors);
+		// `hints` is sorted where stats read it — producers tap `afterSeal` and
+		// `afterEmit`, so they append after this point.
 		this.children.sort(byNameOrHash);
 	}
 
@@ -4754,10 +5030,13 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		for (const module of this.modules) {
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+				const cacheKey = memCache
+					? `moduleHash-${getRuntimeKey(runtime)}`
+					: undefined;
 				if (memCache) {
 					const digest =
 						/** @type {string} */
-						(memCache.get(`moduleHash-${getRuntimeKey(runtime)}`));
+						(memCache.get(/** @type {string} */ (cacheKey)));
 					if (digest !== undefined) {
 						chunkGraph.setModuleHashes(
 							module,
@@ -4781,7 +5060,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					errors
 				);
 				if (memCache) {
-					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
+					memCache.set(/** @type {string} */ (cacheKey), digest);
 				}
 			}
 		}
@@ -4836,7 +5115,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			});
 			moduleHashDigest = moduleHash.digest(hashDigest);
 		} catch (err) {
-			errors.push(new ModuleHashingError(module, /** @type {Error} */ (err)));
+			errors.push(
+				new (getModuleHashingError())(module, /** @type {Error} */ (err))
+			);
 			moduleHashDigest = "XXXXXX";
 		}
 		chunkGraph.setModuleHashes(
@@ -5087,7 +5368,7 @@ This prevents using hashes of each other and should be avoided.`);
 				}
 			} catch (err) {
 				this.errors.push(
-					new ChunkRenderError(chunk, "", /** @type {Error} */ (err))
+					new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
 				);
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
@@ -5603,7 +5884,7 @@ This prevents using hashes of each other and should be avoided.`);
 					});
 				} catch (err) {
 					this.errors.push(
-						new ChunkRenderError(chunk, "", /** @type {Error} */ (err))
+						new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
 					);
 					return callback();
 				}
@@ -5641,7 +5922,9 @@ This prevents using hashes of each other and should be avoided.`);
 											? filenameTemplate
 											: "");
 
-								this.errors.push(new ChunkRenderError(chunk, filename, err));
+								this.errors.push(
+									new (getChunkRenderError())(chunk, filename, err)
+								);
 								inTry = false;
 								return callback();
 							};
@@ -5867,6 +6150,7 @@ This prevents using hashes of each other and should be avoided.`);
 					this.moduleGraph,
 					this.outputOptions.hashFunction
 				);
+				chunkGraph.buildTimeExecution = true;
 				const runtime = "build time";
 				const { hashFunction, hashDigest, hashDigestLength } =
 					this.outputOptions;
@@ -5976,265 +6260,276 @@ This prevents using hashes of each other and should be avoided.`);
 							codeGenerationResults,
 							chunkGraphEntries: chunks
 						});
+						// restored before the deferred attach so no concurrent `make`
+						// task observes the build-time graph
 						this.chunkGraph = old;
+						this._attachPendingRuntimeModules((err) => {
+							if (err) return callback(err);
 
-						const runtimeModules =
-							chunkGraph.getChunkRuntimeModulesIterable(chunk);
+							const runtimeModules =
+								chunkGraph.getChunkRuntimeModulesIterable(chunk);
 
-						// Hash runtime modules
-						for (const module of runtimeModules) {
-							modules.add(module);
-							this._createModuleHash(
-								module,
-								chunkGraph,
-								runtime,
-								hashFunction,
-								runtimeTemplate,
-								hashDigest,
-								hashDigestLength,
-								errors
-							);
-						}
-
-						// Generate code for all runtime modules
-						asyncLib.eachLimit(
-							/** @type {import("neo-async").IterableCollection<RuntimeModule>} */ (
-								runtimeModules
-							),
-							10,
-							codeGen,
-							(err) => {
-								if (err) return callback(err);
-								reportErrors();
-
-								/** @type {Map<Module, ExecuteModuleArgument>} */
-								const moduleArgumentsMap = new Map();
-								/** @type {Map<string, ExecuteModuleArgument>} */
-								const moduleArgumentsById = new Map();
-
-								/** @type {ExecuteModuleResult["fileDependencies"]} */
-								const fileDependencies = new LazySet();
-								/** @type {ExecuteModuleResult["contextDependencies"]} */
-								const contextDependencies = new LazySet();
-								/** @type {ExecuteModuleResult["missingDependencies"]} */
-								const missingDependencies = new LazySet();
-								/** @type {ExecuteModuleResult["buildDependencies"]} */
-								const buildDependencies = new LazySet();
-
-								/** @type {ExecuteModuleResult["assets"]} */
-								const assets = new Map();
-
-								let cacheable = true;
-								/** @type {ExecuteModuleResult["notCacheableReasons"]} */
-								const notCacheableReasons = [];
-
-								/** @type {ExecuteModuleContext} */
-								const context = {
-									assets,
-									__webpack_require__: undefined,
-									chunk,
-									chunkGraph
-								};
+							// Hash runtime modules
+							for (const module of runtimeModules) {
+								modules.add(module);
+								this._createModuleHash(
+									module,
+									chunkGraph,
+									runtime,
+									hashFunction,
+									runtimeTemplate,
+									hashDigest,
+									hashDigestLength,
+									errors
+								);
+							}
 
-								// Prepare execution
-								asyncLib.eachLimit(
-									modules,
-									10,
-									(module, callback) => {
-										const codeGenerationResult = codeGenerationResults.get(
-											module,
-											runtime
-										);
-										/** @type {ExecuteModuleArgument} */
-										const moduleArgument = {
-											module,
-											codeGenerationResult,
-											moduleObject: undefined
-										};
-										moduleArgumentsMap.set(module, moduleArgument);
-										moduleArgumentsById.set(
-											module.identifier(),
-											moduleArgument
-										);
-										module.addCacheDependencies(
-											fileDependencies,
-											contextDependencies,
-											missingDependencies,
-											buildDependencies
-										);
-										const buildInfo = /** @type {BuildInfo} */ (
-											module.buildInfo
-										);
-										if (buildInfo.cacheable === false) {
-											cacheable = false;
-											if (buildInfo.notCacheableReasons) {
-												for (const reason of buildInfo.notCacheableReasons) {
-													if (!notCacheableReasons.includes(reason)) {
-														notCacheableReasons.push(reason);
+							// Generate code for all runtime modules
+							asyncLib.eachLimit(
+								/** @type {import("neo-async").IterableCollection<RuntimeModule>} */ (
+									runtimeModules
+								),
+								10,
+								codeGen,
+								(err) => {
+									if (err) return callback(err);
+									reportErrors();
+
+									/** @type {Map<Module, ExecuteModuleArgument>} */
+									const moduleArgumentsMap = new Map();
+									/** @type {Map<string, ExecuteModuleArgument>} */
+									const moduleArgumentsById = new Map();
+
+									/** @type {ExecuteModuleResult["fileDependencies"]} */
+									const fileDependencies = new LazySet();
+									/** @type {ExecuteModuleResult["contextDependencies"]} */
+									const contextDependencies = new LazySet();
+									/** @type {ExecuteModuleResult["missingDependencies"]} */
+									const missingDependencies = new LazySet();
+									/** @type {ExecuteModuleResult["buildDependencies"]} */
+									const buildDependencies = new LazySet();
+
+									/** @type {ExecuteModuleResult["assets"]} */
+									const assets = new Map();
+
+									let cacheable = true;
+									/** @type {ExecuteModuleResult["notCacheableReasons"]} */
+									const notCacheableReasons = [];
+
+									/** @type {ExecuteModuleContext} */
+									const context = {
+										assets,
+										__webpack_require__: undefined,
+										chunk,
+										chunkGraph
+									};
+
+									// Prepare execution
+									asyncLib.eachLimit(
+										modules,
+										10,
+										(module, callback) => {
+											const codeGenerationResult = codeGenerationResults.get(
+												module,
+												runtime
+											);
+											/** @type {ExecuteModuleArgument} */
+											const moduleArgument = {
+												module,
+												codeGenerationResult,
+												moduleObject: undefined
+											};
+											moduleArgumentsMap.set(module, moduleArgument);
+											moduleArgumentsById.set(
+												module.identifier(),
+												moduleArgument
+											);
+											module.addCacheDependencies(
+												fileDependencies,
+												contextDependencies,
+												missingDependencies,
+												buildDependencies
+											);
+											const buildInfo = /** @type {BuildInfo} */ (
+												module.buildInfo
+											);
+											if (buildInfo.cacheable === false) {
+												cacheable = false;
+												if (buildInfo.notCacheableReasons) {
+													for (const reason of buildInfo.notCacheableReasons) {
+														if (!notCacheableReasons.includes(reason)) {
+															notCacheableReasons.push(reason);
+														}
 													}
 												}
 											}
-										}
-										if (module.buildInfo && module.buildInfo.assets) {
-											const { assets: moduleAssets, assetsInfo } =
-												module.buildInfo;
-											for (const assetName of Object.keys(moduleAssets)) {
-												assets.set(assetName, {
-													source: moduleAssets[assetName],
-													info: assetsInfo
-														? assetsInfo.get(assetName)
-														: undefined
-												});
-											}
-										}
-										this.hooks.prepareModuleExecution.callAsync(
-											moduleArgument,
-											context,
-											callback
-										);
-									},
-									(err) => {
-										if (err) return callback(/** @type {WebpackError} */ (err));
-
-										/** @type {ExecuteModuleExports | undefined} */
-										let exports;
-										try {
-											const {
-												strictModuleErrorHandling,
-												strictModuleExceptionHandling
-											} = this.outputOptions;
-
-											/** @type {WebpackRequire} */
-											const __webpack_require__ = (id) => {
-												const cached = moduleCache[id];
-												if (cached !== undefined) {
-													if (cached.error) throw cached.error;
-													return cached.exports;
+											if (module.buildInfo && module.buildInfo.assets) {
+												const { assets: moduleAssets, assetsInfo } =
+													module.buildInfo;
+												for (const assetName of Object.keys(moduleAssets)) {
+													assets.set(assetName, {
+														source: moduleAssets[assetName],
+														info: assetsInfo
+															? assetsInfo.get(assetName)
+															: undefined
+													});
 												}
-												const moduleArgument = moduleArgumentsById.get(id);
-												return __webpack_require_module__(
-													/** @type {ExecuteModuleArgument} */
-													(moduleArgument),
-													id
-												);
-											};
-											const interceptModuleExecution = (__webpack_require__[
-												/** @type {"i"} */
-												(
-													RuntimeGlobals.interceptModuleExecution.replace(
-														`${RuntimeGlobals.require}.`,
-														""
+											}
+											this.hooks.prepareModuleExecution.callAsync(
+												moduleArgument,
+												context,
+												callback
+											);
+										},
+										(err) => {
+											if (err) {
+												return callback(/** @type {WebpackError} */ (err));
+											}
+
+											/** @type {ExecuteModuleExports | undefined} */
+											let exports;
+											try {
+												const {
+													strictModuleErrorHandling,
+													strictModuleExceptionHandling
+												} = this.outputOptions;
+
+												/** @type {WebpackRequire} */
+												const __webpack_require__ = (id) => {
+													const cached = moduleCache[id];
+													if (cached !== undefined) {
+														if (cached.error) throw cached.error;
+														return cached.exports;
+													}
+													const moduleArgument = moduleArgumentsById.get(id);
+													return __webpack_require_module__(
+														/** @type {ExecuteModuleArgument} */
+														(moduleArgument),
+														id
+													);
+												};
+												const interceptModuleExecution = (__webpack_require__[
+													/** @type {"i"} */
+													(
+														RuntimeGlobals.interceptModuleExecution.replace(
+															`${RuntimeGlobals.require}.`,
+															""
+														)
 													)
-												)
-											] = /** @type {NonNullable<WebpackRequire["i"]>} */ ([]));
-											const moduleCache = (__webpack_require__[
-												/** @type {"c"} */ (
-													RuntimeGlobals.moduleCache.replace(
-														`${RuntimeGlobals.require}.`,
-														""
+												] =
+													/** @type {NonNullable<WebpackRequire["i"]>} */ ([]));
+												const moduleCache = (__webpack_require__[
+													/** @type {"c"} */ (
+														RuntimeGlobals.moduleCache.replace(
+															`${RuntimeGlobals.require}.`,
+															""
+														)
 													)
-												)
-											] = /** @type {NonNullable<WebpackRequire["c"]>} */ ({}));
-
-											context.__webpack_require__ = __webpack_require__;
-
-											/**
-											 * Webpack require module.
-											 * @param {ExecuteModuleArgument} moduleArgument the module argument
-											 * @param {string=} id id
-											 * @returns {ExecuteModuleExports} exports
-											 */
-											const __webpack_require_module__ = (
-												moduleArgument,
-												id
-											) => {
-												/** @type {ExecuteOptions} */
-												const execOptions = {
-													id,
-													module: {
+												] =
+													/** @type {NonNullable<WebpackRequire["c"]>} */ ({}));
+
+												context.__webpack_require__ = __webpack_require__;
+
+												/**
+												 * Webpack require module.
+												 * @param {ExecuteModuleArgument} moduleArgument the module argument
+												 * @param {string=} id id
+												 * @returns {ExecuteModuleExports} exports
+												 */
+												const __webpack_require_module__ = (
+													moduleArgument,
+													id
+												) => {
+													/** @type {ExecuteOptions} */
+													const execOptions = {
 														id,
-														exports: {},
-														loaded: false,
-														error: undefined
-													},
-													require: __webpack_require__
-												};
-												for (const handler of interceptModuleExecution) {
-													handler(execOptions);
-												}
-												const module = moduleArgument.module;
-												this.buildTimeExecutedModules.add(module);
-												const moduleObject = execOptions.module;
-												moduleArgument.moduleObject = moduleObject;
-												try {
-													if (id) moduleCache[id] = moduleObject;
-
-													tryRunOrWebpackError(
-														() =>
-															this.hooks.executeModule.call(
-																moduleArgument,
-																context
-															),
-														"Compilation.hooks.executeModule"
-													);
-													moduleObject.loaded = true;
-													return moduleObject.exports;
-												} catch (execErr) {
-													if (strictModuleExceptionHandling) {
-														if (id) delete moduleCache[id];
-													} else if (strictModuleErrorHandling) {
-														moduleObject.error =
-															/** @type {WebpackError} */
-															(execErr);
+														module: {
+															id,
+															exports: {},
+															loaded: false,
+															error: undefined
+														},
+														require: __webpack_require__
+													};
+													for (const handler of interceptModuleExecution) {
+														handler(execOptions);
 													}
-													if (!(/** @type {WebpackError} */ (execErr).module)) {
-														/** @type {WebpackError} */
-														(execErr).module = module;
+													const module = moduleArgument.module;
+													this.buildTimeExecutedModules.add(module);
+													const moduleObject = execOptions.module;
+													moduleArgument.moduleObject = moduleObject;
+													try {
+														if (id) moduleCache[id] = moduleObject;
+
+														tryRunOrWebpackError(
+															() =>
+																this.hooks.executeModule.call(
+																	moduleArgument,
+																	context
+																),
+															"Compilation.hooks.executeModule"
+														);
+														moduleObject.loaded = true;
+														return moduleObject.exports;
+													} catch (execErr) {
+														if (strictModuleExceptionHandling) {
+															if (id) delete moduleCache[id];
+														} else if (strictModuleErrorHandling) {
+															moduleObject.error =
+																/** @type {WebpackError} */
+																(execErr);
+														}
+														if (
+															!(/** @type {WebpackError} */ (execErr).module)
+														) {
+															/** @type {WebpackError} */
+															(execErr).module = module;
+														}
+														throw execErr;
 													}
-													throw execErr;
+												};
+
+												for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
+													chunk
+												)) {
+													__webpack_require_module__(
+														/** @type {ExecuteModuleArgument} */
+														(moduleArgumentsMap.get(runtimeModule))
+													);
 												}
-											};
 
-											for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
-												chunk
-											)) {
-												__webpack_require_module__(
-													/** @type {ExecuteModuleArgument} */
-													(moduleArgumentsMap.get(runtimeModule))
+												exports = __webpack_require__(module.identifier());
+											} catch (execErr) {
+												const { message, stack, module } =
+													/** @type {WebpackError} */
+													(execErr);
+												const err = new WebpackError(
+													`Execution of module code from module graph (${
+														/** @type {Module} */
+														(module).readableIdentifier(this.requestShortener)
+													}) failed: ${message}`,
+													{ cause: execErr }
 												);
+												err.stack = stack;
+												err.module = module;
+												return callback(err);
 											}
 
-											exports = __webpack_require__(module.identifier());
-										} catch (execErr) {
-											const { message, stack, module } =
-												/** @type {WebpackError} */
-												(execErr);
-											const err = new WebpackError(
-												`Execution of module code from module graph (${
-													/** @type {Module} */
-													(module).readableIdentifier(this.requestShortener)
-												}) failed: ${message}`,
-												{ cause: execErr }
-											);
-											err.stack = stack;
-											err.module = module;
-											return callback(err);
+											callback(null, {
+												exports,
+												assets,
+												cacheable,
+												notCacheableReasons,
+												fileDependencies,
+												contextDependencies,
+												missingDependencies,
+												buildDependencies
+											});
 										}
-
-										callback(null, {
-											exports,
-											assets,
-											cacheable,
-											notCacheableReasons,
-											fileDependencies,
-											contextDependencies,
-											missingDependencies,
-											buildDependencies
-										});
-									}
-								);
-							}
-						);
+									);
+								}
+							);
+						});
 					}
 				);
 			}