webpack 5.31.2 → 5.33.2

package/lib/Compilation.js

@@ -12,7 +12,8 @@ const {
 	SyncBailHook,
 	SyncWaterfallHook,
 	AsyncSeriesHook,
-	AsyncSeriesBailHook
+	AsyncSeriesBailHook,
+	AsyncParallelHook
 } = require("tapable");
 const util = require("util");
 const { CachedSource } = require("webpack-sources");
@@ -32,7 +33,10 @@ const {
 	connectChunkGroupAndChunk,
 	connectChunkGroupParentAndChild
 } = require("./GraphHelpers");
-const { makeWebpackError } = require("./HookWebpackError");
+const {
+	makeWebpackError,
+	tryRunOrWebpackError
+} = require("./HookWebpackError");
 const MainTemplate = require("./MainTemplate");
 const Module = require("./Module");
 const ModuleDependencyError = require("./ModuleDependencyError");
@@ -71,6 +75,7 @@ const {
 	soonFrozenObjectDeprecation,
 	createFakeHook
 } = require("./util/deprecation");
+const processAsyncTree = require("./util/processAsyncTree");
 const { getRuntimeKey } = require("./util/runtime");
 const { isSourceEqual } = require("./util/source");
 
@@ -119,6 +124,13 @@ const { isSourceEqual } = require("./util/source");
  * @returns {void}
  */
 
+/**
+ * @callback ExecuteModuleCallback
+ * @param {WebpackError=} err
+ * @param {ExecuteModuleResult=} result
+ * @returns {void}
+ */
+
 /**
  * @callback DepBlockVarDependenciesCallback
  * @param {Dependency} dependency
@@ -158,6 +170,44 @@ const { isSourceEqual } = require("./util/source");
  * @property {ChunkGraph} chunkGraph the chunk graph
  */
 
+/**
+ * @typedef {Object} RuntimeRequirementsContext
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults the code generation results
+ */
+
+/**
+ * @typedef {Object} ExecuteModuleOptions
+ * @property {EntryOptions=} entryOptions
+ */
+
+/**
+ * @typedef {Object} ExecuteModuleResult
+ * @property {any} exports
+ * @property {boolean} cacheable
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {LazySet<string>} fileDependencies
+ * @property {LazySet<string>} contextDependencies
+ * @property {LazySet<string>} missingDependencies
+ * @property {LazySet<string>} buildDependencies
+ */
+
+/**
+ * @typedef {Object} ExecuteModuleArgument
+ * @property {Module} module
+ * @property {{ id: string, exports: any, loaded: boolean }=} moduleObject
+ * @property {any} preparedInfo
+ * @property {CodeGenerationResult} codeGenerationResult
+ */
+
+/**
+ * @typedef {Object} ExecuteModuleContext
+ * @property {Map<string, { source: Source, info: AssetInfo }>} assets
+ * @property {Chunk} chunk
+ * @property {ChunkGraph} chunkGraph
+ * @property {function(string): any=} __webpack_require__
+ */
+
 /**
  * @typedef {Object} EntryData
  * @property {Dependency[]} dependencies dependencies of the entrypoint that should be evaluated at startup
@@ -525,6 +575,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				"runtime"
 			]),
 
+			/** @type {SyncHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			executeModule: new SyncHook(["options", "context"]),
+			/** @type {AsyncParallelHook<[ExecuteModuleArgument, ExecuteModuleContext]>} */
+			prepareModuleExecution: new AsyncParallelHook(["options", "context"]),
+
 			/** @type {AsyncSeriesHook<[Iterable<Module>]>} */
 			finishModules: new AsyncSeriesHook(["modules"]),
 			/** @type {AsyncSeriesHook<[Module]>} */
@@ -568,32 +623,35 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			/** @type {SyncBailHook<[], boolean>} */
 			shouldRecord: new SyncBailHook([]),
 
