@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/Compilation.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const util = require("util");
-const asyncLib = require("neo-async");
 const {
 	AsyncParallelHook,
 	AsyncSeriesBailHook,
@@ -28,6 +27,9 @@ const Dependency = require("./Dependency");
 const DependencyTemplates = require("./DependencyTemplates");
 const Entrypoint = require("./Entrypoint");
 const ErrorHelpers = require("./ErrorHelpers");
+
+const { toError } = ErrorHelpers;
+
 const FileSystemInfo = require("./FileSystemInfo");
 const LazyBarrelController = require("./LazyBarrel");
 const MainTemplate = require("./MainTemplate");
@@ -53,6 +55,8 @@ const AsyncQueue = require("./util/AsyncQueue");
 const LazySet = require("./util/LazySet");
 const { getOrInsert } = require("./util/MapHelpers");
 const WeakTupleMap = require("./util/WeakTupleMap");
+const asyncLib = require("./util/async");
+const { replayOptimizationBailouts } = require("./util/buildDiagnostics");
 const { cachedCleverMerge } = require("./util/cleverMerge");
 const {
 	compareErrors,
@@ -367,6 +371,20 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * @property {string[]=} trace
  */
 
+/**
+ * Where an asset which is a symbolic link points, as the link itself spells it.
+ * @typedef {object} AssetSymlink
+ * @property {string} target what the link points at, left as it is written
+ * @property {boolean} isDirectory whether it points at a directory, which is what Windows needs in order to create one
+ */
+
+/**
+ * Access and modification times an asset carries onto the file it is written to.
+ * @typedef {object} AssetTimestamps
+ * @property {number} atime last access time, in milliseconds
+ * @property {number} mtime last modification time, in milliseconds
+ */
+
 /**
  * Defines the known asset info type used by this module.
  * @typedef {object} KnownAssetInfo
@@ -378,6 +396,10 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
  * @property {Record<string, string>=} contenthashDigest maps a `[contenthash:<digest>]` value to its digest, so `RealContentHashPlugin` re-encodes the recomputed hash in it
  * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
+ * @property {boolean=} copied true, when the asset was copied from a file by `output.copy`
+ * @property {AssetSymlink=} symlink when set, the asset is emitted as a symbolic link rather than as its content
+ * @property {number=} mode when set, the file the asset is written to is given these permissions
+ * @property {AssetTimestamps=} timestamps when set, the file the asset is written to is stamped with these times
  * @property {number=} size size in bytes, only set after asset has been emitted
  * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
  * @property {boolean=} hotModuleReplacement true, when asset ships data for updating an existing application (HMR)
@@ -1458,6 +1480,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.missingDependencies = new LazySet();
 		/** @type {FileSystemDependencies} */
 		this.buildDependencies = new LazySet();
+		/** @type {FileSystemDependencies} */
+		this.optionalBuildDependencies = new LazySet();
 		// TODO webpack 6 remove
 		/**
 		 * @deprecated
@@ -1806,6 +1830,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					if (currentProfile !== undefined) {
 						currentProfile.markBuildingEnd();
 					}
+					replayOptimizationBailouts(this.moduleGraph, module);
 					this.hooks.stillValidModule.call(module);
 					return callback();
 				}
@@ -1826,6 +1851,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 							this.hooks.failedModule.call(module, err);
 							return callback(err);
 						}
+						replayOptimizationBailouts(this.moduleGraph, module);
 						if (currentProfile !== undefined) {
 							currentProfile.markStoringStart();
 						}
@@ -2348,7 +2374,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (err) {
 					const notFoundError = new (getModuleNotFoundError())(
 						originModule,
-						err,
+						toError(err),
 						/** @type {DependencyLocation} */
 						(dependencies.map((d) => d.loc).find(Boolean))
 					);
@@ -2633,12 +2659,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				return;
 			}
 
