oxlint-plugin-eslint 1.52.0

package/rules/one-var.cjs

@@ -0,0 +1,378 @@
+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/one-var.js
+/**
+* @fileoverview A rule to control the use of single variable declarations.
+* @author Ian Christian Myers
+*/
+var require_one_var = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Determines whether the given node is in a statement list.
+	* @param {ASTNode} node node to check
+	* @returns {boolean} `true` if the given node is in a statement list
+	*/
+	function isInStatementList(node) {
+		return astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type);
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Enforce variables to be declared either together or separately in functions",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/one-var"
+			},
+			fixable: "code",
+			schema: [{ oneOf: [
+				{ enum: [
+					"always",
+					"never",
+					"consecutive"
+				] },
+				{
+					type: "object",
+					properties: {
+						separateRequires: { type: "boolean" },
+						var: { enum: [
+							"always",
+							"never",
+							"consecutive"
+						] },
+						let: { enum: [
+							"always",
+							"never",
+							"consecutive"
+						] },
+						const: { enum: [
+							"always",
+							"never",
+							"consecutive"
+						] },
+						using: { enum: [
+							"always",
+							"never",
+							"consecutive"
+						] },
+						awaitUsing: { enum: [
+							"always",
+							"never",
+							"consecutive"
+						] }
+					},
+					additionalProperties: !1
+				},
+				{
+					type: "object",
+					properties: {
+						initialized: { enum: [
+							"always",
+							"never",
+							"consecutive"
+						] },
+						uninitialized: { enum: [
+							"always",
+							"never",
+							"consecutive"
+						] }
+					},
+					additionalProperties: !1
+				}
+			] }],
+			messages: {
+				combineUninitialized: "Combine this with the previous '{{type}}' statement with uninitialized variables.",
+				combineInitialized: "Combine this with the previous '{{type}}' statement with initialized variables.",
+				splitUninitialized: "Split uninitialized '{{type}}' declarations into multiple statements.",
+				splitInitialized: "Split initialized '{{type}}' declarations into multiple statements.",
+				splitRequires: "Split requires to be separated into a single block.",
+				combine: "Combine this with the previous '{{type}}' statement.",
+				split: "Split '{{type}}' declarations into multiple statements."
+			}
+		},
+		create(context) {
+			let MODE_ALWAYS = "always", MODE_NEVER = "never", MODE_CONSECUTIVE = "consecutive", mode = context.options[0] || MODE_ALWAYS, options = {};
+			typeof mode == "string" ? (options.var = {
+				uninitialized: mode,
+				initialized: mode
+			}, options.let = {
+				uninitialized: mode,
+				initialized: mode
+			}, options.const = {
+				uninitialized: mode,
+				initialized: mode
+			}, options.using = {
+				uninitialized: mode,
+				initialized: mode
+			}, options.awaitUsing = {
+				uninitialized: mode,
+				initialized: mode
+			}) : typeof mode == "object" && (options.separateRequires = !!mode.separateRequires, options.var = {
+				uninitialized: mode.var,
+				initialized: mode.var
+			}, options.let = {
+				uninitialized: mode.let,
+				initialized: mode.let
+			}, options.const = {
+				uninitialized: mode.const,
+				initialized: mode.const
+			}, options.using = {
+				uninitialized: mode.using,
+				initialized: mode.using
+			}, options.awaitUsing = {
+				uninitialized: mode.awaitUsing,
+				initialized: mode.awaitUsing
+			}, Object.hasOwn(mode, "uninitialized") && (options.var.uninitialized = mode.uninitialized, options.let.uninitialized = mode.uninitialized, options.const.uninitialized = mode.uninitialized, options.using.uninitialized = mode.uninitialized, options.awaitUsing.uninitialized = mode.uninitialized), Object.hasOwn(mode, "initialized") && (options.var.initialized = mode.initialized, options.let.initialized = mode.initialized, options.const.initialized = mode.initialized, options.using.initialized = mode.initialized, options.awaitUsing.initialized = mode.initialized));
+			let sourceCode = context.sourceCode, functionStack = [], blockStack = [];
+			/**
+			* Increments the blockStack counter.
+			* @returns {void}
+			* @private
+			*/
+			function startBlock() {
+				blockStack.push({
+					let: {
+						initialized: !1,
+						uninitialized: !1
+					},
+					const: {
+						initialized: !1,
+						uninitialized: !1
+					},
+					using: {
+						initialized: !1,
+						uninitialized: !1
+					},
+					awaitUsing: {
+						initialized: !1,
+						uninitialized: !1
+					}
+				});
+			}
+			/**
+			* Increments the functionStack counter.
+			* @returns {void}
+			* @private
+			*/
+			function startFunction() {
+				functionStack.push({
+					initialized: !1,
+					uninitialized: !1
+				}), startBlock();
+			}
+			/**
+			* Decrements the blockStack counter.
+			* @returns {void}
+			* @private
+			*/
+			function endBlock() {
+				blockStack.pop();
+			}
+			/**
+			* Decrements the functionStack counter.
+			* @returns {void}
+			* @private
+			*/
+			function endFunction() {
+				functionStack.pop(), endBlock();
+			}
+			/**
+			* Check if a variable declaration is a require.
+			* @param {ASTNode} decl variable declaration Node
+			* @returns {bool} if decl is a require, return true; else return false.
+			* @private
+			*/
+			function isRequire(decl) {
+				return decl.init && decl.init.type === "CallExpression" && decl.init.callee.name === "require";
+			}
+			/**
+			* Records whether initialized/uninitialized/required variables are defined in current scope.
+			* @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
+			* @param {ASTNode[]} declarations List of declarations
+			* @param {Object} currentScope The scope being investigated
+			* @returns {void}
+			* @private
+			*/
+			function recordTypes(statementType, declarations, currentScope) {
+				for (let i = 0; i < declarations.length; i++) declarations[i].init === null ? options[statementType] && options[statementType].uninitialized === MODE_ALWAYS && (currentScope.uninitialized = !0) : options[statementType] && options[statementType].initialized === MODE_ALWAYS && (options.separateRequires && isRequire(declarations[i]) ? currentScope.required = !0 : currentScope.initialized = !0);
+			}
+			/**
+			* Determines the current scope (function or block)
+			* @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
+			* @returns {Object} The scope associated with statementType
+			*/
+			function getCurrentScope(statementType) {
+				let currentScope;
+				return statementType === "var" ? currentScope = functionStack.at(-1) : statementType === "let" ? currentScope = blockStack.at(-1).let : statementType === "const" ? currentScope = blockStack.at(-1).const : statementType === "using" ? currentScope = blockStack.at(-1).using : statementType === "awaitUsing" && (currentScope = blockStack.at(-1).awaitUsing), currentScope;
+			}
+			/**
+			* Counts the number of initialized and uninitialized declarations in a list of declarations
+			* @param {ASTNode[]} declarations List of declarations
+			* @returns {Object} Counts of 'uninitialized' and 'initialized' declarations
+			* @private
+			*/
+			function countDeclarations(declarations) {
+				let counts = {
+					uninitialized: 0,
+					initialized: 0
+				};
+				for (let i = 0; i < declarations.length; i++) declarations[i].init === null ? counts.uninitialized++ : counts.initialized++;
+				return counts;
+			}
+			/**
+			* Determines if there is more than one var statement in the current scope.
+			* @param {string} statementType one of: "var", "let", "const", "using", or "awaitUsing"
+			* @param {ASTNode[]} declarations List of declarations
+			* @returns {boolean} Returns true if it is the first var declaration, false if not.
+			* @private
+			*/
+			function hasOnlyOneStatement(statementType, declarations) {
+				let declarationCounts = countDeclarations(declarations), currentOptions = options[statementType] || {}, currentScope = getCurrentScope(statementType), hasRequires = declarations.some(isRequire);
+				return currentOptions.uninitialized === MODE_ALWAYS && currentOptions.initialized === MODE_ALWAYS && (currentScope.uninitialized || currentScope.initialized) && !hasRequires || declarationCounts.uninitialized > 0 && currentOptions.uninitialized === MODE_ALWAYS && currentScope.uninitialized || declarationCounts.initialized > 0 && currentOptions.initialized === MODE_ALWAYS && currentScope.initialized && !hasRequires || currentScope.required && hasRequires ? !1 : (recordTypes(statementType, declarations, currentScope), !0);
+			}
+			/**
+			* Fixer to join VariableDeclaration's into a single declaration
+			* @param {VariableDeclarator[]} declarations The `VariableDeclaration` to join
+			* @returns {Function} The fixer function
+			*/
+			function joinDeclarations(declarations) {
+				let declaration = declarations[0], body = Array.isArray(declaration.parent.parent.body) ? declaration.parent.parent.body : [], previousNode = body[body.findIndex((node) => node.range[0] === declaration.parent.range[0]) - 1];
+				return function* joinDeclarationsFixer(fixer) {
+					let type = sourceCode.getFirstToken(declaration.parent), beforeType = sourceCode.getTokenBefore(type);
+					if (previousNode && previousNode.kind === declaration.parent.kind) {
+						if (beforeType.value === ";" ? yield fixer.replaceText(beforeType, ",") : yield fixer.insertTextAfter(beforeType, ","), declaration.parent.kind === "await using") {
+							let usingToken = sourceCode.getTokenAfter(type);
+							yield fixer.remove(usingToken);
+						}
+						yield fixer.replaceText(type, "");
+					}
+				};
+			}
+			/**
+			* Fixer to split a VariableDeclaration into individual declarations
+			* @param {VariableDeclaration} declaration The `VariableDeclaration` to split
+			* @returns {Function|null} The fixer function
+			*/
+			function splitDeclarations(declaration) {
+				let { parent } = declaration;
+				return isInStatementList(parent.type === "ExportNamedDeclaration" ? parent : declaration) ? (fixer) => declaration.declarations.map((declarator) => {
+					let tokenAfterDeclarator = sourceCode.getTokenAfter(declarator);
+					if (tokenAfterDeclarator === null) return null;
+					let afterComma = sourceCode.getTokenAfter(tokenAfterDeclarator, { includeComments: !0 });
+					if (tokenAfterDeclarator.value !== ",") return null;
+					let exportPlacement = declaration.parent.type === "ExportNamedDeclaration" ? "export " : "";
+					if (afterComma.range[0] === tokenAfterDeclarator.range[1]) return fixer.replaceText(tokenAfterDeclarator, `; ${exportPlacement}${declaration.kind} `);
+					if (afterComma.loc.start.line > tokenAfterDeclarator.loc.end.line || afterComma.type === "Line" || afterComma.type === "Block") {
+						let lastComment = afterComma;
+						for (; lastComment.type === "Line" || lastComment.type === "Block";) lastComment = sourceCode.getTokenAfter(lastComment, { includeComments: !0 });
+						return fixer.replaceTextRange([tokenAfterDeclarator.range[0], lastComment.range[0]], `;${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}${exportPlacement}${declaration.kind} `);
+					}
+					return fixer.replaceText(tokenAfterDeclarator, `; ${exportPlacement}${declaration.kind}`);
+				}).filter((x) => x) : null;
+			}
+			/**
+			* Checks a given VariableDeclaration node for errors.
+			* @param {ASTNode} node The VariableDeclaration node to check
+			* @returns {void}
+			* @private
+			*/
+			function checkVariableDeclaration(node) {
+				let parent = node.parent, type = node.kind, key = type === "await using" ? "awaitUsing" : type;
+				if (!options[key]) return;
+				let declarations = node.declarations, declarationCounts = countDeclarations(declarations), mixedRequires = declarations.some(isRequire) && !declarations.every(isRequire);
+				options[key].initialized === MODE_ALWAYS && options.separateRequires && mixedRequires && context.report({
+					node,
+					messageId: "splitRequires"
+				});
+				let nodeIndex = parent.body && parent.body.length > 0 && parent.body.indexOf(node) || 0;
+				if (nodeIndex > 0) {
+					let previousNode = parent.body[nodeIndex - 1], isPreviousNodeDeclaration = previousNode.type === "VariableDeclaration", declarationsWithPrevious = declarations.concat(previousNode.declarations || []);
+					if (isPreviousNodeDeclaration && previousNode.kind === type && !(declarationsWithPrevious.some(isRequire) && !declarationsWithPrevious.every(isRequire))) {
+						let previousDeclCounts = countDeclarations(previousNode.declarations);
+						options[key].initialized === MODE_CONSECUTIVE && options[key].uninitialized === MODE_CONSECUTIVE ? context.report({
+							node,
+							messageId: "combine",
+							data: { type },
+							fix: joinDeclarations(declarations)
+						}) : options[key].initialized === MODE_CONSECUTIVE && declarationCounts.initialized > 0 && previousDeclCounts.initialized > 0 ? context.report({
+							node,
+							messageId: "combineInitialized",
+							data: { type },
+							fix: joinDeclarations(declarations)
+						}) : options[key].uninitialized === MODE_CONSECUTIVE && declarationCounts.uninitialized > 0 && previousDeclCounts.uninitialized > 0 && context.report({
+							node,
+							messageId: "combineUninitialized",
+							data: { type },
+							fix: joinDeclarations(declarations)
+						});
+					}
+				}
+				if (!hasOnlyOneStatement(key, declarations)) {
+					if (options[key].initialized === MODE_ALWAYS && options[key].uninitialized === MODE_ALWAYS) context.report({
+						node,
+						messageId: "combine",
+						data: { type },
+						fix: joinDeclarations(declarations)
+					});
+					else if (options[key].initialized === MODE_ALWAYS && declarationCounts.initialized > 0 && context.report({
+						node,
+						messageId: "combineInitialized",
+						data: { type },
+						fix: joinDeclarations(declarations)
+					}), options[key].uninitialized === MODE_ALWAYS && declarationCounts.uninitialized > 0) {
+						if (node.parent.left === node && (node.parent.type === "ForInStatement" || node.parent.type === "ForOfStatement")) return;
+						context.report({
+							node,
+							messageId: "combineUninitialized",
+							data: { type },
+							fix: joinDeclarations(declarations)
+						});
+					}
+				}
+				(parent.type !== "ForStatement" || parent.init !== node) && declarationCounts.uninitialized + declarationCounts.initialized > 1 && (options[key].initialized === MODE_NEVER && options[key].uninitialized === MODE_NEVER ? context.report({
+					node,
+					messageId: "split",
+					data: { type },
+					fix: splitDeclarations(node)
+				}) : options[key].initialized === MODE_NEVER && declarationCounts.initialized > 0 ? context.report({
+					node,
+					messageId: "splitInitialized",
+					data: { type },
+					fix: splitDeclarations(node)
+				}) : options[key].uninitialized === MODE_NEVER && declarationCounts.uninitialized > 0 && context.report({
+					node,
+					messageId: "splitUninitialized",
+					data: { type },
+					fix: splitDeclarations(node)
+				}));
+			}
+			return {
+				Program: startFunction,
+				FunctionDeclaration: startFunction,
+				FunctionExpression: startFunction,
+				ArrowFunctionExpression: startFunction,
+				StaticBlock: startFunction,
+				BlockStatement: startBlock,
+				ForStatement: startBlock,
+				ForInStatement: startBlock,
+				ForOfStatement: startBlock,
+				SwitchStatement: startBlock,
+				VariableDeclaration: checkVariableDeclaration,
+				"ForStatement:exit": endBlock,
+				"ForOfStatement:exit": endBlock,
+				"ForInStatement:exit": endBlock,
+				"SwitchStatement:exit": endBlock,
+				"BlockStatement:exit": endBlock,
+				"Program:exit": endFunction,
+				"FunctionDeclaration:exit": endFunction,
+				"FunctionExpression:exit": endFunction,
+				"ArrowFunctionExpression:exit": endFunction,
+				"StaticBlock:exit": endFunction
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/one-var.cjs
+module.exports = require_one_var().create;
+//#endregion

package/rules/operator-assignment.cjs

@@ -0,0 +1,146 @@
+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/operator-assignment.js
+/**
+* @fileoverview Rule to replace assignment expressions with operator assignment
+* @author Brandon Mills
+*/
+var require_operator_assignment = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether an operator is commutative and has an operator assignment
+	* shorthand form.
+	* @param {string} operator Operator to check.
+	* @returns {boolean} True if the operator is commutative and has a
+	*     shorthand form.
+	*/
+	function isCommutativeOperatorWithShorthand(operator) {
+		return [
+			"*",
+			"&",
+			"^",
+			"|"
+		].includes(operator);
+	}
+	/**
+	* Checks whether an operator is not commutative and has an operator assignment
+	* shorthand form.
+	* @param {string} operator Operator to check.
+	* @returns {boolean} True if the operator is not commutative and has
+	*     a shorthand form.
+	*/
+	function isNonCommutativeOperatorWithShorthand(operator) {
+		return [
+			"+",
+			"-",
+			"/",
+			"%",
+			"<<",
+			">>",
+			">>>",
+			"**"
+		].includes(operator);
+	}
+	/**
+	* Determines if the left side of a node can be safely fixed (i.e. if it activates the same getters/setters and)
+	* toString calls regardless of whether assignment shorthand is used)
+	* @param {ASTNode} node The node on the left side of the expression
+	* @returns {boolean} `true` if the node can be fixed
+	*/
+	function canBeFixed(node) {
+		return node.type === "Identifier" || node.type === "MemberExpression" && (node.object.type === "Identifier" || node.object.type === "ThisExpression") && (!node.computed || node.property.type === "Literal");
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: ["always"],
+			docs: {
+				description: "Require or disallow assignment operator shorthand where possible",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/operator-assignment"
+			},
+			schema: [{ enum: ["always", "never"] }],
+			fixable: "code",
+			messages: {
+				replaced: "Assignment (=) can be replaced with operator assignment ({{operator}}).",
+				unexpected: "Unexpected operator assignment ({{operator}}) shorthand."
+			}
+		},
+		create(context) {
+			let never = context.options[0] === "never", sourceCode = context.sourceCode;
+			/**
+			* Returns the operator token of an AssignmentExpression or BinaryExpression
+			* @param {ASTNode} node An AssignmentExpression or BinaryExpression node
+			* @returns {Token} The operator token in the node
+			*/
+			function getOperatorToken(node) {
+				return sourceCode.getFirstTokenBetween(node.left, node.right, (token) => token.value === node.operator);
+			}
+			/**
+			* Ensures that an assignment uses the shorthand form where possible.
+			* @param {ASTNode} node An AssignmentExpression node.
+			* @returns {void}
+			*/
+			function verify(node) {
+				if (node.operator !== "=" || node.right.type !== "BinaryExpression") return;
+				let left = node.left, expr = node.right, operator = expr.operator;
+				if (isCommutativeOperatorWithShorthand(operator) || isNonCommutativeOperatorWithShorthand(operator)) {
+					let replacementOperator = `${operator}=`;
+					astUtils.isSameReference(left, expr.left, !0) ? context.report({
+						node,
+						messageId: "replaced",
+						data: { operator: replacementOperator },
+						fix(fixer) {
+							if (canBeFixed(left) && canBeFixed(expr.left)) {
+								let equalsToken = getOperatorToken(node), operatorToken = getOperatorToken(expr), leftText = sourceCode.getText().slice(node.range[0], equalsToken.range[0]), rightText = sourceCode.getText().slice(operatorToken.range[1], node.right.range[1]);
+								return sourceCode.commentsExistBetween(equalsToken, operatorToken) ? null : fixer.replaceText(node, `${leftText}${replacementOperator}${rightText}`);
+							}
+							return null;
+						}
+					}) : astUtils.isSameReference(left, expr.right, !0) && isCommutativeOperatorWithShorthand(operator) && context.report({
+						node,
+						messageId: "replaced",
+						data: { operator: replacementOperator }
+					});
+				}
+			}
+			/**
+			* Warns if an assignment expression uses operator assignment shorthand.
+			* @param {ASTNode} node An AssignmentExpression node.
+			* @returns {void}
+			*/
+			function prohibit(node) {
+				node.operator !== "=" && !astUtils.isLogicalAssignmentOperator(node.operator) && context.report({
+					node,
+					messageId: "unexpected",
+					data: { operator: node.operator },
+					fix(fixer) {
+						if (canBeFixed(node.left)) {
+							let firstToken = sourceCode.getFirstToken(node), operatorToken = getOperatorToken(node), leftText = sourceCode.getText().slice(node.range[0], operatorToken.range[0]), newOperator = node.operator.slice(0, -1), rightText;
+							if (sourceCode.commentsExistBetween(firstToken, operatorToken)) return null;
+							if (astUtils.getPrecedence(node.right) <= astUtils.getPrecedence({
+								type: "BinaryExpression",
+								operator: newOperator
+							}) && !astUtils.isParenthesised(sourceCode, node.right)) rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
+							else {
+								let tokenAfterOperator = sourceCode.getTokenAfter(operatorToken, { includeComments: !0 }), rightTextPrefix = "";
+								operatorToken.range[1] === tokenAfterOperator.range[0] && !astUtils.canTokensBeAdjacent({
+									type: "Punctuator",
+									value: newOperator
+								}, tokenAfterOperator) && (rightTextPrefix = " "), rightText = `${rightTextPrefix}${sourceCode.text.slice(operatorToken.range[1], node.range[1])}`;
+							}
+							return fixer.replaceText(node, `${leftText}= ${leftText}${newOperator}${rightText}`);
+						}
+						return null;
+					}
+				});
+			}
+			return { AssignmentExpression: never ? prohibit : verify };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/operator-assignment.cjs
+module.exports = require_operator_assignment().create;
+//#endregion

package/rules/operator-linebreak.cjs

@@ -0,0 +1,150 @@
+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/operator-linebreak.js
+/**
+* @fileoverview Operator linebreak - enforces operator linebreak style of two types: after and before
+* @author Benoît Zugmeyer
+* @deprecated in ESLint v8.53.0
+*/
+var require_operator_linebreak = /* @__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: "operator-linebreak",
+						url: "https://eslint.style/rules/operator-linebreak"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Enforce consistent linebreak style for operators",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/operator-linebreak"
+			},
+			schema: [{ enum: [
+				"after",
+				"before",
+				"none",
+				null
+			] }, {
+				type: "object",
+				properties: { overrides: {
+					type: "object",
+					additionalProperties: { enum: [
+						"after",
+						"before",
+						"none",
+						"ignore"
+					] }
+				} },
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: {
+				operatorAtBeginning: "'{{operator}}' should be placed at the beginning of the line.",
+				operatorAtEnd: "'{{operator}}' should be placed at the end of the line.",
+				badLinebreak: "Bad line breaking before and after '{{operator}}'.",
+				noLinebreak: "There should be no line break before or after '{{operator}}'."
+			}
+		},
+		create(context) {
+			let usedDefaultGlobal = !context.options[0], globalStyle = context.options[0] || "after", options = context.options[1] || {}, styleOverrides = options.overrides ? Object.assign({}, options.overrides) : {};
+			usedDefaultGlobal && !styleOverrides["?"] && (styleOverrides["?"] = "before"), usedDefaultGlobal && !styleOverrides[":"] && (styleOverrides[":"] = "before");
+			let sourceCode = context.sourceCode;
+			/**
+			* Gets a fixer function to fix rule issues
+			* @param {Token} operatorToken The operator token of an expression
+			* @param {string} desiredStyle The style for the rule. One of 'before', 'after', 'none'
+			* @returns {Function} A fixer function
+			*/
+			function getFixer(operatorToken, desiredStyle) {
+				return (fixer) => {
+					let tokenBefore = sourceCode.getTokenBefore(operatorToken), tokenAfter = sourceCode.getTokenAfter(operatorToken), textBefore = sourceCode.text.slice(tokenBefore.range[1], operatorToken.range[0]), textAfter = sourceCode.text.slice(operatorToken.range[1], tokenAfter.range[0]), hasLinebreakBefore = !astUtils.isTokenOnSameLine(tokenBefore, operatorToken), hasLinebreakAfter = !astUtils.isTokenOnSameLine(operatorToken, tokenAfter), newTextBefore, newTextAfter;
+					if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== "none") {
+						if (sourceCode.getTokenBefore(operatorToken, { includeComments: !0 }) !== tokenBefore && sourceCode.getTokenAfter(operatorToken, { includeComments: !0 }) !== tokenAfter) return null;
+						newTextBefore = textAfter, newTextAfter = textBefore;
+					} else {
+						let LINEBREAK_REGEX = astUtils.createGlobalLinebreakMatcher();
+						if (newTextBefore = desiredStyle === "before" || textBefore.trim() ? textBefore : textBefore.replace(LINEBREAK_REGEX, ""), newTextAfter = desiredStyle === "after" || textAfter.trim() ? textAfter : textAfter.replace(LINEBREAK_REGEX, ""), newTextBefore === textBefore && newTextAfter === textAfter) return null;
+					}
+					return newTextAfter === "" && tokenAfter.type === "Punctuator" && "+-".includes(operatorToken.value) && tokenAfter.value === operatorToken.value && (newTextAfter += " "), fixer.replaceTextRange([tokenBefore.range[1], tokenAfter.range[0]], newTextBefore + operatorToken.value + newTextAfter);
+				};
+			}
+			/**
+			* Checks the operator placement
+			* @param {ASTNode} node The node to check
+			* @param {ASTNode} rightSide The node that comes after the operator in `node`
+			* @param {string} operator The operator
+			* @private
+			* @returns {void}
+			*/
+			function validateNode(node, rightSide, operator) {
+				let operatorToken = sourceCode.getTokenBefore(rightSide, (token) => token.value === operator), leftToken = sourceCode.getTokenBefore(operatorToken), rightToken = sourceCode.getTokenAfter(operatorToken), operatorStyleOverride = styleOverrides[operator], style = operatorStyleOverride || globalStyle, fix = getFixer(operatorToken, style);
+				astUtils.isTokenOnSameLine(leftToken, operatorToken) && astUtils.isTokenOnSameLine(operatorToken, rightToken) || (operatorStyleOverride !== "ignore" && !astUtils.isTokenOnSameLine(leftToken, operatorToken) && !astUtils.isTokenOnSameLine(operatorToken, rightToken) ? context.report({
+					node,
+					loc: operatorToken.loc,
+					messageId: "badLinebreak",
+					data: { operator },
+					fix
+				}) : style === "before" && astUtils.isTokenOnSameLine(leftToken, operatorToken) ? context.report({
+					node,
+					loc: operatorToken.loc,
+					messageId: "operatorAtBeginning",
+					data: { operator },
+					fix
+				}) : style === "after" && astUtils.isTokenOnSameLine(operatorToken, rightToken) ? context.report({
+					node,
+					loc: operatorToken.loc,
+					messageId: "operatorAtEnd",
+					data: { operator },
+					fix
+				}) : style === "none" && context.report({
+					node,
+					loc: operatorToken.loc,
+					messageId: "noLinebreak",
+					data: { operator },
+					fix
+				}));
+			}
+			/**
+			* Validates a binary expression using `validateNode`
+			* @param {BinaryExpression|LogicalExpression|AssignmentExpression} node node to be validated
+			* @returns {void}
+			*/
+			function validateBinaryExpression(node) {
+				validateNode(node, node.right, node.operator);
+			}
+			return {
+				BinaryExpression: validateBinaryExpression,
+				LogicalExpression: validateBinaryExpression,
+				AssignmentExpression: validateBinaryExpression,
+				VariableDeclarator(node) {
+					node.init && validateNode(node, node.init, "=");
+				},
+				PropertyDefinition(node) {
+					node.value && validateNode(node, node.value, "=");
+				},
+				ConditionalExpression(node) {
+					validateNode(node, node.consequent, "?"), validateNode(node, node.alternate, ":");
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/operator-linebreak.cjs
+module.exports = require_operator_linebreak().create;
+//#endregion