eslint-plugin-wyrm 0.0.10 → 0.0.13

package/dist/rules/discarded-expression-statement.mjs

@@ -0,0 +1,243 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+//#region lib/rules/discarded-expression-statement.ts
+const { name } = path.parse(import.meta.filename);
+const DEFAULT_IGNORE_PROMISES = true;
+const DEFAULT_IGNORED_FUNCTIONS = [];
+const DEFAULT_IGNORED_OBJECTS = [];
+const DEFAULT_IGNORED_METHODS = [];
+var discarded_expression_statement_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid discarding the result of expression statements",
+			pedantic: true,
+			requiresTypeChecking: true
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				ignorePromises: {
+					description: `Whether to ignore floating promises. Default: \`${DEFAULT_IGNORE_PROMISES}\``,
+					type: "boolean"
+				},
+				ignoredFunctions: {
+					description: `Names of functions to ignore. Default: \`${JSON.stringify(DEFAULT_IGNORED_FUNCTIONS)}\``,
+					type: "array",
+					items: { type: "string" }
+				},
+				ignoredObjects: {
+					description: `Names of objects to ignore in method calls. Default: \`${JSON.stringify(DEFAULT_IGNORED_OBJECTS)}\``,
+					type: "array",
+					items: { type: "string" }
+				},
+				ignoredMethods: {
+					description: `Names of methods to ignore. Default: \`${JSON.stringify(DEFAULT_IGNORED_METHODS)}\``,
+					type: "array",
+					items: { type: "string" }
+				}
+			}
+		}],
+		messages: { unusedExpression: "This expression is unused." }
+	},
+	defaultOptions: [{
+		ignorePromises: DEFAULT_IGNORE_PROMISES,
+		ignoredFunctions: DEFAULT_IGNORED_FUNCTIONS,
+		ignoredObjects: DEFAULT_IGNORED_OBJECTS,
+		ignoredMethods: DEFAULT_IGNORED_METHODS
+	}],
+	create(context, [options]) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		let checker;
+		function getChecker() {
+			checker ??= getServices().program.getTypeChecker();
+			return checker;
+		}
+		const windowMethods = [
+			"open",
+			"requestAnimationFrame",
+			"setInterval",
+			"setTimeout"
+		];
+		const ALWAYS_ALLOWED_FUNCTIONS = [
+			...windowMethods,
+			"describe",
+			"onRefetch",
+			"refetch",
+			"render",
+			"set",
+			"setInterval",
+			"setTimeout"
+		];
+		const dateMethods = [
+			"setDate",
+			"setFullYear",
+			"setHours",
+			"setMilliseconds",
+			"setMinutes",
+			"setMonth",
+			"setSeconds",
+			"setTime",
+			"setUTCDate",
+			"setUTCFullYear",
+			"setUTCHours",
+			"setUTCMilliseconds",
+			"setUTCMinutes",
+			"setUTCMonth",
+			"setUTCSeconds"
+		];
+		const testingMethods = [
+			"mock",
+			"mockClear",
+			"mockImplementation",
+			"spyOn",
+			"unmock"
+		];
+		const testingLibraryQueries = [
+			"ByRole",
+			"ByLabelText",
+			"ByPlaceholderText",
+			"ByText",
+			"ByDisplayValue",
+			"ByAltText",
+			"ByTitle",
+			"ByTestId"
+		];
+		const testingLibraryMethodsPrefixes = [
+			"get",
+			"query",
+			"getAll",
+			"queryAll",
+			"find",
+			"findAll"
+		];
+		const testingLibraryMethods = testingLibraryQueries.flatMap((query) => testingLibraryMethodsPrefixes.map((prefix) => `${prefix}${query}`));
+		const ALWAYS_ALLOWED_METHODS = [
+			"add",
+			"assign",
+			"defineProperties",
+			"defineProperty",
+			"delete",
+			"fill",
+			"freeze",
+			"measure",
+			"open",
+			"pop",
+			"push",
+			"reduce",
+			"set",
+			"setQueryData",
+			"splice",
+			"unshift",
+			...dateMethods,
+			...windowMethods,
+			...testingMethods,
+			...testingLibraryMethods
+		];
+		const allowedFunctions = new Set([...options.ignoredFunctions, ...ALWAYS_ALLOWED_FUNCTIONS]);
+		const allowedObjects = new Set(options.ignoredObjects);
+		const allowedMethods = new Set([...options.ignoredMethods, ...ALWAYS_ALLOWED_METHODS]);
+		return { ExpressionStatement(stmt) {
+			const expr = stmt.expression;
+			switch (expr.type) {
+				case AST_NODE_TYPES.AssignmentExpression:
+				case AST_NODE_TYPES.BinaryExpression:
+				case AST_NODE_TYPES.ConditionalExpression:
+				case AST_NODE_TYPES.LogicalExpression:
+				case AST_NODE_TYPES.NewExpression:
+				case AST_NODE_TYPES.SequenceExpression:
+				case AST_NODE_TYPES.TSSatisfiesExpression:
+				case AST_NODE_TYPES.UpdateExpression:
+				case AST_NODE_TYPES.YieldExpression:
+				case AST_NODE_TYPES.ArrayExpression:
+				case AST_NODE_TYPES.ArrayPattern:
+				case AST_NODE_TYPES.ArrowFunctionExpression:
+				case AST_NODE_TYPES.ClassExpression:
+				case AST_NODE_TYPES.FunctionExpression:
+				case AST_NODE_TYPES.Identifier:
+				case AST_NODE_TYPES.ImportExpression:
+				case AST_NODE_TYPES.JSXElement:
+				case AST_NODE_TYPES.JSXFragment:
+				case AST_NODE_TYPES.MemberExpression:
+				case AST_NODE_TYPES.MetaProperty:
+				case AST_NODE_TYPES.ObjectExpression:
+				case AST_NODE_TYPES.ObjectPattern:
+				case AST_NODE_TYPES.Super:
+				case AST_NODE_TYPES.TaggedTemplateExpression:
+				case AST_NODE_TYPES.TemplateLiteral:
+				case AST_NODE_TYPES.ThisExpression:
+				case AST_NODE_TYPES.TSAsExpression:
+				case AST_NODE_TYPES.TSInstantiationExpression:
+				case AST_NODE_TYPES.TSNonNullExpression:
+				case AST_NODE_TYPES.TSTypeAssertion: return;
+				case AST_NODE_TYPES.UnaryExpression:
+					if (expr.operator === "delete" || expr.operator === "void") return;
+					break;
+				case AST_NODE_TYPES.Literal:
+					if (typeof expr.value === "string" && expr.value.startsWith("use ")) return;
+					break;
+				case AST_NODE_TYPES.CallExpression:
+					if (shouldIgnoreCallExpression(expr, allowedFunctions, allowedObjects, allowedMethods)) return;
+					break;
+				case AST_NODE_TYPES.ChainExpression:
+					if (expr.expression.type !== AST_NODE_TYPES.CallExpression) break;
+					if (shouldIgnoreCallExpression(expr.expression, allowedFunctions, allowedObjects, allowedMethods)) return;
+					break;
+				case AST_NODE_TYPES.AwaitExpression:
+					if (expr.argument.type !== AST_NODE_TYPES.CallExpression) break;
+					if (shouldIgnoreCallExpression(expr.argument, allowedFunctions, allowedObjects, allowedMethods)) return;
+					break;
+				default: break;
+			}
+			if (isVoidExpr(stmt.expression)) return;
+			context.report({
+				node: stmt.expression,
+				messageId: "unusedExpression"
+			});
+		} };
+		function isVoidExpr(expression) {
+			const type = getServices().getTypeAtLocation(expression);
+			if (isVoidType(type)) return true;
+			if (expression.type === AST_NODE_TYPES.CallExpression && expression.callee.type === AST_NODE_TYPES.MemberExpression) {
+				const objectType = getServices().getTypeAtLocation(expression.callee.object);
+				if (getChecker().isTypeAssignableTo(type, objectType)) return true;
+			}
+			return false;
+		}
+		function isVoidType(type) {
+			if (type.isUnionOrIntersection()) {
+				if (options.ignorePromises && type.types.some((t) => isPromiseType(t))) return true;
+				return type.types.every((t) => isVoidType(t));
+			}
+			if (getChecker().isArrayType(type) || getChecker().isTupleType(type)) return getChecker().getTypeArguments(type).every((t) => isVoidType(t));
+			if (options.ignorePromises && isPromiseType(type)) return true;
+			const flags = ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Unknown | ts.TypeFlags.Any;
+			return (type.getFlags() & flags) !== 0;
+		}
+	}
+});
+function isPromiseType(type) {
+	return type.getSymbol()?.getName() === "Promise";
+}
+function shouldIgnoreCallExpression(expr, allowedFunctions, allowedObjects, allowedMethods) {
+	switch (expr.callee.type) {
+		case AST_NODE_TYPES.Identifier: return allowedFunctions.has(expr.callee.name);
+		case AST_NODE_TYPES.MemberExpression: {
+			const obj = expr.callee.object;
+			const isAllowedObject = obj.type === AST_NODE_TYPES.Identifier && allowedObjects.has(obj.name);
+			const prop = expr.callee.property;
+			const isAllowedMethod = prop.type === AST_NODE_TYPES.Identifier && allowedMethods.has(prop.name);
+			return isAllowedObject || isAllowedMethod;
+		}
+		default: return false;
+	}
+}
+//#endregion
+export { discarded_expression_statement_default as default };

