eslint 10.4.1 → 10.6.0

package/README.md

@@ -45,7 +45,7 @@ ESLint is a tool for identifying and reporting on patterns found in ECMAScript/J
 
 ### Prerequisites
 
-To use ESLint, you must have [Node.js](https://nodejs.org/) (`^20.19.0`, `^22.13.0`, or `>=24`) installed and built with SSL support. (If you are using an official Node.js distribution, SSL is always built in.)
+To use ESLint, you must have [Node.js](https://nodejs.org/) (`^20.19.0`, `^22.13.0`, or `>=24`) installed and built with SSL and ICU support. (If you are using an official Node.js distribution, both SSL and ICU are always built in.)
 
 If you use ESLint's TypeScript type definitions, TypeScript 5.3 or later is required.
 
@@ -320,8 +320,8 @@ lumir
 </a>
 </td><td align="center" valign="top" width="11%">
 <a href="https://github.com/Pixel998">
-<img src="https://github.com/Pixel998.png?s=75" width="75" height="75" alt="Pixel998's Avatar"><br />
-Pixel998
+<img src="https://github.com/Pixel998.png?s=75" width="75" height="75" alt="Pixel's Avatar"><br />
+Pixel
 </a>
 </td></tr></tbody></table>
 
@@ -358,9 +358,9 @@ to get your logo on our READMEs and [website](https://eslint.org/sponsors).
 
 <h3>Platinum Sponsors</h3>
 <p><a href="https://automattic.com"><img src="https://images.opencollective.com/automattic/d0ef3e1/logo.png" alt="Automattic" height="128"></a></p><h3>Gold Sponsors</h3>
-<p><a href="https://qlty.sh/"><img src="https://images.opencollective.com/qltysh/33d157d/logo.png" alt="Qlty Software" height="96"></a></p><h3>Silver Sponsors</h3>
+<p><a href="https://qlty.sh/"><img src="https://images.opencollective.com/qltysh/33d157d/logo.png" alt="Qlty Software" height="96"></a> <a href="https://shopify.engineering/"><img src="https://avatars.githubusercontent.com/u/8085" alt="Shopify" height="96"></a> <a href="https://www.coderabbit.ai/?utm_source=cr_org&utm_medium=github"><img src="https://avatars.githubusercontent.com/u/132028505" alt="CodeRabbit" height="96"></a></p><h3>Silver Sponsors</h3>
 <p><a href="https://vite.dev/"><img src="https://images.opencollective.com/vite/d472863/logo.png" alt="Vite" height="64"></a> <a href="https://liftoff.io/"><img src="https://images.opencollective.com/liftoff/2d6c3b6/logo.png" alt="Liftoff" height="64"></a> <a href="https://stackblitz.com"><img src="https://avatars.githubusercontent.com/u/28635252" alt="StackBlitz" height="64"></a></p><h3>Bronze Sponsors</h3>
-<p><a href="https://cybozu.co.jp/"><img src="https://images.opencollective.com/cybozu/933e46d/logo.png" alt="Cybozu" height="32"></a> <a href="https://opensource.sap.com"><img src="https://avatars.githubusercontent.com/u/2531208" alt="SAP" height="32"></a> <a href="https://www.crawljobs.com/"><img src="https://images.opencollective.com/crawljobs-poland/fa43a17/logo.png" alt="CrawlJobs" height="32"></a> <a href="https://syntax.fm"><img src="https://github.com/syntaxfm.png" alt="Syntax" height="32"></a> <a href="https://depot.dev"><img src="https://images.opencollective.com/depot/39125a1/logo.png" alt="Depot" height="32"></a> <a href="https://icons8.com/"><img src="https://images.opencollective.com/icons8/7fa1641/logo.png" alt="Icons8" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://www.gitbook.com"><img src="https://avatars.githubusercontent.com/u/7111340" alt="GitBook" height="32"></a> <a href="https://herocoders.com"><img src="https://avatars.githubusercontent.com/u/37549774" alt="HeroCoders" height="32"></a> <a href="https://citadel.co.jp"><img src="https://avatars.githubusercontent.com/u/75781367" alt="Citadel AI" height="32"></a></p>
+<p><a href="https://cybozu.co.jp/"><img src="https://images.opencollective.com/cybozu/933e46d/logo.png" alt="Cybozu" height="32"></a> <a href="https://opensource.sap.com"><img src="https://avatars.githubusercontent.com/u/2531208" alt="SAP" height="32"></a> <a href="https://www.crawljobs.com/"><img src="https://images.opencollective.com/crawljobs-poland/fa43a17/logo.png" alt="CrawlJobs" height="32"></a> <a href="https://syntax.fm"><img src="https://github.com/syntaxfm.png" alt="Syntax" height="32"></a> <a href="https://depot.dev"><img src="https://images.opencollective.com/depot/39125a1/logo.png" alt="Depot" height="32"></a> <a href="https://icons8.com/"><img src="https://images.opencollective.com/icons8/7fa1641/logo.png" alt="Icons8" height="32"></a> <a href="https://discord.com"><img src="https://images.opencollective.com/discordapp/f9645d9/logo.png" alt="Discord" height="32"></a> <a href="https://www.gitbook.com"><img src="https://avatars.githubusercontent.com/u/7111340" alt="GitBook" height="32"></a> <a href="https://citadel.co.jp"><img src="https://avatars.githubusercontent.com/u/75781367" alt="Citadel AI" height="32"></a></p>
 <h3>Technology Sponsors</h3>
 Technology sponsors allow us to use their products and services for free as part of a contribution to the open source ecosystem and our work.
 <p><a href="https://netlify.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/netlify-icon.svg" alt="Netlify" height="32"></a> <a href="https://algolia.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/algolia-icon.svg" alt="Algolia" height="32"></a> <a href="https://1password.com"><img src="https://raw.githubusercontent.com/eslint/eslint.org/main/src/assets/images/techsponsors/1password-icon.svg" alt="1Password" height="32"></a></p>

package/lib/cli-engine/formatters/html.js

@@ -191,8 +191,8 @@ function pluralize(word, count) {
 
 /**
  * Renders text along the template of x problems (x errors, x warnings)
- * @param {string} totalErrors Total errors
- * @param {string} totalWarnings Total warnings
+ * @param {number} totalErrors Total errors
+ * @param {number} totalWarnings Total warnings
  * @returns {string} The formatted string, pluralized where necessary
  */
 function renderSummary(totalErrors, totalWarnings) {
@@ -207,8 +207,8 @@ function renderSummary(totalErrors, totalWarnings) {
 
 /**
  * Get the color based on whether there are errors/warnings...
- * @param {string} totalErrors Total errors
- * @param {string} totalWarnings Total warnings
+ * @param {number} totalErrors Total errors
+ * @param {number} totalWarnings Total warnings
  * @returns {number} The color code (0 = green, 1 = yellow, 2 = red)
  */
 function renderColor(totalErrors, totalWarnings) {

package/lib/rules/array-callback-return.js

@@ -10,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -30,21 +31,6 @@ function isTargetMethod(node) {
 	return astUtils.isSpecificMemberAccess(node, null, TARGET_METHODS);
 }
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /**
  * Returns a human-legible description of an array method
  * @param {string} arrayMethodName A method name to fully qualify

package/lib/rules/consistent-return.js

@@ -10,26 +10,12 @@
 
 const astUtils = require("./utils/ast-utils");
 const { upperCaseFirst } = require("../shared/string-utils");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
-/**
- * Checks all segments in a set and returns true if all are unreachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if all segments are unreachable; false otherwise.
- */
-function areAllSegmentsUnreachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
 /**
  * Checks whether a given node is a `constructor` method in an ES6 class
  * @param {ASTNode} node A node to check
@@ -100,7 +86,7 @@ module.exports = {
 			 */
 			if (
 				!funcInfo.hasReturnValue ||
-				areAllSegmentsUnreachable(funcInfo.currentSegments) ||
+				!isAnySegmentReachable(funcInfo.currentSegments) ||
 				astUtils.isES5Constructor(node) ||
 				isClassConstructor(node)
 			) {

package/lib/rules/getter-return.js

@@ -10,6 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -17,21 +18,6 @@ const astUtils = require("./utils/ast-utils");
 
 const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------

package/lib/rules/max-classes-per-file.js

@@ -71,6 +71,10 @@ module.exports = {
 				if (classCount > max) {
 					context.report({
 						node,
+						loc: {
+							start: node.body[0].loc.start,
+							end: node.body.at(-1).loc.end,
+						},
 						messageId: "maximumExceeded",
 						data: {
 							classCount,

package/lib/rules/max-depth.js

@@ -54,6 +54,8 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		//--------------------------------------------------------------------------
 		// Helpers
 		//--------------------------------------------------------------------------
@@ -102,6 +104,7 @@ module.exports = {
 			if (len > maxDepth) {
 				context.report({
 					node,
+					loc: sourceCode.getFirstToken(node).loc,
 					messageId: "tooDeeply",
 					data: { depth: len, maxDepth },
 				});
@@ -117,6 +120,18 @@ module.exports = {
 			functionStack[functionStack.length - 1]--;
 		}
 
+		/**
+		 * Checks whether a node is an else-if statement.
+		 * @param {ASTNode} node node to evaluate
+		 * @returns {boolean} Whether the node is an else-if statement
+		 */
+		function isElseIf(node) {
+			return (
+				node.parent.type === "IfStatement" &&
+				node.parent.alternate === node
+			);
+		}
+
 		//--------------------------------------------------------------------------
 		// Public API
 		//--------------------------------------------------------------------------
@@ -129,7 +144,7 @@ module.exports = {
 			StaticBlock: startFunction,
 
 			IfStatement(node) {
-				if (node.parent.type !== "IfStatement") {
+				if (!isElseIf(node)) {
 					pushBlock(node);
 				}
 			},
@@ -142,7 +157,11 @@ module.exports = {
 			ForInStatement: pushBlock,
 			ForOfStatement: pushBlock,
 
-			"IfStatement:exit": popBlock,
+			"IfStatement:exit"(node) {
+				if (!isElseIf(node)) {
+					popBlock();
+				}
+			},
 			"SwitchStatement:exit": popBlock,
 			"TryStatement:exit": popBlock,
 			"DoWhileStatement:exit": popBlock,

package/lib/rules/max-lines-per-function.js

@@ -222,6 +222,7 @@ module.exports = {
 
 				context.report({
 					node,
+					loc: astUtils.getFunctionHeadLoc(funcNode, sourceCode),
 					messageId: "exceed",
 					data: { name, lineCount, maxLines },
 				});

package/lib/rules/max-nested-callbacks.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -53,6 +59,8 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		//--------------------------------------------------------------------------
 		// Constants
 		//--------------------------------------------------------------------------
@@ -83,24 +91,34 @@ module.exports = {
 		function checkFunction(node) {
 			const parent = node.parent;
 
-			if (parent.type === "CallExpression") {
-				callbackStack.push(node);
+			if (parent.type !== "CallExpression" || parent.callee === node) {
+				return;
 			}
 
+			callbackStack.push(node);
+
 			if (callbackStack.length > THRESHOLD) {
 				const opts = { num: callbackStack.length, max: THRESHOLD };
 
-				context.report({ node, messageId: "exceed", data: opts });
+				context.report({
+					node,
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					messageId: "exceed",
+					data: opts,
+				});
 			}
 		}
 
 		/**
 		 * Pops the call stack.
+		 * @param {ASTNode} node The node to check.
 		 * @returns {void}
 		 * @private
 		 */
-		function popStack() {
-			callbackStack.pop();
+		function popStack(node) {
+			if (callbackStack.at(-1) === node) {
+				callbackStack.pop();
+			}
 		}
 
 		//--------------------------------------------------------------------------

package/lib/rules/max-statements.js

@@ -108,6 +108,7 @@ module.exports = {
 
 				context.report({
 					node,
+					loc: astUtils.getFunctionHeadLoc(node, context.sourceCode),
 					messageId: "exceed",
 					data: { name, count, max },
 				});

package/lib/rules/no-constant-binary-expression.js

@@ -28,6 +28,8 @@ const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set([
 	">>>",
 ]);
 
+const RELATIONAL_OPERATORS = new Set(["<", "<=", ">", ">="]);
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -87,7 +89,9 @@ function hasConstantNullishness(scope, node, nonNullish) {
 			return (
 				(functionName === "Boolean" ||
 					functionName === "String" ||
-					functionName === "Number") &&
+					functionName === "Number" ||
+					functionName === "Symbol" ||
+					functionName === "BigInt") &&
 				isReferenceToGlobalVariable(scope, node.callee)
 			);
 		}
@@ -372,7 +376,10 @@ function hasConstantStrictBooleanComparison(scope, node) {
 			const functionName = node.callee.name;
 
 			if (
-				(functionName === "String" || functionName === "Number") &&
+				(functionName === "String" ||
+					functionName === "Number" ||
+					functionName === "BigInt" ||
+					functionName === "Symbol") &&
 				isReferenceToGlobalVariable(scope, node.callee)
 			) {
 				return true;
@@ -485,6 +492,33 @@ function findBinaryExpressionConstantOperand(scope, a, b, operator) {
 	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
 //------------------------------------------------------------------------------
@@ -499,7 +533,22 @@ module.exports = {
 			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}}`.",
@@ -509,11 +558,14 @@ module.exports = {
 				"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) {
@@ -587,6 +639,20 @@ module.exports = {
 							messageId: "bothAlwaysNew",
 						});
 					}
+				} else if (
+					checkRelationalComparisons &&
+					RELATIONAL_OPERATORS.has(operator)
+				) {
+					if (
+						isStaticLiteral(scope, left) &&
+						isStaticLiteral(scope, right)
+					) {
+						context.report({
+							node,
+							messageId: "constantRelationalComparison",
+							data: { operator },
+						});
+					}
 				}
 			},
 

package/lib/rules/no-extra-boolean-cast.js

@@ -91,7 +91,8 @@ module.exports = {
 				(node.type === "CallExpression" ||
 					node.type === "NewExpression") &&
 				node.callee.type === "Identifier" &&
-				node.callee.name === "Boolean"
+				node.callee.name === "Boolean" &&
+				sourceCode.isGlobalReference(node.callee)
 			);
 		}
 
@@ -323,7 +324,8 @@ module.exports = {
 			CallExpression(node) {
 				if (
 					node.callee.type !== "Identifier" ||
-					node.callee.name !== "Boolean"
+					node.callee.name !== "Boolean" ||
+					!sourceCode.isGlobalReference(node.callee)
 				) {
 					return;
 				}

package/lib/rules/no-fallthrough.js

@@ -9,6 +9,7 @@
 //------------------------------------------------------------------------------
 
 const { directivesPattern } = require("../shared/directives");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -16,21 +17,6 @@ const { directivesPattern } = require("../shared/directives");
 
 const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /**
  * Checks whether or not a given comment string is really a fallthrough comment and not an ESLint directive.
  * @param {string} comment The comment string to check.

package/lib/rules/no-promise-executor-return.js

@@ -199,10 +199,11 @@ module.exports = {
 						});
 					}
 
-					// Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
+					// 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 === "FunctionExpression" ||
+								node.body.type === "ClassExpression") &&
 							!node.body.id
 						)
 					) {

package/lib/rules/no-throw-literal.js

@@ -31,12 +31,17 @@ module.exports = {
 	},
 
 	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" });
 					}
 				}

package/lib/rules/no-unreachable-loop.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -17,21 +19,6 @@ const allLoopTypes = [
 	"ForOfStatement",
 ];
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 /**
  * Determines whether the given node is the first node in the code path to which a loop statement
  * 'loops' for the next iteration.

package/lib/rules/no-unreachable.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -23,21 +29,6 @@ function isInitialized(node) {
 	return Boolean(node.init);
 }
 
-/**
- * Checks all segments in a set and returns true if all are unreachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if all segments are unreachable; false otherwise.
- */
-function areAllSegmentsUnreachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
 /**
  * The class to distinguish consecutive unreachable statements.
  */
@@ -154,7 +145,7 @@ module.exports = {
 			if (
 				node &&
 				(node.type === "PropertyDefinition" ||
-					areAllSegmentsUnreachable(currentCodePathSegments))
+					!isAnySegmentReachable(currentCodePathSegments))
 			) {
 				// Store this statement to distinguish consecutive statements.
 				if (range.isEmpty) {

package/lib/rules/no-useless-return.js

@@ -10,6 +10,7 @@
 
 const astUtils = require("./utils/ast-utils"),
 	FixTracker = require("./utils/fix-tracker");
+const { isAnySegmentReachable } = require("./utils/code-path-utils");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -60,21 +61,6 @@ function isInFinally(node) {
 	return false;
 }
 
-/**
- * Checks all segments in a set and returns true if any are reachable.
- * @param {Set<CodePathSegment>} segments The segments to check.
- * @returns {boolean} True if any segment is reachable; false otherwise.
- */
-function isAnySegmentReachable(segments) {
-	for (const segment of segments) {
-		if (segment.reachable) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------

package/lib/rules/no-with.js

@@ -28,9 +28,15 @@ module.exports = {
 	},
 
 	create(context) {
+		const sourceCode = context.sourceCode;
+
 		return {
 			WithStatement(node) {
-				context.report({ node, messageId: "unexpectedWith" });
+				context.report({
+					node,
+					loc: sourceCode.getFirstToken(node).loc,
+					messageId: "unexpectedWith",
+				});
 			},
 		};
 	},

package/lib/rules/prefer-exponentiation-operator.js

@@ -21,6 +21,11 @@ const PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils.getPrecedence({
 	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.
@@ -149,11 +154,36 @@ module.exports = {
 						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 = "";
@@ -206,6 +236,15 @@ module.exports = {
 							shouldParenthesizeAll,
 						);
 
+					if (
+						!prefix &&
+						isStartOfExpressionStatement &&
+						continuationChars.has(replacement[0]) &&
+						astUtils.needsPrecedingSemicolon(sourceCode, node)
+					) {
+						prefix = ";";
+					}
+
 					return fixer.replaceText(
 						node,
 						`${prefix}${replacement}${suffix}`,

package/lib/rules/prefer-promise-reject-errors.js

@@ -63,11 +63,15 @@ module.exports = {
 			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,
@@ -82,10 +86,15 @@ module.exports = {
 		 * @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,
+				)
 			);
 		}
 
@@ -110,6 +119,7 @@ module.exports = {
 				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 &&

package/lib/rules/radix.js

@@ -57,12 +57,15 @@ function isParseIntMethod(node) {
  * - 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) {
 	return !(
 		(radix.type === "Literal" && !validRadixValues.has(radix.value)) ||
-		(radix.type === "Identifier" && radix.name === "undefined")
+		(radix.type === "Identifier" &&
+			radix.name === "undefined" &&
+			sourceCode.isGlobalReference(radix))
 	);
 }
 
@@ -148,7 +151,7 @@ module.exports = {
 					break;
 
 				default:
-					if (!isValidRadix(args[1])) {
+					if (!isValidRadix(args[1], sourceCode)) {
 						context.report({
 							node,
 							messageId: "invalidRadix",

package/lib/rules/utils/code-path-utils.js

@@ -0,0 +1,22 @@
+/**
+ * @fileoverview Code path related utilities.
+ */
+
+"use strict";
+
+/**
+ * Checks all segments in a set and returns true if any are reachable.
+ * @param {Set<CodePathSegment>} segments The segments to check.
+ * @returns {boolean} `true` if any segment is reachable; `false` otherwise.
+ */
+function isAnySegmentReachable(segments) {
+	for (const segment of segments) {
+		if (segment.reachable) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+module.exports = { isAnySegmentReachable };

package/lib/types/rules.d.ts

@@ -2228,7 +2228,16 @@ export interface ESLintRules extends Linter.RulesRecord {
 	 * @since 8.14.0
 	 * @see https://eslint.org/docs/latest/rules/no-constant-binary-expression
 	 */
-	"no-constant-binary-expression": Linter.RuleEntry<[]>;
+	"no-constant-binary-expression": Linter.RuleEntry<
+		[
+			Partial<{
+				/**
+				 * @default false
+				 */
+				checkRelationalComparisons: boolean;
+			}>,
+		]
+	>;
 
 	/**
 	 * Rule to disallow constant expressions in conditions.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "10.4.1",
+  "version": "10.6.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "type": "commonjs",
@@ -78,8 +78,15 @@
     "test:fuzz": "node Makefile.js fuzz",
     "test:performance": "node Makefile.js perf",
     "test:pnpm": "cd tests/pnpm && node check.js && pnpm install && pnpm exec tsc",
-    "test:types": "tsc -p tests/lib/types/tsconfig.json"
+    "test:types": "tsc -p tests/lib/types/tsconfig.json && npm run test:types --workspaces --if-present",
+    "test:types:5.3": "npx -p typescript@5.3 -y -- tsc -p tsconfig.types-legacy.json",
+    "test:types:5.x": "npx -p typescript@5.x -y -- tsc -p tsconfig.types.json",
+    "test:types:7.x": "npx -p @typescript/native-preview@latest -y -- tsgo -p tsconfig.types.json",
+    "test:types:all": "npm run test:types && npm run test:types:5.3 && npm run test:types:5.x && npm run test:types:7.x"
   },
+  "workspaces": [
+    "packages/*"
+  ],
   "gitHooks": {
     "pre-commit": "lint-staged"
   },
@@ -151,12 +158,12 @@
     "optionator": "^0.9.3"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.18.0",
+    "@arethetypeswrong/cli": "^0.18.3",
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
     "@cypress/webpack-preprocessor": "^6.0.2",
     "@eslint/eslintrc": "^3.3.5",
-    "@eslint/json": "^1.2.0",
+    "@eslint/json": "^2.0.0",
     "@types/esquery": "^1.5.4",
     "@types/node": "^22.13.14",
     "@typescript-eslint/parser": "^8.58.2",
@@ -185,8 +192,8 @@
     "jiti": "^2.6.1",
     "knip": "^6.13.1",
     "lint-staged": "^11.0.0",
-    "markdown-it": "^12.2.0",
-    "markdown-it-container": "^3.0.0",
+    "markdown-it": "^14.2.0",
+    "markdown-it-container": "^4.0.0",
     "markdownlint-cli2": "^0.22.0",
     "marked": "^4.0.8",
     "metascraper": "^5.25.7",
@@ -198,7 +205,7 @@
     "mocha": "^11.7.1",
     "node-polyfill-webpack-plugin": "^1.0.3",
     "npm-license": "^0.3.3",
-    "prettier": "3.8.3",
+    "prettier": "3.8.4",
     "progress": "^2.0.3",
     "proxyquire": "^2.0.1",
     "regenerator-runtime": "^0.14.0",
@@ -228,10 +235,5 @@
   "license": "MIT",
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"
-  },
-  "overrides": {
-    "@arethetypeswrong/core": {
-      "fflate": "0.8.2"
-    }
   }
 }