webpack 5.104.1 → 5.105.1

package/lib/ids/HashedModuleIdsPlugin.js

@@ -53,7 +53,6 @@ class HashedModuleIdsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const options = this.options;
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.moduleIds.tap(PLUGIN_NAME, () => {
 				const chunkGraph = compilation.chunkGraph;
@@ -67,14 +66,10 @@ class HashedModuleIdsPlugin {
 				);
 				for (const module of modulesInNaturalOrder) {
 					const ident = getFullModuleName(module, context, compiler.root);
-					const hash = createHash(
-						/** @type {NonNullable<HashedModuleIdsPluginOptions["hashFunction"]>} */ (
-							options.hashFunction
-						)
-					);
+					const hash = createHash(this.options.hashFunction);
 					hash.update(ident || "");
-					const hashId = hash.digest(options.hashDigest);
-					let len = options.hashDigestLength;
+					const hashId = hash.digest(this.options.hashDigest);
+					let len = this.options.hashDigestLength;
 					while (usedIds.has(hashId.slice(0, len))) {
 						/** @type {number} */ (len)++;
 					}

package/lib/ids/IdHelpers.js

@@ -13,14 +13,14 @@ const numberHash = require("../util/numberHash");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
-/** @typedef {typeof import("../util/Hash")} Hash */
+/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 /** @typedef {import("../util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 
 /**
  * @param {string} str string to hash
  * @param {number} len max length of the hash
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
  */
 const getHash = (str, len, hashFunction) => {
@@ -56,12 +56,12 @@ const avoidNumber = (str) => {
  * @returns {string} id representation
  */
 const requestToId = (request) =>
-	request.replace(/^(\.\.?\/)+/, "").replace(/(^[.-]|[^a-zA-Z0-9_-])+/g, "_");
+	request.replace(/^(\.\.?\/)+/, "").replace(/(^[.-]|[^a-z0-9_-])+/gi, "_");
 
 /**
  * @param {string} string the string
  * @param {string} delimiter separator for string and hash
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @returns {string} string with limited max length to 100 chars
  */
 const shortenLongString = (string, delimiter, hashFunction) => {
@@ -95,7 +95,7 @@ const getShortModuleName = (module, context, associatedObjectForCache) => {
  * @param {string} shortName the short name
  * @param {Module} module the module
  * @param {string} context context directory
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} long module name
  */
@@ -124,7 +124,7 @@ const getFullModuleName = (module, context, associatedObjectForCache) =>
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
@@ -152,7 +152,7 @@ const getShortChunkName = (
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {string} context context directory
  * @param {string} delimiter delimiter for names
- * @param {string | Hash} hashFunction hash function to use
+ * @param {HashFunction} hashFunction hash function to use
  * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} short chunk name
  */
@@ -231,7 +231,7 @@ const addToMapOfItems = (map, key, value) => {
  */
 const getUsedModuleIdsAndModules = (compilation, filter) => {
 	const chunkGraph = compilation.chunkGraph;
-
+	/** @type {Module[]} */
 	const modules = [];
 
 	/** @type {UsedModuleIds} */
@@ -402,6 +402,7 @@ const assignDeterministicIds = (
 
 	for (const item of items) {
 		const ident = getName(item);
+		/** @type {number} */
 		let id;
 		let i = salt;
 		do {
@@ -420,6 +421,7 @@ const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 	const chunkGraph = compilation.chunkGraph;
 
 	let nextId = 0;
+	/** @type {(mod: Module) => void} */
 	let assignId;
 	if (usedIds.size > 0) {
 		/**

package/lib/ids/NamedChunkIdsPlugin.js

@@ -28,9 +28,9 @@ class NamedChunkIdsPlugin {
 	/**
 	 * @param {NamedChunkIdsPluginOptions=} options options
 	 */
-	constructor(options) {
-		this.delimiter = (options && options.delimiter) || "-";
-		this.context = options && options.context;
+	constructor(options = {}) {
+		/** @type {NamedChunkIdsPluginOptions} */
+		this.options = options;
 	}
 
 	/**
@@ -43,8 +43,10 @@ class NamedChunkIdsPlugin {
 			const hashFunction = compilation.outputOptions.hashFunction;
 			compilation.hooks.chunkIds.tap(PLUGIN_NAME, (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
-				const context = this.context ? this.context : compiler.context;
-				const delimiter = this.delimiter;
+				const context = this.options.context
+					? this.options.context
+					: compiler.context;
+				const delimiter = this.options.delimiter || "-";
 
 				const unnamedChunks = assignNames(
 					[...chunks].filter((chunk) => {

package/lib/ids/NamedModuleIdsPlugin.js

@@ -28,6 +28,7 @@ class NamedModuleIdsPlugin {
 	 * @param {NamedModuleIdsPluginOptions=} options options
 	 */
 	constructor(options = {}) {
+		/** @type {NamedModuleIdsPluginOptions} */
 		this.options = options;
 	}
 

package/lib/ids/OccurrenceChunkIdsPlugin.js

@@ -30,6 +30,7 @@ class OccurrenceChunkIdsPlugin {
 	 */
 	constructor(options = {}) {
 		validate(options);
+		/** @type {OccurrenceChunkIdsPluginOptions} */
 		this.options = options;
 	}
 
@@ -39,7 +40,6 @@ class OccurrenceChunkIdsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const prioritiseInitial = this.options.prioritiseInitial;
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.chunkIds.tap(PLUGIN_NAME, (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
@@ -61,7 +61,7 @@ class OccurrenceChunkIdsPlugin {
 
 				/** @type {Chunk[]} */
 				const chunksInOccurrenceOrder = [...chunks].sort((a, b) => {
-					if (prioritiseInitial) {
+					if (this.options.prioritiseInitial) {
 						const aEntryOccurs =
 							/** @type {number} */
 							(occursInInitialChunksMap.get(a));

package/lib/ids/OccurrenceModuleIdsPlugin.js

@@ -35,6 +35,7 @@ class OccurrenceModuleIdsPlugin {
 	 */
 	constructor(options = {}) {
 		validate(options);
+		/** @type {OccurrenceModuleIdsPluginOptions} */
 		this.options = options;
 	}
 
@@ -44,7 +45,6 @@ class OccurrenceModuleIdsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const prioritiseInitial = this.options.prioritiseInitial;
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			const moduleGraph = compilation.moduleGraph;
 
@@ -54,10 +54,14 @@ class OccurrenceModuleIdsPlugin {
 				const [usedIds, modulesInOccurrenceOrder] =
 					getUsedModuleIdsAndModules(compilation);
 
+				/** @type {Map<Module, number>} */
 				const occursInInitialChunksMap = new Map();
+				/** @type {Map<Module, number>} */
 				const occursInAllChunksMap = new Map();
 
+				/** @type {Map<Module, number>} */
 				const initialChunkChunkMap = new Map();
+				/** @type {Map<Module, number>} */
 				const entryCountMap = new Map();
 				for (const m of modulesInOccurrenceOrder) {
 					let initial = 0;
@@ -111,12 +115,12 @@ class OccurrenceModuleIdsPlugin {
 					return sum;
 				};
 
-				if (prioritiseInitial) {
+				if (this.options.prioritiseInitial) {
 					for (const m of modulesInOccurrenceOrder) {
 						const result =
 							countOccursInEntry(m) +
-							initialChunkChunkMap.get(m) +
-							entryCountMap.get(m);
+							/** @type {number} */ (initialChunkChunkMap.get(m)) +
+							/** @type {number} */ (entryCountMap.get(m));
 						occursInInitialChunksMap.set(m, result);
 					}
 				}
@@ -125,7 +129,7 @@ class OccurrenceModuleIdsPlugin {
 					const result =
 						countOccurs(m) +
 						chunkGraph.getNumberOfModuleChunks(m) +
-						entryCountMap.get(m);
+						/** @type {number} */ (entryCountMap.get(m));
 					occursInAllChunksMap.set(m, result);
 				}
 
@@ -134,14 +138,18 @@ class OccurrenceModuleIdsPlugin {
 				);
 
 				modulesInOccurrenceOrder.sort((a, b) => {
-					if (prioritiseInitial) {
-						const aEntryOccurs = occursInInitialChunksMap.get(a);
-						const bEntryOccurs = occursInInitialChunksMap.get(b);
+					if (this.options.prioritiseInitial) {
+						const aEntryOccurs =
+							/** @type {number} */
+							(occursInInitialChunksMap.get(a));
+						const bEntryOccurs =
+							/** @type {number} */
+							(occursInInitialChunksMap.get(b));
 						if (aEntryOccurs > bEntryOccurs) return -1;
 						if (aEntryOccurs < bEntryOccurs) return 1;
 					}
-					const aOccurs = occursInAllChunksMap.get(a);
-					const bOccurs = occursInAllChunksMap.get(b);
+					const aOccurs = /** @type {number} */ (occursInAllChunksMap.get(a));
+					const bOccurs = /** @type {number} */ (occursInAllChunksMap.get(b));
 					if (aOccurs > bOccurs) return -1;
 					if (aOccurs < bOccurs) return 1;
 					return naturalCompare(a, b);

package/lib/ids/SyncModuleIdsPlugin.js

@@ -13,6 +13,8 @@ const { getUsedModuleIdsAndModules } = require("./IdHelpers");
 /** @typedef {import("../Module").ModuleId} ModuleId */
 /** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
 
+/** @typedef {{ [key: string]: ModuleId }} JSONContent */
+
 const plugin = "SyncModuleIdsPlugin";
 
 /**
@@ -27,14 +29,9 @@ class SyncModuleIdsPlugin {
 	/**
 	 * @param {SyncModuleIdsPluginOptions} options options
 	 */
-	constructor({ path, context, test, mode }) {
-		this._path = path;
-		this._context = context;
-		this._test = test || (() => true);
-		const readAndWrite = !mode || mode === "merge" || mode === "update";
-		this._read = readAndWrite || mode === "read";
-		this._write = readAndWrite || mode === "create";
-		this._prune = mode === "update";
+	constructor(options) {
+		/** @type {SyncModuleIdsPluginOptions} */
+		this.options = options;
 	}
 
 	/**
@@ -46,19 +43,31 @@ class SyncModuleIdsPlugin {
 		/** @type {Map<string, ModuleId>} */
 		let data;
 		let dataChanged = false;
-		if (this._read) {
+
+		const readAndWrite =
+			!this.options.mode ||
+			this.options.mode === "merge" ||
+			this.options.mode === "update";
+
+		const needRead = readAndWrite || this.options.mode === "read";
+		const needWrite = readAndWrite || this.options.mode === "create";
+		const needPrune = this.options.mode === "update";
+
+		if (needRead) {
 			compiler.hooks.readRecords.tapAsync(plugin, (callback) => {
 				const fs =
 					/** @type {IntermediateFileSystem} */
 					(compiler.intermediateFileSystem);
-				fs.readFile(this._path, (err, buffer) => {
+				fs.readFile(this.options.path, (err, buffer) => {
 					if (err) {
 						if (err.code !== "ENOENT") {
 							return callback(err);
 						}
 						return callback();
 					}
+					/** @type {JSONContent} */
 					const json = JSON.parse(/** @type {Buffer} */ (buffer).toString());
+					/** @type {Map<string, string | number | null>} */
 					data = new Map();
 					for (const key of Object.keys(json)) {
 						data.set(key, json[key]);
@@ -68,10 +77,10 @@ class SyncModuleIdsPlugin {
 				});
 			});
 		}
-		if (this._write) {
+		if (needWrite) {
 			compiler.hooks.emitRecords.tapAsync(plugin, (callback) => {
 				if (!data || !dataChanged) return callback();
-				/** @type {{[key: string]: ModuleId}} */
+				/** @type {JSONContent} */
 				const json = {};
 				const sorted = [...data].sort(([a], [b]) => (a < b ? -1 : 1));
 				for (const [key, value] of sorted) {
@@ -80,19 +89,20 @@ class SyncModuleIdsPlugin {
 				const fs =
 					/** @type {IntermediateFileSystem} */
 					(compiler.intermediateFileSystem);
-				fs.writeFile(this._path, JSON.stringify(json), callback);
+				fs.writeFile(this.options.path, JSON.stringify(json), callback);
 			});
 		}
 		compiler.hooks.thisCompilation.tap(plugin, (compilation) => {
 			const associatedObjectForCache = compiler.root;
-			const context = this._context || compiler.context;
-			if (this._read) {
+			const context = this.options.context || compiler.context;
+			const test = this.options.test || (() => true);
+			if (needRead) {
 				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
 					if (!data) return;
 					const { chunkGraph } = compilation;
 					const [usedIds, modules] = getUsedModuleIdsAndModules(
 						compilation,
-						this._test
+						test
 					);
 					for (const module of modules) {
 						const name = module.libIdent({
@@ -104,7 +114,7 @@ class SyncModuleIdsPlugin {
 						const idAsString = `${id}`;
 						if (usedIds.has(idAsString)) {
 							const err = new WebpackError(
-								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
+								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this.options.path}' as it's already used.`
 							);
 							err.module = module;
 							compilation.errors.push(err);
@@ -114,17 +124,17 @@ class SyncModuleIdsPlugin {
 					}
 				});
 			}
-			if (this._write) {
+			if (needWrite) {
 				compilation.hooks.recordModules.tap(plugin, (modules) => {
 					const { chunkGraph } = compilation;
 					let oldData = data;
 					if (!oldData) {
 						oldData = data = new Map();
-					} else if (this._prune) {
+					} else if (needPrune) {
 						data = new Map();
 					}
 					for (const module of modules) {
-						if (this._test(module)) {
+						if (test(module)) {
 							const name = module.libIdent({
 								context,
 								associatedObjectForCache

package/lib/index.js

@@ -33,8 +33,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptions} Configuration */
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
-/** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./webpack").WebpackPluginFunction} WebpackPluginFunction */
+/** @typedef {import("./webpack").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
 /** @typedef {import("./Compilation").Asset} Asset */

package/lib/javascript/BasicEvaluatedExpression.js

@@ -296,6 +296,7 @@ class BasicEvaluatedExpression {
 		if (this.isBigInt()) return `${this.bigint}`;
 		if (this.isRegExp()) return `${this.regExp}`;
 		if (this.isArray()) {
+			/** @type {string[]} */
 			const array = [];
 			for (const item of /** @type {BasicEvaluatedExpression[]} */ (
 				this.items

package/lib/javascript/EnableChunkLoadingPlugin.js

@@ -8,16 +8,19 @@
 /** @typedef {import("../../declarations/WebpackOptions").ChunkLoadingType} ChunkLoadingType */
 /** @typedef {import("../Compiler")} Compiler */
 
-/** @type {WeakMap<Compiler, Set<ChunkLoadingType>>} */
+/** @typedef {Set<ChunkLoadingType>} ChunkLoadingTypes */
+
+/** @type {WeakMap<Compiler, ChunkLoadingTypes>} */
 const enabledTypes = new WeakMap();
 
 /**
  * @param {Compiler} compiler compiler
- * @returns {Set<ChunkLoadingType>} enabled types
+ * @returns {ChunkLoadingTypes} enabled types
  */
 const getEnabledTypes = (compiler) => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {
+		/** @type {ChunkLoadingTypes} */
 		set = new Set();
 		enabledTypes.set(compiler, set);
 	}

package/lib/javascript/JavascriptModulesPlugin.js

@@ -32,7 +32,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
-const { compareModulesByIdOrIdentifier } = require("../util/comparators");
+const { compareModulesByFullName } = require("../util/comparators");
 const {
 	RESERVED_NAMES,
 	addScopeSymbols,
@@ -59,17 +59,21 @@ const JavascriptParser = require("./JavascriptParser");
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compilation").ExecuteModuleObject} ExecuteModuleObject */
+/** @typedef {import("../Compilation").WebpackRequire} WebpackRequire */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/concatenate").ScopeSet} ScopeSet */
+/** @typedef {import("../util/concatenate").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
 
 /**
  * @param {Chunk} chunk a chunk
@@ -278,7 +282,7 @@ class JavascriptModulesPlugin {
 
 	constructor(options = {}) {
 		this.options = options;
-		/** @type {WeakMap<Source, { source: Source, needModule:boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined, renderShorthand: boolean }>} */
+		/** @type {WeakMap<Source, { source: Source, needModule: boolean, needExports: boolean, needRequire: boolean, needThisAsExports: boolean, needStrict: boolean | undefined, renderShorthand: boolean }>} */
 		this._moduleFactoryCache = new WeakMap();
 	}
 
@@ -354,6 +358,7 @@ class JavascriptModulesPlugin {
 							outputOptions
 						);
 
+					/** @type {() => Source} */
 					let render;
 
 					if (hotUpdateChunk) {
@@ -535,6 +540,7 @@ class JavascriptModulesPlugin {
 					const { module } = options;
 					const code = source.source();
 
+					/** @type {(this: ExecuteModuleObject["exports"], exports: ExecuteModuleObject["exports"], moduleObject: ExecuteModuleObject, webpackRequire: WebpackRequire) => void} */
 					const fn = vm.runInThisContext(
 						`(function(${module.moduleArgument}, ${module.exportsArgument}, ${RuntimeGlobals.require}) {\n${code}\n/**/})`,
 						{
@@ -552,7 +558,8 @@ class JavascriptModulesPlugin {
 							moduleObject.exports,
 							moduleObject,
 							moduleObject.exports,
-							context.__webpack_require__
+							/** @type {WebpackRequire} */
+							(context.__webpack_require__)
 						);
 					} catch (err) {
 						/** @type {Error} */
@@ -569,6 +576,7 @@ class JavascriptModulesPlugin {
 					let code = source.source();
 					if (typeof code !== "string") code = code.toString();
 
+					/** @type {(this: null, webpackRequire: WebpackRequire) => void} */
 					const fn = vm.runInThisContext(
 						`(function(${RuntimeGlobals.require}) {\n${code}\n/**/})`,
 						{
@@ -578,7 +586,11 @@ class JavascriptModulesPlugin {
 					);
 					try {
 						// eslint-disable-next-line no-useless-call
-						fn.call(null, context.__webpack_require__);
+						fn.call(
+							null,
+							/** @type {WebpackRequire} */
+							(context.__webpack_require__)
+						);
 					} catch (err) {
 						/** @type {Error} */
 						(err).stack += printGeneratedCodeForStack(options.module, code);
@@ -638,6 +650,7 @@ class JavascriptModulesPlugin {
 					hooks.renderModuleContent.call(moduleSource, module, renderContext),
 				"JavascriptModulesPlugin.getCompilationHooks().renderModuleContent"
 			);
+			/** @type {Source} */
 			let moduleSourcePostContainer;
 			if (factory) {
 				const runtimeRequirements = chunkGraph.getModuleRuntimeRequirements(
@@ -660,6 +673,7 @@ class JavascriptModulesPlugin {
 				);
 				const renderShorthand =
 					renderInObject === true && runtimeTemplate.supportsMethodShorthand();
+				/** @type {Source} */
 				let source;
 				if (
 					cacheEntry &&
@@ -673,6 +687,7 @@ class JavascriptModulesPlugin {
 					source = cacheEntry.source;
 				} else {
 					const factorySource = new ConcatSource();
+					/** @type {string[]} */
 					const args = [];
 					if (needExports || needRequire || needModule) {
 						args.push(
@@ -747,13 +762,14 @@ class JavascriptModulesPlugin {
 	 * @returns {Source} the rendered source
 	 */
 	renderChunk(renderContext, hooks) {
-		const { chunk, chunkGraph } = renderContext;
+		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 		const modules = chunkGraph.getOrderedChunkModulesIterableBySourceType(
 			chunk,
 			JAVASCRIPT_TYPE,
-			compareModulesByIdOrIdentifier(chunkGraph)
+			compareModulesByFullName(runtimeTemplate.compilation.compiler)
 		);
 		const allModules = modules ? [...modules] : [];
+		/** @type {undefined | string} */
 		let strictHeader;
 		let allStrict = renderContext.strictMode;
 		if (
@@ -838,7 +854,7 @@ class JavascriptModulesPlugin {
 			...(chunkGraph.getOrderedChunkModulesIterableBySourceType(
 				chunk,
 				JAVASCRIPT_TYPE,
-				compareModulesByIdOrIdentifier(chunkGraph)
+				compareModulesByFullName(runtimeTemplate.compilation.compiler)
 			) || [])
 		];
 
@@ -850,6 +866,7 @@ class JavascriptModulesPlugin {
 		}
 
 		const source = new ConcatSource();
+		/** @type {string} */
 		let prefix;
 		if (iife) {
 			if (runtimeTemplate.supportsArrowFunction()) {
@@ -1026,6 +1043,7 @@ class JavascriptModulesPlugin {
 						);
 
 				if (renderedModule) {
+					/** @type {string} */
 					let footer;
 					if (iife !== undefined) {
 						startupSource.add(
@@ -1209,7 +1227,7 @@ class JavascriptModulesPlugin {
 			requireFunction || interceptModuleExecution || moduleUsed;
 
 		/**
-		 * @type {{startup: string[], beforeStartup: string[], header: string[], afterStartup: string[], allowInlineStartup: boolean}}
+		 * @type {{ startup: string[], beforeStartup: string[], header: string[], afterStartup: string[], allowInlineStartup: boolean }}
 		 */
 		const result = {
 			header: [],
@@ -1334,6 +1352,7 @@ class JavascriptModulesPlugin {
 						result.allowInlineStartup = false;
 					}
 
+					/** @type {undefined | CodeGenerationResultData} */
 					let data;
 					if (codeGenerationResults.has(entryModule, chunk.runtime)) {
 						const result = codeGenerationResults.get(
@@ -1766,7 +1785,9 @@ class JavascriptModulesPlugin {
 			}
 
 			for (const variable of info.variables) {
+				/** @type {UsedNamesInScopeInfo} */
 				const usedNamesInScopeInfo = new Map();
+				/** @type {ScopeSet} */
 				const ignoredScopes = new Set();
 
 				const name = variable.name;