-			// lazy barrel:
-			// 1. first call: barrel module is not classified yet, so this records the requested
-			//    ids and returns undefined; the targets get built below when
-			//    `processModuleDependencies` runs `_lazyBarrelController.classify` and replays them.
-			// 2. later call: barrel module is already built, so `processModuleDependencies` won't
-			//    re-walk it; the newly requested targets must be built here.
+			// lazy barrel: on the first call the module is unclassified, so this only
+			// records the ids and `processModuleDependencies` replays them. Later the
+			// module is built and never re-walked, so the targets are built here.
 			const unlazyItems = this._lazyBarrelController.request(
 				module,
 				dependencies
@@ -4164,7 +4187,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						// 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))
+							new (getCodeGenerationError())(module, toError(err))
 						);
 						result = {
 							sources: new Map(),
@@ -4221,15 +4244,17 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					const { codeGenerationDependencies } = module;
 					if (
 						codeGenerationDependencies !== undefined &&
-						(notCodeGeneratedModules === undefined ||
-							codeGenerationDependencies.some((dep) => {
-								const referencedModule = /** @type {Module} */ (
-									moduleGraph.getModule(dep)
-								);
-								return /** @type {NotCodeGeneratedModules} */ (
-									notCodeGeneratedModules
-								).has(referencedModule);
-							}))
+						codeGenerationDependencies.some((dep) => {
+							const referencedModule = moduleGraph.getModule(dep);
+							// Nothing resolved it, so it is never code-generated and
+							// waiting on it would stall instead of ordering anything.
+							if (!referencedModule) return false;
+							return (
+								notCodeGeneratedModules === undefined ||
+								/** @type {NotCodeGeneratedModules} */
+								(notCodeGeneratedModules).has(referencedModule)
+							);
+						})
 					) {
 						delayedJobs.push(job);
 						delayedModules.add(module);
@@ -4338,6 +4363,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				codeGenerated = true;
 				this.codeGeneratedModules.add(module);
 				this._generatingModule = module;
+				// Not stored, since nothing is restored here: named so a reason lands on
+				// the same module as it does in a cached build.
+				runtimeTemplate.beginAnalyzableBailouts(module);
 				result = module.codeGeneration({
 					chunkGraph,
 					moduleGraph,
@@ -4349,9 +4377,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					compilation: this
 				});
 			} catch (err) {
-				errors.push(
-					new (getCodeGenerationError())(module, /** @type {Error} */ (err))
-				);
+				errors.push(new (getCodeGenerationError())(module, toError(err)));
 				result = {
 					sources: new Map(),
 					runtimeRequirements: null,
@@ -4359,6 +4385,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				};
 			} finally {
 				this._generatingModule = undefined;
+				runtimeTemplate.finishAnalyzableBailouts();
 			}
 			for (const runtime of runtimes) {
 				results.add(module, runtime, result);
@@ -4382,6 +4409,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					codeGenerated = true;
 					this.codeGeneratedModules.add(module);
 					this._generatingModule = module;
+					runtimeTemplate.beginAnalyzableBailouts(module);
 					result = module.codeGeneration({
 						chunkGraph,
 						moduleGraph,
@@ -4392,10 +4420,15 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						codeGenerationResults: results,
 						compilation: this
 					});
+					// The bailouts travel with the result: a restored module never runs
+					// the code generation that would record them again.
+					const bailouts = runtimeTemplate.finishAnalyzableBailouts();
+					if (bailouts !== undefined) {
+						if (result.data === undefined) result.data = new Map();
+						result.data.set("analyzableBailouts", bailouts);
+					}
 				} catch (err) {
-					errors.push(
-						new (getCodeGenerationError())(module, /** @type {Error} */ (err))
-					);
+					errors.push(new (getCodeGenerationError())(module, toError(err)));
 					result = cachedResult = {
 						sources: new Map(),
 						runtimeRequirements: null,
@@ -4403,9 +4436,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					};
 				} finally {
 					this._generatingModule = undefined;
+					runtimeTemplate.finishAnalyzableBailouts();
 				}
 			} else {
 				result = cachedResult;
+				const bailouts = result.data && result.data.get("analyzableBailouts");
+				if (bailouts) {
+					runtimeTemplate.restoreAnalyzableBailouts(module, bailouts);
+				}
 			}
 			for (const runtime of runtimes) {
 				results.add(module, runtime, result);
@@ -5008,6 +5046,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			this.contextDependencies.addAll(child.contextDependencies);
 			this.missingDependencies.addAll(child.missingDependencies);
 			this.buildDependencies.addAll(child.buildDependencies);
+			this.optionalBuildDependencies.addAll(child.optionalBuildDependencies);
 		}
 
 		for (const module of this.modules) {
@@ -5165,22 +5204,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 
 		this.logger.time("hashing: sort chunks");
-		/*
-		 * Chunks are hashed in 4 categories, in this order:
-		 * 1. Async chunks - no hash dependencies on other chunks
-		 * 2. Non-entry initial chunks (e.g. shared split chunks) - no hash
-		 *    dependencies on other chunks, but runtime chunks may read their
-		 *    hashes via GetChunkFilenameRuntimeModule (dependentHash)
-		 * 3. Runtime chunks - may use hashes of async and non-entry initial
-		 *    chunks (via GetChunkFilenameRuntimeModule). Ordered by references
-		 *    between each other (for async entrypoints)
-		 * 4. Entry chunks - may depend on runtimeChunk.hash (via
-		 *    createChunkHashHandler for ESM/CJS entry importing runtime)
-		 *
-		 * This ordering ensures all hash dependencies flow in one direction:
-		 * async/initial → runtime → entry, with no circular dependencies.
-		 * Chunks within each category are sorted by id for determinism.
-		 */
+		// Hashed as async, then non-entry initial, then runtime, then entry chunks,
+		// so hash dependencies flow one way between those groups. A cycle among the
+		// runtime chunks is still possible, and is warned about below.
 		/** @type {Chunk[]} */
 		const unorderedRuntimeChunks = [];
 		/** @type {Chunk[]} */
@@ -5367,9 +5393,7 @@ This prevents using hashes of each other and should be avoided.`);
 					this.hooks.contentHash.call(chunk);
 				}
 			} catch (err) {
-				this.errors.push(
-					new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
-				);
+				this.errors.push(new (getChunkRenderError())(chunk, "", toError(err)));
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
 		};
@@ -5377,14 +5401,6 @@ This prevents using hashes of each other and should be avoided.`);
 		for (const chunk of initialChunks) processChunk(chunk);
 		for (const chunk of runtimeChunks) processChunk(chunk);
 		for (const chunk of entryChunks) 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");
