oxlint-plugin-eslint 1.52.0

package/rules/curly.cjs

@@ -0,0 +1,173 @@
+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/curly.js
+/**
+* @fileoverview Rule to flag statements without curly braces
+* @author Nicholas C. Zakas
+*/
+var require_curly = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce consistent brace style for all control statements",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/curly"
+			},
+			schema: { anyOf: [{
+				type: "array",
+				items: [{ enum: ["all"] }],
+				minItems: 0,
+				maxItems: 1
+			}, {
+				type: "array",
+				items: [{ enum: [
+					"multi",
+					"multi-line",
+					"multi-or-nest"
+				] }, { enum: ["consistent"] }],
+				minItems: 0,
+				maxItems: 2
+			}] },
+			defaultOptions: ["all"],
+			fixable: "code",
+			messages: {
+				missingCurlyAfter: "Expected { after '{{name}}'.",
+				missingCurlyAfterCondition: "Expected { after '{{name}}' condition.",
+				unexpectedCurlyAfter: "Unnecessary { after '{{name}}'.",
+				unexpectedCurlyAfterCondition: "Unnecessary { after '{{name}}' condition."
+			}
+		},
+		create(context) {
+			let multiOnly = context.options[0] === "multi", multiLine = context.options[0] === "multi-line", multiOrNest = context.options[0] === "multi-or-nest", consistent = context.options[1] === "consistent", sourceCode = context.sourceCode;
+			/**
+			* Determines if a given node is a one-liner that's on the same line as it's preceding code.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} True if the node is a one-liner that's on the same line as it's preceding code.
+			* @private
+			*/
+			function isCollapsedOneLiner(node) {
+				let before = sourceCode.getTokenBefore(node), last = sourceCode.getLastToken(node), lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
+				return before.loc.start.line === lastExcludingSemicolon.loc.end.line;
+			}
+			/**
+			* Determines if a given node is a one-liner.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} True if the node is a one-liner.
+			* @private
+			*/
+			function isOneLiner(node) {
+				if (node.type === "EmptyStatement") return !0;
+				let first = sourceCode.getFirstToken(node), last = sourceCode.getLastToken(node), lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
+				return first.loc.start.line === lastExcludingSemicolon.loc.end.line;
+			}
+			/**
+			* Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError.
+			* @param {Token} closingBracket The } token
+			* @returns {boolean} `true` if a semicolon needs to be inserted after the last statement in the block.
+			*/
+			function needsSemicolon(closingBracket) {
+				let tokenBefore = sourceCode.getTokenBefore(closingBracket), tokenAfter = sourceCode.getTokenAfter(closingBracket), lastBlockNode = sourceCode.getNodeByRangeIndex(tokenBefore.range[0]);
+				return astUtils.isSemicolonToken(tokenBefore) || !tokenAfter || lastBlockNode.type === "BlockStatement" && lastBlockNode.parent.type !== "FunctionExpression" && lastBlockNode.parent.type !== "ArrowFunctionExpression" ? !1 : !!(tokenBefore.loc.end.line === tokenAfter.loc.start.line || /^[([/`+-]/u.test(tokenAfter.value) || tokenBefore.type === "Punctuator" && (tokenBefore.value === "++" || tokenBefore.value === "--"));
+			}
+			/**
+			* Prepares to check the body of a node to see if it's a block statement.
+			* @param {ASTNode} node The node to report if there's a problem.
+			* @param {ASTNode} body The body node to check for blocks.
+			* @param {string} name The name to report if there's a problem.
+			* @param {{ condition: boolean }} opts Options to pass to the report functions
+			* @returns {Object} a prepared check object, with "actual", "expected", "check" properties.
+			*   "actual" will be `true` or `false` whether the body is already a block statement.
+			*   "expected" will be `true` or `false` if the body should be a block statement or not, or
+			*   `null` if it doesn't matter, depending on the rule options. It can be modified to change
+			*   the final behavior of "check".
+			*   "check" will be a function reporting appropriate problems depending on the other
+			*   properties.
+			*/
+			function prepareCheck(node, body, name, opts) {
+				let hasBlock = body.type === "BlockStatement", expected = null;
+				if (hasBlock && (body.body.length !== 1 || astUtils.areBracesNecessary(body, sourceCode))) expected = !0;
+				else if (multiOnly) expected = !1;
+				else if (multiLine) isCollapsedOneLiner(body) || (expected = !0);
+				else if (multiOrNest) if (hasBlock) {
+					let statement = body.body[0], leadingCommentsInBlock = sourceCode.getCommentsBefore(statement);
+					expected = !isOneLiner(statement) || leadingCommentsInBlock.length > 0;
+				} else expected = !isOneLiner(body);
+				else expected = !0;
+				return {
+					actual: hasBlock,
+					expected,
+					check() {
+						this.expected !== null && this.expected !== this.actual && (this.expected ? context.report({
+							node,
+							loc: body.loc,
+							messageId: opts && opts.condition ? "missingCurlyAfterCondition" : "missingCurlyAfter",
+							data: { name },
+							fix: (fixer) => fixer.replaceText(body, `{${sourceCode.getText(body)}}`)
+						}) : context.report({
+							node,
+							loc: body.loc,
+							messageId: opts && opts.condition ? "unexpectedCurlyAfterCondition" : "unexpectedCurlyAfter",
+							data: { name },
+							fix(fixer) {
+								let needsPrecedingSpace = node.type === "DoWhileStatement" && sourceCode.getTokenBefore(body).range[1] === body.range[0] && !astUtils.canTokensBeAdjacent("do", sourceCode.getFirstToken(body, { skip: 1 })), openingBracket = sourceCode.getFirstToken(body), closingBracket = sourceCode.getLastToken(body), lastTokenInBlock = sourceCode.getTokenBefore(closingBracket);
+								if (needsSemicolon(closingBracket)) return null;
+								let resultingBodyText = sourceCode.getText().slice(openingBracket.range[1], lastTokenInBlock.range[0]) + sourceCode.getText(lastTokenInBlock) + sourceCode.getText().slice(lastTokenInBlock.range[1], closingBracket.range[0]);
+								return fixer.replaceText(body, (needsPrecedingSpace ? " " : "") + resultingBodyText);
+							}
+						}));
+					}
+				};
+			}
+			/**
+			* Prepares to check the bodies of a "if", "else if" and "else" chain.
+			* @param {ASTNode} node The first IfStatement node of the chain.
+			* @returns {Object[]} prepared checks for each body of the chain. See `prepareCheck` for more
+			*   information.
+			*/
+			function prepareIfChecks(node) {
+				let preparedChecks = [];
+				for (let currentNode = node; currentNode; currentNode = currentNode.alternate) if (preparedChecks.push(prepareCheck(currentNode, currentNode.consequent, "if", { condition: !0 })), currentNode.alternate && currentNode.alternate.type !== "IfStatement") {
+					preparedChecks.push(prepareCheck(currentNode, currentNode.alternate, "else"));
+					break;
+				}
+				if (consistent) {
+					let expected = preparedChecks.some((preparedCheck) => preparedCheck.expected === null ? preparedCheck.actual : preparedCheck.expected);
+					preparedChecks.forEach((preparedCheck) => {
+						preparedCheck.expected = expected;
+					});
+				}
+				return preparedChecks;
+			}
+			return {
+				IfStatement(node) {
+					let parent = node.parent;
+					parent.type === "IfStatement" && parent.alternate === node || prepareIfChecks(node).forEach((preparedCheck) => {
+						preparedCheck.check();
+					});
+				},
+				WhileStatement(node) {
+					prepareCheck(node, node.body, "while", { condition: !0 }).check();
+				},
+				DoWhileStatement(node) {
+					prepareCheck(node, node.body, "do").check();
+				},
+				ForStatement(node) {
+					prepareCheck(node, node.body, "for", { condition: !0 }).check();
+				},
+				ForInStatement(node) {
+					prepareCheck(node, node.body, "for-in").check();
+				},
+				ForOfStatement(node) {
+					prepareCheck(node, node.body, "for-of").check();
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/curly.cjs
+module.exports = require_curly().create;
+//#endregion

package/rules/default-case-last.cjs

@@ -0,0 +1,36 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/default-case-last.js
+/**
+* @fileoverview Rule to enforce `default` clauses in `switch` statements to be last
+* @author Milos Djermanovic
+*/
+var require_default_case_last = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce `default` clauses in `switch` statements to be last",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/default-case-last"
+			},
+			schema: [],
+			messages: { notLast: "Default clause should be the last clause." }
+		},
+		create(context) {
+			return { SwitchStatement(node) {
+				let cases = node.cases, indexOfDefault = cases.findIndex((c) => c.test === null);
+				if (indexOfDefault !== -1 && indexOfDefault !== cases.length - 1) {
+					let defaultClause = cases[indexOfDefault];
+					context.report({
+						node: defaultClause,
+						messageId: "notLast"
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/default-case-last.cjs
+module.exports = require_default_case_last().create;
+//#endregion

package/rules/default-case.cjs

@@ -0,0 +1,50 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/default-case.js
+/**
+* @fileoverview require default case in switch statements
+* @author Aliaksei Shytkin
+*/
+var require_default_case = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let DEFAULT_COMMENT_PATTERN = /^no default$/iu;
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{}],
+			docs: {
+				description: "Require `default` cases in `switch` statements",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/default-case"
+			},
+			schema: [{
+				type: "object",
+				properties: { commentPattern: { type: "string" } },
+				additionalProperties: !1
+			}],
+			messages: { missingDefaultCase: "Expected a default case." }
+		},
+		create(context) {
+			let [options] = context.options, commentPattern = options.commentPattern ? new RegExp(options.commentPattern, "u") : DEFAULT_COMMENT_PATTERN, sourceCode = context.sourceCode;
+			/**
+			* Shortcut to get last element of array
+			* @param {*[]} collection Array
+			* @returns {any} Last element
+			*/
+			function last(collection) {
+				return collection.at(-1);
+			}
+			return { SwitchStatement(node) {
+				if (node.cases.length && !node.cases.some((v) => v.test === null)) {
+					let comment, lastCase = last(node.cases), comments = sourceCode.getCommentsAfter(lastCase);
+					comments.length && (comment = last(comments)), (!comment || !commentPattern.test(comment.value.trim())) && context.report({
+						node,
+						messageId: "missingDefaultCase"
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/default-case.cjs
+module.exports = require_default_case().create;
+//#endregion

package/rules/default-param-last.cjs

@@ -0,0 +1,61 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/default-param-last.js
+/**
+* @fileoverview enforce default parameters to be last
+* @author Chiawen Chen
+*/
+var require_default_param_last = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* Checks if node is required: i.e. does not have a default value or ? optional indicator.
+	* @param {ASTNode} node the node to be evaluated
+	* @returns {boolean} true if the node is required, false if not.
+	*/
+	function isRequiredParameter(node) {
+		return !(node.type === "AssignmentPattern" || node.type === "RestElement" || node.optional);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			type: "suggestion",
+			docs: {
+				description: "Enforce default parameters to be last",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/default-param-last"
+			},
+			schema: [],
+			messages: { shouldBeLast: "Default parameters should be last." }
+		},
+		create(context) {
+			/**
+			* Handler for function contexts.
+			* @param {ASTNode} node function node
+			* @returns {void}
+			*/
+			function handleFunction(node) {
+				let hasSeenRequiredParameter = !1;
+				for (let i = node.params.length - 1; i >= 0; --i) {
+					let current = node.params[i];
+					if (isRequiredParameter(current.type === "TSParameterProperty" ? current.parameter : current)) {
+						hasSeenRequiredParameter = !0;
+						continue;
+					}
+					hasSeenRequiredParameter && context.report({
+						node: current,
+						messageId: "shouldBeLast"
+					});
+				}
+			}
+			return {
+				FunctionDeclaration: handleFunction,
+				FunctionExpression: handleFunction,
+				ArrowFunctionExpression: handleFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/default-param-last.cjs
+module.exports = require_default_param_last().create;
+//#endregion

package/rules/dot-location.cjs

@@ -0,0 +1,87 @@
+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/dot-location.js
+/**
+* @fileoverview Validates newlines before and after dots
+* @author Greg Cochard
+* @deprecated in ESLint v8.53.0
+*/
+var require_dot_location = /* @__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: "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: "dot-location",
+						url: "https://eslint.style/rules/dot-location"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent newlines before and after dots",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/dot-location"
+			},
+			schema: [{ enum: ["object", "property"] }],
+			fixable: "code",
+			messages: {
+				expectedDotAfterObject: "Expected dot to be on same line as object.",
+				expectedDotBeforeProperty: "Expected dot to be on same line as property."
+			}
+		},
+		create(context) {
+			let config = context.options[0], onObject = config === "object" || !config, sourceCode = context.sourceCode;
+			/**
+			* Reports if the dot between object and property is on the correct location.
+			* @param {ASTNode} node The `MemberExpression` node.
+			* @returns {void}
+			*/
+			function checkDotLocation(node) {
+				let property = node.property, dotToken = sourceCode.getTokenBefore(property);
+				if (onObject) {
+					let tokenBeforeDot = sourceCode.getTokenBefore(dotToken);
+					astUtils.isTokenOnSameLine(tokenBeforeDot, dotToken) || context.report({
+						node,
+						loc: dotToken.loc,
+						messageId: "expectedDotAfterObject",
+						*fix(fixer) {
+							dotToken.value.startsWith(".") && astUtils.isDecimalIntegerNumericToken(tokenBeforeDot) ? yield fixer.insertTextAfter(tokenBeforeDot, ` ${dotToken.value}`) : yield fixer.insertTextAfter(tokenBeforeDot, dotToken.value), yield fixer.remove(dotToken);
+						}
+					});
+				} else astUtils.isTokenOnSameLine(dotToken, property) || context.report({
+					node,
+					loc: dotToken.loc,
+					messageId: "expectedDotBeforeProperty",
+					*fix(fixer) {
+						yield fixer.remove(dotToken), yield fixer.insertTextBefore(property, dotToken.value);
+					}
+				});
+			}
+			/**
+			* Checks the spacing of the dot within a member expression.
+			* @param {ASTNode} node The node to check.
+			* @returns {void}
+			*/
+			function checkNode(node) {
+				node.computed || checkDotLocation(node);
+			}
+			return { MemberExpression: checkNode };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/dot-location.cjs
+module.exports = require_dot_location().create;
+//#endregion

package/rules/dot-notation.cjs

@@ -0,0 +1,77 @@
+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/dot-notation.js
+/**
+* @fileoverview Rule to warn about using dot notation instead of square bracket notation when possible.
+* @author Josh Perez
+*/
+var require_dot_notation = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), keywords = require_keywords$1.t(), validIdentifier = /^[a-zA-Z_$][\w$]*$/u, literalTypesToCheck = new Set(["string", "boolean"]);
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{
+				allowKeywords: !0,
+				allowPattern: ""
+			}],
+			docs: {
+				description: "Enforce dot notation whenever possible",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/dot-notation"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					allowKeywords: { type: "boolean" },
+					allowPattern: { type: "string" }
+				},
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: {
+				useDot: "[{{key}}] is better written in dot notation.",
+				useBrackets: ".{{key}} is a syntax error."
+			}
+		},
+		create(context) {
+			let [options] = context.options, allowKeywords = options.allowKeywords, sourceCode = context.sourceCode, allowPattern;
+			options.allowPattern && (allowPattern = new RegExp(options.allowPattern, "u"));
+			/**
+			* Check if the property is valid dot notation
+			* @param {ASTNode} node The dot notation node
+			* @param {string} value Value which is to be checked
+			* @returns {void}
+			*/
+			function checkComputedProperty(node, value) {
+				if (validIdentifier.test(value) && (allowKeywords || !keywords.includes(String(value))) && !(allowPattern && allowPattern.test(value))) {
+					let formattedValue = node.property.type === "Literal" ? JSON.stringify(value) : `\`${value}\``;
+					context.report({
+						node: node.property,
+						messageId: "useDot",
+						data: { key: formattedValue },
+						*fix(fixer) {
+							let leftBracket = sourceCode.getTokenAfter(node.object, astUtils.isOpeningBracketToken), rightBracket = sourceCode.getLastToken(node), nextToken = sourceCode.getTokenAfter(node);
+							sourceCode.commentsExistBetween(leftBracket, rightBracket) || (node.optional || (yield fixer.insertTextBefore(leftBracket, astUtils.isDecimalInteger(node.object) ? " ." : ".")), yield fixer.replaceTextRange([leftBracket.range[0], rightBracket.range[1]], value), nextToken && rightBracket.range[1] === nextToken.range[0] && !astUtils.canTokensBeAdjacent(String(value), nextToken) && (yield fixer.insertTextAfter(node, " ")));
+						}
+					});
+				}
+			}
+			return { MemberExpression(node) {
+				node.computed && node.property.type === "Literal" && (literalTypesToCheck.has(typeof node.property.value) || astUtils.isNullLiteral(node.property)) && checkComputedProperty(node, node.property.value), node.computed && astUtils.isStaticTemplateLiteral(node.property) && checkComputedProperty(node, node.property.quasis[0].value.cooked), !allowKeywords && !node.computed && node.property.type === "Identifier" && keywords.includes(String(node.property.name)) && context.report({
+					node: node.property,
+					messageId: "useBrackets",
+					data: { key: node.property.name },
+					*fix(fixer) {
+						let dotToken = sourceCode.getTokenBefore(node.property);
+						node.object.type === "Identifier" && node.object.name === "let" && !node.optional || sourceCode.commentsExistBetween(dotToken, node.property) || (node.optional || (yield fixer.remove(dotToken)), yield fixer.replaceText(node.property, `["${node.property.name}"]`));
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/dot-notation.cjs
+module.exports = require_dot_notation().create;
+//#endregion

package/rules/eol-last.cjs

@@ -0,0 +1,91 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/eol-last.js
+/**
+* @fileoverview Require or disallow newline at the end of files
+* @author Nodeca Team <https://github.com/nodeca>
+* @deprecated in ESLint v8.53.0
+*/
+var require_eol_last = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @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: "eol-last",
+						url: "https://eslint.style/rules/eol-last"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require or disallow newline at the end of files",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/eol-last"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: [
+				"always",
+				"never",
+				"unix",
+				"windows"
+			] }],
+			messages: {
+				missing: "Newline required at end of file but not found.",
+				unexpected: "Newline not allowed at end of file."
+			}
+		},
+		create(context) {
+			return { Program: function checkBadEOF(node) {
+				let sourceCode = context.sourceCode, src = sourceCode.getText(), location = {
+					column: sourceCode.lines.at(-1).length,
+					line: sourceCode.lines.length
+				}, endsWithNewline = src.endsWith("\n");
+				if (!src.length) return;
+				let mode = context.options[0] || "always", appendCRLF = !1;
+				if (mode === "unix" && (mode = "always"), mode === "windows" && (mode = "always", appendCRLF = !0), mode === "always" && !endsWithNewline) context.report({
+					node,
+					loc: location,
+					messageId: "missing",
+					fix(fixer) {
+						return fixer.insertTextAfterRange([0, src.length], appendCRLF ? "\r\n" : "\n");
+					}
+				});
+				else if (mode === "never" && endsWithNewline) {
+					let secondLastLine = sourceCode.lines.at(-2);
+					context.report({
+						node,
+						loc: {
+							start: {
+								line: sourceCode.lines.length - 1,
+								column: secondLastLine.length
+							},
+							end: {
+								line: sourceCode.lines.length,
+								column: 0
+							}
+						},
+						messageId: "unexpected",
+						fix(fixer) {
+							let start = /(?:\r?\n)+$/u.exec(sourceCode.text).index, end = sourceCode.text.length;
+							return fixer.replaceTextRange([start, end], "");
+						}
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/eol-last.cjs
+module.exports = require_eol_last().create;
+//#endregion