eslint 9.22.0 → 9.23.0

package/lib/rules/utils/ast-utils.js

@@ -14,10 +14,10 @@ const esutils = require("esutils");
 const espree = require("espree");
 const escapeRegExp = require("escape-string-regexp");
 const {
-    breakableTypePattern,
-    createGlobalLinebreakMatcher,
-    lineBreakPattern,
-    shebangPattern
+	breakableTypePattern,
+	createGlobalLinebreakMatcher,
+	lineBreakPattern,
+	shebangPattern,
 } = require("../../shared/ast-utils");
 const globals = require("../../../conf/globals");
 const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version");
@@ -26,25 +26,33 @@ const { LATEST_ECMA_VERSION } = require("../../../conf/ecma-version");
 // Helpers
 //------------------------------------------------------------------------------
 
-const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
+const anyFunctionPattern =
+	/^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
 const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;
-const arrayMethodWithThisArgPattern = /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|some)$/u;
+const arrayMethodWithThisArgPattern =
+	/^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|some)$/u;
 const arrayOrTypedArrayPattern = /Array$/u;
 const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;
 const thisTagPattern = /^[\s*]*@this/mu;
 
-
-const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
+const COMMENTS_IGNORE_PATTERN =
+	/^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
 const ESLINT_DIRECTIVE_PATTERN = /^(?:eslint[- ]|(?:globals?|exported) )/u;
 const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
 
 // A set of node types that can contain a list of statements
-const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "StaticBlock", "SwitchCase"]);
+const STATEMENT_LIST_PARENTS = new Set([
+	"Program",
+	"BlockStatement",
+	"StaticBlock",
+	"SwitchCase",
+]);
 
 const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
 
 // Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string
-const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = /^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su;
+const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN =
+	/^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su;
 
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
 
