oxlint-plugin-eslint 1.61.0 → 1.62.0

package/common/ast-utils.cjs

@@ -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/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/package.json

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

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/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-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-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/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;
 					}