oxlint-plugin-eslint 1.52.0

package/rules/no-else-return.cjs

@@ -0,0 +1,182 @@
+const require_chunk = require("../common/chunk.cjs"), require_ast_utils$1 = require("../common/ast-utils.cjs"), require_fix_tracker$1 = require("../common/fix-tracker.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-else-return.js
+/**
+* @fileoverview Rule to flag `else` after a `return` in `if`
+* @author Ian Christian Myers
+*/
+var require_no_else_return = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), FixTracker = require_fix_tracker$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			defaultOptions: [{ allowElseIf: !0 }],
+			docs: {
+				description: "Disallow `else` blocks after `return` statements in `if` statements",
+				recommended: !1,
+				frozen: !0,
+				url: "https://eslint.org/docs/latest/rules/no-else-return"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowElseIf: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			fixable: "code",
+			messages: { unexpected: "Unnecessary 'else' after 'return'." }
+		},
+		create(context) {
+			let [{ allowElseIf }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Checks whether the given names can be safely used to declare block-scoped variables
+			* in the given scope. Name collisions can produce redeclaration syntax errors,
+			* or silently change references and modify behavior of the original code.
+			*
+			* This is not a generic function. In particular, it is assumed that the scope is a function scope or
+			* a function's inner scope, and that the names can be valid identifiers in the given scope.
+			* @param {string[]} names Array of variable names.
+			* @param {eslint-scope.Scope} scope Function scope or a function's inner scope.
+			* @returns {boolean} True if all names can be safely declared, false otherwise.
+			*/
+			function isSafeToDeclare(names, scope) {
+				if (names.length === 0) return !0;
+				let functionScope = scope.variableScope;
+				if (scope.variables.filter(({ defs }) => defs.length > 0).some(({ name }) => names.includes(name)) || scope !== functionScope && scope.upper.type === "catch" && scope.upper.variables.some(({ name }) => names.includes(name)) || scope.variables.filter(({ defs, references }) => defs.length === 0 && references.length > 0).some(({ name }) => names.includes(name)) || scope.through.some((t) => names.includes(t.identifier.name))) return !1;
+				if (scope !== functionScope) {
+					let scopeNodeRange = scope.block.range;
+					if (functionScope.variables.filter(({ name }) => names.includes(name)).some((v) => v.defs.some(({ node: { range } }) => scopeNodeRange[0] <= range[0] && range[1] <= scopeNodeRange[1]))) return !1;
+				}
+				return !0;
+			}
+			/**
+			* Checks whether the removal of `else` and its braces is safe from variable name collisions.
+			* @param {Node} node The 'else' node.
+			* @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.
+			* @returns {boolean} True if it is safe, false otherwise.
+			*/
+			function isSafeFromNameCollisions(node, scope) {
+				if (node.type === "FunctionDeclaration") return !1;
+				if (node.type !== "BlockStatement") return !0;
+				let elseBlockScope = scope.childScopes.find(({ block }) => block === node);
+				return elseBlockScope ? isSafeToDeclare(elseBlockScope.variables.map(({ name }) => name), scope) : !0;
+			}
+			/**
+			* Display the context report if rule is violated
+			* @param {Node} elseNode The 'else' node
+			* @returns {void}
+			*/
+			function displayReport(elseNode) {
+				let currentScope = sourceCode.getScope(elseNode.parent);
+				context.report({
+					node: elseNode,
+					messageId: "unexpected",
+					fix(fixer) {
+						if (!isSafeFromNameCollisions(elseNode, currentScope)) return null;
+						let startToken = sourceCode.getFirstToken(elseNode), elseToken = sourceCode.getTokenBefore(startToken), source = sourceCode.getText(elseNode), lastIfToken = sourceCode.getTokenBefore(elseToken), fixedSource, firstTokenOfElseBlock;
+						firstTokenOfElseBlock = startToken.type === "Punctuator" && startToken.value === "{" ? sourceCode.getTokenAfter(startToken) : startToken;
+						let ifBlockMaybeUnsafe = elseNode.parent.consequent.type !== "BlockStatement" && lastIfToken.value !== ";", elseBlockUnsafe = /^[([/+`-]/u.test(firstTokenOfElseBlock.value);
+						if (ifBlockMaybeUnsafe && elseBlockUnsafe) return null;
+						let endToken = sourceCode.getLastToken(elseNode), lastTokenOfElseBlock = sourceCode.getTokenBefore(endToken);
+						if (lastTokenOfElseBlock.value !== ";") {
+							let nextToken = sourceCode.getTokenAfter(endToken), nextTokenUnsafe = nextToken && /^[([/+`-]/u.test(nextToken.value), nextTokenOnSameLine = nextToken && nextToken.loc.start.line === lastTokenOfElseBlock.loc.start.line;
+							if (nextTokenUnsafe || nextTokenOnSameLine && nextToken.value !== "}") return null;
+						}
+						return fixedSource = startToken.type === "Punctuator" && startToken.value === "{" ? source.slice(1, -1) : source, new FixTracker(fixer, sourceCode).retainEnclosingFunction(elseNode).replaceTextRange([elseToken.range[0], elseNode.range[1]], fixedSource);
+					}
+				});
+			}
+			/**
+			* Check to see if the node is a ReturnStatement
+			* @param {Node} node The node being evaluated
+			* @returns {boolean} True if node is a return
+			*/
+			function checkForReturn(node) {
+				return node.type === "ReturnStatement";
+			}
+			/**
+			* Naive return checking, does not iterate through the whole
+			* BlockStatement because we make the assumption that the ReturnStatement
+			* will be the last node in the body of the BlockStatement.
+			* @param {Node} node The consequent/alternate node
+			* @returns {boolean} True if it has a return
+			*/
+			function naiveHasReturn(node) {
+				if (node.type === "BlockStatement") {
+					let lastChildNode = node.body.at(-1);
+					return lastChildNode && checkForReturn(lastChildNode);
+				}
+				return checkForReturn(node);
+			}
+			/**
+			* Check to see if the node is valid for evaluation,
+			* meaning it has an else.
+			* @param {Node} node The node being evaluated
+			* @returns {boolean} True if the node is valid
+			*/
+			function hasElse(node) {
+				return node.alternate && node.consequent;
+			}
+			/**
+			* If the consequent is an IfStatement, check to see if it has an else
+			* and both its consequent and alternate path return, meaning this is
+			* a nested case of rule violation.  If-Else not considered currently.
+			* @param {Node} node The consequent node
+			* @returns {boolean} True if this is a nested rule violation
+			*/
+			function checkForIf(node) {
+				return node.type === "IfStatement" && hasElse(node) && naiveHasReturn(node.alternate) && naiveHasReturn(node.consequent);
+			}
+			/**
+			* Check the consequent/body node to make sure it is not
+			* a ReturnStatement or an IfStatement that returns on both
+			* code paths.
+			* @param {Node} node The consequent or body node
+			* @returns {boolean} `true` if it is a Return/If node that always returns.
+			*/
+			function checkForReturnOrIf(node) {
+				return checkForReturn(node) || checkForIf(node);
+			}
+			/**
+			* Check whether a node returns in every codepath.
+			* @param {Node} node The node to be checked
+			* @returns {boolean} `true` if it returns on every codepath.
+			*/
+			function alwaysReturns(node) {
+				return node.type === "BlockStatement" ? node.body.some(checkForReturnOrIf) : checkForReturnOrIf(node);
+			}
+			/**
+			* Check the if statement, but don't catch else-if blocks.
+			* @returns {void}
+			* @param {Node} node The node for the if statement to check
+			* @private
+			*/
+			function checkIfWithoutElse(node) {
+				let parent = node.parent;
+				if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) return;
+				let consequents = [], alternate;
+				for (let currentNode = node; currentNode.type === "IfStatement"; currentNode = currentNode.alternate) {
+					if (!currentNode.alternate) return;
+					consequents.push(currentNode.consequent), alternate = currentNode.alternate;
+				}
+				consequents.every(alwaysReturns) && displayReport(alternate);
+			}
+			/**
+			* Check the if statement
+			* @returns {void}
+			* @param {Node} node The node for the if statement to check
+			* @private
+			*/
+			function checkIfWithElse(node) {
+				let parent = node.parent;
+				if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) return;
+				let alternate = node.alternate;
+				alternate && alwaysReturns(node.consequent) && displayReport(alternate);
+			}
+			return { "IfStatement:exit": allowElseIf ? checkIfWithoutElse : checkIfWithElse };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-else-return.cjs
+module.exports = require_no_else_return().create;
+//#endregion

package/rules/no-empty-character-class.cjs

@@ -0,0 +1,47 @@
+const require_chunk = require("../common/chunk.cjs"), require_regexpp$1 = require("../common/regexpp.cjs");
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-empty-character-class.js
+/**
+* @fileoverview Rule to flag the use of empty character classes in regular expressions
+* @author Ian Christian Myers
+*/
+var require_no_empty_character_class = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let { RegExpParser, visitRegExpAST } = require_regexpp$1.t(), parser = new RegExpParser(), QUICK_TEST_REGEX = /\[\]/u;
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow empty character classes in regular expressions",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-empty-character-class"
+			},
+			schema: [],
+			messages: { unexpected: "Empty class." }
+		},
+		create(context) {
+			return { "Literal[regex]"(node) {
+				let { pattern, flags } = node.regex;
+				if (!QUICK_TEST_REGEX.test(pattern)) return;
+				let regExpAST;
+				try {
+					regExpAST = parser.parsePattern(pattern, 0, pattern.length, {
+						unicode: flags.includes("u"),
+						unicodeSets: flags.includes("v")
+					});
+				} catch {
+					return;
+				}
+				visitRegExpAST(regExpAST, { onCharacterClassEnter(characterClass) {
+					!characterClass.negate && characterClass.elements.length === 0 && context.report({
+						node,
+						messageId: "unexpected"
+					});
+				} });
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-empty-character-class.cjs
+module.exports = require_no_empty_character_class().create;
+//#endregion

package/rules/no-empty-function.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/no-empty-function.js
+/**
+* @fileoverview Rule to disallow empty functions.
+* @author Toru Nagashima
+*/
+var require_no_empty_function = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t(), ALLOW_OPTIONS = Object.freeze([
+		"functions",
+		"arrowFunctions",
+		"generatorFunctions",
+		"methods",
+		"generatorMethods",
+		"getters",
+		"setters",
+		"constructors",
+		"asyncFunctions",
+		"asyncMethods",
+		"privateConstructors",
+		"protectedConstructors",
+		"decoratedFunctions",
+		"overrideMethods"
+	]);
+	/**
+	* Gets the kind of a given function node.
+	* @param {ASTNode} node A function node to get. This is one of
+	*      an ArrowFunctionExpression, a FunctionDeclaration, or a
+	*      FunctionExpression.
+	* @returns {string} The kind of the function. This is one of "functions",
+	*      "arrowFunctions", "generatorFunctions", "asyncFunctions", "methods",
+	*      "generatorMethods", "asyncMethods", "getters", "setters", and
+	*      "constructors".
+	*/
+	function getKind(node) {
+		let parent = node.parent, kind;
+		if (node.type === "ArrowFunctionExpression") return "arrowFunctions";
+		if (parent.type === "Property") {
+			if (parent.kind === "get") return "getters";
+			if (parent.kind === "set") return "setters";
+			kind = parent.method ? "methods" : "functions";
+		} else if (parent.type === "MethodDefinition") {
+			if (parent.kind === "get") return "getters";
+			if (parent.kind === "set") return "setters";
+			if (parent.kind === "constructor") return "constructors";
+			kind = "methods";
+		} else kind = "functions";
+		let prefix;
+		if (node.generator) prefix = "generator";
+		else if (node.async) prefix = "async";
+		else return kind;
+		return prefix + kind[0].toUpperCase() + kind.slice(1);
+	}
+	/**
+	* Checks if a constructor function has parameter properties.
+	* @param {ASTNode} node The function node to examine.
+	* @returns {boolean} True if the constructor has parameter properties, false otherwise.
+	*/
+	function isParameterPropertiesConstructor(node) {
+		return node.params.some((param) => param.type === "TSParameterProperty");
+	}
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			dialects: ["javascript", "typescript"],
+			language: "javascript",
+			hasSuggestions: !0,
+			type: "suggestion",
+			defaultOptions: [{ allow: [] }],
+			docs: {
+				description: "Disallow empty functions",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-empty-function"
+			},
+			schema: [{
+				type: "object",
+				properties: { allow: {
+					type: "array",
+					items: { enum: ALLOW_OPTIONS },
+					uniqueItems: !0
+				} },
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpected: "Unexpected empty {{name}}.",
+				suggestComment: "Add comment inside empty {{name}}."
+			}
+		},
+		create(context) {
+			let [{ allow }] = context.options, sourceCode = context.sourceCode;
+			/**
+			* Checks if the given function node is allowed to be empty.
+			* @param {ASTNode} node The function node to check.
+			* @returns {boolean} True if the function is allowed to be empty, false otherwise.
+			*/
+			function isAllowedEmptyFunction(node) {
+				let kind = getKind(node);
+				return !!(allow.includes(kind) || kind === "constructors" && (node.parent.accessibility === "private" && allow.includes("privateConstructors") || node.parent.accessibility === "protected" && allow.includes("protectedConstructors") || isParameterPropertiesConstructor(node)) || /(?:g|s)etters|methods$/iu.test(kind) && (node.parent.decorators?.length && allow.includes("decoratedFunctions") || node.parent.override && allow.includes("overrideMethods")));
+			}
+			/**
+			* Reports a given function node if the node matches the following patterns.
+			*
+			* - Not allowed by options.
+			* - The body is empty.
+			* - The body doesn't have any comments.
+			* @param {ASTNode} node A function node to report. This is one of
+			*      an ArrowFunctionExpression, a FunctionDeclaration, or a
+			*      FunctionExpression.
+			* @returns {void}
+			*/
+			function reportIfEmpty(node) {
+				let name = astUtils.getFunctionNameWithKind(node), innerComments = sourceCode.getTokens(node.body, {
+					includeComments: !0,
+					filter: astUtils.isCommentToken
+				});
+				!isAllowedEmptyFunction(node) && node.body.type === "BlockStatement" && node.body.body.length === 0 && innerComments.length === 0 && context.report({
+					node,
+					loc: node.body.loc,
+					messageId: "unexpected",
+					data: { name },
+					suggest: [{
+						messageId: "suggestComment",
+						data: { name },
+						fix(fixer) {
+							let range = [node.body.range[0] + 1, node.body.range[1] - 1];
+							return fixer.replaceTextRange(range, " /* empty */ ");
+						}
+					}]
+				});
+			}
+			return {
+				ArrowFunctionExpression: reportIfEmpty,
+				FunctionDeclaration: reportIfEmpty,
+				FunctionExpression: reportIfEmpty
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-empty-function.cjs
+module.exports = require_no_empty_function().create;
+//#endregion

package/rules/no-empty-pattern.cjs

@@ -0,0 +1,50 @@
+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-empty-pattern.js
+/**
+* @fileoverview Rule to disallow an empty pattern
+* @author Alberto Rodríguez
+*/
+var require_no_empty_pattern = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "problem",
+			defaultOptions: [{ allowObjectPatternsAsParameters: !1 }],
+			docs: {
+				description: "Disallow empty destructuring patterns",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-empty-pattern"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowObjectPatternsAsParameters: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: { unexpected: "Unexpected empty {{type}} pattern." }
+		},
+		create(context) {
+			let [{ allowObjectPatternsAsParameters }] = context.options;
+			return {
+				ObjectPattern(node) {
+					node.properties.length > 0 || allowObjectPatternsAsParameters && (astUtils.isFunction(node.parent) || node.parent.type === "AssignmentPattern" && astUtils.isFunction(node.parent.parent) && node.parent.right.type === "ObjectExpression" && node.parent.right.properties.length === 0) || context.report({
+						node,
+						messageId: "unexpected",
+						data: { type: "object" }
+					});
+				},
+				ArrayPattern(node) {
+					node.elements.length === 0 && context.report({
+						node,
+						messageId: "unexpected",
+						data: { type: "array" }
+					});
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-empty-pattern.cjs
+module.exports = require_no_empty_pattern().create;
+//#endregion

package/rules/no-empty-static-block.cjs

@@ -0,0 +1,50 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-empty-static-block.js
+/**
+* @fileoverview Rule to disallow empty static blocks.
+* @author Sosuke Suzuki
+*/
+var require_no_empty_static_block = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			hasSuggestions: !0,
+			type: "suggestion",
+			docs: {
+				description: "Disallow empty static blocks",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-empty-static-block"
+			},
+			schema: [],
+			messages: {
+				unexpected: "Unexpected empty static block.",
+				suggestComment: "Add comment inside empty static block."
+			}
+		},
+		create(context) {
+			let sourceCode = context.sourceCode;
+			return { StaticBlock(node) {
+				if (node.body.length === 0) {
+					let openingBrace = sourceCode.getFirstToken(node, { skip: 1 }), closingBrace = sourceCode.getLastToken(node);
+					sourceCode.getCommentsBefore(closingBrace).length === 0 && context.report({
+						loc: {
+							start: openingBrace.loc.start,
+							end: closingBrace.loc.end
+						},
+						messageId: "unexpected",
+						suggest: [{
+							messageId: "suggestComment",
+							fix(fixer) {
+								let range = [openingBrace.range[1], closingBrace.range[0]];
+								return fixer.replaceTextRange(range, " /* empty */ ");
+							}
+						}]
+					});
+				}
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-empty-static-block.cjs
+module.exports = require_no_empty_static_block().create;
+//#endregion

package/rules/no-empty.cjs

@@ -0,0 +1,78 @@
+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-empty.js
+/**
+* @fileoverview Rule to flag use of an empty block statement
+* @author Nicholas C. Zakas
+*/
+var require_no_empty = /* @__PURE__ */ require_chunk.t(((exports, module) => {
+	let astUtils = require_ast_utils$1.t();
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			hasSuggestions: !0,
+			type: "suggestion",
+			defaultOptions: [{ allowEmptyCatch: !1 }],
+			docs: {
+				description: "Disallow empty block statements",
+				recommended: !0,
+				url: "https://eslint.org/docs/latest/rules/no-empty"
+			},
+			schema: [{
+				type: "object",
+				properties: { allowEmptyCatch: { type: "boolean" } },
+				additionalProperties: !1
+			}],
+			messages: {
+				unexpected: "Empty {{type}} statement.",
+				suggestComment: "Add comment inside empty {{type}} statement."
+			}
+		},
+		create(context) {
+			let [{ allowEmptyCatch }] = context.options, sourceCode = context.sourceCode;
+			return {
+				BlockStatement(node) {
+					node.body.length === 0 && (astUtils.isFunction(node.parent) || allowEmptyCatch && node.parent.type === "CatchClause" || sourceCode.getCommentsInside(node).length > 0 || context.report({
+						node,
+						messageId: "unexpected",
+						data: { type: "block" },
+						suggest: [{
+							messageId: "suggestComment",
+							data: { type: "block" },
+							fix(fixer) {
+								let range = [node.range[0] + 1, node.range[1] - 1];
+								return fixer.replaceTextRange(range, " /* empty */ ");
+							}
+						}]
+					}));
+				},
+				SwitchStatement(node) {
+					if (node.cases === void 0 || node.cases.length === 0) {
+						let openingBrace = sourceCode.getTokenAfter(node.discriminant, astUtils.isOpeningBraceToken), closingBrace = sourceCode.getLastToken(node);
+						if (sourceCode.commentsExistBetween(openingBrace, closingBrace)) return;
+						context.report({
+							node,
+							loc: {
+								start: openingBrace.loc.start,
+								end: closingBrace.loc.end
+							},
+							messageId: "unexpected",
+							data: { type: "switch" },
+							suggest: [{
+								messageId: "suggestComment",
+								data: { type: "switch" },
+								fix(fixer) {
+									let range = [openingBrace.range[1], closingBrace.range[0]];
+									return fixer.replaceTextRange(range, " /* empty */ ");
+								}
+							}]
+						});
+					}
+				}
+			};
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-empty.cjs
+module.exports = require_no_empty().create;
+//#endregion

package/rules/no-eq-null.cjs

@@ -0,0 +1,34 @@
+//#region ../../node_modules/.pnpm/eslint@9.39.3_jiti@2.6.1/node_modules/eslint/lib/rules/no-eq-null.js
+/**
+* @fileoverview Rule to flag comparisons to null without a type-checking
+* operator.
+* @author Ian Christian Myers
+*/
+var require_no_eq_null = /* @__PURE__ */ require("../common/chunk.cjs").t(((exports, module) => {
+	/** @type {import('../types').Rule.RuleModule} */
+	module.exports = {
+		meta: {
+			type: "suggestion",
+			docs: {
+				description: "Disallow `null` comparisons without type-checking operators",
+				recommended: !1,
+				url: "https://eslint.org/docs/latest/rules/no-eq-null"
+			},
+			schema: [],
+			messages: { unexpected: "Use '===' to compare with null." }
+		},
+		create(context) {
+			return { BinaryExpression(node) {
+				let badOperator = node.operator === "==" || node.operator === "!=";
+				(node.right.type === "Literal" && node.right.raw === "null" && badOperator || node.left.type === "Literal" && node.left.raw === "null" && badOperator) && context.report({
+					node,
+					messageId: "unexpected"
+				});
+			} };
+		}
+	};
+}));
+//#endregion
+//#region src-js/generated/plugin-eslint/rules/no-eq-null.cjs
+module.exports = require_no_eq_null().create;
+//#endregion