oxlint-plugin-eslint 1.52.0

package/rules/no-mixed-requires.cjs

@@ -0,0 +1,117 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-mixed-requires.js
+/**
+* @fileoverview Rule to enforce grouped require statements for Node.JS
+* @author Raphael Pigulla
+* @deprecated in ESLint v7.0.0
+*/
+var require_no_mixed_requires = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			deprecated: {
+				message: "Node.js rules were moved out of ESLint core.",
+				url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
+				deprecatedSince: "7.0.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{
+					message: "eslint-plugin-n now maintains deprecated Node.js-related rules.",
+					plugin: {
+						name: "eslint-plugin-n",
+						url: "https://github.com/eslint-community/eslint-plugin-n"
+					},
+					rule: {
+						name: "no-mixed-requires",
+						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-mixed-requires.md"
+					}
+				}]
+			},
+			type: "suggestion",
+			docs: {
+				description: "Disallow `require` calls to be mixed with regular variable declarations",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-mixed-requires"
+			},
+			schema: [{ oneOf: [{ type: "boolean" }, {
+				type: "object",
+				properties: {
+					grouping: { type: "boolean" },
+					allowCall: { type: "boolean" }
+				},
+				additionalProperties: !1
+			}] }],
+			messages: {
+				noMixRequire: "Do not mix 'require' and other declarations.",
+				noMixCoreModuleFileComputed: "Do not mix core, module, file and computed requires."
+			}
+		},
+		create(context) {
+			let options = context.options[0], grouping = !1, allowCall = !1;
+			typeof options == "object" ? (grouping = options.grouping, allowCall = options.allowCall) : grouping = !!options;
+			/**
+			* Returns the list of built-in modules.
+			* @returns {string[]} An array of built-in Node.js modules.
+			*/
+			function getBuiltinModules() {
+				return /* @__PURE__ */ "assert.buffer.child_process.cluster.crypto.dgram.dns.domain.events.fs.http.https.net.os.path.punycode.querystring.readline.repl.smalloc.stream.string_decoder.tls.tty.url.util.v8.vm.zlib".split(".");
+			}
+			let BUILTIN_MODULES = getBuiltinModules(), DECL_REQUIRE = "require", DECL_UNINITIALIZED = "uninitialized", DECL_OTHER = "other", REQ_COMPUTED = "computed";
+			/**
+			* Determines the type of a declaration statement.
+			* @param {ASTNode} initExpression The init node of the VariableDeclarator.
+			* @returns {string} The type of declaration represented by the expression.
+			*/
+			function getDeclarationType(initExpression) {
+				return initExpression ? initExpression.type === "CallExpression" && initExpression.callee.type === "Identifier" && initExpression.callee.name === "require" ? DECL_REQUIRE : allowCall && initExpression.type === "CallExpression" && initExpression.callee.type === "CallExpression" ? getDeclarationType(initExpression.callee) : initExpression.type === "MemberExpression" ? getDeclarationType(initExpression.object) : DECL_OTHER : DECL_UNINITIALIZED;
+			}
+			/**
+			* Determines the type of module that is loaded via require.
+			* @param {ASTNode} initExpression The init node of the VariableDeclarator.
+			* @returns {string} The module type.
+			*/
+			function inferModuleType(initExpression) {
+				if (initExpression.type === "MemberExpression") return inferModuleType(initExpression.object);
+				if (initExpression.arguments.length === 0) return REQ_COMPUTED;
+				let arg = initExpression.arguments[0];
+				return arg.type !== "Literal" || typeof arg.value != "string" ? REQ_COMPUTED : BUILTIN_MODULES.includes(arg.value) ? "core" : /^\.{0,2}\//u.test(arg.value) ? "file" : "module";
+			}
+			/**
+			* Check if the list of variable declarations is mixed, i.e. whether it
+			* contains both require and other declarations.
+			* @param {ASTNode} declarations The list of VariableDeclarators.
+			* @returns {boolean} True if the declarations are mixed, false if not.
+			*/
+			function isMixed(declarations) {
+				let contains = {};
+				return declarations.forEach((declaration) => {
+					let type = getDeclarationType(declaration.init);
+					contains[type] = !0;
+				}), !!(contains[DECL_REQUIRE] && (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER]));
+			}
+			/**
+			* Check if all require declarations in the given list are of the same
+			* type.
+			* @param {ASTNode} declarations The list of VariableDeclarators.
+			* @returns {boolean} True if the declarations are grouped, false if not.
+			*/
+			function isGrouped(declarations) {
+				let found = {};
+				return declarations.forEach((declaration) => {
+					getDeclarationType(declaration.init) === DECL_REQUIRE && (found[inferModuleType(declaration.init)] = !0);
+				}), Object.keys(found).length <= 1;
+			}
+			return { VariableDeclaration(node) {
+				isMixed(node.declarations) ? context.report({
+					node,
+					messageId: "noMixRequire"
+				}) : grouping && !isGrouped(node.declarations) && context.report({
+					node,
+					messageId: "noMixCoreModuleFileComputed"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-mixed-requires.cjs
+module.exports = require_no_mixed_requires().create;
+//#endregion

package/rules/no-mixed-spaces-and-tabs.cjs

@@ -0,0 +1,87 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js
+/**
+* @fileoverview Disallow mixed spaces and tabs for indentation
+* @author Jary Niebur
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_mixed_spaces_and_tabs = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @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: "no-mixed-spaces-and-tabs",
+						url: "https://eslint.style/rules/no-mixed-spaces-and-tabs"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow mixed spaces and tabs for indentation",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs"
+			},
+			schema: [{ enum: [
+				"smart-tabs",
+				!0,
+				!1
+			] }],
+			messages: { mixedSpacesAndTabs: "Mixed spaces and tabs." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, smartTabs;
+			switch (context.options[0]) {
+				case !0:
+				case "smart-tabs":
+					smartTabs = !0;
+					break;
+				default: smartTabs = !1;
+			}
+			return { "Program:exit"(node) {
+				let lines = sourceCode.lines, comments = sourceCode.getAllComments(), ignoredCommentLines = /* @__PURE__ */ new Set();
+				comments.forEach((comment) => {
+					for (let i = comment.loc.start.line + 1; i <= comment.loc.end.line; i++) ignoredCommentLines.add(i);
+				});
+				let regex = /^(?=( +|\t+))\1(?:\t| )/u;
+				smartTabs && (regex = /^(?=(\t*))\1(?=( +))\2\t/u), lines.forEach((line, i) => {
+					let match = regex.exec(line);
+					if (match) {
+						let lineNumber = i + 1, loc = {
+							start: {
+								line: lineNumber,
+								column: match[0].length - 2
+							},
+							end: {
+								line: lineNumber,
+								column: match[0].length
+							}
+						};
+						if (!ignoredCommentLines.has(lineNumber)) {
+							let containingNode = sourceCode.getNodeByRangeIndex(sourceCode.getIndexFromLoc(loc.start));
+							containingNode && ["Literal", "TemplateElement"].includes(containingNode.type) || context.report({
+								node,
+								loc,
+								messageId: "mixedSpacesAndTabs"
+							});
+						}
+					}
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-mixed-spaces-and-tabs.cjs
+module.exports = require_no_mixed_spaces_and_tabs().create;
+//#endregion

package/rules/no-multi-assign.cjs

@@ -0,0 +1,38 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-multi-assign.js
+/**
+* @fileoverview Rule to check use of chained assignment expressions
+* @author Stewart Rand
+*/
+var require_no_multi_assign = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ ignoreNonDeclaration: !1 }],
+			docs: {
+				description: "Disallow use of chained assignment expressions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-multi-assign"
+			},
+			schema: [{
+				type: "object",
+				properties: { ignoreNonDeclaration: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { unexpectedChain: "Unexpected chained assignment." }
+		},
+		create(context) {
+			let [{ ignoreNonDeclaration }] = context.options, selectors = ["VariableDeclarator > AssignmentExpression.init", "PropertyDefinition > AssignmentExpression.value"];
+			return ignoreNonDeclaration || selectors.push("AssignmentExpression > AssignmentExpression.right"), { [selectors](node) {
+				context.report({
+					node,
+					messageId: "unexpectedChain"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-multi-assign.cjs
+module.exports = require_no_multi_assign().create;
+//#endregion

package/rules/no-multi-spaces.cjs

@@ -0,0 +1,95 @@
+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-multi-spaces.js
+/**
+* @fileoverview Disallow use of multiple spaces.
+* @author Nicholas C. Zakas
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_multi_spaces = /* @__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: "no-multi-spaces",
+						url: "https://eslint.style/rules/no-multi-spaces"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow multiple spaces",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-multi-spaces"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					exceptions: {
+						type: "object",
+						patternProperties: { "^([A-Z][a-z]*)+$": { type: "boolean" } },
+						additionalProperties: !1
+					},
+					ignoreEOLComments: {
+						type: "boolean",
+						default: !1
+					}
+				},
+				additionalProperties: !1
+			}],
+			messages: { multipleSpaces: "Multiple spaces found before '{{displayValue}}'." }
+		},
+		create(context) {
+			let sourceCode = context.sourceCode, options = context.options[0] || {}, ignoreEOLComments = options.ignoreEOLComments, exceptions = Object.assign({ Property: !0 }, options.exceptions), hasExceptions = Object.keys(exceptions).some((key) => exceptions[key]);
+			/**
+			* Formats value of given comment token for error message by truncating its length.
+			* @param {Token} token comment token
+			* @returns {string} formatted value
+			* @private
+			*/
+			function formatReportedCommentValue(token) {
+				let valueLines = token.value.split("\n"), value = valueLines[0], formattedValue = `${value.slice(0, 12)}...`;
+				return valueLines.length === 1 && value.length <= 12 ? value : formattedValue;
+			}
+			return { Program() {
+				sourceCode.tokensAndComments.forEach((leftToken, leftIndex, tokensAndComments) => {
+					if (leftIndex === tokensAndComments.length - 1) return;
+					let rightToken = tokensAndComments[leftIndex + 1];
+					if (!sourceCode.text.slice(leftToken.range[1], rightToken.range[0]).includes("  ") || leftToken.loc.end.line < rightToken.loc.start.line || ignoreEOLComments && astUtils.isCommentToken(rightToken) && (leftIndex === tokensAndComments.length - 2 || rightToken.loc.end.line < tokensAndComments[leftIndex + 2].loc.start.line)) return;
+					if (hasExceptions) {
+						let parentNode = sourceCode.getNodeByRangeIndex(rightToken.range[0] - 1);
+						if (parentNode && exceptions[parentNode.type]) return;
+					}
+					let displayValue;
+					displayValue = rightToken.type === "Block" ? `/*${formatReportedCommentValue(rightToken)}*/` : rightToken.type === "Line" ? `//${formatReportedCommentValue(rightToken)}` : rightToken.value, context.report({
+						node: rightToken,
+						loc: {
+							start: leftToken.loc.end,
+							end: rightToken.loc.start
+						},
+						messageId: "multipleSpaces",
+						data: { displayValue },
+						fix: (fixer) => fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ")
+					});
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-multi-spaces.cjs
+module.exports = require_no_multi_spaces().create;
+//#endregion

package/rules/no-multi-str.cjs

@@ -0,0 +1,44 @@
+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-multi-str.js
+/**
+* @fileoverview Rule to flag when using multiline strings
+* @author Ilya Volodin
+*/
+var require_no_multi_str = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow multiline strings",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-multi-str"
+			},
+			schema: [],
+			messages: { multilineString: "Multiline support is limited to browsers supporting ES5 only." }
+		},
+		create(context) {
+			/**
+			* Determines if a given node is part of JSX syntax.
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} True if the node is a JSX node, false if not.
+			* @private
+			*/
+			function isJSXElement(node) {
+				return node.type.indexOf("JSX") === 0;
+			}
+			return { Literal(node) {
+				astUtils.LINEBREAK_MATCHER.test(node.raw) && !isJSXElement(node.parent) && context.report({
+					node,
+					messageId: "multilineString"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-multi-str.cjs
+module.exports = require_no_multi_str().create;
+//#endregion

package/rules/no-multiple-empty-lines.cjs

@@ -0,0 +1,112 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-multiple-empty-lines.js
+/**
+* @fileoverview Disallows multiple blank lines.
+* implementation adapted from the no-trailing-spaces rule.
+* @author Greg Cochard
+* @deprecated in ESLint v8.53.0
+*/
+var require_no_multiple_empty_lines = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @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: "no-multiple-empty-lines",
+						url: "https://eslint.style/rules/no-multiple-empty-lines"
+					}
+				}]
+			},
+			type: "layout",
+			docs: {
+				description: "Disallow multiple empty lines",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-multiple-empty-lines"
+			},
+			fixable: "whitespace",
+			schema: [{
+				type: "object",
+				properties: {
+					max: {
+						type: "integer",
+						minimum: 0
+					},
+					maxEOF: {
+						type: "integer",
+						minimum: 0
+					},
+					maxBOF: {
+						type: "integer",
+						minimum: 0
+					}
+				},
+				required: ["max"],
+				additionalProperties: !1
+			}],
+			messages: {
+				blankBeginningOfFile: "Too many blank lines at the beginning of file. Max of {{max}} allowed.",
+				blankEndOfFile: "Too many blank lines at the end of file. Max of {{max}} allowed.",
+				consecutiveBlank: "More than {{max}} blank {{pluralizedLines}} not allowed."
+			}
+		},
+		create(context) {
+			let max = 2, maxEOF = max, maxBOF = max;
+			context.options.length && (max = context.options[0].max, maxEOF = context.options[0].maxEOF === void 0 ? max : context.options[0].maxEOF, maxBOF = context.options[0].maxBOF === void 0 ? max : context.options[0].maxBOF);
+			let sourceCode = context.sourceCode, allLines = sourceCode.lines.at(-1) === "" ? sourceCode.lines.slice(0, -1) : sourceCode.lines, templateLiteralLines = /* @__PURE__ */ new Set();
+			return {
+				TemplateLiteral(node) {
+					node.quasis.forEach((literalPart) => {
+						for (let ignoredLine = literalPart.loc.start.line; ignoredLine < literalPart.loc.end.line; ignoredLine++) templateLiteralLines.add(ignoredLine);
+					});
+				},
+				"Program:exit"(node) {
+					return allLines.reduce((nonEmptyLineNumbers, line, index) => ((line.trim() || templateLiteralLines.has(index + 1)) && nonEmptyLineNumbers.push(index + 1), nonEmptyLineNumbers), []).concat(allLines.length + 1).reduce((lastLineNumber, lineNumber) => {
+						let messageId, maxAllowed;
+						return lastLineNumber === 0 ? (messageId = "blankBeginningOfFile", maxAllowed = maxBOF) : lineNumber === allLines.length + 1 ? (messageId = "blankEndOfFile", maxAllowed = maxEOF) : (messageId = "consecutiveBlank", maxAllowed = max), lineNumber - lastLineNumber - 1 > maxAllowed && context.report({
+							node,
+							loc: {
+								start: {
+									line: lastLineNumber + maxAllowed + 1,
+									column: 0
+								},
+								end: {
+									line: lineNumber,
+									column: 0
+								}
+							},
+							messageId,
+							data: {
+								max: maxAllowed,
+								pluralizedLines: maxAllowed === 1 ? "line" : "lines"
+							},
+							fix(fixer) {
+								let rangeStart = sourceCode.getIndexFromLoc({
+									line: lastLineNumber + 1,
+									column: 0
+								}), lineNumberAfterRemovedLines = lineNumber - maxAllowed, rangeEnd = lineNumberAfterRemovedLines <= allLines.length ? sourceCode.getIndexFromLoc({
+									line: lineNumberAfterRemovedLines,
+									column: 0
+								}) : sourceCode.text.length;
+								return fixer.removeRange([rangeStart, rangeEnd]);
+							}
+						}), lineNumber;
+					}, 0);
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-multiple-empty-lines.cjs
+module.exports = require_no_multiple_empty_lines().create;
+//#endregion

package/rules/no-native-reassign.cjs

@@ -0,0 +1,72 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-native-reassign.js
+/**
+* @fileoverview Rule to disallow assignments to native objects or read-only global variables
+* @author Ilya Volodin
+* @deprecated in ESLint v3.3.0
+*/
+var require_no_native_reassign = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow assignments to native objects or read-only global variables",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-native-reassign"
+			},
+			deprecated: {
+				message: "Renamed rule.",
+				url: "https://eslint.org/blog/2016/08/eslint-v3.3.0-released/#deprecated-rules",
+				deprecatedSince: "3.3.0",
+				availableUntil: "11.0.0",
+				replacedBy: [{ rule: {
+					name: "no-global-assign",
+					url: "https://eslint.org/docs/rules/no-global-assign"
+				} }]
+			},
+			schema: [{
+				type: "object",
+				properties: { exceptions: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: { nativeReassign: "Read-only global '{{name}}' should not be modified." }
+		},
+		create(context) {
+			let config = context.options[0], exceptions = config && config.exceptions || [], sourceCode = context.sourceCode;
+			/**
+			* Reports write references.
+			* @param {Reference} reference A reference to check.
+			* @param {number} index The index of the reference in the references.
+			* @param {Reference[]} references The array that the reference belongs to.
+			* @returns {void}
+			*/
+			function checkReference(reference, index, references) {
+				let identifier = reference.identifier;
+				reference.init === !1 && reference.isWrite() && (index === 0 || references[index - 1].identifier !== identifier) && context.report({
+					node: identifier,
+					messageId: "nativeReassign",
+					data: identifier
+				});
+			}
+			/**
+			* Reports write references if a given variable is read-only builtin.
+			* @param {Variable} variable A variable to check.
+			* @returns {void}
+			*/
+			function checkVariable(variable) {
+				variable.writeable === !1 && !exceptions.includes(variable.name) && variable.references.forEach(checkReference);
+			}
+			return { Program(node) {
+				sourceCode.getScope(node).variables.forEach(checkVariable);
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-native-reassign.cjs
+module.exports = require_no_native_reassign().create;
+//#endregion

package/rules/no-negated-condition.cjs

@@ -0,0 +1,77 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-negated-condition.js
+/**
+* @fileoverview Rule to disallow a negated condition
+* @author Alberto Rodríguez
+*/
+var require_no_negated_condition = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow negated conditions",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-negated-condition"
+			},
+			schema: [],
+			messages: { unexpectedNegated: "Unexpected negated condition." }
+		},
+		create(context) {
+			/**
+			* Determines if a given node is an if-else without a condition on the else
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} True if the node has an else without an if.
+			* @private
+			*/
+			function hasElseWithoutCondition(node) {
+				return node.alternate && node.alternate.type !== "IfStatement";
+			}
+			/**
+			* Determines if a given node is a negated unary expression
+			* @param {Object} test The test object to check.
+			* @returns {boolean} True if the node is a negated unary expression.
+			* @private
+			*/
+			function isNegatedUnaryExpression(test) {
+				return test.type === "UnaryExpression" && test.operator === "!";
+			}
+			/**
+			* Determines if a given node is a negated binary expression
+			* @param {Test} test The test to check.
+			* @returns {boolean} True if the node is a negated binary expression.
+			* @private
+			*/
+			function isNegatedBinaryExpression(test) {
+				return test.type === "BinaryExpression" && (test.operator === "!=" || test.operator === "!==");
+			}
+			/**
+			* Determines if a given node has a negated if expression
+			* @param {ASTNode} node The node to check.
+			* @returns {boolean} True if the node has a negated if expression.
+			* @private
+			*/
+			function isNegatedIf(node) {
+				return isNegatedUnaryExpression(node.test) || isNegatedBinaryExpression(node.test);
+			}
+			return {
+				IfStatement(node) {
+					hasElseWithoutCondition(node) && isNegatedIf(node) && context.report({
+						node,
+						messageId: "unexpectedNegated"
+					});
+				},
+				ConditionalExpression(node) {
+					isNegatedIf(node) && context.report({
+						node,
+						messageId: "unexpectedNegated"
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-negated-condition.cjs
+module.exports = require_no_negated_condition().create;
+//#endregion