@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/errors/NonErrorEmittedError.js

@@ -0,0 +1,30 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const WebpackError = require("./WebpackError");
+
+class NonErrorEmittedError extends WebpackError {
+	/**
+	 * @param {EXPECTED_ANY} error value which is not an instance of Error
+	 */
+	constructor(error) {
+		super();
+
+		/** @type {string} */
+		this.name = "NonErrorEmittedError";
+		/** @type {string} */
+		this.message = `(Emitted value instead of an instance of Error) ${error}`;
+	}
+}
+
+makeSerializable(
+	NonErrorEmittedError,
+	"webpack/lib/errors/NonErrorEmittedError"
+);
+
+module.exports = NonErrorEmittedError;

package/lib/{UnhandledSchemeError.js → errors/UnhandledSchemeError.js}

@@ -5,11 +5,17 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
+/**
+ * Error raised when webpack encounters a resource URI scheme that no installed
+ * plugin knows how to read.
+ */
 class UnhandledSchemeError extends WebpackError {
 	/**
+	 * Creates an error explaining that the current resource scheme is not
+	 * supported by the active plugin set.
 	 * @param {string} scheme scheme
 	 * @param {string} resource resource
 	 */
@@ -19,6 +25,7 @@ class UnhandledSchemeError extends WebpackError {
 				'\nWebpack supports "data:" and "file:" URIs by default.' +
 				`\nYou may need an additional plugin to handle "${scheme}:" URIs.`
 		);
+		/** @type {string} */
 		this.file = resource;
 		/** @type {string} */
 		this.name = "UnhandledSchemeError";
@@ -27,7 +34,7 @@ class UnhandledSchemeError extends WebpackError {
 
 makeSerializable(
 	UnhandledSchemeError,
-	"webpack/lib/UnhandledSchemeError",
+	"webpack/lib/errors/UnhandledSchemeError",
 	"UnhandledSchemeError"
 );
 

package/lib/{UnsupportedFeatureWarning.js → errors/UnsupportedFeatureWarning.js}

@@ -5,13 +5,14 @@
 
 "use strict";
 
+const makeSerializable = require("../util/makeSerializable");
 const WebpackError = require("./WebpackError");
-const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 
 class UnsupportedFeatureWarning extends WebpackError {
 	/**
+	 * Creates an instance of UnsupportedFeatureWarning.
 	 * @param {string} message description of warning
 	 * @param {DependencyLocation} loc location start and end positions of the module
 	 */
@@ -29,7 +30,7 @@ class UnsupportedFeatureWarning extends WebpackError {
 
 makeSerializable(
 	UnsupportedFeatureWarning,
-	"webpack/lib/UnsupportedFeatureWarning"
+	"webpack/lib/errors/UnsupportedFeatureWarning"
 );
 
 module.exports = UnsupportedFeatureWarning;

package/lib/errors/WebpackError.js

@@ -0,0 +1,84 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Jarid Margolin @jaridmargolin
+*/
+
+"use strict";
+
+const inspect = require("util").inspect.custom;
+const makeSerializable = require("../util/makeSerializable");
+
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class WebpackError extends Error {
+	/**
+	 * Creates an instance of WebpackError.
+	 * @param {string=} message error message
+	 * @param {{ cause?: unknown }} options error options
+	 */
+	constructor(message, options = {}) {
+		super(message, options);
+
+		/** @type {string=} */
+		this.details = undefined;
+		/** @type {(Module | null)=} */
+		this.module = undefined;
+		/** @type {DependencyLocation=} */
+		this.loc = undefined;
+		/** @type {boolean=} */
+		this.hideStack = undefined;
+		/** @type {Chunk=} */
+		this.chunk = undefined;
+		/** @type {string=} */
+		this.file = undefined;
+	}
+
+	/**
+	 * Returns inspect message.
+	 * @returns {string} inspect message
+	 */
+	[inspect]() {
+		return (
+			this.stack +
+			(this.details ? `\n${this.details}` : "") +
+			(this.cause ? `\n${this.cause}` : "")
+		);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize({ write }) {
+		write(this.name);
+		write(this.message);
+		write(this.stack);
+		write(this.cause);
+		write(this.details);
+		write(this.loc);
+		write(this.hideStack);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize({ read }) {
+		this.name = read();
+		this.message = read();
+		this.stack = read();
+		this.cause = read();
+		this.details = read();
+		this.loc = read();
+		this.hideStack = read();
+	}
+}
+
+makeSerializable(WebpackError, "webpack/lib/errors/WebpackError");
+
+/** @type {typeof WebpackError} */
+module.exports = WebpackError;

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -13,6 +13,7 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Returns true, if the runtime module should get it's own scope.
 	 * @returns {boolean} true, if the runtime module should get it's own scope
 	 */
 	shouldIsolate() {
@@ -20,6 +21,7 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -27,8 +27,11 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 
 /**
+ * Gets relative path.
  * @param {Compilation} compilation the compilation instance
  * @param {Chunk} chunk the chunk
  * @param {Chunk} runtimeChunk the runtime chunk
@@ -69,6 +72,7 @@ const getRelativePath = (compilation, chunk, runtimeChunk) => {
 };
 
 /**
+ * Renders chunk import.
  * @param {Compilation} compilation the compilation instance
  * @param {Chunk} chunk the chunk to render the import for
  * @param {string=} namedImport the named import to use for the import
@@ -76,12 +80,15 @@ const getRelativePath = (compilation, chunk, runtimeChunk) => {
  * @returns {string} the import source
  */
 function renderChunkImport(compilation, chunk, namedImport, runtimeChunk) {
-	return `import ${namedImport ? `* as ${namedImport}` : `{ ${RuntimeGlobals.require} }`} from ${JSON.stringify(
+	return `import ${
+		namedImport ? `* as ${namedImport}` : `{ ${RuntimeGlobals.require} }`
+	} from ${JSON.stringify(
 		getRelativePath(compilation, chunk, runtimeChunk || chunk)
 	)};\n`;
 }
 
 /**
+ * Gets chunk named import.
  * @param {number} index the index of the chunk
  * @returns {string} the named import to use for the import
  */
@@ -93,7 +100,7 @@ const PLUGIN_NAME = "ModuleChunkFormatPlugin";
 
 class ModuleChunkFormatPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -111,6 +118,7 @@ class ModuleChunkFormatPlugin {
 			);
 			const hooks = getCompilationHooks(compilation);
 			/**
+			 * With dependent chunks.
 			 * @param {Iterable<Chunk>} chunks the chunks to render
 			 * @param {ChunkGraph} chunkGraph the chunk graph
 			 * @param {Chunk=} runtimeChunk the runtime chunk
@@ -178,10 +186,14 @@ class ModuleChunkFormatPlugin {
 				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 				const source = new ConcatSource();
 				source.add(
-					`export const ${RuntimeGlobals.esmId} = ${JSON.stringify(chunk.id)};\n`
+					`export const ${RuntimeGlobals.esmId} = ${JSON.stringify(
+						chunk.id
+					)};\n`
 				);
 				source.add(
-					`export const ${RuntimeGlobals.esmIds} = ${JSON.stringify(chunk.ids)};\n`
+					`export const ${RuntimeGlobals.esmIds} = ${JSON.stringify(
+						chunk.ids
+					)};\n`
 				);
 				source.add(`export const ${RuntimeGlobals.esmModules} = `);
 				source.add(modules);
@@ -198,6 +210,8 @@ class ModuleChunkFormatPlugin {
 				}
 				const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
 				if (runtimeChunk) {
+					const { inlinedEntryModule, inlinedEntrySource } =
+						/** @type {ChunkRenderContext} */ (renderContext);
 					const entrySource = new ConcatSource();
 					entrySource.add(source);
 					entrySource.add(";\n\n// load runtime\n");
@@ -205,12 +219,21 @@ class ModuleChunkFormatPlugin {
 						renderChunkImport(compilation, runtimeChunk, "", chunk)
 					);
 					const startupSource = new ConcatSource();
-					startupSource.add(
-						`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-							`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
-							"moduleId"
-						)}\n`
+					// The `__webpack_exec__` helper is only needed for entries that
+					// are executed through the registry, not for inlined entries.
+					const needExec = entries.some(
+						([module]) =>
+							module !== inlinedEntryModule &&
+							chunkGraph.getModuleSourceTypes(module).has(JAVASCRIPT_TYPE)
 					);
+					if (needExec) {
+						startupSource.add(
+							`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+								`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
+								"moduleId"
+							)}\n`
+						);
+					}
 
 					/** @type {Set<Chunk>} */
 					const loadedChunks = new Set();
@@ -244,18 +267,32 @@ class ModuleChunkFormatPlugin {
 							startupSource.add("\n");
 							startupSource.add(sourceWithDependentChunks);
 						}
-						startupSource.add(
-							`${
-								final ? `var ${RuntimeGlobals.exports} = ` : ""
-							}__webpack_exec__(${JSON.stringify(moduleId)});\n`
-						);
+						if (module === inlinedEntryModule && inlinedEntrySource) {
+							// Inline the entry at the top level so its declarations stay
+							// live ESM bindings (exports appended by `renderStartup`).
+							startupSource.add(
+								`${runtimeTemplate.renderLet()} ${
+									RuntimeGlobals.exports
+								} = {};\n`
+							);
+							startupSource.add(inlinedEntrySource);
+							startupSource.add("\n");
+						} else {
+							startupSource.add(
+								`${
+									final ? `var ${RuntimeGlobals.exports} = ` : ""
+								}__webpack_exec__(${JSON.stringify(moduleId)});\n`
+							);
+						}
 					}
 
 					entrySource.add(
 						hooks.renderStartup.call(
 							startupSource,
 							entries[entries.length - 1][0],
-							renderContext
+							inlinedEntryModule
+								? { ...renderContext, inlined: true, inlinedInIIFE: false }
+								: renderContext
 						)
 					);
 					return entrySource;

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -17,7 +17,7 @@ const PLUGIN_NAME = "ModuleChunkLoadingPlugin";
 
 class ModuleChunkLoadingPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -25,6 +25,7 @@ class ModuleChunkLoadingPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalChunkLoading = compilation.outputOptions.chunkLoading;
 			/**
+			 * Checks whether this module chunk loading plugin is enabled for chunk.
 			 * @param {Chunk} chunk chunk to check
 			 * @returns {boolean} true, when the plugin is enabled for the chunk
 			 */
@@ -39,6 +40,7 @@ class ModuleChunkLoadingPlugin {
 			/** @type {WeakSet<Chunk>} */
 			const onceForChunkSet = new WeakSet();
 			/**
+			 * Handles the hook callback for this code path.
 			 * @param {Chunk} chunk chunk to check
 			 * @param {RuntimeRequirements} set runtime requirements
 			 */
@@ -62,6 +64,9 @@ class ModuleChunkLoadingPlugin {
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.externalInstallChunk)
 				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.analyzableChunkImport)
+				.tap(PLUGIN_NAME, handler);
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.onChunksLoaded)
 				.tap(PLUGIN_NAME, handler);
@@ -81,12 +86,15 @@ class ModuleChunkLoadingPlugin {
 					);
 				});
 
-			// We need public path only when we prefetch/preload chunk or public path is not `auto`
+			// The prefetch/preload handlers build the chunk URL themselves, so they need
+			// the public path and script filename directly — without relying on
+			// `ensureChunkHandlers` to pull them in (an analyzable `import()` may replace it).
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.prefetchChunkHandlers)
 				.tap(PLUGIN_NAME, (chunk, set) => {
 					if (!isEnabledForChunk(chunk)) return;
 					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getChunkScriptFilename);
 				});
 
 			compilation.hooks.runtimeRequirementInTree
@@ -94,6 +102,7 @@ class ModuleChunkLoadingPlugin {
 				.tap(PLUGIN_NAME, (chunk, set) => {
 					if (!isEnabledForChunk(chunk)) return;
 					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getChunkScriptFilename);
 				});
 
 			compilation.hooks.runtimeRequirementInTree
@@ -113,7 +122,6 @@ class ModuleChunkLoadingPlugin {
 				.tap(PLUGIN_NAME, (chunk, set) => {
 					if (!isEnabledForChunk(chunk)) return;
 					set.add(RuntimeGlobals.publicPath);
-					set.add(RuntimeGlobals.loadScript);
 					set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
 					set.add(RuntimeGlobals.moduleCache);
 					set.add(RuntimeGlobals.hmrModuleData);

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -5,7 +5,7 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-const Compilation = require("../Compilation");
+/** @typedef {import("../Compilation")} Compilation */
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
@@ -18,44 +18,33 @@ const {
 } = require("../javascript/JavascriptModulesPlugin");
 const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
+const createHooksRegistry = require("../util/createHooksRegistry");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.41.0
+	 */
+	linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.41.0
+	 */
+	linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+});
+
 /**
- * @typedef {object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ * @typedef {ReturnType<typeof createCompilationHooks>} JsonpCompilationPluginHooks
  */
 
-/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
-const compilationHooksMap = new WeakMap();
-
 class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {JsonpCompilationPluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
-	/**
+	 * Creates an instance of ModuleChunkLoadingRuntimeModule.
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
@@ -65,6 +54,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Returns generated code.
 	 * @private
 	 * @param {Chunk} chunk chunk
 	 * @param {string} rootOutputDir root output directory
@@ -85,6 +75,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -101,6 +92,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const withExternalInstallChunk = this._runtimeRequirements.has(
 			RuntimeGlobals.externalInstallChunk
 		);
+		const withAnalyzableImport = this._runtimeRequirements.has(
+			RuntimeGlobals.analyzableChunkImport
+		);
 		const withLoading = this._runtimeRequirements.has(
 			RuntimeGlobals.ensureChunkHandlers
 		);
@@ -145,6 +139,13 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_module`
 			: undefined;
 
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
+		const installedChunksObject = `{\n${Template.indent(
+			Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 0`).join(
+				",\n"
+			)
+		)}\n}`;
 		return Template.asString([
 			withBaseURI
 				? this._generateBaseUri(chunk, rootOutputDir)
@@ -153,18 +154,14 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			"// object to store loaded and loading chunks",
 			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
 			"// [resolve, Promise] = chunk loading, 0 = chunk loaded",
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 0`).join(
-					",\n"
-				)
-			),
-			"};",
+			`${cst} installedChunks = ${
+				stateExpression
+					? runtimeTemplate.assignOr(stateExpression, installedChunksObject)
+					: installedChunksObject
+			};`,
 			"",
-			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("data", [
+			withLoading || withExternalInstallChunk || withAnalyzableImport
+				? `${cst} installChunk = ${runtimeTemplate.basicFunction("data", [
 						runtimeTemplate.destructureObject(
 							[
 								RuntimeGlobals.esmIds,
@@ -206,7 +203,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							hasJsMatcher !== false
 								? Template.indent([
 										"// import() chunk loading for javascript",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+										`${lt} installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
 										'if(installedChunkData !== 0) { // 0 means "already installed".',
 										Template.indent([
 											"",
@@ -222,7 +219,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 													: `if(${hasJsMatcher("chunkId")}) {`,
 												Template.indent([
 													"// setup Promise in chunk cache",
-													`var promise = ${importFunctionName}(${
+													`${lt} promise = ${importFunctionName}(${
 														compilation.outputOptions.publicPath === "auto"
 															? JSON.stringify(rootOutputDir)
 															: RuntimeGlobals.publicPath
@@ -235,7 +232,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 															"throw e;"
 														]
 													)});`,
-													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
+													`promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
 														"installedChunkData = installedChunks[chunkId] = [resolve]",
 														"resolve"
 													)})])`,
@@ -258,6 +255,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 				? `${
 						RuntimeGlobals.prefetchChunkHandlers
 					}.j = ${runtimeTemplate.basicFunction("chunkId", [
+						// prefetch is a browser-only resource hint; no-op without a DOM (e.g. node side of a universal build)
 						isNeutralPlatform
 							? "if (typeof document === 'undefined') return;"
 							: "",
@@ -270,7 +268,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							"installedChunks[chunkId] = null;",
 							linkPrefetch.call(
 								Template.asString([
-									"var link = document.createElement('link');",
+									`${cst} link = document.createElement('link');`,
 									charset ? "link.charset = 'utf-8';" : "",
 									crossOriginLoading
 										? `link.crossOrigin = ${JSON.stringify(
@@ -298,6 +296,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 				? `${
 						RuntimeGlobals.preloadChunkHandlers
 					}.j = ${runtimeTemplate.basicFunction("chunkId", [
+						// preload is a browser-only resource hint; no-op without a DOM (e.g. node side of a universal build)
 						isNeutralPlatform
 							? "if (typeof document === 'undefined') return;"
 							: "",
@@ -310,7 +309,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							"installedChunks[chunkId] = null;",
 							linkPreload.call(
 								Template.asString([
-									"var link = document.createElement('link');",
+									`${cst} link = document.createElement('link');`,
 									charset ? "link.charset = 'utf-8';" : "",
 									`if (${RuntimeGlobals.scriptNonce}) {`,
 									Template.indent(
@@ -347,6 +346,31 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 					])
 				: "// no external install chunk",
 			"",
+			withAnalyzableImport
+				? `${
+						RuntimeGlobals.analyzableChunkImport
+					} = ${runtimeTemplate.basicFunction("chunkId, importFn", [
+						// A literal `import()` a foreign bundler can follow, wrapped to keep
+						// `ensureChunk` timing and deduplication: resolved chunk → resolve now, in-flight →
+						// reuse its promise, else run `importFn()` and install it.
+						`${lt} installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+						"if(installedChunkData === 0) return Promise.resolve();",
+						"if(installedChunkData) return installedChunkData[1];",
+						`${lt} promise = importFn().then(installChunk, ${runtimeTemplate.basicFunction(
+							"e",
+							[
+								"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+								"throw e;"
+							]
+						)});`,
+						`promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
+							"installedChunkData = installedChunks[chunkId] = [resolve]",
+							"resolve"
+						)})]);`,
+						"return (installedChunkData[1] = promise);"
+					])};`
+				: "// no analyzable chunk import",
+			"",
 			withOnChunkLoad
 				? `${
 						RuntimeGlobals.onChunksLoaded
@@ -365,30 +389,30 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 								"resolve, reject",
 								[
 									"// start update chunk loading",
-									`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
-									`var onResolve = ${runtimeTemplate.basicFunction("obj", [
-										`var updatedModules = obj.${RuntimeGlobals.esmModules};`,
-										`var updatedRuntime = obj.${RuntimeGlobals.esmRuntime};`,
+									`${cst} url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkUpdateScriptFilename}(chunkId);`,
+									`${cst} onResolve = ${runtimeTemplate.basicFunction("obj", [
+										`${cst} updatedModules = obj.${RuntimeGlobals.esmModules};`,
+										`${cst} updatedRuntime = obj.${RuntimeGlobals.esmRuntime};`,
 										"if(updatedRuntime) currentUpdateRuntime.push(updatedRuntime);",
 										"for(var moduleId in updatedModules) {",
 										Template.indent([
 											`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
 											Template.indent([
 												"currentUpdate[moduleId] = updatedModules[moduleId];",
-												"if(updatedModulesList) updatedModulesList.push(moduleId);"
+												`${runtimeTemplate.optionalChaining("updatedModulesList", "push(moduleId)")};`
 											]),
 											"}"
 										]),
 										"}",
 										"resolve(obj);"
 									])};`,
-									`var onReject = ${runtimeTemplate.basicFunction("error", [
-										"var errorMsg = error.message || 'unknown reason';",
+									`${cst} onReject = ${runtimeTemplate.basicFunction("error", [
+										`${cst} errorMsg = error.message || 'unknown reason';`,
 										"error.message = 'Loading hot update chunk ' + chunkId + ' failed.\\n(' + errorMsg + ')';",
 										"error.name = 'ChunkLoadError';",
 										"reject(error);"
 									])}`,
-									`var loadScript = ${runtimeTemplate.basicFunction(
+									`${cst} loadScript = ${runtimeTemplate.basicFunction(
 										"url, onResolve, onReject",
 										[
 											`return ${importFunctionName}(/* webpackIgnore: true */ url).then(onResolve).catch(onReject)`
@@ -423,4 +447,8 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 }
 
+ModuleChunkLoadingRuntimeModule.getCompilationHooks = createHooksRegistry(
+	createCompilationHooks
+);
+
 module.exports = ModuleChunkLoadingRuntimeModule;