package/dist/rules/distribute-boolean-casts.d.mts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint1 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/distribute-boolean-casts.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint1.RuleModule<"distributeBooleanCast", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint1.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"distributeBooleanCast", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/distribute-boolean-casts.mjs

@@ -2,7 +2,6 @@ import { createRule } from "../utils/createRule.mjs";
 import { None, Some } from "../utils/option.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/distribute-boolean-casts.ts
 const { name } = path.parse(import.meta.filename);
 var distribute_boolean_casts_default = createRule({
@@ -53,7 +52,9 @@ var distribute_boolean_casts_default = createRule({
 function isBooleanLike(expr) {
 	if (expr.type === AST_NODE_TYPES.UnaryExpression) return expr.operator === "!";
 	if (expr.type === AST_NODE_TYPES.BinaryExpression) switch (expr.operator) {
+		/* v8 ignore next -- @preserve */
 		case "&&": return true;
+		/* v8 ignore next -- @preserve */
 		case "||": return true;
 		case "!=":
 		case "!==":
@@ -86,6 +87,5 @@ function isBooleanCall(node) {
 	if (node.callee.name !== "Boolean") return false;
 	return true;
 }
-
 //#endregion
-export { distribute_boolean_casts_default as default };
+export { distribute_boolean_casts_default as default };

package/dist/rules/duplicate-destructuring.d.mts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint3 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/duplicate-destructuring.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint3.RuleModule<"duplicateKey", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint3.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"duplicateKey", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/duplicate-destructuring.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/duplicate-destructuring.ts
 const { name } = path.parse(import.meta.filename);
 var duplicate_destructuring_default = createRule({
@@ -41,6 +40,5 @@ function extractKeyValue(key) {
 	if (key.value === null) return "null";
 	return key.value.toString();
 }
-
 //#endregion
-export { duplicate_destructuring_default as default };
+export { duplicate_destructuring_default as default };

package/dist/rules/duplicate-object-spread.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/duplicate-object-spread.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"duplicateSpread", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/duplicate-object-spread.mjs

@@ -0,0 +1,44 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/duplicate-object-spread.ts
+const { name } = path.parse(import.meta.filename);
+var duplicate_object_spread_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid duplicate spread elements in object literals",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { duplicateSpread: "This variable is already spread into the object literal" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { ObjectExpression(node) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const prop of node.properties) {
+				if (prop.type !== AST_NODE_TYPES.SpreadElement) continue;
+				if (prop.argument.type !== AST_NODE_TYPES.Identifier) continue;
+				const value = prop.argument.name;
+				if (!seen.has(value)) {
+					seen.add(value);
+					continue;
+				}
+				context.report({
+					node: prop,
+					messageId: "duplicateSpread",
+					*fix(fixer) {
+						yield fixer.remove(prop);
+						const commaToken = context.sourceCode.getTokenAfter(prop);
+						if (commaToken?.type === AST_TOKEN_TYPES.Punctuator && commaToken.value === ",") yield fixer.remove(commaToken);
+					}
+				});
+			}
+		} };
+	}
+});
+//#endregion
+export { duplicate_object_spread_default as default };

package/dist/rules/e.d.mts

@@ -0,0 +1,11 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/e.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noE" | "useOther", [{
+  alternatives: string[];
+}], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/e.mjs

