webpack 5.85.0 → 5.88.1

package/lib/dependencies/RequireResolveHeaderDependency.js

@@ -38,6 +38,10 @@ class RequireResolveHeaderDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {RequireResolveHeaderDependency} RequireResolveHeaderDependency
+	 */
 	static deserialize(context) {
 		const obj = new RequireResolveHeaderDependency(context.read());
 		obj.deserialize(context);
@@ -64,6 +68,11 @@ RequireResolveHeaderDependency.Template = class RequireResolveHeaderDependencyTe
 		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
 	}
 
+	/**
+	 * @param {string} name name
+	 * @param {RequireResolveHeaderDependency} dep dependency
+	 * @param {ReplaceSource} source source
+	 */
 	applyAsTemplateArgument(name, dep, source) {
 		source.replace(dep.range[0], dep.range[1] - 1, "/*require.resolve*/");
 	}

package/lib/dependencies/SystemPlugin.js

@@ -22,7 +22,9 @@ const SystemRuntimeModule = require("./SystemRuntimeModule");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const PLUGIN_NAME = "SystemPlugin";
 
@@ -58,6 +60,9 @@ class SystemPlugin {
 						return;
 					}
 
+					/**
+					 * @param {string} name name
+					 */
 					const setNotSupported = name => {
 						parser.hooks.evaluateTypeof
 							.for(name)
@@ -97,17 +102,21 @@ class SystemPlugin {
 					setNotSupported("System.register");
 
 					parser.hooks.expression.for("System").tap(PLUGIN_NAME, expr => {
-						const dep = new ConstDependency(RuntimeGlobals.system, expr.range, [
-							RuntimeGlobals.system
-						]);
-						dep.loc = expr.loc;
+						const dep = new ConstDependency(
+							RuntimeGlobals.system,
+							/** @type {Range} */ (expr.range),
+							[RuntimeGlobals.system]
+						);
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						parser.state.module.addPresentationalDependency(dep);
 						return true;
 					});
 
 					parser.hooks.call.for("System.import").tap(PLUGIN_NAME, expr => {
 						parser.state.module.addWarning(
-							new SystemImportDeprecationWarning(expr.loc)
+							new SystemImportDeprecationWarning(
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
 						);
 
 						return parser.hooks.importCall.call({
@@ -133,6 +142,9 @@ class SystemPlugin {
 }
 
 class SystemImportDeprecationWarning extends WebpackError {
+	/**
+	 * @param {DependencyLocation} loc location
+	 */
 	constructor(loc) {
 		super(
 			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +

package/lib/dependencies/SystemRuntimeModule.js

@@ -15,7 +15,7 @@ class SystemRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		return Template.asString([

package/lib/dependencies/URLDependency.js

@@ -42,7 +42,7 @@ class URLDependency extends ModuleDependency {
 		this.range = range;
 		this.outerRange = outerRange;
 		this.relative = relative || false;
-		/** @type {Set<string> | boolean} */
+		/** @type {Set<string> | boolean | undefined} */
 		this.usedByExports = undefined;
 	}
 
@@ -68,7 +68,7 @@ class URLDependency extends ModuleDependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @returns {Module | null} a module
 	 */
 	createIgnoredModule(context) {
 		const RawDataUrlModule = getRawDataUrlModule();

package/lib/dependencies/URLPlugin.js

@@ -18,9 +18,11 @@ const URLDependency = require("./URLDependency");
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const PLUGIN_NAME = "URLPlugin";
 
@@ -94,7 +96,7 @@ class URLPlugin {
 
 							return new BasicEvaluatedExpression()
 								.setString(url.toString())
-								.setRange(expr.range);
+								.setRange(/** @type {Range} */ (expr.range));
 						});
 					parser.hooks.new.for("URL").tap(PLUGIN_NAME, _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
@@ -106,11 +108,14 @@ class URLPlugin {
 						const [arg1, arg2] = expr.arguments;
 						const dep = new URLDependency(
 							request,
-							[arg1.range[0], arg2.range[1]],
-							expr.range,
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg2.range)[1]
+							],
+							/** @type {Range} */ (expr.range),
 							relative
 						);
-						dep.loc = expr.loc;
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						parser.state.current.addDependency(dep);
 						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 						return true;

package/lib/dependencies/WebAssemblyImportDependency.js

@@ -55,7 +55,7 @@ class WebAssemblyImportDependency extends ModuleDependency {
 	/**
 	 * Returns errors
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
+	 * @returns {WebpackError[] | null | undefined} errors
 	 */
 	getErrors(moduleGraph) {
 		const module = moduleGraph.getModule(this);

package/lib/dependencies/WorkerPlugin.js

@@ -25,20 +25,32 @@ const {
 } = require("./HarmonyImportDependencyParserPlugin");
 const WorkerDependency = require("./WorkerDependency");
 
+/** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").ChunkLoading} ChunkLoading */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OutputModule} OutputModule */
+/** @typedef {import("../../declarations/WebpackOptions").WasmLoading} WasmLoading */
+/** @typedef {import("../../declarations/WebpackOptions").WorkerPublicPath} WorkerPublicPath */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
+/**
+ * @param {NormalModule} module module
+ * @returns {string} url
+ */
 const getUrl = module => {
 	return pathToFileURL(module.resource).toString();
 };
@@ -58,6 +70,12 @@ const workerIndexMap = new WeakMap();
 const PLUGIN_NAME = "WorkerPlugin";
 
 class WorkerPlugin {
+	/**
+	 * @param {ChunkLoading} chunkLoading chunk loading
+	 * @param {WasmLoading} wasmLoading wasm loading
+	 * @param {OutputModule} module output module
+	 * @param {WorkerPublicPath} workerPublicPath worker public path
+	 */
 	constructor(chunkLoading, wasmLoading, module, workerPublicPath) {
 		this._chunkLoading = chunkLoading;
 		this._wasmLoading = wasmLoading;
@@ -99,7 +117,7 @@ class WorkerPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
+				 * @returns {[BasicEvaluatedExpression, [number, number]] | void} parsed
 				 */
 				const parseModuleUrl = (parser, expr) => {
 					if (
@@ -116,13 +134,19 @@ class WorkerPlugin {
 					const arg2Value = parser.evaluateExpression(arg2);
 					if (
 						!arg2Value.isString() ||
-						!arg2Value.string.startsWith("file://") ||
+						!(/** @type {string} */ (arg2Value.string).startsWith("file://")) ||
 						arg2Value.string !== getUrl(parser.state.module)
 					) {
 						return;
 					}
 					const arg1Value = parser.evaluateExpression(arg1);
-					return [arg1Value, [arg1.range[0], arg2.range[1]]];
+					return [
+						arg1Value,
+						[
+							/** @type {Range} */ (arg1.range)[0],
+							/** @type {Range} */ (arg2.range)[1]
+						]
+					];
 				};
 
 				/**
@@ -182,6 +206,10 @@ class WorkerPlugin {
 					const options = !Array.isArray(parserOptions.worker)
 						? ["..."]
 						: parserOptions.worker;
+					/**
+					 * @param {CallExpression} expr expression
+					 * @returns {boolean | void} true when handled
+					 */
 					const handleNewWorker = expr => {
 						if (expr.arguments.length === 0 || expr.arguments.length > 2)
 							return;
@@ -209,10 +237,12 @@ class WorkerPlugin {
 									values: {},
 									spread: false,
 									insertType: arg2 ? "spread" : "argument",
-									insertLocation: arg2 ? arg2.range : arg1.range[1]
+									insertLocation: arg2
+										? /** @type {Range} */ (arg2.range)
+										: /** @type {Range} */ (arg1.range)[1]
 							  };
 						const { options: importOptions, errors: commentErrors } =
-							parser.parseCommentOptions(expr.range);
+							parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 						if (commentErrors) {
 							for (const e of commentErrors) {
@@ -235,7 +265,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -252,7 +282,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -267,7 +297,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -310,18 +340,22 @@ class WorkerPlugin {
 							}
 						});
 						block.loc = expr.loc;
-						const dep = new WorkerDependency(url.string, range, {
-							publicPath: this._workerPublicPath
-						});
-						dep.loc = expr.loc;
+						const dep = new WorkerDependency(
+							/** @type {string} */ (url.string),
+							range,
+							{
+								publicPath: this._workerPublicPath
+							}
+						);
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
 
 						if (compilation.outputOptions.trustedTypes) {
 							const dep = new CreateScriptUrlDependency(
-								expr.arguments[0].range
+								/** @type {Range} */ (expr.arguments[0].range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addDependency(dep);
 						}
 
@@ -330,9 +364,9 @@ class WorkerPlugin {
 							if (options.type !== false) {
 								const dep = new ConstDependency(
 									this._module ? '"module"' : "undefined",
-									expr.range
+									/** @type {Range} */ (expr.range)
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 								expressions.type = undefined;
 							}
@@ -342,20 +376,20 @@ class WorkerPlugin {
 									`, type: ${this._module ? '"module"' : "undefined"}`,
 									insertLocation
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 							}
 						} else if (insertType === "spread") {
 							const dep1 = new ConstDependency(
 								"Object.assign({}, ",
-								insertLocation[0]
+								/** @type {Range} */ (insertLocation)[0]
 							);
 							const dep2 = new ConstDependency(
 								`, { type: ${this._module ? '"module"' : "undefined"} })`,
-								insertLocation[1]
+								/** @type {Range} */ (insertLocation)[1]
 							);
-							dep1.loc = expr.loc;
-							dep2.loc = expr.loc;
+							dep1.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep2.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep1);
 							parser.state.module.addPresentationalDependency(dep2);
 						} else if (insertType === "argument") {
@@ -364,7 +398,7 @@ class WorkerPlugin {
 									', { type: "module" }',
 									insertLocation
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 							}
 						}
@@ -382,6 +416,9 @@ class WorkerPlugin {
 
 						return true;
 					};
+					/**
+					 * @param {string} item item
+					 */
 					const processItem = item => {
 						if (
 							item.startsWith("*") &&

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -20,7 +20,7 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		return `export default ${RuntimeGlobals.require};`;

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -80,7 +80,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);

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/ids/HashedModuleIdsPlugin.js

@@ -36,7 +36,7 @@ class HashedModuleIdsPlugin {
 
 		/** @type {HashedModuleIdsPluginOptions} */
 		this.options = {
-			context: null,
+			context: undefined,
 			hashFunction: "md4",
 			hashDigest: "base64",
 			hashDigestLength: 4,

package/lib/ids/SyncModuleIdsPlugin.js

@@ -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) {

package/lib/javascript/BasicEvaluatedExpression.js

@@ -5,7 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("./JavascriptParser").Range} Range */
 /** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
 
 const TypeUnknown = 0;
@@ -26,7 +27,7 @@ const TypeBigInt = 13;
 class BasicEvaluatedExpression {
 	constructor() {
 		this.type = TypeUnknown;
-		/** @type {[number, number]} */
+		/** @type {[number, number] | undefined} */
 		this.range = undefined;
 		/** @type {boolean} */
 		this.falsy = false;
@@ -56,23 +57,23 @@ class BasicEvaluatedExpression {
 		this.items = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.options = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
+		/** @type {BasicEvaluatedExpression | undefined | null} */
 		this.prefix = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
+		/** @type {BasicEvaluatedExpression | undefined | null} */
 		this.postfix = undefined;
-		/** @type {BasicEvaluatedExpression[]} */
+		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.wrappedInnerExpressions = undefined;
 		/** @type {string | VariableInfoInterface | undefined} */
 		this.identifier = undefined;
-		/** @type {string | VariableInfoInterface} */
+		/** @type {string | VariableInfoInterface | undefined} */
 		this.rootInfo = undefined;
-		/** @type {() => string[]} */
+		/** @type {(() => string[]) | undefined} */
 		this.getMembers = undefined;
-		/** @type {() => boolean[]} */
+		/** @type {(() => boolean[]) | undefined} */
 		this.getMembersOptionals = undefined;
-		/** @type {() => number[]} */
-		this.getMemberRangeStarts = undefined;
-		/** @type {EsTreeNode} */
+		/** @type {(() => Range[]) | undefined} */
+		this.getMemberRanges = undefined;
+		/** @type {Node | undefined} */
 		this.expression = undefined;
 	}
 
@@ -292,7 +293,9 @@ class BasicEvaluatedExpression {
 		if (this.isRegExp()) return `${this.regExp}`;
 		if (this.isArray()) {
 			let array = [];
-			for (const item of this.items) {
+			for (const item of /** @type {BasicEvaluatedExpression[]} */ (
+				this.items
+			)) {
 				const itemStr = item.asString();
 				if (itemStr === undefined) return undefined;
 				array.push(itemStr);
@@ -302,7 +305,9 @@ class BasicEvaluatedExpression {
 		if (this.isConstArray()) return `${this.array}`;
 		if (this.isTemplateString()) {
 			let str = "";
-			for (const part of this.parts) {
+			for (const part of /** @type {BasicEvaluatedExpression[]} */ (
+				this.parts
+			)) {
 				const partStr = part.asString();
 				if (partStr === undefined) return undefined;
 				str += partStr;
@@ -312,6 +317,10 @@ class BasicEvaluatedExpression {
 		return undefined;
 	}
 
+	/**
+	 * @param {string} string value
+	 * @returns {BasicEvaluatedExpression} basic evaluated expression
+	 */
 	setString(string) {
 		this.type = TypeString;
 		this.string = string;
@@ -386,7 +395,7 @@ class BasicEvaluatedExpression {
 	 * @param {string | VariableInfoInterface} rootInfo root info
 	 * @param {() => string[]} getMembers members
 	 * @param {() => boolean[]=} getMembersOptionals optional members
-	 * @param {() => number[]=} getMemberRangeStarts range start of progressively increasing sub-expressions
+	 * @param {() => Range[]=} getMemberRanges ranges of progressively increasing sub-expressions
 	 * @returns {this} this
 	 */
 	setIdentifier(
@@ -394,14 +403,14 @@ class BasicEvaluatedExpression {
 		rootInfo,
 		getMembers,
 		getMembersOptionals,
-		getMemberRangeStarts
+		getMemberRanges
 	) {
 		this.type = TypeIdentifier;
 		this.identifier = identifier;
 		this.rootInfo = rootInfo;
 		this.getMembers = getMembers;
 		this.getMembersOptionals = getMembersOptionals;
-		this.getMemberRangeStarts = getMemberRangeStarts;
+		this.getMemberRanges = getMemberRanges;
 		this.sideEffects = true;
 		return this;
 	}
@@ -409,8 +418,8 @@ class BasicEvaluatedExpression {
 	/**
 	 * Wraps an array of expressions with a prefix and postfix expression.
 	 *
-	 * @param {BasicEvaluatedExpression | null} prefix Expression to be added before the innerExpressions
-	 * @param {BasicEvaluatedExpression} postfix Expression to be added after the innerExpressions
+	 * @param {BasicEvaluatedExpression | null | undefined} prefix Expression to be added before the innerExpressions
+	 * @param {BasicEvaluatedExpression | null | undefined} postfix Expression to be added after the innerExpressions
 	 * @param {BasicEvaluatedExpression[]} innerExpressions Expressions to be wrapped
 	 * @returns {this} this
 	 */
@@ -550,7 +559,7 @@ class BasicEvaluatedExpression {
 	/**
 	 * Set the expression node for the expression.
 	 *
-	 * @param {EsTreeNode} expression expression
+	 * @param {Node | undefined} expression expression
 	 * @returns {this} this
 	 */
 	setExpression(expression) {

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -17,7 +17,9 @@ const {
 	updateHashForEntryStartup
 } = require("./StartupHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class CommonJsChunkFormatPlugin {
 	/**
@@ -66,7 +68,9 @@ class CommonJsChunkFormatPlugin {
 							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),
@@ -83,7 +87,7 @@ class CommonJsChunkFormatPlugin {
 										compilation.outputOptions
 									),
 									{
-										chunk: runtimeChunk,
+										chunk: /** @type {Chunk} */ (runtimeChunk),
 										contentHashType: "javascript"
 									}
 								)

package/lib/javascript/JavascriptModulesPlugin.js

@@ -60,14 +60,27 @@ const chunkHasJs = (chunk, chunkGraph) => {
 		: false;
 };
 
+/**
+ * @param {Module} module a module
+ * @param {string} code the code
+ * @returns {string} generated code for the stack
+ */
 const printGeneratedCodeForStack = (module, code) => {
 	const lines = code.split("\n");
 	const n = `${lines.length}`.length;
 	return `\n\nGenerated code for ${module.identifier()}\n${lines
-		.map((line, i, lines) => {
-			const iStr = `${i + 1}`;
-			return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
-		})
+		.map(
+			/**
+			 * @param {string} line the line
+			 * @param {number} i the index
+			 * @param {string[]} lines the lines
+			 * @returns {string} the line with line number
+			 */
+			(line, i, lines) => {
+				const iStr = `${i + 1}`;
+				return `${" ".repeat(n - iStr.length)}${iStr} | ${line}`;
+			}
+		)
 		.join("\n")}`;
 };
 
@@ -443,7 +456,10 @@ class JavascriptModulesPlugin {
 							context.__webpack_require__
 						);
 					} catch (e) {
-						e.stack += printGeneratedCodeForStack(options.module, code);
+						e.stack += printGeneratedCodeForStack(
+							options.module,
+							/** @type {string} */ (code)
+						);
 						throw e;
 					}
 				});
@@ -937,6 +953,7 @@ class JavascriptModulesPlugin {
 				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
 			);
 		}
+
 		finalSource = InitFragment.addToSource(
 			finalSource,
 			chunkRenderContext.chunkInitFragments,
@@ -1006,6 +1023,9 @@ class JavascriptModulesPlugin {
 		const useRequire =
 			requireFunction || interceptModuleExecution || moduleUsed;
 
+		/**
+		 * @type {{startup: string[], beforeStartup: string[], header: string[], afterStartup: string[], allowInlineStartup: boolean}}
+		 */
 		const result = {
 			header: [],
 			beforeStartup: [],