oxlint-plugin-eslint 1.52.0

package/rules/array-callback-return.cjs

@@ -0,0 +1,262 @@
+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/array-callback-return.js
+/**
+* @fileoverview Rule to enforce return statements in callbacks of array's methods
+* @author Toru Nagashima
+*/
+var require_array_callback_return = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u, TARGET_METHODS = /^(?:every|filter|find(?:Last)?(?:Index)?|flatMap|forEach|map|reduce(?:Right)?|some|sort|toSorted)$/u;
+	/**
+	* Checks a given node is a member access which has the specified name's
+	* property.
+	* @param {ASTNode} node A node to check.
+	* @returns {boolean} `true` if the node is a member access which has
+	*      the specified name's property. The node may be a `(Chain|Member)Expression` node.
+	*/
+	function isTargetMethod(node) {
+		return astUtils.isSpecificMemberAccess(node, null, TARGET_METHODS);
+	}
+	/**
+	* Checks all segments in a set and returns true if any are reachable.
+	* @param {Set<CodePathSegment>} segments The segments to check.
+	* @returns {boolean} True if any segment is reachable; false otherwise.
+	*/
+	function isAnySegmentReachable(segments) {
+		for (let segment of segments) if (segment.reachable) return !0;
+		return !1;
+	}
+	/**
+	* Returns a human-legible description of an array method
+	* @param {string} arrayMethodName A method name to fully qualify
+	* @returns {string} the method name prefixed with `Array.` if it is a class method,
+	*      or else `Array.prototype.` if it is an instance method.
+	*/
+	function fullMethodName(arrayMethodName) {
+		return [
+			"from",
+			"of",
+			"isArray"
+		].includes(arrayMethodName) ? `Array.${arrayMethodName}` : `Array.prototype.${arrayMethodName}`;
+	}
+	/**
+	* Checks whether or not a given node is a function expression which is the
+	* callback of an array method, returning the method name.
+	* @param {ASTNode} node A node to check. This is one of
+	*      FunctionExpression or ArrowFunctionExpression.
+	* @returns {string} The method name if the node is a callback method,
+	*      null otherwise.
+	*/
+	function getArrayMethodName(node) {
+		let currentNode = node;
+		for (; currentNode;) {
+			let parent = currentNode.parent;
+			switch (parent.type) {
+				case "LogicalExpression":
+				case "ConditionalExpression":
+				case "ChainExpression":
+					currentNode = parent;
+					break;
+				case "ReturnStatement": {
+					let func = astUtils.getUpperFunction(parent);
+					if (func === null || !astUtils.isCallee(func)) return null;
+					currentNode = func.parent;
+					break;
+				}
+				case "CallExpression": return astUtils.isArrayFromMethod(parent.callee) && parent.arguments.length >= 2 && parent.arguments[1] === currentNode ? "from" : isTargetMethod(parent.callee) && parent.arguments.length >= 1 && parent.arguments[0] === currentNode ? astUtils.getStaticPropertyName(parent.callee) : null;
+				default: return null;
+			}
+		}
+		/* c8 ignore next */
+		return null;
+	}
+	/**
+	* Checks if the given node is a void expression.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} - `true` if the node is a void expression
+	*/
+	function isExpressionVoid(node) {
+		return node.type === "UnaryExpression" && node.operator === "void";
+	}
+	/**
+	* Fixes the linting error by prepending "void " to the given node
+	* @param {Object} sourceCode context given by context.sourceCode
+	* @param {ASTNode} node The node to fix.
+	* @param {Object} fixer The fixer object provided by ESLint.
+	* @returns {Array<Object>} - An array of fix objects to apply to the node.
+	*/
+	function voidPrependFixer(sourceCode, node, fixer) {
+		let requiresParens = astUtils.getPrecedence(node) < astUtils.getPrecedence({
+			type: "UnaryExpression",
+			operator: "void"
+		}) && !astUtils.isParenthesised(sourceCode, node), returnOrArrowToken = sourceCode.getTokenBefore(node, node.parent.type === "ArrowFunctionExpression" ? astUtils.isArrowToken : (token) => token.type === "Keyword" && token.value === "return"), firstToken = sourceCode.getTokenAfter(returnOrArrowToken), prependSpace = returnOrArrowToken.value === "return" && returnOrArrowToken.range[1] === firstToken.range[0];
+		return [fixer.insertTextBefore(firstToken, `${prependSpace ? " " : ""}void ${requiresParens ? "(" : ""}`), fixer.insertTextAfter(node, requiresParens ? ")" : "")];
+	}
+	/**
+	* Fixes the linting error by `wrapping {}` around the given node's body.
+	* @param {Object} sourceCode context given by context.sourceCode
+	* @param {ASTNode} node The node to fix.
+	* @param {Object} fixer The fixer object provided by ESLint.
+	* @returns {Array<Object>} - An array of fix objects to apply to the node.
+	*/
+	function curlyWrapFixer(sourceCode, node, fixer) {
+		let arrowToken = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken), firstToken = sourceCode.getTokenAfter(arrowToken), lastToken = sourceCode.getLastToken(node);
+		return [fixer.insertTextBefore(firstToken, "{"), fixer.insertTextAfter(lastToken, "}")];
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{
+				allowImplicit: !1,
+				checkForEach: !1,
+				allowVoid: !1
+			}],
+			docs: {
+				description: "Enforce `return` statements in callbacks of array methods",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/array-callback-return"
+			},
+			hasSuggestions: !0,
+			schema: [{
+				type: "object",
+				properties: {
+					allowImplicit: { type: "boolean" },
+					checkForEach: { type: "boolean" },
+					allowVoid: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				expectedAtEnd: "{{arrayMethodName}}() expects a value to be returned at the end of {{name}}.",
+				expectedInside: "{{arrayMethodName}}() expects a return value from {{name}}.",
+				expectedReturnValue: "{{arrayMethodName}}() expects a return value from {{name}}.",
+				expectedNoReturnValue: "{{arrayMethodName}}() expects no useless return value from {{name}}.",
+				wrapBraces: "Wrap the expression in `{}`.",
+				prependVoid: "Prepend `void` to the expression."
+			}
+		},
+		create(context) {
+			let [options] = context.options, sourceCode = context.sourceCode, funcInfo = {
+				arrayMethodName: null,
+				upper: null,
+				codePath: null,
+				hasReturn: !1,
+				shouldCheck: !1,
+				node: null
+			};
+			/**
+			* Checks whether or not the last code path segment is reachable.
+			* Then reports this function if the segment is reachable.
+			*
+			* If the last code path segment is reachable, there are paths which are not
+			* returned or thrown.
+			* @param {ASTNode} node A node to check.
+			* @returns {void}
+			*/
+			function checkLastSegment(node) {
+				if (!funcInfo.shouldCheck) return;
+				let messageAndSuggestions = {
+					messageId: "",
+					suggest: []
+				};
+				if (funcInfo.arrayMethodName === "forEach") {
+					if (options.checkForEach && node.type === "ArrowFunctionExpression" && node.expression) if (options.allowVoid) {
+						if (isExpressionVoid(node.body)) return;
+						messageAndSuggestions.messageId = "expectedNoReturnValue", messageAndSuggestions.suggest = [{
+							messageId: "wrapBraces",
+							fix(fixer) {
+								return curlyWrapFixer(sourceCode, node, fixer);
+							}
+						}, {
+							messageId: "prependVoid",
+							fix(fixer) {
+								return voidPrependFixer(sourceCode, node.body, fixer);
+							}
+						}];
+					} else messageAndSuggestions.messageId = "expectedNoReturnValue", messageAndSuggestions.suggest = [{
+						messageId: "wrapBraces",
+						fix(fixer) {
+							return curlyWrapFixer(sourceCode, node, fixer);
+						}
+					}];
+				} else node.body.type === "BlockStatement" && isAnySegmentReachable(funcInfo.currentSegments) && (messageAndSuggestions.messageId = funcInfo.hasReturn ? "expectedAtEnd" : "expectedInside");
+				if (messageAndSuggestions.messageId) {
+					let name = astUtils.getFunctionNameWithKind(node);
+					context.report({
+						node,
+						loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+						messageId: messageAndSuggestions.messageId,
+						data: {
+							name,
+							arrayMethodName: fullMethodName(funcInfo.arrayMethodName)
+						},
+						suggest: messageAndSuggestions.suggest.length === 0 ? null : messageAndSuggestions.suggest
+					});
+				}
+			}
+			return {
+				onCodePathStart(codePath, node) {
+					let methodName = null;
+					TARGET_NODE_TYPE.test(node.type) && (methodName = getArrayMethodName(node)), funcInfo = {
+						arrayMethodName: methodName,
+						upper: funcInfo,
+						codePath,
+						hasReturn: !1,
+						shouldCheck: methodName && !node.async && !node.generator,
+						node,
+						currentSegments: /* @__PURE__ */ new Set()
+					};
+				},
+				onCodePathEnd() {
+					funcInfo = funcInfo.upper;
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					funcInfo.currentSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				onCodePathSegmentStart(segment) {
+					funcInfo.currentSegments.add(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					funcInfo.currentSegments.delete(segment);
+				},
+				ReturnStatement(node) {
+					if (!funcInfo.shouldCheck) return;
+					funcInfo.hasReturn = !0;
+					let messageAndSuggestions = {
+						messageId: "",
+						suggest: []
+					};
+					if (funcInfo.arrayMethodName === "forEach") {
+						if (options.checkForEach && node.argument) if (options.allowVoid) {
+							if (isExpressionVoid(node.argument)) return;
+							messageAndSuggestions.messageId = "expectedNoReturnValue", messageAndSuggestions.suggest = [{
+								messageId: "prependVoid",
+								fix(fixer) {
+									return voidPrependFixer(sourceCode, node.argument, fixer);
+								}
+							}];
+						} else messageAndSuggestions.messageId = "expectedNoReturnValue";
+					} else !options.allowImplicit && !node.argument && (messageAndSuggestions.messageId = "expectedReturnValue");
+					messageAndSuggestions.messageId && context.report({
+						node,
+						messageId: messageAndSuggestions.messageId,
+						data: {
+							name: astUtils.getFunctionNameWithKind(funcInfo.node),
+							arrayMethodName: fullMethodName(funcInfo.arrayMethodName)
+						},
+						suggest: messageAndSuggestions.suggest.length === 0 ? null : messageAndSuggestions.suggest
+					});
+				},
+				"FunctionExpression:exit": checkLastSegment,
+				"ArrowFunctionExpression:exit": checkLastSegment
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/array-callback-return.cjs
+module.exports = require_array_callback_return().create;
+//#endregion

package/rules/array-element-newline.cjs

@@ -0,0 +1,178 @@
+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/array-element-newline.js
+/**
+* @fileoverview Rule to enforce line breaks after each array element
+* @author Jan Peer Stöcklmair <https://github.com/JPeer264>
+* @deprecated in ESLint v8.53.0
+*/
+var require_array_element_newline = /* @__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: "array-element-newline",
+						url: "https://eslint.style/rules/array-element-newline"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce line breaks after each array element",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/array-element-newline"
+			},
+			fixable: "whitespace",
+			schema: {
+				definitions: { basicConfig: { oneOf: [{ enum: [
+					"always",
+					"never",
+					"consistent"
+				] }, {
+					type: "object",
+					properties: {
+						multiline: { type: "boolean" },
+						minItems: {
+							type: ["integer", "null"],
+							minimum: 0
+						}
+					},
+					additionalProperties: !1
+				}] } },
+				type: "array",
+				items: [{ oneOf: [{ $ref: "#/definitions/basicConfig" }, {
+					type: "object",
+					properties: {
+						ArrayExpression: { $ref: "#/definitions/basicConfig" },
+						ArrayPattern: { $ref: "#/definitions/basicConfig" }
+					},
+					additionalProperties: !1,
+					minProperties: 1
+				}] }]
+			},
+			messages: {
+				unexpectedLineBreak: "There should be no linebreak here.",
+				missingLineBreak: "There should be a linebreak after this element."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			/**
+			* Normalizes a given option value.
+			* @param {string|Object|undefined} providedOption An option value to parse.
+			* @returns {{multiline: boolean, minItems: number}} Normalized option object.
+			*/
+			function normalizeOptionValue(providedOption) {
+				let consistent = !1, multiline = !1, minItems, option = providedOption || "always";
+				return !option || option === "always" || option.minItems === 0 ? minItems = 0 : option === "never" ? minItems = Infinity : option === "consistent" ? (consistent = !0, minItems = Infinity) : (multiline = !!option.multiline, minItems = option.minItems || Infinity), {
+					consistent,
+					multiline,
+					minItems
+				};
+			}
+			/**
+			* Normalizes a given option value.
+			* @param {string|Object|undefined} options An option value to parse.
+			* @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
+			*/
+			function normalizeOptions(options) {
+				if (options && (options.ArrayExpression || options.ArrayPattern)) {
+					let expressionOptions, patternOptions;
+					return options.ArrayExpression && (expressionOptions = normalizeOptionValue(options.ArrayExpression)), options.ArrayPattern && (patternOptions = normalizeOptionValue(options.ArrayPattern)), {
+						ArrayExpression: expressionOptions,
+						ArrayPattern: patternOptions
+					};
+				}
+				let value = normalizeOptionValue(options);
+				return {
+					ArrayExpression: value,
+					ArrayPattern: value
+				};
+			}
+			/**
+			* Reports that there shouldn't be a line break after the first token
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportNoLineBreak(token) {
+				let tokenBefore = sourceCode.getTokenBefore(token, { includeComments: !0 });
+				context.report({
+					loc: {
+						start: tokenBefore.loc.end,
+						end: token.loc.start
+					},
+					messageId: "unexpectedLineBreak",
+					fix(fixer) {
+						if (astUtils.isCommentToken(tokenBefore)) return null;
+						if (!astUtils.isTokenOnSameLine(tokenBefore, token)) return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " ");
+						let twoTokensBefore = sourceCode.getTokenBefore(tokenBefore, { includeComments: !0 });
+						return astUtils.isCommentToken(twoTokensBefore) ? null : fixer.replaceTextRange([twoTokensBefore.range[1], tokenBefore.range[0]], "");
+					}
+				});
+			}
+			/**
+			* Reports that there should be a line break after the first token
+			* @param {Token} token The token to use for the report.
+			* @returns {void}
+			*/
+			function reportRequiredLineBreak(token) {
+				let tokenBefore = sourceCode.getTokenBefore(token, { includeComments: !0 });
+				context.report({
+					loc: {
+						start: tokenBefore.loc.end,
+						end: token.loc.start
+					},
+					messageId: "missingLineBreak",
+					fix(fixer) {
+						return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], "\n");
+					}
+				});
+			}
+			/**
+			* Reports a given node if it violated this rule.
+			* @param {ASTNode} node A node to check. This is an ObjectExpression node or an ObjectPattern node.
+			* @returns {void}
+			*/
+			function check(node) {
+				let elements = node.elements, options = normalizeOptions(context.options[0])[node.type];
+				if (!options) return;
+				let elementBreak = !1;
+				options.multiline && (elementBreak = elements.filter((element) => element !== null).some((element) => element.loc.start.line !== element.loc.end.line));
+				let linebreaksCount = 0;
+				for (let i = 0; i < node.elements.length; i++) {
+					let element = node.elements[i], previousElement = elements[i - 1];
+					if (i === 0 || element === null || previousElement === null) continue;
+					let commaToken = sourceCode.getFirstTokenBetween(previousElement, element, astUtils.isCommaToken), lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken), firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
+					astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement) || linebreaksCount++;
+				}
+				let needsLinebreaks = elements.length >= options.minItems || options.multiline && elementBreak || options.consistent && linebreaksCount > 0 && linebreaksCount < node.elements.length;
+				elements.forEach((element, i) => {
+					let previousElement = elements[i - 1];
+					if (i === 0 || element === null || previousElement === null) return;
+					let commaToken = sourceCode.getFirstTokenBetween(previousElement, element, astUtils.isCommaToken), lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken), firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
+					needsLinebreaks ? astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement) && reportRequiredLineBreak(firstTokenOfCurrentElement) : astUtils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement) || reportNoLineBreak(firstTokenOfCurrentElement);
+				});
+			}
+			return {
+				ArrayPattern: check,
+				ArrayExpression: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/array-element-newline.cjs
+module.exports = require_array_element_newline().create;
+//#endregion

package/rules/arrow-body-style.cjs

@@ -0,0 +1,135 @@
+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/arrow-body-style.js
+/**
+* @fileoverview Rule to require braces in arrow function body.
+* @author Alberto Rodríguez
+*/
+var require_arrow_body_style = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["as-needed"],
+			docs: {
+				description: "Require braces around arrow function bodies",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/arrow-body-style"
+			},
+			schema: { anyOf: [{
+				type: "array",
+				items: [{ enum: ["always", "never"] }],
+				minItems: 0,
+				maxItems: 1
+			}, {
+				type: "array",
+				items: [{ enum: ["as-needed"] }, {
+					type: "object",
+					properties: { requireReturnForObjectLiteral: { type: "boolean" } },
+					additionalProperties: !1
+				}],
+				minItems: 0,
+				maxItems: 2
+			}] },
+			fixable: "code",
+			messages: {
+				unexpectedOtherBlock: "Unexpected block statement surrounding arrow body.",
+				unexpectedEmptyBlock: "Unexpected block statement surrounding arrow body; put a value of `undefined` immediately after the `=>`.",
+				unexpectedObjectBlock: "Unexpected block statement surrounding arrow body; parenthesize the returned value and move it immediately after the `=>`.",
+				unexpectedSingleBlock: "Unexpected block statement surrounding arrow body; move the returned value immediately after the `=>`.",
+				expectedBlock: "Expected block statement surrounding arrow body."
+			}
+		},
+		create(context) {
+			let options = context.options, always = options[0] === "always", asNeeded = options[0] === "as-needed", never = options[0] === "never", requireReturnForObjectLiteral = options[1] && options[1].requireReturnForObjectLiteral, sourceCode = context.sourceCode, funcInfo = null;
+			/**
+			* Checks whether the given node has ASI problem or not.
+			* @param {Token} token The token to check.
+			* @returns {boolean} `true` if it changes semantics if `;` or `}` followed by the token are removed.
+			*/
+			function hasASIProblem(token) {
+				return token && token.type === "Punctuator" && /^[([/`+-]/u.test(token.value);
+			}
+			/**
+			* Gets the closing parenthesis by the given node.
+			* @param {ASTNode} node first node after an opening parenthesis.
+			* @returns {Token} The found closing parenthesis token.
+			*/
+			function findClosingParen(node) {
+				let nodeToCheck = node;
+				for (; !astUtils.isParenthesised(sourceCode, nodeToCheck);) nodeToCheck = nodeToCheck.parent;
+				return sourceCode.getTokenAfter(nodeToCheck);
+			}
+			/**
+			* Check whether the node is inside of a for loop's init
+			* @param {ASTNode} node node is inside for loop
+			* @returns {boolean} `true` if the node is inside of a for loop, else `false`
+			*/
+			function isInsideForLoopInitializer(node) {
+				return node && node.parent ? node.parent.type === "ForStatement" && node.parent.init === node ? !0 : isInsideForLoopInitializer(node.parent) : !1;
+			}
+			/**
+			* Determines whether a arrow function body needs braces
+			* @param {ASTNode} node The arrow function node.
+			* @returns {void}
+			*/
+			function validate(node) {
+				let arrowBody = node.body;
+				if (arrowBody.type === "BlockStatement") {
+					let blockBody = arrowBody.body;
+					if (blockBody.length !== 1 && !never || asNeeded && requireReturnForObjectLiteral && blockBody[0].type === "ReturnStatement" && blockBody[0].argument && blockBody[0].argument.type === "ObjectExpression") return;
+					if (never || asNeeded && blockBody[0].type === "ReturnStatement") {
+						let messageId;
+						messageId = blockBody.length === 0 ? "unexpectedEmptyBlock" : blockBody.length > 1 || blockBody[0].type !== "ReturnStatement" ? "unexpectedOtherBlock" : blockBody[0].argument === null ? "unexpectedSingleBlock" : astUtils.isOpeningBraceToken(sourceCode.getFirstToken(blockBody[0], { skip: 1 })) ? "unexpectedObjectBlock" : "unexpectedSingleBlock", context.report({
+							node,
+							loc: arrowBody.loc,
+							messageId,
+							fix(fixer) {
+								let fixes = [];
+								if (blockBody.length !== 1 || blockBody[0].type !== "ReturnStatement" || !blockBody[0].argument || hasASIProblem(sourceCode.getTokenAfter(arrowBody))) return fixes;
+								let openingBrace = sourceCode.getFirstToken(arrowBody), closingBrace = sourceCode.getLastToken(arrowBody), firstValueToken = sourceCode.getFirstToken(blockBody[0], 1), lastValueToken = sourceCode.getLastToken(blockBody[0]);
+								return sourceCode.commentsExistBetween(openingBrace, firstValueToken) || sourceCode.commentsExistBetween(lastValueToken, closingBrace) ? fixes.push(fixer.remove(openingBrace), fixer.remove(closingBrace), fixer.remove(sourceCode.getTokenAfter(openingBrace))) : fixes.push(fixer.removeRange([openingBrace.range[0], firstValueToken.range[0]]), fixer.removeRange([lastValueToken.range[1], closingBrace.range[1]])), (astUtils.isOpeningBraceToken(firstValueToken) || blockBody[0].argument.type === "SequenceExpression" || funcInfo.hasInOperator && isInsideForLoopInitializer(node)) && (astUtils.isParenthesised(sourceCode, blockBody[0].argument) || fixes.push(fixer.insertTextBefore(firstValueToken, "("), fixer.insertTextAfter(lastValueToken, ")"))), astUtils.isSemicolonToken(lastValueToken) && fixes.push(fixer.remove(lastValueToken)), fixes;
+							}
+						});
+					}
+				} else (always || asNeeded && requireReturnForObjectLiteral && arrowBody.type === "ObjectExpression") && context.report({
+					node,
+					loc: arrowBody.loc,
+					messageId: "expectedBlock",
+					fix(fixer) {
+						let fixes = [], arrowToken = sourceCode.getTokenBefore(arrowBody, astUtils.isArrowToken), [firstTokenAfterArrow, secondTokenAfterArrow] = sourceCode.getTokensAfter(arrowToken, { count: 2 }), lastToken = sourceCode.getLastToken(node), parenthesisedObjectLiteral = null;
+						if (astUtils.isOpeningParenToken(firstTokenAfterArrow) && astUtils.isOpeningBraceToken(secondTokenAfterArrow)) {
+							let braceNode = sourceCode.getNodeByRangeIndex(secondTokenAfterArrow.range[0]);
+							braceNode.type === "ObjectExpression" && (parenthesisedObjectLiteral = braceNode);
+						}
+						if (parenthesisedObjectLiteral) {
+							let openingParenToken = firstTokenAfterArrow, openingBraceToken = secondTokenAfterArrow;
+							astUtils.isTokenOnSameLine(openingParenToken, openingBraceToken) ? fixes.push(fixer.replaceText(openingParenToken, "{return ")) : fixes.push(fixer.replaceText(openingParenToken, "{"), fixer.insertTextBefore(openingBraceToken, "return ")), fixes.push(fixer.remove(findClosingParen(parenthesisedObjectLiteral))), fixes.push(fixer.insertTextAfter(lastToken, "}"));
+						} else fixes.push(fixer.insertTextBefore(firstTokenAfterArrow, "{return ")), fixes.push(fixer.insertTextAfter(lastToken, "}"));
+						return fixes;
+					}
+				});
+			}
+			return {
+				"BinaryExpression[operator='in']"() {
+					let info = funcInfo;
+					for (; info;) info.hasInOperator = !0, info = info.upper;
+				},
+				ArrowFunctionExpression() {
+					funcInfo = {
+						upper: funcInfo,
+						hasInOperator: !1
+					};
+				},
+				"ArrowFunctionExpression:exit"(node) {
+					validate(node), funcInfo = funcInfo.upper;
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/arrow-body-style.cjs
+module.exports = require_arrow_body_style().create;
+//#endregion