@@ -63,21 +71,22 @@ const ECMASCRIPT_GLOBALS = globals[`es${LATEST_ECMA_VERSION}`];
  * @private
  */
 function isModifyingReference(reference, index, references) {
-    const identifier = reference.identifier;
-
-    /*
-     * Destructuring assignments can have multiple default value, so
-     * possibly there are multiple writeable references for the same
-     * identifier.
-     */
-    const modifyingDifferentIdentifier = index === 0 ||
-        references[index - 1].identifier !== identifier;
-
-    return (identifier &&
-        reference.init === false &&
-        reference.isWrite() &&
-        modifyingDifferentIdentifier
-    );
+	const identifier = reference.identifier;
+
+	/*
+	 * Destructuring assignments can have multiple default value, so
+	 * possibly there are multiple writeable references for the same
+	 * identifier.
+	 */
+	const modifyingDifferentIdentifier =
+		index === 0 || references[index - 1].identifier !== identifier;
+
+	return (
+		identifier &&
+		reference.init === false &&
+		reference.isWrite() &&
+		modifyingDifferentIdentifier
+	);
 }
 
 /**
@@ -86,7 +95,7 @@ function isModifyingReference(reference, index, references) {
  * @returns {boolean} `true` if the string starts with uppercase.
  */
 function startsWithUpperCase(s) {
-    return s[0] !== s[0].toLocaleLowerCase();
+	return s[0] !== s[0].toLocaleLowerCase();
 }
 
 /**
@@ -95,7 +104,7 @@ function startsWithUpperCase(s) {
  * @returns {boolean} Whether or not a node is a constructor.
  */
 function isES5Constructor(node) {
-    return (node.id && startsWithUpperCase(node.id.name));
+	return node.id && startsWithUpperCase(node.id.name);
 }
 
 /**
@@ -104,12 +113,16 @@ function isES5Constructor(node) {
  * @returns {Node|null} A found function node.
  */
 function getUpperFunction(node) {
-    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
-        if (anyFunctionPattern.test(currentNode.type)) {
-            return currentNode;
-        }
-    }
-    return null;
+	for (
+		let currentNode = node;
+		currentNode;
+		currentNode = currentNode.parent
+	) {
+		if (anyFunctionPattern.test(currentNode.type)) {
+			return currentNode;
+		}
+	}
+	return null;
 }
 
 /**
@@ -123,7 +136,7 @@ function getUpperFunction(node) {
  * @returns {boolean} `true` if the node is a function node.
  */
 function isFunction(node) {
-    return Boolean(node && anyFunctionPattern.test(node.type));
+	return Boolean(node && anyFunctionPattern.test(node.type));
 }
 
 /**
@@ -139,7 +152,7 @@ function isFunction(node) {
  * @returns {boolean} `true` if the node is a loop node.
  */
 function isLoop(node) {
-    return Boolean(node && anyLoopPattern.test(node.type));
+	return Boolean(node && anyLoopPattern.test(node.type));
 }
 
 /**
@@ -148,13 +161,17 @@ function isLoop(node) {
  * @returns {boolean} `true` if the node is in a loop.
  */
 function isInLoop(node) {
-    for (let currentNode = node; currentNode && !isFunction(currentNode); currentNode = currentNode.parent) {
-        if (isLoop(currentNode)) {
-            return true;
-        }
-    }
-
-    return false;
+	for (
+		let currentNode = node;
+		currentNode && !isFunction(currentNode);
+		currentNode = currentNode.parent
+	) {
+		if (isLoop(currentNode)) {
+			return true;
+		}
+	}
+
+	return false;
 }
 
 /**
@@ -163,15 +180,19 @@ function isInLoop(node) {
  * @returns {boolean} `true` if the node is a `null` literal
  */
 function isNullLiteral(node) {
-
-    /*
-     * Checking `node.value === null` does not guarantee that a literal is a null literal.
-     * When parsing values that cannot be represented in the current environment (e.g. unicode
-     * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to
-     * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check
-     * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020
-     */
-    return node.type === "Literal" && node.value === null && !node.regex && !node.bigint;
+	/*
+	 * Checking `node.value === null` does not guarantee that a literal is a null literal.
+	 * When parsing values that cannot be represented in the current environment (e.g. unicode
+	 * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to
+	 * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check
+	 * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020
+	 */
+	return (
+		node.type === "Literal" &&
+		node.value === null &&
+		!node.regex &&
+		!node.bigint
+	);
 }
 
 /**
@@ -181,11 +202,11 @@ function isNullLiteral(node) {
  * @public
  */
 function isNullOrUndefined(node) {
-    return (
-        isNullLiteral(node) ||
-        (node.type === "Identifier" && node.name === "undefined") ||
-        (node.type === "UnaryExpression" && node.operator === "void")
-    );
+	return (
+		isNullLiteral(node) ||
+		(node.type === "Identifier" && node.name === "undefined") ||
+		(node.type === "UnaryExpression" && node.operator === "void")
+	);
 }
 
 /**
@@ -194,7 +215,7 @@ function isNullOrUndefined(node) {
  * @returns {boolean} Whether or not the node is callee.
  */
 function isCallee(node) {
-    return node.parent.type === "CallExpression" && node.parent.callee === node;
+	return node.parent.type === "CallExpression" && node.parent.callee === node;
 }
 
 /**
@@ -207,35 +228,34 @@ function isCallee(node) {
  * @returns {string|null} String value if it can be determined. Otherwise, `null`.
  */
 function getStaticStringValue(node) {
-    switch (node.type) {
-        case "Literal":
-            if (node.value === null) {
-                if (isNullLiteral(node)) {
-                    return String(node.value); // "null"
-                }
-                if (node.regex) {
-                    return `/${node.regex.pattern}/${node.regex.flags}`;
-                }
-                if (node.bigint) {
-                    return node.bigint;
-                }
-
-                // Otherwise, this is an unknown literal. The function will return null.
-
-            } else {
-                return String(node.value);
-            }
-            break;
-        case "TemplateLiteral":
-            if (node.expressions.length === 0 && node.quasis.length === 1) {
-                return node.quasis[0].value.cooked;
-            }
-            break;
-
-            // no default
-    }
-
-    return null;
+	switch (node.type) {
+		case "Literal":
+			if (node.value === null) {
+				if (isNullLiteral(node)) {
+					return String(node.value); // "null"
+				}
+				if (node.regex) {
+					return `/${node.regex.pattern}/${node.regex.flags}`;
+				}
+				if (node.bigint) {
+					return node.bigint;
+				}
+
+				// Otherwise, this is an unknown literal. The function will return null.
+			} else {
+				return String(node.value);
+			}
+			break;
+		case "TemplateLiteral":
+			if (node.expressions.length === 0 && node.quasis.length === 1) {
+				return node.quasis[0].value.cooked;
+			}
+			break;
+
+		// no default
+	}
+
+	return null;
 }
 
 /**
@@ -269,34 +289,34 @@ function getStaticStringValue(node) {
  * @returns {string|null} The property name if static. Otherwise, null.
  */
 function getStaticPropertyName(node) {
-    let prop;
+	let prop;
 
-    switch (node && node.type) {
-        case "ChainExpression":
-            return getStaticPropertyName(node.expression);
+	switch (node && node.type) {
+		case "ChainExpression":
+			return getStaticPropertyName(node.expression);
 
-        case "Property":
-        case "PropertyDefinition":
-        case "MethodDefinition":
-            prop = node.key;
-            break;
+		case "Property":
+		case "PropertyDefinition":
+		case "MethodDefinition":
+			prop = node.key;
+			break;
 
-        case "MemberExpression":
-            prop = node.property;
-            break;
+		case "MemberExpression":
+			prop = node.property;
+			break;
 
-            // no default
-    }
+		// no default
+	}
 
-    if (prop) {
-        if (prop.type === "Identifier" && !node.computed) {
-            return prop.name;
-        }
+	if (prop) {
+		if (prop.type === "Identifier" && !node.computed) {
+			return prop.name;
+		}
 
-        return getStaticStringValue(prop);
-    }
+		return getStaticStringValue(prop);
+	}
 
-    return null;
+	return null;
 }
 
 /**
@@ -305,7 +325,7 @@ function getStaticPropertyName(node) {
  * @returns {ASTNode} The `ChainExpression#expression` value if the node is a `ChainExpression` node. Otherwise, the node.
  */
 function skipChainExpression(node) {
-    return node && node.type === "ChainExpression" ? node.expression : node;
+	return node && node.type === "ChainExpression" ? node.expression : node;
 }
 
 /**
@@ -315,9 +335,9 @@ function skipChainExpression(node) {
  * @returns {boolean} `true` if the `actual` is an expected value.
  */
 function checkText(actual, expected) {
-    return typeof expected === "string"
-        ? actual === expected
-        : expected.test(actual);
+	return typeof expected === "string"
+		? actual === expected
+		: expected.test(actual);
 }
 
 /**
@@ -327,7 +347,7 @@ function checkText(actual, expected) {
  * @returns {boolean} `true` if the node is an Identifier node with the name.
  */
 function isSpecificId(node, name) {
-    return node.type === "Identifier" && checkText(node.name, name);
+	return node.type === "Identifier" && checkText(node.name, name);
 }
 
 /**
@@ -340,25 +360,28 @@ function isSpecificId(node, name) {
  * The node is a `MemberExpression` or `ChainExpression`.
  */
 function isSpecificMemberAccess(node, objectName, propertyName) {
-    const checkNode = skipChainExpression(node);
+	const checkNode = skipChainExpression(node);
 
-    if (checkNode.type !== "MemberExpression") {
-        return false;
-    }
+	if (checkNode.type !== "MemberExpression") {
+		return false;
+	}
 
-    if (objectName && !isSpecificId(checkNode.object, objectName)) {
-        return false;
-    }
+	if (objectName && !isSpecificId(checkNode.object, objectName)) {
+		return false;
+	}
 
-    if (propertyName) {
-        const actualPropertyName = getStaticPropertyName(checkNode);
+	if (propertyName) {
+		const actualPropertyName = getStaticPropertyName(checkNode);
 
-        if (typeof actualPropertyName !== "string" || !checkText(actualPropertyName, propertyName)) {
-            return false;
-        }
-    }
+		if (
+			typeof actualPropertyName !== "string" ||
+			!checkText(actualPropertyName, propertyName)
+		) {
+			return false;
+		}
+	}
 
-    return true;
+	return true;
 }
 
 /**
@@ -368,23 +391,22 @@ function isSpecificMemberAccess(node, objectName, propertyName) {
  * @returns {boolean} `true` if the two literal nodes are the same value.
  */
 function equalLiteralValue(left, right) {
-
-    // RegExp literal.
-    if (left.regex || right.regex) {
-        return Boolean(
-            left.regex &&
-            right.regex &&
-            left.regex.pattern === right.regex.pattern &&
-            left.regex.flags === right.regex.flags
-        );
-    }
-
-    // BigInt literal.
-    if (left.bigint || right.bigint) {
-        return left.bigint === right.bigint;
-    }
-
-    return left.value === right.value;
+	// RegExp literal.
+	if (left.regex || right.regex) {
+		return Boolean(
+			left.regex &&
+				right.regex &&
+				left.regex.pattern === right.regex.pattern &&
+				left.regex.flags === right.regex.flags,
+		);
+	}
+
+	// BigInt literal.
+	if (left.bigint || right.bigint) {
+		return left.bigint === right.bigint;
+	}
+
+	return left.value === right.value;
 }
 
 /**
@@ -399,61 +421,83 @@ function equalLiteralValue(left, right) {
  * @returns {boolean} `true` if both sides match and reference the same value.
  */
 function isSameReference(left, right, disableStaticComputedKey = false) {
-    if (left.type !== right.type) {
-
-        // Handle `a.b` and `a?.b` are samely.
-        if (left.type === "ChainExpression") {
-            return isSameReference(left.expression, right, disableStaticComputedKey);
-        }
-        if (right.type === "ChainExpression") {
-            return isSameReference(left, right.expression, disableStaticComputedKey);
-        }
-
-        return false;
-    }
-
-    switch (left.type) {
-        case "Super":
-        case "ThisExpression":
-            return true;
-
-        case "Identifier":
-        case "PrivateIdentifier":
-            return left.name === right.name;
-        case "Literal":
-            return equalLiteralValue(left, right);
-
-        case "ChainExpression":
-            return isSameReference(left.expression, right.expression, disableStaticComputedKey);
-
-        case "MemberExpression": {
-            if (!disableStaticComputedKey) {
-                const nameA = getStaticPropertyName(left);
-
-                // x.y = x["y"]
-                if (nameA !== null) {
-                    return (
-                        isSameReference(left.object, right.object, disableStaticComputedKey) &&
-                        nameA === getStaticPropertyName(right)
-                    );
-                }
-            }
-
-            /*
-             * x[0] = x[0]
-             * x[y] = x[y]
-             * x.y = x.y
-             */
-            return (
-                left.computed === right.computed &&
-                isSameReference(left.object, right.object, disableStaticComputedKey) &&
-                isSameReference(left.property, right.property, disableStaticComputedKey)
-            );
-        }
-
-        default:
-            return false;
-    }
+	if (left.type !== right.type) {
+		// Handle `a.b` and `a?.b` are samely.
+		if (left.type === "ChainExpression") {
+			return isSameReference(
+				left.expression,
+				right,
+				disableStaticComputedKey,
+			);
+		}
+		if (right.type === "ChainExpression") {
+			return isSameReference(
+				left,
+				right.expression,
+				disableStaticComputedKey,
+			);
+		}
+
+		return false;
+	}
+
+	switch (left.type) {
+		case "Super":
+		case "ThisExpression":
+			return true;
+
+		case "Identifier":
+		case "PrivateIdentifier":
+			return left.name === right.name;
+		case "Literal":
+			return equalLiteralValue(left, right);
+
+		case "ChainExpression":
+			return isSameReference(
+				left.expression,
+				right.expression,
+				disableStaticComputedKey,
+			);
+
+		case "MemberExpression": {
+			if (!disableStaticComputedKey) {
+				const nameA = getStaticPropertyName(left);
+
+				// x.y = x["y"]
+				if (nameA !== null) {
+					return (
+						isSameReference(
+							left.object,
+							right.object,
+							disableStaticComputedKey,
+						) && nameA === getStaticPropertyName(right)
+					);
+				}
+			}
+
+			/*
+			 * x[0] = x[0]
+			 * x[y] = x[y]
+			 * x.y = x.y
+			 */
+			return (
+				left.computed === right.computed &&
+				isSameReference(
+					left.object,
+					right.object,
+					disableStaticComputedKey,
+				) &&
+				isSameReference(
+					left.property,
+					right.property,
+					disableStaticComputedKey,
+				)
+			);
+		}
+
+		default:
+			return false;
+	}
 }
 
 /**
@@ -462,7 +506,7 @@ function isSameReference(left, right, disableStaticComputedKey = false) {
  * @returns {boolean} Whether or not the node is a `Reflect.apply`.
  */
 function isReflectApply(node) {
-    return isSpecificMemberAccess(node, "Reflect", "apply");
+	return isSpecificMemberAccess(node, "Reflect", "apply");
 }
 
 /**
@@ -471,7 +515,7 @@ function isReflectApply(node) {
  * @returns {boolean} Whether or not the node is a `Array.from`.
  */
 function isArrayFromMethod(node) {
-    return isSpecificMemberAccess(node, arrayOrTypedArrayPattern, "from");
+	return isSpecificMemberAccess(node, arrayOrTypedArrayPattern, "from");
 }
 
 /**
@@ -480,7 +524,7 @@ function isArrayFromMethod(node) {
  * @returns {boolean} Whether or not the node is a method which expects a function as a first argument, and `thisArg` as a second argument.
  */
 function isMethodWhichHasThisArg(node) {
-    return isSpecificMemberAccess(node, null, arrayMethodWithThisArgPattern);
+	return isSpecificMemberAccess(node, null, arrayMethodWithThisArgPattern);
 }
 
 /**
@@ -489,7 +533,7 @@ function isMethodWhichHasThisArg(node) {
  * @returns {Function} Negated function.
  */
 function negate(f) {
-    return token => !f(token);
+	return token => !f(token);
 }
 
 /**
@@ -499,17 +543,19 @@ function negate(f) {
  * @returns {boolean} Whether or not the node has a `@this` tag in its comments.
  */
 function hasJSDocThisTag(node, sourceCode) {
-    const jsdocComment = sourceCode.getJSDocComment(node);
-
-    if (jsdocComment && thisTagPattern.test(jsdocComment.value)) {
-        return true;
-    }
-
-    // Checks `@this` in its leading comments for callbacks,
-    // because callbacks don't have its JSDoc comment.
-    // e.g.
-    //     sinon.test(/* @this sinon.Sandbox */function() { this.spy(); });
-    return sourceCode.getCommentsBefore(node).some(comment => thisTagPattern.test(comment.value));
+	const jsdocComment = sourceCode.getJSDocComment(node);
+
+	if (jsdocComment && thisTagPattern.test(jsdocComment.value)) {
+		return true;
+	}
+
+	// Checks `@this` in its leading comments for callbacks,
+	// because callbacks don't have its JSDoc comment.
+	// e.g.
+	//     sinon.test(/* @this sinon.Sandbox */function() { this.spy(); });
+	return sourceCode
+		.getCommentsBefore(node)
+		.some(comment => thisTagPattern.test(comment.value));
 }
 
 /**
@@ -520,12 +566,16 @@ function hasJSDocThisTag(node, sourceCode) {
  * @private
  */
 function isParenthesised(sourceCode, node) {
-    const previousToken = sourceCode.getTokenBefore(node),
-        nextToken = sourceCode.getTokenAfter(node);
-
-    return Boolean(previousToken && nextToken) &&
-        previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
-        nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+	const previousToken = sourceCode.getTokenBefore(node),
+		nextToken = sourceCode.getTokenAfter(node);
+
+	return (
+		Boolean(previousToken && nextToken) &&
+		previousToken.value === "(" &&
+		previousToken.range[1] <= node.range[0] &&
+		nextToken.value === ")" &&
+		nextToken.range[0] >= node.range[1]
+	);
 }
 
 /**
@@ -534,7 +584,7 @@ function isParenthesised(sourceCode, node) {
  * @returns {boolean} `true` if the token is a `=` token.
  */
 function isEqToken(token) {
-    return token.value === "=" && token.type === "Punctuator";
+	return token.value === "=" && token.type === "Punctuator";
 }
 
 /**
@@ -543,7 +593,7 @@ function isEqToken(token) {
  * @returns {boolean} `true` if the token is an arrow token.
  */
 function isArrowToken(token) {
-    return token.value === "=>" && token.type === "Punctuator";
+	return token.value === "=>" && token.type === "Punctuator";
 }
 
 /**
@@ -552,7 +602,7 @@ function isArrowToken(token) {
  * @returns {boolean} `true` if the token is a comma token.
  */
 function isCommaToken(token) {
-    return token.value === "," && token.type === "Punctuator";
+	return token.value === "," && token.type === "Punctuator";
 }
 
 /**
@@ -561,7 +611,7 @@ function isCommaToken(token) {
  * @returns {boolean} `true` if the token is a dot token.
  */
 function isDotToken(token) {
-    return token.value === "." && token.type === "Punctuator";
+	return token.value === "." && token.type === "Punctuator";
 }
 
 /**
@@ -570,7 +620,7 @@ function isDotToken(token) {
  * @returns {boolean} `true` if the token is a `?.` token.
  */
 function isQuestionDotToken(token) {
-    return token.value === "?." && token.type === "Punctuator";
+	return token.value === "?." && token.type === "Punctuator";
 }
 
 /**
@@ -579,7 +629,7 @@ function isQuestionDotToken(token) {
  * @returns {boolean} `true` if the token is a semicolon token.
  */
 function isSemicolonToken(token) {
-    return token.value === ";" && token.type === "Punctuator";
+	return token.value === ";" && token.type === "Punctuator";
 }
 
 /**
@@ -588,7 +638,7 @@ function isSemicolonToken(token) {
  * @returns {boolean} `true` if the token is a colon token.
  */
 function isColonToken(token) {
-    return token.value === ":" && token.type === "Punctuator";
+	return token.value === ":" && token.type === "Punctuator";
 }
 
 /**
@@ -597,7 +647,7 @@ function isColonToken(token) {
  * @returns {boolean} `true` if the token is an opening parenthesis token.
  */
 function isOpeningParenToken(token) {
-    return token.value === "(" && token.type === "Punctuator";
+	return token.value === "(" && token.type === "Punctuator";
 }
 
 /**
@@ -606,7 +656,7 @@ function isOpeningParenToken(token) {
  * @returns {boolean} `true` if the token is a closing parenthesis token.
  */
 function isClosingParenToken(token) {
-    return token.value === ")" && token.type === "Punctuator";
+	return token.value === ")" && token.type === "Punctuator";
 }
 
 /**
@@ -615,7 +665,7 @@ function isClosingParenToken(token) {
  * @returns {boolean} `true` if the token is an opening square bracket token.
  */
 function isOpeningBracketToken(token) {
-    return token.value === "[" && token.type === "Punctuator";
+	return token.value === "[" && token.type === "Punctuator";
 }
 
 /**
@@ -624,7 +674,7 @@ function isOpeningBracketToken(token) {
  * @returns {boolean} `true` if the token is a closing square bracket token.
  */
 function isClosingBracketToken(token) {
-    return token.value === "]" && token.type === "Punctuator";
+	return token.value === "]" && token.type === "Punctuator";
 }
 
 /**
@@ -633,7 +683,7 @@ function isClosingBracketToken(token) {
  * @returns {boolean} `true` if the token is an opening brace token.
  */
 function isOpeningBraceToken(token) {
-    return token.value === "{" && token.type === "Punctuator";
+	return token.value === "{" && token.type === "Punctuator";
 }
 
 /**
@@ -642,7 +692,7 @@ function isOpeningBraceToken(token) {
  * @returns {boolean} `true` if the token is a closing brace token.
  */
 function isClosingBraceToken(token) {
-    return token.value === "}" && token.type === "Punctuator";
+	return token.value === "}" && token.type === "Punctuator";
 }
 
 /**
@@ -651,7 +701,11 @@ function isClosingBraceToken(token) {
  * @returns {boolean} `true` if the token is a comment token.
  */
 function isCommentToken(token) {
-    return token.type === "Line" || token.type === "Block" || token.type === "Shebang";
+	return (
+		token.type === "Line" ||
+		token.type === "Block" ||
+		token.type === "Shebang"
+	);
 }
 
 /**
@@ -660,7 +714,7 @@ function isCommentToken(token) {
  * @returns {boolean} `true` if the token is a keyword token.
  */
 function isKeywordToken(token) {
-    return token.type === "Keyword";
+	return token.type === "Keyword";
 }
 
 /**
@@ -670,19 +724,20 @@ function isKeywordToken(token) {
  * @returns {Token} `(` token.
  */
 function getOpeningParenOfParams(node, sourceCode) {
-
-    // If the node is an arrow function and doesn't have parens, this returns the identifier of the first param.
-    if (node.type === "ArrowFunctionExpression" && node.params.length === 1) {
-        const argToken = sourceCode.getFirstToken(node.params[0]);
-        const maybeParenToken = sourceCode.getTokenBefore(argToken);
-
-        return isOpeningParenToken(maybeParenToken) ? maybeParenToken : argToken;
-    }
-
-    // Otherwise, returns paren.
-    return node.id
-        ? sourceCode.getTokenAfter(node.id, isOpeningParenToken)
-        : sourceCode.getFirstToken(node, isOpeningParenToken);
+	// If the node is an arrow function and doesn't have parens, this returns the identifier of the first param.
+	if (node.type === "ArrowFunctionExpression" && node.params.length === 1) {
+		const argToken = sourceCode.getFirstToken(node.params[0]);
+		const maybeParenToken = sourceCode.getTokenBefore(argToken);
+
+		return isOpeningParenToken(maybeParenToken)
+			? maybeParenToken
+			: argToken;
+	}
+
+	// Otherwise, returns paren.
+	return node.id
+		? sourceCode.getTokenAfter(node.id, isOpeningParenToken)
+		: sourceCode.getFirstToken(node, isOpeningParenToken);
 }
 
 /**
@@ -693,21 +748,22 @@ function getOpeningParenOfParams(node, sourceCode) {
  * @returns {boolean} the source code for the given node.
  */
 function equalTokens(left, right, sourceCode) {
-    const tokensL = sourceCode.getTokens(left);
-    const tokensR = sourceCode.getTokens(right);
-
-    if (tokensL.length !== tokensR.length) {
-        return false;
-    }
-    for (let i = 0; i < tokensL.length; ++i) {
-        if (tokensL[i].type !== tokensR[i].type ||
-            tokensL[i].value !== tokensR[i].value
-        ) {
-            return false;
-        }
-    }
-
-    return true;
+	const tokensL = sourceCode.getTokens(left);
+	const tokensR = sourceCode.getTokens(right);
+
+	if (tokensL.length !== tokensR.length) {
+		return false;
+	}
+	for (let i = 0; i < tokensL.length; ++i) {
+		if (
+			tokensL[i].type !== tokensR[i].type ||
+			tokensL[i].value !== tokensR[i].value
+		) {
+			return false;
+		}
+	}
+
+	return true;
 }
 
 /**
@@ -723,10 +779,10 @@ function equalTokens(left, right, sourceCode) {
  * @see https://tc39.es/ecma262/#prod-ShortCircuitExpression
  */
 function isLogicalExpression(node) {
-    return (
-        node.type === "LogicalExpression" &&
-            (node.operator === "&&" || node.operator === "||")
-    );
+	return (
+		node.type === "LogicalExpression" &&
+		(node.operator === "&&" || node.operator === "||")
+	);
 }
 
 /**
@@ -741,7 +797,7 @@ function isLogicalExpression(node) {
  * @returns {boolean} `true` if the node is `??`.
  */
 function isCoalesceExpression(node) {
-    return node.type === "LogicalExpression" && node.operator === "??";
+	return node.type === "LogicalExpression" && node.operator === "??";
 }
 
 /**
@@ -751,10 +807,10 @@ function isCoalesceExpression(node) {
  * @returns {boolean} `true` if the two nodes are the pair of a logical expression and a coalesce expression.
  */
 function isMixedLogicalAndCoalesceExpressions(left, right) {
-    return (
-        (isLogicalExpression(left) && isCoalesceExpression(right)) ||
-            (isCoalesceExpression(left) && isLogicalExpression(right))
-    );
+	return (
+		(isLogicalExpression(left) && isCoalesceExpression(right)) ||
+		(isCoalesceExpression(left) && isLogicalExpression(right))
+	);
 }
 
 /**
@@ -763,7 +819,7 @@ function isMixedLogicalAndCoalesceExpressions(left, right) {
  * @returns {boolean} `true` if the operator is a logical assignment operator.
  */
 function isLogicalAssignmentOperator(operator) {
-    return LOGICAL_ASSIGNMENT_OPERATORS.has(operator);
+	return LOGICAL_ASSIGNMENT_OPERATORS.has(operator);
 }
 
 /**
@@ -773,10 +829,10 @@ function isLogicalAssignmentOperator(operator) {
  * @returns {Token} The colon token of the node.
  */
 function getSwitchCaseColonToken(node, sourceCode) {
-    if (node.test) {
-        return sourceCode.getTokenAfter(node.test, isColonToken);
-    }
-    return sourceCode.getFirstToken(node, 1);
+	if (node.test) {
+		return sourceCode.getTokenAfter(node.test, isColonToken);
+	}
+	return sourceCode.getFirstToken(node, 1);
 }
 
 /**
@@ -790,12 +846,12 @@ function getSwitchCaseColonToken(node, sourceCode) {
  * @returns {string} The module export name.
  */
 function getModuleExportName(node) {
-    if (node.type === "Identifier") {
-        return node.name;
-    }
+	if (node.type === "Identifier") {
+		return node.name;
+	}
 
-    // string literal
-    return node.value;
+	// string literal
+	return node.value;
 }
 
 /**
@@ -805,27 +861,26 @@ function getModuleExportName(node) {
  *  `null` when it cannot be determined.
  */
 function getBooleanValue(node) {
-    if (node.value === null) {
-
-        /*
-         * it might be a null literal or bigint/regex literal in unsupported environments .
-         * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es5.md#regexpliteral
-         * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es2020.md#bigintliteral
-         */
-
-        if (node.raw === "null") {
-            return false;
-        }
-
-        // regex is always truthy
-        if (typeof node.regex === "object") {
-            return true;
-        }
-
-        return null;
-    }
-
-    return !!node.value;
+	if (node.value === null) {
+		/*
+		 * it might be a null literal or bigint/regex literal in unsupported environments .
+		 * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es5.md#regexpliteral
+		 * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es2020.md#bigintliteral
+		 */
+
+		if (node.raw === "null") {
+			return false;
+		}
+
+		// regex is always truthy
+		if (typeof node.regex === "object") {
+			return true;
+		}
+
+		return null;
+	}
+
+	return !!node.value;
 }
 
 /**
@@ -835,34 +890,37 @@ function getBooleanValue(node) {
  * @returns {boolean} true when condition short circuits whole condition
  */
 function isLogicalIdentity(node, operator) {
-    switch (node.type) {
-        case "Literal":
-            return (operator === "||" && getBooleanValue(node) === true) ||
-                  (operator === "&&" && getBooleanValue(node) === false);
-
-        case "UnaryExpression":
-            return (operator === "&&" && node.operator === "void");
-
-        case "LogicalExpression":
-
-            /*
-             * handles `a && false || b`
-             * `false` is an identity element of `&&` but not `||`
-             */
-            return operator === node.operator &&
-                    (
-                        isLogicalIdentity(node.left, operator) ||
-                        isLogicalIdentity(node.right, operator)
-                    );
-
-        case "AssignmentExpression":
-            return ["||=", "&&="].includes(node.operator) &&
-               operator === node.operator.slice(0, -1) &&
-               isLogicalIdentity(node.right, operator);
-
-       // no default
-    }
-    return false;
+	switch (node.type) {
+		case "Literal":
+			return (
+				(operator === "||" && getBooleanValue(node) === true) ||
+				(operator === "&&" && getBooleanValue(node) === false)
+			);
+
+		case "UnaryExpression":
+			return operator === "&&" && node.operator === "void";
+
+		case "LogicalExpression":
+			/*
+			 * handles `a && false || b`
+			 * `false` is an identity element of `&&` but not `||`
+			 */
+			return (
+				operator === node.operator &&
+				(isLogicalIdentity(node.left, operator) ||
+					isLogicalIdentity(node.right, operator))
+			);
+
+		case "AssignmentExpression":
+			return (
+				["||=", "&&="].includes(node.operator) &&
+				operator === node.operator.slice(0, -1) &&
+				isLogicalIdentity(node.right, operator)
+			);
+
+		// no default
+	}
+	return false;
 }
 
 /**
@@ -872,17 +930,16 @@ function isLogicalIdentity(node, operator) {
  * @returns {boolean} `true` if the identifier is a reference to a global variable.
  */
 function isReferenceToGlobalVariable(scope, node) {
-    const reference = scope.references.find(ref => ref.identifier === node);
-
-    return Boolean(
-        reference &&
-            reference.resolved &&
-            reference.resolved.scope.type === "global" &&
-            reference.resolved.defs.length === 0
-    );
+	const reference = scope.references.find(ref => ref.identifier === node);
+
+	return Boolean(
+		reference &&
+			reference.resolved &&
+			reference.resolved.scope.type === "global" &&
+			reference.resolved.defs.length === 0,
+	);
 }
 
