oxlint-plugin-eslint 1.52.0

package/rules/no-extra-parens.cjs

@@ -0,0 +1,665 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_eslint_utils$1 = require("../common/eslint-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-extra-parens.js
+/**
+* @fileoverview Disallow parenthesising higher precedence subexpressions.
+* @author Michael Ficarra
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_extra_parens = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { isParenthesized: isParenthesizedRaw } = require_eslint_utils$1.t(), astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "no-extra-parens",
+						url: "https://eslint.style/rules/no-extra-parens"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow unnecessary parentheses",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-extra-parens"
+			},
+			fixable: "code",
+			schema: { anyOf: [{
+				type: "array",
+				items: [{ enum: ["functions"] }],
+				minItems: 0,
+				maxItems: 1
+			}, {
+				type: "array",
+				items: [{ enum: ["all"] }, {
+					type: "object",
+					properties: {
+						conditionalAssign: { type: "boolean" },
+						ternaryOperandBinaryExpressions: { type: "boolean" },
+						nestedBinaryExpressions: { type: "boolean" },
+						returnAssign: { type: "boolean" },
+						ignoreJSX: { enum: [
+							"none",
+							"all",
+							"single-line",
+							"multi-line"
+						] },
+						enforceForArrowConditionals: { type: "boolean" },
+						enforceForSequenceExpressions: { type: "boolean" },
+						enforceForNewInMemberExpressions: { type: "boolean" },
+						enforceForFunctionPrototypeMethods: { type: "boolean" },
+						allowParensAfterCommentPattern: { type: "string" }
+					},
+					additionalProperties: !1
+				}],
+				minItems: 0,
+				maxItems: 2
+			}] },
+			messages: { unexpected: "Unnecessary parentheses around expression." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, tokensToIgnore = /* @__PURE__ */ new WeakSet(), precedence = astUtils.getPrecedence, ALL_NODES = context.options[0] !== "functions", EXCEPT_COND_ASSIGN = ALL_NODES && context.options[1] && context.options[1].conditionalAssign === !1, EXCEPT_COND_TERNARY = ALL_NODES && context.options[1] && context.options[1].ternaryOperandBinaryExpressions === !1, NESTED_BINARY = ALL_NODES && context.options[1] && context.options[1].nestedBinaryExpressions === !1, EXCEPT_RETURN_ASSIGN = ALL_NODES && context.options[1] && context.options[1].returnAssign === !1, IGNORE_JSX = ALL_NODES && context.options[1] && context.options[1].ignoreJSX, IGNORE_ARROW_CONDITIONALS = ALL_NODES && context.options[1] && context.options[1].enforceForArrowConditionals === !1, IGNORE_SEQUENCE_EXPRESSIONS = ALL_NODES && context.options[1] && context.options[1].enforceForSequenceExpressions === !1, IGNORE_NEW_IN_MEMBER_EXPR = ALL_NODES && context.options[1] && context.options[1].enforceForNewInMemberExpressions === !1, IGNORE_FUNCTION_PROTOTYPE_METHODS = ALL_NODES && context.options[1] && context.options[1].enforceForFunctionPrototypeMethods === !1, ALLOW_PARENS_AFTER_COMMENT_PATTERN = ALL_NODES && context.options[1] && context.options[1].allowParensAfterCommentPattern, PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" }), PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: "UpdateExpression" }), reportsBuffer;
+			/**
+			* Determines whether the given node is a `call` or `apply` method call, invoked directly on a `FunctionExpression` node.
+			* Example: function(){}.call()
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is an immediate `call` or `apply` method call.
+			* @private
+			*/
+			function isImmediateFunctionPrototypeMethodCall(node) {
+				let callNode = astUtils.skipChainExpression(node);
+				if (callNode.type !== "CallExpression") return !1;
+				let callee = astUtils.skipChainExpression(callNode.callee);
+				return callee.type === "MemberExpression" && callee.object.type === "FunctionExpression" && ["call", "apply"].includes(astUtils.getStaticPropertyName(callee));
+			}
+			/**
+			* Determines if this rule should be enforced for a node given the current configuration.
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the rule should be enforced for this node.
+			* @private
+			*/
+			function ruleApplies(node) {
+				if (node.type === "JSXElement" || node.type === "JSXFragment") {
+					let isSingleLine = node.loc.start.line === node.loc.end.line;
+					switch (IGNORE_JSX) {
+						case "all": return !1;
+						case "multi-line": return isSingleLine;
+						case "single-line": return !isSingleLine;
+						case "none": break;
+					}
+				}
+				return node.type === "SequenceExpression" && IGNORE_SEQUENCE_EXPRESSIONS || isImmediateFunctionPrototypeMethodCall(node) && IGNORE_FUNCTION_PROTOTYPE_METHODS ? !1 : ALL_NODES || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+			}
+			/**
+			* Determines if a node is surrounded by parentheses.
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is parenthesised.
+			* @private
+			*/
+			function isParenthesised(node) {
+				return isParenthesizedRaw(1, node, sourceCode);
+			}
+			/**
+			* Determines if a node is surrounded by parentheses twice.
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is doubly parenthesised.
+			* @private
+			*/
+			function isParenthesisedTwice(node) {
+				return isParenthesizedRaw(2, node, sourceCode);
+			}
+			/**
+			* Determines if a node is surrounded by (potentially) invalid parentheses.
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is incorrectly parenthesised.
+			* @private
+			*/
+			function hasExcessParens(node) {
+				return ruleApplies(node) && isParenthesised(node);
+			}
+			/**
+			* Determines if a node that is expected to be parenthesised is surrounded by
+			* (potentially) invalid extra parentheses.
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is has an unexpected extra pair of parentheses.
+			* @private
+			*/
+			function hasDoubleExcessParens(node) {
+				return ruleApplies(node) && isParenthesisedTwice(node);
+			}
+			/**
+			* Determines if a node that is expected to be parenthesised is surrounded by
+			* (potentially) invalid extra parentheses with considering precedence level of the node.
+			* If the preference level of the node is not higher or equal to precedence lower limit, it also checks
+			* whether the node is surrounded by parentheses twice or not.
+			* @param {ASTNode} node The node to be checked.
+			* @param {number} precedenceLowerLimit The lower limit of precedence.
+			* @returns {boolean} True if the node is has an unexpected extra pair of parentheses.
+			* @private
+			*/
+			function hasExcessParensWithPrecedence(node, precedenceLowerLimit) {
+				return !!(ruleApplies(node) && isParenthesised(node) && (precedence(node) >= precedenceLowerLimit || isParenthesisedTwice(node)));
+			}
+			/**
+			* Determines if a node test expression is allowed to have a parenthesised assignment
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the assignment can be parenthesised.
+			* @private
+			*/
+			function isCondAssignException(node) {
+				return EXCEPT_COND_ASSIGN && node.test.type === "AssignmentExpression";
+			}
+			/**
+			* Determines if a node is in a return statement
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is in a return statement.
+			* @private
+			*/
+			function isInReturnStatement(node) {
+				for (let currentNode = node; currentNode; currentNode = currentNode.parent) if (currentNode.type === "ReturnStatement" || currentNode.type === "ArrowFunctionExpression" && currentNode.body.type !== "BlockStatement") return !0;
+				return !1;
+			}
+			/**
+			* Determines if a constructor function is newed-up with parens
+			* @param {ASTNode} newExpression The NewExpression node to be checked.
+			* @returns {boolean} True if the constructor is called with parens.
+			* @private
+			*/
+			function isNewExpressionWithParens(newExpression) {
+				let lastToken = sourceCode.getLastToken(newExpression), penultimateToken = sourceCode.getTokenBefore(lastToken);
+				return newExpression.arguments.length > 0 || astUtils.isOpeningParenToken(penultimateToken) && astUtils.isClosingParenToken(lastToken) && newExpression.callee.range[1] < newExpression.range[1];
+			}
+			/**
+			* Determines if a node is or contains an assignment expression
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is or contains an assignment expression.
+			* @private
+			*/
+			function containsAssignment(node) {
+				return !!(node.type === "AssignmentExpression" || node.type === "ConditionalExpression" && (node.consequent.type === "AssignmentExpression" || node.alternate.type === "AssignmentExpression") || node.left && node.left.type === "AssignmentExpression" || node.right && node.right.type === "AssignmentExpression");
+			}
+			/**
+			* Determines if a node is contained by or is itself a return statement and is allowed to have a parenthesised assignment
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the assignment can be parenthesised.
+			* @private
+			*/
+			function isReturnAssignException(node) {
+				return !EXCEPT_RETURN_ASSIGN || !isInReturnStatement(node) ? !1 : node.type === "ReturnStatement" ? node.argument && containsAssignment(node.argument) : node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement" ? containsAssignment(node.body) : containsAssignment(node);
+			}
+			/**
+			* Determines if a node following a [no LineTerminator here] restriction is
+			* surrounded by (potentially) invalid extra parentheses.
+			* @param {Token} token The token preceding the [no LineTerminator here] restriction.
+			* @param {ASTNode} node The node to be checked.
+			* @returns {boolean} True if the node is incorrectly parenthesised.
+			* @private
+			*/
+			function hasExcessParensNoLineTerminator(token, node) {
+				return token.loc.end.line === node.loc.start.line ? hasExcessParens(node) : hasDoubleExcessParens(node);
+			}
+			/**
+			* Determines whether a node should be preceded by an additional space when removing parens
+			* @param {ASTNode} node node to evaluate; must be surrounded by parentheses
+			* @returns {boolean} `true` if a space should be inserted before the node
+			* @private
+			*/
+			function requiresLeadingSpace(node) {
+				let leftParenToken = sourceCode.getTokenBefore(node), tokenBeforeLeftParen = sourceCode.getTokenBefore(leftParenToken, { includeComments: !0 }), tokenAfterLeftParen = sourceCode.getTokenAfter(leftParenToken, { includeComments: !0 });
+				return tokenBeforeLeftParen && tokenBeforeLeftParen.range[1] === leftParenToken.range[0] && leftParenToken.range[1] === tokenAfterLeftParen.range[0] && !astUtils.canTokensBeAdjacent(tokenBeforeLeftParen, tokenAfterLeftParen);
+			}
+			/**
+			* Determines whether a node should be followed by an additional space when removing parens
+			* @param {ASTNode} node node to evaluate; must be surrounded by parentheses
+			* @returns {boolean} `true` if a space should be inserted after the node
+			* @private
+			*/
+			function requiresTrailingSpace(node) {
+				let nextTwoTokens = sourceCode.getTokensAfter(node, { count: 2 }), rightParenToken = nextTwoTokens[0], tokenAfterRightParen = nextTwoTokens[1], tokenBeforeRightParen = sourceCode.getLastToken(node);
+				return rightParenToken && tokenAfterRightParen && !sourceCode.isSpaceBetweenTokens(rightParenToken, tokenAfterRightParen) && !astUtils.canTokensBeAdjacent(tokenBeforeRightParen, tokenAfterRightParen);
+			}
+			/**
+			* Determines if a given expression node is an IIFE
+			* @param {ASTNode} node The node to check
+			* @returns {boolean} `true` if the given node is an IIFE
+			*/
+			function isIIFE(node) {
+				let maybeCallNode = astUtils.skipChainExpression(node);
+				return maybeCallNode.type === "CallExpression" && maybeCallNode.callee.type === "FunctionExpression";
+			}
+			/**
+			* Determines if the given node can be the assignment target in destructuring or the LHS of an assignment.
+			* This is to avoid an autofix that could change behavior because parsers mistakenly allow invalid syntax,
+			* such as `(a = b) = c` and `[(a = b) = c] = []`. Ideally, this function shouldn't be necessary.
+			* @param {ASTNode} [node] The node to check
+			* @returns {boolean} `true` if the given node can be a valid assignment target
+			*/
+			function canBeAssignmentTarget(node) {
+				return node && (node.type === "Identifier" || node.type === "MemberExpression");
+			}
+			/**
+			* Checks if a node is fixable.
+			* A node is fixable if removing a single pair of surrounding parentheses does not turn it
+			* into a directive after fixing other nodes.
+			* Almost all nodes are fixable, except if all of the following conditions are met:
+			* The node is a string Literal
+			* It has a single pair of parentheses
+			* It is the only child of an ExpressionStatement
+			* @param {ASTNode} node The node to evaluate.
+			* @returns {boolean} Whether or not the node is fixable.
+			* @private
+			*/
+			function isFixable(node) {
+				return node.type !== "Literal" || typeof node.value != "string" || isParenthesisedTwice(node) ? !0 : !astUtils.isTopLevelExpressionStatement(node.parent);
+			}
+			/**
+			* Report the node
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function report(node) {
+				let leftParenToken = sourceCode.getTokenBefore(node), rightParenToken = sourceCode.getTokenAfter(node);
+				if (!isParenthesisedTwice(node)) {
+					if (tokensToIgnore.has(sourceCode.getFirstToken(node)) || isIIFE(node) && !isParenthesised(node.callee)) return;
+					if (ALLOW_PARENS_AFTER_COMMENT_PATTERN) {
+						let commentsBeforeLeftParenToken = sourceCode.getCommentsBefore(leftParenToken), totalCommentsBeforeLeftParenTokenCount = commentsBeforeLeftParenToken.length, ignorePattern = new RegExp(ALLOW_PARENS_AFTER_COMMENT_PATTERN, "u");
+						if (totalCommentsBeforeLeftParenTokenCount > 0 && ignorePattern.test(commentsBeforeLeftParenToken[totalCommentsBeforeLeftParenTokenCount - 1].value)) return;
+					}
+				}
+				/**
+				* Finishes reporting
+				* @returns {void}
+				* @private
+				*/
+				function finishReport() {
+					context.report({
+						node,
+						loc: leftParenToken.loc,
+						messageId: "unexpected",
+						fix: isFixable(node) ? (fixer) => {
+							let parenthesizedSource = sourceCode.text.slice(leftParenToken.range[1], rightParenToken.range[0]);
+							return fixer.replaceTextRange([leftParenToken.range[0], rightParenToken.range[1]], (requiresLeadingSpace(node) ? " " : "") + parenthesizedSource + (requiresTrailingSpace(node) ? " " : ""));
+						} : null
+					});
+				}
+				if (reportsBuffer) {
+					reportsBuffer.reports.push({
+						node,
+						finishReport
+					});
+					return;
+				}
+				finishReport();
+			}
+			/**
+			* Evaluate a argument of the node.
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function checkArgumentWithPrecedence(node) {
+				hasExcessParensWithPrecedence(node.argument, precedence(node)) && report(node.argument);
+			}
+			/**
+			* Check if a member expression contains a call expression
+			* @param {ASTNode} node MemberExpression node to evaluate
+			* @returns {boolean} true if found, false if not
+			*/
+			function doesMemberExpressionContainCallExpression(node) {
+				let currentNode = node.object, currentNodeType = node.object.type;
+				for (; currentNodeType === "MemberExpression";) currentNode = currentNode.object, currentNodeType = currentNode.type;
+				return currentNodeType === "CallExpression";
+			}
+			/**
+			* Evaluate a new call
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function checkCallNew(node) {
+				let callee = node.callee;
+				hasExcessParensWithPrecedence(callee, precedence(node)) && (hasDoubleExcessParens(callee) || !(isIIFE(node) || callee.type === "NewExpression" && !isNewExpressionWithParens(callee) && !(node.type === "NewExpression" && !isNewExpressionWithParens(node)) || node.type === "NewExpression" && callee.type === "MemberExpression" && doesMemberExpressionContainCallExpression(callee) || !node.optional && callee.type === "ChainExpression")) && report(node.callee), node.arguments.filter((arg) => hasExcessParensWithPrecedence(arg, PRECEDENCE_OF_ASSIGNMENT_EXPR)).forEach(report);
+			}
+			/**
+			* Evaluate binary logicals
+			* @param {ASTNode} node node to evaluate
+			* @returns {void}
+			* @private
+			*/
+			function checkBinaryLogical(node) {
+				let prec = precedence(node), leftPrecedence = precedence(node.left), rightPrecedence = precedence(node.right), isExponentiation = node.operator === "**", shouldSkipLeft = NESTED_BINARY && (node.left.type === "BinaryExpression" || node.left.type === "LogicalExpression"), shouldSkipRight = NESTED_BINARY && (node.right.type === "BinaryExpression" || node.right.type === "LogicalExpression");
+				!shouldSkipLeft && hasExcessParens(node.left) && (!(["AwaitExpression", "UnaryExpression"].includes(node.left.type) && isExponentiation) && !astUtils.isMixedLogicalAndCoalesceExpressions(node.left, node) && (leftPrecedence > prec || leftPrecedence === prec && !isExponentiation) || isParenthesisedTwice(node.left)) && report(node.left), !shouldSkipRight && hasExcessParens(node.right) && (!astUtils.isMixedLogicalAndCoalesceExpressions(node.right, node) && (rightPrecedence > prec || rightPrecedence === prec && isExponentiation) || isParenthesisedTwice(node.right)) && report(node.right);
+			}
+			/**
+			* Check the parentheses around the super class of the given class definition.
+			* @param {ASTNode} node The node of class declarations to check.
+			* @returns {void}
+			*/
+			function checkClass(node) {
+				node.superClass && (precedence(node.superClass) > PRECEDENCE_OF_UPDATE_EXPR ? hasExcessParens(node.superClass) : hasDoubleExcessParens(node.superClass)) && report(node.superClass);
+			}
+			/**
+			* Check the parentheses around the argument of the given spread operator.
+			* @param {ASTNode} node The node of spread elements/properties to check.
+			* @returns {void}
+			*/
+			function checkSpreadOperator(node) {
+				hasExcessParensWithPrecedence(node.argument, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.argument);
+			}
+			/**
+			* Checks the parentheses for an ExpressionStatement or ExportDefaultDeclaration
+			* @param {ASTNode} node The ExpressionStatement.expression or ExportDefaultDeclaration.declaration node
+			* @returns {void}
+			*/
+			function checkExpressionOrExportStatement(node) {
+				let firstToken = isParenthesised(node) ? sourceCode.getTokenBefore(node) : sourceCode.getFirstToken(node), secondToken = sourceCode.getTokenAfter(firstToken, astUtils.isNotOpeningParenToken), thirdToken = secondToken ? sourceCode.getTokenAfter(secondToken) : null, tokenAfterClosingParens = secondToken ? sourceCode.getTokenAfter(secondToken, astUtils.isNotClosingParenToken) : null;
+				astUtils.isOpeningParenToken(firstToken) && (astUtils.isOpeningBraceToken(secondToken) || secondToken.type === "Keyword" && (secondToken.value === "function" || secondToken.value === "class" || secondToken.value === "let" && tokenAfterClosingParens && (astUtils.isOpeningBracketToken(tokenAfterClosingParens) || tokenAfterClosingParens.type === "Identifier")) || secondToken && secondToken.type === "Identifier" && secondToken.value === "async" && thirdToken && thirdToken.type === "Keyword" && thirdToken.value === "function") && tokensToIgnore.add(secondToken), (node.parent.type === "ExportDefaultDeclaration" ? hasExcessParensWithPrecedence(node, PRECEDENCE_OF_ASSIGNMENT_EXPR) : hasExcessParens(node)) && report(node);
+			}
+			/**
+			* Finds the path from the given node to the specified ancestor.
+			* @param {ASTNode} node First node in the path.
+			* @param {ASTNode} ancestor Last node in the path.
+			* @returns {ASTNode[]} Path, including both nodes.
+			* @throws {Error} If the given node does not have the specified ancestor.
+			*/
+			function pathToAncestor(node, ancestor) {
+				let path = [node], currentNode = node;
+				for (; currentNode !== ancestor;) {
+					/* c8 ignore start */
+					if (currentNode = currentNode.parent, currentNode === null) throw Error("Nodes are not in the ancestor-descendant relationship.");
+					path.push(currentNode);
+				}
+				return path;
+			}
+			/**
+			* Finds the path from the given node to the specified descendant.
+			* @param {ASTNode} node First node in the path.
+			* @param {ASTNode} descendant Last node in the path.
+			* @returns {ASTNode[]} Path, including both nodes.
+			* @throws {Error} If the given node does not have the specified descendant.
+			*/
+			function pathToDescendant(node, descendant) {
+				return pathToAncestor(descendant, node).reverse();
+			}
+			/**
+			* Checks whether the syntax of the given ancestor of an 'in' expression inside a for-loop initializer
+			* is preventing the 'in' keyword from being interpreted as a part of an ill-formed for-in loop.
+			* @param {ASTNode} node Ancestor of an 'in' expression.
+			* @param {ASTNode} child Child of the node, ancestor of the same 'in' expression or the 'in' expression itself.
+			* @returns {boolean} True if the keyword 'in' would be interpreted as the 'in' operator, without any parenthesis.
+			*/
+			function isSafelyEnclosingInExpression(node, child) {
+				switch (node.type) {
+					case "ArrayExpression":
+					case "ArrayPattern":
+					case "BlockStatement":
+					case "ObjectExpression":
+					case "ObjectPattern":
+					case "TemplateLiteral": return !0;
+					case "ArrowFunctionExpression":
+					case "FunctionExpression": return node.params.includes(child);
+					case "CallExpression":
+					case "NewExpression": return node.arguments.includes(child);
+					case "MemberExpression": return node.computed && node.property === child;
+					case "ConditionalExpression": return node.consequent === child;
+					default: return !1;
+				}
+			}
+			/**
+			* Starts a new reports buffering. Warnings will be stored in a buffer instead of being reported immediately.
+			* An additional logic that requires multiple nodes (e.g. a whole subtree) may dismiss some of the stored warnings.
+			* @returns {void}
+			*/
+			function startNewReportsBuffering() {
+				reportsBuffer = {
+					upper: reportsBuffer,
+					inExpressionNodes: [],
+					reports: []
+				};
+			}
+			/**
+			* Ends the current reports buffering.
+			* @returns {void}
+			*/
+			function endCurrentReportsBuffering() {
+				let { upper, inExpressionNodes, reports } = reportsBuffer;
+				upper ? (upper.inExpressionNodes.push(...inExpressionNodes), upper.reports.push(...reports)) : reports.forEach(({ finishReport }) => finishReport()), reportsBuffer = upper;
+			}
+			/**
+			* Checks whether the given node is in the current reports buffer.
+			* @param {ASTNode} node Node to check.
+			* @returns {boolean} True if the node is in the current buffer, false otherwise.
+			*/
+			function isInCurrentReportsBuffer(node) {
+				return reportsBuffer.reports.some((r) => r.node === node);
+			}
+			/**
+			* Removes the given node from the current reports buffer.
+			* @param {ASTNode} node Node to remove.
+			* @returns {void}
+			*/
+			function removeFromCurrentReportsBuffer(node) {
+				reportsBuffer.reports = reportsBuffer.reports.filter((r) => r.node !== node);
+			}
+			/**
+			* Checks whether a node is a MemberExpression at NewExpression's callee.
+			* @param {ASTNode} node node to check.
+			* @returns {boolean} True if the node is a MemberExpression at NewExpression's callee. false otherwise.
+			*/
+			function isMemberExpInNewCallee(node) {
+				return node.type === "MemberExpression" ? node.parent.type === "NewExpression" && node.parent.callee === node ? !0 : node.parent.object === node && isMemberExpInNewCallee(node.parent) : !1;
+			}
+			/**
+			* Checks if the left-hand side of an assignment is an identifier, the operator is one of
+			* `=`, `&&=`, `||=` or `??=` and the right-hand side is an anonymous class or function.
+			*
+			* As per https://tc39.es/ecma262/#sec-assignment-operators-runtime-semantics-evaluation, an
+			* assignment involving one of the operators `=`, `&&=`, `||=` or `??=` where the right-hand
+			* side is an anonymous class or function and the left-hand side is an *unparenthesized*
+			* identifier has different semantics than other assignments.
+			* Specifically, when an expression like `foo = function () {}` is evaluated, `foo.name`
+			* will be set to the string "foo", i.e. the identifier name. The same thing does not happen
+			* when evaluating `(foo) = function () {}`.
+			* Since the parenthesizing of the identifier in the left-hand side is significant in this
+			* special case, the parentheses, if present, should not be flagged as unnecessary.
+			* @param {ASTNode} node an AssignmentExpression node.
+			* @returns {boolean} `true` if the left-hand side of the assignment is an identifier, the
+			* operator is one of `=`, `&&=`, `||=` or `??=` and the right-hand side is an anonymous
+			* class or function; otherwise, `false`.
+			*/
+			function isAnonymousFunctionAssignmentException({ left, operator, right }) {
+				if (left.type === "Identifier" && [
+					"=",
+					"&&=",
+					"||=",
+					"??="
+				].includes(operator)) {
+					let rhsType = right.type;
+					if (rhsType === "ArrowFunctionExpression" || (rhsType === "FunctionExpression" || rhsType === "ClassExpression") && !right.id) return !0;
+				}
+				return !1;
+			}
+			return {
+				ArrayExpression(node) {
+					node.elements.filter((e) => e && hasExcessParensWithPrecedence(e, PRECEDENCE_OF_ASSIGNMENT_EXPR)).forEach(report);
+				},
+				ArrayPattern(node) {
+					node.elements.filter((e) => canBeAssignmentTarget(e) && hasExcessParens(e)).forEach(report);
+				},
+				ArrowFunctionExpression(node) {
+					if (!isReturnAssignException(node) && !(node.body.type === "ConditionalExpression" && IGNORE_ARROW_CONDITIONALS) && node.body.type !== "BlockStatement") {
+						let firstBodyToken = sourceCode.getFirstToken(node.body, astUtils.isNotOpeningParenToken), tokenBeforeFirst = sourceCode.getTokenBefore(firstBodyToken);
+						astUtils.isOpeningParenToken(tokenBeforeFirst) && astUtils.isOpeningBraceToken(firstBodyToken) && tokensToIgnore.add(firstBodyToken), hasExcessParensWithPrecedence(node.body, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.body);
+					}
+				},
+				AssignmentExpression(node) {
+					canBeAssignmentTarget(node.left) && hasExcessParens(node.left) && (!isAnonymousFunctionAssignmentException(node) || isParenthesisedTwice(node.left)) && report(node.left), !isReturnAssignException(node) && hasExcessParensWithPrecedence(node.right, precedence(node)) && report(node.right);
+				},
+				BinaryExpression(node) {
+					reportsBuffer && node.operator === "in" && reportsBuffer.inExpressionNodes.push(node), checkBinaryLogical(node);
+				},
+				CallExpression: checkCallNew,
+				ConditionalExpression(node) {
+					if (isReturnAssignException(node)) return;
+					let availableTypes = new Set(["BinaryExpression", "LogicalExpression"]);
+					!(EXCEPT_COND_TERNARY && availableTypes.has(node.test.type)) && !isCondAssignException(node) && hasExcessParensWithPrecedence(node.test, precedence({
+						type: "LogicalExpression",
+						operator: "||"
+					})) && report(node.test), !(EXCEPT_COND_TERNARY && availableTypes.has(node.consequent.type)) && hasExcessParensWithPrecedence(node.consequent, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.consequent), !(EXCEPT_COND_TERNARY && availableTypes.has(node.alternate.type)) && hasExcessParensWithPrecedence(node.alternate, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.alternate);
+				},
+				DoWhileStatement(node) {
+					hasExcessParens(node.test) && !isCondAssignException(node) && report(node.test);
+				},
+				ExportDefaultDeclaration: (node) => checkExpressionOrExportStatement(node.declaration),
+				ExpressionStatement: (node) => checkExpressionOrExportStatement(node.expression),
+				ForInStatement(node) {
+					if (node.left.type !== "VariableDeclaration") {
+						let firstLeftToken = sourceCode.getFirstToken(node.left, astUtils.isNotOpeningParenToken);
+						firstLeftToken.value === "let" && astUtils.isOpeningBracketToken(sourceCode.getTokenAfter(firstLeftToken, astUtils.isNotClosingParenToken)) && tokensToIgnore.add(firstLeftToken);
+					}
+					hasExcessParens(node.left) && report(node.left), hasExcessParens(node.right) && report(node.right);
+				},
+				ForOfStatement(node) {
+					if (node.left.type !== "VariableDeclaration") {
+						let firstLeftToken = sourceCode.getFirstToken(node.left, astUtils.isNotOpeningParenToken);
+						firstLeftToken.value === "let" && tokensToIgnore.add(firstLeftToken);
+					}
+					hasExcessParens(node.left) && report(node.left), hasExcessParensWithPrecedence(node.right, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.right);
+				},
+				ForStatement(node) {
+					if (node.test && hasExcessParens(node.test) && !isCondAssignException(node) && report(node.test), node.update && hasExcessParens(node.update) && report(node.update), node.init) {
+						if (node.init.type !== "VariableDeclaration") {
+							let firstToken = sourceCode.getFirstToken(node.init, astUtils.isNotOpeningParenToken);
+							firstToken.value === "let" && astUtils.isOpeningBracketToken(sourceCode.getTokenAfter(firstToken, astUtils.isNotClosingParenToken)) && tokensToIgnore.add(firstToken);
+						}
+						startNewReportsBuffering(), hasExcessParens(node.init) && report(node.init);
+					}
+				},
+				"ForStatement > *.init:exit"(node) {
+					reportsBuffer.reports.length && reportsBuffer.inExpressionNodes.forEach((inExpressionNode) => {
+						let path = pathToDescendant(node, inExpressionNode), nodeToExclude;
+						for (let i = 0; i < path.length; i++) {
+							let pathNode = path[i];
+							if (i < path.length - 1) {
+								let nextPathNode = path[i + 1];
+								if (isSafelyEnclosingInExpression(pathNode, nextPathNode)) return;
+							}
+							if (isParenthesised(pathNode)) if (isInCurrentReportsBuffer(pathNode)) {
+								if (isParenthesisedTwice(pathNode)) return;
+								nodeToExclude ||= pathNode;
+							} else return;
+						}
+						removeFromCurrentReportsBuffer(nodeToExclude);
+					}), endCurrentReportsBuffering();
+				},
+				IfStatement(node) {
+					hasExcessParens(node.test) && !isCondAssignException(node) && report(node.test);
+				},
+				ImportExpression(node) {
+					let { source } = node;
+					source.type === "SequenceExpression" ? hasDoubleExcessParens(source) && report(source) : hasExcessParens(source) && report(source);
+				},
+				LogicalExpression: checkBinaryLogical,
+				MemberExpression(node) {
+					let nodeObjHasExcessParens = isMemberExpInNewCallee(node) && doesMemberExpressionContainCallExpression(node) ? hasDoubleExcessParens(node.object) : hasExcessParens(node.object) && !(isImmediateFunctionPrototypeMethodCall(node.parent) && node.parent.callee === node && IGNORE_FUNCTION_PROTOTYPE_METHODS);
+					nodeObjHasExcessParens && precedence(node.object) >= precedence(node) && (node.computed || !(astUtils.isDecimalInteger(node.object) || node.object.type === "Literal" && node.object.regex)) && report(node.object), nodeObjHasExcessParens && node.object.type === "CallExpression" && report(node.object), nodeObjHasExcessParens && !IGNORE_NEW_IN_MEMBER_EXPR && node.object.type === "NewExpression" && isNewExpressionWithParens(node.object) && report(node.object), nodeObjHasExcessParens && node.optional && node.object.type === "ChainExpression" && report(node.object), node.computed && hasExcessParens(node.property) && report(node.property);
+				},
+				"MethodDefinition[computed=true]"(node) {
+					hasExcessParensWithPrecedence(node.key, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.key);
+				},
+				NewExpression: checkCallNew,
+				ObjectExpression(node) {
+					node.properties.filter((property) => property.value && hasExcessParensWithPrecedence(property.value, PRECEDENCE_OF_ASSIGNMENT_EXPR)).forEach((property) => report(property.value));
+				},
+				ObjectPattern(node) {
+					node.properties.filter((property) => {
+						let value = property.value;
+						return canBeAssignmentTarget(value) && hasExcessParens(value);
+					}).forEach((property) => report(property.value));
+				},
+				Property(node) {
+					if (node.computed) {
+						let { key } = node;
+						key && hasExcessParensWithPrecedence(key, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(key);
+					}
+				},
+				PropertyDefinition(node) {
+					node.computed && hasExcessParensWithPrecedence(node.key, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.key), node.value && hasExcessParensWithPrecedence(node.value, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(node.value);
+				},
+				RestElement(node) {
+					let argument = node.argument;
+					canBeAssignmentTarget(argument) && hasExcessParens(argument) && report(argument);
+				},
+				ReturnStatement(node) {
+					let returnToken = sourceCode.getFirstToken(node);
+					isReturnAssignException(node) || node.argument && hasExcessParensNoLineTerminator(returnToken, node.argument) && !(node.argument.type === "Literal" && node.argument.regex) && report(node.argument);
+				},
+				SequenceExpression(node) {
+					let precedenceOfNode = precedence(node);
+					node.expressions.filter((e) => hasExcessParensWithPrecedence(e, precedenceOfNode)).forEach(report);
+				},
+				SwitchCase(node) {
+					node.test && hasExcessParens(node.test) && report(node.test);
+				},
+				SwitchStatement(node) {
+					hasExcessParens(node.discriminant) && report(node.discriminant);
+				},
+				ThrowStatement(node) {
+					hasExcessParensNoLineTerminator(sourceCode.getFirstToken(node), node.argument) && report(node.argument);
+				},
+				UnaryExpression: checkArgumentWithPrecedence,
+				UpdateExpression(node) {
+					if (node.prefix) checkArgumentWithPrecedence(node);
+					else {
+						let { argument } = node, operatorToken = sourceCode.getLastToken(node);
+						argument.loc.end.line === operatorToken.loc.start.line ? checkArgumentWithPrecedence(node) : hasDoubleExcessParens(argument) && report(argument);
+					}
+				},
+				AwaitExpression: checkArgumentWithPrecedence,
+				VariableDeclarator(node) {
+					node.init && hasExcessParensWithPrecedence(node.init, PRECEDENCE_OF_ASSIGNMENT_EXPR) && !(node.init.type === "Literal" && node.init.regex) && report(node.init);
+				},
+				WhileStatement(node) {
+					hasExcessParens(node.test) && !isCondAssignException(node) && report(node.test);
+				},
+				WithStatement(node) {
+					hasExcessParens(node.object) && report(node.object);
+				},
+				YieldExpression(node) {
+					if (node.argument) {
+						let yieldToken = sourceCode.getFirstToken(node);
+						(precedence(node.argument) >= precedence(node) && hasExcessParensNoLineTerminator(yieldToken, node.argument) || hasDoubleExcessParens(node.argument)) && report(node.argument);
+					}
+				},
+				ClassDeclaration: checkClass,
+				ClassExpression: checkClass,
+				SpreadElement: checkSpreadOperator,
+				SpreadProperty: checkSpreadOperator,
+				ExperimentalSpreadProperty: checkSpreadOperator,
+				TemplateLiteral(node) {
+					node.expressions.filter((e) => e && hasExcessParens(e)).forEach(report);
+				},
+				AssignmentPattern(node) {
+					let { left, right } = node;
+					canBeAssignmentTarget(left) && hasExcessParens(left) && report(left), right && hasExcessParensWithPrecedence(right, PRECEDENCE_OF_ASSIGNMENT_EXPR) && report(right);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-extra-parens.cjs
+module.exports = require_no_extra_parens().create;
+//#endregion