oxlint-plugin-eslint 1.52.0

package/rules/lines-around-comment.cjs

@@ -0,0 +1,290 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/lines-around-comment.js
+/**
+* @fileoverview Enforces empty lines around comments.
+* @author Jamund Ferguson
+* @deprecated in ESLint v8.53.0
+*/
+var require_lines_around_comment = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Return an array with any line numbers that are empty.
+	* @param {Array} lines An array of each line of the file.
+	* @returns {Array} An array of line numbers.
+	*/
+	function getEmptyLineNums(lines) {
+		return lines.map((line, i) => ({
+			code: line.trim(),
+			num: i + 1
+		})).filter((line) => !line.code).map((line) => line.num);
+	}
+	/**
+	* Return an array with any line numbers that contain comments.
+	* @param {Array} comments An array of comment tokens.
+	* @returns {Array} An array of line numbers.
+	*/
+	function getCommentLineNums(comments) {
+		let lines = [];
+		return comments.forEach((token) => {
+			let start = token.loc.start.line, end = token.loc.end.line;
+			lines.push(start, end);
+		}), lines;
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "lines-around-comment",
+						url: "https://eslint.style/rules/lines-around-comment"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require empty lines around comments",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/lines-around-comment"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					beforeBlockComment: {
+						type: "boolean",
+						default: !0
+					},
+					afterBlockComment: {
+						type: "boolean",
+						default: !1
+					},
+					beforeLineComment: {
+						type: "boolean",
+						default: !1
+					},
+					afterLineComment: {
+						type: "boolean",
+						default: !1
+					},
+					allowBlockStart: {
+						type: "boolean",
+						default: !1
+					},
+					allowBlockEnd: {
+						type: "boolean",
+						default: !1
+					},
+					allowClassStart: { type: "boolean" },
+					allowClassEnd: { type: "boolean" },
+					allowObjectStart: { type: "boolean" },
+					allowObjectEnd: { type: "boolean" },
+					allowArrayStart: { type: "boolean" },
+					allowArrayEnd: { type: "boolean" },
+					ignorePattern: { type: "string" },
+					applyDefaultIgnorePatterns: { type: "boolean" },
+					afterHashbangComment: {
+						type: "boolean",
+						default: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				after: "Expected line after comment.",
+				before: "Expected line before comment."
+			}
+		},
+		create(context) {
+			let options = Object.assign({}, context.options[0]), ignorePattern = options.ignorePattern, defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN, customIgnoreRegExp = new RegExp(ignorePattern, "u"), applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns !== !1;
+			options.beforeBlockComment = options.beforeBlockComment === void 0 ? !0 : options.beforeBlockComment;
+			let sourceCode = context.sourceCode, lines = sourceCode.lines, numLines = lines.length + 1, comments = sourceCode.getAllComments(), commentLines = getCommentLineNums(comments), emptyLines = getEmptyLineNums(lines), commentAndEmptyLines = new Set(commentLines.concat(emptyLines));
+			/**
+			* Returns whether or not comments are on lines starting with or ending with code
+			* @param {token} token The comment token to check.
+			* @returns {boolean} True if the comment is not alone.
+			*/
+			function codeAroundComment(token) {
+				let currentToken = token;
+				do
+					currentToken = sourceCode.getTokenBefore(currentToken, { includeComments: !0 });
+				while (currentToken && astUtils.isCommentToken(currentToken));
+				if (currentToken && astUtils.isTokenOnSameLine(currentToken, token)) return !0;
+				currentToken = token;
+				do
+					currentToken = sourceCode.getTokenAfter(currentToken, { includeComments: !0 });
+				while (currentToken && astUtils.isCommentToken(currentToken));
+				return !!(currentToken && astUtils.isTokenOnSameLine(token, currentToken));
+			}
+			/**
+			* Returns whether or not comments are inside a node type or not.
+			* @param {ASTNode} parent The Comment parent node.
+			* @param {string} nodeType The parent type to check against.
+			* @returns {boolean} True if the comment is inside nodeType.
+			*/
+			function isParentNodeType(parent, nodeType) {
+				return parent.type === nodeType || parent.body && parent.body.type === nodeType || parent.consequent && parent.consequent.type === nodeType;
+			}
+			/**
+			* Returns the parent node that contains the given token.
+			* @param {token} token The token to check.
+			* @returns {ASTNode|null} The parent node that contains the given token.
+			*/
+			function getParentNodeOfToken(token) {
+				let node = sourceCode.getNodeByRangeIndex(token.range[0]);
+				if (node && node.type === "StaticBlock") {
+					let openingBrace = sourceCode.getFirstToken(node, { skip: 1 });
+					return token.range[0] >= openingBrace.range[0] ? node : null;
+				}
+				return node;
+			}
+			/**
+			* Returns whether or not comments are at the parent start or not.
+			* @param {token} token The Comment token.
+			* @param {string} nodeType The parent type to check against.
+			* @returns {boolean} True if the comment is at parent start.
+			*/
+			function isCommentAtParentStart(token, nodeType) {
+				let parent = getParentNodeOfToken(token);
+				if (parent && isParentNodeType(parent, nodeType)) {
+					let parentStartNodeOrToken = parent;
+					return parent.type === "StaticBlock" ? parentStartNodeOrToken = sourceCode.getFirstToken(parent, { skip: 1 }) : parent.type === "SwitchStatement" && (parentStartNodeOrToken = sourceCode.getTokenAfter(parent.discriminant, { filter: astUtils.isOpeningBraceToken })), token.loc.start.line - parentStartNodeOrToken.loc.start.line === 1;
+				}
+				return !1;
+			}
+			/**
+			* Returns whether or not comments are at the parent end or not.
+			* @param {token} token The Comment token.
+			* @param {string} nodeType The parent type to check against.
+			* @returns {boolean} True if the comment is at parent end.
+			*/
+			function isCommentAtParentEnd(token, nodeType) {
+				let parent = getParentNodeOfToken(token);
+				return !!parent && isParentNodeType(parent, nodeType) && parent.loc.end.line - token.loc.end.line === 1;
+			}
+			/**
+			* Returns whether or not comments are at the block start or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at block start.
+			*/
+			function isCommentAtBlockStart(token) {
+				return isCommentAtParentStart(token, "ClassBody") || isCommentAtParentStart(token, "BlockStatement") || isCommentAtParentStart(token, "StaticBlock") || isCommentAtParentStart(token, "SwitchCase") || isCommentAtParentStart(token, "SwitchStatement");
+			}
+			/**
+			* Returns whether or not comments are at the block end or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at block end.
+			*/
+			function isCommentAtBlockEnd(token) {
+				return isCommentAtParentEnd(token, "ClassBody") || isCommentAtParentEnd(token, "BlockStatement") || isCommentAtParentEnd(token, "StaticBlock") || isCommentAtParentEnd(token, "SwitchCase") || isCommentAtParentEnd(token, "SwitchStatement");
+			}
+			/**
+			* Returns whether or not comments are at the class start or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at class start.
+			*/
+			function isCommentAtClassStart(token) {
+				return isCommentAtParentStart(token, "ClassBody");
+			}
+			/**
+			* Returns whether or not comments are at the class end or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at class end.
+			*/
+			function isCommentAtClassEnd(token) {
+				return isCommentAtParentEnd(token, "ClassBody");
+			}
+			/**
+			* Returns whether or not comments are at the object start or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at object start.
+			*/
+			function isCommentAtObjectStart(token) {
+				return isCommentAtParentStart(token, "ObjectExpression") || isCommentAtParentStart(token, "ObjectPattern");
+			}
+			/**
+			* Returns whether or not comments are at the object end or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at object end.
+			*/
+			function isCommentAtObjectEnd(token) {
+				return isCommentAtParentEnd(token, "ObjectExpression") || isCommentAtParentEnd(token, "ObjectPattern");
+			}
+			/**
+			* Returns whether or not comments are at the array start or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at array start.
+			*/
+			function isCommentAtArrayStart(token) {
+				return isCommentAtParentStart(token, "ArrayExpression") || isCommentAtParentStart(token, "ArrayPattern");
+			}
+			/**
+			* Returns whether or not comments are at the array end or not.
+			* @param {token} token The Comment token.
+			* @returns {boolean} True if the comment is at array end.
+			*/
+			function isCommentAtArrayEnd(token) {
+				return isCommentAtParentEnd(token, "ArrayExpression") || isCommentAtParentEnd(token, "ArrayPattern");
+			}
+			/**
+			* Checks if a comment token has lines around it (ignores inline comments)
+			* @param {token} token The Comment token.
+			* @param {Object} opts Options to determine the newline.
+			* @param {boolean} opts.after Should have a newline after this line.
+			* @param {boolean} opts.before Should have a newline before this line.
+			* @returns {void}
+			*/
+			function checkForEmptyLine(token, opts) {
+				if (applyDefaultIgnorePatterns && defaultIgnoreRegExp.test(token.value) || ignorePattern && customIgnoreRegExp.test(token.value)) return;
+				let after = opts.after, before = opts.before, prevLineNum = token.loc.start.line - 1, nextLineNum = token.loc.end.line + 1, commentIsNotAlone = codeAroundComment(token), blockStartAllowed = options.allowBlockStart && isCommentAtBlockStart(token) && !(options.allowClassStart === !1 && isCommentAtClassStart(token)), blockEndAllowed = options.allowBlockEnd && isCommentAtBlockEnd(token) && !(options.allowClassEnd === !1 && isCommentAtClassEnd(token)), classStartAllowed = options.allowClassStart && isCommentAtClassStart(token), classEndAllowed = options.allowClassEnd && isCommentAtClassEnd(token), objectStartAllowed = options.allowObjectStart && isCommentAtObjectStart(token), objectEndAllowed = options.allowObjectEnd && isCommentAtObjectEnd(token), arrayStartAllowed = options.allowArrayStart && isCommentAtArrayStart(token), arrayEndAllowed = options.allowArrayEnd && isCommentAtArrayEnd(token), exceptionStartAllowed = blockStartAllowed || classStartAllowed || objectStartAllowed || arrayStartAllowed, exceptionEndAllowed = blockEndAllowed || classEndAllowed || objectEndAllowed || arrayEndAllowed;
+				if (prevLineNum < 1 && (before = !1), nextLineNum >= numLines && (after = !1), commentIsNotAlone) return;
+				let previousTokenOrComment = sourceCode.getTokenBefore(token, { includeComments: !0 }), nextTokenOrComment = sourceCode.getTokenAfter(token, { includeComments: !0 });
+				if (!exceptionStartAllowed && before && !commentAndEmptyLines.has(prevLineNum) && !(astUtils.isCommentToken(previousTokenOrComment) && astUtils.isTokenOnSameLine(previousTokenOrComment, token))) {
+					let lineStart = token.range[0] - token.loc.start.column, range = [lineStart, lineStart];
+					context.report({
+						node: token,
+						messageId: "before",
+						fix(fixer) {
+							return fixer.insertTextBeforeRange(range, "\n");
+						}
+					});
+				}
+				!exceptionEndAllowed && after && !commentAndEmptyLines.has(nextLineNum) && !(astUtils.isCommentToken(nextTokenOrComment) && astUtils.isTokenOnSameLine(token, nextTokenOrComment)) && context.report({
+					node: token,
+					messageId: "after",
+					fix(fixer) {
+						return fixer.insertTextAfter(token, "\n");
+					}
+				});
+			}
+			return { Program() {
+				comments.forEach((token) => {
+					token.type === "Line" ? (options.beforeLineComment || options.afterLineComment) && checkForEmptyLine(token, {
+						after: options.afterLineComment,
+						before: options.beforeLineComment
+					}) : token.type === "Block" ? (options.beforeBlockComment || options.afterBlockComment) && checkForEmptyLine(token, {
+						after: options.afterBlockComment,
+						before: options.beforeBlockComment
+					}) : token.type === "Shebang" && options.afterHashbangComment && checkForEmptyLine(token, {
+						after: options.afterHashbangComment,
+						before: !1
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/lines-around-comment.cjs
+module.exports = require_lines_around_comment().create;
+//#endregion

package/rules/lines-around-directive.cjs

@@ -0,0 +1,129 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/lines-around-directive.js
+/**
+* @fileoverview Require or disallow newlines around directives.
+* @author Kai Cataldo
+* @deprecated in ESLint v4.0.0
+*/
+var require_lines_around_directive = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "layout",
+			docs: {
+				description: "Require or disallow newlines around directives",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/lines-around-directive"
+			},
+			schema: [{ oneOf: [{ enum: ["always", "never"] }, {
+				type: "object",
+				properties: {
+					before: { enum: ["always", "never"] },
+					after: { enum: ["always", "never"] }
+				},
+				additionalProperties: !1,
+				minProperties: 2
+			}] }],
+			fixable: "whitespace",
+			messages: {
+				expected: "Expected newline {{location}} \"{{value}}\" directive.",
+				unexpected: "Unexpected newline {{location}} \"{{value}}\" directive."
+			},
+			deprecated: {
+				message: "The rule was replaced with a more general rule.",
+				url: "https://eslint.org/blog/2017/06/eslint-v4.0.0-released/",
+				deprecatedSince: "4.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "The new rule moved to a plugin.",
+					url: "https://eslint.org/docs/latest/rules/padding-line-between-statements#examples",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "padding-line-between-statements",
+						url: "https://eslint.style/rules/padding-line-between-statements"
+					}
+				}]
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, config = context.options[0] || "always", expectLineBefore = typeof config == "string" ? config : config.before, expectLineAfter = typeof config == "string" ? config : config.after;
+			/**
+			* Check if node is preceded by a blank newline.
+			* @param {ASTNode} node Node to check.
+			* @returns {boolean} Whether or not the passed in node is preceded by a blank newline.
+			*/
+			function hasNewlineBefore(node) {
+				let tokenBefore = sourceCode.getTokenBefore(node, { includeComments: !0 }), tokenLineBefore = tokenBefore ? tokenBefore.loc.end.line : 0;
+				return node.loc.start.line - tokenLineBefore >= 2;
+			}
+			/**
+			* Gets the last token of a node that is on the same line as the rest of the node.
+			* This will usually be the last token of the node, but it will be the second-to-last token if the node has a trailing
+			* semicolon on a different line.
+			* @param {ASTNode} node A directive node
+			* @returns {Token} The last token of the node on the line
+			*/
+			function getLastTokenOnLine(node) {
+				let lastToken = sourceCode.getLastToken(node), secondToLastToken = sourceCode.getTokenBefore(lastToken);
+				return astUtils.isSemicolonToken(lastToken) && lastToken.loc.start.line > secondToLastToken.loc.end.line ? secondToLastToken : lastToken;
+			}
+			/**
+			* Check if node is followed by a blank newline.
+			* @param {ASTNode} node Node to check.
+			* @returns {boolean} Whether or not the passed in node is followed by a blank newline.
+			*/
+			function hasNewlineAfter(node) {
+				let lastToken = getLastTokenOnLine(node);
+				return sourceCode.getTokenAfter(lastToken, { includeComments: !0 }).loc.start.line - lastToken.loc.end.line >= 2;
+			}
+			/**
+			* Report errors for newlines around directives.
+			* @param {ASTNode} node Node to check.
+			* @param {string} location Whether the error was found before or after the directive.
+			* @param {boolean} expected Whether or not a newline was expected or unexpected.
+			* @returns {void}
+			*/
+			function reportError(node, location, expected) {
+				context.report({
+					node,
+					messageId: expected ? "expected" : "unexpected",
+					data: {
+						value: node.expression.value,
+						location
+					},
+					fix(fixer) {
+						let lastToken = getLastTokenOnLine(node);
+						return expected ? location === "before" ? fixer.insertTextBefore(node, "\n") : fixer.insertTextAfter(lastToken, "\n") : fixer.removeRange(location === "before" ? [node.range[0] - 1, node.range[0]] : [lastToken.range[1], lastToken.range[1] + 1]);
+					}
+				});
+			}
+			/**
+			* Check lines around directives in node
+			* @param {ASTNode} node node to check
+			* @returns {void}
+			*/
+			function checkDirectives(node) {
+				let directives = astUtils.getDirectivePrologue(node);
+				if (!directives.length) return;
+				let firstDirective = directives[0], leadingComments = sourceCode.getCommentsBefore(firstDirective);
+				leadingComments.length ? (expectLineBefore === "always" && !hasNewlineBefore(firstDirective) && reportError(firstDirective, "before", !0), expectLineBefore === "never" && hasNewlineBefore(firstDirective) && reportError(firstDirective, "before", !1)) : node.type === "Program" && expectLineBefore === "never" && !leadingComments.length && hasNewlineBefore(firstDirective) && reportError(firstDirective, "before", !1);
+				let lastDirective = directives.at(-1);
+				lastDirective === (node.type === "Program" ? node.body : node.body.body).at(-1) && !lastDirective.trailingComments || (expectLineAfter === "always" && !hasNewlineAfter(lastDirective) && reportError(lastDirective, "after", !0), expectLineAfter === "never" && hasNewlineAfter(lastDirective) && reportError(lastDirective, "after", !1));
+			}
+			return {
+				Program: checkDirectives,
+				FunctionDeclaration: checkDirectives,
+				FunctionExpression: checkDirectives,
+				ArrowFunctionExpression: checkDirectives
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/lines-around-directive.cjs
+module.exports = require_lines_around_directive().create;
+//#endregion

package/rules/lines-between-class-members.cjs

@@ -0,0 +1,212 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/lines-between-class-members.js
+/**
+* @fileoverview Rule to check empty newline between class members
+* @author 薛定谔的猫<hh_2013@foxmail.com>
+* @deprecated in ESLint v8.53.0
+*/
+var require_lines_between_class_members = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), ClassMemberTypes = {
+		"*": { test: () => !0 },
+		field: { test: (node) => node.type === "PropertyDefinition" },
+		method: { test: (node) => node.type === "MethodDefinition" }
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "lines-between-class-members",
+						url: "https://eslint.style/rules/lines-between-class-members"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require or disallow an empty line between class members",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/lines-between-class-members"
+			},
+			fixable: "whitespace",
+			schema: [{ anyOf: [{
+				type: "object",
+				properties: { enforce: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							blankLine: { enum: ["always", "never"] },
+							prev: { enum: [
+								"method",
+								"field",
+								"*"
+							] },
+							next: { enum: [
+								"method",
+								"field",
+								"*"
+							] }
+						},
+						additionalProperties: !1,
+						required: [
+							"blankLine",
+							"prev",
+							"next"
+						]
+					},
+					minItems: 1
+				} },
+				additionalProperties: !1,
+				required: ["enforce"]
+			}, { enum: ["always", "never"] }] }, {
+				type: "object",
+				properties: { exceptAfterSingleLine: {
+					type: "boolean",
+					default: !1
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				never: "Unexpected blank line between class members.",
+				always: "Expected blank line between class members."
+			}
+		},
+		create(context) {
+			let options = [];
+			options[0] = context.options[0] || "always", options[1] = context.options[1] || { exceptAfterSingleLine: !1 };
+			let configureList = typeof options[0] == "object" ? options[0].enforce : [{
+				blankLine: options[0],
+				prev: "*",
+				next: "*"
+			}], sourceCode = context.sourceCode;
+			/**
+			* Gets a pair of tokens that should be used to check lines between two class member nodes.
+			*
+			* In most cases, this returns the very last token of the current node and
+			* the very first token of the next node.
+			* For example:
+			*
+			*     class C {
+			*         x = 1;   // curLast: `;` nextFirst: `in`
+			*         in = 2
+			*     }
+			*
+			* There is only one exception. If the given node ends with a semicolon, and it looks like
+			* a semicolon-less style's semicolon - one that is not on the same line as the preceding
+			* token, but is on the line where the next class member starts - this returns the preceding
+			* token and the semicolon as boundary tokens.
+			* For example:
+			*
+			*     class C {
+			*         x = 1    // curLast: `1` nextFirst: `;`
+			*         ;in = 2
+			*     }
+			* When determining the desired layout of the code, we should treat this semicolon as
+			* a part of the next class member node instead of the one it technically belongs to.
+			* @param {ASTNode} curNode Current class member node.
+			* @param {ASTNode} nextNode Next class member node.
+			* @returns {Token} The actual last token of `node`.
+			* @private
+			*/
+			function getBoundaryTokens(curNode, nextNode) {
+				let lastToken = sourceCode.getLastToken(curNode), prevToken = sourceCode.getTokenBefore(lastToken), nextToken = sourceCode.getFirstToken(nextNode);
+				return astUtils.isSemicolonToken(lastToken) && !astUtils.isTokenOnSameLine(prevToken, lastToken) && astUtils.isTokenOnSameLine(lastToken, nextToken) ? {
+					curLast: prevToken,
+					nextFirst: lastToken
+				} : {
+					curLast: lastToken,
+					nextFirst: nextToken
+				};
+			}
+			/**
+			* Return the last token among the consecutive tokens that have no exceed max line difference in between, before the first token in the next member.
+			* @param {Token} prevLastToken The last token in the previous member node.
+			* @param {Token} nextFirstToken The first token in the next member node.
+			* @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
+			* @returns {Token} The last token among the consecutive tokens.
+			*/
+			function findLastConsecutiveTokenAfter(prevLastToken, nextFirstToken, maxLine) {
+				let after = sourceCode.getTokenAfter(prevLastToken, { includeComments: !0 });
+				return after !== nextFirstToken && after.loc.start.line - prevLastToken.loc.end.line <= maxLine ? findLastConsecutiveTokenAfter(after, nextFirstToken, maxLine) : prevLastToken;
+			}
+			/**
+			* Return the first token among the consecutive tokens that have no exceed max line difference in between, after the last token in the previous member.
+			* @param {Token} nextFirstToken The first token in the next member node.
+			* @param {Token} prevLastToken The last token in the previous member node.
+			* @param {number} maxLine The maximum number of allowed line difference between consecutive tokens.
+			* @returns {Token} The first token among the consecutive tokens.
+			*/
+			function findFirstConsecutiveTokenBefore(nextFirstToken, prevLastToken, maxLine) {
+				let before = sourceCode.getTokenBefore(nextFirstToken, { includeComments: !0 });
+				return before !== prevLastToken && nextFirstToken.loc.start.line - before.loc.end.line <= maxLine ? findFirstConsecutiveTokenBefore(before, prevLastToken, maxLine) : nextFirstToken;
+			}
+			/**
+			* Checks if there is a token or comment between two tokens.
+			* @param {Token} before The token before.
+			* @param {Token} after The token after.
+			* @returns {boolean} True if there is a token or comment between two tokens.
+			*/
+			function hasTokenOrCommentBetween(before, after) {
+				return sourceCode.getTokensBetween(before, after, { includeComments: !0 }).length !== 0;
+			}
+			/**
+			* Checks whether the given node matches the given type.
+			* @param {ASTNode} node The class member node to check.
+			* @param {string} type The class member type to check.
+			* @returns {boolean} `true` if the class member node matched the type.
+			* @private
+			*/
+			function match(node, type) {
+				return ClassMemberTypes[type].test(node);
+			}
+			/**
+			* Finds the last matched configuration from the configureList.
+			* @param {ASTNode} prevNode The previous node to match.
+			* @param {ASTNode} nextNode The current node to match.
+			* @returns {string|null} Padding type or `null` if no matches were found.
+			* @private
+			*/
+			function getPaddingType(prevNode, nextNode) {
+				for (let i = configureList.length - 1; i >= 0; --i) {
+					let configure = configureList[i];
+					if (match(prevNode, configure.prev) && match(nextNode, configure.next)) return configure.blankLine;
+				}
+				return null;
+			}
+			return { ClassBody(node) {
+				let body = node.body;
+				for (let i = 0; i < body.length - 1; i++) {
+					let curFirst = sourceCode.getFirstToken(body[i]), { curLast, nextFirst } = getBoundaryTokens(body[i], body[i + 1]), skip = !!astUtils.isTokenOnSameLine(curFirst, curLast) && options[1].exceptAfterSingleLine, beforePadding = findLastConsecutiveTokenAfter(curLast, nextFirst, 1), afterPadding = findFirstConsecutiveTokenBefore(nextFirst, curLast, 1), isPadded = afterPadding.loc.start.line - beforePadding.loc.end.line > 1, hasTokenInPadding = hasTokenOrCommentBetween(beforePadding, afterPadding), curLineLastToken = findLastConsecutiveTokenAfter(curLast, nextFirst, 0), paddingType = getPaddingType(body[i], body[i + 1]);
+					paddingType === "never" && isPadded ? context.report({
+						node: body[i + 1],
+						messageId: "never",
+						fix(fixer) {
+							return hasTokenInPadding ? null : fixer.replaceTextRange([beforePadding.range[1], afterPadding.range[0]], "\n");
+						}
+					}) : paddingType === "always" && !skip && !isPadded && context.report({
+						node: body[i + 1],
+						messageId: "always",
+						fix(fixer) {
+							return hasTokenInPadding ? null : fixer.insertTextAfter(curLineLastToken, "\n");
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/lines-between-class-members.cjs
+module.exports = require_lines_between_class_members().create;
+//#endregion