@@ -5399,19 +5415,16 @@ This prevents using hashes of each other and should be avoided.`);
 			for (const module of /** @type {Iterable<RuntimeModule>} */ (
 				chunkGraph.getChunkFullHashModulesIterable(chunk)
 			)) {
-				const moduleHash = createHash(hashFunction);
-				module.updateHash(moduleHash, {
-					chunkGraph,
-					runtime: chunk.runtime,
-					runtimeTemplate
-				});
-				const moduleHashDigest = moduleHash.digest(hashDigest);
 				const oldHash = chunkGraph.getModuleHash(module, chunk.runtime);
-				chunkGraph.setModuleHashes(
+				const moduleHashDigest = this._createModuleHash(
 					module,
+					chunkGraph,
 					chunk.runtime,
-					moduleHashDigest,
-					moduleHashDigest.slice(0, hashDigestLength)
+					hashFunction,
+					runtimeTemplate,
+					hashDigest,
+					hashDigestLength,
+					errors
 				);
 				/** @type {CodeGenerationJob} */
 				(
@@ -5428,6 +5441,16 @@ This prevents using hashes of each other and should be avoided.`);
 			this.hooks.contentHash.call(chunk);
 		}
 		this.logger.timeEnd("hashing: process full hash modules");
+
+		if (errors.length > 0) {
+			errors.sort(
+				compareSelect((err) => err.module, compareModulesByIdentifier)
+			);
+			for (const error of errors) {
+				this.errors.push(error);
+			}
+		}
+
 		return codeGenerationJobs;
 	}
 
@@ -5861,7 +5884,7 @@ This prevents using hashes of each other and should be avoided.`);
 		/** @type {Map<string, { hash: string, source: Source, chunk: Chunk }>} */
 		const alreadyWrittenFiles = new Map();
 
-		asyncLib.forEachLimit(
+		asyncLib.eachLimit(
 			this.chunks,
 			15,
 			(chunk, callback) => {
@@ -5884,7 +5907,7 @@ This prevents using hashes of each other and should be avoided.`);
 					});
 				} catch (err) {
 					this.errors.push(
-						new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
+						new (getChunkRenderError())(chunk, "", toError(err))
 					);
 					return callback();
 				}
@@ -5923,7 +5946,7 @@ This prevents using hashes of each other and should be avoided.`);
 											: "");
 
 								this.errors.push(
-									new (getChunkRenderError())(chunk, filename, err)
+									new (getChunkRenderError())(chunk, filename, toError(err))
 								);
 								inTry = false;
 								return callback();
@@ -6239,299 +6262,275 @@ This prevents using hashes of each other and should be avoided.`);
 				};
 
 				// Generate code for all aggregated modules
