oxlint-plugin-eslint 1.52.0

package/rules/arrow-parens.cjs

@@ -0,0 +1,130 @@
+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-parens.js
+/**
+* @fileoverview Rule to require parens in arrow function arguments.
+* @author Jxck
+* @deprecated in ESLint v8.53.0
+*/
+var require_arrow_parens = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Determines if the given arrow function has block body.
+	* @param {ASTNode} node `ArrowFunctionExpression` node.
+	* @returns {boolean} `true` if the function has block body.
+	*/
+	function hasBlockBody(node) {
+		return node.body.type === "BlockStatement";
+	}
+	/** @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: "arrow-parens",
+						url: "https://eslint.style/rules/arrow-parens"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Require parentheses around arrow function arguments",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/arrow-parens"
+			},
+			fixable: "code",
+			schema: [{ enum: ["always", "as-needed"] }, {
+				type: "object",
+				properties: { requireForBlockBody: {
+					type: "boolean",
+					default: !1
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpectedParens: "Unexpected parentheses around single function argument.",
+				expectedParens: "Expected parentheses around arrow function argument.",
+				unexpectedParensInline: "Unexpected parentheses around single function argument having a body with no curly braces.",
+				expectedParensBlock: "Expected parentheses around arrow function argument having a body with curly braces."
+			}
+		},
+		create(context) {
+			let asNeeded = context.options[0] === "as-needed", requireForBlockBody = asNeeded && context.options[1] && context.options[1].requireForBlockBody === !0, sourceCode = context.sourceCode;
+			/**
+			* Finds opening paren of parameters for the given arrow function, if it exists.
+			* It is assumed that the given arrow function has exactly one parameter.
+			* @param {ASTNode} node `ArrowFunctionExpression` node.
+			* @returns {Token|null} the opening paren, or `null` if the given arrow function doesn't have parens of parameters.
+			*/
+			function findOpeningParenOfParams(node) {
+				let tokenBeforeParams = sourceCode.getTokenBefore(node.params[0]);
+				return tokenBeforeParams && astUtils.isOpeningParenToken(tokenBeforeParams) && node.range[0] <= tokenBeforeParams.range[0] ? tokenBeforeParams : null;
+			}
+			/**
+			* Finds closing paren of parameters for the given arrow function.
+			* It is assumed that the given arrow function has parens of parameters and that it has exactly one parameter.
+			* @param {ASTNode} node `ArrowFunctionExpression` node.
+			* @returns {Token} the closing paren of parameters.
+			*/
+			function getClosingParenOfParams(node) {
+				return sourceCode.getTokenAfter(node.params[0], astUtils.isClosingParenToken);
+			}
+			/**
+			* Determines whether the given arrow function has comments inside parens of parameters.
+			* It is assumed that the given arrow function has parens of parameters.
+			* @param {ASTNode} node `ArrowFunctionExpression` node.
+			* @param {Token} openingParen Opening paren of parameters.
+			* @returns {boolean} `true` if the function has at least one comment inside of parens of parameters.
+			*/
+			function hasCommentsInParensOfParams(node, openingParen) {
+				return sourceCode.commentsExistBetween(openingParen, getClosingParenOfParams(node));
+			}
+			/**
+			* Determines whether the given arrow function has unexpected tokens before opening paren of parameters,
+			* in which case it will be assumed that the existing parens of parameters are necessary.
+			* Only tokens within the range of the arrow function (tokens that are part of the arrow function) are taken into account.
+			* Example: <T>(a) => b
+			* @param {ASTNode} node `ArrowFunctionExpression` node.
+			* @param {Token} openingParen Opening paren of parameters.
+			* @returns {boolean} `true` if the function has at least one unexpected token.
+			*/
+			function hasUnexpectedTokensBeforeOpeningParen(node, openingParen) {
+				let expectedCount = node.async ? 1 : 0;
+				return sourceCode.getFirstToken(node, { skip: expectedCount }) !== openingParen;
+			}
+			return { "ArrowFunctionExpression[params.length=1]"(node) {
+				let shouldHaveParens = !asNeeded || requireForBlockBody && hasBlockBody(node), openingParen = findOpeningParenOfParams(node), hasParens = openingParen !== null, [param] = node.params;
+				shouldHaveParens && !hasParens && context.report({
+					node,
+					messageId: requireForBlockBody ? "expectedParensBlock" : "expectedParens",
+					loc: param.loc,
+					*fix(fixer) {
+						yield fixer.insertTextBefore(param, "("), yield fixer.insertTextAfter(param, ")");
+					}
+				}), !shouldHaveParens && hasParens && param.type === "Identifier" && !param.typeAnnotation && !node.returnType && !hasCommentsInParensOfParams(node, openingParen) && !hasUnexpectedTokensBeforeOpeningParen(node, openingParen) && context.report({
+					node,
+					messageId: requireForBlockBody ? "unexpectedParensInline" : "unexpectedParens",
+					loc: param.loc,
+					*fix(fixer) {
+						let tokenBeforeOpeningParen = sourceCode.getTokenBefore(openingParen), closingParen = getClosingParenOfParams(node);
+						tokenBeforeOpeningParen && tokenBeforeOpeningParen.range[1] === openingParen.range[0] && !astUtils.canTokensBeAdjacent(tokenBeforeOpeningParen, sourceCode.getFirstToken(param)) && (yield fixer.insertTextBefore(openingParen, " ")), yield fixer.removeRange([openingParen.range[0], param.range[0]]), yield fixer.removeRange([param.range[1], closingParen.range[1]]);
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/arrow-parens.cjs
+module.exports = require_arrow_parens().create;
+//#endregion

package/rules/arrow-spacing.cjs

@@ -0,0 +1,129 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/arrow-spacing.js
+/**
+* @fileoverview Rule to define spacing before/after arrow function's arrow.
+* @author Jxck
+* @deprecated in ESLint v8.53.0
+*/
+var require_arrow_spacing = /* @__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: "arrow-spacing",
+						url: "https://eslint.style/rules/arrow-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent spacing before and after the arrow in arrow functions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/arrow-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					before: {
+						type: "boolean",
+						default: !0
+					},
+					after: {
+						type: "boolean",
+						default: !0
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: {
+				expectedBefore: "Missing space before =>.",
+				unexpectedBefore: "Unexpected space before =>.",
+				expectedAfter: "Missing space after =>.",
+				unexpectedAfter: "Unexpected space after =>."
+			}
+		},
+		create(context) {
+			let rule = Object.assign({}, context.options[0]);
+			rule.before = rule.before !== !1, rule.after = rule.after !== !1;
+			let sourceCode = context.sourceCode;
+			/**
+			* Get tokens of arrow(`=>`) and before/after arrow.
+			* @param {ASTNode} node The arrow function node.
+			* @returns {Object} Tokens of arrow and before/after arrow.
+			*/
+			function getTokens(node) {
+				let arrow = sourceCode.getTokenBefore(node.body, astUtils.isArrowToken);
+				return {
+					before: sourceCode.getTokenBefore(arrow),
+					arrow,
+					after: sourceCode.getTokenAfter(arrow)
+				};
+			}
+			/**
+			* Count spaces before/after arrow(`=>`) token.
+			* @param {Object} tokens Tokens before/after arrow.
+			* @returns {Object} count of space before/after arrow.
+			*/
+			function countSpaces(tokens) {
+				return {
+					before: tokens.arrow.range[0] - tokens.before.range[1],
+					after: tokens.after.range[0] - tokens.arrow.range[1]
+				};
+			}
+			/**
+			* Determines whether space(s) before after arrow(`=>`) is satisfy rule.
+			* if before/after value is `true`, there should be space(s).
+			* if before/after value is `false`, there should be no space.
+			* @param {ASTNode} node The arrow function node.
+			* @returns {void}
+			*/
+			function spaces(node) {
+				let tokens = getTokens(node), countSpace = countSpaces(tokens);
+				rule.before ? countSpace.before === 0 && context.report({
+					node: tokens.before,
+					messageId: "expectedBefore",
+					fix(fixer) {
+						return fixer.insertTextBefore(tokens.arrow, " ");
+					}
+				}) : countSpace.before > 0 && context.report({
+					node: tokens.before,
+					messageId: "unexpectedBefore",
+					fix(fixer) {
+						return fixer.removeRange([tokens.before.range[1], tokens.arrow.range[0]]);
+					}
+				}), rule.after ? countSpace.after === 0 && context.report({
+					node: tokens.after,
+					messageId: "expectedAfter",
+					fix(fixer) {
+						return fixer.insertTextAfter(tokens.arrow, " ");
+					}
+				}) : countSpace.after > 0 && context.report({
+					node: tokens.after,
+					messageId: "unexpectedAfter",
+					fix(fixer) {
+						return fixer.removeRange([tokens.arrow.range[1], tokens.after.range[0]]);
+					}
+				});
+			}
+			return { ArrowFunctionExpression: spaces };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/arrow-spacing.cjs
+module.exports = require_arrow_spacing().create;
+//#endregion

package/rules/block-scoped-var.cjs

@@ -0,0 +1,101 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/block-scoped-var.js
+/**
+* @fileoverview Rule to check for "block scoped" variables by binding context
+* @author Matt DuVall <http://www.mattduvall.com>
+*/
+var require_block_scoped_var = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce the use of variables within the scope they are defined",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/block-scoped-var"
+			},
+			schema: [],
+			messages: { outOfScope: "'{{name}}' declared on line {{definitionLine}} column {{definitionColumn}} is used outside of binding context." }
+		},
+		create(context) {
+			let stack = [], sourceCode = context.sourceCode;
+			/**
+			* Makes a block scope.
+			* @param {ASTNode} node A node of a scope.
+			* @returns {void}
+			*/
+			function enterScope(node) {
+				stack.push(node.range);
+			}
+			/**
+			* Pops the last block scope.
+			* @returns {void}
+			*/
+			function exitScope() {
+				stack.pop();
+			}
+			/**
+			* Reports a given reference.
+			* @param {eslint-scope.Reference} reference A reference to report.
+			* @param {eslint-scope.Definition} definition A definition for which to report reference.
+			* @returns {void}
+			*/
+			function report(reference, definition) {
+				let identifier = reference.identifier, definitionPosition = definition.name.loc.start;
+				context.report({
+					node: identifier,
+					messageId: "outOfScope",
+					data: {
+						name: identifier.name,
+						definitionLine: definitionPosition.line,
+						definitionColumn: definitionPosition.column + 1
+					}
+				});
+			}
+			/**
+			* Finds and reports references which are outside of valid scopes.
+			* @param {ASTNode} node A node to get variables.
+			* @returns {void}
+			*/
+			function checkForVariables(node) {
+				if (node.kind !== "var") return;
+				let scopeRange = stack.at(-1);
+				/**
+				* Check if a reference is out of scope
+				* @param {ASTNode} reference node to examine
+				* @returns {boolean} True is its outside the scope
+				* @private
+				*/
+				function isOutsideOfScope(reference) {
+					let idRange = reference.identifier.range;
+					return idRange[0] < scopeRange[0] || idRange[1] > scopeRange[1];
+				}
+				let variables = sourceCode.getDeclaredVariables(node);
+				for (let i = 0; i < variables.length; ++i) variables[i].references.filter(isOutsideOfScope).forEach((ref) => report(ref, variables[i].defs.find((def) => def.parent === node)));
+			}
+			return {
+				Program(node) {
+					stack = [node.range];
+				},
+				BlockStatement: enterScope,
+				"BlockStatement:exit": exitScope,
+				ForStatement: enterScope,
+				"ForStatement:exit": exitScope,
+				ForInStatement: enterScope,
+				"ForInStatement:exit": exitScope,
+				ForOfStatement: enterScope,
+				"ForOfStatement:exit": exitScope,
+				SwitchStatement: enterScope,
+				"SwitchStatement:exit": exitScope,
+				CatchClause: enterScope,
+				"CatchClause:exit": exitScope,
+				StaticBlock: enterScope,
+				"StaticBlock:exit": exitScope,
+				VariableDeclaration: checkForVariables
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/block-scoped-var.cjs
+module.exports = require_block_scoped_var().create;
+//#endregion

package/rules/block-spacing.cjs

@@ -0,0 +1,125 @@
+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/block-spacing.js
+/**
+* @fileoverview A rule to disallow or enforce spaces inside of single line blocks.
+* @author Toru Nagashima
+* @deprecated in ESLint v8.53.0
+*/
+var require_block_spacing = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let util = 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: "block-spacing",
+						url: "https://eslint.style/rules/block-spacing"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow or enforce spaces inside of blocks after opening block and before closing block",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/block-spacing"
+			},
+			fixable: "whitespace",
+			schema: [{ enum: ["always", "never"] }],
+			messages: {
+				missing: "Requires a space {{location}} '{{token}}'.",
+				extra: "Unexpected space(s) {{location}} '{{token}}'."
+			}
+		},
+		create(context) {
+			let always = context.options[0] !== "never", messageId = always ? "missing" : "extra", sourceCode = context.sourceCode;
+			/**
+			* Gets the open brace token from a given node.
+			* @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to get.
+			* @returns {Token} The token of the open brace.
+			*/
+			function getOpenBrace(node) {
+				return node.type === "SwitchStatement" ? node.cases.length > 0 ? sourceCode.getTokenBefore(node.cases[0]) : sourceCode.getLastToken(node, 1) : node.type === "StaticBlock" ? sourceCode.getFirstToken(node, { skip: 1 }) : sourceCode.getFirstToken(node);
+			}
+			/**
+			* Checks whether or not:
+			*   - given tokens are on same line.
+			*   - there is/isn't a space between given tokens.
+			* @param {Token} left A token to check.
+			* @param {Token} right The token which is next to `left`.
+			* @returns {boolean}
+			*    When the option is `"always"`, `true` if there are one or more spaces between given tokens.
+			*    When the option is `"never"`, `true` if there are not any spaces between given tokens.
+			*    If given tokens are not on same line, it's always `true`.
+			*/
+			function isValid(left, right) {
+				return !util.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetweenTokens(left, right) === always;
+			}
+			/**
+			* Checks and reports invalid spacing style inside braces.
+			* @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to check.
+			* @returns {void}
+			*/
+			function checkSpacingInsideBraces(node) {
+				let openBrace = getOpenBrace(node), closeBrace = sourceCode.getLastToken(node), firstToken = sourceCode.getTokenAfter(openBrace, { includeComments: !0 }), lastToken = sourceCode.getTokenBefore(closeBrace, { includeComments: !0 });
+				if (!(openBrace.type !== "Punctuator" || openBrace.value !== "{" || closeBrace.type !== "Punctuator" || closeBrace.value !== "}" || firstToken === closeBrace) && !(!always && firstToken.type === "Line")) {
+					if (!isValid(openBrace, firstToken)) {
+						let loc = openBrace.loc;
+						messageId === "extra" && (loc = {
+							start: openBrace.loc.end,
+							end: firstToken.loc.start
+						}), context.report({
+							node,
+							loc,
+							messageId,
+							data: {
+								location: "after",
+								token: openBrace.value
+							},
+							fix(fixer) {
+								return always ? fixer.insertTextBefore(firstToken, " ") : fixer.removeRange([openBrace.range[1], firstToken.range[0]]);
+							}
+						});
+					}
+					if (!isValid(lastToken, closeBrace)) {
+						let loc = closeBrace.loc;
+						messageId === "extra" && (loc = {
+							start: lastToken.loc.end,
+							end: closeBrace.loc.start
+						}), context.report({
+							node,
+							loc,
+							messageId,
+							data: {
+								location: "before",
+								token: closeBrace.value
+							},
+							fix(fixer) {
+								return always ? fixer.insertTextAfter(lastToken, " ") : fixer.removeRange([lastToken.range[1], closeBrace.range[0]]);
+							}
+						});
+					}
+				}
+			}
+			return {
+				BlockStatement: checkSpacingInsideBraces,
+				StaticBlock: checkSpacingInsideBraces,
+				SwitchStatement: checkSpacingInsideBraces
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/block-spacing.cjs
+module.exports = require_block_spacing().create;
+//#endregion

package/rules/brace-style.cjs

@@ -0,0 +1,141 @@
+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/brace-style.js
+/**
+* @fileoverview Rule to flag block statements that do not use the one true brace style
+* @author Ian Christian Myers
+* @deprecated in ESLint v8.53.0
+*/
+var require_brace_style = /* @__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: "brace-style",
+						url: "https://eslint.style/rules/brace-style"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent brace style for blocks",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/brace-style"
+			},
+			schema: [{ enum: [
+				"1tbs",
+				"stroustrup",
+				"allman"
+			] }, {
+				type: "object",
+				properties: { allowSingleLine: {
+					type: "boolean",
+					default: !1
+				} },
+				additionalProperties: !1
+			}],
+			fixable: "whitespace",
+			messages: {
+				nextLineOpen: "Opening curly brace does not appear on the same line as controlling statement.",
+				sameLineOpen: "Opening curly brace appears on the same line as controlling statement.",
+				blockSameLine: "Statement inside of curly braces should be on next line.",
+				nextLineClose: "Closing curly brace does not appear on the same line as the subsequent block.",
+				singleLineClose: "Closing curly brace should be on the same line as opening curly brace or on the line after the previous block.",
+				sameLineClose: "Closing curly brace appears on the same line as the subsequent block."
+			}
+		},
+		create(context) {
+			let style = context.options[0] || "1tbs", params = context.options[1] || {}, sourceCode = context.sourceCode;
+			/**
+			* Fixes a place where a newline unexpectedly appears
+			* @param {Token} firstToken The token before the unexpected newline
+			* @param {Token} secondToken The token after the unexpected newline
+			* @returns {Function} A fixer function to remove the newlines between the tokens
+			*/
+			function removeNewlineBetween(firstToken, secondToken) {
+				let textRange = [firstToken.range[1], secondToken.range[0]];
+				return sourceCode.text.slice(textRange[0], textRange[1]).trim() ? null : (fixer) => fixer.replaceTextRange(textRange, " ");
+			}
+			/**
+			* Validates a pair of curly brackets based on the user's config
+			* @param {Token} openingCurly The opening curly bracket
+			* @param {Token} closingCurly The closing curly bracket
+			* @returns {void}
+			*/
+			function validateCurlyPair(openingCurly, closingCurly) {
+				let tokenBeforeOpeningCurly = sourceCode.getTokenBefore(openingCurly), tokenAfterOpeningCurly = sourceCode.getTokenAfter(openingCurly), tokenBeforeClosingCurly = sourceCode.getTokenBefore(closingCurly), singleLineException = params.allowSingleLine && astUtils.isTokenOnSameLine(openingCurly, closingCurly);
+				style !== "allman" && !astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly) && context.report({
+					node: openingCurly,
+					messageId: "nextLineOpen",
+					fix: removeNewlineBetween(tokenBeforeOpeningCurly, openingCurly)
+				}), style === "allman" && astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly) && !singleLineException && context.report({
+					node: openingCurly,
+					messageId: "sameLineOpen",
+					fix: (fixer) => fixer.insertTextBefore(openingCurly, "\n")
+				}), astUtils.isTokenOnSameLine(openingCurly, tokenAfterOpeningCurly) && tokenAfterOpeningCurly !== closingCurly && !singleLineException && context.report({
+					node: openingCurly,
+					messageId: "blockSameLine",
+					fix: (fixer) => fixer.insertTextAfter(openingCurly, "\n")
+				}), tokenBeforeClosingCurly !== openingCurly && !singleLineException && astUtils.isTokenOnSameLine(tokenBeforeClosingCurly, closingCurly) && context.report({
+					node: closingCurly,
+					messageId: "singleLineClose",
+					fix: (fixer) => fixer.insertTextBefore(closingCurly, "\n")
+				});
+			}
+			/**
+			* Validates the location of a token that appears before a keyword (e.g. a newline before `else`)
+			* @param {Token} curlyToken The closing curly token. This is assumed to precede a keyword token (such as `else` or `finally`).
+			* @returns {void}
+			*/
+			function validateCurlyBeforeKeyword(curlyToken) {
+				let keywordToken = sourceCode.getTokenAfter(curlyToken);
+				style === "1tbs" && !astUtils.isTokenOnSameLine(curlyToken, keywordToken) && context.report({
+					node: curlyToken,
+					messageId: "nextLineClose",
+					fix: removeNewlineBetween(curlyToken, keywordToken)
+				}), style !== "1tbs" && astUtils.isTokenOnSameLine(curlyToken, keywordToken) && context.report({
+					node: curlyToken,
+					messageId: "sameLineClose",
+					fix: (fixer) => fixer.insertTextAfter(curlyToken, "\n")
+				});
+			}
+			return {
+				BlockStatement(node) {
+					astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type) || validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
+				},
+				StaticBlock(node) {
+					validateCurlyPair(sourceCode.getFirstToken(node, { skip: 1 }), sourceCode.getLastToken(node));
+				},
+				ClassBody(node) {
+					validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
+				},
+				SwitchStatement(node) {
+					let closingCurly = sourceCode.getLastToken(node);
+					validateCurlyPair(sourceCode.getTokenBefore(node.cases.length ? node.cases[0] : closingCurly), closingCurly);
+				},
+				IfStatement(node) {
+					node.consequent.type === "BlockStatement" && node.alternate && validateCurlyBeforeKeyword(sourceCode.getLastToken(node.consequent));
+				},
+				TryStatement(node) {
+					validateCurlyBeforeKeyword(sourceCode.getLastToken(node.block)), node.handler && node.finalizer && validateCurlyBeforeKeyword(sourceCode.getLastToken(node.handler.body));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/brace-style.cjs
+module.exports = require_brace_style().create;
+//#endregion