oxlint-plugin-eslint 1.52.0

package/rules/multiline-ternary.cjs

@@ -0,0 +1,106 @@
+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/multiline-ternary.js
+/**
+* @fileoverview Enforce newlines between operands of ternary expressions
+* @author Kai Cataldo
+* @deprecated in ESLint v8.53.0
+*/
+var require_multiline_ternary = /* @__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: "multiline-ternary",
+						url: "https://eslint.style/rules/multiline-ternary"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce newlines between operands of ternary expressions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/multiline-ternary"
+			},
+			schema: [{ enum: [
+				"always",
+				"always-multiline",
+				"never"
+			] }],
+			messages: {
+				expectedTestCons: "Expected newline between test and consequent of ternary expression.",
+				expectedConsAlt: "Expected newline between consequent and alternate of ternary expression.",
+				unexpectedTestCons: "Unexpected newline between test and consequent of ternary expression.",
+				unexpectedConsAlt: "Unexpected newline between consequent and alternate of ternary expression."
+			},
+			fixable: "whitespace"
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, option = context.options[0], multiline = option !== "never", allowSingleLine = option === "always-multiline";
+			return { ConditionalExpression(node) {
+				let questionToken = sourceCode.getTokenAfter(node.test, astUtils.isNotClosingParenToken), colonToken = sourceCode.getTokenAfter(node.consequent, astUtils.isNotClosingParenToken), firstTokenOfTest = sourceCode.getFirstToken(node), lastTokenOfTest = sourceCode.getTokenBefore(questionToken), firstTokenOfConsequent = sourceCode.getTokenAfter(questionToken), lastTokenOfConsequent = sourceCode.getTokenBefore(colonToken), firstTokenOfAlternate = sourceCode.getTokenAfter(colonToken), areTestAndConsequentOnSameLine = astUtils.isTokenOnSameLine(lastTokenOfTest, firstTokenOfConsequent), areConsequentAndAlternateOnSameLine = astUtils.isTokenOnSameLine(lastTokenOfConsequent, firstTokenOfAlternate), hasComments = !!sourceCode.getCommentsInside(node).length;
+				if (!multiline) areTestAndConsequentOnSameLine || context.report({
+					node: node.test,
+					loc: {
+						start: firstTokenOfTest.loc.start,
+						end: lastTokenOfTest.loc.end
+					},
+					messageId: "unexpectedTestCons",
+					fix(fixer) {
+						if (hasComments) return null;
+						let fixers = [], areTestAndQuestionOnSameLine = astUtils.isTokenOnSameLine(lastTokenOfTest, questionToken), areQuestionAndConsOnSameLine = astUtils.isTokenOnSameLine(questionToken, firstTokenOfConsequent);
+						return areTestAndQuestionOnSameLine || fixers.push(fixer.removeRange([lastTokenOfTest.range[1], questionToken.range[0]])), areQuestionAndConsOnSameLine || fixers.push(fixer.removeRange([questionToken.range[1], firstTokenOfConsequent.range[0]])), fixers;
+					}
+				}), areConsequentAndAlternateOnSameLine || context.report({
+					node: node.consequent,
+					loc: {
+						start: firstTokenOfConsequent.loc.start,
+						end: lastTokenOfConsequent.loc.end
+					},
+					messageId: "unexpectedConsAlt",
+					fix(fixer) {
+						if (hasComments) return null;
+						let fixers = [], areConsAndColonOnSameLine = astUtils.isTokenOnSameLine(lastTokenOfConsequent, colonToken), areColonAndAltOnSameLine = astUtils.isTokenOnSameLine(colonToken, firstTokenOfAlternate);
+						return areConsAndColonOnSameLine || fixers.push(fixer.removeRange([lastTokenOfConsequent.range[1], colonToken.range[0]])), areColonAndAltOnSameLine || fixers.push(fixer.removeRange([colonToken.range[1], firstTokenOfAlternate.range[0]])), fixers;
+					}
+				});
+				else {
+					if (allowSingleLine && node.loc.start.line === node.loc.end.line) return;
+					areTestAndConsequentOnSameLine && context.report({
+						node: node.test,
+						loc: {
+							start: firstTokenOfTest.loc.start,
+							end: lastTokenOfTest.loc.end
+						},
+						messageId: "expectedTestCons",
+						fix: (fixer) => hasComments ? null : fixer.replaceTextRange([lastTokenOfTest.range[1], questionToken.range[0]], "\n")
+					}), areConsequentAndAlternateOnSameLine && context.report({
+						node: node.consequent,
+						loc: {
+							start: firstTokenOfConsequent.loc.start,
+							end: lastTokenOfConsequent.loc.end
+						},
+						messageId: "expectedConsAlt",
+						fix: (fixer) => hasComments ? null : fixer.replaceTextRange([lastTokenOfConsequent.range[1], colonToken.range[0]], "\n")
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/multiline-ternary.cjs
+module.exports = require_multiline_ternary().create;
+//#endregion

package/rules/new-cap.cjs

@@ -0,0 +1,139 @@
+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/new-cap.js
+/**
+* @fileoverview Rule to flag use of constructors without capital letters
+* @author Nicholas C. Zakas
+*/
+var require_new_cap = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), CAPS_ALLOWED = [
+		"Array",
+		"Boolean",
+		"Date",
+		"Error",
+		"Function",
+		"Number",
+		"Object",
+		"RegExp",
+		"String",
+		"Symbol",
+		"BigInt"
+	];
+	/**
+	* A reducer function to invert an array to an Object mapping the string form of the key, to `true`.
+	* @param {Object} map Accumulator object for the reduce.
+	* @param {string} key Object key to set to `true`.
+	* @returns {Object} Returns the updated Object for further reduction.
+	*/
+	function invert(map, key) {
+		return map[key] = !0, map;
+	}
+	/**
+	* Creates an object with the cap is new exceptions as its keys and true as their values.
+	* @param {Object} config Rule configuration
+	* @returns {Object} Object with cap is new exceptions.
+	*/
+	function calculateCapIsNewExceptions(config) {
+		return Array.from(new Set([...config.capIsNewExceptions, ...CAPS_ALLOWED])).reduce(invert, {});
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Require constructor names to begin with a capital letter",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/new-cap"
+			},
+			schema: [{
+				type: "object",
+				properties: {
+					newIsCap: { type: "boolean" },
+					capIsNew: { type: "boolean" },
+					newIsCapExceptions: {
+						type: "array",
+						items: { type: "string" }
+					},
+					newIsCapExceptionPattern: { type: "string" },
+					capIsNewExceptions: {
+						type: "array",
+						items: { type: "string" }
+					},
+					capIsNewExceptionPattern: { type: "string" },
+					properties: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			defaultOptions: [{
+				capIsNew: !0,
+				capIsNewExceptions: CAPS_ALLOWED,
+				newIsCap: !0,
+				newIsCapExceptions: [],
+				properties: !0
+			}],
+			messages: {
+				upper: "A function with a name starting with an uppercase letter should only be used as a constructor.",
+				lower: "A constructor name should not start with a lowercase letter."
+			}
+		},
+		create(context) {
+			let [config] = context.options, skipProperties = !config.properties, newIsCapExceptions = config.newIsCapExceptions.reduce(invert, {}), newIsCapExceptionPattern = config.newIsCapExceptionPattern ? new RegExp(config.newIsCapExceptionPattern, "u") : null, capIsNewExceptions = calculateCapIsNewExceptions(config), capIsNewExceptionPattern = config.capIsNewExceptionPattern ? new RegExp(config.capIsNewExceptionPattern, "u") : null, listeners = {}, sourceCode = context.sourceCode;
+			/**
+			* Get exact callee name from expression
+			* @param {ASTNode} node CallExpression or NewExpression node
+			* @returns {string} name
+			*/
+			function extractNameFromExpression(node) {
+				return node.callee.type === "Identifier" ? node.callee.name : astUtils.getStaticPropertyName(node.callee) || "";
+			}
+			/**
+			* Returns the capitalization state of the string -
+			* Whether the first character is uppercase, lowercase, or non-alphabetic
+			* @param {string} str String
+			* @returns {string} capitalization state: "non-alpha", "lower", or "upper"
+			*/
+			function getCap(str) {
+				let firstChar = str.charAt(0), firstCharLower = firstChar.toLowerCase();
+				return firstCharLower === firstChar.toUpperCase() ? "non-alpha" : firstChar === firstCharLower ? "lower" : "upper";
+			}
+			/**
+			* Check if capitalization is allowed for a CallExpression
+			* @param {Object} allowedMap Object mapping calleeName to a Boolean
+			* @param {ASTNode} node CallExpression node
+			* @param {string} calleeName Capitalized callee name from a CallExpression
+			* @param {Object} pattern RegExp object from options pattern
+			* @returns {boolean} Returns true if the callee may be capitalized
+			*/
+			function isCapAllowed(allowedMap, node, calleeName, pattern) {
+				let sourceText = sourceCode.getText(node.callee);
+				if (allowedMap[calleeName] || allowedMap[sourceText] || pattern && pattern.test(sourceText)) return !0;
+				let callee = astUtils.skipChainExpression(node.callee);
+				return calleeName === "UTC" && callee.type === "MemberExpression" ? callee.object.type === "Identifier" && callee.object.name === "Date" : skipProperties && callee.type === "MemberExpression";
+			}
+			/**
+			* Reports the given messageId for the given node. The location will be the start of the property or the callee.
+			* @param {ASTNode} node CallExpression or NewExpression node.
+			* @param {string} messageId The messageId to report.
+			* @returns {void}
+			*/
+			function report(node, messageId) {
+				let callee = astUtils.skipChainExpression(node.callee);
+				callee.type === "MemberExpression" && (callee = callee.property), context.report({
+					node,
+					loc: callee.loc,
+					messageId
+				});
+			}
+			return config.newIsCap && (listeners.NewExpression = function(node) {
+				let constructorName = extractNameFromExpression(node);
+				constructorName && (getCap(constructorName) !== "lower" || isCapAllowed(newIsCapExceptions, node, constructorName, newIsCapExceptionPattern) || report(node, "lower"));
+			}), config.capIsNew && (listeners.CallExpression = function(node) {
+				let calleeName = extractNameFromExpression(node);
+				calleeName && (getCap(calleeName) !== "upper" || isCapAllowed(capIsNewExceptions, node, calleeName, capIsNewExceptionPattern) || report(node, "upper"));
+			}), listeners;
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/new-cap.cjs
+module.exports = require_new_cap().create;
+//#endregion

package/rules/new-parens.cjs

@@ -0,0 +1,70 @@
+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/new-parens.js
+/**
+* @fileoverview Rule to flag when using constructor without parentheses
+* @author Ilya Volodin
+* @deprecated in ESLint v8.53.0
+*/
+var require_new_parens = /* @__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: "new-parens",
+						url: "https://eslint.style/rules/new-parens"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce or disallow parentheses when invoking a constructor with no arguments",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/new-parens"
+			},
+			fixable: "code",
+			schema: [{ enum: ["always", "never"] }],
+			messages: {
+				missing: "Missing '()' invoking a constructor.",
+				unnecessary: "Unnecessary '()' invoking a constructor with no arguments."
+			}
+		},
+		create(context) {
+			let always = context.options[0] !== "never", sourceCode = context.sourceCode;
+			return { NewExpression(node) {
+				if (node.arguments.length !== 0) return;
+				let lastToken = sourceCode.getLastToken(node), hasParens = lastToken && astUtils.isClosingParenToken(lastToken) && astUtils.isOpeningParenToken(sourceCode.getTokenBefore(lastToken)) && node.callee.range[1] < node.range[1];
+				always ? hasParens || context.report({
+					node,
+					messageId: "missing",
+					fix: (fixer) => fixer.insertTextAfter(node, "()")
+				}) : hasParens && context.report({
+					node,
+					messageId: "unnecessary",
+					fix: (fixer) => [
+						fixer.remove(sourceCode.getTokenBefore(lastToken)),
+						fixer.remove(lastToken),
+						fixer.insertTextBefore(node, "("),
+						fixer.insertTextAfter(node, ")")
+					]
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/new-parens.cjs
+module.exports = require_new_parens().create;
+//#endregion

package/rules/newline-after-var.cjs

@@ -0,0 +1,159 @@
+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/newline-after-var.js
+/**
+* @fileoverview Rule to check empty newline after "var" statement
+* @author Gopal Venkatesan
+* @deprecated in ESLint v4.0.0
+*/
+var require_newline_after_var = /* @__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 an empty line after variable declarations",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/newline-after-var"
+			},
+			schema: [{ enum: ["never", "always"] }],
+			fixable: "whitespace",
+			messages: {
+				expected: "Expected blank line after variable declarations.",
+				unexpected: "Unexpected blank line after variable declarations."
+			},
+			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, mode = context.options[0] === "never" ? "never" : "always", commentEndLine = sourceCode.getAllComments().reduce((result, token) => (result[token.loc.start.line] = token.loc.end.line, result), {});
+			/**
+			* Gets a token from the given node to compare line to the next statement.
+			*
+			* In general, the token is the last token of the node. However, the token is the second last token if the following conditions satisfy.
+			*
+			* - The last token is semicolon.
+			* - The semicolon is on a different line from the previous token of the semicolon.
+			*
+			* This behavior would address semicolon-less style code. e.g.:
+			*
+			*     var foo = 1
+			*
+			*     ;(a || b).doSomething()
+			* @param {ASTNode} node The node to get.
+			* @returns {Token} The token to compare line to the next statement.
+			*/
+			function getLastToken(node) {
+				let lastToken = sourceCode.getLastToken(node);
+				if (lastToken.type === "Punctuator" && lastToken.value === ";") {
+					let prevToken = sourceCode.getTokenBefore(lastToken);
+					if (prevToken.loc.end.line !== lastToken.loc.start.line) return prevToken;
+				}
+				return lastToken;
+			}
+			/**
+			* Determine if provided keyword is a variable declaration
+			* @private
+			* @param {string} keyword keyword to test
+			* @returns {boolean} True if `keyword` is a type of var
+			*/
+			function isVar(keyword) {
+				return keyword === "var" || keyword === "let" || keyword === "const";
+			}
+			/**
+			* Determine if provided keyword is a variant of for specifiers
+			* @private
+			* @param {string} keyword keyword to test
+			* @returns {boolean} True if `keyword` is a variant of for specifier
+			*/
+			function isForTypeSpecifier(keyword) {
+				return keyword === "ForStatement" || keyword === "ForInStatement" || keyword === "ForOfStatement";
+			}
+			/**
+			* Determine if provided keyword is an export specifiers
+			* @private
+			* @param {string} nodeType nodeType to test
+			* @returns {boolean} True if `nodeType` is an export specifier
+			*/
+			function isExportSpecifier(nodeType) {
+				return nodeType === "ExportNamedDeclaration" || nodeType === "ExportSpecifier" || nodeType === "ExportDefaultDeclaration" || nodeType === "ExportAllDeclaration";
+			}
+			/**
+			* Determine if provided node is the last of their parent block.
+			* @private
+			* @param {ASTNode} node node to test
+			* @returns {boolean} True if `node` is last of their parent block.
+			*/
+			function isLastNode(node) {
+				let token = sourceCode.getTokenAfter(node);
+				return !token || token.type === "Punctuator" && token.value === "}";
+			}
+			/**
+			* Gets the last line of a group of consecutive comments
+			* @param {number} commentStartLine The starting line of the group
+			* @returns {number} The number of the last comment line of the group
+			*/
+			function getLastCommentLineOfBlock(commentStartLine) {
+				let currentCommentEnd = commentEndLine[commentStartLine];
+				return commentEndLine[currentCommentEnd + 1] ? getLastCommentLineOfBlock(currentCommentEnd + 1) : currentCommentEnd;
+			}
+			/**
+			* Determine if a token starts more than one line after a comment ends
+			* @param {token} token The token being checked
+			* @param {integer} commentStartLine The line number on which the comment starts
+			* @returns {boolean} True if `token` does not start immediately after a comment
+			*/
+			function hasBlankLineAfterComment(token, commentStartLine) {
+				return token.loc.start.line > getLastCommentLineOfBlock(commentStartLine) + 1;
+			}
+			/**
+			* Checks that a blank line exists after a variable declaration when mode is
+			* set to "always", or checks that there is no blank line when mode is set
+			* to "never"
+			* @private
+			* @param {ASTNode} node `VariableDeclaration` node to test
+			* @returns {void}
+			*/
+			function checkForBlankLine(node) {
+				let lastToken = getLastToken(node), nextToken = lastToken === sourceCode.getLastToken(node) ? sourceCode.getTokenAfter(node) : sourceCode.getLastToken(node), nextLineNum = lastToken.loc.end.line + 1;
+				if (!nextToken || isForTypeSpecifier(node.parent.type) || isExportSpecifier(node.parent.type) || nextToken.type === "Keyword" && isVar(nextToken.value) || isLastNode(node)) return;
+				let noNextLineToken = nextToken.loc.start.line > nextLineNum, hasNextLineComment = commentEndLine[nextLineNum] !== void 0;
+				mode === "never" && noNextLineToken && !hasNextLineComment && context.report({
+					node,
+					messageId: "unexpected",
+					fix(fixer) {
+						let linesBetween = sourceCode.getText().slice(lastToken.range[1], nextToken.range[0]).split(astUtils.LINEBREAK_MATCHER);
+						return fixer.replaceTextRange([lastToken.range[1], nextToken.range[0]], `${linesBetween.slice(0, -1).join("")}\n${linesBetween.at(-1)}`);
+					}
+				}), mode === "always" && (!noNextLineToken || hasNextLineComment && !hasBlankLineAfterComment(nextToken, nextLineNum)) && context.report({
+					node,
+					messageId: "expected",
+					fix(fixer) {
+						return (noNextLineToken ? getLastCommentLineOfBlock(nextLineNum) : lastToken.loc.end.line) === nextToken.loc.start.line ? fixer.insertTextBefore(nextToken, "\n\n") : fixer.insertTextBeforeRange([nextToken.range[0] - nextToken.loc.start.column, nextToken.range[1]], "\n");
+					}
+				});
+			}
+			return { VariableDeclaration: checkForBlankLine };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/newline-after-var.cjs
+module.exports = require_newline_after_var().create;
+//#endregion

package/rules/newline-before-return.cjs

@@ -0,0 +1,128 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/newline-before-return.js
+/**
+* @fileoverview Rule to require newlines before `return` statement
+* @author Kai Cataldo
+* @deprecated in ESLint v4.0.0
+*/
+var require_newline_before_return = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "layout",
+			docs: {
+				description: "Require an empty line before `return` statements",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/newline-before-return"
+			},
+			fixable: "whitespace",
+			schema: [],
+			messages: { expected: "Expected newline before return statement." },
+			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;
+			/**
+			* Tests whether node is preceded by supplied tokens
+			* @param {ASTNode} node node to check
+			* @param {Array} testTokens array of tokens to test against
+			* @returns {boolean} Whether or not the node is preceded by one of the supplied tokens
+			* @private
+			*/
+			function isPrecededByTokens(node, testTokens) {
+				let tokenBefore = sourceCode.getTokenBefore(node);
+				return testTokens.includes(tokenBefore.value);
+			}
+			/**
+			* Checks whether node is the first node after statement or in block
+			* @param {ASTNode} node node to check
+			* @returns {boolean} Whether or not the node is the first node after statement or in block
+			* @private
+			*/
+			function isFirstNode(node) {
+				let parentType = node.parent.type;
+				return node.parent.body ? Array.isArray(node.parent.body) ? node.parent.body[0] === node : node.parent.body === node : parentType === "IfStatement" ? isPrecededByTokens(node, ["else", ")"]) : parentType === "DoWhileStatement" ? isPrecededByTokens(node, ["do"]) : parentType === "SwitchCase" ? isPrecededByTokens(node, [":"]) : isPrecededByTokens(node, [")"]);
+			}
+			/**
+			* Returns the number of lines of comments that precede the node
+			* @param {ASTNode} node node to check for overlapping comments
+			* @param {number} lineNumTokenBefore line number of previous token, to check for overlapping comments
+			* @returns {number} Number of lines of comments that precede the node
+			* @private
+			*/
+			function calcCommentLines(node, lineNumTokenBefore) {
+				let comments = sourceCode.getCommentsBefore(node), numLinesComments = 0;
+				return comments.length && comments.forEach((comment) => {
+					numLinesComments++, comment.type === "Block" && (numLinesComments += comment.loc.end.line - comment.loc.start.line), comment.loc.start.line === lineNumTokenBefore && numLinesComments--, comment.loc.end.line === node.loc.start.line && numLinesComments--;
+				}), numLinesComments;
+			}
+			/**
+			* Returns the line number of the token before the node that is passed in as an argument
+			* @param {ASTNode} node The node to use as the start of the calculation
+			* @returns {number} Line number of the token before `node`
+			* @private
+			*/
+			function getLineNumberOfTokenBefore(node) {
+				let tokenBefore = sourceCode.getTokenBefore(node), lineNumTokenBefore;
+				return lineNumTokenBefore = tokenBefore ? tokenBefore.loc.end.line : 0, lineNumTokenBefore;
+			}
+			/**
+			* Checks whether node is preceded by a newline
+			* @param {ASTNode} node node to check
+			* @returns {boolean} Whether or not the node is preceded by a newline
+			* @private
+			*/
+			function hasNewlineBefore(node) {
+				let lineNumNode = node.loc.start.line, lineNumTokenBefore = getLineNumberOfTokenBefore(node), commentLines = calcCommentLines(node, lineNumTokenBefore);
+				return lineNumNode - lineNumTokenBefore - commentLines > 1;
+			}
+			/**
+			* Checks whether it is safe to apply a fix to a given return statement.
+			*
+			* The fix is not considered safe if the given return statement has leading comments,
+			* as we cannot safely determine if the newline should be added before or after the comments.
+			* For more information, see: https://github.com/eslint/eslint/issues/5958#issuecomment-222767211
+			* @param {ASTNode} node The return statement node to check.
+			* @returns {boolean} `true` if it can fix the node.
+			* @private
+			*/
+			function canFix(node) {
+				let leadingComments = sourceCode.getCommentsBefore(node), lastLeadingComment = leadingComments.at(-1), tokenBefore = sourceCode.getTokenBefore(node);
+				return leadingComments.length === 0 || lastLeadingComment.loc.end.line === tokenBefore.loc.end.line && lastLeadingComment.loc.end.line !== node.loc.start.line;
+			}
+			return { ReturnStatement(node) {
+				!isFirstNode(node) && !hasNewlineBefore(node) && context.report({
+					node,
+					messageId: "expected",
+					fix(fixer) {
+						if (canFix(node)) {
+							let tokenBefore = sourceCode.getTokenBefore(node), newlines = node.loc.start.line === tokenBefore.loc.end.line ? "\n\n" : "\n";
+							return fixer.insertTextBefore(node, newlines);
+						}
+						return null;
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/newline-before-return.cjs
+module.exports = require_newline_before_return().create;
+//#endregion