@@ -0,0 +1,87 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { ASTUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/e.ts
+/**
+* @fileoverview
+*
+* In JS, the parameter name `e` is semantically overloaded: it is often used for errors, events, elements...
+* This rule forbids using `e` as a parameter name, in favor of more explicit identifiers like `err`, `evt` or `elt`.
+*/
+const { name } = path.parse(import.meta.filename);
+const DEFAULT_ALTERNATIVES = [
+	"err",
+	"evt",
+	"elt"
+];
+var e_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid using `e` as a parameter name",
+			strict: true
+		},
+		hasSuggestions: true,
+		schema: [{
+			type: "object",
+			properties: { alternatives: {
+				description: `Suggested alternatives for identifier names. Default: \`${JSON.stringify(DEFAULT_ALTERNATIVES)}\``,
+				type: "array",
+				items: { type: "string" }
+			} }
+		}],
+		messages: {
+			noE: "Do not use `e` as a parameter name. Use a less ambiguous name.",
+			useOther: "Use `{{ ident }}` instead"
+		}
+	},
+	defaultOptions: [{ alternatives: DEFAULT_ALTERNATIVES }],
+	create(context, [options]) {
+		return {
+			ArrowFunctionExpression: checkFunction,
+			FunctionExpression: checkFunction,
+			FunctionDeclaration: checkFunction,
+			TSDeclareFunction: checkFunction,
+			TSFunctionType: checkFunction,
+			TSCallSignatureDeclaration: checkFunction,
+			CatchClause(node) {
+				if (node.param?.type !== AST_NODE_TYPES.Identifier) return;
+				checkParam(node.param);
+			}
+		};
+		function checkFunction(node) {
+			for (const param of node.params) {
+				if (param.type !== AST_NODE_TYPES.Identifier) return;
+				checkParam(param);
+			}
+		}
+		function checkParam(param) {
+			if (param.name !== "e") return;
+			const scope = context.sourceCode.getScope(param);
+			const variable = ASTUtils.findVariable(scope, param);
+			/* v8 ignore if -- @preserve */
+			if (!variable) return;
+			const { alternatives } = options;
+			context.report({
+				node: param,
+				messageId: "noE",
+				suggest: alternatives.map((alternative) => ({
+					messageId: "useOther",
+					data: { ident: alternative },
+					*fix(fixer) {
+						for (const ref of variable.references) yield fixer.replaceText(ref.identifier, alternative);
+						if (param.typeAnnotation) {
+							const rng = [param.range[0], param.typeAnnotation.range[0]];
+							yield fixer.replaceTextRange(rng, alternative);
+							return;
+						}
+						yield fixer.replaceText(param, alternative);
+					}
+				}))
+			});
+		}
+	}
+});
+//#endregion
+export { e_default as default };

