oxlint-plugin-eslint 1.52.0

package/rules/no-unneeded-ternary.cjs

@@ -0,0 +1,112 @@
+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/no-unneeded-ternary.js
+/**
+* @fileoverview Rule to flag no-unneeded-ternary
+* @author Gyandeep Singh
+*/
+var require_no_unneeded_ternary = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), BOOLEAN_OPERATORS = new Set([
+		"==",
+		"===",
+		"!=",
+		"!==",
+		">",
+		">=",
+		"<",
+		"<=",
+		"in",
+		"instanceof"
+	]), OPERATOR_INVERSES = {
+		"==": "!=",
+		"!=": "==",
+		"===": "!==",
+		"!==": "==="
+	}, OR_PRECEDENCE = astUtils.getPrecedence({
+		type: "LogicalExpression",
+		operator: "||"
+	});
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ defaultAssignment: !0 }],
+			docs: {
+				description: "Disallow ternary operators when simpler alternatives exist",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-unneeded-ternary"
+			},
+			schema: [{
+				type: "object",
+				properties: { defaultAssignment: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: {
+				unnecessaryConditionalExpression: "Unnecessary use of boolean literals in conditional expression.",
+				unnecessaryConditionalAssignment: "Unnecessary use of conditional expression for default assignment."
+			}
+		},
+		create(context) {
+			let [{ defaultAssignment }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Test if the node is a boolean literal
+			* @param {ASTNode} node The node to report.
+			* @returns {boolean} True if the its a boolean literal
+			* @private
+			*/
+			function isBooleanLiteral(node) {
+				return node.type === "Literal" && typeof node.value == "boolean";
+			}
+			/**
+			* Creates an expression that represents the boolean inverse of the expression represented by the original node
+			* @param {ASTNode} node A node representing an expression
+			* @returns {string} A string representing an inverted expression
+			*/
+			function invertExpression(node) {
+				if (node.type === "BinaryExpression" && Object.hasOwn(OPERATOR_INVERSES, node.operator)) {
+					let operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, (token) => token.value === node.operator), text = sourceCode.getText();
+					return text.slice(node.range[0], operatorToken.range[0]) + OPERATOR_INVERSES[node.operator] + text.slice(operatorToken.range[1], node.range[1]);
+				}
+				return astUtils.getPrecedence(node) < astUtils.getPrecedence({ type: "UnaryExpression" }) ? `!(${astUtils.getParenthesisedText(sourceCode, node)})` : `!${astUtils.getParenthesisedText(sourceCode, node)}`;
+			}
+			/**
+			* Tests if a given node always evaluates to a boolean value
+			* @param {ASTNode} node An expression node
+			* @returns {boolean} True if it is determined that the node will always evaluate to a boolean value
+			*/
+			function isBooleanExpression(node) {
+				return node.type === "BinaryExpression" && BOOLEAN_OPERATORS.has(node.operator) || node.type === "UnaryExpression" && node.operator === "!";
+			}
+			/**
+			* Test if the node matches the pattern id ? id : expression
+			* @param {ASTNode} node The ConditionalExpression to check.
+			* @returns {boolean} True if the pattern is matched, and false otherwise
+			* @private
+			*/
+			function matchesDefaultAssignment(node) {
+				return node.test.type === "Identifier" && node.consequent.type === "Identifier" && node.test.name === node.consequent.name;
+			}
+			return { ConditionalExpression(node) {
+				isBooleanLiteral(node.alternate) && isBooleanLiteral(node.consequent) ? context.report({
+					node,
+					messageId: "unnecessaryConditionalExpression",
+					fix(fixer) {
+						return node.consequent.value === node.alternate.value ? node.test.type === "Identifier" ? fixer.replaceText(node, node.consequent.value.toString()) : null : node.alternate.value ? fixer.replaceText(node, invertExpression(node.test)) : fixer.replaceText(node, isBooleanExpression(node.test) ? astUtils.getParenthesisedText(sourceCode, node.test) : `!${invertExpression(node.test)}`);
+					}
+				}) : !defaultAssignment && matchesDefaultAssignment(node) && context.report({
+					node,
+					messageId: "unnecessaryConditionalAssignment",
+					fix(fixer) {
+						let alternateText = (astUtils.getPrecedence(node.alternate) < OR_PRECEDENCE || astUtils.isCoalesceExpression(node.alternate)) && !astUtils.isParenthesised(sourceCode, node.alternate) ? `(${sourceCode.getText(node.alternate)})` : astUtils.getParenthesisedText(sourceCode, node.alternate), testText = astUtils.getParenthesisedText(sourceCode, node.test);
+						return fixer.replaceText(node, `${testText} || ${alternateText}`);
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unneeded-ternary.cjs
+module.exports = require_no_unneeded_ternary().create;
+//#endregion

package/rules/no-unreachable-loop.cjs

@@ -0,0 +1,128 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unreachable-loop.js
+/**
+* @fileoverview Rule to disallow loops with a body that allows only one iteration
+* @author Milos Djermanovic
+*/
+var require_no_unreachable_loop = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let allLoopTypes = [
+		"WhileStatement",
+		"DoWhileStatement",
+		"ForStatement",
+		"ForInStatement",
+		"ForOfStatement"
+	];
+	/**
+	* 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;
+	}
+	/**
+	* Determines whether the given node is the first node in the code path to which a loop statement
+	* 'loops' for the next iteration.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is a looping target.
+	*/
+	function isLoopingTarget(node) {
+		let parent = node.parent;
+		if (parent) switch (parent.type) {
+			case "WhileStatement": return node === parent.test;
+			case "DoWhileStatement": return node === parent.body;
+			case "ForStatement": return node === (parent.update || parent.test || parent.body);
+			case "ForInStatement":
+			case "ForOfStatement": return node === parent.left;
+		}
+		return !1;
+	}
+	/**
+	* Creates an array with elements from the first given array that are not included in the second given array.
+	* @param {Array} arrA The array to compare from.
+	* @param {Array} arrB The array to compare against.
+	* @returns {Array} a new array that represents `arrA \ arrB`.
+	*/
+	function getDifference(arrA, arrB) {
+		return arrA.filter((a) => !arrB.includes(a));
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ ignore: [] }],
+			docs: {
+				description: "Disallow loops with a body that allows only one iteration",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-unreachable-loop"
+			},
+			schema: [{
+				type: "object",
+				properties: { ignore: {
+					type: "array",
+					items: { enum: allLoopTypes },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: { invalid: "Invalid loop. Its body allows only one iteration." }
+		},
+		create(context) {
+			let [{ ignore: ignoredLoopTypes }] = context.options, loopSelector = getDifference(allLoopTypes, ignoredLoopTypes).join(","), loopsByTargetSegments = /* @__PURE__ */ new Map(), loopsToReport = /* @__PURE__ */ new Set(), codePathSegments = [], currentCodePathSegments = /* @__PURE__ */ new Set();
+			return {
+				onCodePathStart() {
+					codePathSegments.push(currentCodePathSegments), currentCodePathSegments = /* @__PURE__ */ new Set();
+				},
+				onCodePathEnd() {
+					currentCodePathSegments = codePathSegments.pop();
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					currentCodePathSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					currentCodePathSegments.delete(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					currentCodePathSegments.delete(segment);
+				},
+				onCodePathSegmentStart(segment, node) {
+					if (currentCodePathSegments.add(segment), isLoopingTarget(node)) {
+						let loop = node.parent;
+						loopsByTargetSegments.set(segment, loop);
+					}
+				},
+				onCodePathSegmentLoop(_, toSegment, node) {
+					let loop = loopsByTargetSegments.get(toSegment);
+					/**
+					* The second iteration is reachable, meaning that the loop is valid by the logic of this rule,
+					* only if there is at least one loop event with the appropriate target (which has been already
+					* determined in the `loopsByTargetSegments` map), raised from either:
+					*
+					* - the end of the loop's body (in which case `node === loop`)
+					* - a `continue` statement
+					*
+					* This condition skips loop events raised from `ForInStatement > .right` and `ForOfStatement > .right` nodes.
+					*/
+					(node === loop || node.type === "ContinueStatement") && loopsToReport.delete(loop);
+				},
+				[loopSelector](node) {
+					/**
+					* Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise.
+					* For unreachable segments, the code path analysis does not raise events required for this implementation.
+					*/
+					isAnySegmentReachable(currentCodePathSegments) && loopsToReport.add(node);
+				},
+				"Program:exit"() {
+					loopsToReport.forEach((node) => context.report({
+						node,
+						messageId: "invalid"
+					}));
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unreachable-loop.cjs
+module.exports = require_no_unreachable_loop().create;
+//#endregion

package/rules/no-unreachable.cjs

@@ -0,0 +1,195 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unreachable.js
+/**
+* @fileoverview Checks for unreachable code due to return, throws, break, and continue.
+* @author Joel Feenstra
+*/
+var require_no_unreachable = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/**
+	* @typedef {Object} ConstructorInfo
+	* @property {ConstructorInfo | null} upper Info about the constructor that encloses this constructor.
+	* @property {boolean} hasSuperCall The flag about having `super()` expressions.
+	*/
+	/**
+	* Checks whether or not a given variable declarator has the initializer.
+	* @param {ASTNode} node A VariableDeclarator node to check.
+	* @returns {boolean} `true` if the node has the initializer.
+	*/
+	function isInitialized(node) {
+		return !!node.init;
+	}
+	/**
+	* Checks all segments in a set and returns true if all are unreachable.
+	* @param {Set<CodePathSegment>} segments The segments to check.
+	* @returns {boolean} True if all segments are unreachable; false otherwise.
+	*/
+	function areAllSegmentsUnreachable(segments) {
+		for (let segment of segments) if (segment.reachable) return !1;
+		return !0;
+	}
+	/**
+	* The class to distinguish consecutive unreachable statements.
+	*/
+	var ConsecutiveRange = class {
+		constructor(sourceCode) {
+			this.sourceCode = sourceCode, this.startNode = null, this.endNode = null;
+		}
+		/**
+		* The location object of this range.
+		* @type {Object}
+		*/
+		get location() {
+			return {
+				start: this.startNode.loc.start,
+				end: this.endNode.loc.end
+			};
+		}
+		/**
+		* `true` if this range is empty.
+		* @type {boolean}
+		*/
+		get isEmpty() {
+			return !(this.startNode && this.endNode);
+		}
+		/**
+		* Checks whether the given node is inside of this range.
+		* @param {ASTNode|Token} node The node to check.
+		* @returns {boolean} `true` if the node is inside of this range.
+		*/
+		contains(node) {
+			return node.range[0] >= this.startNode.range[0] && node.range[1] <= this.endNode.range[1];
+		}
+		/**
+		* Checks whether the given node is consecutive to this range.
+		* @param {ASTNode} node The node to check.
+		* @returns {boolean} `true` if the node is consecutive to this range.
+		*/
+		isConsecutive(node) {
+			return this.contains(this.sourceCode.getTokenBefore(node));
+		}
+		/**
+		* Merges the given node to this range.
+		* @param {ASTNode} node The node to merge.
+		* @returns {void}
+		*/
+		merge(node) {
+			this.endNode = node;
+		}
+		/**
+		* Resets this range by the given node or null.
+		* @param {ASTNode|null} node The node to reset, or null.
+		* @returns {void}
+		*/
+		reset(node) {
+			this.startNode = this.endNode = node;
+		}
+	};
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-unreachable"
+			},
+			schema: [],
+			messages: { unreachableCode: "Unreachable code." }
+		},
+		create(context) {
+			/** @type {ConstructorInfo | null} */
+			let constructorInfo = null, range = new ConsecutiveRange(context.sourceCode), codePathSegments = [], currentCodePathSegments = /* @__PURE__ */ new Set();
+			/**
+			* Reports a given node if it's unreachable.
+			* @param {ASTNode} node A statement node to report.
+			* @returns {void}
+			*/
+			function reportIfUnreachable(node) {
+				let nextNode = null;
+				if (node && (node.type === "PropertyDefinition" || areAllSegmentsUnreachable(currentCodePathSegments))) {
+					if (range.isEmpty) {
+						range.reset(node);
+						return;
+					}
+					if (range.contains(node)) return;
+					if (range.isConsecutive(node)) {
+						range.merge(node);
+						return;
+					}
+					nextNode = node;
+				}
+				range.isEmpty || context.report({
+					messageId: "unreachableCode",
+					loc: range.location,
+					node: range.startNode
+				}), range.reset(nextNode);
+			}
+			return {
+				onCodePathStart() {
+					codePathSegments.push(currentCodePathSegments), currentCodePathSegments = /* @__PURE__ */ new Set();
+				},
+				onCodePathEnd() {
+					currentCodePathSegments = codePathSegments.pop();
+				},
+				onUnreachableCodePathSegmentStart(segment) {
+					currentCodePathSegments.add(segment);
+				},
+				onUnreachableCodePathSegmentEnd(segment) {
+					currentCodePathSegments.delete(segment);
+				},
+				onCodePathSegmentEnd(segment) {
+					currentCodePathSegments.delete(segment);
+				},
+				onCodePathSegmentStart(segment) {
+					currentCodePathSegments.add(segment);
+				},
+				BlockStatement: reportIfUnreachable,
+				BreakStatement: reportIfUnreachable,
+				ClassDeclaration: reportIfUnreachable,
+				ContinueStatement: reportIfUnreachable,
+				DebuggerStatement: reportIfUnreachable,
+				DoWhileStatement: reportIfUnreachable,
+				ExpressionStatement: reportIfUnreachable,
+				ForInStatement: reportIfUnreachable,
+				ForOfStatement: reportIfUnreachable,
+				ForStatement: reportIfUnreachable,
+				IfStatement: reportIfUnreachable,
+				ImportDeclaration: reportIfUnreachable,
+				LabeledStatement: reportIfUnreachable,
+				ReturnStatement: reportIfUnreachable,
+				SwitchStatement: reportIfUnreachable,
+				ThrowStatement: reportIfUnreachable,
+				TryStatement: reportIfUnreachable,
+				VariableDeclaration(node) {
+					(node.kind !== "var" || node.declarations.some(isInitialized)) && reportIfUnreachable(node);
+				},
+				WhileStatement: reportIfUnreachable,
+				WithStatement: reportIfUnreachable,
+				ExportNamedDeclaration: reportIfUnreachable,
+				ExportDefaultDeclaration: reportIfUnreachable,
+				ExportAllDeclaration: reportIfUnreachable,
+				"Program:exit"() {
+					reportIfUnreachable();
+				},
+				"MethodDefinition[kind='constructor']"() {
+					constructorInfo = {
+						upper: constructorInfo,
+						hasSuperCall: !1
+					};
+				},
+				"MethodDefinition[kind='constructor']:exit"(node) {
+					let { hasSuperCall } = constructorInfo;
+					if (constructorInfo = constructorInfo.upper, !node.value.body) return;
+					let classDefinition = node.parent.parent;
+					if (classDefinition.superClass && !hasSuperCall) for (let element of classDefinition.body.body) element.type === "PropertyDefinition" && !element.static && reportIfUnreachable(element);
+				},
+				"CallExpression > Super.callee"() {
+					constructorInfo && (constructorInfo.hasSuperCall = !0);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unreachable.cjs
+module.exports = require_no_unreachable().create;
+//#endregion

package/rules/no-unsafe-finally.cjs

@@ -0,0 +1,67 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-unsafe-finally.js
+/**
+* @fileoverview Rule to flag unsafe statements in finally block
+* @author Onur Temizkan
+*/
+var require_no_unsafe_finally = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	let SENTINEL_NODE_TYPE_RETURN_THROW = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression)$/u, SENTINEL_NODE_TYPE_BREAK = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement|SwitchStatement)$/u, SENTINEL_NODE_TYPE_CONTINUE = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement)$/u;
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow control flow statements in `finally` blocks",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-unsafe-finally"
+			},
+			schema: [],
+			messages: { unsafeUsage: "Unsafe usage of {{nodeType}}." }
+		},
+		create(context) {
+			/**
+			* Checks if the node is the finalizer of a TryStatement
+			* @param {ASTNode} node node to check.
+			* @returns {boolean} - true if the node is the finalizer of a TryStatement
+			*/
+			function isFinallyBlock(node) {
+				return node.parent.type === "TryStatement" && node.parent.finalizer === node;
+			}
+			/**
+			* Climbs up the tree if the node is not a sentinel node
+			* @param {ASTNode} node node to check.
+			* @param {string} label label of the break or continue statement
+			* @returns {boolean} - return whether the node is a finally block or a sentinel node
+			*/
+			function isInFinallyBlock(node, label) {
+				let labelInside = !1, sentinelNodeType;
+				sentinelNodeType = node.type === "BreakStatement" && !node.label ? SENTINEL_NODE_TYPE_BREAK : node.type === "ContinueStatement" ? SENTINEL_NODE_TYPE_CONTINUE : SENTINEL_NODE_TYPE_RETURN_THROW;
+				for (let currentNode = node; currentNode && !sentinelNodeType.test(currentNode.type); currentNode = currentNode.parent) if (currentNode.parent.label && label && currentNode.parent.label.name === label.name && (labelInside = !0), isFinallyBlock(currentNode)) return !(label && labelInside);
+				return !1;
+			}
+			/**
+			* Checks whether the possibly-unsafe statement is inside a finally block.
+			* @param {ASTNode} node node to check.
+			* @returns {void}
+			*/
+			function check(node) {
+				isInFinallyBlock(node, node.label) && context.report({
+					messageId: "unsafeUsage",
+					data: { nodeType: node.type },
+					node,
+					line: node.loc.line,
+					column: node.loc.column
+				});
+			}
+			return {
+				ReturnStatement: check,
+				ThrowStatement: check,
+				BreakStatement: check,
+				ContinueStatement: check
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unsafe-finally.cjs
+module.exports = require_no_unsafe_finally().create;
+//#endregion

package/rules/no-unsafe-negation.cjs

@@ -0,0 +1,86 @@
+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/no-unsafe-negation.js
+/**
+* @fileoverview Rule to disallow negating the left operand of relational operators
+* @author Toru Nagashima
+*/
+var require_no_unsafe_negation = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/**
+	* Checks whether the given operator is `in` or `instanceof`
+	* @param {string} op The operator type to check.
+	* @returns {boolean} `true` if the operator is `in` or `instanceof`
+	*/
+	function isInOrInstanceOfOperator(op) {
+		return op === "in" || op === "instanceof";
+	}
+	/**
+	* Checks whether the given operator is an ordering relational operator or not.
+	* @param {string} op The operator type to check.
+	* @returns {boolean} `true` if the operator is an ordering relational operator.
+	*/
+	function isOrderingRelationalOperator(op) {
+		return op === "<" || op === ">" || op === ">=" || op === "<=";
+	}
+	/**
+	* Checks whether the given node is a logical negation expression or not.
+	* @param {ASTNode} node The node to check.
+	* @returns {boolean} `true` if the node is a logical negation expression.
+	*/
+	function isNegation(node) {
+		return node.type === "UnaryExpression" && node.operator === "!";
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ enforceForOrderingRelations: !1 }],
+			docs: {
+				description: "Disallow negating the left operand of relational operators",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-unsafe-negation"
+			},
+			hasSuggestions: !0,
+			schema: [{
+				type: "object",
+				properties: { enforceForOrderingRelations: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			fixable: null,
+			messages: {
+				unexpected: "Unexpected negating the left operand of '{{operator}}' operator.",
+				suggestNegatedExpression: "Negate '{{operator}}' expression instead of its left operand. This changes the current behavior.",
+				suggestParenthesisedNegation: "Wrap negation in '()' to make the intention explicit. This preserves the current behavior."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, [{ enforceForOrderingRelations }] = context.options;
+			return { BinaryExpression(node) {
+				let operator = node.operator, orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(operator);
+				(isInOrInstanceOfOperator(operator) || orderingRelationRuleApplies) && isNegation(node.left) && !astUtils.isParenthesised(sourceCode, node.left) && context.report({
+					node,
+					loc: node.left.loc,
+					messageId: "unexpected",
+					data: { operator },
+					suggest: [{
+						messageId: "suggestNegatedExpression",
+						data: { operator },
+						fix(fixer) {
+							let fixRange = [sourceCode.getFirstToken(node.left).range[1], node.range[1]], text = sourceCode.text.slice(fixRange[0], fixRange[1]);
+							return fixer.replaceTextRange(fixRange, `(${text})`);
+						}
+					}, {
+						messageId: "suggestParenthesisedNegation",
+						fix(fixer) {
+							return fixer.replaceText(node.left, `(${sourceCode.getText(node.left)})`);
+						}
+					}]
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-unsafe-negation.cjs
+module.exports = require_no_unsafe_negation().create;
+//#endregion