-			/** @type {SyncHook<[Chunk, Set<string>]>} */
+			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
 			additionalChunkRuntimeRequirements: new SyncHook([
 				"chunk",
-				"runtimeRequirements"
+				"runtimeRequirements",
+				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>]>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
 			runtimeRequirementInChunk: new HookMap(
-				() => new SyncBailHook(["chunk", "runtimeRequirements"])
+				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
-			/** @type {SyncHook<[Module, Set<string>]>} */
+			/** @type {SyncHook<[Module, Set<string>, RuntimeRequirementsContext]>} */
 			additionalModuleRuntimeRequirements: new SyncHook([
 				"module",
-				"runtimeRequirements"
+				"runtimeRequirements",
+				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Module, Set<string>]>>} */
+			/** @type {HookMap<SyncBailHook<[Module, Set<string>, RuntimeRequirementsContext]>>} */
 			runtimeRequirementInModule: new HookMap(
-				() => new SyncBailHook(["module", "runtimeRequirements"])
+				() => new SyncBailHook(["module", "runtimeRequirements", "context"])
 			),
-			/** @type {SyncHook<[Chunk, Set<string>]>} */
+			/** @type {SyncHook<[Chunk, Set<string>, RuntimeRequirementsContext]>} */
 			additionalTreeRuntimeRequirements: new SyncHook([
 				"chunk",
-				"runtimeRequirements"
+				"runtimeRequirements",
+				"context"
 			]),
-			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>]>>} */
+			/** @type {HookMap<SyncBailHook<[Chunk, Set<string>, RuntimeRequirementsContext]>>} */
 			runtimeRequirementInTree: new HookMap(
-				() => new SyncBailHook(["chunk", "runtimeRequirements"])
+				() => new SyncBailHook(["chunk", "runtimeRequirements", "context"])
 			),
 
 			/** @type {SyncHook<[RuntimeModule, Chunk]>} */
@@ -776,7 +834,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		if (compiler.contextTimestamps) {
 			this.fileSystemInfo.addContextTimestamps(compiler.contextTimestamps);
 		}
-		/** @type {Map<string, string>} */
+		/** @type {Map<string, string | Set<string>>} */
 		this.valueCacheVersions = new Map();
 		this.requestShortener = compiler.requestShortener;
 		this.compilerPath = compiler.compilerPath;
@@ -824,6 +882,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 
 		this.moduleGraph = new ModuleGraph();
+		/** @type {ChunkGraph} */
 		this.chunkGraph = undefined;
 		/** @type {CodeGenerationResults} */
 		this.codeGenerationResults = undefined;
@@ -928,6 +987,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.builtModules = new WeakSet();
 		/** @type {WeakSet<Module>} */
 		this.codeGeneratedModules = new WeakSet();
+		/** @type {WeakSet<Module>} */
+		this.buildTimeExecutedModules = new WeakSet();
 		/** @private @type {Map<Module, Callback[]>} */
 		this._rebuildingModules = new Map();
 		/** @type {Set<string>} */
@@ -1435,6 +1496,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @property {Partial<ModuleFactoryCreateDataContextInfo>=} contextInfo
 	 * @property {string=} context
 	 * @property {boolean=} recursive recurse into dependencies of the created module
+	 * @property {boolean=} connectOrigin connect the resolved module with the origin module
 	 */
 
 	/**
@@ -1449,7 +1511,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			originModule,
 			contextInfo,
 			context,
-			recursive = true
+			recursive = true,
+			connectOrigin = recursive
 		},
 		callback
 	) {
@@ -1497,7 +1560,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					for (let i = 0; i < dependencies.length; i++) {
 						const dependency = dependencies[i];
 						moduleGraph.setResolvedModule(
-							recursive ? originModule : null,
+							connectOrigin ? originModule : null,
 							dependency,
 							module
 						);
@@ -1888,6 +1951,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 
 			this.processDependenciesQueue.invalidate(module);
+			this.moduleGraph.unfreeze();
 			this.processModuleDependencies(module, err => {
 				if (err) return callback(err);
 				this.removeReasonsOfDependencyBlock(module, {
@@ -2094,6 +2158,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			// extract warnings and errors from modules
 			this.logger.time("report dependency errors and warnings");
+			this.moduleGraph.freeze();
 			for (const module of modules) {
 				this.reportDependencyErrorsAndWarnings(module, [module]);
 				const errors = module.getErrors();
@@ -2115,6 +2180,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					}
 				}
 			}
+			this.moduleGraph.unfreeze();
 			this.logger.timeEnd("report dependency errors and warnings");
 
 			callback();
@@ -2132,6 +2198,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assets = {};
 		this.assetsInfo.clear();
 		this.moduleGraph.removeAllModuleAttributes();
+		this.moduleGraph.unfreeze();
 	}
 
 	/**
@@ -2157,6 +2224,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 		this.logger.time("create chunks");
 		this.hooks.beforeChunks.call();
+		this.moduleGraph.freeze();
 		/** @type {Map<Entrypoint, Module[]>} */
 		const chunkGraphInit = new Map();
 		for (const [name, { dependencies, includeDependencies, options }] of this
@@ -2644,20 +2712,45 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		});
 	}
 