-
 /**
  * Checks if a  node has a constant truthiness value.
  * @param {Scope} scope Scope in which the node appears.
@@ -895,104 +952,139 @@ function isReferenceToGlobalVariable(scope, node) {
  * @private
  */
 function isConstant(scope, node, inBooleanPosition) {
-
-    // node.elements can return null values in the case of sparse arrays ex. [,]
-    if (!node) {
-        return true;
-    }
-    switch (node.type) {
-        case "Literal":
-        case "ArrowFunctionExpression":
-        case "FunctionExpression":
-            return true;
-        case "ClassExpression":
-        case "ObjectExpression":
-
-            /**
-             * In theory objects like:
-             *
-             * `{toString: () => a}`
-             * `{valueOf: () => a}`
-             *
-             * Or a classes like:
-             *
-             * `class { static toString() { return a } }`
-             * `class { static valueOf() { return a } }`
-             *
-             * Are not constant verifiably when `inBooleanPosition` is
-             * false, but it's an edge case we've opted not to handle.
-             */
-            return true;
-        case "TemplateLiteral":
-            return (inBooleanPosition && node.quasis.some(quasi => quasi.value.cooked.length)) ||
-                        node.expressions.every(exp => isConstant(scope, exp, false));
-
-        case "ArrayExpression": {
-            if (!inBooleanPosition) {
-                return node.elements.every(element => isConstant(scope, element, false));
-            }
-            return true;
-        }
-
-        case "UnaryExpression":
-            if (
-                node.operator === "void" ||
-                        node.operator === "typeof" && inBooleanPosition
-            ) {
-                return true;
-            }
-
-            if (node.operator === "!") {
-                return isConstant(scope, node.argument, true);
-            }
-
-            return isConstant(scope, node.argument, false);
-
-        case "BinaryExpression":
-            return isConstant(scope, node.left, false) &&
-                            isConstant(scope, node.right, false) &&
-                            node.operator !== "in";
-
-        case "LogicalExpression": {
-            const isLeftConstant = isConstant(scope, node.left, inBooleanPosition);
-            const isRightConstant = isConstant(scope, node.right, inBooleanPosition);
-            const isLeftShortCircuit = (isLeftConstant && isLogicalIdentity(node.left, node.operator));
-            const isRightShortCircuit = (inBooleanPosition && isRightConstant && isLogicalIdentity(node.right, node.operator));
-
-            return (isLeftConstant && isRightConstant) ||
-                        isLeftShortCircuit ||
-                        isRightShortCircuit;
-        }
-        case "NewExpression":
-            return inBooleanPosition;
-        case "AssignmentExpression":
-            if (node.operator === "=") {
-                return isConstant(scope, node.right, inBooleanPosition);
-            }
-
-            if (["||=", "&&="].includes(node.operator) && inBooleanPosition) {
-                return isLogicalIdentity(node.right, node.operator.slice(0, -1));
-            }
-
-            return false;
-
-        case "SequenceExpression":
-            return isConstant(scope, node.expressions.at(-1), inBooleanPosition);
-        case "SpreadElement":
-            return isConstant(scope, node.argument, inBooleanPosition);
-        case "CallExpression":
-            if (node.callee.type === "Identifier" && node.callee.name === "Boolean") {
-                if (node.arguments.length === 0 || isConstant(scope, node.arguments[0], true)) {
-                    return isReferenceToGlobalVariable(scope, node.callee);
-                }
-            }
-            return false;
-        case "Identifier":
-            return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
-
-                // no default
-    }
-    return false;
+	// node.elements can return null values in the case of sparse arrays ex. [,]
+	if (!node) {
+		return true;
+	}
+	switch (node.type) {
+		case "Literal":
+		case "ArrowFunctionExpression":
+		case "FunctionExpression":
+			return true;
+		case "ClassExpression":
+		case "ObjectExpression":
+			/**
+			 * In theory objects like:
+			 *
+			 * `{toString: () => a}`
+			 * `{valueOf: () => a}`
+			 *
+			 * Or a classes like:
+			 *
+			 * `class { static toString() { return a } }`
+			 * `class { static valueOf() { return a } }`
+			 *
+			 * Are not constant verifiably when `inBooleanPosition` is
+			 * false, but it's an edge case we've opted not to handle.
+			 */
+			return true;
+		case "TemplateLiteral":
+			return (
+				(inBooleanPosition &&
+					node.quasis.some(quasi => quasi.value.cooked.length)) ||
+				node.expressions.every(exp => isConstant(scope, exp, false))
+			);
+
+		case "ArrayExpression": {
+			if (!inBooleanPosition) {
+				return node.elements.every(element =>
+					isConstant(scope, element, false),
+				);
+			}
+			return true;
+		}
+
+		case "UnaryExpression":
+			if (
+				node.operator === "void" ||
+				(node.operator === "typeof" && inBooleanPosition)
+			) {
+				return true;
+			}
+
+			if (node.operator === "!") {
+				return isConstant(scope, node.argument, true);
+			}
+
+			return isConstant(scope, node.argument, false);
+
+		case "BinaryExpression":
+			return (
+				isConstant(scope, node.left, false) &&
+				isConstant(scope, node.right, false) &&
+				node.operator !== "in"
+			);
+
+		case "LogicalExpression": {
+			const isLeftConstant = isConstant(
+				scope,
+				node.left,
+				inBooleanPosition,
+			);
+			const isRightConstant = isConstant(
+				scope,
+				node.right,
+				inBooleanPosition,
+			);
+			const isLeftShortCircuit =
+				isLeftConstant && isLogicalIdentity(node.left, node.operator);
+			const isRightShortCircuit =
+				inBooleanPosition &&
+				isRightConstant &&
+				isLogicalIdentity(node.right, node.operator);
+
+			return (
+				(isLeftConstant && isRightConstant) ||
+				isLeftShortCircuit ||
+				isRightShortCircuit
+			);
+		}
+		case "NewExpression":
+			return inBooleanPosition;
+		case "AssignmentExpression":
+			if (node.operator === "=") {
+				return isConstant(scope, node.right, inBooleanPosition);
+			}
+
+			if (["||=", "&&="].includes(node.operator) && inBooleanPosition) {
+				return isLogicalIdentity(
+					node.right,
+					node.operator.slice(0, -1),
+				);
+			}
+
+			return false;
+
+		case "SequenceExpression":
+			return isConstant(
+				scope,
+				node.expressions.at(-1),
+				inBooleanPosition,
+			);
+		case "SpreadElement":
+			return isConstant(scope, node.argument, inBooleanPosition);
+		case "CallExpression":
+			if (
+				node.callee.type === "Identifier" &&
+				node.callee.name === "Boolean"
+			) {
+				if (
+					node.arguments.length === 0 ||
+					isConstant(scope, node.arguments[0], true)
+				) {
+					return isReferenceToGlobalVariable(scope, node.callee);
+				}
+			}
+			return false;
+		case "Identifier":
+			return (
+				node.name === "undefined" &&
+				isReferenceToGlobalVariable(scope, node)
+			);
+
+		// no default
+	}
+	return false;
 }
 
 /**
@@ -1005,13 +1097,15 @@ function isConstant(scope, node, inBooleanPosition) {
  * file or function body.
  */
 function isTopLevelExpressionStatement(node) {
-    if (node.type !== "ExpressionStatement") {
-        return false;
-    }
-    const parent = node.parent;
-
-    return parent.type === "Program" || (parent.type === "BlockStatement" && isFunction(parent.parent));
-
+	if (node.type !== "ExpressionStatement") {
+		return false;
+	}
+	const parent = node.parent;
+
+	return (
+		parent.type === "Program" ||
+		(parent.type === "BlockStatement" && isFunction(parent.parent))
+	);
 }
 
 /**
@@ -1020,7 +1114,10 @@ function isTopLevelExpressionStatement(node) {
  * @returns {boolean} `true` if the node is a part of directive prologue.
  */
 function isDirective(node) {
-    return node.type === "ExpressionStatement" && typeof node.directive === "string";
+	return (
+		node.type === "ExpressionStatement" &&
+		typeof node.directive === "string"
+	);
 }
 
 /**
@@ -1029,15 +1126,15 @@ function isDirective(node) {
  * @returns {boolean} Whether the node appears at the beginning of an ancestor ExpressionStatement node.
  */
 function isStartOfExpressionStatement(node) {
-    const start = node.range[0];
-    let ancestor = node;
-
-    while ((ancestor = ancestor.parent) && ancestor.range[0] === start) {
-        if (ancestor.type === "ExpressionStatement") {
-            return true;
-        }
-    }
-    return false;
+	const start = node.range[0];
+	let ancestor = node;
+
+	while ((ancestor = ancestor.parent) && ancestor.range[0] === start) {
+		if (ancestor.type === "ExpressionStatement") {
+			return true;
+		}
+	}
+	return false;
 }
 
 /**
@@ -1052,84 +1149,94 @@ function isStartOfExpressionStatement(node) {
 let needsPrecedingSemicolon;
 
 {
-    const BREAK_OR_CONTINUE = new Set(["BreakStatement", "ContinueStatement"]);
-
-    // Declaration types that cannot be continued by a punctuator when ending with a string Literal that is a direct child.
-    const DECLARATIONS = new Set(["ExportAllDeclaration", "ExportNamedDeclaration", "ImportDeclaration"]);
-
-    const IDENTIFIER_OR_KEYWORD = new Set(["Identifier", "Keyword"]);
-
-    // Keywords that can immediately precede an ExpressionStatement node, mapped to the their node types.
-    const NODE_TYPES_BY_KEYWORD = {
-        __proto__: null,
-        break: "BreakStatement",
-        continue: "ContinueStatement",
-        debugger: "DebuggerStatement",
-        do: "DoWhileStatement",
-        else: "IfStatement",
-        return: "ReturnStatement",
-        yield: "YieldExpression"
-    };
-
-    /*
-     * Before an opening parenthesis, postfix `++` and `--` always trigger ASI;
-     * the tokens `:`, `;`, `{` and `=>` don't expect a semicolon, as that would count as an empty statement.
-     */
-    const PUNCTUATORS = new Set([":", ";", "{", "=>", "++", "--"]);
-
-    /*
-     * Statements that can contain an `ExpressionStatement` after a closing parenthesis.
-     * DoWhileStatement is an exception in that it always triggers ASI after the closing parenthesis.
-     */
-    const STATEMENTS = new Set([
-        "DoWhileStatement",
-        "ForInStatement",
-        "ForOfStatement",
-        "ForStatement",
-        "IfStatement",
-        "WhileStatement",
-        "WithStatement"
-    ]);
-
-    needsPrecedingSemicolon =
-    function(sourceCode, node) {
-        const prevToken = sourceCode.getTokenBefore(node);
-
-        if (!prevToken || prevToken.type === "Punctuator" && PUNCTUATORS.has(prevToken.value)) {
-            return false;
-        }
-
-        const prevNode = sourceCode.getNodeByRangeIndex(prevToken.range[0]);
-
-        if (isClosingParenToken(prevToken)) {
-            return !STATEMENTS.has(prevNode.type);
-        }
-
-        if (isClosingBraceToken(prevToken)) {
-            return (
-                prevNode.type === "BlockStatement" && prevNode.parent.type === "FunctionExpression" && prevNode.parent.parent.type !== "MethodDefinition" ||
-                prevNode.type === "ClassBody" && prevNode.parent.type === "ClassExpression" ||
-                prevNode.type === "ObjectExpression"
-            );
-        }
-
-        if (IDENTIFIER_OR_KEYWORD.has(prevToken.type)) {
-            if (BREAK_OR_CONTINUE.has(prevNode.parent.type)) {
-                return false;
-            }
-
-            const keyword = prevToken.value;
-            const nodeType = NODE_TYPES_BY_KEYWORD[keyword];
-
-            return prevNode.type !== nodeType;
-        }
-
-        if (prevToken.type === "String") {
-            return !DECLARATIONS.has(prevNode.parent.type);
-        }
-
-        return true;
-    };
+	const BREAK_OR_CONTINUE = new Set(["BreakStatement", "ContinueStatement"]);
+
+	// Declaration types that cannot be continued by a punctuator when ending with a string Literal that is a direct child.
+	const DECLARATIONS = new Set([
+		"ExportAllDeclaration",
+		"ExportNamedDeclaration",
+		"ImportDeclaration",
+	]);
+
+	const IDENTIFIER_OR_KEYWORD = new Set(["Identifier", "Keyword"]);
+
+	// Keywords that can immediately precede an ExpressionStatement node, mapped to the their node types.
+	const NODE_TYPES_BY_KEYWORD = {
+		__proto__: null,
+		break: "BreakStatement",
+		continue: "ContinueStatement",
+		debugger: "DebuggerStatement",
+		do: "DoWhileStatement",
+		else: "IfStatement",
+		return: "ReturnStatement",
+		yield: "YieldExpression",
+	};
+
+	/*
+	 * Before an opening parenthesis, postfix `++` and `--` always trigger ASI;
+	 * the tokens `:`, `;`, `{` and `=>` don't expect a semicolon, as that would count as an empty statement.
+	 */
+	const PUNCTUATORS = new Set([":", ";", "{", "=>", "++", "--"]);
+
+	/*
+	 * Statements that can contain an `ExpressionStatement` after a closing parenthesis.
+	 * DoWhileStatement is an exception in that it always triggers ASI after the closing parenthesis.
+	 */
+	const STATEMENTS = new Set([
+		"DoWhileStatement",
+		"ForInStatement",
+		"ForOfStatement",
+		"ForStatement",
+		"IfStatement",
+		"WhileStatement",
+		"WithStatement",
+	]);
+
+	needsPrecedingSemicolon = function (sourceCode, node) {
+		const prevToken = sourceCode.getTokenBefore(node);
+
+		if (
+			!prevToken ||
+			(prevToken.type === "Punctuator" &&
+				PUNCTUATORS.has(prevToken.value))
+		) {
+			return false;
+		}
+
+		const prevNode = sourceCode.getNodeByRangeIndex(prevToken.range[0]);
+
+		if (isClosingParenToken(prevToken)) {
+			return !STATEMENTS.has(prevNode.type);
+		}
+
+		if (isClosingBraceToken(prevToken)) {
+			return (
+				(prevNode.type === "BlockStatement" &&
+					prevNode.parent.type === "FunctionExpression" &&
+					prevNode.parent.parent.type !== "MethodDefinition") ||
+				(prevNode.type === "ClassBody" &&
+					prevNode.parent.type === "ClassExpression") ||
+				prevNode.type === "ObjectExpression"
+			);
+		}
+
+		if (IDENTIFIER_OR_KEYWORD.has(prevToken.type)) {
+			if (BREAK_OR_CONTINUE.has(prevNode.parent.type)) {
+				return false;
+			}
+
+			const keyword = prevToken.value;
+			const nodeType = NODE_TYPES_BY_KEYWORD[keyword];
+
+			return prevNode.type !== nodeType;
+		}
+
+		if (prevToken.type === "String") {
+			return !DECLARATIONS.has(prevNode.parent.type);
+		}
+
+		return true;
+	};
 }
 
 /**
@@ -1138,40 +1245,41 @@ let needsPrecedingSemicolon;
  * @returns {boolean} Whether the node is used as an import attribute key.
  */
 function isImportAttributeKey(node) {
-    const { parent } = node;
-
-    // static import/re-export
-    if (parent.type === "ImportAttribute" && parent.key === node) {
-        return true;
-    }
-
-    // dynamic import
-    if (
-        parent.type === "Property" &&
-        !parent.computed &&
-        (parent.key === node || parent.value === node && parent.shorthand && !parent.method) &&
-        parent.parent.type === "ObjectExpression"
-    ) {
-        const objectExpression = parent.parent;
-        const objectExpressionParent = objectExpression.parent;
-
-        if (
-            objectExpressionParent.type === "ImportExpression" &&
-            objectExpressionParent.options === objectExpression
-        ) {
-            return true;
-        }
-
-        // nested key
-        if (
-            objectExpressionParent.type === "Property" &&
-            objectExpressionParent.value === objectExpression
-        ) {
-            return isImportAttributeKey(objectExpressionParent.key);
-        }
-    }
-
-    return false;
+	const { parent } = node;
+
+	// static import/re-export
+	if (parent.type === "ImportAttribute" && parent.key === node) {
+		return true;
+	}
+
+	// dynamic import
+	if (
+		parent.type === "Property" &&
+		!parent.computed &&
+		(parent.key === node ||
+			(parent.value === node && parent.shorthand && !parent.method)) &&
+		parent.parent.type === "ObjectExpression"
+	) {
+		const objectExpression = parent.parent;
+		const objectExpressionParent = objectExpression.parent;
+
+		if (
+			objectExpressionParent.type === "ImportExpression" &&
+			objectExpressionParent.options === objectExpression
+		) {
+			return true;
+		}
+
+		// nested key
+		if (
+			objectExpressionParent.type === "Property" &&
+			objectExpressionParent.value === objectExpression
+		) {
+			return isImportAttributeKey(objectExpressionParent.key);
+		}
+	}
+
+	return false;
 }
 
 //------------------------------------------------------------------------------
