webpack 5.84.1 → 5.85.1

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -17,7 +17,9 @@ const {
 } = require("../javascript/JavascriptModulesPlugin");
 const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class ModuleChunkFormatPlugin {
 	/**
@@ -73,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),
@@ -87,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
@@ -124,7 +132,7 @@ class ModuleChunkFormatPlugin {
 								entrySource.add(";\n\n// load runtime\n");
 								entrySource.add(
 									`import ${RuntimeGlobals.require} from ${JSON.stringify(
-										getRelativePath(runtimeChunk)
+										getRelativePath(/** @type {Chunk} */ (runtimeChunk))
 									)};\n`
 								);
 
@@ -143,8 +151,8 @@ 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) {
@@ -166,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
@@ -69,11 +70,10 @@ 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);`;
@@ -83,7 +83,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	 * @returns {string} 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 }
@@ -106,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"
@@ -115,7 +117,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		);
 		const rootOutputDir = getUndoPath(
 			outputName,
-			/** @type {string} */ (this.compilation.outputOptions.path),
+			/** @type {string} */ (compilation.outputOptions.path),
 			true
 		);
 

package/lib/hmr/LazyCompilationPlugin.js

@@ -303,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"),
@@ -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/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]);
@@ -98,7 +98,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/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -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");

package/lib/javascript/BasicEvaluatedExpression.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("./JavascriptParser").Range} Range */
 /** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
 
 const TypeUnknown = 0;
@@ -70,6 +71,8 @@ class BasicEvaluatedExpression {
 		this.getMembers = undefined;
 		/** @type {() => boolean[]} */
 		this.getMembersOptionals = undefined;
+		/** @type {() => Range[]} */
+		this.getMemberRanges = undefined;
 		/** @type {EsTreeNode} */
 		this.expression = undefined;
 	}