package/dist/rules/empty-for.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/empty-for.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noEmptyFor", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/empty-for.mjs

@@ -0,0 +1,34 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+//#region lib/rules/empty-for.ts
+const { name } = path.parse(import.meta.filename);
+var empty_for_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid using `for (;;)`",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noEmptyFor: "Use `while (true)` instead of `for (;;)`" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { ForStatement(node) {
+			if (node.init) return;
+			if (node.test) return;
+			if (node.update) return;
+			context.report({
+				node,
+				messageId: "noEmptyFor",
+				fix(fixer) {
+					return fixer.replaceTextRange([node.range[0], node.body.range[0]], "while (true) ");
+				}
+			});
+		} };
+	}
+});
+//#endregion
+export { empty_for_default as default };

package/dist/rules/enum-member.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/enum-member.d.ts
+declare const _default: ESLintUtils.RuleModule<"preferEnumMember", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/enum-member.mjs

@@ -0,0 +1,51 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+//#region lib/rules/enum-member.ts
+const { name } = path.parse(import.meta.filename);
+var enum_member_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Prefer enum members to literals asserted as enum",
+			recommended: true,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { preferEnumMember: "Use `satisfies` instead of `as`" }
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		return { TSAsExpression(node) {
+			if (node.expression.type !== AST_NODE_TYPES.Literal) return;
+			const { value } = node.expression;
+			if (typeof value !== "string" && typeof value !== "number") return;
+			const assertedType = getServices().getTypeFromTypeNode(node.typeAnnotation);
+			if ((assertedType.flags & ts.TypeFlags.EnumLike) === 0) return;
+			if (!assertedType.isUnion()) return;
+			const enumName = assertedType.getSymbol()?.getEscapedName().toString();
+			if (enumName === void 0) return;
+			const member = assertedType.types.filter((t) => t.isStringLiteral() || t.isNumberLiteral()).find((t) => t.value === value);
+			if (member === void 0) return;
+			const memberName = member.getSymbol()?.getEscapedName().toString();
+			if (memberName === void 0) return;
+			context.report({
+				node,
+				messageId: "preferEnumMember",
+				fix(fixer) {
+					return fixer.replaceText(node, `${enumName}.${memberName}`);
+				}
+			});
+		} };
+	}
+});
+//#endregion
+export { enum_member_default as default };

