eslint-linter-browserify 10.5.0 → 10.6.0

package/linter.cjs

@@ -4216,7 +4216,7 @@ function requireEslintVisitorKeys$2 () {
 	return eslintVisitorKeys$2;
 }
 
-var version = "10.5.0";
+var version = "10.6.0";
 var require$$3$1 = {
 	version: version};
 
@@ -69766,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,
@@ -71032,10 +71036,12 @@ 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 };
 
@@ -75598,6 +75604,8 @@ function requireNoConstantBinaryExpression () {
 		">>>",
 	]);
 
+	const RELATIONAL_OPERATORS = new Set(["<", "<=", ">", ">="]);
+
 	//------------------------------------------------------------------------------
 	// Helpers
 	//------------------------------------------------------------------------------
@@ -75657,7 +75665,9 @@ function requireNoConstantBinaryExpression () {
 				return (
 					(functionName === "Boolean" ||
 						functionName === "String" ||
-						functionName === "Number") &&
+						functionName === "Number" ||
+						functionName === "Symbol" ||
+						functionName === "BigInt") &&
 					isReferenceToGlobalVariable(scope, node.callee)
 				);
 			}
@@ -75942,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;
@@ -76055,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
 	//------------------------------------------------------------------------------
@@ -76069,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}}`.",
@@ -76079,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) {
@@ -76157,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 },
+							});
+						}
 					}
 				},
 
@@ -83083,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)
 				);
 			}
 
@@ -83315,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;
 					}
@@ -94136,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
 							)
 						) {
@@ -100240,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" });
 						}
 					}
@@ -115332,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.
@@ -115460,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 = "";
@@ -115517,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}`,
@@ -116471,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,
@@ -116490,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,
+					)
 				);
 			}
 
@@ -116518,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 &&
@@ -119357,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))
 		);
 	}
 
@@ -119448,7 +119580,7 @@ function requireRadix () {
 						break;
 
 					default:
-						if (!isValidRadix(args[1])) {
+						if (!isValidRadix(args[1], sourceCode)) {
 							context.report({
 								node,
 								messageId: "invalidRadix",

package/linter.js

@@ -4218,7 +4218,7 @@
 		return eslintVisitorKeys$2;
 	}
 
-	var version = "10.5.0";
+	var version = "10.6.0";
 	var require$$3$1 = {
 		version: version};
 
@@ -69768,6 +69768,10 @@
 						if (classCount > max) {
 							context.report({
 								node,
+								loc: {
+									start: node.body[0].loc.start,
+									end: node.body.at(-1).loc.end,
+								},
 								messageId: "maximumExceeded",
 								data: {
 									classCount,
@@ -71034,10 +71038,12 @@
 				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 };
 
@@ -75600,6 +75606,8 @@
 			">>>",
 		]);
 
+		const RELATIONAL_OPERATORS = new Set(["<", "<=", ">", ">="]);
+
 		//------------------------------------------------------------------------------
 		// Helpers
 		//------------------------------------------------------------------------------
@@ -75659,7 +75667,9 @@
 					return (
 						(functionName === "Boolean" ||
 							functionName === "String" ||
-							functionName === "Number") &&
+							functionName === "Number" ||
+							functionName === "Symbol" ||
+							functionName === "BigInt") &&
 						isReferenceToGlobalVariable(scope, node.callee)
 					);
 				}
@@ -75944,7 +75954,10 @@
 					const functionName = node.callee.name;
 
 					if (
-						(functionName === "String" || functionName === "Number") &&
+						(functionName === "String" ||
+							functionName === "Number" ||
+							functionName === "BigInt" ||
+							functionName === "Symbol") &&
 						isReferenceToGlobalVariable(scope, node.callee)
 					) {
 						return true;
@@ -76057,6 +76070,33 @@
 			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
 		//------------------------------------------------------------------------------
@@ -76071,7 +76111,22 @@
 					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}}`.",
@@ -76081,11 +76136,14 @@
 						"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) {
@@ -76159,6 +76217,20 @@
 									messageId: "bothAlwaysNew",
 								});
 							}
+						} else if (
+							checkRelationalComparisons &&
+							RELATIONAL_OPERATORS.has(operator)
+						) {
+							if (
+								isStaticLiteral(scope, left) &&
+								isStaticLiteral(scope, right)
+							) {
+								context.report({
+									node,
+									messageId: "constantRelationalComparison",
+									data: { operator },
+								});
+							}
 						}
 					},
 
@@ -83085,7 +83157,8 @@
 						(node.type === "CallExpression" ||
 							node.type === "NewExpression") &&
 						node.callee.type === "Identifier" &&
-						node.callee.name === "Boolean"
+						node.callee.name === "Boolean" &&
+						sourceCode.isGlobalReference(node.callee)
 					);
 				}
 
@@ -83317,7 +83390,8 @@
 					CallExpression(node) {
 						if (
 							node.callee.type !== "Identifier" ||
-							node.callee.name !== "Boolean"
+							node.callee.name !== "Boolean" ||
+							!sourceCode.isGlobalReference(node.callee)
 						) {
 							return;
 						}
@@ -94138,10 +94212,11 @@
 								});
 							}
 
-							// 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
 								)
 							) {
@@ -100242,12 +100317,17 @@
 			},
 
 			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" });
 							}
 						}
@@ -115334,6 +115414,11 @@
 			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.
@@ -115462,11 +115547,36 @@
 								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 = "";
@@ -115519,6 +115629,15 @@
 									shouldParenthesizeAll,
 								);
 
+							if (
+								!prefix &&
+								isStartOfExpressionStatement &&
+								continuationChars.has(replacement[0]) &&
+								astUtils.needsPrecedingSemicolon(sourceCode, node)
+							) {
+								prefix = ";";
+							}
+
 							return fixer.replaceText(
 								node,
 								`${prefix}${replacement}${suffix}`,
@@ -116473,11 +116592,15 @@
 					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,
@@ -116492,10 +116615,15 @@
 				 * @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,
+						)
 					);
 				}
 
@@ -116520,6 +116648,7 @@
 						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 &&
@@ -119359,12 +119488,15 @@
 		 * - 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))
 			);
 		}
 
@@ -119450,7 +119582,7 @@
 							break;
 
 						default:
-							if (!isValidRadix(args[1])) {
+							if (!isValidRadix(args[1], sourceCode)) {
 								context.report({
 									node,
 									messageId: "invalidRadix",