@@ -384,14 +387,22 @@ class BasicEvaluatedExpression {
 	 * @param {string | VariableInfoInterface} rootInfo root info
 	 * @param {() => string[]} getMembers members
 	 * @param {() => boolean[]=} getMembersOptionals optional members
+	 * @param {() => Range[]=} getMemberRanges ranges of progressively increasing sub-expressions
 	 * @returns {this} this
 	 */
-	setIdentifier(identifier, rootInfo, getMembers, getMembersOptionals) {
+	setIdentifier(
+		identifier,
+		rootInfo,
+		getMembers,
+		getMembersOptionals,
+		getMemberRanges
+	) {
 		this.type = TypeIdentifier;
 		this.identifier = identifier;
 		this.rootInfo = rootInfo;
 		this.getMembers = getMembers;
 		this.getMembersOptionals = getMembersOptionals;
+		this.getMemberRanges = getMemberRanges;
 		this.sideEffects = true;
 		return this;
 	}

package/lib/javascript/ChunkHelpers.js

@@ -11,8 +11,8 @@ const Entrypoint = require("../Entrypoint");
 
 /**
  * @param {Entrypoint} entrypoint a chunk group
- * @param {Chunk} excludedChunk1 current chunk which is excluded
- * @param {Chunk} excludedChunk2 runtime chunk which is excluded
+ * @param {Chunk=} excludedChunk1 current chunk which is excluded
+ * @param {Chunk=} excludedChunk2 runtime chunk which is excluded
  * @returns {Set<Chunk>} chunks
  */
 const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {

package/lib/javascript/EnableChunkLoadingPlugin.js

@@ -11,6 +11,10 @@
 /** @type {WeakMap<Compiler, Set<ChunkLoadingType>>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @param {Compiler} compiler compiler
+ * @returns {Set<ChunkLoadingType>} enabled types
+ */
 const getEnabledTypes = compiler => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {

package/lib/javascript/JavascriptModulesPlugin.js

@@ -130,8 +130,8 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
  * @property {SyncBailHook<[Module, RenderBootstrapContext], string>} inlineInRuntimeBailout
- * @property {SyncBailHook<[Module, RenderContext], string>} embedInRuntimeBailout
- * @property {SyncBailHook<[RenderContext], string>} strictRuntimeBailout
+ * @property {SyncBailHook<[Module, RenderContext], string | void>} embedInRuntimeBailout
+ * @property {SyncBailHook<[RenderContext], string | void>} strictRuntimeBailout
  * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
  * @property {SyncBailHook<[Chunk, RenderContext], boolean>} useSourceMap
  */
@@ -691,6 +691,7 @@ class JavascriptModulesPlugin {
 		);
 
 		const hasEntryModules = chunkGraph.getNumberOfEntryModules(chunk) > 0;
+		/** @type {Set<Module> | undefined} */
 		let inlinedModules;
 		if (bootstrap.allowInlineStartup && hasEntryModules) {
 			inlinedModules = new Set(chunkGraph.getChunkEntryModulesIterable(chunk));
@@ -732,7 +733,9 @@ class JavascriptModulesPlugin {
 		const chunkModules = Template.renderChunkModules(
 			chunkRenderContext,
 			inlinedModules
-				? allModules.filter(m => !inlinedModules.has(m))
+				? allModules.filter(
+						m => !(/** @type {Set<Module>} */ (inlinedModules).has(m))
+				  )
 				: allModules,
 			module => this.renderModule(module, chunkRenderContext, hooks, true),
 			prefix
@@ -798,7 +801,7 @@ class JavascriptModulesPlugin {
 			}
 			const lastInlinedModule = last(inlinedModules);
 			const startupSource = new ConcatSource();
-			startupSource.add(`var __webpack_exports__ = {};\n`);
+			startupSource.add(`var ${RuntimeGlobals.exports} = {};\n`);
 			for (const m of inlinedModules) {
 				const renderedModule = this.renderModule(
 					m,
@@ -814,7 +817,7 @@ class JavascriptModulesPlugin {
 					);
 					const exports = runtimeRequirements.has(RuntimeGlobals.exports);
 					const webpackExports =
-						exports && m.exportsArgument === "__webpack_exports__";
+						exports && m.exportsArgument === RuntimeGlobals.exports;
 					let iife = innerStrict
 						? "it need to be in strict mode."
 						: inlinedModules.size > 1
@@ -846,9 +849,9 @@ class JavascriptModulesPlugin {
 					if (exports) {
 						if (m !== lastInlinedModule)
 							startupSource.add(`var ${m.exportsArgument} = {};\n`);
-						else if (m.exportsArgument !== "__webpack_exports__")
+						else if (m.exportsArgument !== RuntimeGlobals.exports)
 							startupSource.add(
-								`var ${m.exportsArgument} = __webpack_exports__;\n`
+								`var ${m.exportsArgument} = ${RuntimeGlobals.exports};\n`
 							);
 					}
 					startupSource.add(renderedModule);
@@ -857,7 +860,7 @@ class JavascriptModulesPlugin {
 			}
 			if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
 				startupSource.add(
-					`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);\n`
+					`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});\n`
 				);
 			}
 			source.add(
@@ -909,7 +912,7 @@ class JavascriptModulesPlugin {
 			hasEntryModules &&
 			runtimeRequirements.has(RuntimeGlobals.returnExportsFromRuntime)
 		) {
-			source.add(`${prefix}return __webpack_exports__;\n`);
+			source.add(`${prefix}return ${RuntimeGlobals.exports};\n`);
 		}
 		if (iife) {
 			source.add("/******/ })()\n");
@@ -1158,7 +1161,7 @@ class JavascriptModulesPlugin {
 					}
 					if (chunks.length > 0) {
 						buf2.push(
-							`${i === 0 ? "var __webpack_exports__ = " : ""}${
+							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.onChunksLoaded
 							}(undefined, ${JSON.stringify(
 								chunks.map(c => c.id)
@@ -1168,22 +1171,22 @@ class JavascriptModulesPlugin {
 						);
 					} else if (useRequire) {
 						buf2.push(
-							`${i === 0 ? "var __webpack_exports__ = " : ""}${
+							`${i === 0 ? `var ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.require
 							}(${moduleIdExpr});`
 						);
 					} else {
-						if (i === 0) buf2.push("var __webpack_exports__ = {};");
+						if (i === 0) buf2.push(`var ${RuntimeGlobals.exports} = {};`);
 						if (requireScopeUsed) {
 							buf2.push(
 								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
+									i === 0 ? RuntimeGlobals.exports : "{}"
 								}, ${RuntimeGlobals.require});`
 							);
 						} else if (entryRuntimeRequirements.has(RuntimeGlobals.exports)) {
 							buf2.push(
 								`__webpack_modules__[${moduleIdExpr}](0, ${
-									i === 0 ? "__webpack_exports__" : "{}"
+									i === 0 ? RuntimeGlobals.exports : "{}"
 								});`
 							);
 						} else {
@@ -1193,7 +1196,7 @@ class JavascriptModulesPlugin {
 				}
 				if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
 					buf2.push(
-						`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);`
+						`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});`
 					);
 				}
 				if (
@@ -1206,13 +1209,13 @@ class JavascriptModulesPlugin {
 					buf.push(
 						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction("", [
 							...buf2,
-							"return __webpack_exports__;"
+							`return ${RuntimeGlobals.exports};`
 						])};`
 					);
 					buf.push("");
 					startup.push("// run startup");
 					startup.push(
-						`var __webpack_exports__ = ${RuntimeGlobals.startup}();`
+						`var ${RuntimeGlobals.exports} = ${RuntimeGlobals.startup}();`
 					);
 				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
 					buf.push("// the startup function");
@@ -1260,7 +1263,9 @@ class JavascriptModulesPlugin {
 				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
 			);
 			startup.push("// run startup");
-			startup.push(`var __webpack_exports__ = ${RuntimeGlobals.startup}();`);
+			startup.push(
+				`var ${RuntimeGlobals.exports} = ${RuntimeGlobals.startup}();`
+			);
 		}
 		return result;
 	}
@@ -1346,7 +1351,7 @@ class JavascriptModulesPlugin {
 				? Template.asString([
 						"",
 						"// Flag the module as loaded",
-						"module.loaded = true;",
+						`${RuntimeGlobals.moduleLoaded} = true;`,
 						""
 				  ])
 				: "",