package/dist/rules/eqeq-null.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/eqeq-null.d.ts
+declare const _default: ESLintUtils.RuleModule<"useEqEqEqNull" | "useEqEqEqUndefined" | "constantEquality" | "constantInequality", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/eqeq-null.mjs

@@ -0,0 +1,101 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import * as ts$1 from "typescript";
+//#region lib/rules/eqeq-null.ts
+const { name } = path.parse(import.meta.filename);
+var eqeq_null_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid using `x == null` when equivalent to `x === null`",
+			strict: true,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: {
+			useEqEqEqNull: "Use {{ op }} null",
+			useEqEqEqUndefined: "Use {{ op }} undefined",
+			constantEquality: "`== null` or `== undefined` will always be true because undefined == null",
+			constantInequality: "`!= null` or `!= undefined` will always be false because undefined == null"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		return { BinaryExpression(node) {
+			if (node.operator !== "==" && node.operator !== "!=") return;
+			const maybeExpr = getNullishedComparedNode(node);
+			if (!maybeExpr.some) return;
+			const type = getServices().getTypeAtLocation(maybeExpr.value);
+			const text = context.sourceCode.getText(maybeExpr.value);
+			const strictOperator = node.operator === "==" ? "===" : "!==";
+			if (isNull(type) && !isUndefined(type)) {
+				context.report({
+					node,
+					messageId: "useEqEqEqNull",
+					data: { op: strictOperator },
+					fix(fixer) {
+						return fixer.replaceText(node, `${text} ${strictOperator} null`);
+					}
+				});
+				return;
+			}
+			if (!isNull(type) && isUndefined(type)) {
+				context.report({
+					node,
+					messageId: "useEqEqEqUndefined",
+					data: { op: strictOperator },
+					fix(fixer) {
+						return fixer.replaceText(node, `${text} ${strictOperator} undefined`);
+					}
+				});
+				return;
+			}
+			if (!isOnlyNullish(type)) return;
+			if (node.operator === "==") context.report({
+				node,
+				messageId: "constantEquality"
+			});
+			else context.report({
+				node,
+				messageId: "constantInequality"
+			});
+		} };
+	}
+});
+function isNull(type) {
+	if (type.isUnion()) return type.types.some((t) => isNull(t));
+	return (type.getFlags() & ts$1.TypeFlags.Null) !== 0;
+}
+function isUndefined(type) {
+	if (type.isUnion()) return type.types.some((t) => isUndefined(t));
+	return (type.getFlags() & ts$1.TypeFlags.Undefined) !== 0;
+}
+function isOnlyNullish(type) {
+	if (!type.isUnion()) return false;
+	return type.types.every((t) => isNull(t) || isUndefined(t));
+}
+function getNullishedComparedNode(node) {
+	if (isNullishLiteral(node.left)) return Some(node.right);
+	if (isNullishLiteral(node.right)) return Some(node.left);
+	return None;
+}
+function isNullishLiteral(node) {
+	return isUndefinedLiteral(node) || isNullLiteral(node);
+}
+function isUndefinedLiteral(node) {
+	return node.type === AST_NODE_TYPES.Identifier && node.name === "undefined";
+}
+function isNullLiteral(node) {
+	return node.type === AST_NODE_TYPES.Literal && node.value === null;
+}
+//#endregion
+export { eqeq_null_default as default };