webpack 5.87.0 → 5.88.0

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -29,8 +29,14 @@ const RequireResolveContextDependency = require("./RequireResolveContextDependen
 const RequireResolveDependency = require("./RequireResolveDependency");
 const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
 
-/** @typedef {import("estree").CallExpression} CallExpressionNode */
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").NewExpression} NewExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const createRequireSpecifierTag = Symbol("createRequire");
 const createdRequireIdentifierTag = Symbol("createRequire()");
@@ -43,6 +49,10 @@ class CommonJsImportsParserPlugin {
 		this.options = options;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
 		const options = this.options;
 
@@ -54,6 +64,10 @@ class CommonJsImportsParserPlugin {
 		};
 
 		//#region metadata
+		/**
+		 * @param {TODO} expression expression
+		 * @param {() => string[]} getMembers get members
+		 */
 		const tapRequireExpression = (expression, getMembers) => {
 			parser.hooks.typeof
 				.for(expression)
@@ -71,6 +85,9 @@ class CommonJsImportsParserPlugin {
 					evaluateToIdentifier(expression, "require", getMembers, true)
 				);
 		};
+		/**
+		 * @param {string | symbol} tag tag
+		 */
 		const tapRequireExpressionTag = tag => {
 			parser.hooks.typeof
 				.for(tag)
@@ -93,7 +110,7 @@ class CommonJsImportsParserPlugin {
 			.tap("CommonJsImportsParserPlugin", expr => {
 				// to not leak to global "require", we need to define a local require here.
 				const dep = new ConstDependency("var require;", 0);
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			});
@@ -138,10 +155,17 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Renaming
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when set undefined
+		 */
 		const defineUndefined = expr => {
 			// To avoid "not defined" error, replace the value with undefined
-			const dep = new ConstDependency("undefined", expr.range);
-			dep.loc = expr.loc;
+			const dep = new ConstDependency(
+				"undefined",
+				/** @type {Range} */ (expr.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			parser.state.module.addPresentationalDependency(dep);
 			return false;
 		};
@@ -170,6 +194,10 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require as expression
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when handled
+		 */
 		const requireAsExpressionHandler = expr => {
 			const dep = new CommonJsRequireContextDependency(
 				{
@@ -178,7 +206,7 @@ class CommonJsImportsParserPlugin {
 					regExp: options.unknownContextRegExp,
 					mode: "sync"
 				},
-				expr.range,
+				/** @type {Range} */ (expr.range),
 				undefined,
 				parser.scope.inShorthand,
 				getContext()
@@ -186,7 +214,7 @@ class CommonJsImportsParserPlugin {
 			dep.critical =
 				options.unknownContextCritical &&
 				"require function is used in a way in which dependencies cannot be statically extracted";
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			dep.optional = !!parser.scope.inTry;
 			parser.state.current.addDependency(dep);
 			return true;
@@ -197,23 +225,33 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require
+		/**
+		 * @param {CallExpression | NewExpression} expr expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @returns {boolean | void} true when handled
+		 */
 		const processRequireItem = (expr, param) => {
 			if (param.isString()) {
 				const dep = new CommonJsRequireDependency(
-					param.string,
-					param.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (param.range),
 					getContext()
 				);
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = !!parser.scope.inTry;
 				parser.state.current.addDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression | NewExpression} expr expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @returns {boolean | void} true when handled
+		 */
 		const processRequireContext = (expr, param) => {
 			const dep = ContextDependencyHelpers.create(
 				CommonJsRequireContextDependency,
-				expr.range,
+				/** @type {Range} */ (expr.range),
 				param,
 				expr,
 				options,
@@ -225,15 +263,19 @@ class CommonJsImportsParserPlugin {
 				getContext()
 			);
 			if (!dep) return;
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			dep.optional = !!parser.scope.inTry;
 			parser.state.current.addDependency(dep);
 			return true;
 		};
+		/**
+		 * @param {boolean} callNew true, when require is called with new
+		 * @returns {(expr: CallExpression | NewExpression) => (boolean | void)} handler
+		 */
 		const createRequireHandler = callNew => expr => {
 			if (options.commonjsMagicComments) {
 				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(expr.range);
+					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 				if (commentErrors) {
 					for (const e of commentErrors) {
@@ -252,7 +294,7 @@ class CommonJsImportsParserPlugin {
 							parser.state.module.addWarning(
 								new UnsupportedFeatureWarning(
 									`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-									expr.loc
+									/** @type {DependencyLocation} */ (expr.loc)
 								)
 							);
 						} else {
@@ -270,26 +312,37 @@ class CommonJsImportsParserPlugin {
 			const param = parser.evaluateExpression(expr.arguments[0]);
 			if (param.isConditional()) {
 				let isExpression = false;
-				for (const p of param.options) {
+				for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+					param.options
+				)) {
 					const result = processRequireItem(expr, p);
 					if (result === undefined) {
 						isExpression = true;
 					}
 				}
 				if (!isExpression) {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
+					const dep = new RequireHeaderDependency(
+						/** @type {Range} */ (expr.callee.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addPresentationalDependency(dep);
 					return true;
 				}
 			}
 			if (
 				param.isString() &&
-				(localModule = getLocalModule(parser.state, param.string))
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */ (param.string)
+				))
 			) {
 				localModule.flagUsed();
-				const dep = new LocalModuleDependency(localModule, expr.range, callNew);
-				dep.loc = expr.loc;
+				const dep = new LocalModuleDependency(
+					localModule,
+					/** @type {Range} */ (expr.range),
+					callNew
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			} else {
@@ -297,8 +350,10 @@ class CommonJsImportsParserPlugin {
 				if (result === undefined) {
 					processRequireContext(expr, param);
 				} else {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
+					const dep = new RequireHeaderDependency(
+						/** @type {Range} */ (expr.callee.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addPresentationalDependency(dep);
 				}
 				return true;
@@ -319,35 +374,59 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require with property access
+		/**
+		 * @param {Expression} expr expression
+		 * @param {string[]} calleeMembers callee members
+		 * @param {CallExpression} callExpr call expression
+		 * @param {string[]} members members
+		 * @returns {boolean | void} true when handled
+		 */
 		const chainHandler = (expr, calleeMembers, callExpr, members) => {
 			if (callExpr.arguments.length !== 1) return;
 			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+			if (
+				param.isString() &&
+				!getLocalModule(parser.state, /** @type {string} */ (param.string))
+			) {
 				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (expr.range),
 					members
 				);
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
 				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.current.addDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression} expr expression
+		 * @param {string[]} calleeMembers callee members
+		 * @param {CallExpression} callExpr call expression
+		 * @param {string[]} members members
+		 * @returns {boolean | void} true when handled
+		 */
 		const callChainHandler = (expr, calleeMembers, callExpr, members) => {
 			if (callExpr.arguments.length !== 1) return;
 			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+			if (
+				param.isString() &&
+				!getLocalModule(parser.state, /** @type {string} */ (param.string))
+			) {
 				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.callee.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (expr.callee.range),
 					members
 				);
 				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
 				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.callee.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.callee.loc);
 				parser.state.current.addDependency(dep);
 				parser.walkExpressions(expr.arguments);
 				return true;
@@ -368,18 +447,27 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require.resolve
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
 		const processResolve = (expr, weak) => {
 			if (expr.arguments.length !== 1) return;
 			const param = parser.evaluateExpression(expr.arguments[0]);
 			if (param.isConditional()) {
-				for (const option of param.options) {
+				for (const option of /** @type {BasicEvaluatedExpression[]} */ (
+					param.options
+				)) {
 					const result = processResolveItem(expr, option, weak);
 					if (result === undefined) {
 						processResolveContext(expr, option, weak);
 					}
 				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
+				const dep = new RequireResolveHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			} else {
@@ -387,30 +475,44 @@ class CommonJsImportsParserPlugin {
 				if (result === undefined) {
 					processResolveContext(expr, param, weak);
 				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
+				const dep = new RequireResolveHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
 		const processResolveItem = (expr, param, weak) => {
 			if (param.isString()) {
 				const dep = new RequireResolveDependency(
-					param.string,
-					param.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (param.range),
 					getContext()
 				);
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = !!parser.scope.inTry;
 				dep.weak = weak;
 				parser.state.current.addDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
 		const processResolveContext = (expr, param, weak) => {
 			const dep = ContextDependencyHelpers.create(
 				RequireResolveContextDependency,
-				param.range,
+				/** @type {Range} */ (param.range),
 				param,
 				expr,
 				options,
@@ -422,7 +524,7 @@ class CommonJsImportsParserPlugin {
 				getContext()
 			);
 			if (!dep) return;
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			dep.optional = !!parser.scope.inTry;
 			parser.state.current.addDependency(dep);
 			return true;
@@ -444,7 +546,9 @@ class CommonJsImportsParserPlugin {
 
 		if (!options.createRequire) return;
 
+		/** @type {ImportSource[]} */
 		let moduleName = [];
+		/** @type {string | undefined} */
 		let specifierName;
 
 		if (options.createRequire === true) {
@@ -481,9 +585,13 @@ class CommonJsImportsParserPlugin {
 					next: undefined
 				});
 				return new BasicEvaluatedExpression()
-					.setIdentifier(ident, ident, () => [])
+					.setIdentifier(
+						/** @type {TODO} */ (ident),
+						/** @type {TODO} */ (ident),
+						() => []
+					)
 					.setSideEffects(false)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		parser.hooks.unhandledExpressionMemberChain
 			.for(createdRequireIdentifierTag)
@@ -509,8 +617,8 @@ class CommonJsImportsParserPlugin {
 			.for(createdRequireIdentifierTag)
 			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
 		/**
-		 * @param {CallExpressionNode} expr call expression
-		 * @returns {string} context
+		 * @param {CallExpression} expr call expression
+		 * @returns {string | void} context
 		 */
 		const parseCreateRequireArguments = expr => {
 			const args = expr.arguments;
@@ -518,7 +626,7 @@ class CommonJsImportsParserPlugin {
 				const err = new WebpackError(
 					"module.createRequire supports only one argument."
 				);
-				err.loc = expr.loc;
+				err.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addWarning(err);
 				return;
 			}
@@ -528,13 +636,13 @@ class CommonJsImportsParserPlugin {
 				const err = new WebpackError(
 					"module.createRequire failed parsing argument."
 				);
-				err.loc = arg.loc;
+				err.loc = /** @type {DependencyLocation} */ (arg.loc);
 				parser.state.module.addWarning(err);
 				return;
 			}
-			const ctx = evaluated.string.startsWith("file://")
-				? fileURLToPath(evaluated.string)
-				: evaluated.string;
+			const ctx = /** @type {string} */ (evaluated.string).startsWith("file://")
+				? fileURLToPath(/** @type {string} */ (evaluated.string))
+				: /** @type {string} */ (evaluated.string);
 			// argument always should be a filename
 			return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith("/") ? "/" : "\\"));
 		};
@@ -556,12 +664,14 @@ class CommonJsImportsParserPlugin {
 				// clear for 'import { createRequire as x } from "module"'
 				// if any other specifier was used import module
 				const clearDep = new ConstDependency(
-					parser.isAsiPosition(statement.range[0]) ? ";" : "",
-					statement.range
+					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+						? ";"
+						: "",
+					/** @type {Range} */ (statement.range)
 				);
-				clearDep.loc = statement.loc;
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
 				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(statement.range[1]);
+				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
 				return true;
 			}
 		);
@@ -586,9 +696,9 @@ class CommonJsImportsParserPlugin {
 					declarator.init.callee.type !== "Identifier"
 				)
 					return;
-				const variableInfo = parser.getVariableInfo(
-					declarator.init.callee.name
-				);
+				const variableInfo =
+					/** @type {TODO} */
+					(parser.getVariableInfo(declarator.init.callee.name));
 				if (
 					variableInfo &&
 					variableInfo.tagInfo &&
@@ -658,9 +768,9 @@ class CommonJsImportsParserPlugin {
 			.tap("CommonJsImportsParserPlugin", expr => {
 				const clearDep = new ConstDependency(
 					"/* createRequire() */ undefined",
-					expr.range
+					/** @type {Range} */ (expr.range)
 				);
-				clearDep.loc = expr.loc;
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(clearDep);
 				return true;
 			});

package/lib/dependencies/CommonJsPlugin.js

@@ -35,7 +35,10 @@ const {
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 
 const PLUGIN_NAME = "CommonJsPlugin";
@@ -199,12 +202,13 @@ class CommonJsPlugin {
 					parser.hooks.expression
 						.for(RuntimeGlobals.moduleLoaded)
 						.tap(PLUGIN_NAME, expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
 								RuntimeGlobals.moduleLoaded;
 							const dep = new RuntimeRequirementsDependency([
 								RuntimeGlobals.moduleLoaded
 							]);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -212,12 +216,13 @@ class CommonJsPlugin {
 					parser.hooks.expression
 						.for(RuntimeGlobals.moduleId)
 						.tap(PLUGIN_NAME, expr => {
-							parser.state.module.buildInfo.moduleConcatenationBailout =
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
 								RuntimeGlobals.moduleId;
 							const dep = new RuntimeRequirementsDependency([
 								RuntimeGlobals.moduleId
 							]);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
@@ -250,10 +255,10 @@ class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
 		return Template.asString([
 			`${
 				RuntimeGlobals.harmonyModuleDecorator
@@ -280,10 +285,10 @@ class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const { runtimeTemplate } = /** @type {Compilation} */ (this.compilation);
 		return Template.asString([
 			`${RuntimeGlobals.nodeModuleDecorator} = ${runtimeTemplate.basicFunction(
 				"module",

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -17,8 +17,8 @@ class CommonJsRequireContextDependency extends ContextDependency {
 	/**
 	 * @param {TODO} options options for the context module
 	 * @param {Range} range location in source code
-	 * @param {Range} valueRange location of the require call
-	 * @param {boolean} inShorthand true, if the require call is in shorthand notation
+	 * @param {Range | undefined} valueRange location of the require call
+	 * @param {boolean | string } inShorthand true or name
 	 * @param {string} context context
 	 */
 	constructor(options, range, valueRange, inShorthand, context) {

package/lib/dependencies/ContextDependency.js

@@ -23,6 +23,10 @@ const getCriticalDependencyWarning = memoize(() =>
 
 /** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
 
+/**
+ * @param {RegExp | null | undefined} r regexp
+ * @returns {string} stringified regexp
+ */
 const regExpToString = r => (r ? r + "" : "");
 
 class ContextDependency extends Dependency {
@@ -35,7 +39,7 @@ class ContextDependency extends Dependency {
 
 		this.options = options;
 		this.userRequest = this.options && this.options.request;
-		/** @type {false | string} */
+		/** @type {false | undefined | string} */
 		this.critical = false;
 		this.hadGlobalOrStickyRegExp = false;
 
@@ -50,6 +54,7 @@ class ContextDependency extends Dependency {
 		this.request = undefined;
 		this.range = undefined;
 		this.valueRange = undefined;
+		/** @type {boolean | string | undefined} */
 		this.inShorthand = undefined;
 		// TODO refactor this
 		this.replaces = undefined;
@@ -93,7 +98,7 @@ class ContextDependency extends Dependency {
 	/**
 	 * Returns warnings
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} warnings
+	 * @returns {WebpackError[] | null | undefined} warnings
 	 */
 	getWarnings(moduleGraph) {
 		let warnings = super.getWarnings(moduleGraph);

package/lib/dependencies/CssImportDependency.js

@@ -74,7 +74,7 @@ class CssImportDependency extends ModuleDependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @returns {Module | null} a module
 	 */
 	createIgnoredModule(context) {
 		return null;

package/lib/dependencies/CssLocalIdentifierDependency.js

@@ -75,6 +75,11 @@ class CssLocalIdentifierDependency extends NullDependency {
 	}
 }
 
+/**
+ * @param {string} str string
+ * @param {string | boolean} omitUnderscore true if you need to omit underscore
+ * @returns {string} escaped css identifier
+ */
 const escapeCssIdentifier = (str, omitUnderscore) => {
 	const escaped = `${str}`.replace(
 		// cspell:word uffff

package/lib/dependencies/CssUrlDependency.js

@@ -48,7 +48,7 @@ class CssUrlDependency extends ModuleDependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @returns {Module | null} a module
 	 */
 	createIgnoredModule(context) {
 		const RawDataUrlModule = getRawDataUrlModule();
@@ -133,7 +133,7 @@ CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
 				newValue = cssEscapeString(
 					runtimeTemplate.assetUrl({
 						publicPath: "",
-						module: moduleGraph.getModule(dep),
+						module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 						codeGenerationResults
 					})
 				);
@@ -142,7 +142,7 @@ CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
 				newValue = `url(${cssEscapeString(
 					runtimeTemplate.assetUrl({
 						publicPath: "",
-						module: moduleGraph.getModule(dep),
+						module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 						codeGenerationResults
 					})
 				)})`;

package/lib/dependencies/DllEntryDependency.js

@@ -10,8 +10,13 @@ const makeSerializable = require("../util/makeSerializable");
 
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./EntryDependency")} EntryDependency */
 
 class DllEntryDependency extends Dependency {
+	/**
+	 * @param {EntryDependency[]} dependencies dependencies
+	 * @param {string} name name
+	 */
 	constructor(dependencies, name) {
 		super();