webpack 5.90.3 → 5.92.0

package/lib/ModuleFilenameHelpers.js

@@ -46,11 +46,13 @@ ModuleFilenameHelpers.REGEXP_HASH = /\[hash\]/gi;
 ModuleFilenameHelpers.NAMESPACE = "[namespace]";
 ModuleFilenameHelpers.REGEXP_NAMESPACE = /\[namespace\]/gi;
 
+/** @typedef {() => string} ReturnStringCallback */
+
 /**
  * Returns a function that returns the part of the string after the token
- * @param {() => string} strFn the function to get the string
+ * @param {ReturnStringCallback} strFn the function to get the string
  * @param {string} token the token to search for
- * @returns {() => string} a function that returns the part of the string after the token
+ * @returns {ReturnStringCallback} a function that returns the part of the string after the token
  */
 const getAfter = (strFn, token) => {
 	return () => {
@@ -62,9 +64,9 @@ const getAfter = (strFn, token) => {
 
 /**
  * Returns a function that returns the part of the string before the token
- * @param {() => string} strFn the function to get the string
+ * @param {ReturnStringCallback} strFn the function to get the string
  * @param {string} token the token to search for
- * @returns {() => string} a function that returns the part of the string before the token
+ * @returns {ReturnStringCallback} a function that returns the part of the string before the token
  */
 const getBefore = (strFn, token) => {
 	return () => {
@@ -76,11 +78,11 @@ const getBefore = (strFn, token) => {
 
 /**
  * Returns a function that returns a hash of the string
- * @param {() => string} strFn the function to get the string
- * @param {string | Hash} hashFunction the hash function to use
- * @returns {() => string} a function that returns the hash of the string
+ * @param {ReturnStringCallback} strFn the function to get the string
+ * @param {string | Hash=} hashFunction the hash function to use
+ * @returns {ReturnStringCallback} a function that returns the hash of the string
  */
-const getHash = (strFn, hashFunction) => {
+const getHash = (strFn, hashFunction = "md4") => {
 	return () => {
 		const hash = createHash(hashFunction);
 		hash.update(strFn());
@@ -115,8 +117,8 @@ const asRegExp = test => {
  * @template T
  * Returns a lazy object. The object is lazy in the sense that the properties are
  * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
- * @param {Record<string, () => T>} obj the object to covert to a lazy access object
- * @returns {Object} the lazy access object
+ * @param {Record<string, () => T>} obj the object to convert to a lazy access object
+ * @returns {object} the lazy access object
  */
 const lazyObject = obj => {
 	const newObj = {};
@@ -144,10 +146,10 @@ const SQUARE_BRACKET_TAG_REGEXP = /\[\\*([\w-]+)\\*\]/gi;
  *
  * @param {Module | string} module the module
  * @param {TODO} options options
- * @param {Object} contextInfo context info
+ * @param {object} contextInfo context info
  * @param {RequestShortener} contextInfo.requestShortener requestShortener
  * @param {ChunkGraph} contextInfo.chunkGraph chunk graph
- * @param {string | Hash} contextInfo.hashFunction the hash function to use
+ * @param {string | Hash=} contextInfo.hashFunction the hash function to use
  * @returns {string} the filename
  */
 ModuleFilenameHelpers.createFilename = (
@@ -167,11 +169,16 @@ ModuleFilenameHelpers.createFilename = (
 
 	let absoluteResourcePath;
 	let hash;
+	/** @type {ReturnStringCallback} */
 	let identifier;
+	/** @type {ReturnStringCallback} */
 	let moduleId;
+	/** @type {ReturnStringCallback} */
 	let shortIdentifier;
 	if (typeof module === "string") {
-		shortIdentifier = memoize(() => requestShortener.shorten(module));
+		shortIdentifier =
+			/** @type {ReturnStringCallback} */
+			(memoize(() => requestShortener.shorten(module)));
 		identifier = shortIdentifier;
 		moduleId = () => "";
 		absoluteResourcePath = () => module.split("!").pop();
@@ -180,15 +187,21 @@ ModuleFilenameHelpers.createFilename = (
 		shortIdentifier = memoize(() =>
 			module.readableIdentifier(requestShortener)
 		);
-		identifier = memoize(() => requestShortener.shorten(module.identifier()));
-		moduleId = () => chunkGraph.getModuleId(module);
+		identifier =
+			/** @type {ReturnStringCallback} */
+			(memoize(() => requestShortener.shorten(module.identifier())));
+		moduleId =
+			/** @type {ReturnStringCallback} */
+			(() => chunkGraph.getModuleId(module));
 		absoluteResourcePath = () =>
 			module instanceof NormalModule
 				? module.resource
 				: module.identifier().split("!").pop();
 		hash = getHash(identifier, hashFunction);
 	}
-	const resource = memoize(() => shortIdentifier().split("!").pop());
+	const resource =
+		/** @type {ReturnStringCallback} */
+		(memoize(() => shortIdentifier().split("!").pop()));
 
 	const loaders = getBefore(shortIdentifier, "!");
 	const allLoaders = getBefore(identifier, "!");
@@ -249,7 +262,7 @@ ModuleFilenameHelpers.createFilename = (
 	]);
 
 	// TODO webpack 6: consider removing weird double placeholders
-	return opts.moduleFilenameTemplate
+	return /** @type {string} */ (opts.moduleFilenameTemplate)
 		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
 		.replace(
 			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,

package/lib/ModuleGraph.js

@@ -89,13 +89,16 @@ const getConnectionsByModule = set => {
 	return map;
 };
 
+/** @typedef {SortableSet<ModuleGraphConnection>} IncomingConnections */
+/** @typedef {SortableSet<ModuleGraphConnection>} OutgoingConnections */
+
 class ModuleGraphModule {
 	constructor() {
-		/** @type {SortableSet<ModuleGraphConnection>} */
+		/** @type {IncomingConnections} */
 		this.incomingConnections = new SortableSet();
-		/** @type {SortableSet<ModuleGraphConnection> | undefined} */
+		/** @type {OutgoingConnections | undefined} */
 		this.outgoingConnections = undefined;
-		/** @type {Module | null} */
+		/** @type {Module | null | undefined} */
 		this.issuer = undefined;
 		/** @type {(string | OptimizationBailoutFunction)[]} */
 		this.optimizationBailout = [];
@@ -107,31 +110,47 @@ class ModuleGraphModule {
 		this.postOrderIndex = null;
 		/** @type {number | null} */
 		this.depth = null;
-		/** @type {ModuleProfile | undefined | null} */
+		/** @type {ModuleProfile | undefined} */
 		this.profile = undefined;
 		/** @type {boolean} */
 		this.async = false;
-		/** @type {ModuleGraphConnection[]} */
+		/** @type {ModuleGraphConnection[] | undefined} */
 		this._unassignedConnections = undefined;
 	}
 }
 
 class ModuleGraph {
 	constructor() {
-		/** @type {WeakMap<Dependency, ModuleGraphConnection | null>} */
+		/**
+		 * @type {WeakMap<Dependency, ModuleGraphConnection | null>}
+		 * @private
+		 */
 		this._dependencyMap = new WeakMap();
-		/** @type {Map<Module, ModuleGraphModule>} */
+		/**
+		 * @type {Map<Module, ModuleGraphModule>}
+		 * @private
+		 */
 		this._moduleMap = new Map();
-		/** @type {WeakMap<any, Object>} */
+		/**
+		 * @type {WeakMap<any, object>}
+		 * @private
+		 */
 		this._metaMap = new WeakMap();
-
-		/** @type {WeakTupleMap<any[], any> | undefined} */
+		/**
+		 * @type {WeakTupleMap<any[], any> | undefined}
+		 * @private
+		 */
 		this._cache = undefined;
-
-		/** @type {Map<Module, WeakTupleMap<any, any>>} */
+		/**
+		 * @type {Map<Module, WeakTupleMap<any, any>> | undefined}
+		 * @private
+		 */
 		this._moduleMemCaches = undefined;
 
-		/** @type {string | undefined} */
+		/**
+		 * @type {string | undefined}
+		 * @private
+		 */
 		this._cacheStage = undefined;
 	}
 
@@ -163,7 +182,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency
-	 * @returns {Module} parent module
+	 * @returns {Module | undefined} parent module
 	 */
 	getParentModule(dependency) {
 		return dependency._parentModule;
@@ -171,7 +190,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Dependency} dependency the dependency
-	 * @returns {DependenciesBlock} parent block
+	 * @returns {DependenciesBlock | undefined} parent block
 	 */
 	getParentBlock(dependency) {
 		return dependency._parentDependenciesBlock;
@@ -186,7 +205,7 @@ class ModuleGraph {
 	}
 
 	/**
-	 * @param {Module} originModule the referencing module
+	 * @param {Module | null} originModule the referencing module
 	 * @param {Dependency} dependency the referencing dependency
 	 * @param {Module} module the referenced module
 	 * @returns {void}
@@ -231,8 +250,11 @@ class ModuleGraph {
 		newConnection.module = module;
 		this._dependencyMap.set(dependency, newConnection);
 		connection.setActive(false);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.add(newConnection);
+		const originMgm = this._getModuleGraphModule(
+			/** @type {Module} */ (connection.originModule)
+		);
+		/** @type {OutgoingConnections} */
+		(originMgm.outgoingConnections).add(newConnection);
 		const targetMgm = this._getModuleGraphModule(module);
 		targetMgm.incomingConnections.add(newConnection);
 	}
@@ -242,11 +264,16 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	removeConnection(dependency) {
-		const connection = this.getConnection(dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(this.getConnection(dependency));
 		const targetMgm = this._getModuleGraphModule(connection.module);
 		targetMgm.incomingConnections.delete(connection);
-		const originMgm = this._getModuleGraphModule(connection.originModule);
-		originMgm.outgoingConnections.delete(connection);
+		const originMgm = this._getModuleGraphModule(
+			/** @type {Module} */ (connection.originModule)
+		);
+		/** @type {OutgoingConnections} */
+		(originMgm.outgoingConnections).delete(connection);
 		this._dependencyMap.set(dependency, null);
 	}
 
@@ -256,7 +283,9 @@ class ModuleGraph {
 	 * @returns {void}
 	 */
 	addExplanation(dependency, explanation) {
-		const connection = this.getConnection(dependency);
+		const connection =
+			/** @type {ModuleGraphConnection} */
+			(this.getConnection(dependency));
 		connection.addExplanation(explanation);
 	}
 
@@ -468,7 +497,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {readonly Map<Module | undefined, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
+	 * @returns {readonly Map<Module | undefined | null, readonly ModuleGraphConnection[]>} reasons why a module is included, in a map by source module
 	 */
 	getIncomingConnectionsByOriginModule(module) {
 		const connections = this._getModuleGraphModule(module).incomingConnections;
@@ -488,7 +517,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {ModuleProfile | null} the module profile
+	 * @returns {ModuleProfile | undefined} the module profile
 	 */
 	getProfile(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -497,7 +526,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @param {ModuleProfile | null} profile the module profile
+	 * @param {ModuleProfile | undefined} profile the module profile
 	 * @returns {void}
 	 */
 	setProfile(module, profile) {
@@ -507,7 +536,7 @@ class ModuleGraph {
 
 	/**
 	 * @param {Module} module the module
-	 * @returns {Module | null} the issuer module
+	 * @returns {Module | null | undefined} the issuer module
 	 */
 	getIssuer(module) {
 		const mgm = this._getModuleGraphModule(module);
@@ -728,20 +757,20 @@ class ModuleGraph {
 
 	/**
 	 * @param {any} thing any thing
-	 * @returns {Object} metadata
+	 * @returns {object} metadata
 	 */
 	getMeta(thing) {
 		let meta = this._metaMap.get(thing);
 		if (meta === undefined) {
 			meta = Object.create(null);
-			this._metaMap.set(thing, /** @type {Object} */ (meta));
+			this._metaMap.set(thing, /** @type {object} */ (meta));
 		}
-		return /** @type {Object} */ (meta);
+		return /** @type {object} */ (meta);
 	}
 
 	/**
 	 * @param {any} thing any thing
-	 * @returns {Object | undefined} metadata
+	 * @returns {object | undefined} metadata
 	 */
 	getMetaIfExisting(thing) {
 		return this._metaMap.get(thing);
@@ -789,7 +818,7 @@ class ModuleGraph {
 		const fn = args.pop();
 		if (this._moduleMemCaches && this._cacheStage) {
 			const memCache = this._moduleMemCaches.get(
-				this.getParentModule(dependency)
+				/** @type {Module} */ (this.getParentModule(dependency))
 			);
 			if (memCache !== undefined) {
 				return memCache.provide(dependency, this._cacheStage, ...args, () =>

package/lib/ModuleGraphConnection.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
@@ -56,7 +57,7 @@ class ModuleGraphConnection {
 	 * @param {Module} module the referenced module
 	 * @param {string=} explanation some extra detail
 	 * @param {boolean=} weak the reference is weak
-	 * @param {false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState=} condition condition for the connection
+	 * @param {false | null | GetConditionFn | undefined} condition condition for the connection
 	 */
 	constructor(
 		originModule,

package/lib/MultiCompiler.js

@@ -11,6 +11,7 @@ const { SyncHook, MultiHook } = require("tapable");
 const ConcurrentCompilationError = require("./ConcurrentCompilationError");
 const MultiStats = require("./MultiStats");
 const MultiWatching = require("./MultiWatching");
+const WebpackError = require("./WebpackError");
 const ArrayQueue = require("./util/ArrayQueue");
 
 /** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
@@ -28,7 +29,7 @@ const ArrayQueue = require("./util/ArrayQueue");
 /**
  * @template T
  * @callback Callback
- * @param {(Error | null)=} err
+ * @param {Error | null} err
  * @param {T=} result
  */
 
@@ -39,7 +40,7 @@ const ArrayQueue = require("./util/ArrayQueue");
  */
 
 /**
- * @typedef {Object} MultiCompilerOptions
+ * @typedef {object} MultiCompilerOptions
  * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
  */
 
@@ -50,9 +51,11 @@ module.exports = class MultiCompiler {
 	 */
 	constructor(compilers, options) {
 		if (!Array.isArray(compilers)) {
+			/** @type {Compiler[]} */
 			compilers = Object.keys(compilers).map(name => {
-				compilers[name].name = name;
-				return compilers[name];
+				/** @type {Record<string, Compiler>} */
+				(compilers)[name].name = name;
+				return /** @type {Record<string, Compiler>} */ (compilers)[name];
 			});
 		}
 
@@ -107,6 +110,40 @@ module.exports = class MultiCompiler {
 				}
 			});
 		}
+		this._validateCompilersOptions();
+	}
+
+	_validateCompilersOptions() {
+		if (this.compilers.length < 2) return;
+		/**
+		 * @param {Compiler} compiler compiler
+		 * @param {WebpackError} warning warning
+		 */
+		const addWarning = (compiler, warning) => {
+			compiler.hooks.thisCompilation.tap("MultiCompiler", compilation => {
+				compilation.warnings.push(warning);
+			});
+		};
+		const cacheNames = new Set();
+		for (const compiler of this.compilers) {
+			if (compiler.options.cache && "name" in compiler.options.cache) {
+				const name = compiler.options.cache.name;
+				if (cacheNames.has(name)) {
+					addWarning(
+						compiler,
+						new WebpackError(
+							`${
+								compiler.name
+									? `Compiler with name "${compiler.name}" doesn't use unique cache name. `
+									: ""
+							}Please set unique "cache.name" option. Name "${name}" already used.`
+						)
+					);
+				} else {
+					cacheNames.add(name);
+				}
+			}
+		}
 	}
 
 	get options() {
@@ -221,10 +258,19 @@ module.exports = class MultiCompiler {
 			}
 			return false;
 		};
+		/**
+		 * @param {{source: Compiler, target: Compiler}} e1 edge 1
+		 * @param {{source: Compiler, target: Compiler}} e2 edge 2
+		 * @returns {number} result
+		 */
 		const sortEdges = (e1, e2) => {
 			return (
-				e1.source.name.localeCompare(e2.source.name) ||
-				e1.target.name.localeCompare(e2.target.name)
+				/** @type {string} */
+				(e1.source.name).localeCompare(
+					/** @type {string} */ (e2.source.name)
+				) ||
+				/** @type {string} */
+				(e1.target.name).localeCompare(/** @type {string} */ (e2.target.name))
 			);
 		};
 		for (const source of this.compilers) {
@@ -290,6 +336,9 @@ module.exports = class MultiCompiler {
 		 * @returns {boolean} when dependency was fulfilled
 		 */
 		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		/**
+		 * @returns {Compiler[]} compilers
+		 */
 		const getReadyCompilers = () => {
 			let readyCompilers = [];
 			let list = remainingCompilers;
@@ -311,7 +360,7 @@ module.exports = class MultiCompiler {
 		 * @returns {void}
 		 */
 		const runCompilers = callback => {
-			if (remainingCompilers.length === 0) return callback();
+			if (remainingCompilers.length === 0) return callback(null);
 			asyncLib.map(
 				getReadyCompilers(),
 				(compiler, callback) => {
@@ -321,7 +370,9 @@ module.exports = class MultiCompiler {
 						runCompilers(callback);
 					});
 				},
-				/** @type {Callback<TODO>} */ (callback)
+				(err, results) => {
+					callback(err, /** @type {TODO} */ (results));
+				}
 			);
 		};
 		runCompilers(callback);
@@ -602,7 +653,9 @@ module.exports = class MultiCompiler {
 			(compiler, callback) => {
 				compiler.close(callback);
 			},
-			callback
+			error => {
+				callback(error);
+			}
 		);
 	}
 };

package/lib/NodeStuffPlugin.js

@@ -32,6 +32,7 @@ const { parseResource } = require("./util/identifier");
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
 const PLUGIN_NAME = "NodeStuffPlugin";
 
@@ -193,7 +194,11 @@ class NodeStuffPlugin {
 								break;
 							case true:
 								setModuleConstant("__filename", module =>
-									relative(compiler.inputFileSystem, context, module.resource)
+									relative(
+										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+										context,
+										module.resource
+									)
 								);
 								break;
 						}
@@ -227,7 +232,11 @@ class NodeStuffPlugin {
 								break;
 							case true:
 								setModuleConstant("__dirname", module =>
-									relative(compiler.inputFileSystem, context, module.context)
+									relative(
+										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
+										context,
+										/** @type {string} */ (module.context)
+									)
 								);
 								break;
 						}
@@ -236,7 +245,9 @@ class NodeStuffPlugin {
 							.for("__dirname")
 							.tap(PLUGIN_NAME, expr => {
 								if (!parser.state.module) return;
-								return evaluateToString(parser.state.module.context)(expr);
+								return evaluateToString(
+									/** @type {string} */ (parser.state.module.context)
+								)(expr);
 							});
 					}
 					parser.hooks.expression

package/lib/NormalModule.js

@@ -89,7 +89,7 @@ const memoize = require("./util/memoize");
 /** @typedef {UnsafeCacheData & { parser: undefined | Parser, parserOptions: undefined | ParserOptions, generator: undefined | Generator, generatorOptions: undefined | GeneratorOptions }} NormalModuleUnsafeCacheData */
 
 /**
- * @typedef {Object} SourceMap
+ * @typedef {object} SourceMap
  * @property {number} version
  * @property {string[]} sources
  * @property {string} mappings
@@ -107,7 +107,7 @@ const getValidate = memoize(() => require("schema-utils").validate);
 const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 
 /**
- * @typedef {Object} LoaderItem
+ * @typedef {object} LoaderItem
  * @property {string} loader
  * @property {any} options
  * @property {string?} ident
@@ -117,7 +117,7 @@ const ABSOLUTE_PATH_REGEX = /^([a-zA-Z]:\\|\\\\|\/)/;
 /**
  * @param {string} context absolute context path
  * @param {string} source a source path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {string} new source path
  */
 const contextifySourceUrl = (context, source, associatedObjectForCache) => {
@@ -132,7 +132,7 @@ const contextifySourceUrl = (context, source, associatedObjectForCache) => {
 /**
  * @param {string} context absolute context path
  * @param {SourceMap} sourceMap a source map
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+ * @param {object=} associatedObjectForCache an object to which the cache will be attached
  * @returns {SourceMap} new source map
  */
 const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
@@ -199,7 +199,7 @@ makeSerializable(
 );
 
 /**
- * @typedef {Object} NormalModuleCompilationHooks
+ * @typedef {object} NormalModuleCompilationHooks
  * @property {SyncHook<[object, NormalModule]>} loader
  * @property {SyncHook<[LoaderItem[], NormalModule, object]>} beforeLoaders
  * @property {SyncHook<[NormalModule]>} beforeParse
@@ -210,7 +210,7 @@ makeSerializable(
  */
 
 /**
- * @typedef {Object} NormalModuleCreateData
+ * @typedef {object} NormalModuleCreateData
  * @property {string=} layer an optional layer in which the module is
  * @property {JavaScriptModuleTypes | ""} type module type. When deserializing, this is set to an empty string "".
  * @property {string} request request string
@@ -344,12 +344,12 @@ class NormalModule extends Module {
 		/**
 		 * @private
 		 * @type {Map<string, number> | undefined}
-		 **/
+		 */
 		this._sourceSizes = undefined;
 		/**
 		 * @private
 		 * @type {undefined | SourceTypes}
-		 **/
+		 */
 		this._sourceTypes = undefined;
 
 		// Cache
@@ -499,7 +499,7 @@ class NormalModule extends Module {
 	 * @param {string} name the asset name
 	 * @param {string | Buffer} content the content
 	 * @param {(string | SourceMap)=} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {object=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSourceForAsset(
@@ -776,7 +776,7 @@ class NormalModule extends Module {
 	 * @param {string} context the compilation context
 	 * @param {string | Buffer} content the content
 	 * @param {(string | SourceMapSource)=} sourceMap an optional source map
-	 * @param {Object=} associatedObjectForCache object for caching
+	 * @param {object=} associatedObjectForCache object for caching
 	 * @returns {Source} the created source
 	 */
 	createSource(context, content, sourceMap, associatedObjectForCache) {
@@ -926,6 +926,8 @@ class NormalModule extends Module {
 				loaderContext._compilation =
 					loaderContext._compiler =
 					loaderContext._module =
+					// eslint-disable-next-line no-warning-comments
+					// @ts-ignore
 					loaderContext.fs =
 						undefined;
 
@@ -1325,7 +1327,6 @@ class NormalModule extends Module {
 		moduleGraph,
 		chunkGraph,
 		runtime,
-		runtimes,
 		concatenationScope,
 		codeGenerationResults,
 		sourceTypes
@@ -1352,14 +1353,13 @@ class NormalModule extends Module {
 				? new RawSource(
 						"throw new Error(" + JSON.stringify(this.error.message) + ");"
 					)
-				: this.generator.generate(this, {
+				: /** @type {Generator} */ (this.generator).generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,
 						moduleGraph,
 						chunkGraph,
 						runtimeRequirements,
 						runtime,
-						runtimes,
 						concatenationScope,
 						codeGenerationResults,
 						getData,