+	_getChunkGraphEntries() {
+		/** @type {Set<Chunk>} */
+		const treeEntries = new Set();
+		for (const ep of this.entrypoints.values()) {
+			const chunk = ep.getRuntimeChunk();
+			if (chunk) treeEntries.add(chunk);
+		}
+		for (const ep of this.asyncEntrypoints) {
+			const chunk = ep.getRuntimeChunk();
+			if (chunk) treeEntries.add(chunk);
+		}
+		return treeEntries;
+	}
+
 	/**
+	 * @param {Object} options options
+	 * @param {ChunkGraph=} options.chunkGraph the chunk graph
+	 * @param {Iterable<Module>=} options.modules modules
+	 * @param {Iterable<Chunk>=} options.chunks chunks
+	 * @param {CodeGenerationResults=} options.codeGenerationResults codeGenerationResults
+	 * @param {Iterable<Chunk>=} options.chunkGraphEntries chunkGraphEntries
 	 * @returns {void}
 	 */
-	processRuntimeRequirements() {
-		const { chunkGraph } = this;
-
+	processRuntimeRequirements({
+		chunkGraph = this.chunkGraph,
+		modules = this.modules,
+		chunks = this.chunks,
+		codeGenerationResults = this.codeGenerationResults,
+		chunkGraphEntries = this._getChunkGraphEntries()
+	} = {}) {
+		const context = { chunkGraph, codeGenerationResults };
 		const additionalModuleRuntimeRequirements = this.hooks
 			.additionalModuleRuntimeRequirements;
 		const runtimeRequirementInModule = this.hooks.runtimeRequirementInModule;
-		for (const module of this.modules) {
+		for (const module of modules) {
 			if (chunkGraph.getNumberOfModuleChunks(module) > 0) {
 				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
 					let set;
-					const runtimeRequirements = this.codeGenerationResults.getRuntimeRequirements(
+					const runtimeRequirements = codeGenerationResults.getRuntimeRequirements(
 						module,
 						runtime
 					);
@@ -2668,18 +2761,18 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					} else {
 						continue;
 					}
-					additionalModuleRuntimeRequirements.call(module, set);
+					additionalModuleRuntimeRequirements.call(module, set, context);
 
 					for (const r of set) {
 						const hook = runtimeRequirementInModule.get(r);
-						if (hook !== undefined) hook.call(module, set);
+						if (hook !== undefined) hook.call(module, set, context);
 					}
 					chunkGraph.addModuleRuntimeRequirements(module, runtime, set);
 				}
 			}
 		}
 
-		for (const chunk of this.chunks) {
+		for (const chunk of chunks) {
 			const set = new Set();
 			for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
@@ -2688,27 +2781,16 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				);
 				for (const r of runtimeRequirements) set.add(r);
 			}
-			this.hooks.additionalChunkRuntimeRequirements.call(chunk, set);
+			this.hooks.additionalChunkRuntimeRequirements.call(chunk, set, context);
 
 			for (const r of set) {
-				this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set);
+				this.hooks.runtimeRequirementInChunk.for(r).call(chunk, set, context);
 			}
 
 			chunkGraph.addChunkRuntimeRequirements(chunk, set);
 		}
 
