eslint-linter-browserify 10.4.1 → 10.6.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.4.1";
+var version = "10.6.0";
 var require$$3$1 = {
 	version: version};
 
@@ -50101,6 +50101,36 @@ function requireArrayBracketSpacing () {
 	return arrayBracketSpacing;
 }
 
+/**
+ * @fileoverview Code path related utilities.
+ */
+
+var codePathUtils;
+var hasRequiredCodePathUtils;
+
+function requireCodePathUtils () {
+	if (hasRequiredCodePathUtils) return codePathUtils;
+	hasRequiredCodePathUtils = 1;
+
+	/**
+	 * 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;
+	}
+
+	codePathUtils = { isAnySegmentReachable };
+	return codePathUtils;
+}
+
 /**
  * @fileoverview Rule to enforce return statements in callbacks of array's methods
  * @author Toru Nagashima
@@ -50118,6 +50148,7 @@ function requireArrayCallbackReturn () {
 	//------------------------------------------------------------------------------
 
 	const astUtils = requireAstUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -50138,21 +50169,6 @@ function requireArrayCallbackReturn () {
 		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
@@ -55364,26 +55380,12 @@ function requireConsistentReturn () {
 
 	const astUtils = requireAstUtils();
 	const { upperCaseFirst } = requireStringUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// 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
@@ -55454,7 +55456,7 @@ function requireConsistentReturn () {
 				 */
 				if (
 					!funcInfo.hasReturnValue ||
-					areAllSegmentsUnreachable(funcInfo.currentSegments) ||
+					!isAnySegmentReachable(funcInfo.currentSegments) ||
 					astUtils.isES5Constructor(node) ||
 					isClassConstructor(node)
 				) {
@@ -59846,6 +59848,7 @@ function requireGetterReturn () {
 	//------------------------------------------------------------------------------
 
 	const astUtils = requireAstUtils();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -59853,21 +59856,6 @@ function requireGetterReturn () {
 
 	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
 	//------------------------------------------------------------------------------
@@ -69778,6 +69766,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,
@@ -69861,6 +69853,8 @@ function requireMaxDepth () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			//--------------------------------------------------------------------------
 			// Helpers
 			//--------------------------------------------------------------------------
@@ -69909,6 +69903,7 @@ function requireMaxDepth () {
 				if (len > maxDepth) {
 					context.report({
 						node,
+						loc: sourceCode.getFirstToken(node).loc,
 						messageId: "tooDeeply",
 						data: { depth: len, maxDepth },
 					});
@@ -69924,6 +69919,18 @@ function requireMaxDepth () {
 				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
 			//--------------------------------------------------------------------------
@@ -69936,7 +69943,7 @@ function requireMaxDepth () {
 				StaticBlock: startFunction,
 
 				IfStatement(node) {
-					if (node.parent.type !== "IfStatement") {
+					if (!isElseIf(node)) {
 						pushBlock(node);
 					}
 				},
@@ -69949,7 +69956,11 @@ function requireMaxDepth () {
 				ForInStatement: pushBlock,
 				ForOfStatement: pushBlock,
 
-				"IfStatement:exit": popBlock,
+				"IfStatement:exit"(node) {
+					if (!isElseIf(node)) {
+						popBlock();
+					}
+				},
 				"SwitchStatement:exit": popBlock,
 				"TryStatement:exit": popBlock,
 				"DoWhileStatement:exit": popBlock,
@@ -70906,6 +70917,7 @@ function requireMaxLinesPerFunction () {
 
 					context.report({
 						node,
+						loc: astUtils.getFunctionHeadLoc(funcNode, sourceCode),
 						messageId: "exceed",
 						data: { name, lineCount, maxLines },
 					});
@@ -70938,6 +70950,12 @@ function requireMaxNestedCallbacks () {
 	if (hasRequiredMaxNestedCallbacks) return maxNestedCallbacks;
 	hasRequiredMaxNestedCallbacks = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const astUtils = requireAstUtils();
+
 	//------------------------------------------------------------------------------
 	// Rule Definition
 	//------------------------------------------------------------------------------
@@ -70986,6 +71004,8 @@ function requireMaxNestedCallbacks () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			//--------------------------------------------------------------------------
 			// Constants
 			//--------------------------------------------------------------------------
@@ -71016,24 +71036,34 @@ function requireMaxNestedCallbacks () {
 			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();
+				}
 			}
 
 			//--------------------------------------------------------------------------
@@ -71325,6 +71355,7 @@ function requireMaxStatements () {
 
 					context.report({
 						node,
+						loc: astUtils.getFunctionHeadLoc(node, context.sourceCode),
 						messageId: "exceed",
 						data: { name, count, max },
 					});
@@ -75573,6 +75604,8 @@ function requireNoConstantBinaryExpression () {
 		">>>",
 	]);
 
+	const RELATIONAL_OPERATORS = new Set(["<", "<=", ">", ">="]);
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -75632,7 +75665,9 @@ function requireNoConstantBinaryExpression () {
 				return (
 					(functionName === "Boolean" ||
 						functionName === "String" ||
-						functionName === "Number") &&
+						functionName === "Number" ||
+						functionName === "Symbol" ||
+						functionName === "BigInt") &&
 					isReferenceToGlobalVariable(scope, node.callee)
 				);
 			}
@@ -75917,7 +75952,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;
@@ -76030,6 +76068,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
 	//------------------------------------------------------------------------------
@@ -76044,7 +76109,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}}`.",
@@ -76054,11 +76134,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) {
@@ -76132,6 +76215,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 },
+							});
+						}
 					}
 				},
 
@@ -83058,7 +83155,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)
 				);
 			}
 
@@ -83290,7 +83388,8 @@ function requireNoExtraBooleanCast () {
 				CallExpression(node) {
 					if (
 						node.callee.type !== "Identifier" ||
-						node.callee.name !== "Boolean"
+						node.callee.name !== "Boolean" ||
+						!sourceCode.isGlobalReference(node.callee)
 					) {
 						return;
 					}
@@ -85431,6 +85530,7 @@ function requireNoFallthrough () {
 	//------------------------------------------------------------------------------
 
 	const { directivesPattern } = requireDirectives();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -85438,21 +85538,6 @@ function requireNoFallthrough () {
 
 	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.
@@ -94125,10 +94210,11 @@ function requireNoPromiseExecutorReturn () {
 							});
 						}
 
-						// 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
 							)
 						) {
@@ -100229,12 +100315,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" });
 						}
 					}
@@ -102039,6 +102130,12 @@ function requireNoUnreachable () {
 	if (hasRequiredNoUnreachable) return noUnreachable;
 	hasRequiredNoUnreachable = 1;
 
+	//------------------------------------------------------------------------------
+	// Requirements
+	//------------------------------------------------------------------------------
+
+	const { isAnySegmentReachable } = requireCodePathUtils();
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -102058,21 +102155,6 @@ function requireNoUnreachable () {
 		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.
 	 */
@@ -102189,7 +102271,7 @@ function requireNoUnreachable () {
 				if (
 					node &&
 					(node.type === "PropertyDefinition" ||
-						areAllSegmentsUnreachable(currentCodePathSegments))
+						!isAnySegmentReachable(currentCodePathSegments))
 				) {
 					// Store this statement to distinguish consecutive statements.
 					if (range.isEmpty) {
@@ -102348,6 +102430,8 @@ function requireNoUnreachableLoop () {
 	if (hasRequiredNoUnreachableLoop) return noUnreachableLoop;
 	hasRequiredNoUnreachableLoop = 1;
 
+	const { isAnySegmentReachable } = requireCodePathUtils();
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -102360,21 +102444,6 @@ function requireNoUnreachableLoop () {
 		"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.
@@ -108448,6 +108517,7 @@ function requireNoUselessReturn () {
 
 	const astUtils = requireAstUtils(),
 		FixTracker = requireFixTracker();
+	const { isAnySegmentReachable } = requireCodePathUtils();
 
 	//------------------------------------------------------------------------------
 	// Helpers
@@ -108498,21 +108568,6 @@ function requireNoUselessReturn () {
 		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
 	//------------------------------------------------------------------------------
@@ -109739,9 +109794,15 @@ function requireNoWith () {
 		},
 
 		create(context) {
+			const sourceCode = context.sourceCode;
+
 			return {
 				WithStatement(node) {
-					context.report({ node, messageId: "unexpectedWith" });
+					context.report({
+						node,
+						loc: sourceCode.getFirstToken(node).loc,
+						messageId: "unexpectedWith",
+					});
 				},
 			};
 		},
@@ -115351,6 +115412,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.
@@ -115479,11 +115545,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 = "";
@@ -115536,6 +115627,15 @@ function requirePreferExponentiationOperator () {
 								shouldParenthesizeAll,
 							);
 
+						if (
+							!prefix &&
+							isStartOfExpressionStatement &&
+							continuationChars.has(replacement[0]) &&
+							astUtils.needsPrecedingSemicolon(sourceCode, node)
+						) {
+							prefix = ";";
+						}
+
 						return fixer.replaceText(
 							node,
 							`${prefix}${replacement}${suffix}`,
@@ -116490,11 +116590,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,
@@ -116509,10 +116613,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,
+					)
 				);
 			}
 
@@ -116537,6 +116646,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 &&
@@ -119376,12 +119486,15 @@ 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) {
 		return !(
 			(radix.type === "Literal" && !validRadixValues.has(radix.value)) ||
-			(radix.type === "Identifier" && radix.name === "undefined")
+			(radix.type === "Identifier" &&
+				radix.name === "undefined" &&
+				sourceCode.isGlobalReference(radix))
 		);
 	}
 
@@ -119467,7 +119580,7 @@ function requireRadix () {
 						break;
 
 					default:
-						if (!isValidRadix(args[1])) {
+						if (!isValidRadix(args[1], sourceCode)) {
 							context.report({
 								node,
 								messageId: "invalidRadix",