@@ -1179,1298 +1287,1369 @@ function isImportAttributeKey(node) {
 //------------------------------------------------------------------------------
 
 module.exports = {
-    COMMENTS_IGNORE_PATTERN,
-    LINEBREAKS,
-    LINEBREAK_MATCHER: lineBreakPattern,
-    SHEBANG_MATCHER: shebangPattern,
-    STATEMENT_LIST_PARENTS,
-    ECMASCRIPT_GLOBALS,
-
-    /**
-     * Determines whether two adjacent tokens are on the same line.
-     * @param {Object} left The left token object.
-     * @param {Object} right The right token object.
-     * @returns {boolean} Whether or not the tokens are on the same line.
-     * @public
-     */
-    isTokenOnSameLine(left, right) {
-        return left.loc.end.line === right.loc.start.line;
-    },
-
-    isNullOrUndefined,
-    isCallee,
-    isES5Constructor,
-    getUpperFunction,
-    isFunction,
-    isLoop,
-    isInLoop,
-    isArrayFromMethod,
-    isParenthesised,
-    createGlobalLinebreakMatcher,
-    equalTokens,
-
-    isArrowToken,
-    isClosingBraceToken,
-    isClosingBracketToken,
-    isClosingParenToken,
-    isColonToken,
-    isCommaToken,
-    isCommentToken,
-    isDotToken,
-    isQuestionDotToken,
-    isKeywordToken,
-    isNotClosingBraceToken: negate(isClosingBraceToken),
-    isNotClosingBracketToken: negate(isClosingBracketToken),
-    isNotClosingParenToken: negate(isClosingParenToken),
-    isNotColonToken: negate(isColonToken),
-    isNotCommaToken: negate(isCommaToken),
-    isNotDotToken: negate(isDotToken),
-    isNotQuestionDotToken: negate(isQuestionDotToken),
-    isNotOpeningBraceToken: negate(isOpeningBraceToken),
-    isNotOpeningBracketToken: negate(isOpeningBracketToken),
-    isNotOpeningParenToken: negate(isOpeningParenToken),
-    isNotSemicolonToken: negate(isSemicolonToken),
-    isOpeningBraceToken,
-    isOpeningBracketToken,
-    isOpeningParenToken,
-    isSemicolonToken,
-    isEqToken,
-
-    /**
-     * Checks whether or not a given node is a string literal.
-     * @param {ASTNode} node A node to check.
-     * @returns {boolean} `true` if the node is a string literal.
-     */
-    isStringLiteral(node) {
-        return (
-            (node.type === "Literal" && typeof node.value === "string") ||
-            node.type === "TemplateLiteral"
-        );
-    },
-
-    /**
-     * Checks whether a given node is a breakable statement or not.
-     * The node is breakable if the node is one of the following type:
-     *
-     * - DoWhileStatement
-     * - ForInStatement
-     * - ForOfStatement
-     * - ForStatement
-     * - SwitchStatement
-     * - WhileStatement
-     * @param {ASTNode} node A node to check.
-     * @returns {boolean} `true` if the node is breakable.
-     */
-    isBreakableStatement(node) {
-        return breakableTypePattern.test(node.type);
-    },
-
-    /**
-     * Gets references which are non initializer and writable.
-     * @param {Reference[]} references An array of references.
-     * @returns {Reference[]} An array of only references which are non initializer and writable.
-     * @public
-     */
-    getModifyingReferences(references) {
-        return references.filter(isModifyingReference);
-    },
-
-    /**
-     * Validate that a string passed in is surrounded by the specified character
-     * @param {string} val The text to check.
-     * @param {string} character The character to see if it's surrounded by.
-     * @returns {boolean} True if the text is surrounded by the character, false if not.
-     * @private
-     */
-    isSurroundedBy(val, character) {
-        return val[0] === character && val.at(-1) === character;
-    },
-
-    /**
-     * Returns whether the provided node is an ESLint directive comment or not
-     * @param {Line|Block} node The comment token to be checked
-     * @returns {boolean} `true` if the node is an ESLint directive comment
-     */
-    isDirectiveComment(node) {
-        const comment = node.value.trim();
-
-        return (
-            node.type === "Line" && comment.startsWith("eslint-") ||
-            node.type === "Block" && ESLINT_DIRECTIVE_PATTERN.test(comment)
-        );
-    },
-
-    /**
-     * Gets the trailing statement of a given node.
-     *
-     *     if (code)
-     *         consequent;
-     *
-     * When taking this `IfStatement`, returns `consequent;` statement.
-     * @param {ASTNode} A node to get.
-     * @returns {ASTNode|null} The trailing statement's node.
-     */
-    getTrailingStatement: esutils.ast.trailingStatement,
-
-    /**
-     * Finds the variable by a given name in a given scope and its upper scopes.
-     * @param {eslint-scope.Scope} initScope A scope to start find.
-     * @param {string} name A variable name to find.
-     * @returns {eslint-scope.Variable|null} A found variable or `null`.
-     */
-    getVariableByName(initScope, name) {
-        let scope = initScope;
-
-        while (scope) {
-            const variable = scope.set.get(name);
-
-            if (variable) {
-                return variable;
-            }
-
-            scope = scope.upper;
-        }
-
-        return null;
-    },
-
-    /**
-     * Checks whether or not a given function node is the default `this` binding.
-     *
-     * First, this checks the node:
-     *
-     * - The given node is not in `PropertyDefinition#value` position.
-     * - The given node is not `StaticBlock`.
-     * - The function name does not start with uppercase. It's a convention to capitalize the names
-     *   of constructor functions. This check is not performed if `capIsConstructor` is set to `false`.
-     * - The function does not have a JSDoc comment that has a @this tag.
-     *
-     * Next, this checks the location of the node.
-     * If the location is below, this judges `this` is valid.
-     *
-     * - The location is not on an object literal.
-     * - The location is not assigned to a variable which starts with an uppercase letter. Applies to anonymous
-     *   functions only, as the name of the variable is considered to be the name of the function in this case.
-     *   This check is not performed if `capIsConstructor` is set to `false`.
-     * - The location is not on an ES2015 class.
-     * - Its `bind`/`call`/`apply` method is not called directly.
-     * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given.
-     * @param {ASTNode} node A function node to check. It also can be an implicit function, like `StaticBlock`
-     * or any expression that is `PropertyDefinition#value` node.
-     * @param {SourceCode} sourceCode A SourceCode instance to get comments.
-     * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts
-     * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors.
-     * @returns {boolean} The function node is the default `this` binding.
-     */
-    isDefaultThisBinding(node, sourceCode, { capIsConstructor = true } = {}) {
-
-        /*
-         * Class field initializers are implicit functions, but ESTree doesn't have the AST node of field initializers.
-         * Therefore, A expression node at `PropertyDefinition#value` is a function.
-         * In this case, `this` is always not default binding.
-         */
-        if (node.parent.type === "PropertyDefinition" && node.parent.value === node) {
-            return false;
-        }
-
-        // Class static blocks are implicit functions. In this case, `this` is always not default binding.
-        if (node.type === "StaticBlock") {
-            return false;
-        }
-
-        if (
-            (capIsConstructor && isES5Constructor(node)) ||
-            hasJSDocThisTag(node, sourceCode)
-        ) {
-            return false;
-        }
-        const isAnonymous = node.id === null;
-        let currentNode = node;
-
-        while (currentNode) {
-            const parent = currentNode.parent;
-
-            switch (parent.type) {
-
-                /*
-                 * Looks up the destination.
-                 * e.g., obj.foo = nativeFoo || function foo() { ... };
-                 */
-                case "LogicalExpression":
-                case "ConditionalExpression":
-                case "ChainExpression":
-                    currentNode = parent;
-                    break;
-
-                /*
-                 * If the upper function is IIFE, checks the destination of the return value.
-                 * e.g.
-                 *   obj.foo = (function() {
-                 *     // setup...
-                 *     return function foo() { ... };
-                 *   })();
-                 *   obj.foo = (() =>
-                 *     function foo() { ... }
-                 *   )();
-                 */
-                case "ReturnStatement": {
-                    const func = getUpperFunction(parent);
-
-                    if (func === null || !isCallee(func)) {
-                        return true;
-                    }
-                    currentNode = func.parent;
-                    break;
-                }
-                case "ArrowFunctionExpression":
-                    if (currentNode !== parent.body || !isCallee(parent)) {
-                        return true;
-                    }
-                    currentNode = parent.parent;
-                    break;
-
-                /*
-                 * e.g.
-                 *   var obj = { foo() { ... } };
-                 *   var obj = { foo: function() { ... } };
-                 *   class A { constructor() { ... } }
-                 *   class A { foo() { ... } }
-                 *   class A { get foo() { ... } }
-                 *   class A { set foo() { ... } }
-                 *   class A { static foo() { ... } }
-                 *   class A { foo = function() { ... } }
-                 */
-                case "Property":
-                case "PropertyDefinition":
-                case "MethodDefinition":
-                    return parent.value !== currentNode;
-
-                /*
-                 * e.g.
-                 *   obj.foo = function foo() { ... };
-                 *   Foo = function() { ... };
-                 *   [obj.foo = function foo() { ... }] = a;
-                 *   [Foo = function() { ... }] = a;
-                 */
-                case "AssignmentExpression":
-                case "AssignmentPattern":
-                    if (parent.left.type === "MemberExpression") {
-                        return false;
-                    }
-                    if (
-                        capIsConstructor &&
-                        isAnonymous &&
-                        parent.left.type === "Identifier" &&
-                        startsWithUpperCase(parent.left.name)
-                    ) {
-                        return false;
-                    }
-                    return true;
-
-                /*
-                 * e.g.
-                 *   var Foo = function() { ... };
-                 */
-                case "VariableDeclarator":
-                    return !(
-                        capIsConstructor &&
-                        isAnonymous &&
-                        parent.init === currentNode &&
-                        parent.id.type === "Identifier" &&
-                        startsWithUpperCase(parent.id.name)
-                    );
-
-                /*
-                 * e.g.
-                 *   var foo = function foo() { ... }.bind(obj);
-                 *   (function foo() { ... }).call(obj);
-                 *   (function foo() { ... }).apply(obj, []);
-                 */
-                case "MemberExpression":
-                    if (
-                        parent.object === currentNode &&
-                        isSpecificMemberAccess(parent, null, bindOrCallOrApplyPattern)
-                    ) {
-                        const maybeCalleeNode = parent.parent.type === "ChainExpression"
-                            ? parent.parent
-                            : parent;
-
-                        return !(
-                            isCallee(maybeCalleeNode) &&
-                            maybeCalleeNode.parent.arguments.length >= 1 &&
-                            !isNullOrUndefined(maybeCalleeNode.parent.arguments[0])
-                        );
-                    }
-                    return true;
-
-                /*
-                 * e.g.
-                 *   Reflect.apply(function() {}, obj, []);
-                 *   Array.from([], function() {}, obj);
-                 *   list.forEach(function() {}, obj);
-                 */
-                case "CallExpression":
-                    if (isReflectApply(parent.callee)) {
-                        return (
-                            parent.arguments.length !== 3 ||
-                            parent.arguments[0] !== currentNode ||
-                            isNullOrUndefined(parent.arguments[1])
-                        );
-                    }
-                    if (isArrayFromMethod(parent.callee)) {
-                        return (
-                            parent.arguments.length !== 3 ||
-                            parent.arguments[1] !== currentNode ||
-                            isNullOrUndefined(parent.arguments[2])
-                        );
-                    }
-                    if (isMethodWhichHasThisArg(parent.callee)) {
-                        return (
-                            parent.arguments.length !== 2 ||
-                            parent.arguments[0] !== currentNode ||
-                            isNullOrUndefined(parent.arguments[1])
-                        );
-                    }
-                    return true;
-
-                // Otherwise `this` is default.
-                default:
-                    return true;
-            }
-        }
-
-        /* c8 ignore next */
-        return true;
-    },
-
-    /**
-     * Get the precedence level based on the node type
-     * @param {ASTNode} node node to evaluate
-     * @returns {int} precedence level
-     * @private
-     */
-    getPrecedence(node) {
-        switch (node.type) {
-            case "SequenceExpression":
-                return 0;
-
-            case "AssignmentExpression":
-            case "ArrowFunctionExpression":
-            case "YieldExpression":
-                return 1;
-
-            case "ConditionalExpression":
-                return 3;
-
-            case "LogicalExpression":
-                switch (node.operator) {
-                    case "||":
-                    case "??":
-                        return 4;
-                    case "&&":
-                        return 5;
-
-                    // no default
-                }
-
-                /* falls through */
-
-            case "BinaryExpression":
-
-                switch (node.operator) {
-                    case "|":
-                        return 6;
-                    case "^":
-                        return 7;
-                    case "&":
-                        return 8;
-                    case "==":
-                    case "!=":
-                    case "===":
-                    case "!==":
-                        return 9;
-                    case "<":
-                    case "<=":
-                    case ">":
-                    case ">=":
-                    case "in":
-                    case "instanceof":
-                        return 10;
-                    case "<<":
-                    case ">>":
-                    case ">>>":
-                        return 11;
-                    case "+":
-                    case "-":
-                        return 12;
-                    case "*":
-                    case "/":
-                    case "%":
-                        return 13;
-                    case "**":
-                        return 15;
-
-                    // no default
-                }
-
-                /* falls through */
-
-            case "UnaryExpression":
-            case "AwaitExpression":
-                return 16;
-
-            case "UpdateExpression":
-                return 17;
-
-            case "CallExpression":
-            case "ChainExpression":
-            case "ImportExpression":
-                return 18;
-
-            case "NewExpression":
-                return 19;
-
-            default:
-                if (node.type in eslintVisitorKeys) {
-                    return 20;
-                }
-
-                /*
-                 * if the node is not a standard node that we know about, then assume it has the lowest precedence
-                 * this will mean that rules will wrap unknown nodes in parentheses where applicable instead of
-                 * unwrapping them and potentially changing the meaning of the code or introducing a syntax error.
-                 */
-                return -1;
-        }
-    },
-
-    /**
-     * Checks whether the given node is an empty block node or not.
-     * @param {ASTNode|null} node The node to check.
-     * @returns {boolean} `true` if the node is an empty block.
-     */
-    isEmptyBlock(node) {
-        return Boolean(node && node.type === "BlockStatement" && node.body.length === 0);
-    },
-
-    /**
-     * Checks whether the given node is an empty function node or not.
-     * @param {ASTNode|null} node The node to check.
-     * @returns {boolean} `true` if the node is an empty function.
-     */
-    isEmptyFunction(node) {
-        return isFunction(node) && module.exports.isEmptyBlock(node.body);
-    },
-
-    /**
-     * Get directives from directive prologue of a Program or Function node.
-     * @param {ASTNode} node The node to check.
-     * @returns {ASTNode[]} The directives found in the directive prologue.
-     */
-    getDirectivePrologue(node) {
-        const directives = [];
-
-        // Directive prologues only occur at the top of files or functions.
-        if (
-            node.type === "Program" ||
-            node.type === "FunctionDeclaration" ||
-            node.type === "FunctionExpression" ||
-
-            /*
-             * Do not check arrow functions with implicit return.
-             * `() => "use strict";` returns the string `"use strict"`.
-             */
-            (node.type === "ArrowFunctionExpression" && node.body.type === "BlockStatement")
-        ) {
-            const statements = node.type === "Program" ? node.body : node.body.body;
-
-            for (const statement of statements) {
-                if (
-                    statement.type === "ExpressionStatement" &&
-                    statement.expression.type === "Literal"
-                ) {
-                    directives.push(statement);
-                } else {
-                    break;
-                }
-            }
-        }
-
-        return directives;
-    },
-
-    /**
-     * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added
-     * after the node will be parsed as a decimal point, rather than a property-access dot.
-     * @param {ASTNode} node The node to check.
-     * @returns {boolean} `true` if this node is a decimal integer.
-     * @example
-     *
-     * 0         // true
-     * 5         // true
-     * 50        // true
-     * 5_000     // true
-     * 1_234_56  // true
-     * 08        // true
-     * 0192      // true
-     * 5.        // false
-     * .5        // false
-     * 5.0       // false
-     * 5.00_00   // false
-     * 05        // false
-     * 0x5       // false
-     * 0b101     // false
-     * 0b11_01   // false
-     * 0o5       // false
-     * 5e0       // false
-     * 5e1_000   // false
-     * 5n        // false
-     * 1_000n    // false
-     * "5"       // false
-     *
-     */
-    isDecimalInteger(node) {
-        return node.type === "Literal" && typeof node.value === "number" &&
-            DECIMAL_INTEGER_PATTERN.test(node.raw);
-    },
-
-    /**
-     * Determines whether this token is a decimal integer numeric token.
-     * This is similar to isDecimalInteger(), but for tokens.
-     * @param {Token} token The token to check.
-     * @returns {boolean} `true` if this token is a decimal integer.
-     */
-    isDecimalIntegerNumericToken(token) {
-        return token.type === "Numeric" && DECIMAL_INTEGER_PATTERN.test(token.value);
-    },
-
-    /**
-     * Gets the name and kind of the given function node.
-     *
-     * - `function foo() {}`  .................... `function 'foo'`
-     * - `(function foo() {})`  .................. `function 'foo'`
-     * - `(function() {})`  ...................... `function`
-     * - `function* foo() {}`  ................... `generator function 'foo'`
-     * - `(function* foo() {})`  ................. `generator function 'foo'`
-     * - `(function*() {})`  ..................... `generator function`
-     * - `() => {}`  ............................. `arrow function`
-     * - `async () => {}`  ....................... `async arrow function`
-     * - `({ foo: function foo() {} })`  ......... `method 'foo'`
-     * - `({ foo: function() {} })`  ............. `method 'foo'`
-     * - `({ ['foo']: function() {} })`  ......... `method 'foo'`
-     * - `({ [foo]: function() {} })`  ........... `method`
-     * - `({ foo() {} })`  ....................... `method 'foo'`
-     * - `({ foo: function* foo() {} })`  ........ `generator method 'foo'`
-     * - `({ foo: function*() {} })`  ............ `generator method 'foo'`
-     * - `({ ['foo']: function*() {} })`  ........ `generator method 'foo'`
-     * - `({ [foo]: function*() {} })`  .......... `generator method`
-     * - `({ *foo() {} })`  ...................... `generator method 'foo'`
-     * - `({ foo: async function foo() {} })`  ... `async method 'foo'`
-     * - `({ foo: async function() {} })`  ....... `async method 'foo'`
-     * - `({ ['foo']: async function() {} })`  ... `async method 'foo'`
-     * - `({ [foo]: async function() {} })`  ..... `async method`
-     * - `({ async foo() {} })`  ................. `async method 'foo'`
-     * - `({ get foo() {} })`  ................... `getter 'foo'`
-     * - `({ set foo(a) {} })`  .................. `setter 'foo'`
-     * - `class A { constructor() {} }`  ......... `constructor`
-     * - `class A { foo() {} }`  ................. `method 'foo'`
-     * - `class A { *foo() {} }`  ................ `generator method 'foo'`
-     * - `class A { async foo() {} }`  ........... `async method 'foo'`
-     * - `class A { ['foo']() {} }`  ............. `method 'foo'`
-     * - `class A { *['foo']() {} }`  ............ `generator method 'foo'`
-     * - `class A { async ['foo']() {} }`  ....... `async method 'foo'`
-     * - `class A { [foo]() {} }`  ............... `method`
-     * - `class A { *[foo]() {} }`  .............. `generator method`
-     * - `class A { async [foo]() {} }`  ......... `async method`
-     * - `class A { get foo() {} }`  ............. `getter 'foo'`
-     * - `class A { set foo(a) {} }`  ............ `setter 'foo'`
-     * - `class A { static foo() {} }`  .......... `static method 'foo'`
-     * - `class A { static *foo() {} }`  ......... `static generator method 'foo'`
-     * - `class A { static async foo() {} }`  .... `static async method 'foo'`
-     * - `class A { static get foo() {} }`  ...... `static getter 'foo'`
-     * - `class A { static set foo(a) {} }`  ..... `static setter 'foo'`
-     * - `class A { foo = () => {}; }`  .......... `method 'foo'`
-     * - `class A { foo = function() {}; }`  ..... `method 'foo'`
-     * - `class A { foo = function bar() {}; }`  . `method 'foo'`
-     * - `class A { static foo = () => {}; }`  ... `static method 'foo'`
-     * - `class A { '#foo' = () => {}; }`  ....... `method '#foo'`
-     * - `class A { #foo = () => {}; }`  ......... `private method #foo`
-     * - `class A { static #foo = () => {}; }`  .. `static private method #foo`
-     * - `class A { '#foo'() {} }`  .............. `method '#foo'`
-     * - `class A { #foo() {} }`  ................ `private method #foo`
-     * - `class A { static #foo() {} }`  ......... `static private method #foo`
-     * @param {ASTNode} node The function node to get.
-     * @returns {string} The name and kind of the function node.
-     */
-    getFunctionNameWithKind(node) {
-        const parent = node.parent;
-        const tokens = [];
-
-        if (parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") {
-
-            // The proposal uses `static` word consistently before visibility words: https://github.com/tc39/proposal-static-class-features
-            if (parent.static) {
-                tokens.push("static");
-            }
-            if (!parent.computed && parent.key.type === "PrivateIdentifier") {
-                tokens.push("private");
-            }
-        }
-        if (node.async) {
-            tokens.push("async");
-        }
-        if (node.generator) {
-            tokens.push("generator");
-        }
-
-        if (parent.type === "Property" || parent.type === "MethodDefinition") {
-            if (parent.kind === "constructor") {
-                return "constructor";
-            }
-            if (parent.kind === "get") {
-                tokens.push("getter");
-            } else if (parent.kind === "set") {
-                tokens.push("setter");
-            } else {
-                tokens.push("method");
-            }
-        } else if (parent.type === "PropertyDefinition") {
-            tokens.push("method");
-        } else {
-            if (node.type === "ArrowFunctionExpression") {
-                tokens.push("arrow");
-            }
-            tokens.push("function");
-        }
-
-        if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") {
-            if (!parent.computed && parent.key.type === "PrivateIdentifier") {
-                tokens.push(`#${parent.key.name}`);
-            } else {
-                const name = getStaticPropertyName(parent);
-
-                if (name !== null) {
-                    tokens.push(`'${name}'`);
-                } else if (node.id) {
-                    tokens.push(`'${node.id.name}'`);
-                }
-            }
-        } else if (node.id) {
-            tokens.push(`'${node.id.name}'`);
-        }
-
-        return tokens.join(" ");
-    },
-
-    /**
-     * Gets the location of the given function node for reporting.
-     *
-     * - `function foo() {}`
-     *    ^^^^^^^^^^^^
-     * - `(function foo() {})`
-     *     ^^^^^^^^^^^^
-     * - `(function() {})`
-     *     ^^^^^^^^
-     * - `function* foo() {}`
-     *    ^^^^^^^^^^^^^
-     * - `(function* foo() {})`
-     *     ^^^^^^^^^^^^^
-     * - `(function*() {})`
-     *     ^^^^^^^^^
-     * - `() => {}`
-     *       ^^
-     * - `async () => {}`
-     *             ^^
-     * - `({ foo: function foo() {} })`
-     *       ^^^^^^^^^^^^^^^^^
-     * - `({ foo: function() {} })`
-     *       ^^^^^^^^^^^^^
-     * - `({ ['foo']: function() {} })`
-     *       ^^^^^^^^^^^^^^^^^
-     * - `({ [foo]: function() {} })`
-     *       ^^^^^^^^^^^^^^^
-     * - `({ foo() {} })`
-     *       ^^^
-     * - `({ foo: function* foo() {} })`
-     *       ^^^^^^^^^^^^^^^^^^
-     * - `({ foo: function*() {} })`
-     *       ^^^^^^^^^^^^^^
-     * - `({ ['foo']: function*() {} })`
-     *       ^^^^^^^^^^^^^^^^^^
-     * - `({ [foo]: function*() {} })`
-     *       ^^^^^^^^^^^^^^^^
-     * - `({ *foo() {} })`
-     *       ^^^^
-     * - `({ foo: async function foo() {} })`
-     *       ^^^^^^^^^^^^^^^^^^^^^^^
-     * - `({ foo: async function() {} })`
-     *       ^^^^^^^^^^^^^^^^^^^
-     * - `({ ['foo']: async function() {} })`
-     *       ^^^^^^^^^^^^^^^^^^^^^^^
-     * - `({ [foo]: async function() {} })`
-     *       ^^^^^^^^^^^^^^^^^^^^^
-     * - `({ async foo() {} })`
-     *       ^^^^^^^^^
-     * - `({ get foo() {} })`
-     *       ^^^^^^^
-     * - `({ set foo(a) {} })`
-     *       ^^^^^^^
-     * - `class A { constructor() {} }`
-     *              ^^^^^^^^^^^
-     * - `class A { foo() {} }`
-     *              ^^^
-     * - `class A { *foo() {} }`
-     *              ^^^^
-     * - `class A { async foo() {} }`
-     *              ^^^^^^^^^
-     * - `class A { ['foo']() {} }`
-     *              ^^^^^^^
-     * - `class A { *['foo']() {} }`
-     *              ^^^^^^^^
-     * - `class A { async ['foo']() {} }`
-     *              ^^^^^^^^^^^^^
-     * - `class A { [foo]() {} }`
-     *              ^^^^^
-     * - `class A { *[foo]() {} }`
-     *              ^^^^^^
-     * - `class A { async [foo]() {} }`
-     *              ^^^^^^^^^^^
-     * - `class A { get foo() {} }`
-     *              ^^^^^^^
-     * - `class A { set foo(a) {} }`
-     *              ^^^^^^^
-     * - `class A { static foo() {} }`
-     *              ^^^^^^^^^^
-     * - `class A { static *foo() {} }`
-     *              ^^^^^^^^^^^
-     * - `class A { static async foo() {} }`
-     *              ^^^^^^^^^^^^^^^^
-     * - `class A { static get foo() {} }`
-     *              ^^^^^^^^^^^^^^
-     * - `class A { static set foo(a) {} }`
-     *              ^^^^^^^^^^^^^^
-     * - `class A { foo = function() {} }`
-     *              ^^^^^^^^^^^^^^
-     * - `class A { static foo = function() {} }`
-     *              ^^^^^^^^^^^^^^^^^^^^^
-     * - `class A { foo = (a, b) => {} }`
-     *              ^^^^^^
-     * @param {ASTNode} node The function node to get.
-     * @param {SourceCode} sourceCode The source code object to get tokens.
-     * @returns {string} The location of the function node for reporting.
-     */
-    getFunctionHeadLoc(node, sourceCode) {
-        const parent = node.parent;
-        let start;
-        let end;
-
-        if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") {
-            start = parent.loc.start;
-            end = getOpeningParenOfParams(node, sourceCode).loc.start;
-        } else if (node.type === "ArrowFunctionExpression") {
-            const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken);
-
-            start = arrowToken.loc.start;
-            end = arrowToken.loc.end;
-        } else {
-            start = node.loc.start;
-            end = getOpeningParenOfParams(node, sourceCode).loc.start;
-        }
-
-        return {
-            start: Object.assign({}, start),
-            end: Object.assign({}, end)
-        };
-    },
-
-    /**
-     * Gets next location when the result is not out of bound, otherwise returns null.
-     *
-     * Assumptions:
-     *
-     * - The given location represents a valid location in the given source code.
-     * - Columns are 0-based.
-     * - Lines are 1-based.
-     * - Column immediately after the last character in a line (not incl. linebreaks) is considered to be a valid location.
-     * - If the source code ends with a linebreak, `sourceCode.lines` array will have an extra element (empty string) at the end.
-     *   The start (column 0) of that extra line is considered to be a valid location.
-     *
-     * Examples of successive locations (line, column):
-     *
-     * code: foo
-     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> null
-     *
-     * code: foo<LF>
-     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
-     *
-     * code: foo<CR><LF>
-     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
-     *
-     * code: a<LF>b
-     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> null
-     *
-     * code: a<LF>b<LF>
-     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
-     *
-     * code: a<CR><LF>b<CR><LF>
-     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
-     *
-     * code: a<LF><LF>
-     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (3, 0) -> null
-     *
-     * code: <LF>
-     * locations: (1, 0) -> (2, 0) -> null
-     *
-     * code:
-     * locations: (1, 0) -> null
-     * @param {SourceCode} sourceCode The sourceCode
-     * @param {{line: number, column: number}} location The location
-     * @returns {{line: number, column: number} | null} Next location
-     */
-    getNextLocation(sourceCode, { line, column }) {
-        if (column < sourceCode.lines[line - 1].length) {
-            return {
-                line,
-                column: column + 1
-            };
-        }
-
-        if (line < sourceCode.lines.length) {
-            return {
-                line: line + 1,
-                column: 0
-            };
-        }
-
-        return null;
-    },
-
-    /**
-     * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses
-     * surrounding the node.
-     * @param {SourceCode} sourceCode The source code object
-     * @param {ASTNode} node An expression node
-     * @returns {string} The text representing the node, with all surrounding parentheses included
-     */
-    getParenthesisedText(sourceCode, node) {
-        let leftToken = sourceCode.getFirstToken(node);
-        let rightToken = sourceCode.getLastToken(node);
-
-        while (
-            sourceCode.getTokenBefore(leftToken) &&
-            sourceCode.getTokenBefore(leftToken).type === "Punctuator" &&
-            sourceCode.getTokenBefore(leftToken).value === "(" &&
-            sourceCode.getTokenAfter(rightToken) &&
-            sourceCode.getTokenAfter(rightToken).type === "Punctuator" &&
-            sourceCode.getTokenAfter(rightToken).value === ")"
-        ) {
-            leftToken = sourceCode.getTokenBefore(leftToken);
-            rightToken = sourceCode.getTokenAfter(rightToken);
-        }
-
-        return sourceCode.getText().slice(leftToken.range[0], rightToken.range[1]);
-    },
-
-    /**
-     * Determine if a node has a possibility to be an Error object
-     * @param {ASTNode} node ASTNode to check
-     * @returns {boolean} True if there is a chance it contains an Error obj
-     */
-    couldBeError(node) {
-        switch (node.type) {
-            case "Identifier":
-            case "CallExpression":
-            case "NewExpression":
-            case "MemberExpression":
-            case "TaggedTemplateExpression":
-            case "YieldExpression":
-            case "AwaitExpression":
-            case "ChainExpression":
-                return true; // possibly an error object.
-
-            case "AssignmentExpression":
-                if (["=", "&&="].includes(node.operator)) {
-                    return module.exports.couldBeError(node.right);
-                }
-
-                if (["||=", "??="].includes(node.operator)) {
-                    return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);
-                }
-
-                /**
-                 * All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
-                 * An assignment expression with a mathematical operator can either evaluate to a primitive value,
-                 * or throw, depending on the operands. Thus, it cannot evaluate to an `Error` object.
-                 */
-                return false;
-
-            case "SequenceExpression": {
-                const exprs = node.expressions;
-
-                return exprs.length !== 0 && module.exports.couldBeError(exprs.at(-1));
-            }
-
-            case "LogicalExpression":
-
-                /*
-                 * If the && operator short-circuits, the left side was falsy and therefore not an error, and if it
-                 * doesn't short-circuit, it takes the value from the right side, so the right side must always be
-                 * a plausible error. A future improvement could verify that the left side could be truthy by
-                 * excluding falsy literals.
-                 */
-                if (node.operator === "&&") {
-                    return module.exports.couldBeError(node.right);
-                }
-
-                return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);
-
-            case "ConditionalExpression":
-                return module.exports.couldBeError(node.consequent) || module.exports.couldBeError(node.alternate);
-
-            default:
-                return false;
-        }
-    },
-
-    /**
-     * Check if a given node is a numeric literal or not.
-     * @param {ASTNode} node The node to check.
-     * @returns {boolean} `true` if the node is a number or bigint literal.
-     */
-    isNumericLiteral(node) {
-        return (
-            node.type === "Literal" &&
-            (typeof node.value === "number" || Boolean(node.bigint))
-        );
-    },
-
-    /**
-     * Determines whether two tokens can safely be placed next to each other without merging into a single token
-     * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used.
-     * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used.
-     * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed
-     * next to each other, behavior is undefined (although it should return `true` in most cases).
-     */
-    canTokensBeAdjacent(leftValue, rightValue) {
-        const espreeOptions = {
-            ecmaVersion: espree.latestEcmaVersion,
-            comment: true,
-            range: true
-        };
-
-        let leftToken;
-
-        if (typeof leftValue === "string") {
-            let tokens;
-
-            try {
-                tokens = espree.tokenize(leftValue, espreeOptions);
-            } catch {
-                return false;
-            }
-
-            const comments = tokens.comments;
-
-            leftToken = tokens.at(-1);
-            if (comments.length) {
-                const lastComment = comments.at(-1);
-
-                if (!leftToken || lastComment.range[0] > leftToken.range[0]) {
-                    leftToken = lastComment;
-                }
-            }
-        } else {
-            leftToken = leftValue;
-        }
-
-        /*
-         * If a hashbang comment was passed as a token object from SourceCode,
-         * its type will be "Shebang" because of the way ESLint itself handles hashbangs.
-         * If a hashbang comment was passed in a string and then tokenized in this function,
-         * its type will be "Hashbang" because of the way Espree tokenizes hashbangs.
-         */
-        if (leftToken.type === "Shebang" || leftToken.type === "Hashbang") {
-            return false;
-        }
-
-        let rightToken;
-
-        if (typeof rightValue === "string") {
-            let tokens;
-
-            try {
-                tokens = espree.tokenize(rightValue, espreeOptions);
-            } catch {
-                return false;
-            }
-
-            const comments = tokens.comments;
-
-            rightToken = tokens[0];
-            if (comments.length) {
-                const firstComment = comments[0];
-
-                if (!rightToken || firstComment.range[0] < rightToken.range[0]) {
-                    rightToken = firstComment;
-                }
-            }
-        } else {
-            rightToken = rightValue;
-        }
-
-        if (leftToken.type === "Punctuator" || rightToken.type === "Punctuator") {
-            if (leftToken.type === "Punctuator" && rightToken.type === "Punctuator") {
-                const PLUS_TOKENS = new Set(["+", "++"]);
-                const MINUS_TOKENS = new Set(["-", "--"]);
-
-                return !(
-                    PLUS_TOKENS.has(leftToken.value) && PLUS_TOKENS.has(rightToken.value) ||
-                    MINUS_TOKENS.has(leftToken.value) && MINUS_TOKENS.has(rightToken.value)
-                );
-            }
-            if (leftToken.type === "Punctuator" && leftToken.value === "/") {
-                return !["Block", "Line", "RegularExpression"].includes(rightToken.type);
-            }
-            return true;
-        }
-
-        if (
-            leftToken.type === "String" || rightToken.type === "String" ||
-            leftToken.type === "Template" || rightToken.type === "Template"
-        ) {
-            return true;
-        }
-
-        if (leftToken.type !== "Numeric" && rightToken.type === "Numeric" && rightToken.value.startsWith(".")) {
-            return true;
-        }
-
-        if (leftToken.type === "Block" || rightToken.type === "Block" || rightToken.type === "Line") {
-            return true;
-        }
-
-        if (rightToken.type === "PrivateIdentifier") {
-            return true;
-        }
-
-        return false;
-    },
-
-    /**
-     * Get the `loc` object of a given name in a `/*globals` directive comment.
-     * @param {SourceCode} sourceCode The source code to convert index to loc.
-     * @param {Comment} comment The `/*globals` directive comment which include the name.
-     * @param {string} name The name to find.
-     * @returns {SourceLocation} The `loc` object.
-     */
-    getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) {
-        const namePattern = new RegExp(`[\\s,]${escapeRegExp(name)}(?:$|[\\s,:])`, "gu");
-
-        // To ignore the first text "global".
-        namePattern.lastIndex = comment.value.indexOf("global") + 6;
-
-        // Search a given variable name.
-        const match = namePattern.exec(comment.value);
-
-        // Convert the index to loc.
-        const start = sourceCode.getLocFromIndex(
-            comment.range[0] +
-            "/*".length +
-            (match ? match.index + 1 : 0)
-        );
-        const end = {
-            line: start.line,
-            column: start.column + (match ? name.length : 1)
-        };
-
-        return { start, end };
-    },
-
-    /**
-     * Determines whether the given raw string contains an octal escape sequence
-     * or a non-octal decimal escape sequence ("\8", "\9").
-     *
-     * "\1", "\2" ... "\7", "\8", "\9"
-     * "\00", "\01" ... "\07", "\08", "\09"
-     *
-     * "\0", when not followed by a digit, is not an octal escape sequence.
-     * @param {string} rawString A string in its raw representation.
-     * @returns {boolean} `true` if the string contains at least one octal escape sequence
-     * or at least one non-octal decimal escape sequence.
-     */
-    hasOctalOrNonOctalDecimalEscapeSequence(rawString) {
-        return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString);
-    },
-
-    /**
-     * Determines whether the given node is a template literal without expressions.
-     * @param {ASTNode} node Node to check.
-     * @returns {boolean} True if the node is a template literal without expressions.
-     */
-    isStaticTemplateLiteral(node) {
-        return node.type === "TemplateLiteral" && node.expressions.length === 0;
-    },
-
-    /**
-     * Determines whether the existing curly braces around the single statement are necessary to preserve the semantics of the code.
-     * The braces, which make the given block body, are necessary in either of the following situations:
-     *
-     * 1. The statement is a lexical declaration.
-     * 2. Without the braces, an `if` within the statement would become associated with an `else` after the closing brace:
-     *
-     *     if (a) {
-     *         if (b)
-     *             foo();
-     *     }
-     *     else
-     *         bar();
-     *
-     *     if (a)
-     *         while (b)
-     *             while (c) {
-     *                 while (d)
-     *                     if (e)
-     *                         while(f)
-     *                             foo();
-     *            }
-     *     else
-     *         bar();
-     * @param {ASTNode} node `BlockStatement` body with exactly one statement directly inside. The statement can have its own nested statements.
-     * @param {SourceCode} sourceCode The source code
-     * @returns {boolean} `true` if the braces are necessary - removing them (replacing the given `BlockStatement` body with its single statement content)
-     * would change the semantics of the code or produce a syntax error.
-     */
-    areBracesNecessary(node, sourceCode) {
-
-        /**
-         * Determines if the given node is a lexical declaration (let, const, function, or class)
-         * @param {ASTNode} nodeToCheck The node to check
-         * @returns {boolean} True if the node is a lexical declaration
-         * @private
-         */
-        function isLexicalDeclaration(nodeToCheck) {
-            if (nodeToCheck.type === "VariableDeclaration") {
-                return nodeToCheck.kind === "const" || nodeToCheck.kind === "let";
-            }
-
-            return nodeToCheck.type === "FunctionDeclaration" || nodeToCheck.type === "ClassDeclaration";
-        }
-
-
-        /**
-         * Checks if the given token is an `else` token or not.
-         * @param {Token} token The token to check.
-         * @returns {boolean} `true` if the token is an `else` token.
-         */
-        function isElseKeywordToken(token) {
-            return token.value === "else" && token.type === "Keyword";
-        }
-
-        /**
-         * Determines whether the given node has an `else` keyword token as the first token after.
-         * @param {ASTNode} nodeToCheck The node to check.
-         * @returns {boolean} `true` if the node is followed by an `else` keyword token.
-         */
-        function isFollowedByElseKeyword(nodeToCheck) {
-            const nextToken = sourceCode.getTokenAfter(nodeToCheck);
-
-            return Boolean(nextToken) && isElseKeywordToken(nextToken);
-        }
-
-        /**
-         * Determines whether the code represented by the given node contains an `if` statement
-         * that would become associated with an `else` keyword directly appended to that code.
-         *
-         * Examples where it returns `true`:
-         *
-         *    if (a)
-         *        foo();
-         *
-         *    if (a) {
-         *        foo();
-         *    }
-         *
-         *    if (a)
-         *        foo();
-         *    else if (b)
-         *        bar();
-         *
-         *    while (a)
-         *        if (b)
-         *            if(c)
-         *                foo();
-         *            else
-         *                bar();
-         *
-         * Examples where it returns `false`:
-         *
-         *    if (a)
-         *        foo();
-         *    else
-         *        bar();
-         *
-         *    while (a) {
-         *        if (b)
-         *            if(c)
-         *                foo();
-         *            else
-         *                bar();
-         *    }
-         *
-         *    while (a)
-         *        if (b) {
-         *            if(c)
-         *                foo();
-         *        }
-         *        else
-         *            bar();
-         * @param {ASTNode} nodeToCheck Node representing the code to check.
-         * @returns {boolean} `true` if an `if` statement within the code would become associated with an `else` appended to that code.
-         */
-        function hasUnsafeIf(nodeToCheck) {
-            switch (nodeToCheck.type) {
-                case "IfStatement":
-                    if (!nodeToCheck.alternate) {
-                        return true;
-                    }
-                    return hasUnsafeIf(nodeToCheck.alternate);
-                case "ForStatement":
-                case "ForInStatement":
-                case "ForOfStatement":
-                case "LabeledStatement":
-                case "WithStatement":
-                case "WhileStatement":
-                    return hasUnsafeIf(nodeToCheck.body);
-                default:
-                    return false;
-            }
-        }
-
-        const statement = node.body[0];
-
-        return isLexicalDeclaration(statement) ||
-          hasUnsafeIf(statement) && isFollowedByElseKeyword(node);
-    },
-
-    isReferenceToGlobalVariable,
-    isLogicalExpression,
-    isCoalesceExpression,
-    isMixedLogicalAndCoalesceExpressions,
-    isNullLiteral,
-    getStaticStringValue,
-    getStaticPropertyName,
-    skipChainExpression,
-    isSpecificId,
-    isSpecificMemberAccess,
-    equalLiteralValue,
-    isSameReference,
-    isLogicalAssignmentOperator,
-    getSwitchCaseColonToken,
-    getModuleExportName,
-    isConstant,
-    isTopLevelExpressionStatement,
-    isDirective,
-    isStartOfExpressionStatement,
-    needsPrecedingSemicolon,
-    isImportAttributeKey
+	COMMENTS_IGNORE_PATTERN,
+	LINEBREAKS,
+	LINEBREAK_MATCHER: lineBreakPattern,
+	SHEBANG_MATCHER: shebangPattern,
+	STATEMENT_LIST_PARENTS,
+	ECMASCRIPT_GLOBALS,
+
+	/**
+	 * Determines whether two adjacent tokens are on the same line.
+	 * @param {Object} left The left token object.
+	 * @param {Object} right The right token object.
+	 * @returns {boolean} Whether or not the tokens are on the same line.
+	 * @public
+	 */
+	isTokenOnSameLine(left, right) {
+		return left.loc.end.line === right.loc.start.line;
+	},
+
+	isNullOrUndefined,
+	isCallee,
+	isES5Constructor,
+	getUpperFunction,
+	isFunction,
+	isLoop,
+	isInLoop,
+	isArrayFromMethod,
+	isParenthesised,
+	createGlobalLinebreakMatcher,
+	equalTokens,
+
+	isArrowToken,
+	isClosingBraceToken,
+	isClosingBracketToken,
+	isClosingParenToken,
+	isColonToken,
+	isCommaToken,
+	isCommentToken,
+	isDotToken,
+	isQuestionDotToken,
+	isKeywordToken,
+	isNotClosingBraceToken: negate(isClosingBraceToken),
+	isNotClosingBracketToken: negate(isClosingBracketToken),
+	isNotClosingParenToken: negate(isClosingParenToken),
+	isNotColonToken: negate(isColonToken),
+	isNotCommaToken: negate(isCommaToken),
+	isNotDotToken: negate(isDotToken),
+	isNotQuestionDotToken: negate(isQuestionDotToken),
+	isNotOpeningBraceToken: negate(isOpeningBraceToken),
+	isNotOpeningBracketToken: negate(isOpeningBracketToken),
+	isNotOpeningParenToken: negate(isOpeningParenToken),
+	isNotSemicolonToken: negate(isSemicolonToken),
+	isOpeningBraceToken,
+	isOpeningBracketToken,
+	isOpeningParenToken,
+	isSemicolonToken,
+	isEqToken,
+
+	/**
+	 * Checks whether or not a given node is a string literal.
+	 * @param {ASTNode} node A node to check.
+	 * @returns {boolean} `true` if the node is a string literal.
+	 */
+	isStringLiteral(node) {
+		return (
+			(node.type === "Literal" && typeof node.value === "string") ||
+			node.type === "TemplateLiteral"
+		);
+	},
+
+	/**
+	 * Checks whether a given node is a breakable statement or not.
+	 * The node is breakable if the node is one of the following type:
+	 *
+	 * - DoWhileStatement
+	 * - ForInStatement
+	 * - ForOfStatement
+	 * - ForStatement
+	 * - SwitchStatement
+	 * - WhileStatement
+	 * @param {ASTNode} node A node to check.
+	 * @returns {boolean} `true` if the node is breakable.
+	 */
+	isBreakableStatement(node) {
+		return breakableTypePattern.test(node.type);
+	},
+
+	/**
+	 * Gets references which are non initializer and writable.
+	 * @param {Reference[]} references An array of references.
+	 * @returns {Reference[]} An array of only references which are non initializer and writable.
+	 * @public
+	 */
+	getModifyingReferences(references) {
+		return references.filter(isModifyingReference);
+	},
+
+	/**
+	 * Validate that a string passed in is surrounded by the specified character
+	 * @param {string} val The text to check.
+	 * @param {string} character The character to see if it's surrounded by.
+	 * @returns {boolean} True if the text is surrounded by the character, false if not.
+	 * @private
+	 */
+	isSurroundedBy(val, character) {
+		return val[0] === character && val.at(-1) === character;
+	},
+
+	/**
+	 * Returns whether the provided node is an ESLint directive comment or not
+	 * @param {Line|Block} node The comment token to be checked
+	 * @returns {boolean} `true` if the node is an ESLint directive comment
+	 */
+	isDirectiveComment(node) {
+		const comment = node.value.trim();
+
+		return (
+			(node.type === "Line" && comment.startsWith("eslint-")) ||
+			(node.type === "Block" && ESLINT_DIRECTIVE_PATTERN.test(comment))
+		);
+	},
+
+	/**
+	 * Gets the trailing statement of a given node.
+	 *
+	 *     if (code)
+	 *         consequent;
+	 *
+	 * When taking this `IfStatement`, returns `consequent;` statement.
+	 * @param {ASTNode} A node to get.
+	 * @returns {ASTNode|null} The trailing statement's node.
+	 */
+	getTrailingStatement: esutils.ast.trailingStatement,
+
+	/**
+	 * Finds the variable by a given name in a given scope and its upper scopes.
+	 * @param {eslint-scope.Scope} initScope A scope to start find.
+	 * @param {string} name A variable name to find.
+	 * @returns {eslint-scope.Variable|null} A found variable or `null`.
+	 */
+	getVariableByName(initScope, name) {
+		let scope = initScope;
+
+		while (scope) {
+			const variable = scope.set.get(name);
+
+			if (variable) {
+				return variable;
+			}
+
+			scope = scope.upper;
+		}
+
+		return null;
+	},
+
+	/**
+	 * Checks whether or not a given function node is the default `this` binding.
+	 *
+	 * First, this checks the node:
+	 *
+	 * - The given node is not in `PropertyDefinition#value` position.
+	 * - The given node is not `StaticBlock`.
+	 * - The function name does not start with uppercase. It's a convention to capitalize the names
+	 *   of constructor functions. This check is not performed if `capIsConstructor` is set to `false`.
+	 * - The function does not have a JSDoc comment that has a @this tag.
+	 *
+	 * Next, this checks the location of the node.
+	 * If the location is below, this judges `this` is valid.
+	 *
+	 * - The location is not on an object literal.
+	 * - The location is not assigned to a variable which starts with an uppercase letter. Applies to anonymous
+	 *   functions only, as the name of the variable is considered to be the name of the function in this case.
+	 *   This check is not performed if `capIsConstructor` is set to `false`.
+	 * - The location is not on an ES2015 class.
+	 * - Its `bind`/`call`/`apply` method is not called directly.
+	 * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given.
+	 * @param {ASTNode} node A function node to check. It also can be an implicit function, like `StaticBlock`
+	 * or any expression that is `PropertyDefinition#value` node.
+	 * @param {SourceCode} sourceCode A SourceCode instance to get comments.
+	 * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts
+	 * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors.
+	 * @returns {boolean} The function node is the default `this` binding.
+	 */
+	isDefaultThisBinding(node, sourceCode, { capIsConstructor = true } = {}) {
+		/*
+		 * Class field initializers are implicit functions, but ESTree doesn't have the AST node of field initializers.
+		 * Therefore, A expression node at `PropertyDefinition#value` is a function.
+		 * In this case, `this` is always not default binding.
+		 */
+		if (
+			node.parent.type === "PropertyDefinition" &&
+			node.parent.value === node
+		) {
+			return false;
+		}
+
+		// Class static blocks are implicit functions. In this case, `this` is always not default binding.
+		if (node.type === "StaticBlock") {
+			return false;
+		}
+
+		if (
+			(capIsConstructor && isES5Constructor(node)) ||
+			hasJSDocThisTag(node, sourceCode)
+		) {
+			return false;
+		}
+		const isAnonymous = node.id === null;
+		let currentNode = node;
+
+		while (currentNode) {
+			const parent = currentNode.parent;
+
+			switch (parent.type) {
+				/*
+				 * Looks up the destination.
+				 * e.g., obj.foo = nativeFoo || function foo() { ... };
+				 */
+				case "LogicalExpression":
+				case "ConditionalExpression":
+				case "ChainExpression":
+					currentNode = parent;
+					break;
+
+				/*
+				 * If the upper function is IIFE, checks the destination of the return value.
+				 * e.g.
+				 *   obj.foo = (function() {
+				 *     // setup...
+				 *     return function foo() { ... };
+				 *   })();
+				 *   obj.foo = (() =>
+				 *     function foo() { ... }
+				 *   )();
+				 */
+				case "ReturnStatement": {
+					const func = getUpperFunction(parent);
+
+					if (func === null || !isCallee(func)) {
+						return true;
+					}
+					currentNode = func.parent;
+					break;
+				}
+				case "ArrowFunctionExpression":
+					if (currentNode !== parent.body || !isCallee(parent)) {
+						return true;
+					}
+					currentNode = parent.parent;
+					break;
+
+				/*
+				 * e.g.
+				 *   var obj = { foo() { ... } };
+				 *   var obj = { foo: function() { ... } };
+				 *   class A { constructor() { ... } }
+				 *   class A { foo() { ... } }
+				 *   class A { get foo() { ... } }
+				 *   class A { set foo() { ... } }
+				 *   class A { static foo() { ... } }
+				 *   class A { foo = function() { ... } }
+				 */
+				case "Property":
+				case "PropertyDefinition":
+				case "MethodDefinition":
+					return parent.value !== currentNode;
+
+				/*
+				 * e.g.
+				 *   obj.foo = function foo() { ... };
+				 *   Foo = function() { ... };
+				 *   [obj.foo = function foo() { ... }] = a;
+				 *   [Foo = function() { ... }] = a;
+				 */
+				case "AssignmentExpression":
+				case "AssignmentPattern":
+					if (parent.left.type === "MemberExpression") {
+						return false;
+					}
+					if (
+						capIsConstructor &&
+						isAnonymous &&
+						parent.left.type === "Identifier" &&
+						startsWithUpperCase(parent.left.name)
+					) {
+						return false;
+					}
+					return true;
+
+				/*
+				 * e.g.
+				 *   var Foo = function() { ... };
+				 */
+				case "VariableDeclarator":
+					return !(
+						capIsConstructor &&
+						isAnonymous &&
+						parent.init === currentNode &&
+						parent.id.type === "Identifier" &&
+						startsWithUpperCase(parent.id.name)
+					);
+
+				/*
+				 * e.g.
+				 *   var foo = function foo() { ... }.bind(obj);
+				 *   (function foo() { ... }).call(obj);
+				 *   (function foo() { ... }).apply(obj, []);
+				 */
+				case "MemberExpression":
+					if (
+						parent.object === currentNode &&
+						isSpecificMemberAccess(
+							parent,
+							null,
+							bindOrCallOrApplyPattern,
+						)
+					) {
+						const maybeCalleeNode =
+							parent.parent.type === "ChainExpression"
+								? parent.parent
+								: parent;
+
+						return !(
+							isCallee(maybeCalleeNode) &&
+							maybeCalleeNode.parent.arguments.length >= 1 &&
+							!isNullOrUndefined(
+								maybeCalleeNode.parent.arguments[0],
+							)
+						);
+					}
+					return true;
+
+				/*
+				 * e.g.
+				 *   Reflect.apply(function() {}, obj, []);
+				 *   Array.from([], function() {}, obj);
+				 *   list.forEach(function() {}, obj);
+				 */
+				case "CallExpression":
+					if (isReflectApply(parent.callee)) {
+						return (
+							parent.arguments.length !== 3 ||
+							parent.arguments[0] !== currentNode ||
+							isNullOrUndefined(parent.arguments[1])
+						);
+					}
+					if (isArrayFromMethod(parent.callee)) {
+						return (
+							parent.arguments.length !== 3 ||
+							parent.arguments[1] !== currentNode ||
+							isNullOrUndefined(parent.arguments[2])
+						);
+					}
+					if (isMethodWhichHasThisArg(parent.callee)) {
+						return (
+							parent.arguments.length !== 2 ||
+							parent.arguments[0] !== currentNode ||
+							isNullOrUndefined(parent.arguments[1])
+						);
+					}
+					return true;
+
+				// Otherwise `this` is default.
+				default:
+					return true;
+			}
+		}
+
+		/* c8 ignore next */
+		return true;
+	},
+
+	/**
+	 * Get the precedence level based on the node type
+	 * @param {ASTNode} node node to evaluate
+	 * @returns {int} precedence level
+	 * @private
+	 */
+	getPrecedence(node) {
+		switch (node.type) {
+			case "SequenceExpression":
+				return 0;
+
+			case "AssignmentExpression":
+			case "ArrowFunctionExpression":
+			case "YieldExpression":
+				return 1;
+
+			case "ConditionalExpression":
+				return 3;
+
+			case "LogicalExpression":
+				switch (node.operator) {
+					case "||":
+					case "??":
+						return 4;
+					case "&&":
+						return 5;
+
+					// no default
+				}
+
+			/* falls through */
+
+			case "BinaryExpression":
+				switch (node.operator) {
+					case "|":
+						return 6;
+					case "^":
+						return 7;
+					case "&":
+						return 8;
+					case "==":
+					case "!=":
+					case "===":
+					case "!==":
+						return 9;
+					case "<":
+					case "<=":
+					case ">":
+					case ">=":
+					case "in":
+					case "instanceof":
+						return 10;
+					case "<<":
+					case ">>":
+					case ">>>":
+						return 11;
+					case "+":
+					case "-":
+						return 12;
+					case "*":
+					case "/":
+					case "%":
+						return 13;
+					case "**":
+						return 15;
+
+					// no default
+				}
+
+			/* falls through */
+
+			case "UnaryExpression":
+			case "AwaitExpression":
+				return 16;
+
+			case "UpdateExpression":
+				return 17;
+
+			case "CallExpression":
+			case "ChainExpression":
+			case "ImportExpression":
+				return 18;
+
+			case "NewExpression":
+				return 19;
+
+			default:
+				if (node.type in eslintVisitorKeys) {
+					return 20;
+				}
+
+				/*
+				 * if the node is not a standard node that we know about, then assume it has the lowest precedence
+				 * this will mean that rules will wrap unknown nodes in parentheses where applicable instead of
+				 * unwrapping them and potentially changing the meaning of the code or introducing a syntax error.
+				 */
+				return -1;
+		}
+	},
+
+	/**
+	 * Checks whether the given node is an empty block node or not.
+	 * @param {ASTNode|null} node The node to check.
+	 * @returns {boolean} `true` if the node is an empty block.
+	 */
+	isEmptyBlock(node) {
+		return Boolean(
+			node && node.type === "BlockStatement" && node.body.length === 0,
+		);
+	},
+
+	/**
+	 * Checks whether the given node is an empty function node or not.
+	 * @param {ASTNode|null} node The node to check.
+	 * @returns {boolean} `true` if the node is an empty function.
+	 */
+	isEmptyFunction(node) {
+		return isFunction(node) && module.exports.isEmptyBlock(node.body);
+	},
+
+	/**
+	 * Get directives from directive prologue of a Program or Function node.
+	 * @param {ASTNode} node The node to check.
+	 * @returns {ASTNode[]} The directives found in the directive prologue.
+	 */
+	getDirectivePrologue(node) {
+		const directives = [];
+
+		// Directive prologues only occur at the top of files or functions.
+		if (
+			node.type === "Program" ||
+			node.type === "FunctionDeclaration" ||
+			node.type === "FunctionExpression" ||
+			/*
+			 * Do not check arrow functions with implicit return.
+			 * `() => "use strict";` returns the string `"use strict"`.
+			 */
+			(node.type === "ArrowFunctionExpression" &&
+				node.body.type === "BlockStatement")
+		) {
+			const statements =
+				node.type === "Program" ? node.body : node.body.body;
+
+			for (const statement of statements) {
+				if (
+					statement.type === "ExpressionStatement" &&
+					statement.expression.type === "Literal"
+				) {
+					directives.push(statement);
+				} else {
+					break;
+				}
+			}
+		}
+
+		return directives;
+	},
+
+	/**
+	 * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added
+	 * after the node will be parsed as a decimal point, rather than a property-access dot.
+	 * @param {ASTNode} node The node to check.
+	 * @returns {boolean} `true` if this node is a decimal integer.
+	 * @example
+	 *
+	 * 0         // true
+	 * 5         // true
+	 * 50        // true
+	 * 5_000     // true
+	 * 1_234_56  // true
+	 * 08        // true
+	 * 0192      // true
+	 * 5.        // false
+	 * .5        // false
+	 * 5.0       // false
+	 * 5.00_00   // false
+	 * 05        // false
+	 * 0x5       // false
+	 * 0b101     // false
+	 * 0b11_01   // false
+	 * 0o5       // false
+	 * 5e0       // false
+	 * 5e1_000   // false
+	 * 5n        // false
+	 * 1_000n    // false
+	 * "5"       // false
+	 *
+	 */
+	isDecimalInteger(node) {
+		return (
+			node.type === "Literal" &&
+			typeof node.value === "number" &&
+			DECIMAL_INTEGER_PATTERN.test(node.raw)
+		);
+	},
+
+	/**
+	 * Determines whether this token is a decimal integer numeric token.
+	 * This is similar to isDecimalInteger(), but for tokens.
+	 * @param {Token} token The token to check.
+	 * @returns {boolean} `true` if this token is a decimal integer.
+	 */
+	isDecimalIntegerNumericToken(token) {
+		return (
+			token.type === "Numeric" &&
+			DECIMAL_INTEGER_PATTERN.test(token.value)
+		);
+	},
+
+	/**
+	 * Gets the name and kind of the given function node.
+	 *
+	 * - `function foo() {}`  .................... `function 'foo'`
+	 * - `(function foo() {})`  .................. `function 'foo'`
+	 * - `(function() {})`  ...................... `function`
+	 * - `function* foo() {}`  ................... `generator function 'foo'`
+	 * - `(function* foo() {})`  ................. `generator function 'foo'`
+	 * - `(function*() {})`  ..................... `generator function`
+	 * - `() => {}`  ............................. `arrow function`
+	 * - `async () => {}`  ....................... `async arrow function`
+	 * - `({ foo: function foo() {} })`  ......... `method 'foo'`
+	 * - `({ foo: function() {} })`  ............. `method 'foo'`
+	 * - `({ ['foo']: function() {} })`  ......... `method 'foo'`
+	 * - `({ [foo]: function() {} })`  ........... `method`
+	 * - `({ foo() {} })`  ....................... `method 'foo'`
+	 * - `({ foo: function* foo() {} })`  ........ `generator method 'foo'`
+	 * - `({ foo: function*() {} })`  ............ `generator method 'foo'`
+	 * - `({ ['foo']: function*() {} })`  ........ `generator method 'foo'`
+	 * - `({ [foo]: function*() {} })`  .......... `generator method`
+	 * - `({ *foo() {} })`  ...................... `generator method 'foo'`
+	 * - `({ foo: async function foo() {} })`  ... `async method 'foo'`
+	 * - `({ foo: async function() {} })`  ....... `async method 'foo'`
+	 * - `({ ['foo']: async function() {} })`  ... `async method 'foo'`
+	 * - `({ [foo]: async function() {} })`  ..... `async method`
+	 * - `({ async foo() {} })`  ................. `async method 'foo'`
+	 * - `({ get foo() {} })`  ................... `getter 'foo'`
+	 * - `({ set foo(a) {} })`  .................. `setter 'foo'`
+	 * - `class A { constructor() {} }`  ......... `constructor`
+	 * - `class A { foo() {} }`  ................. `method 'foo'`
+	 * - `class A { *foo() {} }`  ................ `generator method 'foo'`
+	 * - `class A { async foo() {} }`  ........... `async method 'foo'`
+	 * - `class A { ['foo']() {} }`  ............. `method 'foo'`
+	 * - `class A { *['foo']() {} }`  ............ `generator method 'foo'`
+	 * - `class A { async ['foo']() {} }`  ....... `async method 'foo'`
+	 * - `class A { [foo]() {} }`  ............... `method`
+	 * - `class A { *[foo]() {} }`  .............. `generator method`
+	 * - `class A { async [foo]() {} }`  ......... `async method`
+	 * - `class A { get foo() {} }`  ............. `getter 'foo'`
+	 * - `class A { set foo(a) {} }`  ............ `setter 'foo'`
+	 * - `class A { static foo() {} }`  .......... `static method 'foo'`
+	 * - `class A { static *foo() {} }`  ......... `static generator method 'foo'`
+	 * - `class A { static async foo() {} }`  .... `static async method 'foo'`
+	 * - `class A { static get foo() {} }`  ...... `static getter 'foo'`
+	 * - `class A { static set foo(a) {} }`  ..... `static setter 'foo'`
+	 * - `class A { foo = () => {}; }`  .......... `method 'foo'`
+	 * - `class A { foo = function() {}; }`  ..... `method 'foo'`
+	 * - `class A { foo = function bar() {}; }`  . `method 'foo'`
+	 * - `class A { static foo = () => {}; }`  ... `static method 'foo'`
+	 * - `class A { '#foo' = () => {}; }`  ....... `method '#foo'`
+	 * - `class A { #foo = () => {}; }`  ......... `private method #foo`
+	 * - `class A { static #foo = () => {}; }`  .. `static private method #foo`
+	 * - `class A { '#foo'() {} }`  .............. `method '#foo'`
+	 * - `class A { #foo() {} }`  ................ `private method #foo`
+	 * - `class A { static #foo() {} }`  ......... `static private method #foo`
+	 * @param {ASTNode} node The function node to get.
+	 * @returns {string} The name and kind of the function node.
+	 */
+	getFunctionNameWithKind(node) {
+		const parent = node.parent;
+		const tokens = [];
+
+		if (
+			parent.type === "MethodDefinition" ||
+			parent.type === "PropertyDefinition"
+		) {
+			// The proposal uses `static` word consistently before visibility words: https://github.com/tc39/proposal-static-class-features
+			if (parent.static) {
+				tokens.push("static");
+			}
+			if (!parent.computed && parent.key.type === "PrivateIdentifier") {
+				tokens.push("private");
+			}
+		}
+		if (node.async) {
+			tokens.push("async");
+		}
+		if (node.generator) {
+			tokens.push("generator");
+		}
+
+		if (parent.type === "Property" || parent.type === "MethodDefinition") {
+			if (parent.kind === "constructor") {
+				return "constructor";
+			}
+			if (parent.kind === "get") {
+				tokens.push("getter");
+			} else if (parent.kind === "set") {
+				tokens.push("setter");
+			} else {
+				tokens.push("method");
+			}
+		} else if (parent.type === "PropertyDefinition") {
+			tokens.push("method");
+		} else {
+			if (node.type === "ArrowFunctionExpression") {
+				tokens.push("arrow");
+			}
+			tokens.push("function");
+		}
+
+		if (
+			parent.type === "Property" ||
+			parent.type === "MethodDefinition" ||
+			parent.type === "PropertyDefinition"
+		) {
+			if (!parent.computed && parent.key.type === "PrivateIdentifier") {
+				tokens.push(`#${parent.key.name}`);
+			} else {
+				const name = getStaticPropertyName(parent);
+
+				if (name !== null) {
+					tokens.push(`'${name}'`);
+				} else if (node.id) {
+					tokens.push(`'${node.id.name}'`);
+				}
+			}
+		} else if (node.id) {
+			tokens.push(`'${node.id.name}'`);
+		}
+
+		return tokens.join(" ");
+	},
+
+	/**
+	 * Gets the location of the given function node for reporting.
+	 *
+	 * - `function foo() {}`
+	 *    ^^^^^^^^^^^^
+	 * - `(function foo() {})`
+	 *     ^^^^^^^^^^^^
+	 * - `(function() {})`
+	 *     ^^^^^^^^
+	 * - `function* foo() {}`
+	 *    ^^^^^^^^^^^^^
+	 * - `(function* foo() {})`
+	 *     ^^^^^^^^^^^^^
+	 * - `(function*() {})`
+	 *     ^^^^^^^^^
+	 * - `() => {}`
+	 *       ^^
+	 * - `async () => {}`
+	 *             ^^
+	 * - `({ foo: function foo() {} })`
+	 *       ^^^^^^^^^^^^^^^^^
+	 * - `({ foo: function() {} })`
+	 *       ^^^^^^^^^^^^^
+	 * - `({ ['foo']: function() {} })`
+	 *       ^^^^^^^^^^^^^^^^^
+	 * - `({ [foo]: function() {} })`
+	 *       ^^^^^^^^^^^^^^^
+	 * - `({ foo() {} })`
+	 *       ^^^
+	 * - `({ foo: function* foo() {} })`
+	 *       ^^^^^^^^^^^^^^^^^^
+	 * - `({ foo: function*() {} })`
+	 *       ^^^^^^^^^^^^^^
+	 * - `({ ['foo']: function*() {} })`
+	 *       ^^^^^^^^^^^^^^^^^^
+	 * - `({ [foo]: function*() {} })`
+	 *       ^^^^^^^^^^^^^^^^
+	 * - `({ *foo() {} })`
+	 *       ^^^^
+	 * - `({ foo: async function foo() {} })`
+	 *       ^^^^^^^^^^^^^^^^^^^^^^^
+	 * - `({ foo: async function() {} })`
+	 *       ^^^^^^^^^^^^^^^^^^^
+	 * - `({ ['foo']: async function() {} })`
+	 *       ^^^^^^^^^^^^^^^^^^^^^^^
+	 * - `({ [foo]: async function() {} })`
+	 *       ^^^^^^^^^^^^^^^^^^^^^
+	 * - `({ async foo() {} })`
+	 *       ^^^^^^^^^
+	 * - `({ get foo() {} })`
+	 *       ^^^^^^^
+	 * - `({ set foo(a) {} })`
+	 *       ^^^^^^^
+	 * - `class A { constructor() {} }`
+	 *              ^^^^^^^^^^^
+	 * - `class A { foo() {} }`
+	 *              ^^^
+	 * - `class A { *foo() {} }`
+	 *              ^^^^
+	 * - `class A { async foo() {} }`
+	 *              ^^^^^^^^^
+	 * - `class A { ['foo']() {} }`
+	 *              ^^^^^^^
+	 * - `class A { *['foo']() {} }`
+	 *              ^^^^^^^^
+	 * - `class A { async ['foo']() {} }`
+	 *              ^^^^^^^^^^^^^
+	 * - `class A { [foo]() {} }`
+	 *              ^^^^^
+	 * - `class A { *[foo]() {} }`
+	 *              ^^^^^^
+	 * - `class A { async [foo]() {} }`
+	 *              ^^^^^^^^^^^
+	 * - `class A { get foo() {} }`
+	 *              ^^^^^^^
+	 * - `class A { set foo(a) {} }`
+	 *              ^^^^^^^
+	 * - `class A { static foo() {} }`
+	 *              ^^^^^^^^^^
+	 * - `class A { static *foo() {} }`
+	 *              ^^^^^^^^^^^
+	 * - `class A { static async foo() {} }`
+	 *              ^^^^^^^^^^^^^^^^
+	 * - `class A { static get foo() {} }`
+	 *              ^^^^^^^^^^^^^^
+	 * - `class A { static set foo(a) {} }`
+	 *              ^^^^^^^^^^^^^^
+	 * - `class A { foo = function() {} }`
+	 *              ^^^^^^^^^^^^^^
+	 * - `class A { static foo = function() {} }`
+	 *              ^^^^^^^^^^^^^^^^^^^^^
+	 * - `class A { foo = (a, b) => {} }`
+	 *              ^^^^^^
+	 * @param {ASTNode} node The function node to get.
+	 * @param {SourceCode} sourceCode The source code object to get tokens.
+	 * @returns {string} The location of the function node for reporting.
+	 */
+	getFunctionHeadLoc(node, sourceCode) {
+		const parent = node.parent;
+		let start;
+		let end;
+
+		if (
+			parent.type === "Property" ||
+			parent.type === "MethodDefinition" ||
+			parent.type === "PropertyDefinition"
+		) {
+			start = parent.loc.start;
+			end = getOpeningParenOfParams(node, sourceCode).loc.start;
+		} else if (node.type === "ArrowFunctionExpression") {
+			const arrowToken = sourceCode.getTokenBefore(
+				node.body,
+				isArrowToken,
+			);
+
+			start = arrowToken.loc.start;
+			end = arrowToken.loc.end;
+		} else {
+			start = node.loc.start;
+			end = getOpeningParenOfParams(node, sourceCode).loc.start;
+		}
+
+		return {
+			start: Object.assign({}, start),
+			end: Object.assign({}, end),
+		};
+	},
+
+	/**
+	 * Gets next location when the result is not out of bound, otherwise returns null.
+	 *
+	 * Assumptions:
+	 *
+	 * - The given location represents a valid location in the given source code.
+	 * - Columns are 0-based.
+	 * - Lines are 1-based.
+	 * - Column immediately after the last character in a line (not incl. linebreaks) is considered to be a valid location.
+	 * - If the source code ends with a linebreak, `sourceCode.lines` array will have an extra element (empty string) at the end.
+	 *   The start (column 0) of that extra line is considered to be a valid location.
+	 *
+	 * Examples of successive locations (line, column):
+	 *
+	 * code: foo
+	 * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> null
+	 *
+	 * code: foo<LF>
+	 * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
+	 *
+	 * code: foo<CR><LF>
+	 * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
+	 *
+	 * code: a<LF>b
+	 * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> null
+	 *
+	 * code: a<LF>b<LF>
+	 * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
+	 *
+	 * code: a<CR><LF>b<CR><LF>
+	 * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
+	 *
+	 * code: a<LF><LF>
+	 * locations: (1, 0) -> (1, 1) -> (2, 0) -> (3, 0) -> null
+	 *
+	 * code: <LF>
+	 * locations: (1, 0) -> (2, 0) -> null
+	 *
+	 * code:
+	 * locations: (1, 0) -> null
+	 * @param {SourceCode} sourceCode The sourceCode
+	 * @param {{line: number, column: number}} location The location
+	 * @returns {{line: number, column: number} | null} Next location
+	 */
+	getNextLocation(sourceCode, { line, column }) {
+		if (column < sourceCode.lines[line - 1].length) {
+			return {
+				line,
+				column: column + 1,
+			};
+		}
+
+		if (line < sourceCode.lines.length) {
+			return {
+				line: line + 1,
+				column: 0,
+			};
+		}
+
+		return null;
+	},
+
+	/**
+	 * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses
+	 * surrounding the node.
+	 * @param {SourceCode} sourceCode The source code object
+	 * @param {ASTNode} node An expression node
+	 * @returns {string} The text representing the node, with all surrounding parentheses included
+	 */
+	getParenthesisedText(sourceCode, node) {
+		let leftToken = sourceCode.getFirstToken(node);
+		let rightToken = sourceCode.getLastToken(node);
+
+		while (
+			sourceCode.getTokenBefore(leftToken) &&
+			sourceCode.getTokenBefore(leftToken).type === "Punctuator" &&
+			sourceCode.getTokenBefore(leftToken).value === "(" &&
+			sourceCode.getTokenAfter(rightToken) &&
+			sourceCode.getTokenAfter(rightToken).type === "Punctuator" &&
+			sourceCode.getTokenAfter(rightToken).value === ")"
+		) {
+			leftToken = sourceCode.getTokenBefore(leftToken);
+			rightToken = sourceCode.getTokenAfter(rightToken);
+		}
+
+		return sourceCode
+			.getText()
+			.slice(leftToken.range[0], rightToken.range[1]);
+	},
+
+	/**
+	 * Determine if a node has a possibility to be an Error object
+	 * @param {ASTNode} node ASTNode to check
+	 * @returns {boolean} True if there is a chance it contains an Error obj
+	 */
+	couldBeError(node) {
+		switch (node.type) {
+			case "Identifier":
+			case "CallExpression":
+			case "NewExpression":
+			case "MemberExpression":
+			case "TaggedTemplateExpression":
+			case "YieldExpression":
+			case "AwaitExpression":
+			case "ChainExpression":
+				return true; // possibly an error object.
+
+			case "AssignmentExpression":
+				if (["=", "&&="].includes(node.operator)) {
+					return module.exports.couldBeError(node.right);
+				}
+
+				if (["||=", "??="].includes(node.operator)) {
+					return (
+						module.exports.couldBeError(node.left) ||
+						module.exports.couldBeError(node.right)
+					);
+				}
+
+				/**
+				 * All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
+				 * An assignment expression with a mathematical operator can either evaluate to a primitive value,
+				 * or throw, depending on the operands. Thus, it cannot evaluate to an `Error` object.
+				 */
+				return false;
+
+			case "SequenceExpression": {
+				const exprs = node.expressions;
+
+				return (
+					exprs.length !== 0 &&
+					module.exports.couldBeError(exprs.at(-1))
+				);
+			}
+
+			case "LogicalExpression":
+				/*
+				 * If the && operator short-circuits, the left side was falsy and therefore not an error, and if it
+				 * doesn't short-circuit, it takes the value from the right side, so the right side must always be
+				 * a plausible error. A future improvement could verify that the left side could be truthy by
+				 * excluding falsy literals.
+				 */
+				if (node.operator === "&&") {
+					return module.exports.couldBeError(node.right);
+				}
+
+				return (
+					module.exports.couldBeError(node.left) ||
+					module.exports.couldBeError(node.right)
+				);
+
+			case "ConditionalExpression":
+				return (
+					module.exports.couldBeError(node.consequent) ||
+					module.exports.couldBeError(node.alternate)
+				);
+
+			default:
+				return false;
+		}
+	},
+
+	/**
+	 * Check if a given node is a numeric literal or not.
+	 * @param {ASTNode} node The node to check.
+	 * @returns {boolean} `true` if the node is a number or bigint literal.
+	 */
+	isNumericLiteral(node) {
+		return (
+			node.type === "Literal" &&
+			(typeof node.value === "number" || Boolean(node.bigint))
+		);
+	},
+
+	/**
+	 * Determines whether two tokens can safely be placed next to each other without merging into a single token
+	 * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used.
+	 * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used.
+	 * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed
+	 * next to each other, behavior is undefined (although it should return `true` in most cases).
+	 */
+	canTokensBeAdjacent(leftValue, rightValue) {
+		const espreeOptions = {
+			ecmaVersion: espree.latestEcmaVersion,
+			comment: true,
+			range: true,
+		};
+
+		let leftToken;
+
+		if (typeof leftValue === "string") {
+			let tokens;
+
+			try {
+				tokens = espree.tokenize(leftValue, espreeOptions);
+			} catch {
+				return false;
+			}
+
+			const comments = tokens.comments;
+
+			leftToken = tokens.at(-1);
+			if (comments.length) {
+				const lastComment = comments.at(-1);
+
+				if (!leftToken || lastComment.range[0] > leftToken.range[0]) {
+					leftToken = lastComment;
+				}
+			}
+		} else {
+			leftToken = leftValue;
+		}
+
+		/*
+		 * If a hashbang comment was passed as a token object from SourceCode,
+		 * its type will be "Shebang" because of the way ESLint itself handles hashbangs.
+		 * If a hashbang comment was passed in a string and then tokenized in this function,
+		 * its type will be "Hashbang" because of the way Espree tokenizes hashbangs.
+		 */
+		if (leftToken.type === "Shebang" || leftToken.type === "Hashbang") {
+			return false;
+		}
+
+		let rightToken;
+
+		if (typeof rightValue === "string") {
+			let tokens;
+
+			try {
+				tokens = espree.tokenize(rightValue, espreeOptions);
+			} catch {
+				return false;
+			}
+
+			const comments = tokens.comments;
+
+			rightToken = tokens[0];
+			if (comments.length) {
+				const firstComment = comments[0];
+
+				if (
+					!rightToken ||
+					firstComment.range[0] < rightToken.range[0]
+				) {
+					rightToken = firstComment;
+				}
+			}
+		} else {
+			rightToken = rightValue;
+		}
+
+		if (
+			leftToken.type === "Punctuator" ||
+			rightToken.type === "Punctuator"
+		) {
+			if (
+				leftToken.type === "Punctuator" &&
+				rightToken.type === "Punctuator"
+			) {
+				const PLUS_TOKENS = new Set(["+", "++"]);
+				const MINUS_TOKENS = new Set(["-", "--"]);
+
+				return !(
+					(PLUS_TOKENS.has(leftToken.value) &&
+						PLUS_TOKENS.has(rightToken.value)) ||
+					(MINUS_TOKENS.has(leftToken.value) &&
+						MINUS_TOKENS.has(rightToken.value))
+				);
+			}
+			if (leftToken.type === "Punctuator" && leftToken.value === "/") {
+				return !["Block", "Line", "RegularExpression"].includes(
+					rightToken.type,
+				);
+			}
+			return true;
+		}
+
+		if (
+			leftToken.type === "String" ||
+			rightToken.type === "String" ||
+			leftToken.type === "Template" ||
+			rightToken.type === "Template"
+		) {
+			return true;
+		}
+
+		if (
+			leftToken.type !== "Numeric" &&
+			rightToken.type === "Numeric" &&
+			rightToken.value.startsWith(".")
+		) {
+			return true;
+		}
+
+		if (
+			leftToken.type === "Block" ||
+			rightToken.type === "Block" ||
+			rightToken.type === "Line"
+		) {
+			return true;
+		}
+
+		if (rightToken.type === "PrivateIdentifier") {
+			return true;
+		}
+
+		return false;
+	},
+
+	/**
+	 * Get the `loc` object of a given name in a `/*globals` directive comment.
+	 * @param {SourceCode} sourceCode The source code to convert index to loc.
+	 * @param {Comment} comment The `/*globals` directive comment which include the name.
+	 * @param {string} name The name to find.
+	 * @returns {SourceLocation} The `loc` object.
+	 */
+	getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) {
+		const namePattern = new RegExp(
+			`[\\s,]${escapeRegExp(name)}(?:$|[\\s,:])`,
+			"gu",
+		);
+
+		// To ignore the first text "global".
+		namePattern.lastIndex = comment.value.indexOf("global") + 6;
+
+		// Search a given variable name.
+		const match = namePattern.exec(comment.value);
+
+		// Convert the index to loc.
+		const start = sourceCode.getLocFromIndex(
+			comment.range[0] + "/*".length + (match ? match.index + 1 : 0),
+		);
+		const end = {
+			line: start.line,
+			column: start.column + (match ? name.length : 1),
+		};
+
+		return { start, end };
+	},
+
+	/**
+	 * Determines whether the given raw string contains an octal escape sequence
+	 * or a non-octal decimal escape sequence ("\8", "\9").
+	 *
+	 * "\1", "\2" ... "\7", "\8", "\9"
+	 * "\00", "\01" ... "\07", "\08", "\09"
+	 *
+	 * "\0", when not followed by a digit, is not an octal escape sequence.
+	 * @param {string} rawString A string in its raw representation.
+	 * @returns {boolean} `true` if the string contains at least one octal escape sequence
+	 * or at least one non-octal decimal escape sequence.
+	 */
+	hasOctalOrNonOctalDecimalEscapeSequence(rawString) {
+		return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString);
+	},
+
+	/**
+	 * Determines whether the given node is a template literal without expressions.
+	 * @param {ASTNode} node Node to check.
+	 * @returns {boolean} True if the node is a template literal without expressions.
+	 */
+	isStaticTemplateLiteral(node) {
+		return node.type === "TemplateLiteral" && node.expressions.length === 0;
+	},
+
+	/**
+	 * Determines whether the existing curly braces around the single statement are necessary to preserve the semantics of the code.
+	 * The braces, which make the given block body, are necessary in either of the following situations:
+	 *
+	 * 1. The statement is a lexical declaration.
+	 * 2. Without the braces, an `if` within the statement would become associated with an `else` after the closing brace:
+	 *
+	 *     if (a) {
+	 *         if (b)
+	 *             foo();
+	 *     }
+	 *     else
+	 *         bar();
+	 *
+	 *     if (a)
+	 *         while (b)
+	 *             while (c) {
+	 *                 while (d)
+	 *                     if (e)
+	 *                         while(f)
+	 *                             foo();
+	 *            }
+	 *     else
+	 *         bar();
+	 * @param {ASTNode} node `BlockStatement` body with exactly one statement directly inside. The statement can have its own nested statements.
+	 * @param {SourceCode} sourceCode The source code
+	 * @returns {boolean} `true` if the braces are necessary - removing them (replacing the given `BlockStatement` body with its single statement content)
+	 * would change the semantics of the code or produce a syntax error.
+	 */
+	areBracesNecessary(node, sourceCode) {
+		/**
+		 * Determines if the given node is a lexical declaration (let, const, function, or class)
+		 * @param {ASTNode} nodeToCheck The node to check
+		 * @returns {boolean} True if the node is a lexical declaration
+		 * @private
+		 */
+		function isLexicalDeclaration(nodeToCheck) {
+			if (nodeToCheck.type === "VariableDeclaration") {
+				return (
+					nodeToCheck.kind === "const" || nodeToCheck.kind === "let"
+				);
+			}
+
+			return (
+				nodeToCheck.type === "FunctionDeclaration" ||
+				nodeToCheck.type === "ClassDeclaration"
+			);
+		}
+
+		/**
+		 * Checks if the given token is an `else` token or not.
+		 * @param {Token} token The token to check.
+		 * @returns {boolean} `true` if the token is an `else` token.
+		 */
+		function isElseKeywordToken(token) {
+			return token.value === "else" && token.type === "Keyword";
+		}
+
+		/**
+		 * Determines whether the given node has an `else` keyword token as the first token after.
+		 * @param {ASTNode} nodeToCheck The node to check.
+		 * @returns {boolean} `true` if the node is followed by an `else` keyword token.
+		 */
+		function isFollowedByElseKeyword(nodeToCheck) {
+			const nextToken = sourceCode.getTokenAfter(nodeToCheck);
+
+			return Boolean(nextToken) && isElseKeywordToken(nextToken);
+		}
+
+		/**
+		 * Determines whether the code represented by the given node contains an `if` statement
+		 * that would become associated with an `else` keyword directly appended to that code.
+		 *
+		 * Examples where it returns `true`:
+		 *
+		 *    if (a)
+		 *        foo();
+		 *
+		 *    if (a) {
+		 *        foo();
+		 *    }
+		 *
+		 *    if (a)
+		 *        foo();
+		 *    else if (b)
+		 *        bar();
+		 *
+		 *    while (a)
+		 *        if (b)
+		 *            if(c)
+		 *                foo();
+		 *            else
+		 *                bar();
+		 *
+		 * Examples where it returns `false`:
+		 *
+		 *    if (a)
+		 *        foo();
+		 *    else
+		 *        bar();
+		 *
+		 *    while (a) {
+		 *        if (b)
+		 *            if(c)
+		 *                foo();
+		 *            else
+		 *                bar();
+		 *    }
+		 *
+		 *    while (a)
+		 *        if (b) {
+		 *            if(c)
+		 *                foo();
+		 *        }
+		 *        else
+		 *            bar();
+		 * @param {ASTNode} nodeToCheck Node representing the code to check.
+		 * @returns {boolean} `true` if an `if` statement within the code would become associated with an `else` appended to that code.
+		 */
+		function hasUnsafeIf(nodeToCheck) {
+			switch (nodeToCheck.type) {
+				case "IfStatement":
+					if (!nodeToCheck.alternate) {
+						return true;
+					}
+					return hasUnsafeIf(nodeToCheck.alternate);
+				case "ForStatement":
+				case "ForInStatement":
+				case "ForOfStatement":
+				case "LabeledStatement":
+				case "WithStatement":
+				case "WhileStatement":
+					return hasUnsafeIf(nodeToCheck.body);
+				default:
+					return false;
+			}
+		}
+
+		const statement = node.body[0];
+
+		return (
+			isLexicalDeclaration(statement) ||
+			(hasUnsafeIf(statement) && isFollowedByElseKeyword(node))
+		);
+	},
+
+	isReferenceToGlobalVariable,
+	isLogicalExpression,
+	isCoalesceExpression,
+	isMixedLogicalAndCoalesceExpressions,
+	isNullLiteral,
+	getStaticStringValue,
+	getStaticPropertyName,
+	skipChainExpression,
+	isSpecificId,
+	isSpecificMemberAccess,
+	equalLiteralValue,
+	isSameReference,
+	isLogicalAssignmentOperator,
+	getSwitchCaseColonToken,
+	getModuleExportName,
+	isConstant,
+	isTopLevelExpressionStatement,
+	isDirective,
+	isStartOfExpressionStatement,
+	needsPrecedingSemicolon,
+	isImportAttributeKey,
 };