webpack 5.59.0 → 5.94.0

package/lib/dependencies/WorkerPlugin.js

@@ -8,6 +8,10 @@
 const { pathToFileURL } = require("url");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
@@ -21,21 +25,36 @@ const {
 } = require("./HarmonyImportDependencyParserPlugin");
 const WorkerDependency = require("./WorkerDependency");
 
+/** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").ChunkLoading} ChunkLoading */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OutputModule} OutputModule */
+/** @typedef {import("../../declarations/WebpackOptions").WasmLoading} WasmLoading */
+/** @typedef {import("../../declarations/WebpackOptions").WorkerPublicPath} WorkerPublicPath */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
-const getUrl = module => {
-	return pathToFileURL(module.resource).toString();
-};
+/**
+ * @param {NormalModule} module module
+ * @returns {string} url
+ */
+const getUrl = module => pathToFileURL(module.resource).toString();
+
+const WorkerSpecifierTag = Symbol("worker specifier tag");
 
 const DEFAULT_SYNTAX = [
 	"Worker",
@@ -47,12 +66,22 @@ const DEFAULT_SYNTAX = [
 /** @type {WeakMap<ParserState, number>} */
 const workerIndexMap = new WeakMap();
 
+const PLUGIN_NAME = "WorkerPlugin";
+
 class WorkerPlugin {
-	constructor(chunkLoading, wasmLoading, module) {
+	/**
+	 * @param {ChunkLoading=} chunkLoading chunk loading
+	 * @param {WasmLoading=} wasmLoading wasm loading
+	 * @param {OutputModule=} module output module
+	 * @param {WorkerPublicPath=} workerPublicPath worker public path
+	 */
+	constructor(chunkLoading, wasmLoading, module, workerPublicPath) {
 		this._chunkLoading = chunkLoading;
 		this._wasmLoading = wasmLoading;
 		this._module = module;
+		this._workerPublicPath = workerPublicPath;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -70,7 +99,7 @@ class WorkerPlugin {
 			compiler.root
 		);
 		compiler.hooks.thisCompilation.tap(
-			"WorkerPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					WorkerDependency,
@@ -88,7 +117,7 @@ class WorkerPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
+				 * @returns {[BasicEvaluatedExpression, [number, number]] | void} parsed
 				 */
 				const parseModuleUrl = (parser, expr) => {
 					if (
@@ -105,13 +134,19 @@ class WorkerPlugin {
 					const arg2Value = parser.evaluateExpression(arg2);
 					if (
 						!arg2Value.isString() ||
-						!arg2Value.string.startsWith("file://") ||
+						!(/** @type {string} */ (arg2Value.string).startsWith("file://")) ||
 						arg2Value.string !== getUrl(parser.state.module)
 					) {
 						return;
 					}
 					const arg1Value = parser.evaluateExpression(arg1);
-					return [arg1Value, [arg1.range[0], arg2.range[1]]];
+					return [
+						arg1Value,
+						[
+							/** @type {Range} */ (arg1.range)[0],
+							/** @type {Range} */ (arg2.range)[1]
+						]
+					];
 				};
 
 				/**
@@ -149,8 +184,9 @@ class WorkerPlugin {
 						}
 					}
 					const insertType = expr.properties.length > 0 ? "comma" : "single";
-					const insertLocation =
-						expr.properties[expr.properties.length - 1].range[1];
+					const insertLocation = /** @type {Range} */ (
+						expr.properties[expr.properties.length - 1].range
+					)[1];
 					return {
 						expressions,
 						otherElements,
@@ -162,14 +198,19 @@ class WorkerPlugin {
 				};
 
 				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {object} parserOptions options
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
 				 */
 				const parserPlugin = (parser, parserOptions) => {
 					if (parserOptions.worker === false) return;
 					const options = !Array.isArray(parserOptions.worker)
 						? ["..."]
 						: parserOptions.worker;
+					/**
+					 * @param {CallExpression} expr expression
+					 * @returns {boolean | void} true when handled
+					 */
 					const handleNewWorker = expr => {
 						if (expr.arguments.length === 0 || expr.arguments.length > 2)
 							return;
@@ -190,15 +231,19 @@ class WorkerPlugin {
 						} = arg2 && arg2.type === "ObjectExpression"
 							? parseObjectExpression(parser, arg2)
 							: {
+									/** @type {Record<string, Expression | Pattern>} */
 									expressions: {},
 									otherElements: [],
+									/** @type {Record<string, any>} */
 									values: {},
 									spread: false,
 									insertType: arg2 ? "spread" : "argument",
-									insertLocation: arg2 ? arg2.range : arg1.range[1]
-							  };
+									insertLocation: arg2
+										? /** @type {Range} */ (arg2.range)
+										: /** @type {Range} */ (arg1.range)[1]
+								};
 						const { options: importOptions, errors: commentErrors } =
-							parser.parseCommentOptions(expr.range);
+							parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 						if (commentErrors) {
 							for (const e of commentErrors) {
@@ -213,7 +258,7 @@ class WorkerPlugin {
 						}
 
 						/** @type {EntryOptions} */
-						let entryOptions = {};
+						const entryOptions = {};
 
 						if (importOptions) {
 							if (importOptions.webpackIgnore !== undefined) {
@@ -221,13 +266,11 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
-								} else {
-									if (importOptions.webpackIgnore) {
-										return false;
-									}
+								} else if (importOptions.webpackIgnore) {
+									return false;
 								}
 							}
 							if (importOptions.webpackEntryOptions !== undefined) {
@@ -238,7 +281,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -253,7 +296,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -271,16 +314,19 @@ class WorkerPlugin {
 						}
 
 						if (entryOptions.runtime === undefined) {
-							let i = workerIndexMap.get(parser.state) || 0;
+							const i = workerIndexMap.get(parser.state) || 0;
 							workerIndexMap.set(parser.state, i + 1);
-							let name = `${cachedContextify(
+							const name = `${cachedContextify(
 								parser.state.module.identifier()
 							)}|${i}`;
-							const hash = createHash(compilation.outputOptions.hashFunction);
-							hash.update(name);
-							const digest = /** @type {string} */ (
-								hash.digest(compilation.outputOptions.hashDigest)
+							const hash = createHash(
+								/** @type {Algorithm} */
+								(compilation.outputOptions.hashFunction)
 							);
+							hash.update(name);
+							const digest =
+								/** @type {string} */
+								(hash.digest(compilation.outputOptions.hashDigest));
 							entryOptions.runtime = digest.slice(
 								0,
 								compilation.outputOptions.hashDigestLength
@@ -296,16 +342,22 @@ class WorkerPlugin {
 							}
 						});
 						block.loc = expr.loc;
-						const dep = new WorkerDependency(url.string, range);
-						dep.loc = expr.loc;
+						const dep = new WorkerDependency(
+							/** @type {string} */ (url.string),
+							range,
+							{
+								publicPath: this._workerPublicPath
+							}
+						);
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
 
 						if (compilation.outputOptions.trustedTypes) {
 							const dep = new CreateScriptUrlDependency(
-								expr.arguments[0].range
+								/** @type {Range} */ (expr.arguments[0].range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addDependency(dep);
 						}
 
@@ -314,11 +366,12 @@ class WorkerPlugin {
 							if (options.type !== false) {
 								const dep = new ConstDependency(
 									this._module ? '"module"' : "undefined",
-									expr.range
+									/** @type {Range} */ (expr.range)
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
-								expressions.type = undefined;
+								/** @type {TODO} */
+								(expressions).type = undefined;
 							}
 						} else if (insertType === "comma") {
 							if (this._module || hasSpreadInOptions) {
@@ -326,31 +379,29 @@ class WorkerPlugin {
 									`, type: ${this._module ? '"module"' : "undefined"}`,
 									insertLocation
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 							}
 						} else if (insertType === "spread") {
 							const dep1 = new ConstDependency(
 								"Object.assign({}, ",
-								insertLocation[0]
+								/** @type {Range} */ (insertLocation)[0]
 							);
 							const dep2 = new ConstDependency(
 								`, { type: ${this._module ? '"module"' : "undefined"} })`,
-								insertLocation[1]
+								/** @type {Range} */ (insertLocation)[1]
 							);
-							dep1.loc = expr.loc;
-							dep2.loc = expr.loc;
+							dep1.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep2.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep1);
 							parser.state.module.addPresentationalDependency(dep2);
-						} else if (insertType === "argument") {
-							if (this._module) {
-								const dep = new ConstDependency(
-									', { type: "module" }',
-									insertLocation
-								);
-								dep.loc = expr.loc;
-								parser.state.module.addPresentationalDependency(dep);
-							}
+						} else if (insertType === "argument" && this._module) {
+							const dep = new ConstDependency(
+								', { type: "module" }',
+								insertLocation
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
 						}
 
 						parser.walkExpression(expr.callee);
@@ -366,11 +417,42 @@ class WorkerPlugin {
 
 						return true;
 					};
+					/**
+					 * @param {string} item item
+					 */
 					const processItem = item => {
-						if (item.endsWith("()")) {
+						if (
+							item.startsWith("*") &&
+							item.includes(".") &&
+							item.endsWith("()")
+						) {
+							const firstDot = item.indexOf(".");
+							const pattern = item.slice(1, firstDot);
+							const itemMembers = item.slice(firstDot + 1, -2);
+
+							parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+								if (decl.id.type === "Identifier" && decl.id.name === pattern) {
+									parser.tagVariable(decl.id.name, WorkerSpecifierTag);
+									return true;
+								}
+							});
+							parser.hooks.pattern.for(pattern).tap(PLUGIN_NAME, pattern => {
+								parser.tagVariable(pattern.name, WorkerSpecifierTag);
+								return true;
+							});
+							parser.hooks.callMemberChain
+								.for(WorkerSpecifierTag)
+								.tap(PLUGIN_NAME, (expression, members) => {
+									if (itemMembers !== members.join(".")) {
+										return;
+									}
+
+									return handleNewWorker(expression);
+								});
+						} else if (item.endsWith("()")) {
 							parser.hooks.call
 								.for(item.slice(0, -2))
-								.tap("WorkerPlugin", handleNewWorker);
+								.tap(PLUGIN_NAME, handleNewWorker);
 						} else {
 							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
 							if (match) {
@@ -379,7 +461,7 @@ class WorkerPlugin {
 								const source = match[3];
 								(call ? parser.hooks.call : parser.hooks.new)
 									.for(harmonySpecifierTag)
-									.tap("WorkerPlugin", expr => {
+									.tap(PLUGIN_NAME, expr => {
 										const settings = /** @type {HarmonySettings} */ (
 											parser.currentTagData
 										);
@@ -393,22 +475,24 @@ class WorkerPlugin {
 										return handleNewWorker(expr);
 									});
 							} else {
-								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
+								parser.hooks.new.for(item).tap(PLUGIN_NAME, handleNewWorker);
 							}
 						}
 					};
 					for (const item of options) {
 						if (item === "...") {
-							DEFAULT_SYNTAX.forEach(processItem);
+							for (const itemFromDefault of DEFAULT_SYNTAX) {
+								processItem(itemFromDefault);
+							}
 						} else processItem(item);
 					}
 				};
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WorkerPlugin", parserPlugin);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserPlugin);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WorkerPlugin", parserPlugin);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserPlugin);
 			}
 		);
 	}

package/lib/dependencies/getFunctionExpression.js

@@ -5,6 +5,15 @@
 
 "use strict";
 
+/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").FunctionExpression} FunctionExpression */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+
+/**
+ * @param {Expression | SpreadElement} expr expressions
+ * @returns {{fn: FunctionExpression | ArrowFunctionExpression, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined } | undefined} function expression with additional information
+ */
 module.exports = expr => {
 	// <FunctionExpression>
 	if (

package/lib/dependencies/processExportInfo.js

@@ -10,9 +10,11 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {string[][]} ReferencedExports */
+
 /**
  * @param {RuntimeSpec} runtime the runtime
- * @param {string[][]} referencedExports list of referenced exports, will be added to
+ * @param {ReferencedExports} referencedExports list of referenced exports, will be added to
  * @param {string[]} prefix export prefix
  * @param {ExportInfo=} exportInfo the export info
  * @param {boolean} defaultPointsToSelf when true, using default will reference itself

package/lib/electron/ElectronTargetPlugin.js

@@ -16,6 +16,7 @@ class ElectronTargetPlugin {
 	constructor(context) {
 		this._context = context;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -4,6 +4,7 @@
 
 "use strict";
 
+const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
 class ExportWebpackRequireRuntimeModule extends RuntimeModule {
@@ -19,10 +20,10 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		return "export default __webpack_require__;";
+		return `export default ${RuntimeGlobals.require};`;
 	}
 }
 

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -5,20 +5,22 @@
 
 "use strict";
 
-const { ConcatSource, RawSource } = require("webpack-sources");
+const { ConcatSource } = require("webpack-sources");
 const { RuntimeGlobals } = require("..");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const Template = require("../Template");
+const { getAllChunks } = require("../javascript/ChunkHelpers");
 const {
+	chunkHasJs,
 	getCompilationHooks,
 	getChunkFilenameTemplate
 } = require("../javascript/JavascriptModulesPlugin");
-const {
-	generateEntryStartup,
-	updateHashForEntryStartup
-} = require("../javascript/StartupHelpers");
+const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
+const { getUndoPath } = require("../util/identifier");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class ModuleChunkFormatPlugin {
 	/**
@@ -56,9 +58,9 @@ class ModuleChunkFormatPlugin {
 						} else {
 							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
 							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
-							source.add(`export const modules = `);
+							source.add("export const modules = ");
 							source.add(modules);
-							source.add(`;\n`);
+							source.add(";\n");
 							const runtimeModules =
 								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 							if (runtimeModules.length > 0) {
@@ -74,7 +76,9 @@ class ModuleChunkFormatPlugin {
 								chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
 							);
 							if (entries.length > 0) {
-								const runtimeChunk = entries[0][1].getRuntimeChunk();
+								const runtimeChunk =
+									/** @type {Entrypoint[][]} */
+									(entries)[0][1].getRuntimeChunk();
 								const currentOutputName = compilation
 									.getPath(
 										getChunkFilenameTemplate(chunk, compilation.outputOptions),
@@ -83,64 +87,97 @@ class ModuleChunkFormatPlugin {
 											contentHashType: "javascript"
 										}
 									)
-									.split("/");
-								const runtimeOutputName = compilation
-									.getPath(
-										getChunkFilenameTemplate(
-											runtimeChunk,
-											compilation.outputOptions
-										),
-										{
-											chunk: runtimeChunk,
-											contentHashType: "javascript"
-										}
-									)
+									.replace(/^\/+/g, "")
 									.split("/");
 
-								// remove filename, we only need the directory
-								const outputFilename = currentOutputName.pop();
+								/**
+								 * @param {Chunk} chunk the chunk
+								 * @returns {string} the relative path
+								 */
+								const getRelativePath = chunk => {
+									const baseOutputName = currentOutputName.slice();
+									const chunkOutputName = compilation
+										.getPath(
+											getChunkFilenameTemplate(
+												chunk,
+												compilation.outputOptions
+											),
+											{
+												chunk,
+												contentHashType: "javascript"
+											}
+										)
+										.replace(/^\/+/g, "")
+										.split("/");
 
-								// remove common parts
-								while (
-									currentOutputName.length > 0 &&
-									runtimeOutputName.length > 0 &&
-									currentOutputName[0] === runtimeOutputName[0]
-								) {
-									currentOutputName.shift();
-									runtimeOutputName.shift();
-								}
-
-								// create final path
-								const runtimePath =
-									(currentOutputName.length > 0
-										? "../".repeat(currentOutputName.length)
-										: "./") + runtimeOutputName.join("/");
+									// remove common parts except filename
+									while (
+										baseOutputName.length > 1 &&
+										chunkOutputName.length > 1 &&
+										baseOutputName[0] === chunkOutputName[0]
+									) {
+										baseOutputName.shift();
+										chunkOutputName.shift();
+									}
+									const last = chunkOutputName.join("/");
+									// create final path
+									return (
+										getUndoPath(baseOutputName.join("/"), last, true) + last
+									);
+								};
 
 								const entrySource = new ConcatSource();
 								entrySource.add(source);
 								entrySource.add(";\n\n// load runtime\n");
 								entrySource.add(
-									`import __webpack_require__ from ${JSON.stringify(
-										runtimePath
+									`import ${RuntimeGlobals.require} from ${JSON.stringify(
+										getRelativePath(/** @type {Chunk} */ (runtimeChunk))
 									)};\n`
 								);
-								entrySource.add(
-									`import * as __webpack_self_exports__ from ${JSON.stringify(
-										"./" + outputFilename
-									)};\n`
-								);
-								entrySource.add(
-									`${RuntimeGlobals.externalInstallChunk}(__webpack_self_exports__);\n`
-								);
-								const startupSource = new RawSource(
-									generateEntryStartup(
-										chunkGraph,
-										runtimeTemplate,
-										entries,
-										chunk,
-										false
-									)
+
+								const startupSource = new ConcatSource();
+								startupSource.add(
+									`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+										`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
+										"moduleId"
+									)}\n`
 								);
+
+								const loadedChunks = new Set();
+								let index = 0;
+								for (let i = 0; i < entries.length; i++) {
+									const [module, entrypoint] = entries[i];
+									const final = i + 1 === entries.length;
+									const moduleId = chunkGraph.getModuleId(module);
+									const chunks = getAllChunks(
+										/** @type {Entrypoint} */ (entrypoint),
+										/** @type {Chunk} */ (runtimeChunk),
+										undefined
+									);
+									for (const chunk of chunks) {
+										if (
+											loadedChunks.has(chunk) ||
+											!chunkHasJs(chunk, chunkGraph)
+										)
+											continue;
+										loadedChunks.add(chunk);
+										startupSource.add(
+											`import * as __webpack_chunk_${index}__ from ${JSON.stringify(
+												getRelativePath(chunk)
+											)};\n`
+										);
+										startupSource.add(
+											`${RuntimeGlobals.externalInstallChunk}(__webpack_chunk_${index}__);\n`
+										);
+										index++;
+									}
+									startupSource.add(
+										`${
+											final ? `var ${RuntimeGlobals.exports} = ` : ""
+										}__webpack_exec__(${JSON.stringify(moduleId)});\n`
+									);
+								}
+
 								entrySource.add(
 									hooks.renderStartup.call(
 										startupSource,