oxlint-plugin-eslint 1.52.0

package/rules/keyword-spacing.cjs

@@ -0,0 +1,464 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_keywords$1 = require("../common/keywords.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/keyword-spacing.js
+/**
+* @fileoverview Rule to enforce spacing before and after keywords.
+* @author Toru Nagashima
+* @deprecated in ESLint v8.53.0
+*/
+var require_keyword_spacing = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), keywords = require_keywords$1.t(), PREV_TOKEN = /^[)\]}>]$/u, NEXT_TOKEN = /^(?:[([{<~!]|\+\+?|--?)$/u, PREV_TOKEN_M = /^[)\]}>*]$/u, NEXT_TOKEN_M = /^[{*]$/u, TEMPLATE_OPEN_PAREN = /\$\{$/u, TEMPLATE_CLOSE_PAREN = /^\}/u, CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template|PrivateIdentifier)$/u, KEYS = keywords.concat([
+		"as",
+		"async",
+		"await",
+		"from",
+		"get",
+		"let",
+		"of",
+		"set",
+		"yield"
+	]);
+	(function() {
+		KEYS.sort();
+		for (let i = 1; i < KEYS.length; ++i) if (KEYS[i] === KEYS[i - 1]) throw Error(`Duplication was found in the keyword list: ${KEYS[i]}`);
+	})();
+	/**
+	* Checks whether or not a given token is a "Template" token ends with "${".
+	* @param {Token} token A token to check.
+	* @returns {boolean} `true` if the token is a "Template" token ends with "${".
+	*/
+	function isOpenParenOfTemplate(token) {
+		return token.type === "Template" && TEMPLATE_OPEN_PAREN.test(token.value);
+	}
+	/**
+	* Checks whether or not a given token is a "Template" token starts with "}".
+	* @param {Token} token A token to check.
+	* @returns {boolean} `true` if the token is a "Template" token starts with "}".
+	*/
+	function isCloseParenOfTemplate(token) {
+		return token.type === "Template" && TEMPLATE_CLOSE_PAREN.test(token.value);
+	}
+	/** @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: "keyword-spacing",
+						url: "https://eslint.style/rules/keyword-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing before and after keywords",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/keyword-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					before: {
+						type: "boolean",
+						default: !0
+					},
+					after: {
+						type: "boolean",
+						default: !0
+					},
+					overrides: {
+						type: "object",
+						properties: KEYS.reduce((retv, key) => (retv[key] = {
+							type: "object",
+							properties: {
+								before: { type: "boolean" },
+								after: { type: "boolean" }
+							},
+							additionalProperties: !1
+						}, retv), {}),
+						additionalProperties: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				expectedBefore: "Expected space(s) before \"{{value}}\".",
+				expectedAfter: "Expected space(s) after \"{{value}}\".",
+				unexpectedBefore: "Unexpected space(s) before \"{{value}}\".",
+				unexpectedAfter: "Unexpected space(s) after \"{{value}}\"."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, tokensToIgnore = /* @__PURE__ */ new WeakSet();
+			/**
+			* Reports a given token if there are not space(s) before the token.
+			* @param {Token} token A token to report.
+			* @param {RegExp} pattern A pattern of the previous token to check.
+			* @returns {void}
+			*/
+			function expectSpaceBefore(token, pattern) {
+				let prevToken = sourceCode.getTokenBefore(token);
+				prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && astUtils.isTokenOnSameLine(prevToken, token) && !sourceCode.isSpaceBetweenTokens(prevToken, token) && context.report({
+					loc: token.loc,
+					messageId: "expectedBefore",
+					data: token,
+					fix(fixer) {
+						return fixer.insertTextBefore(token, " ");
+					}
+				});
+			}
+			/**
+			* Reports a given token if there are space(s) before the token.
+			* @param {Token} token A token to report.
+			* @param {RegExp} pattern A pattern of the previous token to check.
+			* @returns {void}
+			*/
+			function unexpectSpaceBefore(token, pattern) {
+				let prevToken = sourceCode.getTokenBefore(token);
+				prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && astUtils.isTokenOnSameLine(prevToken, token) && sourceCode.isSpaceBetweenTokens(prevToken, token) && context.report({
+					loc: {
+						start: prevToken.loc.end,
+						end: token.loc.start
+					},
+					messageId: "unexpectedBefore",
+					data: token,
+					fix(fixer) {
+						return fixer.removeRange([prevToken.range[1], token.range[0]]);
+					}
+				});
+			}
+			/**
+			* Reports a given token if there are not space(s) after the token.
+			* @param {Token} token A token to report.
+			* @param {RegExp} pattern A pattern of the next token to check.
+			* @returns {void}
+			*/
+			function expectSpaceAfter(token, pattern) {
+				let nextToken = sourceCode.getTokenAfter(token);
+				nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && astUtils.isTokenOnSameLine(token, nextToken) && !sourceCode.isSpaceBetweenTokens(token, nextToken) && context.report({
+					loc: token.loc,
+					messageId: "expectedAfter",
+					data: token,
+					fix(fixer) {
+						return fixer.insertTextAfter(token, " ");
+					}
+				});
+			}
+			/**
+			* Reports a given token if there are space(s) after the token.
+			* @param {Token} token A token to report.
+			* @param {RegExp} pattern A pattern of the next token to check.
+			* @returns {void}
+			*/
+			function unexpectSpaceAfter(token, pattern) {
+				let nextToken = sourceCode.getTokenAfter(token);
+				nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && astUtils.isTokenOnSameLine(token, nextToken) && sourceCode.isSpaceBetweenTokens(token, nextToken) && context.report({
+					loc: {
+						start: token.loc.end,
+						end: nextToken.loc.start
+					},
+					messageId: "unexpectedAfter",
+					data: token,
+					fix(fixer) {
+						return fixer.removeRange([token.range[1], nextToken.range[0]]);
+					}
+				});
+			}
+			/**
+			* Parses the option object and determines check methods for each keyword.
+			* @param {Object|undefined} options The option object to parse.
+			* @returns {Object} - Normalized option object.
+			*      Keys are keywords (there are for every keyword).
+			*      Values are instances of `{"before": function, "after": function}`.
+			*/
+			function parseOptions(options = {}) {
+				let before = options.before !== !1, after = options.after !== !1, defaultValue = {
+					before: before ? expectSpaceBefore : unexpectSpaceBefore,
+					after: after ? expectSpaceAfter : unexpectSpaceAfter
+				}, overrides = options && options.overrides || {}, retv = Object.create(null);
+				for (let i = 0; i < KEYS.length; ++i) {
+					let key = KEYS[i], override = overrides[key];
+					if (override) {
+						let thisBefore = "before" in override ? override.before : before, thisAfter = "after" in override ? override.after : after;
+						retv[key] = {
+							before: thisBefore ? expectSpaceBefore : unexpectSpaceBefore,
+							after: thisAfter ? expectSpaceAfter : unexpectSpaceAfter
+						};
+					} else retv[key] = defaultValue;
+				}
+				return retv;
+			}
+			let checkMethodMap = parseOptions(context.options[0]);
+			/**
+			* Reports a given token if usage of spacing followed by the token is
+			* invalid.
+			* @param {Token} token A token to report.
+			* @param {RegExp} [pattern] Optional. A pattern of the previous
+			*      token to check.
+			* @returns {void}
+			*/
+			function checkSpacingBefore(token, pattern) {
+				checkMethodMap[token.value].before(token, pattern || PREV_TOKEN);
+			}
+			/**
+			* Reports a given token if usage of spacing preceded by the token is
+			* invalid.
+			* @param {Token} token A token to report.
+			* @param {RegExp} [pattern] Optional. A pattern of the next
+			*      token to check.
+			* @returns {void}
+			*/
+			function checkSpacingAfter(token, pattern) {
+				checkMethodMap[token.value].after(token, pattern || NEXT_TOKEN);
+			}
+			/**
+			* Reports a given token if usage of spacing around the token is invalid.
+			* @param {Token} token A token to report.
+			* @returns {void}
+			*/
+			function checkSpacingAround(token) {
+				checkSpacingBefore(token), checkSpacingAfter(token);
+			}
+			/**
+			* Reports the first token of a given node if the first token is a keyword
+			* and usage of spacing around the token is invalid.
+			* @param {ASTNode|null} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingAroundFirstToken(node) {
+				let firstToken = node && sourceCode.getFirstToken(node);
+				firstToken && firstToken.type === "Keyword" && checkSpacingAround(firstToken);
+			}
+			/**
+			* Reports the first token of a given node if the first token is a keyword
+			* and usage of spacing followed by the token is invalid.
+			*
+			* This is used for unary operators (e.g. `typeof`), `function`, and `super`.
+			* Other rules are handling usage of spacing preceded by those keywords.
+			* @param {ASTNode|null} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingBeforeFirstToken(node) {
+				let firstToken = node && sourceCode.getFirstToken(node);
+				firstToken && firstToken.type === "Keyword" && checkSpacingBefore(firstToken);
+			}
+			/**
+			* Reports the previous token of a given node if the token is a keyword and
+			* usage of spacing around the token is invalid.
+			* @param {ASTNode|null} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingAroundTokenBefore(node) {
+				node && checkSpacingAround(sourceCode.getTokenBefore(node, astUtils.isKeywordToken));
+			}
+			/**
+			* Reports `async` or `function` keywords of a given node if usage of
+			* spacing around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForFunction(node) {
+				let firstToken = node && sourceCode.getFirstToken(node);
+				firstToken && (firstToken.type === "Keyword" && firstToken.value === "function" || firstToken.value === "async") && checkSpacingBefore(firstToken);
+			}
+			/**
+			* Reports `class` and `extends` keywords of a given node if usage of
+			* spacing around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForClass(node) {
+				checkSpacingAroundFirstToken(node), checkSpacingAroundTokenBefore(node.superClass);
+			}
+			/**
+			* Reports `if` and `else` keywords of a given node if usage of spacing
+			* around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForIfStatement(node) {
+				checkSpacingAroundFirstToken(node), checkSpacingAroundTokenBefore(node.alternate);
+			}
+			/**
+			* Reports `try`, `catch`, and `finally` keywords of a given node if usage
+			* of spacing around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForTryStatement(node) {
+				checkSpacingAroundFirstToken(node), checkSpacingAroundFirstToken(node.handler), checkSpacingAroundTokenBefore(node.finalizer);
+			}
+			/**
+			* Reports `do` and `while` keywords of a given node if usage of spacing
+			* around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForDoWhileStatement(node) {
+				checkSpacingAroundFirstToken(node), checkSpacingAroundTokenBefore(node.test);
+			}
+			/**
+			* Reports `for` and `in` keywords of a given node if usage of spacing
+			* around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForForInStatement(node) {
+				checkSpacingAroundFirstToken(node);
+				let inToken = sourceCode.getTokenBefore(node.right, astUtils.isNotOpeningParenToken);
+				sourceCode.getTokenBefore(inToken).type !== "PrivateIdentifier" && checkSpacingBefore(inToken), checkSpacingAfter(inToken);
+			}
+			/**
+			* Reports `for` and `of` keywords of a given node if usage of spacing
+			* around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForForOfStatement(node) {
+				node.await ? (checkSpacingBefore(sourceCode.getFirstToken(node, 0)), checkSpacingAfter(sourceCode.getFirstToken(node, 1))) : checkSpacingAroundFirstToken(node);
+				let ofToken = sourceCode.getTokenBefore(node.right, astUtils.isNotOpeningParenToken);
+				sourceCode.getTokenBefore(ofToken).type !== "PrivateIdentifier" && checkSpacingBefore(ofToken), checkSpacingAfter(ofToken);
+			}
+			/**
+			* Reports `import`, `export`, `as`, and `from` keywords of a given node if
+			* usage of spacing around those keywords is invalid.
+			*
+			* This rule handles the `*` token in module declarations.
+			*
+			*     import*as A from "./a"; /*error Expected space(s) after "import".
+			*                               error Expected space(s) before "as".
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForModuleDeclaration(node) {
+				let firstToken = sourceCode.getFirstToken(node);
+				if (checkSpacingBefore(firstToken, PREV_TOKEN_M), checkSpacingAfter(firstToken, NEXT_TOKEN_M), node.type === "ExportDefaultDeclaration" && checkSpacingAround(sourceCode.getTokenAfter(firstToken)), node.type === "ExportAllDeclaration" && node.exported) {
+					let asToken = sourceCode.getTokenBefore(node.exported);
+					checkSpacingBefore(asToken, PREV_TOKEN_M), checkSpacingAfter(asToken, NEXT_TOKEN_M);
+				}
+				if (node.source) {
+					let fromToken = sourceCode.getTokenBefore(node.source);
+					checkSpacingBefore(fromToken, PREV_TOKEN_M), checkSpacingAfter(fromToken, NEXT_TOKEN_M);
+				}
+			}
+			/**
+			* Reports `as` keyword of a given node if usage of spacing around this
+			* keyword is invalid.
+			* @param {ASTNode} node An `ImportSpecifier` node to check.
+			* @returns {void}
+			*/
+			function checkSpacingForImportSpecifier(node) {
+				node.imported.range[0] !== node.local.range[0] && checkSpacingBefore(sourceCode.getTokenBefore(node.local), PREV_TOKEN_M);
+			}
+			/**
+			* Reports `as` keyword of a given node if usage of spacing around this
+			* keyword is invalid.
+			* @param {ASTNode} node An `ExportSpecifier` node to check.
+			* @returns {void}
+			*/
+			function checkSpacingForExportSpecifier(node) {
+				if (node.local.range[0] !== node.exported.range[0]) {
+					let asToken = sourceCode.getTokenBefore(node.exported);
+					checkSpacingBefore(asToken, PREV_TOKEN_M), checkSpacingAfter(asToken, NEXT_TOKEN_M);
+				}
+			}
+			/**
+			* Reports `as` keyword of a given node if usage of spacing around this
+			* keyword is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForImportNamespaceSpecifier(node) {
+				checkSpacingBefore(sourceCode.getFirstToken(node, 1), PREV_TOKEN_M);
+			}
+			/**
+			* Reports `static`, `get`, and `set` keywords of a given node if usage of
+			* spacing around those keywords is invalid.
+			* @param {ASTNode} node A node to report.
+			* @throws {Error} If unable to find token get, set, or async beside method name.
+			* @returns {void}
+			*/
+			function checkSpacingForProperty(node) {
+				if (node.static && checkSpacingAroundFirstToken(node), node.kind === "get" || node.kind === "set" || (node.method || node.type === "MethodDefinition") && node.value.async) {
+					let token = sourceCode.getTokenBefore(node.key, (tok) => {
+						switch (tok.value) {
+							case "get":
+							case "set":
+							case "async": return !0;
+							default: return !1;
+						}
+					});
+					if (!token) throw Error("Failed to find token get, set, or async beside method name");
+					checkSpacingAround(token);
+				}
+			}
+			/**
+			* Reports `await` keyword of a given node if usage of spacing before
+			* this keyword is invalid.
+			* @param {ASTNode} node A node to report.
+			* @returns {void}
+			*/
+			function checkSpacingForAwaitExpression(node) {
+				checkSpacingBefore(sourceCode.getFirstToken(node));
+			}
+			return {
+				DebuggerStatement: checkSpacingAroundFirstToken,
+				WithStatement: checkSpacingAroundFirstToken,
+				BreakStatement: checkSpacingAroundFirstToken,
+				ContinueStatement: checkSpacingAroundFirstToken,
+				ReturnStatement: checkSpacingAroundFirstToken,
+				ThrowStatement: checkSpacingAroundFirstToken,
+				TryStatement: checkSpacingForTryStatement,
+				IfStatement: checkSpacingForIfStatement,
+				SwitchStatement: checkSpacingAroundFirstToken,
+				SwitchCase: checkSpacingAroundFirstToken,
+				DoWhileStatement: checkSpacingForDoWhileStatement,
+				ForInStatement: checkSpacingForForInStatement,
+				ForOfStatement: checkSpacingForForOfStatement,
+				ForStatement: checkSpacingAroundFirstToken,
+				WhileStatement: checkSpacingAroundFirstToken,
+				ClassDeclaration: checkSpacingForClass,
+				ExportNamedDeclaration: checkSpacingForModuleDeclaration,
+				ExportDefaultDeclaration: checkSpacingForModuleDeclaration,
+				ExportAllDeclaration: checkSpacingForModuleDeclaration,
+				FunctionDeclaration: checkSpacingForFunction,
+				ImportDeclaration: checkSpacingForModuleDeclaration,
+				VariableDeclaration: checkSpacingAroundFirstToken,
+				ArrowFunctionExpression: checkSpacingForFunction,
+				AwaitExpression: checkSpacingForAwaitExpression,
+				ClassExpression: checkSpacingForClass,
+				FunctionExpression: checkSpacingForFunction,
+				NewExpression: checkSpacingBeforeFirstToken,
+				Super: checkSpacingBeforeFirstToken,
+				ThisExpression: checkSpacingBeforeFirstToken,
+				UnaryExpression: checkSpacingBeforeFirstToken,
+				YieldExpression: checkSpacingBeforeFirstToken,
+				ImportSpecifier: checkSpacingForImportSpecifier,
+				ExportSpecifier: checkSpacingForExportSpecifier,
+				ImportNamespaceSpecifier: checkSpacingForImportNamespaceSpecifier,
+				MethodDefinition: checkSpacingForProperty,
+				PropertyDefinition: checkSpacingForProperty,
+				StaticBlock: checkSpacingAroundFirstToken,
+				Property: checkSpacingForProperty,
+				"BinaryExpression[operator='>']"(node) {
+					let operatorToken = sourceCode.getTokenBefore(node.right, astUtils.isNotOpeningParenToken);
+					tokensToIgnore.add(operatorToken);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/keyword-spacing.cjs
+module.exports = require_keyword_spacing().create;
+//#endregion

package/rules/line-comment-position.cjs

@@ -0,0 +1,75 @@
+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/line-comment-position.js
+/**
+* @fileoverview Rule to enforce the position of line comments
+* @author Alberto Rodríguez
+* @deprecated in ESLint v9.3.0
+*/
+var require_line_comment_position = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "9.3.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: "line-comment-position",
+						url: "https://eslint.style/rules/line-comment-position"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce position of line comments",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/line-comment-position"
+			},
+			schema: [{ oneOf: [{ enum: ["above", "beside"] }, {
+				type: "object",
+				properties: {
+					position: { enum: ["above", "beside"] },
+					ignorePattern: { type: "string" },
+					applyDefaultPatterns: { type: "boolean" },
+					applyDefaultIgnorePatterns: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				above: "Expected comment to be above code.",
+				beside: "Expected comment to be beside code."
+			}
+		},
+		create(context) {
+			let options = context.options[0], above, ignorePattern, applyDefaultIgnorePatterns = !0;
+			!options || typeof options == "string" ? above = !options || options === "above" : (above = !options.position || options.position === "above", ignorePattern = options.ignorePattern, applyDefaultIgnorePatterns = Object.hasOwn(options, "applyDefaultIgnorePatterns") ? options.applyDefaultIgnorePatterns : options.applyDefaultPatterns !== !1);
+			let defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN, fallThroughRegExp = /^\s*falls?\s?through/u, customIgnoreRegExp = new RegExp(ignorePattern, "u"), sourceCode = context.sourceCode;
+			return { Program() {
+				sourceCode.getAllComments().filter((token) => token.type === "Line").forEach((node) => {
+					if (applyDefaultIgnorePatterns && (defaultIgnoreRegExp.test(node.value) || fallThroughRegExp.test(node.value)) || ignorePattern && customIgnoreRegExp.test(node.value)) return;
+					let previous = sourceCode.getTokenBefore(node, { includeComments: !0 }), isOnSameLine = previous && previous.loc.end.line === node.loc.start.line;
+					above ? isOnSameLine && context.report({
+						node,
+						messageId: "above"
+					}) : isOnSameLine || context.report({
+						node,
+						messageId: "beside"
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/line-comment-position.cjs
+module.exports = require_line_comment_position().create;
+//#endregion

package/rules/linebreak-style.cjs

@@ -0,0 +1,89 @@
+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/linebreak-style.js
+/**
+* @fileoverview Rule to enforce a single linebreak style.
+* @author Erik Mueller
+* @deprecated in ESLint v8.53.0
+*/
+var require_linebreak_style = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	/**
+	* @import { SourceRange } from "@eslint/core";
+	*/
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Formatting rules are being moved out of ESLint core.",
+				url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+				deprecatedSince: "8.53.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style"
+					},
+					rule: {
+						name: "linebreak-style",
+						url: "https://eslint.style/rules/linebreak-style"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent linebreak style",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/linebreak-style"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["unix", "windows"] }],
+			messages: {
+				expectedLF: "Expected linebreaks to be 'LF' but found 'CRLF'.",
+				expectedCRLF: "Expected linebreaks to be 'CRLF' but found 'LF'."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Builds a fix function that replaces text at the specified range in the source text.
+			* @param {SourceRange} range The range to replace
+			* @param {string} text The text to insert.
+			* @returns {Function} Fixer function
+			* @private
+			*/
+			function createFix(range, text) {
+				return function(fixer) {
+					return fixer.replaceTextRange(range, text);
+				};
+			}
+			return { Program: function checkForLinebreakStyle(node) {
+				let expectedLF = (context.options[0] || "unix") === "unix", expectedLFChars = expectedLF ? "\n" : "\r\n", source = sourceCode.getText(), pattern = astUtils.createGlobalLinebreakMatcher(), match, i = 0;
+				for (; (match = pattern.exec(source)) !== null;) {
+					if (i++, match[0] === expectedLFChars) continue;
+					let index = match.index, range = [index, index + match[0].length];
+					context.report({
+						node,
+						loc: {
+							start: {
+								line: i,
+								column: sourceCode.lines[i - 1].length
+							},
+							end: {
+								line: i + 1,
+								column: 0
+							}
+						},
+						messageId: expectedLF ? "expectedLF" : "expectedCRLF",
+						fix: createFix(range, expectedLFChars)
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/linebreak-style.cjs
+module.exports = require_linebreak_style().create;
+//#endregion