oxlint-plugin-eslint 1.60.0 → 1.62.0

package/common/ast-utils.cjs

@@ -2739,27 +2739,27 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 			for (var prop in node) newNode[prop] = node[prop];
 			return newNode;
 		};
-		var scriptValuesAddedInUnicode = "Gara Garay Gukh Gurung_Khema Hrkt Katakana_Or_Hiragana Kawi Kirat_Rai Krai Nag_Mundari Nagm Ol_Onal Onao Sunu Sunuwar Todhri Todr Tulu_Tigalari Tutg Unknown Zzzz", ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS", ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic", ecma11BinaryProperties = ecma10BinaryProperties, ecma12BinaryProperties = ecma11BinaryProperties + " EBase EComp EMod EPres ExtPict", ecma13BinaryProperties = ecma12BinaryProperties, ecma14BinaryProperties = ecma13BinaryProperties, unicodeBinaryProperties = {
+		var scriptValuesAddedInUnicode = "Gara Garay Gukh Gurung_Khema Hrkt Katakana_Or_Hiragana Kawi Kirat_Rai Krai Nag_Mundari Nagm Ol_Onal Onao Sunu Sunuwar Todhri Todr Tulu_Tigalari Tutg Unknown Zzzz", ecma9BinaryProperties = "ASCII ASCII_Hex_Digit AHex Alphabetic Alpha Any Assigned Bidi_Control Bidi_C Bidi_Mirrored Bidi_M Case_Ignorable CI Cased Changes_When_Casefolded CWCF Changes_When_Casemapped CWCM Changes_When_Lowercased CWL Changes_When_NFKC_Casefolded CWKCF Changes_When_Titlecased CWT Changes_When_Uppercased CWU Dash Default_Ignorable_Code_Point DI Deprecated Dep Diacritic Dia Emoji Emoji_Component Emoji_Modifier Emoji_Modifier_Base Emoji_Presentation Extender Ext Grapheme_Base Gr_Base Grapheme_Extend Gr_Ext Hex_Digit Hex IDS_Binary_Operator IDSB IDS_Trinary_Operator IDST ID_Continue IDC ID_Start IDS Ideographic Ideo Join_Control Join_C Logical_Order_Exception LOE Lowercase Lower Math Noncharacter_Code_Point NChar Pattern_Syntax Pat_Syn Pattern_White_Space Pat_WS Quotation_Mark QMark Radical Regional_Indicator RI Sentence_Terminal STerm Soft_Dotted SD Terminal_Punctuation Term Unified_Ideograph UIdeo Uppercase Upper Variation_Selector VS White_Space space XID_Continue XIDC XID_Start XIDS", ecma10BinaryProperties = ecma9BinaryProperties + " Extended_Pictographic", ecma11BinaryProperties = ecma10BinaryProperties, ecma12BinaryProperties = ecma11BinaryProperties + " EBase EComp EMod EPres ExtPict", ecma13BinaryProperties = ecma12BinaryProperties, unicodeBinaryProperties = {
 			9: ecma9BinaryProperties,
 			10: ecma10BinaryProperties,
 			11: ecma11BinaryProperties,
 			12: ecma12BinaryProperties,
 			13: ecma13BinaryProperties,
-			14: ecma14BinaryProperties
-		}, ecma14BinaryPropertiesOfStrings = "Basic_Emoji Emoji_Keycap_Sequence RGI_Emoji_Modifier_Sequence RGI_Emoji_Flag_Sequence RGI_Emoji_Tag_Sequence RGI_Emoji_ZWJ_Sequence RGI_Emoji", unicodeBinaryPropertiesOfStrings = {
+			14: ecma13BinaryProperties
+		}, unicodeBinaryPropertiesOfStrings = {
 			9: "",
 			10: "",
 			11: "",
 			12: "",
 			13: "",
-			14: ecma14BinaryPropertiesOfStrings
-		}, unicodeGeneralCategoryValues = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu", ecma9ScriptValues = "Adlam Adlm Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb", ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd", ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho", ecma12ScriptValues = ecma11ScriptValues + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi", ecma13ScriptValues = ecma12ScriptValues + " Cypro_Minoan Cpmn Old_Uyghur Ougr Tangsa Tnsa Toto Vithkuqi Vith", ecma14ScriptValues = ecma13ScriptValues + " " + scriptValuesAddedInUnicode, unicodeScriptValues = {
+			14: "Basic_Emoji Emoji_Keycap_Sequence RGI_Emoji_Modifier_Sequence RGI_Emoji_Flag_Sequence RGI_Emoji_Tag_Sequence RGI_Emoji_ZWJ_Sequence RGI_Emoji"
+		}, unicodeGeneralCategoryValues = "Cased_Letter LC Close_Punctuation Pe Connector_Punctuation Pc Control Cc cntrl Currency_Symbol Sc Dash_Punctuation Pd Decimal_Number Nd digit Enclosing_Mark Me Final_Punctuation Pf Format Cf Initial_Punctuation Pi Letter L Letter_Number Nl Line_Separator Zl Lowercase_Letter Ll Mark M Combining_Mark Math_Symbol Sm Modifier_Letter Lm Modifier_Symbol Sk Nonspacing_Mark Mn Number N Open_Punctuation Ps Other C Other_Letter Lo Other_Number No Other_Punctuation Po Other_Symbol So Paragraph_Separator Zp Private_Use Co Punctuation P punct Separator Z Space_Separator Zs Spacing_Mark Mc Surrogate Cs Symbol S Titlecase_Letter Lt Unassigned Cn Uppercase_Letter Lu", ecma9ScriptValues = "Adlam Adlm Ahom Anatolian_Hieroglyphs Hluw Arabic Arab Armenian Armn Avestan Avst Balinese Bali Bamum Bamu Bassa_Vah Bass Batak Batk Bengali Beng Bhaiksuki Bhks Bopomofo Bopo Brahmi Brah Braille Brai Buginese Bugi Buhid Buhd Canadian_Aboriginal Cans Carian Cari Caucasian_Albanian Aghb Chakma Cakm Cham Cham Cherokee Cher Common Zyyy Coptic Copt Qaac Cuneiform Xsux Cypriot Cprt Cyrillic Cyrl Deseret Dsrt Devanagari Deva Duployan Dupl Egyptian_Hieroglyphs Egyp Elbasan Elba Ethiopic Ethi Georgian Geor Glagolitic Glag Gothic Goth Grantha Gran Greek Grek Gujarati Gujr Gurmukhi Guru Han Hani Hangul Hang Hanunoo Hano Hatran Hatr Hebrew Hebr Hiragana Hira Imperial_Aramaic Armi Inherited Zinh Qaai Inscriptional_Pahlavi Phli Inscriptional_Parthian Prti Javanese Java Kaithi Kthi Kannada Knda Katakana Kana Kayah_Li Kali Kharoshthi Khar Khmer Khmr Khojki Khoj Khudawadi Sind Lao Laoo Latin Latn Lepcha Lepc Limbu Limb Linear_A Lina Linear_B Linb Lisu Lisu Lycian Lyci Lydian Lydi Mahajani Mahj Malayalam Mlym Mandaic Mand Manichaean Mani Marchen Marc Masaram_Gondi Gonm Meetei_Mayek Mtei Mende_Kikakui Mend Meroitic_Cursive Merc Meroitic_Hieroglyphs Mero Miao Plrd Modi Mongolian Mong Mro Mroo Multani Mult Myanmar Mymr Nabataean Nbat New_Tai_Lue Talu Newa Newa Nko Nkoo Nushu Nshu Ogham Ogam Ol_Chiki Olck Old_Hungarian Hung Old_Italic Ital Old_North_Arabian Narb Old_Permic Perm Old_Persian Xpeo Old_South_Arabian Sarb Old_Turkic Orkh Oriya Orya Osage Osge Osmanya Osma Pahawh_Hmong Hmng Palmyrene Palm Pau_Cin_Hau Pauc Phags_Pa Phag Phoenician Phnx Psalter_Pahlavi Phlp Rejang Rjng Runic Runr Samaritan Samr Saurashtra Saur Sharada Shrd Shavian Shaw Siddham Sidd SignWriting Sgnw Sinhala Sinh Sora_Sompeng Sora Soyombo Soyo Sundanese Sund Syloti_Nagri Sylo Syriac Syrc Tagalog Tglg Tagbanwa Tagb Tai_Le Tale Tai_Tham Lana Tai_Viet Tavt Takri Takr Tamil Taml Tangut Tang Telugu Telu Thaana Thaa Thai Thai Tibetan Tibt Tifinagh Tfng Tirhuta Tirh Ugaritic Ugar Vai Vaii Warang_Citi Wara Yi Yiii Zanabazar_Square Zanb", ecma10ScriptValues = ecma9ScriptValues + " Dogra Dogr Gunjala_Gondi Gong Hanifi_Rohingya Rohg Makasar Maka Medefaidrin Medf Old_Sogdian Sogo Sogdian Sogd", ecma11ScriptValues = ecma10ScriptValues + " Elymaic Elym Nandinagari Nand Nyiakeng_Puachue_Hmong Hmnp Wancho Wcho", ecma12ScriptValues = ecma11ScriptValues + " Chorasmian Chrs Diak Dives_Akuru Khitan_Small_Script Kits Yezi Yezidi", ecma13ScriptValues = ecma12ScriptValues + " Cypro_Minoan Cpmn Old_Uyghur Ougr Tangsa Tnsa Toto Vithkuqi Vith", unicodeScriptValues = {
 			9: ecma9ScriptValues,
 			10: ecma10ScriptValues,
 			11: ecma11ScriptValues,
 			12: ecma12ScriptValues,
 			13: ecma13ScriptValues,
-			14: ecma14ScriptValues
+			14: ecma13ScriptValues + " " + scriptValuesAddedInUnicode
 		}, data = {};
 		function buildUnicodeData(ecmaVersion) {
 			var d = data[ecmaVersion] = {
@@ -4199,6 +4199,14 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 	}
 	TokenTranslator.prototype = {
 		constructor: TokenTranslator,
+		/**
+		* Translates a single Esprima token to a single Acorn token. This may be
+		* inaccurate due to how templates are handled differently in Esprima and
+		* Acorn, but should be accurate for all other tokens.
+		* @param {AcornToken} token The Acorn token to translate.
+		* @param {Object} extra Espree extra object.
+		* @returns {EsprimaToken} The Esprima version of the token.
+		*/
 		translate(token, extra) {
 			let type = token.type, tt = this._acornTokTypes;
 			if (type === tt.name) token.type = Token.Identifier, token.value === "static" && (token.type = Token.Keyword), extra.ecmaVersion > 5 && (token.value === "yield" || token.value === "let") && (token.type = Token.Keyword);
@@ -4219,6 +4227,12 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 			}
 			return token;
 		},
+		/**
+		* Function to call during Acorn's onToken handler.
+		* @param {AcornToken} token The Acorn token.
+		* @param {Object} extra The Espree extra object.
+		* @returns {void}
+		*/
 		onToken(token, extra) {
 			let tt = this._acornTokTypes, tokens = extra.tokens, templateTokens = this._tokens, translateTemplateTokens = () => {
 				tokens.push(convertTemplatePart(this._tokens, this._code)), this._tokens = [];
@@ -5392,6 +5406,13 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 		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;
 		},
@@ -5432,23 +5453,75 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 		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) {
 			let 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;
 			for (; scope;) {
@@ -5458,6 +5531,34 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 			}
 			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 = !0 } = {}) {
 			if (node.parent.type === "PropertyDefinition" && node.parent.value === node || node.type === "StaticBlock" || (node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.params.some((param) => param.type === "Identifier" && param.name === "this") || capIsConstructor && isES5Constructor(node) || hasJSDocThisTag(node, sourceCode)) return !1;
 			let isAnonymous = node.id === null, currentNode = node;
@@ -5498,6 +5599,12 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 			/* c8 ignore next */
 			return !0;
 		},
+		/**
+		* Get the precedence level based on the node type
+		* @param {ASTNode} node node to evaluate
+		* @returns {number} precedence level
+		* @private
+		*/
 		getPrecedence(node) {
 			switch (node.type) {
 				case "SequenceExpression": return 0;
@@ -5544,12 +5651,27 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 				default: return node.type in eslintVisitorKeys ? 20 : -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 !!(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) {
 			let directives = [];
 			if (node.type === "Program" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" && node.body.type === "BlockStatement") {
@@ -5559,12 +5681,106 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 			}
 			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) {
 			let parent = node.parent, tokens = [];
 			if ((parent.type === "MethodDefinition" || parent.type === "PropertyDefinition" || node.type === "TSPropertySignature" || node.type === "TSMethodSignature") && (parent.static && tokens.push("static"), !parent.computed && parent.key?.type === "PrivateIdentifier" && tokens.push("private")), node.async && tokens.push("async"), node.generator && tokens.push("generator"), parent.type === "Property" || parent.type === "MethodDefinition") {
@@ -5579,6 +5795,103 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 			else node.type === "TSMethodSignature" ? tokens.push(`'${getStaticPropertyName(node)}'`) : 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) {
 			let parent = node.parent, start, end;
 			if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition" || parent.type === "TSPropertySignature" || parent.type === "TSMethodSignature") start = parent.loc.start, end = getOpeningParenOfParams(node, sourceCode).loc.start;
@@ -5591,6 +5904,50 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 				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 }) {
 			return column < sourceCode.lines[line - 1].length ? {
 				line,
@@ -5600,11 +5957,23 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 				column: 0
 			} : 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), rightToken = sourceCode.getLastToken(node);
 			for (; 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":
@@ -5631,9 +6000,21 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 				default: return !1;
 			}
 		},
+		/**
+		* 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" || !!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) {
 			let espreeOptions = {
 				ecmaVersion: espree.latestEcmaVersion,
@@ -5681,6 +6062,13 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 			}
 			return !!(leftToken.type === "String" || rightToken.type === "String" || leftToken.type === "Template" || rightToken.type === "Template" || leftToken.type !== "Numeric" && rightToken.type === "Numeric" && rightToken.value.startsWith(".") || leftToken.type === "Block" || rightToken.type === "Block" || rightToken.type === "Line" || rightToken.type === "PrivateIdentifier");
 		},
+		/**
+		* 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) {
 			let namePattern = RegExp(`[\\s,]${escapeRegExp(name)}(?:$|[\\s,:])`, "gu");
 			namePattern.lastIndex = comment.value.indexOf("global") + 6;
@@ -5693,12 +6081,58 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 				}
 			};
 		},
+		/**
+		* 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, using, await using, function, or class)

package/common/chunk.cjs

@@ -1,5 +1,5 @@
 //#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 //#endregion
 Object.defineProperty(exports, "t", {
 	enumerable: !0,

package/common/eslint-utils.cjs

@@ -989,10 +989,20 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 		return typeof x == "object" && !!x && typeof x.type == "string";
 	}
 	let visitor = Object.freeze(Object.assign(Object.create(null), {
+		/**
+		* @param {Node} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		$visit(node, options, visitorKeys) {
 			let { type } = node;
 			return typeof this[type] == "function" ? this[type](node, options, visitorKeys) : this.$visitChildren(node, options, visitorKeys);
 		},
+		/**
+		* @param {Node} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		$visitChildren(node, options, visitorKeys) {
 			let { type } = node;
 			for (let key of visitorKeys[type] || eslintVisitorKeys.getKeys(node)) {
@@ -1012,6 +1022,11 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 		AwaitExpression() {
 			return !0;
 		},
+		/**
+		* @param {BinaryExpression} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		BinaryExpression(node, options, visitorKeys) {
 			return options.considerImplicitTypeConversion && typeConversionBinaryOps.has(node.operator) && (node.left.type !== "Literal" || node.right.type !== "Literal") ? !0 : this.$visitChildren(node, options, visitorKeys);
 		},
@@ -1024,21 +1039,46 @@ var require_eslint_visitor_keys = /* @__PURE__ */ require_chunk.t(((exports) =>
 		ImportExpression() {
 			return !0;
 		},
+		/**
+		* @param {MemberExpression} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		MemberExpression(node, options, visitorKeys) {
 			return options.considerGetters || options.considerImplicitTypeConversion && node.computed && node.property.type !== "Literal" ? !0 : this.$visitChildren(node, options, visitorKeys);
 		},
+		/**
+		* @param {MethodDefinition} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		MethodDefinition(node, options, visitorKeys) {
 			return options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal" ? !0 : this.$visitChildren(node, options, visitorKeys);
 		},
 		NewExpression() {
 			return !0;
 		},
+		/**
+		* @param {Property} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		Property(node, options, visitorKeys) {
 			return options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal" ? !0 : this.$visitChildren(node, options, visitorKeys);
 		},
+		/**
+		* @param {PropertyDefinition} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		PropertyDefinition(node, options, visitorKeys) {
 			return options.considerImplicitTypeConversion && node.computed && node.key.type !== "Literal" ? !0 : this.$visitChildren(node, options, visitorKeys);
 		},
+		/**
+		* @param {UnaryExpression} node
+		* @param {HasSideEffectOptions} options
+		* @param {Record<string, string[]>} visitorKeys
+		*/
 		UnaryExpression(node, options, visitorKeys) {
 			return node.operator === "delete" || options.considerImplicitTypeConversion && typeConversionUnaryOps.has(node.operator) && node.argument.type !== "Literal" ? !0 : this.$visitChildren(node, options, visitorKeys);
 		},

package/common/regexpp.cjs

@@ -1193,7 +1193,7 @@ var require_regexpp = /* @__PURE__ */ require("./chunk.cjs").t(((exports) => {
 		onGroupEnter(start) {
 			let parent = this._node;
 			if (parent.type !== "Alternative") throw Error("UnknownError");
-			this._node = {
+			let group = {
 				type: "Group",
 				parent,
 				start,
@@ -1201,7 +1201,8 @@ var require_regexpp = /* @__PURE__ */ require("./chunk.cjs").t(((exports) => {
 				raw: "",
 				modifiers: null,
 				alternatives: []
-			}, parent.elements.push(this._node);
+			};
+			this._node = group, parent.elements.push(this._node);
 		}
 		onGroupLeave(start, end) {
 			let node = this._node;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-eslint",
-  "version": "1.60.0",
+  "version": "1.62.0",
   "description": "ESLint's built-in rules as an Oxlint plugin",
   "keywords": [
     "eslint",

package/rules/arrow-parens.cjs

@@ -99,7 +99,7 @@ var require_arrow_parens = /* @__PURE__ */ require_chunk.t(((exports, module) =>
 			* @returns {boolean} `true` if the function has at least one unexpected token.
 			*/
 			function hasUnexpectedTokensBeforeOpeningParen(node, openingParen) {
-				let expectedCount = node.async ? 1 : 0;
+				let expectedCount = +!!node.async;
 				return sourceCode.getFirstToken(node, { skip: expectedCount }) !== openingParen;
 			}
 			return { "ArrowFunctionExpression[params.length=1]"(node) {

package/rules/constructor-super.cjs

@@ -110,6 +110,12 @@ var require_constructor_super = /* @__PURE__ */ require("../common/chunk.cjs").t
 				return segment.reachable && segInfoMap[segment.id].calledInEveryPaths;
 			}
 			return {
+				/**
+				* Stacks a constructor information.
+				* @param {CodePath} codePath A code path which was started.
+				* @param {ASTNode} node The current node.
+				* @returns {void}
+				*/
 				onCodePathStart(codePath, node) {
 					if (isConstructorFunction(node)) {
 						let superClass = node.parent.parent.parent.superClass;
@@ -130,6 +136,13 @@ var require_constructor_super = /* @__PURE__ */ require("../common/chunk.cjs").t
 						currentSegments: /* @__PURE__ */ new Set()
 					};
 				},
+				/**
+				* Pops a constructor information.
+				* And reports if `super()` lacked.
+				* @param {CodePath} codePath A code path which was ended.
+				* @param {ASTNode} node The current node.
+				* @returns {void}
+				*/
 				onCodePathEnd(codePath, node) {
 					let hasExtends = funcInfo.hasExtends;
 					if (funcInfo = funcInfo.upper, !hasExtends) return;
@@ -139,6 +152,12 @@ var require_constructor_super = /* @__PURE__ */ require("../common/chunk.cjs").t
 						node: node.parent
 					});
 				},
+				/**
+				* Initialize information of a given code path segment.
+				* @param {CodePathSegment} segment A code path segment to initialize.
+				* @param {CodePathSegment} node Node that starts the segment.
+				* @returns {void}
+				*/
 				onCodePathSegmentStart(segment, node) {
 					if (funcInfo.currentSegments.add(segment), !(funcInfo.isConstructor && funcInfo.hasExtends)) return;
 					let info = segInfoMap[segment.id] = new SegmentInfo(), seenPrevSegments = segment.prevSegments.filter(hasSegmentBeenSeen);
@@ -153,6 +172,15 @@ var require_constructor_super = /* @__PURE__ */ require("../common/chunk.cjs").t
 				onCodePathSegmentEnd(segment) {
 					funcInfo.currentSegments.delete(segment);
 				},
+				/**
+				* Update information of the code path segment when a code path was
+				* looped.
+				* @param {CodePathSegment} fromSegment The code path segment of the
+				*      end of a loop.
+				* @param {CodePathSegment} toSegment A code path segment of the head
+				*      of a loop.
+				* @returns {void}
+				*/
 				onCodePathSegmentLoop(fromSegment, toSegment) {
 					funcInfo.isConstructor && funcInfo.hasExtends && funcInfo.codePath.traverseSegments({
 						first: toSegment,
@@ -177,6 +205,11 @@ var require_constructor_super = /* @__PURE__ */ require("../common/chunk.cjs").t
 						}
 					});
 				},
+				/**
+				* Checks for a call of `super()`.
+				* @param {ASTNode} node A CallExpression node to check.
+				* @returns {void}
+				*/
 				"CallExpression:exit"(node) {
 					if (!(funcInfo.isConstructor && funcInfo.hasExtends) || node.callee.type !== "Super") return;
 					let segments = funcInfo.currentSegments, duplicate = !1, info = null;
@@ -189,6 +222,11 @@ var require_constructor_super = /* @__PURE__ */ require("../common/chunk.cjs").t
 						node
 					}));
 				},
+				/**
+				* Set the mark to the returned path as `super()` was called.
+				* @param {ASTNode} node A ReturnStatement node to check.
+				* @returns {void}
+				*/
 				ReturnStatement(node) {
 					if (!(funcInfo.isConstructor && funcInfo.hasExtends) || !node.argument) return;
 					let segments = funcInfo.currentSegments;

package/rules/function-paren-newline.cjs

@@ -140,7 +140,7 @@ var require_function_paren_newline = /* @__PURE__ */ require_chunk.t(((exports,
 						};
 					}
 					case "ArrowFunctionExpression": {
-						let firstToken = sourceCode.getFirstToken(node, { skip: node.async ? 1 : 0 });
+						let firstToken = sourceCode.getFirstToken(node, { skip: +!!node.async });
 						return astUtils.isOpeningParenToken(firstToken) ? {
 							leftParen: firstToken,
 							rightParen: node.params.length ? sourceCode.getTokenAfter(node.params.at(-1), astUtils.isClosingParenToken) : sourceCode.getTokenAfter(firstToken)

package/rules/indent.cjs

@@ -606,7 +606,7 @@ var require_indent = /* @__PURE__ */ require_chunk.t(((exports, module) => {
 					addElementListIndent(node.properties, openingCurly, closingCurly, options.ObjectExpression);
 				},
 				ArrowFunctionExpression(node) {
-					let maybeOpeningParen = sourceCode.getFirstToken(node, { skip: node.async ? 1 : 0 });
+					let maybeOpeningParen = sourceCode.getFirstToken(node, { skip: +!!node.async });
 					if (astUtils.isOpeningParenToken(maybeOpeningParen)) {
 						let openingParen = maybeOpeningParen, closingParen = sourceCode.getTokenBefore(node.body, astUtils.isClosingParenToken);
 						parameterParens.add(openingParen), parameterParens.add(closingParen), addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters);
@@ -634,7 +634,17 @@ var require_indent = /* @__PURE__ */ require_chunk.t(((exports, module) => {
 					let firstToken = sourceCode.getFirstToken(node);
 					if (!options.flatTernaryExpressions || !astUtils.isTokenOnSameLine(node.test, node.consequent) || isOnFirstLineOfStatement(firstToken, node)) {
 						let questionMarkToken = sourceCode.getFirstTokenBetween(node.test, node.consequent, (token) => token.type === "Punctuator" && token.value === "?"), colonToken = sourceCode.getFirstTokenBetween(node.consequent, node.alternate, (token) => token.type === "Punctuator" && token.value === ":"), firstConsequentToken = sourceCode.getTokenAfter(questionMarkToken), lastConsequentToken = sourceCode.getTokenBefore(colonToken), firstAlternateToken = sourceCode.getTokenAfter(colonToken);
-						offsets.setDesiredOffset(questionMarkToken, firstToken, 1), offsets.setDesiredOffset(colonToken, firstToken, 1), offsets.setDesiredOffset(firstConsequentToken, firstToken, firstConsequentToken.type === "Punctuator" && options.offsetTernaryExpressions ? 2 : 1), lastConsequentToken.loc.end.line === firstAlternateToken.loc.start.line ? offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0) : offsets.setDesiredOffset(firstAlternateToken, firstToken, firstAlternateToken.type === "Punctuator" && options.offsetTernaryExpressions ? 2 : 1);
+						offsets.setDesiredOffset(questionMarkToken, firstToken, 1), offsets.setDesiredOffset(colonToken, firstToken, 1), offsets.setDesiredOffset(firstConsequentToken, firstToken, firstConsequentToken.type === "Punctuator" && options.offsetTernaryExpressions ? 2 : 1), lastConsequentToken.loc.end.line === firstAlternateToken.loc.start.line ? offsets.setDesiredOffset(firstAlternateToken, firstConsequentToken, 0) : 
+						/**
+						* If the alternate and consequent do not share part of a line, offset the alternate from the first
+						* token of the conditional expression. For example:
+						* foo ? bar
+						*   : baz
+						*
+						* If `baz` were aligned with `bar` rather than being offset by 1 from `foo`, `baz` would end up
+						* having no expected indentation.
+						*/
+offsets.setDesiredOffset(firstAlternateToken, firstToken, firstAlternateToken.type === "Punctuator" && options.offsetTernaryExpressions ? 2 : 1);
 					}
 				},
 				"DoWhileStatement, WhileStatement, ForInStatement, ForOfStatement, WithStatement": (node) => addBlocklessNodeIndent(node.body),

package/rules/no-extra-boolean-cast.cjs

@@ -110,6 +110,7 @@ var require_no_extra_boolean_cast = /* @__PURE__ */ require_chunk.t(((exports, m
 						throw Error("Ternary child must be test, consequent, or alternate.");
 					case "UnaryExpression": return precedence(node) < precedence(parent);
 					case "LogicalExpression": return astUtils.isMixedLogicalAndCoalesceExpressions(node, parent) ? !0 : previousNode === parent.left ? precedence(node) < precedence(parent) : precedence(node) <= precedence(parent);
+					/* c8 ignore next */
 					default: throw Error(`Unexpected parent type: ${parent.type}`);
 				}
 			}

package/rules/no-extra-semi.cjs

@@ -74,6 +74,11 @@ var require_no_extra_semi = /* @__PURE__ */ require_chunk.t(((exports, module) =
 				for (let token = firstToken; token.type === "Punctuator" && !astUtils.isClosingBraceToken(token); token = sourceCode.getTokenAfter(token)) astUtils.isSemicolonToken(token) && report(token);
 			}
 			return {
+				/**
+				* Reports this empty statement, except if the parent node is a loop.
+				* @param {Node} node A EmptyStatement node to be reported.
+				* @returns {void}
+				*/
 				EmptyStatement(node) {
 					let parent = node.parent;
 					[
@@ -87,9 +92,19 @@ var require_no_extra_semi = /* @__PURE__ */ require_chunk.t(((exports, module) =
 						"WithStatement"
 					].includes(parent.type) || report(node);
 				},
+				/**
+				* Checks tokens from the head of this class body to the first MethodDefinition or the end of this class body.
+				* @param {Node} node A ClassBody node to check.
+				* @returns {void}
+				*/
 				ClassBody(node) {
 					checkForPartOfClassBody(sourceCode.getFirstToken(node, 1));
 				},
+				/**
+				* Checks tokens from this MethodDefinition to the next MethodDefinition or the end of this class body.
+				* @param {Node} node A MethodDefinition node of the start point.
+				* @returns {void}
+				*/
 				"MethodDefinition, PropertyDefinition, StaticBlock"(node) {
 					checkForPartOfClassBody(sourceCode.getTokenAfter(node));
 				}

package/rules/no-return-await.cjs

@@ -46,7 +46,7 @@ var require_no_return_await = /* @__PURE__ */ require_chunk.t(((exports, module)
 						fix(fixer) {
 							let sourceCode = context.sourceCode, [awaitToken, tokenAfterAwait] = sourceCode.getFirstTokens(node, 2);
 							if (awaitToken.loc.start.line !== tokenAfterAwait.loc.start.line) return null;
-							let [startOfAwait, endOfAwait] = awaitToken.range, range = [startOfAwait, endOfAwait + (sourceCode.text[endOfAwait] === " " ? 1 : 0)];
+							let [startOfAwait, endOfAwait] = awaitToken.range, range = [startOfAwait, endOfAwait + +(sourceCode.text[endOfAwait] === " ")];
 							return fixer.removeRange(range);
 						}
 					}]

package/rules/no-this-before-super.cjs

@@ -95,6 +95,12 @@ var require_no_this_before_super = /* @__PURE__ */ require_chunk.t(((exports, mo
 				for (let segment of segments) segment.reachable && (segInfoMap[segment.id].superCalled = !0);
 			}
 			return {
+				/**
+				* Adds information of a constructor into the stack.
+				* @param {CodePath} codePath A code path which was started.
+				* @param {ASTNode} node The current node.
+				* @returns {void}
+				*/
 				onCodePathStart(codePath, node) {
 					if (isConstructorFunction(node)) {
 						let classNode = node.parent.parent.parent;
@@ -113,6 +119,14 @@ var require_no_this_before_super = /* @__PURE__ */ require_chunk.t(((exports, mo
 						currentSegments: /* @__PURE__ */ new Set()
 					};
 				},
+				/**
+				* Removes the top of stack item.
+				*
+				* And this traverses all segments of this code path then reports every
+				* invalid node.
+				* @param {CodePath} codePath A code path which was ended.
+				* @returns {void}
+				*/
 				onCodePathEnd(codePath) {
 					let isDerivedClass = funcInfo.hasExtends;
 					if (funcInfo = funcInfo.upper, !isDerivedClass) return;
@@ -131,6 +145,11 @@ var require_no_this_before_super = /* @__PURE__ */ require_chunk.t(((exports, mo
 						info.superCalled && controller.skip();
 					});
 				},
+				/**
+				* Initialize information of a given code path segment.
+				* @param {CodePathSegment} segment A code path segment to initialize.
+				* @returns {void}
+				*/
 				onCodePathSegmentStart(segment) {
 					funcInfo.currentSegments.add(segment), isInConstructorOfDerivedClass() && (segInfoMap[segment.id] = {
 						superCalled: segment.prevSegments.length > 0 && segment.prevSegments.every(isCalled),
@@ -146,6 +165,15 @@ var require_no_this_before_super = /* @__PURE__ */ require_chunk.t(((exports, mo
 				onCodePathSegmentEnd(segment) {
 					funcInfo.currentSegments.delete(segment);
 				},
+				/**
+				* Update information of the code path segment when a code path was
+				* looped.
+				* @param {CodePathSegment} fromSegment The code path segment of the
+				*      end of a loop.
+				* @param {CodePathSegment} toSegment A code path segment of the head
+				*      of a loop.
+				* @returns {void}
+				*/
 				onCodePathSegmentLoop(fromSegment, toSegment) {
 					isInConstructorOfDerivedClass() && funcInfo.codePath.traverseSegments({
 						first: toSegment,
@@ -155,15 +183,34 @@ var require_no_this_before_super = /* @__PURE__ */ require_chunk.t(((exports, mo
 						info.superCalled ? controller.skip() : segment.prevSegments.length > 0 && segment.prevSegments.every(isCalled) && (info.superCalled = !0), segInfoMap[segment.id] = info;
 					});
 				},
+				/**
+				* Reports if this is before `super()`.
+				* @param {ASTNode} node A target node.
+				* @returns {void}
+				*/
 				ThisExpression(node) {
 					isBeforeCallOfSuper() && setInvalid(node);
 				},
+				/**
+				* Reports if this is before `super()`.
+				* @param {ASTNode} node A target node.
+				* @returns {void}
+				*/
 				Super(node) {
 					!astUtils.isCallee(node) && isBeforeCallOfSuper() && setInvalid(node);
 				},
+				/**
+				* Marks `super()` called.
+				* @param {ASTNode} node A target node.
+				* @returns {void}
+				*/
 				"CallExpression:exit"(node) {
 					node.callee.type === "Super" && isBeforeCallOfSuper() && setSuperCalled();
 				},
+				/**
+				* Resets state.
+				* @returns {void}
+				*/
 				"Program:exit"() {
 					segInfoMap = Object.create(null);
 				}

package/rules/no-unmodified-loop-condition.cjs

@@ -369,7 +369,7 @@ var require_ms = /* @__PURE__ */ require_chunk.t(((exports, module) => {
 			"GITHUB_ACTIONS",
 			"BUILDKITE"
 		].some((sign) => sign in env) || env.CI_NAME === "codeship" ? 1 : min;
-		if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+		if ("TEAMCITY_VERSION" in env) return +!!/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION);
 		if (env.COLORTERM === "truecolor") return 3;
 		if ("TERM_PROGRAM" in env) {
 			let version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);

package/rules/no-useless-assignment.cjs

@@ -127,8 +127,21 @@ var require_no_useless_assignment = /* @__PURE__ */ require_chunk.t(((exports, m
 					* and if additional iterations are needed, start iterating from the retained position.
 					*/
 					let subsequentSegmentData = {
+						/**
+						* Cache of subsequent segment information list that have already been iterated.
+						* @type {SubsequentSegmentData[]}
+						*/
 						results: [],
+						/**
+						* Subsequent segments that have already been iterated on. Used to avoid infinite loops.
+						* @type {Set<CodePathSegment>}
+						*/
 						subsequentSegments: /* @__PURE__ */ new Set(),
+						/**
+						* Unexplored code path segment.
+						* If additional iterations are needed, consume this information and iterate.
+						* @type {CodePathSegment[]}
+						*/
 						queueSegments: targetAssignment.segments.flatMap((segment) => segment.nextSegments)
 					};
 					/**

package/rules/no-useless-computed-key.cjs

@@ -41,6 +41,7 @@ var require_no_useless_computed_key = /* @__PURE__ */ require_chunk.t(((exports,
 			case "Property": return node.parent.type === "ObjectExpression" ? value !== "__proto__" : !0;
 			case "PropertyDefinition": return node.static ? value !== "constructor" && value !== "prototype" : value !== "constructor";
 			case "MethodDefinition": return node.static ? value !== "prototype" : value !== "constructor";
+			/* c8 ignore next */
 			default: throw Error(`Unexpected node type: ${node.type}`);
 		}
 	}

package/rules/no-whitespace-before-property.cjs

@@ -61,7 +61,7 @@ var require_no_whitespace_before_property = /* @__PURE__ */ require_chunk.t(((ex
 			}
 			return { MemberExpression(node) {
 				let rightToken, leftToken;
-				astUtils.isTokenOnSameLine(node.object, node.property) && (node.computed ? (rightToken = sourceCode.getTokenBefore(node.property, astUtils.isOpeningBracketToken), leftToken = sourceCode.getTokenBefore(rightToken, node.optional ? 1 : 0)) : (rightToken = sourceCode.getFirstToken(node.property), leftToken = sourceCode.getTokenBefore(rightToken, 1)), sourceCode.isSpaceBetweenTokens(leftToken, rightToken) && reportError(node, leftToken, rightToken));
+				astUtils.isTokenOnSameLine(node.object, node.property) && (node.computed ? (rightToken = sourceCode.getTokenBefore(node.property, astUtils.isOpeningBracketToken), leftToken = sourceCode.getTokenBefore(rightToken, +!!node.optional)) : (rightToken = sourceCode.getFirstToken(node.property), leftToken = sourceCode.getTokenBefore(rightToken, 1)), sourceCode.isSpaceBetweenTokens(leftToken, rightToken) && reportError(node, leftToken, rightToken));
 			} };
 		}
 	};

package/rules/object-shorthand.cjs

@@ -162,7 +162,7 @@ var require_object_shorthand = /* @__PURE__ */ require_chunk.t(((exports, module
 					let functionToken = sourceCode.getTokens(node.value).find((token) => token.type === "Keyword" && token.value === "function"), tokenBeforeParams = node.value.generator ? sourceCode.getTokenAfter(functionToken) : functionToken;
 					return fixer.replaceTextRange(fixRange, methodPrefix + sourceCode.text.slice(tokenBeforeParams.range[1], node.value.range[1]));
 				}
-				let arrowToken = sourceCode.getTokenBefore(node.value.body, astUtils.isArrowToken), fnBody = sourceCode.text.slice(arrowToken.range[1], node.value.range[1]), sliceStart = sourceCode.getFirstToken(node.value, { skip: node.value.async ? 1 : 0 }).range[0], sliceEnd = sourceCode.getTokenBefore(arrowToken).range[1], shouldAddParens = node.value.params.length === 1 && node.value.params[0].range[0] === sliceStart, oldParamText = sourceCode.text.slice(sliceStart, sliceEnd), newParamText = shouldAddParens ? `(${oldParamText})` : oldParamText;
+				let arrowToken = sourceCode.getTokenBefore(node.value.body, astUtils.isArrowToken), fnBody = sourceCode.text.slice(arrowToken.range[1], node.value.range[1]), sliceStart = sourceCode.getFirstToken(node.value, { skip: +!!node.value.async }).range[0], sliceEnd = sourceCode.getTokenBefore(arrowToken).range[1], shouldAddParens = node.value.params.length === 1 && node.value.params[0].range[0] === sliceStart, oldParamText = sourceCode.text.slice(sliceStart, sliceEnd), newParamText = shouldAddParens ? `(${oldParamText})` : oldParamText;
 				return fixer.replaceTextRange(fixRange, methodPrefix + newParamText + fnBody);
 			}
 			/**

package/rules/padded-blocks.cjs

@@ -123,6 +123,7 @@ var require_padded_blocks = /* @__PURE__ */ require_chunk.t(((exports, module) =
 					case "StaticBlock": return options.blocks;
 					case "SwitchStatement": return options.switches;
 					case "ClassBody": return options.classes;
+					/* c8 ignore next */
 					default: throw Error("unreachable");
 				}
 			}

package/rules/padding-line-between-statements.cjs

@@ -148,6 +148,26 @@ var require_padding_line_between_statements = /* @__PURE__ */ require_chunk.t(((
 			fix(fixer) {
 				let sourceCode = context.sourceCode, prevToken = getActualLastToken(sourceCode, prevNode), nextToken = sourceCode.getFirstTokenBetween(prevToken, nextNode, {
 					includeComments: !0,
+					/**
+					* Skip the trailing comments of the previous node.
+					* This inserts a blank line after the last trailing comment.
+					*
+					* For example:
+					*
+					*     foo(); // trailing comment.
+					*     // comment.
+					*     bar();
+					*
+					* Get fixed to:
+					*
+					*     foo(); // trailing comment.
+					*
+					*     // comment.
+					*     bar();
+					* @param {Token} token The token to check.
+					* @returns {boolean} `true` if the token is not a trailing comment.
+					* @private
+					*/
 					filter(token) {
 						return astUtils.isTokenOnSameLine(prevToken, token) ? (prevToken = token, !1) : !0;
 					}

package/rules/prefer-arrow-callback.cjs

@@ -168,7 +168,7 @@ var require_prefer_arrow_callback = /* @__PURE__ */ require_chunk.t(((exports, m
 								if (astUtils.isParenthesised(sourceCode, memberNode) || sourceCode.commentsExistBetween(firstTokenToRemove, lastTokenToRemove)) return;
 								yield fixer.removeRange([firstTokenToRemove.range[0], lastTokenToRemove.range[1]]);
 							}
-							let functionToken = sourceCode.getFirstToken(node, node.async ? 1 : 0), leftParenToken = sourceCode.getTokenAfter(functionToken, astUtils.isOpeningParenToken), tokenBeforeBody = sourceCode.getTokenBefore(node.body);
+							let functionToken = sourceCode.getFirstToken(node, +!!node.async), leftParenToken = sourceCode.getTokenAfter(functionToken, astUtils.isOpeningParenToken), tokenBeforeBody = sourceCode.getTokenBefore(node.body);
 							sourceCode.commentsExistBetween(functionToken, leftParenToken) ? (yield fixer.remove(functionToken), node.id && (yield fixer.remove(node.id))) : yield fixer.removeRange([functionToken.range[0], leftParenToken.range[0]]), yield fixer.insertTextAfter(tokenBeforeBody, " =>");
 							let replacedNode = callbackInfo.isLexicalThis ? node.parent.parent : node;
 							replacedNode.type === "ChainExpression" && (replacedNode = replacedNode.parent), replacedNode.parent.type !== "CallExpression" && replacedNode.parent.type !== "ConditionalExpression" && !astUtils.isParenthesised(sourceCode, replacedNode) && !astUtils.isParenthesised(sourceCode, node) && (yield fixer.insertTextBefore(replacedNode, "("), yield fixer.insertTextAfter(replacedNode, ")"));