-				asyncLib.eachLimit(
-					/** @type {import("neo-async").IterableCollection<Module>} */ (
-						/** @type {unknown} */ (modules)
-					),
-					10,
-					codeGen,
-					(err) => {
+				asyncLib.eachLimit(modules, 10, codeGen, (err) => {
+					if (err) return callback(err);
+					reportErrors();
+
+					// for backward-compat temporary set the chunk graph
+					// TODO webpack 6
+					const old = this.chunkGraph;
+					this.chunkGraph = chunkGraph;
+					this.processRuntimeRequirements({
+						chunkGraph,
+						modules,
+						chunks,
+						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);
-						reportErrors();
-
-						// for backward-compat temporary set the chunk graph
-						// TODO webpack 6
-						const old = this.chunkGraph;
-						this.chunkGraph = chunkGraph;
-						this.processRuntimeRequirements({
-							chunkGraph,
-							modules,
-							chunks,
-							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
-								);
-							}
+						// 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(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
+							};
 
-							// Generate code for all runtime modules
+							// Prepare execution
 							asyncLib.eachLimit(
-								/** @type {import("neo-async").IterableCollection<RuntimeModule>} */ (
-									runtimeModules
-								),
+								modules,
 								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
+								(module, callback) => {
+									const codeGenerationResult = codeGenerationResults.get(
+										module,
+										runtime
+									);
+									/** @type {ExecuteModuleArgument} */
+									const moduleArgument = {
+										module,
+										codeGenerationResult,
+										moduleObject: undefined
 									};
-
-									// 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);
-														}
-													}
+									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;
+										const moduleDiagnostics = buildInfo.diagnostics;
+										if (
+											moduleDiagnostics !== undefined &&
+											moduleDiagnostics.notCacheableReasons
+										) {
+											for (const reason of moduleDiagnostics.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
-													});
-												}
+										}
+									}
+									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;
 											}
-											this.hooks.prepareModuleExecution.callAsync(
-												moduleArgument,
-												context,
-												callback
+											const moduleArgument = moduleArgumentsById.get(id);
+											return __webpack_require_module__(
+												/** @type {ExecuteModuleArgument} */
+												(moduleArgument),
+												id
 											);
-										},
-										(err) => {
-											if (err) {
-												return callback(/** @type {WebpackError} */ (err));
+										};
+										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["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: {
+													id,
+													exports: {},
+													loaded: false,
+													error: undefined
+												},
+												require: __webpack_require__
+											};
+											for (const handler of interceptModuleExecution) {
+												handler(execOptions);
 											}
-
-											/** @type {ExecuteModuleExports | undefined} */
-											let exports;
+											const module = moduleArgument.module;
+											this.buildTimeExecutedModules.add(module);
+											const moduleObject = execOptions.module;
+											moduleArgument.moduleObject = moduleObject;
 											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["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: {
-															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);
-														}
-														if (
-															!(/** @type {WebpackError} */ (execErr).module)
-														) {
-															/** @type {WebpackError} */
-															(execErr).module = module;
-														}
-														throw execErr;
-													}
-												};
-
-												for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
-													chunk
-												)) {
-													__webpack_require_module__(
-														/** @type {ExecuteModuleArgument} */
-														(moduleArgumentsMap.get(runtimeModule))
-													);
-												}
-
-												exports = __webpack_require__(module.identifier());
+												if (id) moduleCache[id] = moduleObject;
+
+												tryRunOrWebpackError(
+													() =>
+														this.hooks.executeModule.call(
+															moduleArgument,
+															context
+														),
+													"Compilation.hooks.executeModule"
+												);
+												moduleObject.loaded = true;
+												return moduleObject.exports;
 											} catch (execErr) {
-												const { message, stack, module } =
+												if (strictModuleExceptionHandling) {
+													if (id) delete moduleCache[id];
+												} else if (strictModuleErrorHandling) {
+													moduleObject.error =
+														/** @type {WebpackError} */
+														(execErr);
+												}
+												if (!(/** @type {WebpackError} */ (execErr).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);
+													(execErr).module = module;
+												}
+												throw execErr;
 											}
-
-											callback(null, {
-												exports,
-												assets,
-												cacheable,
-												notCacheableReasons,
-												fileDependencies,
-												contextDependencies,
-												missingDependencies,
-												buildDependencies
-											});
+										};
+
+										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);
+									}
+
+									callback(null, {
+										exports,
+										assets,
+										cacheable,
+										notCacheableReasons,
+										fileDependencies,
+										contextDependencies,
+										missingDependencies,
+										buildDependencies
+									});
 								}
 							);
 						});
-					}
-				);
+					});
+				});
 			}
 		);
 	}