webpack 5.76.1 → 5.88.2

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -11,12 +11,15 @@ const HotUpdateChunk = require("../HotUpdateChunk");
 const Template = require("../Template");
 const { getAllChunks } = require("../javascript/ChunkHelpers");
 const {
+	chunkHasJs,
 	getCompilationHooks,
 	getChunkFilenameTemplate
 } = require("../javascript/JavascriptModulesPlugin");
 const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class ModuleChunkFormatPlugin {
 	/**
@@ -72,7 +75,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),
@@ -86,6 +91,10 @@ class ModuleChunkFormatPlugin {
 								// remove filename, we only need the directory
 								currentOutputName.pop();
 
+								/**
+								 * @param {Chunk} chunk the chunk
+								 * @returns {string} the relative path
+								 */
 								const getRelativePath = chunk => {
 									const baseOutputName = currentOutputName.slice();
 									const chunkOutputName = compilation
@@ -122,15 +131,15 @@ class ModuleChunkFormatPlugin {
 								entrySource.add(source);
 								entrySource.add(";\n\n// load runtime\n");
 								entrySource.add(
-									`import __webpack_require__ from ${JSON.stringify(
-										getRelativePath(runtimeChunk)
+									`import ${RuntimeGlobals.require} from ${JSON.stringify(
+										getRelativePath(/** @type {Chunk} */ (runtimeChunk))
 									)};\n`
 								);
 
 								const startupSource = new ConcatSource();
 								startupSource.add(
 									`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-										`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+										`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
 										"moduleId"
 									)}\n`
 								);
@@ -142,12 +151,16 @@ class ModuleChunkFormatPlugin {
 									const final = i + 1 === entries.length;
 									const moduleId = chunkGraph.getModuleId(module);
 									const chunks = getAllChunks(
-										entrypoint,
-										runtimeChunk,
+										/** @type {Entrypoint} */ (entrypoint),
+										/** @type {Chunk} */ (runtimeChunk),
 										undefined
 									);
 									for (const chunk of chunks) {
-										if (loadedChunks.has(chunk)) continue;
+										if (
+											loadedChunks.has(chunk) ||
+											!chunkHasJs(chunk, chunkGraph)
+										)
+											continue;
 										loadedChunks.add(chunk);
 										startupSource.add(
 											`import * as __webpack_chunk_${index}__ from ${JSON.stringify(
@@ -161,7 +174,7 @@ class ModuleChunkFormatPlugin {
 									}
 									startupSource.add(
 										`${
-											final ? "var __webpack_exports__ = " : ""
+											final ? `var ${RuntimeGlobals.exports} = ` : ""
 										}__webpack_exec__(${JSON.stringify(moduleId)});\n`
 									);
 								}

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -9,6 +9,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const ExportWebpackRequireRuntimeModule = require("./ExportWebpackRequireRuntimeModule");
 const ModuleChunkLoadingRuntimeModule = require("./ModuleChunkLoadingRuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 class ModuleChunkLoadingPlugin {
@@ -22,6 +23,10 @@ class ModuleChunkLoadingPlugin {
 			"ModuleChunkLoadingPlugin",
 			compilation => {
 				const globalChunkLoading = compilation.outputOptions.chunkLoading;
+				/**
+				 * @param {Chunk} chunk chunk to check
+				 * @returns {boolean} true, when the plugin is enabled for the chunk
+				 */
 				const isEnabledForChunk = chunk => {
 					const options = chunk.getEntryOptions();
 					const chunkLoading =
@@ -31,6 +36,10 @@ class ModuleChunkLoadingPlugin {
 					return chunkLoading === "import";
 				};
 				const onceForChunkSet = new WeakSet();
+				/**
+				 * @param {Chunk} chunk chunk to check
+				 * @param {Set<string>} set runtime requirements
+				 */
 				const handler = (chunk, set) => {
 					if (onceForChunkSet.has(chunk)) return;
 					onceForChunkSet.add(chunk);

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -18,6 +18,7 @@ const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
 
 /**
  * @typedef {Object} JsonpCompilationPluginHooks
@@ -50,6 +51,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		return hooks;
 	}
 
+	/**
+	 * @param {ReadonlySet<string>} runtimeRequirements runtime requirements
+	 */
 	constructor(runtimeRequirements) {
 		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
 		this._runtimeRequirements = runtimeRequirements;
@@ -66,21 +70,22 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		if (options && options.baseUri) {
 			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
 		}
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
-			compilation: {
-				outputOptions: { importMetaName }
-			}
-		} = this;
+			outputOptions: { importMetaName }
+		} = compilation;
 		return `${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
 			rootOutputDir
 		)}, ${importMetaName}.url);`;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation, chunk, chunkGraph } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const {
 			runtimeTemplate,
 			outputOptions: { importFunctionName }
@@ -103,8 +108,8 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = this.compilation.getPath(
-			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+		const outputName = compilation.getPath(
+			getChunkFilenameTemplate(chunk, compilation.outputOptions),
 			{
 				chunk,
 				contentHashType: "javascript"
@@ -112,7 +117,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const rootOutputDir = getUndoPath(
 			outputName,
-			this.compilation.outputOptions.path,
+			/** @type {string} */ (compilation.outputOptions.path),
 			true
 		);
 
@@ -127,7 +132,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			"",
 			"// object to store loaded and loading chunks",
 			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			"// [resolve, Promise] = chunk loading, 0 = chunk loaded",
 			`var installedChunks = ${
 				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
 			}{`,
@@ -156,7 +161,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							"}"
 						]),
 						"}",
-						"if(runtime) runtime(__webpack_require__);",
+						`if(runtime) runtime(${RuntimeGlobals.require});`,
 						"for(;i < ids.length; i++) {",
 						Template.indent([
 							"chunkId = ids[i];",
@@ -210,7 +215,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 													)})])`,
 													`promises.push(installedChunkData[1] = promise);`
 												]),
-												"} else installedChunks[chunkId] = 0;"
+												hasJsMatcher === true
+													? "}"
+													: "} else installedChunks[chunkId] = 0;"
 											]),
 											"}"
 										]),

package/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -14,7 +14,7 @@ class HotModuleReplacementRuntimeModule extends RuntimeModule {
 		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		return Template.getFunctionContent(

package/lib/hmr/LazyCompilationPlugin.js

@@ -10,6 +10,9 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
 const ModuleFactory = require("../ModuleFactory");
+const {
+	WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
@@ -95,7 +98,11 @@ registerNotSerializable(LazyCompilationDependency);
 
 class LazyCompilationProxyModule extends Module {
 	constructor(context, originalModule, request, client, data, active) {
-		super("lazy-compilation-proxy", context, originalModule.layer);
+		super(
+			WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY,
+			context,
+			originalModule.layer
+		);
 		this.originalModule = originalModule;
 		this.request = request;
 		this.client = client;
@@ -107,7 +114,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
-		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}|${this.originalModule.identifier()}`;
 	}
 
 	/**
@@ -115,7 +122,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY} ${this.originalModule.readableIdentifier(
 			requestShortener
 		)}`;
 	}
@@ -142,7 +149,9 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
-		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
+		return `${this.originalModule.libIdent(
+			options
+		)}!${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}`;
 	}
 
 	/**
@@ -294,7 +303,7 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/ids/ChunkModuleIdRangePlugin.js

@@ -13,7 +13,18 @@ const {
 
 /** @typedef {import("../Compiler")} Compiler */
 
+/**
+ * @typedef {Object} ChunkModuleIdRangePluginOptions
+ * @property {string} name the chunk name
+ * @property {("index" | "index2" | "preOrderIndex" | "postOrderIndex")=} order order
+ * @property {number=} start start id
+ * @property {number=} end end id
+ */
+
 class ChunkModuleIdRangePlugin {
+	/**
+	 * @param {ChunkModuleIdRangePluginOptions} options options object
+	 */
 	constructor(options) {
 		this.options = options;
 	}

package/lib/ids/DeterministicChunkIdsPlugin.js

@@ -15,9 +15,18 @@ const {
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {Object} DeterministicChunkIdsPluginOptions
+ * @property {string=} context context for ids
+ * @property {number=} maxLength maximum length of ids
+ */
+
 class DeterministicChunkIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {DeterministicChunkIdsPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -17,15 +17,19 @@ const {
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {Object} DeterministicModuleIdsPluginOptions
+ * @property {string=} context context relative to which module identifiers are computed
+ * @property {function(Module): boolean=} test selector function for modules
+ * @property {number=} maxLength maximum id length in digits (used as starting point)
+ * @property {number=} salt hash salt for ids
+ * @property {boolean=} fixedLength do not increase the maxLength to find an optimal id space size
+ * @property {boolean=} failOnConflict throw an error when id conflicts occur (instead of rehashing)
+ */
+
 class DeterministicModuleIdsPlugin {
 	/**
-	 * @param {Object} options options
-	 * @param {string=} options.context context relative to which module identifiers are computed
-	 * @param {function(Module): boolean=} options.test selector function for modules
-	 * @param {number=} options.maxLength maximum id length in digits (used as starting point)
-	 * @param {number=} options.salt hash salt for ids
-	 * @param {boolean=} options.fixedLength do not increase the maxLength to find an optimal id space size
-	 * @param {boolean=} options.failOnConflict throw an error when id conflicts occur (instead of rehashing)
+	 * @param {DeterministicModuleIdsPluginOptions} [options] options
 	 */
 	constructor(options = {}) {
 		this.options = options;

package/lib/ids/HashedModuleIdsPlugin.js

@@ -16,6 +16,7 @@ const {
 } = require("./IdHelpers");
 
 /** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
+/** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/HashedModuleIdsPlugin.check.js"),
@@ -35,7 +36,7 @@ class HashedModuleIdsPlugin {
 
 		/** @type {HashedModuleIdsPluginOptions} */
 		this.options = {
-			context: null,
+			context: undefined,
 			hashFunction: "md4",
 			hashDigest: "base64",
 			hashDigestLength: 4,
@@ -43,6 +44,11 @@ class HashedModuleIdsPlugin {
 		};
 	}
 
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
 	apply(compiler) {
 		const options = this.options;
 		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
@@ -64,7 +70,8 @@ class HashedModuleIdsPlugin {
 						hash.digest(options.hashDigest)
 					);
 					let len = options.hashDigestLength;
-					while (usedIds.has(hashId.slice(0, len))) len++;
+					while (usedIds.has(hashId.slice(0, len)))
+						/** @type {number} */ (len)++;
 					const moduleId = hashId.slice(0, len);
 					chunkGraph.setModuleId(module, moduleId);
 					usedIds.add(moduleId);

package/lib/ids/IdHelpers.js

@@ -427,6 +427,9 @@ const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 	let nextId = 0;
 	let assignId;
 	if (usedIds.size > 0) {
+		/**
+		 * @param {Module} module the module
+		 */
 		assignId = module => {
 			if (chunkGraph.getModuleId(module) === null) {
 				while (usedIds.has(nextId + "")) nextId++;
@@ -434,6 +437,9 @@ const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 			}
 		};
 	} else {
+		/**
+		 * @param {Module} module the module
+		 */
 		assignId = module => {
 			if (chunkGraph.getModuleId(module) === null) {
 				chunkGraph.setModuleId(module, nextId++);

package/lib/ids/NamedChunkIdsPlugin.js

@@ -14,11 +14,21 @@ const {
 	assignAscendingChunkIds
 } = require("./IdHelpers");
 
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {Object} NamedChunkIdsPluginOptions
+ * @property {string} [context] context
+ * @property {string} [delimiter] delimiter
+ */
+
 class NamedChunkIdsPlugin {
+	/**
+	 * @param {NamedChunkIdsPluginOptions=} options options
+	 */
 	constructor(options) {
 		this.delimiter = (options && options.delimiter) || "-";
 		this.context = options && options.context;
@@ -31,7 +41,9 @@ class NamedChunkIdsPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("NamedChunkIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
+			const hashFunction =
+				/** @type {NonNullable<Output["hashFunction"]>} */
+				(compilation.outputOptions.hashFunction);
 			compilation.hooks.chunkIds.tap("NamedChunkIdsPlugin", chunks => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.context ? this.context : compiler.context;

package/lib/ids/NamedModuleIdsPlugin.js

@@ -14,12 +14,21 @@ const {
 	assignAscendingModuleIds
 } = require("./IdHelpers");
 
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 
+/**
+ * @typedef {Object} NamedModuleIdsPluginOptions
+ * @property {string} [context] context
+ */
+
 class NamedModuleIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {NamedModuleIdsPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -30,7 +39,9 @@ class NamedModuleIdsPlugin {
 	apply(compiler) {
 		const { root } = compiler;
 		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
-			const { hashFunction } = compilation.outputOptions;
+			const hashFunction =
+				/** @type {NonNullable<Output["hashFunction"]>} */
+				(compilation.outputOptions.hashFunction);
 			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context

package/lib/ids/OccurrenceChunkIdsPlugin.js

@@ -60,8 +60,12 @@ class OccurrenceChunkIdsPlugin {
 
 				const chunksInOccurrenceOrder = Array.from(chunks).sort((a, b) => {
 					if (prioritiseInitial) {
-						const aEntryOccurs = occursInInitialChunksMap.get(a);
-						const bEntryOccurs = occursInInitialChunksMap.get(b);
+						const aEntryOccurs =
+							/** @type {number} */
+							(occursInInitialChunksMap.get(a));
+						const bEntryOccurs =
+							/** @type {number} */
+							(occursInInitialChunksMap.get(b));
 						if (aEntryOccurs > bEntryOccurs) return -1;
 						if (aEntryOccurs < bEntryOccurs) return 1;
 					}

package/lib/ids/OccurrenceModuleIdsPlugin.js

@@ -81,7 +81,7 @@ class OccurrenceModuleIdsPlugin {
 					] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
 						if (!originModule) continue;
 						if (!connections.some(c => c.isTargetActive(undefined))) continue;
-						sum += initialChunkChunkMap.get(originModule);
+						sum += initialChunkChunkMap.get(originModule) || 0;
 					}
 					return sum;
 				};

package/lib/ids/SyncModuleIdsPlugin.js

@@ -50,7 +50,7 @@ class SyncModuleIdsPlugin {
 						}
 						return callback();
 					}
-					const json = JSON.parse(buffer.toString());
+					const json = JSON.parse(/** @type {Buffer} */ (buffer).toString());
 					data = new Map();
 					for (const key of Object.keys(json)) {
 						data.set(key, json[key]);
@@ -63,6 +63,7 @@ class SyncModuleIdsPlugin {
 		if (this._write) {
 			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
 				if (!data || !dataChanged) return callback();
+				/** @type {Object<string, string | number>} */
 				const json = {};
 				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
 				for (const [key, value] of sorted) {
@@ -98,7 +99,7 @@ class SyncModuleIdsPlugin {
 							err.module = module;
 							compilation.errors.push(err);
 						}
-						chunkGraph.setModuleId(module, id);
+						chunkGraph.setModuleId(module, /** @type {string | number} */ (id));
 						usedIds.add(idAsString);
 					}
 				});

package/lib/index.js

@@ -11,8 +11,14 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
 /** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemFunctionData} ExternalItemFunctionData */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectKnown} ExternalItemObjectKnown */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemObjectUnknown} ExternalItemObjectUnknown */
+/** @typedef {import("../declarations/WebpackOptions").ExternalItemValue} ExternalItemValue */
+/** @typedef {import("../declarations/WebpackOptions").Externals} Externals */
 /** @typedef {import("../declarations/WebpackOptions").FileCacheOptions} FileCacheOptions */
 /** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../declarations/WebpackOptions").MemoryCacheOptions} MemoryCacheOptions */
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").RuleSetCondition} RuleSetCondition */
@@ -25,12 +31,14 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Compilation").Asset} Asset */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compilation").EntryOptions} EntryOptions */
 /** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
 /** @typedef {import("./MultiStats")} MultiStats */
+/** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
 /** @typedef {import("./Parser").ParserState} ParserState */
 /** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
 /** @typedef {import("./ResolverFactory").Resolver} Resolver */

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -84,8 +84,8 @@ class ArrayPushCallbackChunkFormatPlugin {
 							if (runtimeModules.length > 0 || entries.length > 0) {
 								const runtime = new ConcatSource(
 									(runtimeTemplate.supportsArrowFunction()
-										? "__webpack_require__ =>"
-										: "function(__webpack_require__)") +
+										? `${RuntimeGlobals.require} =>`
+										: `function(${RuntimeGlobals.require})`) +
 										" { // webpackRuntimeModules\n"
 								);
 								if (runtimeModules.length > 0) {
@@ -121,7 +121,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 											.getChunkRuntimeRequirements(chunk)
 											.has(RuntimeGlobals.returnExportsFromRuntime)
 									) {
-										runtime.add("return __webpack_exports__;\n");
+										runtime.add(`return ${RuntimeGlobals.exports};\n`);
 									}
 								}
 								runtime.add("}\n");