eslint-linter-browserify 10.5.0 → 10.7.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.5.0";
+var version = "10.7.0";
 var require$$3$1 = {
 	version: version};
 
@@ -47526,7 +47526,7 @@ function requireAstUtils () {
 			 * @returns {boolean} Whether the node is inside a TypeScript type context.
 			 */
 			function isInType(node) {
-				for (let currNode = node; ; ) {
+				for (let currNode = node; ;) {
 					const { parent } = currNode;
 					if (!parent) {
 						break;
@@ -53661,7 +53661,8 @@ function requireClassMethodsUseThis () {
 			function hasImplements(node) {
 				const classNode = node.parent.parent;
 				return (
-					classNode?.type === "ClassDeclaration" &&
+					(classNode?.type === "ClassDeclaration" ||
+						classNode?.type === "ClassExpression") &&
 					classNode.implements?.length > 0
 				);
 			}
@@ -57617,6 +57618,24 @@ function requireEqeqeq () {
 				return isTypeOf(node.left) || isTypeOf(node.right);
 			}
 
+			/**
+			 * Gets the type of a literal node.
+			 * @param {ASTNode} node The node to check
+			 * @returns {string|null} The type of the literal
+			 * @private
+			 */
+			function getLiteralType(node) {
+				if (node.type === "Literal") {
+					return typeof node.value;
+				}
+
+				if (astUtils.isStaticTemplateLiteral(node)) {
+					return "string";
+				}
+
+				return null;
+			}
+
 			/**
 			 * Checks if operands are literals of the same type (via typeof)
 			 * @param {ASTNode} node The node to check
@@ -57624,11 +57643,9 @@ function requireEqeqeq () {
 			 * @private
 			 */
 			function areLiteralsAndSameType(node) {
-				return (
-					node.left.type === "Literal" &&
-					node.right.type === "Literal" &&
-					typeof node.left.value === typeof node.right.value
-				);
+				const leftType = getLiteralType(node.left);
+
+				return leftType !== null && leftType === getLiteralType(node.right);
 			}
 
 			/**
@@ -57701,7 +57718,11 @@ function requireEqeqeq () {
 					const isNull = isNullCheck(node);
 
 					if (node.operator !== "==" && node.operator !== "!=") {
-						if (enforceInverseRuleForNull && isNull) {
+						if (
+							enforceInverseRuleForNull &&
+							isNull &&
+							(node.operator === "===" || node.operator === "!==")
+						) {
 							report(node, node.operator.slice(0, -1));
 						}
 						return;
@@ -58494,9 +58515,9 @@ function requireFuncNameMatching () {
 				},
 
 				"Property, PropertyDefinition[value]"(node) {
-					if (
-						!(node.value.type === "FunctionExpression" && node.value.id)
-					) {
+					if (!(
+						node.value.type === "FunctionExpression" && node.value.id
+					)) {
 						return;
 					}
 
@@ -59810,12 +59831,10 @@ function requireGeneratorStarSpacing () {
 				}
 
 				// Only check before when preceded by `function`|`static` keyword
-				if (
-					!(
-						kind === "method" &&
-						starToken === sourceCode.getFirstToken(node.parent)
-					)
-				) {
+				if (!(
+					kind === "method" &&
+					starToken === sourceCode.getFirstToken(node.parent)
+				)) {
 					checkSpacing(kind, "before", prevToken, starToken);
 				}
 
@@ -63780,12 +63799,10 @@ function requireIndent () {
 				},
 
 				SwitchCase(node) {
-					if (
-						!(
-							node.consequent.length === 1 &&
-							node.consequent[0].type === "BlockStatement"
-						)
-					) {
+					if (!(
+						node.consequent.length === 1 &&
+						node.consequent[0].type === "BlockStatement"
+					)) {
 						const caseKeyword = sourceCode.getFirstToken(node);
 						const tokenAfterCurrentCase =
 							sourceCode.getTokenAfter(node);
@@ -66312,12 +66329,10 @@ function requireKeySpacing () {
 			 */
 			function isKeyValueProperty(property) {
 				return !(
-					(
-						property.method ||
-						property.shorthand ||
-						property.kind !== "init" ||
-						property.type !== "Property"
-					) // Could be "ExperimentalSpreadProperty" or "SpreadElement"
+					property.method ||
+					property.shorthand ||
+					property.kind !== "init" ||
+					property.type !== "Property" // Could be "ExperimentalSpreadProperty" or "SpreadElement"
 				);
 			}
 
@@ -69766,6 +69781,10 @@ function requireMaxClassesPerFile () {
 					if (classCount > max) {
 						context.report({
 							node,
+							loc: {
+								start: node.body[0].loc.start,
+								end: node.body.at(-1).loc.end,
+							},
 							messageId: "maximumExceeded",
 							data: {
 								classCount,
@@ -70985,6 +71004,9 @@ function requireMaxNestedCallbacks () {
 									type: "integer",
 									minimum: 0,
 								},
+								checkConstructorCallCallbacks: {
+									type: "boolean",
+								},
 							},
 							additionalProperties: false,
 						},
@@ -71032,10 +71054,19 @@ function requireMaxNestedCallbacks () {
 			function checkFunction(node) {
 				const parent = node.parent;
 
-				if (parent.type === "CallExpression") {
-					callbackStack.push(node);
+				if (
+					(parent.type !== "CallExpression" &&
+						!(
+							option.checkConstructorCallCallbacks &&
+							parent.type === "NewExpression"
+						)) ||
+					parent.callee === node
+				) {
+					return;
 				}
 
+				callbackStack.push(node);
+
 				if (callbackStack.length > THRESHOLD) {
 					const opts = { num: callbackStack.length, max: THRESHOLD };
 
@@ -74858,6 +74889,12 @@ function requireNoCompareNegZero () {
 	if (hasRequiredNoCompareNegZero) return noCompareNegZero;
 	hasRequiredNoCompareNegZero = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const { getVariableByName } = requireAstUtils();
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -74874,15 +74911,24 @@ function requireNoCompareNegZero () {
 			},
 
 			fixable: null,
+			hasSuggestions: true,
 			schema: [],
 
 			messages: {
 				unexpected:
 					"Do not use the '{{operator}}' operator to compare against -0.",
+				suggestRemoveMinus:
+					"Replace '-0' with '0' (keeps the current comparison behavior).",
+				suggestObjectIs:
+					"Replace with 'Object.is()' (changes the comparison to distinguish -0 from +0).",
+				suggestNotObjectIs:
+					"Replace with '!Object.is()' (changes the comparison to distinguish -0 from +0).",
 			},
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			//--------------------------------------------------------------------------
 			// Helpers
 			//--------------------------------------------------------------------------
@@ -74900,6 +74946,18 @@ function requireNoCompareNegZero () {
 					node.argument.value === 0
 				);
 			}
+
+			/**
+			 * Gets the source text of an operand, keeping parentheses where required.
+			 * @param {ASTNode} operand A comparison operand node.
+			 * @returns {string} The source text of the operand.
+			 */
+			function getOperandText(operand) {
+				const text = sourceCode.getText(operand);
+
+				return operand.type === "SequenceExpression" ? `(${text})` : text;
+			}
+
 			const OPERATORS_TO_CHECK = new Set([
 				">",
 				">=",
@@ -74913,15 +74971,71 @@ function requireNoCompareNegZero () {
 
 			return {
 				BinaryExpression(node) {
-					if (OPERATORS_TO_CHECK.has(node.operator)) {
-						if (isNegZero(node.left) || isNegZero(node.right)) {
-							context.report({
-								node,
-								messageId: "unexpected",
-								data: { operator: node.operator },
-							});
-						}
+					if (!OPERATORS_TO_CHECK.has(node.operator)) {
+						return;
 					}
+
+					const leftIsNegZero = isNegZero(node.left);
+					const rightIsNegZero = isNegZero(node.right);
+
+					if (!leftIsNegZero && !rightIsNegZero) {
+						return;
+					}
+
+					context.report({
+						node,
+						messageId: "unexpected",
+						data: { operator: node.operator },
+						suggest: [
+							{
+								messageId: "suggestRemoveMinus",
+								*fix(fixer) {
+									if (leftIsNegZero) {
+										yield fixer.replaceText(node.left, "0");
+									}
+									if (rightIsNegZero) {
+										yield fixer.replaceText(node.right, "0");
+									}
+								},
+							},
+							{
+								messageId:
+									node.operator === "==="
+										? "suggestObjectIs"
+										: "suggestNotObjectIs",
+								fix(fixer) {
+									if (
+										(node.operator !== "===" &&
+											node.operator !== "!==") ||
+										sourceCode.getCommentsInside(node).length >
+											0
+									) {
+										return null;
+									}
+
+									const objectVariable = getVariableByName(
+										sourceCode.getScope(node),
+										"Object",
+									);
+
+									if (
+										!objectVariable ||
+										objectVariable.identifiers.length > 0
+									) {
+										return null;
+									}
+
+									const negation =
+										node.operator === "===" ? "" : "!";
+
+									return fixer.replaceText(
+										node,
+										`${negation}Object.is(${getOperandText(node.left)}, ${getOperandText(node.right)})`,
+									);
+								},
+							},
+						],
+					});
 				},
 			};
 		},
@@ -75598,6 +75712,8 @@ function requireNoConstantBinaryExpression () {
 		">>>",
 	]);
 
+	const RELATIONAL_OPERATORS = new Set(["<", "<=", ">", ">="]);
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -75657,7 +75773,9 @@ function requireNoConstantBinaryExpression () {
 				return (
 					(functionName === "Boolean" ||
 						functionName === "String" ||
-						functionName === "Number") &&
+						functionName === "Number" ||
+						functionName === "Symbol" ||
+						functionName === "BigInt") &&
 					isReferenceToGlobalVariable(scope, node.callee)
 				);
 			}
@@ -75942,7 +76060,10 @@ function requireNoConstantBinaryExpression () {
 				const functionName = node.callee.name;
 
 				if (
-					(functionName === "String" || functionName === "Number") &&
+					(functionName === "String" ||
+						functionName === "Number" ||
+						functionName === "BigInt" ||
+						functionName === "Symbol") &&
 					isReferenceToGlobalVariable(scope, node.callee)
 				) {
 					return true;
@@ -76055,6 +76176,33 @@ function requireNoConstantBinaryExpression () {
 		return null;
 	}
 
+	/**
+	 * Checks if a node is a statically knowable literal.
+	 * @param {Scope} scope The scope in which the node was found.
+	 * @param {ASTNode} node The node to test.
+	 * @returns {boolean} `true` if the node is a literal.
+	 */
+	function isStaticLiteral(scope, node) {
+		switch (node.type) {
+			case "Literal":
+				return true;
+			case "UnaryExpression":
+				return (
+					["-", "+", "~"].includes(node.operator) &&
+					node.argument.type === "Literal"
+				);
+			case "Identifier":
+				return (
+					node.name === "undefined" &&
+					isReferenceToGlobalVariable(scope, node)
+				);
+			case "TemplateLiteral":
+				return node.expressions.length === 0;
+			default:
+				return false;
+		}
+	}
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -76069,7 +76217,22 @@ function requireNoConstantBinaryExpression () {
 				recommended: true,
 				url: "https://eslint.org/docs/latest/rules/no-constant-binary-expression",
 			},
-			schema: [],
+			defaultOptions: [
+				{
+					checkRelationalComparisons: false,
+				},
+			],
+			schema: [
+				{
+					type: "object",
+					properties: {
+						checkRelationalComparisons: {
+							type: "boolean",
+						},
+					},
+					additionalProperties: false,
+				},
+			],
 			messages: {
 				constantBinaryOperand:
 					"Unexpected constant binary expression. Compares constantly with the {{otherSide}}-hand side of the `{{operator}}`.",
@@ -76079,11 +76242,14 @@ function requireNoConstantBinaryExpression () {
 					"Unexpected comparison to newly constructed object. These two values can never be equal.",
 				bothAlwaysNew:
 					"Unexpected comparison of two newly constructed objects. These two values can never be equal.",
+				constantRelationalComparison:
+					"Unexpected constant relational comparison. Both sides of the `{{operator}}` are literal values.",
 			},
 		},
 
 		create(context) {
 			const sourceCode = context.sourceCode;
+			const { checkRelationalComparisons } = context.options[0];
 
 			return {
 				LogicalExpression(node) {
@@ -76157,6 +76323,20 @@ function requireNoConstantBinaryExpression () {
 								messageId: "bothAlwaysNew",
 							});
 						}
+					} else if (
+						checkRelationalComparisons &&
+						RELATIONAL_OPERATORS.has(operator)
+					) {
+						if (
+							isStaticLiteral(scope, left) &&
+							isStaticLiteral(scope, right)
+						) {
+							context.report({
+								node,
+								messageId: "constantRelationalComparison",
+								data: { operator },
+							});
+						}
 					}
 				},
 
@@ -79614,6 +79794,8 @@ function requireNoControlRegex () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			/**
 			 * Get the regex expression
 			 * @param {ASTNode} node `Literal` node to evaluate
@@ -79632,6 +79814,7 @@ function requireNoControlRegex () {
 						node.parent.type === "CallExpression") &&
 					node.parent.callee.type === "Identifier" &&
 					node.parent.callee.name === "RegExp" &&
+					sourceCode.isGlobalReference(node.parent.callee) &&
 					node.parent.arguments[0] === node
 				) {
 					const pattern = node.value;
@@ -83083,7 +83266,8 @@ function requireNoExtraBooleanCast () {
 					(node.type === "CallExpression" ||
 						node.type === "NewExpression") &&
 					node.callee.type === "Identifier" &&
-					node.callee.name === "Boolean"
+					node.callee.name === "Boolean" &&
+					sourceCode.isGlobalReference(node.callee)
 				);
 			}
 
@@ -83315,7 +83499,8 @@ function requireNoExtraBooleanCast () {
 				CallExpression(node) {
 					if (
 						node.callee.type !== "Identifier" ||
-						node.callee.name !== "Boolean"
+						node.callee.name !== "Boolean" ||
+						!sourceCode.isGlobalReference(node.callee)
 					) {
 						return;
 					}
@@ -86246,6 +86431,21 @@ function requireNoImplicitCoercion () {
 			const [options] = context.options;
 			const sourceCode = context.sourceCode;
 
+			/**
+			 * Gets the source text of a node to be used as the argument of a
+			 * `Boolean()`, `Number()`, or `String()` call in a recommendation. A
+			 * `SequenceExpression` operand must be parenthesized, otherwise its commas
+			 * would be parsed as argument separators, which changes the evaluated
+			 * operand (for example `!!(a, b)` becomes `Boolean(a, b)`).
+			 * @param {ASTNode} node The operand node.
+			 * @returns {string} The source text, parenthesized if needed.
+			 */
+			function getOperandText(node) {
+				const text = sourceCode.getText(node);
+
+				return node.type === "SequenceExpression" ? `(${text})` : text;
+			}
+
 			/**
 			 * Reports an error and autofixes the node
 			 * @param {ASTNode} node An ast node to report the error on.
@@ -86311,7 +86511,7 @@ function requireNoImplicitCoercion () {
 						options.boolean &&
 						isDoubleLogicalNegating(node)
 					) {
-						const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+						const recommendation = `Boolean(${getOperandText(node.argument.argument)})`;
 						const variable = astUtils.getVariableByName(
 							sourceCode.getScope(node),
 							"Boolean",
@@ -86346,7 +86546,7 @@ function requireNoImplicitCoercion () {
 						node.operator === "+" &&
 						!isNumeric(node.argument)
 					) {
-						const recommendation = `Number(${sourceCode.getText(node.argument)})`;
+						const recommendation = `Number(${getOperandText(node.argument)})`;
 
 						report(node, recommendation, true, false);
 					}
@@ -86361,7 +86561,7 @@ function requireNoImplicitCoercion () {
 						node.argument.operator === "-" &&
 						!isNumeric(node.argument.argument)
 					) {
-						const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
+						const recommendation = `Number(${getOperandText(node.argument.argument)})`;
 
 						report(node, recommendation, true, false);
 					}
@@ -86381,7 +86581,7 @@ function requireNoImplicitCoercion () {
 						getNonNumericOperand(node);
 
 					if (nonNumericOperand) {
-						const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
+						const recommendation = `Number(${getOperandText(nonNumericOperand)})`;
 
 						report(node, recommendation, true, false);
 					}
@@ -86396,7 +86596,7 @@ function requireNoImplicitCoercion () {
 						node.right.value === 0 &&
 						!isNumeric(node.left)
 					) {
-						const recommendation = `Number(${sourceCode.getText(node.left)})`;
+						const recommendation = `Number(${getOperandText(node.left)})`;
 
 						report(node, recommendation, true, false);
 					}
@@ -86408,7 +86608,7 @@ function requireNoImplicitCoercion () {
 						options.string &&
 						isConcatWithEmptyString(node)
 					) {
-						const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
+						const recommendation = `String(${getOperandText(getNonEmptyOperand(node))})`;
 
 						report(node, recommendation, true, false);
 					}
@@ -86460,8 +86660,7 @@ function requireNoImplicitCoercion () {
 						return;
 					}
 
-					const code = sourceCode.getText(node.expressions[0]);
-					const recommendation = `String(${code})`;
+					const recommendation = `String(${getOperandText(node.expressions[0])})`;
 
 					report(node, recommendation, true, false);
 				},
@@ -87420,6 +87619,7 @@ function requireNoInvalidRegexp () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
 			const [{ allowConstructorFlags }] = context.options;
 			let allowedFlags = [];
 
@@ -87547,7 +87747,8 @@ function requireNoInvalidRegexp () {
 				"CallExpression, NewExpression"(node) {
 					if (
 						node.callee.type !== "Identifier" ||
-						node.callee.name !== "RegExp"
+						node.callee.name !== "RegExp" ||
+						!sourceCode.isGlobalReference(node.callee)
 					) {
 						return;
 					}
@@ -91307,14 +91508,12 @@ function requireNoMixedSpacesAndTabs () {
 										sourceCode.getIndexFromLoc(loc.start),
 									);
 
-								if (
-									!(
-										containingNode &&
-										["Literal", "TemplateElement"].includes(
-											containingNode.type,
-										)
+								if (!(
+									containingNode &&
+									["Literal", "TemplateElement"].includes(
+										containingNode.type,
 									)
-								) {
+								)) {
 									context.report({
 										node,
 										loc,
@@ -94136,13 +94335,12 @@ function requireNoPromiseExecutorReturn () {
 							});
 						}
 
-						// Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
-						if (
-							!(
-								node.body.type === "FunctionExpression" &&
-								!node.body.id
-							)
-						) {
+						// Do not suggest wrapping an unnamed function or class expression in braces as that would be invalid syntax.
+						if (!(
+							(node.body.type === "FunctionExpression" ||
+								node.body.type === "ClassExpression") &&
+							!node.body.id
+						)) {
 							suggest.push({
 								messageId: "wrapBraces",
 								fix(fixer) {
@@ -97820,12 +98018,10 @@ function requireNoScriptUrl () {
 					}
 				},
 				TemplateLiteral(node) {
-					if (
-						!(
-							node.parent &&
-							node.parent.type === "TaggedTemplateExpression"
-						)
-					) {
+					if (!(
+						node.parent &&
+						node.parent.type === "TaggedTemplateExpression"
+					)) {
 						check(node);
 					}
 				},
@@ -98792,12 +98988,10 @@ function requireNoShadow () {
 
 				const { variableScope } = variable.scope;
 
-				if (
-					!(
-						FUNC_EXPR_NODE_TYPES.has(variableScope.block.type) &&
-						getOuterScope(variableScope) === shadowedVariable.scope
-					)
-				) {
+				if (!(
+					FUNC_EXPR_NODE_TYPES.has(variableScope.block.type) &&
+					getOuterScope(variableScope) === shadowedVariable.scope
+				)) {
 					return false;
 				}
 
@@ -98922,14 +99116,12 @@ function requireNoShadow () {
 					return false;
 				}
 
-				if (
-					!(
-						(innerDef.type === "FunctionName" &&
-							innerDef.node.type === "FunctionExpression") ||
-						(innerDef.type === "ClassName" &&
-							innerDef.node.type === "ClassExpression")
-					)
-				) {
+				if (!(
+					(innerDef.type === "FunctionName" &&
+						innerDef.node.type === "FunctionExpression") ||
+					(innerDef.type === "ClassName" &&
+						innerDef.node.type === "ClassExpression")
+				)) {
 					return false;
 				}
 
@@ -98949,12 +99141,10 @@ function requireNoShadow () {
 				const nodeToCheck = innerDef.node; // FunctionExpression or ClassExpression node
 
 				// Exit early if the node to check isn't inside the initializer
-				if (
-					!(
-						initializerNode.range[0] <= nodeToCheck.range[0] &&
-						nodeToCheck.range[1] <= initializerNode.range[1]
-					)
-				) {
+				if (!(
+					initializerNode.range[0] <= nodeToCheck.range[0] &&
+					nodeToCheck.range[1] <= initializerNode.range[1]
+				)) {
 					return false;
 				}
 
@@ -100240,12 +100430,17 @@ function requireNoThrowLiteral () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			return {
 				ThrowStatement(node) {
 					if (!astUtils.couldBeError(node.argument)) {
 						context.report({ node, messageId: "object" });
 					} else if (node.argument.type === "Identifier") {
-						if (node.argument.name === "undefined") {
+						if (
+							node.argument.name === "undefined" &&
+							sourceCode.isGlobalReference(node.argument)
+						) {
 							context.report({ node, messageId: "undef" });
 						}
 					}
@@ -115332,6 +115527,11 @@ function requirePreferExponentiationOperator () {
 		operator: "**",
 	});
 
+	/*
+	 * Characters that can cause continuation without preceding semi
+	 */
+	const continuationChars = new Set(["(", "[", "/", "`"]);
+
 	/**
 	 * Determines whether the given node needs parens if used as the base in an exponentiation binary expression.
 	 * @param {ASTNode} base The node to check.
@@ -115460,11 +115660,36 @@ function requirePreferExponentiationOperator () {
 							shouldParenthesizeBase = doesBaseNeedParens(base),
 							shouldParenthesizeExponent =
 								doesExponentNeedParens(exponent),
-							shouldParenthesizeAll =
-								doesExponentiationExpressionNeedParens(
-									node,
-									sourceCode,
-								);
+							isStartOfExpressionStatement =
+								astUtils.isStartOfExpressionStatement(node);
+
+						let shouldParenthesizeAll =
+							doesExponentiationExpressionNeedParens(
+								node,
+								sourceCode,
+							);
+
+						/*
+						 * `function`, `class`, or `{` token at the start of an expression statement
+						 * would cause incorrect parsing.
+						 * https://github.com/eslint/eslint/issues/20987
+						 */
+						if (
+							!shouldParenthesizeAll &&
+							!shouldParenthesizeBase &&
+							isStartOfExpressionStatement
+						) {
+							const firstTokenOfBase = sourceCode.getFirstToken(base);
+
+							if (
+								astUtils.isOpeningBraceToken(firstTokenOfBase) ||
+								(firstTokenOfBase.type === "Keyword" &&
+									(firstTokenOfBase.value === "function" ||
+										firstTokenOfBase.value === "class"))
+							) {
+								shouldParenthesizeAll = true;
+							}
+						}
 
 						let prefix = "",
 							suffix = "";
@@ -115517,6 +115742,15 @@ function requirePreferExponentiationOperator () {
 								shouldParenthesizeAll,
 							);
 
+						if (
+							!prefix &&
+							isStartOfExpressionStatement &&
+							continuationChars.has(replacement[0]) &&
+							astUtils.needsPrecedingSemicolon(sourceCode, node)
+						) {
+							prefix = ";";
+						}
+
 						return fixer.replaceText(
 							node,
 							`${prefix}${replacement}${suffix}`,
@@ -115784,14 +116018,22 @@ function requirePreferNumericLiterals () {
 	 * Checks to see if a CallExpression's callee node is `parseInt` or
 	 * `Number.parseInt`.
 	 * @param {ASTNode} calleeNode The callee node to evaluate.
+	 * @param {SourceCode} sourceCode The source code object.
 	 * @returns {boolean} True if the callee is `parseInt` or `Number.parseInt`,
 	 * false otherwise.
 	 */
-	function isParseInt(calleeNode) {
-		return (
-			astUtils.isSpecificId(calleeNode, "parseInt") ||
-			astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
-		);
+	function isParseInt(calleeNode, sourceCode) {
+		if (astUtils.isSpecificId(calleeNode, "parseInt")) {
+			return sourceCode.isGlobalReference(calleeNode);
+		}
+
+		if (astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")) {
+			const objectNode = astUtils.skipChainExpression(calleeNode).object;
+
+			return sourceCode.isGlobalReference(objectNode);
+		}
+
+		return false;
 	}
 
 	//------------------------------------------------------------------------------
@@ -115840,7 +116082,7 @@ function requirePreferNumericLiterals () {
 						radixNode.type === "Literal" &&
 						typeof radix === "number" &&
 						radixMap.has(radix) &&
-						isParseInt(node.callee)
+						isParseInt(node.callee, sourceCode)
 					) {
 						const { system, literalPrefix } = radixMap.get(radix);
 
@@ -115999,12 +116241,10 @@ function requirePreferObjectHasOwn () {
 
 			return {
 				CallExpression(node) {
-					if (
-						!(
-							node.callee.type === "MemberExpression" &&
-							node.callee.object.type === "MemberExpression"
-						)
-					) {
+					if (!(
+						node.callee.type === "MemberExpression" &&
+						node.callee.object.type === "MemberExpression"
+					)) {
 						return;
 					}
 
@@ -116471,11 +116711,15 @@ function requirePreferPromiseRejectErrors () {
 				if (!callExpression.arguments.length && allowEmptyReject) {
 					return;
 				}
+
+				const rejectionReason = callExpression.arguments[0];
+
 				if (
 					!callExpression.arguments.length ||
-					!astUtils.couldBeError(callExpression.arguments[0]) ||
-					(callExpression.arguments[0].type === "Identifier" &&
-						callExpression.arguments[0].name === "undefined")
+					!astUtils.couldBeError(rejectionReason) ||
+					(rejectionReason.type === "Identifier" &&
+						rejectionReason.name === "undefined" &&
+						sourceCode.isGlobalReference(rejectionReason))
 				) {
 					context.report({
 						node: callExpression,
@@ -116490,10 +116734,15 @@ function requirePreferPromiseRejectErrors () {
 			 * @returns {boolean} `true` if the call is a Promise.reject() call
 			 */
 			function isPromiseRejectCall(node) {
-				return astUtils.isSpecificMemberAccess(
-					node.callee,
-					"Promise",
-					"reject",
+				return (
+					astUtils.isSpecificMemberAccess(
+						node.callee,
+						"Promise",
+						"reject",
+					) &&
+					sourceCode.isGlobalReference(
+						astUtils.skipChainExpression(node.callee).object,
+					)
 				);
 			}
 
@@ -116518,6 +116767,7 @@ function requirePreferPromiseRejectErrors () {
 					if (
 						node.callee.type === "Identifier" &&
 						node.callee.name === "Promise" &&
+						sourceCode.isGlobalReference(node.callee) &&
 						node.arguments.length &&
 						astUtils.isFunction(node.arguments[0]) &&
 						node.arguments[0].params.length > 1 &&
@@ -117970,18 +118220,13 @@ function requirePreserveCaughtError () {
 	/**
 	 * Finds and returns information about the `cause` property of an error being thrown.
 	 * @param {ASTNode} throwStatement `ThrowStatement` to be checked.
+	 * @param {number} optionsIndex The index of the options argument in the error constructor.
 	 * @returns {{ value: ASTNode; multipleDefinitions: boolean; } | UNKNOWN_CAUSE | null}
 	 * Information about the `cause` of the error being thrown, such as the value node and
 	 * whether there are multiple definitions of `cause`. `null` if there is no `cause`.
 	 */
-	function getErrorCause(throwStatement) {
+	function getErrorCause(throwStatement, optionsIndex) {
 		const throwExpression = throwStatement.argument;
-		/*
-		 * Determine which argument index holds the options object
-		 * `AggregateError` is a special case as it accepts the `options` object as third argument.
-		 */
-		const optionsIndex =
-			throwExpression.callee.name === "AggregateError" ? 2 : 1;
 
 		/*
 		 * Make sure there is no `SpreadElement` at or before the `optionsIndex`
@@ -118082,6 +118327,7 @@ function requirePreserveCaughtError () {
 			defaultOptions: [
 				{
 					requireCatchParameter: false,
+					errorClassNames: [],
 				},
 			],
 
@@ -118091,14 +118337,6 @@ function requirePreserveCaughtError () {
 				recommended: true,
 				url: "https://eslint.org/docs/latest/rules/preserve-caught-error", // URL to the documentation page for this rule
 			},
-			/*
-			 * TODO: We should allow passing `customErrorTypes` option once something like `typescript-eslint`'s
-			 * 		`TypeOrValueSpecifier` is implemented in core Eslint.
-			 *      See:
-			 * 		1. https://typescript-eslint.io/packages/type-utils/type-or-value-specifier/
-			 *      2. https://github.com/eslint/eslint/pull/19913#discussion_r2192608593
-			 *      3. https://github.com/eslint/eslint/discussions/16540
-			 */
 			schema: [
 				{
 					type: "object",
@@ -118108,6 +118346,33 @@ function requirePreserveCaughtError () {
 							description:
 								"Requires the catch blocks to always have the caught error parameter so it is not discarded.",
 						},
+						errorClassNames: {
+							type: "array",
+							description:
+								"Additional error class names to check for cause preservation.",
+							items: {
+								oneOf: [
+									{
+										type: "string",
+									},
+									{
+										type: "object",
+										required: ["name", "argumentPosition"],
+										properties: {
+											name: {
+												type: "string",
+											},
+											argumentPosition: {
+												type: "integer",
+												minimum: 1,
+											},
+										},
+										additionalProperties: false,
+									},
+								],
+							},
+							uniqueItems: true,
+						},
 					},
 					additionalProperties: false,
 				},
@@ -118131,12 +118396,34 @@ function requirePreserveCaughtError () {
 
 		create(context) {
 			const sourceCode = context.sourceCode;
-			const [{ requireCatchParameter }] = context.options;
+			const [{ requireCatchParameter, errorClassNames }] = context.options;
+
+			const errorClassNamesMap = new Map();
+			for (const item of errorClassNames) {
+				const name = typeof item === "string" ? item : item.name;
+				const argumentPosition =
+					typeof item === "string" ? 2 : item.argumentPosition;
+
+				errorClassNamesMap.set(name, argumentPosition);
+			}
 
 			//----------------------------------------------------------------------
 			// Helpers
 			//----------------------------------------------------------------------
 
+			/**
+			 * Checks if the given callee refers to a built-in global Error constructor.
+			 * @param {ASTNode} callee The callee node.
+			 * @returns {boolean} `true` if the callee is a built-in global Error constructor.
+			 */
+			function isBuiltInGlobalError(callee) {
+				return (
+					callee.type === "Identifier" &&
+					BUILT_IN_ERROR_TYPES.has(callee.name) &&
+					sourceCode.isGlobalReference(callee)
+				);
+			}
+
 			/**
 			 * Checks if a `ThrowStatement` is constructing and throwing a new `Error` object.
 			 *
@@ -118146,18 +118433,33 @@ function requirePreserveCaughtError () {
 			 * @returns {boolean} `true` if a new "Error" is being thrown, else `false`.
 			 */
 			function isThrowingNewError(throwStatement) {
+				if (!(
+					throwStatement.argument.type === "NewExpression" ||
+					throwStatement.argument.type === "CallExpression"
+				)) {
+					return false;
+				}
+
+				const callee = throwStatement.argument.callee;
+
+				/*
+				 * Make sure the thrown Error instance is one of the built-in global error types.
+				 * Custom imports could shadow this, which would lead to false positives.
+				 * e.g. import { Error } from "./my-custom-error.js";
+				 *      throw Error("Failed to perform error prone operations");
+				 */
+				if (isBuiltInGlobalError(callee)) {
+					return true;
+				}
+
+				const target =
+					callee.type === "MemberExpression" && !callee.computed
+						? callee.property
+						: callee;
+
 				return (
-					(throwStatement.argument.type === "NewExpression" ||
-						throwStatement.argument.type === "CallExpression") &&
-					throwStatement.argument.callee.type === "Identifier" &&
-					BUILT_IN_ERROR_TYPES.has(throwStatement.argument.callee.name) &&
-					/*
-					 * Make sure the thrown Error is instance is one of the built-in global error types.
-					 * Custom imports could shadow this, which would lead to false positives.
-					 * e.g. import { Error } from "./my-custom-error.js";
-					 *      throw Error("Failed to perform error prone operations");
-					 */
-					sourceCode.isGlobalReference(throwStatement.argument.callee)
+					target.type === "Identifier" &&
+					errorClassNamesMap.has(target.name)
 				);
 			}
 
@@ -118186,6 +118488,30 @@ function requirePreserveCaughtError () {
 				);
 			}
 
+			/**
+			 * Gets the token after which new arguments should be inserted for the
+			 * given argument, accounting for parentheses wrapping the argument so
+			 * that insertions land outside them (e.g. `new Error(("msg"))`).
+			 * @param {ASTNode} argNode The argument node.
+			 * @param {ASTNode} callNode The enclosing call or new expression.
+			 * @returns {Token} The token to insert after.
+			 */
+			function getLastArgumentToken(argNode, callNode) {
+				const callLastToken = sourceCode.getLastToken(callNode);
+				let token = sourceCode.getLastToken(argNode);
+				let nextToken = sourceCode.getTokenAfter(token);
+
+				while (
+					nextToken &&
+					nextToken !== callLastToken &&
+					astUtils.isClosingParenToken(nextToken)
+				) {
+					token = nextToken;
+					nextToken = sourceCode.getTokenAfter(token);
+				}
+				return token;
+			}
+
 			//----------------------------------------------------------------------
 			// Public
 			//----------------------------------------------------------------------
@@ -118229,8 +118555,30 @@ function requirePreserveCaughtError () {
 							return;
 						}
 
+						// Determine the options argument index
+						const callee = throwStatement.argument.callee;
+						const errorClassName =
+							callee.type === "Identifier"
+								? callee.name
+								: callee.property.name;
+
+						const builtInGlobalError = isBuiltInGlobalError(callee);
+
+						let optionsIndex;
+						if (builtInGlobalError) {
+							optionsIndex =
+								errorClassName === "AggregateError" ? 2 : 1;
+						} else {
+							const argumentPosition =
+								errorClassNamesMap.get(errorClassName);
+							optionsIndex = argumentPosition - 1;
+						}
+
 						// Check if there is a cause attached to the new error
-						const errorCauseInfo = getErrorCause(throwStatement);
+						const errorCauseInfo = getErrorCause(
+							throwStatement,
+							optionsIndex,
+						);
 
 						if (errorCauseInfo === UNKNOWN_CAUSE) {
 							// Error options exist, but too complicated to be analyzed/fixed
@@ -118249,11 +118597,33 @@ function requirePreserveCaughtError () {
 											const throwExpression =
 												throwStatement.argument;
 											const args = throwExpression.arguments;
-											const errorType =
-												throwExpression.callee.name;
+
+											/**
+											 * Inserts `cause` into the options argument if it is an `ObjectExpression`.
+											 * @param {ASTNode} optionsArg The options argument node.
+											 * @returns {Fix | null} The fix, or `null` if the argument is not an object.
+											 */
+											function fixExistingOptions(
+												optionsArg,
+											) {
+												if (
+													optionsArg.type ===
+													"ObjectExpression"
+												) {
+													return insertCauseIntoOptions(
+														fixer,
+														optionsArg,
+														caughtError.name,
+													);
+												}
+												return null;
+											}
 
 											// AggregateError: errors, message, options
-											if (errorType === "AggregateError") {
+											if (
+												builtInGlobalError &&
+												errorClassName === "AggregateError"
+											) {
 												const errorsArg = args[0];
 												const messageArg = args[1];
 												const optionsArg = args[2];
@@ -118290,7 +118660,10 @@ function requirePreserveCaughtError () {
 												if (!messageArg) {
 													// Case: `throw new AggregateError([])` → insert message and options
 													return fixer.insertTextAfter(
-														errorsArg,
+														getLastArgumentToken(
+															errorsArg,
+															throwExpression,
+														),
 														`, "", { cause: ${caughtError.name} }`,
 													);
 												}
@@ -118298,32 +118671,94 @@ function requirePreserveCaughtError () {
 												if (!optionsArg) {
 													// Case: `throw new AggregateError([], "")` → insert error options only
 													return fixer.insertTextAfter(
-														messageArg,
+														getLastArgumentToken(
+															messageArg,
+															throwExpression,
+														),
 														`, { cause: ${caughtError.name} }`,
 													);
 												}
 
-												if (
-													optionsArg.type ===
-													"ObjectExpression"
-												) {
-													return insertCauseIntoOptions(
-														fixer,
-														optionsArg,
-														caughtError.name,
+												return fixExistingOptions(
+													optionsArg,
+												);
+											}
+
+											// Normal Error types
+											if (builtInGlobalError) {
+												const messageArg = args[0];
+												const optionsArg = args[1];
+
+												if (!messageArg) {
+													// Case: `throw new Error()` → insert both message and options
+													const lastToken =
+														sourceCode.getLastToken(
+															throwExpression,
+														);
+													const lastCalleeToken =
+														sourceCode.getLastToken(
+															throwExpression.callee,
+														);
+													const parenToken =
+														sourceCode.getFirstTokenBetween(
+															lastCalleeToken,
+															lastToken,
+															astUtils.isOpeningParenToken,
+														);
+
+													if (parenToken) {
+														return fixer.insertTextAfter(
+															parenToken,
+															`"", { cause: ${caughtError.name} }`,
+														);
+													}
+													return fixer.insertTextAfter(
+														throwExpression.callee,
+														`("", { cause: ${caughtError.name} })`,
 													);
 												}
+												if (!optionsArg) {
+													// Case: `throw new Error("Some message")` → insert only options
+													return fixer.insertTextAfter(
+														getLastArgumentToken(
+															messageArg,
+															throwExpression,
+														),
+														`, { cause: ${caughtError.name} }`,
+													);
+												}
+
+												return fixExistingOptions(
+													optionsArg,
+												);
+											}
 
-												// Complex dynamic options — skip
+											// Custom error types
+											const optionsArg = args[optionsIndex];
+
+											/*
+											 * Custom error signature is unknown, so skip the suggestion rather
+											 * than synthesize placeholder values for missing positional args.
+											 */
+											if (args.length < optionsIndex) {
 												return null;
 											}
 
-											// Normal Error types
-											const messageArg = args[0];
-											const optionsArg = args[1];
+											if (!optionsArg) {
+												const lastProvidedArg = args.at(-1);
+
+												if (lastProvidedArg) {
+													// Options slot missing, all prior args provided → append options
+													return fixer.insertTextAfter(
+														getLastArgumentToken(
+															lastProvidedArg,
+															throwExpression,
+														),
+														`, { cause: ${caughtError.name} }`,
+													);
+												}
 
-											if (!messageArg) {
-												// Case: `throw new Error()` → insert both message and options
+												// argumentPosition: 1 and no args → insert `{ cause: err }` inside parens
 												const lastToken =
 													sourceCode.getLastToken(
 														throwExpression,
@@ -118342,34 +118777,16 @@ function requirePreserveCaughtError () {
 												if (parenToken) {
 													return fixer.insertTextAfter(
 														parenToken,
-														`"", { cause: ${caughtError.name} }`,
+														`{ cause: ${caughtError.name} }`,
 													);
 												}
 												return fixer.insertTextAfter(
 													throwExpression.callee,
-													`("", { cause: ${caughtError.name} })`,
-												);
-											}
-											if (!optionsArg) {
-												// Case: `throw new Error("Some message")` → insert only options
-												return fixer.insertTextAfter(
-													messageArg,
-													`, { cause: ${caughtError.name} }`,
+													`({ cause: ${caughtError.name} })`,
 												);
 											}
 
-											if (
-												optionsArg.type ===
-												"ObjectExpression"
-											) {
-												return insertCauseIntoOptions(
-													fixer,
-													optionsArg,
-													caughtError.name,
-												);
-											}
-
-											return null; // Identifier or spread — do not fix
+											return fixExistingOptions(optionsArg);
 										},
 									},
 								],
@@ -118382,12 +118799,10 @@ function requirePreserveCaughtError () {
 						const { value: thrownErrorCause } = errorCauseInfo;
 
 						// If there is an attached cause, verify that it matches the caught error
-						if (
-							!(
-								thrownErrorCause.type === "Identifier" &&
-								thrownErrorCause.name === caughtError.name
-							)
-						) {
+						if (!(
+							thrownErrorCause.type === "Identifier" &&
+							thrownErrorCause.name === caughtError.name
+						)) {
 							const suggest = errorCauseInfo.multipleDefinitions
 								? null // If there are multiple `cause` definitions, a suggestion could be confusing.
 								: [
@@ -119334,21 +119749,6 @@ function requireRadix () {
 		return variable.defs.length >= 1;
 	}
 
-	/**
-	 * Checks whether a given node is a MemberExpression of `parseInt` method or not.
-	 * @param {ASTNode} node A node to check.
-	 * @returns {boolean} `true` if the node is a MemberExpression of `parseInt`
-	 *      method.
-	 */
-	function isParseIntMethod(node) {
-		return (
-			node.type === "MemberExpression" &&
-			!node.computed &&
-			node.property.type === "Identifier" &&
-			node.property.name === "parseInt"
-		);
-	}
-
 	/**
 	 * Checks whether a given node is a valid value of radix or not.
 	 *
@@ -119357,12 +119757,29 @@ function requireRadix () {
 	 * - A literal except integers between 2 and 36.
 	 * - undefined.
 	 * @param {ASTNode} radix A node of radix to check.
+	 * @param {SourceCode} sourceCode The source code object.
 	 * @returns {boolean} `true` if the node is valid.
 	 */
-	function isValidRadix(radix) {
+	function isValidRadix(radix, sourceCode) {
+		if (
+			radix.type === "UnaryExpression" &&
+			(radix.operator === "-" || radix.operator === "+") &&
+			radix.argument.type === "Literal" &&
+			typeof radix.argument.value === "number"
+		) {
+			const value =
+				radix.operator === "-"
+					? -radix.argument.value
+					: radix.argument.value;
+
+			return validRadixValues.has(value);
+		}
+
 		return !(
 			(radix.type === "Literal" && !validRadixValues.has(radix.value)) ||
-			(radix.type === "Identifier" && radix.name === "undefined")
+			(radix.type === "Identifier" &&
+				radix.name === "undefined" &&
+				sourceCode.isGlobalReference(radix))
 		);
 	}
 
@@ -119412,49 +119829,47 @@ function requireRadix () {
 			 */
 			function checkArguments(node) {
 				const args = node.arguments;
+				const spreadIndex = args.findIndex(
+					arg => arg.type === "SpreadElement",
+				);
 
-				switch (args.length) {
-					case 0:
-						context.report({
-							node,
-							messageId: "missingParameters",
-						});
-						break;
+				if (spreadIndex !== -1 && spreadIndex < 2) {
+					return;
+				}
 
-					case 1:
-						context.report({
-							node,
-							messageId: "missingRadix",
-							suggest: [
-								{
-									messageId: "addRadixParameter10",
-									fix(fixer) {
-										const tokens = sourceCode.getTokens(node);
-										const lastToken = tokens.at(-1); // Parenthesis.
-										const secondToLastToken = tokens.at(-2); // May or may not be a comma.
-										const hasTrailingComma =
-											secondToLastToken.type ===
-												"Punctuator" &&
-											secondToLastToken.value === ",";
-
-										return fixer.insertTextBefore(
-											lastToken,
-											hasTrailingComma ? " 10," : ", 10",
-										);
-									},
-								},
-							],
-						});
-						break;
+				if (args.length === 0) {
+					context.report({
+						node,
+						messageId: "missingParameters",
+					});
+				} else if (args.length === 1) {
+					context.report({
+						node,
+						messageId: "missingRadix",
+						suggest: [
+							{
+								messageId: "addRadixParameter10",
+								fix(fixer) {
+									const lastToken = sourceCode.getLastToken(node);
+									const prevToken =
+										sourceCode.getTokenBefore(lastToken);
 
-					default:
-						if (!isValidRadix(args[1])) {
-							context.report({
-								node,
-								messageId: "invalidRadix",
-							});
-						}
-						break;
+									const hasTrailingComma =
+										astUtils.isCommaToken(prevToken);
+
+									return fixer.insertTextBefore(
+										lastToken,
+										hasTrailingComma ? " 10," : ", 10",
+									);
+								},
+							},
+						],
+					});
+				} else if (!isValidRadix(args[1], sourceCode)) {
+					context.report({
+						node,
+						messageId: "invalidRadix",
+					});
 				}
 			}
 
@@ -119486,7 +119901,11 @@ function requireRadix () {
 									: parentNode;
 
 							if (
-								isParseIntMethod(parentNode) &&
+								astUtils.isSpecificMemberAccess(
+									parentNode,
+									"Number",
+									"parseInt",
+								) &&
 								astUtils.isCallee(maybeCallee)
 							) {
 								checkArguments(maybeCallee.parent);
@@ -125421,9 +125840,10 @@ function requireUseIsnan () {
 	/**
 	 * Determines if the given node is a NaN `Identifier` node.
 	 * @param {ASTNode|null} node The node to check.
-	 * @returns {boolean} `true` if the node is 'NaN' identifier.
+	 * @param {SourceCode} sourceCode The source code object.
+	 * @returns {boolean} `true` if the node is a global 'NaN' identifier.
 	 */
-	function isNaNIdentifier(node) {
+	function isNaNIdentifier(node, sourceCode) {
 		if (!node) {
 			return false;
 		}
@@ -125431,10 +125851,16 @@ function requireUseIsnan () {
 		const nodeToCheck =
 			node.type === "SequenceExpression" ? node.expressions.at(-1) : node;
 
-		return (
-			astUtils.isSpecificId(nodeToCheck, "NaN") ||
-			astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN")
-		);
+		if (astUtils.isSpecificId(nodeToCheck, "NaN")) {
+			return sourceCode.isGlobalReference(nodeToCheck);
+		}
+
+		if (astUtils.isSpecificMemberAccess(nodeToCheck, "Number", "NaN")) {
+			const objectNode = astUtils.skipChainExpression(nodeToCheck).object;
+			return sourceCode.isGlobalReference(objectNode);
+		}
+
+		return false;
 	}
 
 	//------------------------------------------------------------------------------
@@ -125506,7 +125932,7 @@ function requireUseIsnan () {
 			 */
 			function getBinaryExpressionFixer(node, wrapValue) {
 				return fixer => {
-					const comparedValue = isNaNIdentifier(node.left)
+					const comparedValue = isNaNIdentifier(node.left, sourceCode)
 						? node.right
 						: node.left;
 					const shouldWrap = comparedValue.type === "SequenceExpression";
@@ -125533,10 +125959,11 @@ function requireUseIsnan () {
 			function checkBinaryExpression(node) {
 				if (
 					/^(?:[<>]|[!=]=)=?$/u.test(node.operator) &&
-					(isNaNIdentifier(node.left) || isNaNIdentifier(node.right))
+					(isNaNIdentifier(node.left, sourceCode) ||
+						isNaNIdentifier(node.right, sourceCode))
 				) {
 					const suggestedFixes = [];
-					const NaNNode = isNaNIdentifier(node.left)
+					const NaNNode = isNaNIdentifier(node.left, sourceCode)
 						? node.left
 						: node.right;
 
@@ -125581,12 +126008,12 @@ function requireUseIsnan () {
 			 * @returns {void}
 			 */
 			function checkSwitchStatement(node) {
-				if (isNaNIdentifier(node.discriminant)) {
+				if (isNaNIdentifier(node.discriminant, sourceCode)) {
 					context.report({ node, messageId: "switchNaN" });
 				}
 
 				for (const switchCase of node.cases) {
-					if (isNaNIdentifier(switchCase.test)) {
+					if (isNaNIdentifier(switchCase.test, sourceCode)) {
 						context.report({ node: switchCase, messageId: "caseNaN" });
 					}
 				}
@@ -125607,7 +126034,7 @@ function requireUseIsnan () {
 						(methodName === "indexOf" ||
 							methodName === "lastIndexOf") &&
 						node.arguments.length <= 2 &&
-						isNaNIdentifier(node.arguments[0])
+						isNaNIdentifier(node.arguments[0], sourceCode)
 					) {
 						/*
 						 * To retain side effects, it's essential to address `NaN` beforehand, which