webpack 5.86.0 → 5.87.0

package/lib/javascript/JavascriptParser.js

@@ -47,6 +47,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").MetaProperty} MetaProperty */
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").AssignmentPattern} AssignmentPattern */
+/** @typedef {import("estree").ChainElement} ChainElement */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").UpdateExpression} UpdateExpression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
@@ -105,7 +106,7 @@ const parser = AcornParser.extend(importAssertions);
 class VariableInfo {
 	/**
 	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
-	 * @param {string | true} freeName which free name the variable aliases, or true when none
+	 * @param {string | true | undefined} freeName which free name the variable aliases, or true when none
 	 * @param {TagInfo | undefined} tagInfo info about tags
 	 */
 	constructor(declaredScope, freeName, tagInfo) {
@@ -404,9 +405,9 @@ class JavascriptParser extends Parser {
 			unhandledExpressionMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
-			/** @type {SyncBailHook<[Expression], boolean | void>} */
+			/** @type {SyncBailHook<[ConditionalExpression], boolean | void>} */
 			expressionConditionalOperator: new SyncBailHook(["expression"]),
-			/** @type {SyncBailHook<[Expression], boolean | void>} */
+			/** @type {SyncBailHook<[LogicalExpression], boolean | void>} */
 			expressionLogicalOperator: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			program: new SyncBailHook(["ast", "comments"]),
@@ -422,7 +423,7 @@ class JavascriptParser extends Parser {
 		this.semicolons = undefined;
 		/** @type {(Statement | ModuleDeclaration | Expression)[]} */
 		this.statementPath = undefined;
-		/** @type {Statement | ModuleDeclaration | Expression} */
+		/** @type {Statement | ModuleDeclaration | Expression | undefined} */
 		this.prevStatement = undefined;
 		/** @type {WeakMap<Expression, Set<string>>} */
 		this.destructuringAssignmentProperties = undefined;
@@ -438,27 +439,29 @@ class JavascriptParser extends Parser {
 				case "number":
 					return new BasicEvaluatedExpression()
 						.setNumber(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "bigint":
 					return new BasicEvaluatedExpression()
 						.setBigInt(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "string":
 					return new BasicEvaluatedExpression()
 						.setString(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "boolean":
 					return new BasicEvaluatedExpression()
 						.setBoolean(expr.value)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 			}
 			if (expr.value === null) {
-				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
+				return new BasicEvaluatedExpression()
+					.setNull()
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 			if (expr.value instanceof RegExp) {
 				return new BasicEvaluatedExpression()
 					.setRegExp(expr.value)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
 		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
@@ -493,7 +496,7 @@ class JavascriptParser extends Parser {
 			} else {
 				return new BasicEvaluatedExpression()
 					.setRegExp(new RegExp(""))
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 
 			const arg2 = expr.arguments[1];
@@ -518,7 +521,7 @@ class JavascriptParser extends Parser {
 
 			return new BasicEvaluatedExpression()
 				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
-				.setRange(expr.range);
+				.setRange(/** @type {Range} */ (expr.range));
 		});
 		this.hooks.evaluate
 			.for("LogicalExpression")
@@ -584,7 +587,7 @@ class JavascriptParser extends Parser {
 		 * @param {boolean | number | BigInt | string} value the value to convert to an expression
 		 * @param {BinaryExpression | UnaryExpression} expr the expression being evaluated
 		 * @param {boolean} sideEffects whether the expression has side effects
-		 * @returns {BasicEvaluatedExpression} the evaluated expression
+		 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
 		 * @example
 		 *
 		 * ```js
@@ -611,22 +614,22 @@ class JavascriptParser extends Parser {
 					return new BasicEvaluatedExpression()
 						.setBoolean(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "number":
 					return new BasicEvaluatedExpression()
 						.setNumber(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "bigint":
 					return new BasicEvaluatedExpression()
 						.setBigInt(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				case "string":
 					return new BasicEvaluatedExpression()
 						.setString(value)
 						.setSideEffects(sideEffects)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 			}
 		};
 
@@ -720,7 +723,7 @@ class JavascriptParser extends Parser {
 					const left = this.evaluateExpression(expr.left);
 					const right = this.evaluateExpression(expr.right);
 					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 
 					const leftConst = left.isCompileTimeValue();
 					const rightConst = right.isCompileTimeValue();
@@ -758,8 +761,14 @@ class JavascriptParser extends Parser {
 						(rightPrimitive === false &&
 							(rightConst || leftPrimitive === true)) ||
 						// Different nullish or boolish status also means not equal
-						isAlwaysDifferent(left.asBool(), right.asBool()) ||
-						isAlwaysDifferent(left.asNullish(), right.asNullish())
+						isAlwaysDifferent(
+							/** @type {boolean} */ (left.asBool()),
+							/** @type {boolean} */ (right.asBool())
+						) ||
+						isAlwaysDifferent(
+							/** @type {boolean} */ (left.asNullish()),
+							/** @type {boolean} */ (right.asNullish())
+						)
 					) {
 						return res
 							.setBoolean(!eql)
@@ -1363,7 +1372,7 @@ class JavascriptParser extends Parser {
 
 				const part = new BasicEvaluatedExpression()
 					.setString(quasi)
-					.setRange(quasiExpr.range)
+					.setRange(/** @type {Range} */ (quasiExpr.range))
 					.setExpression(quasiExpr);
 				quasis.push(part);
 				parts.push(part);
@@ -1381,11 +1390,11 @@ class JavascriptParser extends Parser {
 
 				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
 				if (parts.length === 1) {
-					return parts[0].setRange(node.range);
+					return parts[0].setRange(/** @type {Range} */ (node.range));
 				}
 				return new BasicEvaluatedExpression()
 					.setTemplateString(quasis, parts, "cooked")
-					.setRange(node.range);
+					.setRange(/** @type {Range} */ (node.range));
 			});
 		this.hooks.evaluate
 			.for("TaggedTemplateExpression")
@@ -1400,7 +1409,7 @@ class JavascriptParser extends Parser {
 					);
 					return new BasicEvaluatedExpression()
 						.setTemplateString(quasis, parts, "raw")
-						.setRange(node.range);
+						.setRange(/** @type {Range} */ (node.range));
 				}
 			});
 
@@ -1490,7 +1499,7 @@ class JavascriptParser extends Parser {
 				return new BasicEvaluatedExpression()
 					.setArray(result)
 					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluate
 			.for("ConditionalExpression")
@@ -1505,12 +1514,16 @@ class JavascriptParser extends Parser {
 					const alternate = this.evaluateExpression(expr.alternate);
 					res = new BasicEvaluatedExpression();
 					if (consequent.isConditional()) {
-						res.setOptions(consequent.options);
+						res.setOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (consequent.options)
+						);
 					} else {
 						res.setOptions([consequent]);
 					}
 					if (alternate.isConditional()) {
-						res.addOptions(alternate.options);
+						res.addOptions(
+							/** @type {BasicEvaluatedExpression[]} */ (alternate.options)
+						);
 					} else {
 						res.addOptions([alternate]);
 					}
@@ -1520,7 +1533,7 @@ class JavascriptParser extends Parser {
 					);
 					if (condition.couldHaveSideEffects()) res.setSideEffects();
 				}
-				res.setRange(expr.range);
+				res.setRange(/** @type {Range} */ (expr.range));
 				return res;
 			});
 		this.hooks.evaluate
@@ -1538,7 +1551,7 @@ class JavascriptParser extends Parser {
 				if (!items.every(Boolean)) return;
 				return new BasicEvaluatedExpression()
 					.setItems(items)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluate
 			.for("ChainExpression")
@@ -1573,11 +1586,13 @@ class JavascriptParser extends Parser {
 				}
 
 				while (optionalExpressionsStack.length > 0) {
-					const expression = optionalExpressionsStack.pop();
+					const expression =
+						/** @type {Expression} */
+						(optionalExpressionsStack.pop());
 					const evaluated = this.evaluateExpression(expression);
 
 					if (evaluated.asNullish()) {
-						return evaluated.setRange(_expr.range);
+						return evaluated.setRange(/** @type {Range} */ (_expr.range));
 					}
 				}
 				return this.evaluateExpression(expr.expression);
@@ -2696,6 +2711,9 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {TODO} expression expression
+	 */
 	walkExpression(expression) {
 		switch (expression.type) {
 			case "ArrayExpression":
@@ -3423,10 +3441,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {MemberExpression} expr expression info
-	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
-	 * @param {function(string): any} defined callback when variable is defined
+	 * @param {(function(string, string | ScopeInfo | VariableInfo, function(): string[]): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(string): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForExpressionWithFallback(
 		hookMap,
@@ -3458,7 +3476,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {string} name key in map
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForName(hookMap, name, ...args) {
 		return this.callHooksForNameWithFallback(
@@ -3476,7 +3494,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
 	 * @param {ExportedVariableInfo} info variable info
 	 * @param  {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfo(hookMap, info, ...args) {
 		return this.callHooksForInfoWithFallback(
@@ -3493,10 +3511,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {ExportedVariableInfo} info variable info
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
+	 * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
 		let name;
@@ -3543,10 +3561,10 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {string} name key in map
-	 * @param {function(string): any} fallback callback when variable in not handled by hooks
-	 * @param {function(): any} defined callback when variable is defined
+	 * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {(function(): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
-	 * @returns {R} result of hook
+	 * @returns {R | undefined} result of hook
 	 */
 	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
 		return this.callHooksForInfoWithFallback(
@@ -3586,6 +3604,12 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {boolean} hasThis true, when this is defined
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inClassScope(hasThis, params, fn) {
 		const oldScope = this.scope;
 		this.scope = {
@@ -3610,6 +3634,12 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {boolean} hasThis true, when this is defined
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inFunctionScope(hasThis, params, fn) {
 		const oldScope = this.scope;
 		this.scope = {
@@ -3634,6 +3664,10 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
 	inBlockScope(fn) {
 		const oldScope = this.scope;
 		this.scope = {
@@ -3650,15 +3684,28 @@ class JavascriptParser extends Parser {
 		this.scope = oldScope;
 	}
 
+	/**
+	 * @param {Array<Directive | Statement | ModuleDeclaration>} statements statements
+	 */
 	detectMode(statements) {
 		const isLiteral =
 			statements.length >= 1 &&
 			statements[0].type === "ExpressionStatement" &&
 			statements[0].expression.type === "Literal";
-		if (isLiteral && statements[0].expression.value === "use strict") {
+		if (
+			isLiteral &&
+			/** @type {Literal} */
+			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
+				"use strict"
+		) {
 			this.scope.isStrict = true;
 		}
-		if (isLiteral && statements[0].expression.value === "use asm") {
+		if (
+			isLiteral &&
+			/** @type {Literal} */
+			(/** @type {ExpressionStatement} */ (statements[0]).expression).value ===
+				"use asm"
+		) {
 			this.scope.isAsmJs = true;
 		}
 	}
@@ -3761,7 +3808,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression} expression expression node
+	 * @param {TODO} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -3779,7 +3826,7 @@ class JavascriptParser extends Parser {
 			// ignore error
 		}
 		return new BasicEvaluatedExpression()
-			.setRange(expression.range)
+			.setRange(/** @type {Range} */ (expression.range))
 			.setExpression(expression);
 	}
 
@@ -4024,43 +4071,52 @@ class JavascriptParser extends Parser {
 
 			case "VariableDeclaration":
 				return expr.declarations.every(decl =>
-					this.isPure(decl.init, decl.range[0])
+					this.isPure(decl.init, /** @type {Range} */ (decl.range)[0])
 				);
 
 			case "ConditionalExpression":
 				return (
 					this.isPure(expr.test, commentsStartPos) &&
-					this.isPure(expr.consequent, expr.test.range[1]) &&
-					this.isPure(expr.alternate, expr.consequent.range[1])
+					this.isPure(
+						expr.consequent,
+						/** @type {Range} */ (expr.test.range)[1]
+					) &&
+					this.isPure(
+						expr.alternate,
+						/** @type {Range} */ (expr.consequent.range)[1]
+					)
 				);
 
 			case "LogicalExpression":
 				return (
 					this.isPure(expr.left, commentsStartPos) &&
-					this.isPure(expr.right, expr.left.range[1])
+					this.isPure(expr.right, /** @type {Range} */ (expr.left.range)[1])
 				);
 
 			case "SequenceExpression":
 				return expr.expressions.every(expr => {
 					const pureFlag = this.isPure(expr, commentsStartPos);
-					commentsStartPos = expr.range[1];
+					commentsStartPos = /** @type {Range} */ (expr.range)[1];
 					return pureFlag;
 				});
 
 			case "CallExpression": {
 				const pureFlag =
-					expr.range[0] - commentsStartPos > 12 &&
-					this.getComments([commentsStartPos, expr.range[0]]).some(
+					/** @type {Range} */ (expr.range)[0] - commentsStartPos > 12 &&
+					this.getComments([
+						commentsStartPos,
+						/** @type {Range} */ (expr.range)[0]
+					]).some(
 						comment =>
 							comment.type === "Block" &&
 							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
 					);
 				if (!pureFlag) return false;
-				commentsStartPos = expr.callee.range[1];
+				commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
 				return expr.arguments.every(arg => {
 					if (arg.type === "SpreadElement") return false;
 					const pureFlag = this.isPure(arg, commentsStartPos);
-					commentsStartPos = arg.range[1];
+					commentsStartPos = /** @type {Range} */ (arg.range)[1];
 					return pureFlag;
 				});
 			}
@@ -4114,6 +4170,10 @@ class JavascriptParser extends Parser {
 		this.semicolons.delete(pos);
 	}
 
+	/**
+	 * @param {Expression} expr expression
+	 * @returns {boolean} true, when the expression is a statement level expression
+	 */
 	isStatementLevelExpression(expr) {
 		const currentStatement = this.statementPath[this.statementPath.length - 1];
 		return (
@@ -4303,7 +4363,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} varName variable name
-	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
+	 * @returns {{name: string, info: VariableInfo | string} | undefined} name of the free variable and variable info for that
 	 */
 	getFreeInfoFromVariable(varName) {
 		const info = this.getVariableInfo(varName);
@@ -4383,7 +4443,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {MemberExpression} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]} | undefined} name info
 	 */
 	getNameForExpression(expression) {
 		return this.getMemberExpressionInfo(
@@ -4407,7 +4467,7 @@ class JavascriptParser extends Parser {
 			sourceType: type === "auto" ? "module" : type
 		};
 
-		/** @type {AnyNode} */
+		/** @type {AnyNode | undefined} */
 		let ast;
 		let error;
 		let threw = false;

package/lib/javascript/JavascriptParserHelpers.js

@@ -9,20 +9,26 @@ const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
-/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("./JavascriptParser")} JavascriptParser */
+/** @typedef {import("./JavascriptParser").Range} Range */
 
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} value the const value
  * @param {string[]=} runtimeRequirements runtime requirements
- * @returns {function(ExpressionNode): true} plugin function
+ * @returns {function(Expression): true} plugin function
  */
 exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 	return function constDependency(expr) {
-		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			value,
+			/** @type {Range} */ (expr.range),
+			runtimeRequirements
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		return true;
 	};
@@ -30,33 +36,37 @@ exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 
 /**
  * @param {string} value the string value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToString = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setString(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {number} value the number value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToNumber = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setNumber(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {boolean} value the boolean value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToBoolean = value => {
 	return function booleanExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setBoolean(value)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
@@ -65,14 +75,14 @@ exports.evaluateToBoolean = value => {
  * @param {string} rootInfo rootInfo
  * @param {function(): string[]} getMembers getMembers
  * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
+ * @returns {function(Expression): BasicEvaluatedExpression} callback
  */
 exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	return function identifierExpression(expr) {
 		let evaluatedExpression = new BasicEvaluatedExpression()
 			.setIdentifier(identifier, rootInfo, getMembers)
 			.setSideEffects(false)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 		switch (truthy) {
 			case true:
 				evaluatedExpression.setTruthy();
@@ -89,14 +99,26 @@ exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	};
 };
 
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} message the message
+ * @returns {function(Expression): boolean | undefined} callback to handle unsupported expression
+ */
 exports.expressionIsUnsupported = (parser, message) => {
 	return function unsupportedExpression(expr) {
-		const dep = new ConstDependency("(void 0)", expr.range, null);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			"(void 0)",
+			/** @type {Range} */ (expr.range),
+			null
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		if (!parser.state.module) return;
 		parser.state.module.addWarning(
-			new UnsupportedFeatureWarning(message, expr.loc)
+			new UnsupportedFeatureWarning(
+				message,
+				/** @type {SourceLocation} */ (expr.loc)
+			)
 		);
 		return true;
 	};

package/lib/performance/SizeLimitsPlugin.js

@@ -95,7 +95,7 @@ module.exports = class SizeLimitsPlugin {
 				}
 
 				const size = info.size || source.size();
-				if (size > assetSizeLimit) {
+				if (size > /** @type {number} */ (assetSizeLimit)) {
 					assetsOverSizeLimit.push({
 						name,
 						size
@@ -114,7 +114,7 @@ module.exports = class SizeLimitsPlugin {
 			for (const [name, entry] of compilation.entrypoints) {
 				const size = getEntrypointSize(entry);
 
-				if (size > entrypointSizeLimit) {
+				if (size > /** @type {number} */ (entrypointSizeLimit)) {
 					entrypointsOverLimit.push({
 						name: name,
 						size: size,
@@ -131,14 +131,17 @@ module.exports = class SizeLimitsPlugin {
 				// if !1, then 2, if !2 return
 				if (assetsOverSizeLimit.length > 0) {
 					warnings.push(
-						new AssetsOverSizeLimitWarning(assetsOverSizeLimit, assetSizeLimit)
+						new AssetsOverSizeLimitWarning(
+							assetsOverSizeLimit,
+							/** @type {number} */ (assetSizeLimit)
+						)
 					);
 				}
 				if (entrypointsOverLimit.length > 0) {
 					warnings.push(
 						new EntrypointsOverSizeLimitWarning(
 							entrypointsOverLimit,
-							entrypointSizeLimit
+							/** @type {number} */ (entrypointSizeLimit)
 						)
 					);
 				}

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -7,6 +7,7 @@
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 
 class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
@@ -27,7 +28,8 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	 */
 	generate() {
 		const { runtimeFunction, runtimeHandlers } = this;
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		return Template.asString([
 			`${runtimeHandlers} = {};`,
 			`${runtimeFunction} = ${runtimeTemplate.basicFunction("chunkId", [