-		/** @type {Set<Chunk>} */
-		const treeEntries = new Set();
-		for (const ep of this.entrypoints.values()) {
-			const chunk = ep.getRuntimeChunk();
-			if (chunk) treeEntries.add(chunk);
-		}
-		for (const ep of this.asyncEntrypoints) {
-			const chunk = ep.getRuntimeChunk();
-			if (chunk) treeEntries.add(chunk);
-		}
-
-		for (const treeEntry of treeEntries) {
+		for (const treeEntry of chunkGraphEntries) {
 			const set = new Set();
 			for (const chunk of treeEntry.getAllReferencedChunks()) {
 				const runtimeRequirements = chunkGraph.getChunkRuntimeRequirements(
@@ -2717,22 +2799,30 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				for (const r of runtimeRequirements) set.add(r);
 			}
 
-			this.hooks.additionalTreeRuntimeRequirements.call(treeEntry, set);
+			this.hooks.additionalTreeRuntimeRequirements.call(
+				treeEntry,
+				set,
+				context
+			);
 
 			for (const r of set) {
-				this.hooks.runtimeRequirementInTree.for(r).call(treeEntry, set);
+				this.hooks.runtimeRequirementInTree
+					.for(r)
+					.call(treeEntry, set, context);
 			}
 
 			chunkGraph.addTreeRuntimeRequirements(treeEntry, set);
 		}
 	}
 
+	// TODO webpack 6 make chunkGraph argument non-optional
 	/**
 	 * @param {Chunk} chunk target chunk
 	 * @param {RuntimeModule} module runtime module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @returns {void}
 	 */
-	addRuntimeModule(chunk, module) {
+	addRuntimeModule(chunk, module, chunkGraph = this.chunkGraph) {
 		// Deprecated ModuleGraph association
 		ModuleGraph.setModuleGraphForModule(module, this.moduleGraph);
 
@@ -2741,14 +2831,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		this._modules.set(module.identifier(), module);
 
 		// connect to the chunk graph
-		this.chunkGraph.connectChunkAndModule(chunk, module);
-		this.chunkGraph.connectChunkAndRuntimeModule(chunk, module);
+		chunkGraph.connectChunkAndModule(chunk, module);
+		chunkGraph.connectChunkAndRuntimeModule(chunk, module);
 		if (module.fullHash) {
-			this.chunkGraph.addFullHashModuleToChunk(chunk, module);
+			chunkGraph.addFullHashModuleToChunk(chunk, module);
 		}
 
 		// attach runtime module
-		module.attach(this, chunk);
+		module.attach(this, chunk, chunkGraph);
 
 		// Setup internals
 		const exportsInfo = this.moduleGraph.getExportsInfo(module);
@@ -2762,14 +2852,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				exportsInfo.setUsedForSideEffectsOnly(runtime);
 			}
 		}
-		this.chunkGraph.addModuleRuntimeRequirements(
+		chunkGraph.addModuleRuntimeRequirements(
 			module,
 			chunk.runtime,
 			new Set([RuntimeGlobals.requireScope])
 		);
 
 		// runtime modules don't need ids
-		this.chunkGraph.setModuleId(module, "");
+		chunkGraph.setModuleId(module, "");
 
 		// Call hook
 		this.hooks.runtimeModule.call(module, chunk);
@@ -3889,6 +3979,356 @@ This prevents using hashes of each other and should be avoided.`);
 		);
 	}
 
+	/**
+	 * @param {Module} module the module
+	 * @param {ExecuteModuleOptions} options options
+	 * @param {ExecuteModuleCallback} callback callback
+	 */
+	executeModule(module, options, callback) {
+		// Aggregate all referenced modules and ensure they are ready
+		const modules = new Set([module]);
+		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.addModuleQueue.waitFor(module, err => {
+					if (err) return callback(err);
+					this.buildQueue.waitFor(module, err => {
+						if (err) return callback(err);
+						this.processDependenciesQueue.waitFor(module, err => {
+							if (err) return callback(err);
+							for (const {
+								module: m
+							} of this.moduleGraph.getOutgoingConnections(module)) {
+								const size = modules.size;
+								modules.add(m);
+								if (modules.size !== size) push(m);
+							}
+							callback();
+						});
+					});
+				});
+			},
+			err => {
+				if (err) return callback(err);
+
+				// Create new chunk graph, chunk and entrypoint for the build time execution
+				const chunkGraph = new ChunkGraph(this.moduleGraph);
+				const runtime = "build time";
+				const {
+					hashFunction,
+					hashDigest,
+					hashDigestLength
+				} = this.outputOptions;
+				const runtimeTemplate = this.runtimeTemplate;
+
+				const chunk = new Chunk("build time chunk");
+				chunk.id = chunk.name;
+				chunk.ids = [chunk.id];
+				chunk.runtime = runtime;
+
+				const entrypoint = new Entrypoint({
+					runtime,
+					chunkLoading: false,
+					...options.entryOptions
+				});
+				chunkGraph.connectChunkAndEntryModule(chunk, module, entrypoint);
+				connectChunkGroupAndChunk(entrypoint, chunk);
+				entrypoint.setRuntimeChunk(chunk);
+				entrypoint.setEntrypointChunk(chunk);
+
+				const chunks = new Set([chunk]);
+
+				// Assign ids to modules and modules to the chunk
+				for (const module of modules) {
+					const id = module.identifier();
+					chunkGraph.setModuleId(module, id);
+					chunkGraph.connectChunkAndModule(chunk, module);
+				}
+
+				// Hash modules
+				for (const module of modules) {
+					this._createModuleHash(
+						module,
+						chunkGraph,
+						runtime,
+						hashFunction,
+						runtimeTemplate,
+						hashDigest,
+						hashDigestLength
+					);
+				}
+
+				const codeGenerationResults = new CodeGenerationResults();
+				/** @type {WebpackError[]} */
+				const errors = [];
+				/**
+				 * @param {Module} module the module
+				 * @param {Callback} callback callback
+				 * @returns {void}
+				 */
+				const codeGen = (module, callback) => {
+					this._codeGenerationModule(
+						module,
+						runtime,
+						[runtime],
+						chunkGraph.getModuleHash(module, runtime),
+						this.dependencyTemplates,
+						chunkGraph,
+						this.moduleGraph,
+						runtimeTemplate,
+						errors,
+						codeGenerationResults,
+						(err, codeGenerated) => {
+							callback(err);
+						}
+					);
+				};
+
+				const reportErrors = () => {
+					if (errors.length > 0) {
+						errors.sort(
+							compareSelect(err => err.module, compareModulesByIdentifier)
+						);
+						for (const error of errors) {
+							this.errors.push(error);
+						}
+						errors.length = 0;
+					}
+				};
+
+				// Generate code for all aggregated modules
+				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
+					});
+					this.chunkGraph = old;
+
+					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
+						);
+					}
+
+					// 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 {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,
+									preparedInfo: undefined,
+									moduleObject: undefined
+								};
+								moduleArgumentsMap.set(module, moduleArgument);
+								moduleArgumentsById.set(module.identifier(), moduleArgument);
+								module.addCacheDependencies(
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								);
+								if (module.buildInfo.cacheable === false) {
+									cacheable = false;
+								}
+								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(err);
+
+								let exports;
+								try {
+									const {
+										strictModuleErrorHandling,
+										strictModuleExceptionHandling
+									} = this.outputOptions;
+									const __webpack_require__ = id => {
+										const cached = moduleCache[id];
+										if (cached !== undefined) {
+											if (cached.error) throw cached.error;
+											return cached.exports;
+										}
+										const moduleArgument = moduleArgumentsById.get(id);
+										return __webpack_require_module__(moduleArgument, id);
+									};
+									const interceptModuleExecution = (__webpack_require__[
+										RuntimeGlobals.interceptModuleExecution.replace(
+											"__webpack_require__.",
+											""
+										)
+									] = []);
+									const moduleCache = (__webpack_require__[
+										RuntimeGlobals.moduleCache.replace(
+											"__webpack_require__.",
+											""
+										)
+									] = {});
+
+									context.__webpack_require__ = __webpack_require__;
+
+									/**
+									 * @param {ExecuteModuleArgument} moduleArgument the module argument
+									 * @param {string=} id id
+									 * @returns {any} exports
+									 */
+									const __webpack_require_module__ = (moduleArgument, id) => {
+										var execOptions = {
+											id,
+											module: {
+												id,
+												exports: {},
+												loaded: false,
+												error: undefined
+											},
+											require: __webpack_require__
+										};
+										interceptModuleExecution.forEach(handler =>
+											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 (e) {
+											if (strictModuleExceptionHandling) {
+												if (id) delete moduleCache[id];
+											} else if (strictModuleErrorHandling) {
+												moduleObject.error = e;
+											}
+											if (!e.module) e.module = module;
+											throw e;
+										}
+									};
+
+									for (const runtimeModule of chunkGraph.getChunkRuntimeModulesInOrder(
+										chunk
+									)) {
+										__webpack_require_module__(
+											moduleArgumentsMap.get(runtimeModule)
+										);
+									}
+									exports = __webpack_require__(module.identifier());
+								} catch (e) {
+									const err = new WebpackError(
+										`Execution of module code from module graph (${module.readableIdentifier(
+											this.requestShortener
+										)}) failed: ${e.message}`
+									);
+									err.stack = e.stack;
+									err.module = e.module;
+									return callback(err);
+								}
+
+								callback(null, {
+									exports,
+									assets,
+									cacheable,
+									fileDependencies,
+									contextDependencies,
+									missingDependencies,
+									buildDependencies
+								});
+							}
+						);
+					});
+				});
+			}
+		);
+	}
+
 	checkConstraints() {
 		const chunkGraph = this.chunkGraph;