eslint-plugin-wyrm 0.0.10 → 0.0.13

package/dist/rules/no-nullish-ternary.mjs

@@ -0,0 +1,121 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some, getFirstOption } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/no-nullish-ternary.ts
+const { name } = path.parse(import.meta.filename);
+var no_nullish_ternary_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid ternary conditions that can be replaced by optional chains",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noNullishTernary: "Replace this ternary condition by optional chaining" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { ConditionalExpression(node) {
+			const maybeTestResult = analyzeTest(node.test);
+			if (!maybeTestResult.some) return;
+			const testResult = maybeTestResult.value;
+			switch (testResult.kind) {
+				case TestKind.TRUTHY:
+					checkTernary(testResult.ident, node.consequent, node.alternate);
+					break;
+				case TestKind.FALSY:
+					checkTernary(testResult.ident, node.alternate, node.consequent);
+					break;
+				default: {
+					const check = testResult.kind;
+					console.error(`[wyrm] Unexpected test kind: ${check}`);
+				}
+			}
+			function checkTernary(ident, consequent, alternate) {
+				if (!isUndefinedLiteral(alternate)) return;
+				if (consequent.type !== AST_NODE_TYPES.MemberExpression) return;
+				if (consequent.object.type !== AST_NODE_TYPES.Identifier) return;
+				if (consequent.object.name !== ident.name) return;
+				context.report({
+					node,
+					messageId: "noNullishTernary",
+					fix(fixer) {
+						const objTxt = context.sourceCode.getText(consequent.object);
+						const propTxt = context.sourceCode.getText(consequent.property);
+						const txt = consequent.computed ? `${objTxt}?.[${propTxt}]` : `${objTxt}?.${propTxt}`;
+						return fixer.replaceText(node, txt);
+					}
+				});
+			}
+		} };
+	}
+});
+function isUndefinedLiteral(node) {
+	return node.type === AST_NODE_TYPES.Identifier && node.name === "undefined";
+}
+var TestKind = /* @__PURE__ */ function(TestKind) {
+	TestKind["TRUTHY"] = "TRUTHY";
+	TestKind["FALSY"] = "FALSY";
+	return TestKind;
+}(TestKind || {});
+function analyzeTest(test) {
+	switch (test.type) {
+		case AST_NODE_TYPES.Identifier: return Some({
+			kind: TestKind.TRUTHY,
+			ident: test
+		});
+		case AST_NODE_TYPES.BinaryExpression: return getFirstOption([analyzeEqualityCheck(test, test.left, test.right), analyzeEqualityCheck(test, test.right, test.left)]);
+		case AST_NODE_TYPES.UnaryExpression:
+			if (test.operator !== "!") return None;
+			if (test.argument.type === AST_NODE_TYPES.Identifier) return Some({
+				kind: TestKind.FALSY,
+				ident: test.argument
+			});
+			return None;
+		default: return None;
+	}
+}
+function analyzeEqualityCheck(node, left, right) {
+	switch (node.operator) {
+		case "!=":
+		case "!==": {
+			const kind = TestKind.TRUTHY;
+			if (left.type === AST_NODE_TYPES.Identifier && right.type === AST_NODE_TYPES.Literal && right.value === null) return Some({
+				ident: left,
+				kind
+			});
+			if (left.type === AST_NODE_TYPES.Identifier && right.type === AST_NODE_TYPES.Identifier && right.name === "undefined") return Some({
+				ident: left,
+				kind
+			});
+			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "typeof" && right.type === AST_NODE_TYPES.Literal && right.value === "undefined" && left.argument.type === AST_NODE_TYPES.Identifier) return Some({
+				ident: left.argument,
+				kind
+			});
+			return None;
+		}
+		case "==":
+		case "===": {
+			const kind = TestKind.FALSY;
+			if (left.type === AST_NODE_TYPES.Identifier && right.type === AST_NODE_TYPES.Literal && right.value === null) return Some({
+				ident: left,
+				kind
+			});
+			if (left.type === AST_NODE_TYPES.Identifier && right.type === AST_NODE_TYPES.Identifier && right.name === "undefined") return Some({
+				ident: left,
+				kind
+			});
+			if (left.type === AST_NODE_TYPES.UnaryExpression && left.operator === "typeof" && right.type === AST_NODE_TYPES.Literal && right.value === "undefined" && left.argument.type === AST_NODE_TYPES.Identifier) return Some({
+				ident: left.argument,
+				kind
+			});
+			return None;
+		}
+		default: return None;
+	}
+}
+//#endregion
+export { no_nullish_ternary_default as default };

package/dist/rules/no-numbered-comments.d.mts

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

package/dist/rules/no-numbered-comments.mjs

@@ -1,6 +1,5 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
-
 //#region lib/rules/no-numbered-comments.ts
 const { name } = path.parse(import.meta.filename);
 var no_numbered_comments_default = createRule({
@@ -31,6 +30,5 @@ var no_numbered_comments_default = createRule({
 function isNumberedComment(comment) {
 	return /^\d+\. /u.test(comment.value.trim());
 }
-
 //#endregion
-export { no_numbered_comments_default as default };
+export { no_numbered_comments_default as default };

package/dist/rules/no-obvious-any.mjs

@@ -1,8 +1,7 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-
+import * as ts$1 from "typescript";
 //#region lib/rules/no-obvious-any.ts
 const { name } = path.parse(import.meta.filename);
 var no_obvious_any_default = createRule({
@@ -16,7 +15,7 @@ var no_obvious_any_default = createRule({
 		},
 		fixable: "code",
 		schema: [],
-		messages: { noObviousAny: "Do not use `any` when a stricter type can be trivially inferred." }
+		messages: { noObviousAny: "Do not use `any` when a stricter type can be trivially inferred: {{inferredType}}" }
 	},
 	defaultOptions: [],
 	create(context) {
@@ -26,14 +25,14 @@ var no_obvious_any_default = createRule({
 				const scope = context.sourceCode.getScope(stmt.declaration);
 				const variable = ASTUtils.findVariable(scope, stmt.declaration);
 				if (!variable) return false;
-				if (variable.references.some((ref) => ref.resolved?.identifiers.includes(id))) return true;
+				if (variable.identifiers.includes(id)) return true;
 			}
 			if (stmt.type === AST_NODE_TYPES.ExportNamedDeclaration) {
 				const scope = context.sourceCode.getScope(stmt);
-				return stmt.specifiers.map((specifier) => specifier.exported).filter((exported) => exported.type === AST_NODE_TYPES.Identifier).some((exported) => {
-					const variable = ASTUtils.findVariable(scope, exported);
+				return stmt.specifiers.map((specifier) => specifier.local).filter((local) => local.type === AST_NODE_TYPES.Identifier).some((local) => {
+					const variable = ASTUtils.findVariable(scope, local);
 					if (!variable) return false;
-					return variable.references.some((ref) => ref.resolved?.identifiers.includes(id));
+					return variable.identifiers.includes(id);
 				});
 			}
 			return false;
@@ -49,7 +48,7 @@ var no_obvious_any_default = createRule({
 			if (isFunctionExported(node, id)) return;
 			const scope = context.sourceCode.getScope(node);
 			const variable = ASTUtils.findVariable(scope, id);
-			/** v8 ignore next -- @preserve */
+			/* v8 ignore next -- @preserve */
 			if (!variable) return;
 			const allArgs = variable.references.map((ref) => ref.identifier.parent).filter((parent) => parent.type === AST_NODE_TYPES.CallExpression).map((parent) => parent.arguments);
 			for (const [i, param] of node.params.entries()) {
@@ -62,6 +61,7 @@ var no_obvious_any_default = createRule({
 				context.report({
 					node: param,
 					messageId: "noObviousAny",
+					data: { inferredType },
 					fix(fixer) {
 						return fixer.replaceText(typeAnnotation, inferredType);
 					}
@@ -72,7 +72,7 @@ var no_obvious_any_default = createRule({
 			const services = ESLintUtils.getParserServices(context);
 			const checker = services.program.getTypeChecker();
 			const types = args.map((arg) => services.getTypeAtLocation(arg));
-			if (types.some((t) => t.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never))) return null;
+			if (types.some((t) => t.flags & (ts$1.TypeFlags.Any | ts$1.TypeFlags.Unknown | ts$1.TypeFlags.Never))) return null;
 			const typesAsStrings = types.map((widened) => checker.getBaseTypeOfLiteralType(widened)).map((widened) => checker.typeToString(widened));
 			return [...new Set(typesAsStrings)].join(" | ");
 		}
@@ -83,43 +83,53 @@ var no_obvious_any_default = createRule({
 				const { typeAnnotation } = node.id.typeAnnotation;
 				if (typeAnnotation.type !== AST_NODE_TYPES.TSAnyKeyword) return;
 				if (node.init.type === AST_NODE_TYPES.ArrayExpression) {
+					const inferredType = "any[]";
 					context.report({
 						node,
 						messageId: "noObviousAny",
+						data: { inferredType },
 						fix(fixer) {
-							return fixer.replaceText(typeAnnotation, "any[]");
+							return fixer.replaceText(typeAnnotation, inferredType);
 						}
 					});
 					return;
 				}
 				const type = ESLintUtils.getParserServices(context).getTypeAtLocation(node.init);
-				if (type.flags & ts.TypeFlags.NumberLike) {
+				if (type.flags & ts$1.TypeFlags.NumberLike) {
+					const inferredType = "number";
 					context.report({
 						node,
 						messageId: "noObviousAny",
+						data: { inferredType },
 						fix(fixer) {
-							return fixer.replaceText(typeAnnotation, "number");
+							return fixer.replaceText(typeAnnotation, inferredType);
 						}
 					});
 					return;
 				}
-				if (type.flags & ts.TypeFlags.StringLike) {
+				if (type.flags & ts$1.TypeFlags.StringLike) {
+					const inferredType = "string";
 					context.report({
 						node,
 						messageId: "noObviousAny",
+						data: { inferredType },
 						fix(fixer) {
-							return fixer.replaceText(typeAnnotation, "string");
+							return fixer.replaceText(typeAnnotation, inferredType);
 						}
 					});
 					return;
 				}
-				if (type.flags & ts.TypeFlags.BooleanLike) context.report({
-					node,
-					messageId: "noObviousAny",
-					fix(fixer) {
-						return fixer.replaceText(typeAnnotation, "boolean");
-					}
-				});
+				if (type.flags & ts$1.TypeFlags.BooleanLike) {
+					const inferredType = "boolean";
+					context.report({
+						node,
+						messageId: "noObviousAny",
+						data: { inferredType },
+						fix(fixer) {
+							return fixer.replaceText(typeAnnotation, inferredType);
+						}
+					});
+				}
 			},
 			FunctionDeclaration: checkFunction,
 			FunctionExpression: checkFunction,
@@ -136,13 +146,11 @@ function getFunctionName(node) {
 			if (node.parent.type !== AST_NODE_TYPES.VariableDeclarator) return null;
 			if (node.parent.id.type !== AST_NODE_TYPES.Identifier) return null;
 			return node.parent.id;
-		default: {
-			const check = nodeType;
-			console.error(`Unexpected node type: ${check}`);
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected node type: ${nodeType}`);
 			return null;
-		}
 	}
 }
-
 //#endregion
-export { no_obvious_any_default as default };
+export { no_obvious_any_default as default };

package/dist/rules/no-optional-type-guard-param.d.mts

@@ -1,9 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint49 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-optional-type-guard-param.d.ts
-
-declare const _default: _typescript_eslint_utils_ts_eslint49.RuleModule<"optionalTypeGuardParam", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint49.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"optionalTypeGuardParam", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-optional-type-guard-param.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/no-optional-type-guard-param.ts
 /**
 * @fileoverview
@@ -67,6 +66,5 @@ var no_optional_type_guard_param_default = createRule({
 		};
 	}
 });
-
 //#endregion
-export { no_optional_type_guard_param_default as default };
+export { no_optional_type_guard_param_default as default };

package/dist/rules/no-out-of-order-comments.d.mts

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

package/dist/rules/no-out-of-order-comments.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import { None, Some } from "../utils/option.mjs";
 import path from "node:path";
-
 //#region lib/rules/no-out-of-order-comments.ts
 const { name } = path.parse(import.meta.filename);
 var no_out_of_order_comments_default = createRule({
@@ -37,15 +36,12 @@ var no_out_of_order_comments_default = createRule({
 	}
 });
 function getCommentNumber(comment) {
-	const result = /^(?<number>\d+)\. /u.exec(comment.value.trim());
-	if (!result) return None;
-	const capture = result.groups?.["number"];
-	/** v8 ignore if -- @preserve */
-	if (capture === void 0) return None;
+	const plainBulletPointResult = /^(?<number>\d+)\s*[.:)-] /u.exec(comment.value.trim());
+	const prefixResult = /^\w+ (?<number>\d+)\s*[.:)-] /u.exec(comment.value.trim());
+	const capture = plainBulletPointResult?.groups?.["number"] ?? prefixResult?.groups?.["number"];
 	const n = Number(capture);
 	if (!Number.isFinite(n)) return None;
 	return Some(n);
 }
-
 //#endregion
-export { no_out_of_order_comments_default as default };
+export { no_out_of_order_comments_default as default };

package/dist/rules/no-possibly-nullish-equality.d.mts

@@ -2,7 +2,6 @@ import { WyrmPluginDocs } from "../utils/createRule.mjs";
 import { ESLintUtils } from "@typescript-eslint/utils";
 
 //#region lib/rules/no-possibly-nullish-equality.d.ts
-
 declare const _default: ESLintUtils.RuleModule<"noPossiblyNullishEquality" | "noPossiblyNullishLooseEquality" | "noConstantNullishComparison", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
   name: string;
 };

package/dist/rules/no-possibly-nullish-equality.mjs

@@ -1,8 +1,7 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-
+import * as ts$1 from "typescript";
 //#region lib/rules/no-possibly-nullish-equality.ts
 /**
 * @fileoverview
@@ -32,7 +31,6 @@ var no_possibly_nullish_equality_default = createRule({
 			requiresTypeChecking: true,
 			strict: true
 		},
-		fixable: "code",
 		schema: [],
 		messages: {
 			noPossiblyNullishEquality: "You are comparing two values, but if they are both undefined or both null, they will be considered equal. Make sure this is expected.",
@@ -82,34 +80,29 @@ var no_possibly_nullish_equality_default = createRule({
 });
 function isPossiblyNullish(type) {
 	if (type.isUnion() && type.types.some((t) => isPossiblyNullish(t))) return true;
-	return (type.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) !== 0;
+	return (type.flags & (ts$1.TypeFlags.Undefined | ts$1.TypeFlags.Null)) !== 0;
 }
 function nullishTypesIntersect(a, b) {
 	if (isPossiblyNull(a) && !isPossiblyNull(b)) return false;
 	if (isPossiblyUndefined(a) && !isPossiblyUndefined(b)) return false;
-	/* v8 ignore if -- @preserve */
-	if (!isPossiblyNull(a) && isPossiblyNull(b)) return false;
-	/* v8 ignore if -- @preserve */
-	if (!isPossiblyUndefined(a) && isPossiblyUndefined(b)) return false;
 	return true;
 }
 function isPossiblyNull(type) {
 	if (type.isUnion() && type.types.some((t) => isPossiblyNull(t))) return true;
-	return (type.flags & ts.TypeFlags.Null) !== 0;
+	return (type.flags & ts$1.TypeFlags.Null) !== 0;
 }
 function isPossiblyUndefined(type) {
 	if (type.isUnion() && type.types.some((t) => isPossiblyUndefined(t))) return true;
-	return (type.flags & ts.TypeFlags.Undefined) !== 0;
+	return (type.flags & ts$1.TypeFlags.Undefined) !== 0;
 }
 function isConstantNullish(type) {
 	if (type.isUnion() && type.types.every((t) => isConstantNullish(t))) return true;
-	return (type.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) !== 0;
+	return (type.flags & (ts$1.TypeFlags.Undefined | ts$1.TypeFlags.Null)) !== 0;
 }
 function isIdentifier(node) {
 	if (node.type !== AST_NODE_TYPES.Identifier) return false;
 	if (node.name === "undefined") return false;
 	return true;
 }
-
 //#endregion
-export { no_possibly_nullish_equality_default as default };
+export { no_possibly_nullish_equality_default as default };

package/dist/rules/no-redundant-function-declaration.d.mts

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

package/dist/rules/no-redundant-function-declaration.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/no-redundant-function-declaration.ts
 const { name } = path.parse(import.meta.filename);
 var no_redundant_function_declaration_default = createRule({
@@ -57,6 +56,5 @@ var no_redundant_function_declaration_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { no_redundant_function_declaration_default as default };
+export { no_redundant_function_declaration_default as default };

package/dist/rules/no-return-to-void.mjs

@@ -1,7 +1,6 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-
 //#region lib/rules/no-return-to-void.ts
 const { name } = path.parse(import.meta.filename);
 var no_return_to_void_default = createRule({
@@ -70,12 +69,12 @@ function getAllReturnStatements(node) {
 		case AST_NODE_TYPES.ReturnStatement: return [node];
 		case AST_NODE_TYPES.BlockStatement: return node.body.flatMap((stmt) => getAllReturnStatements(stmt));
 		case AST_NODE_TYPES.IfStatement: return [...getAllReturnStatements(node.consequent), ...getAllReturnStatements(node.alternate)].flat();
+		case AST_NODE_TYPES.CatchClause: return getAllReturnStatements(node.body);
 		case AST_NODE_TYPES.TryStatement: return [
 			...getAllReturnStatements(node.block),
 			...getAllReturnStatements(node.handler),
 			...getAllReturnStatements(node.finalizer)
 		].flat();
-		case AST_NODE_TYPES.CatchClause: return getAllReturnStatements(node.body);
 		case AST_NODE_TYPES.DoWhileStatement:
 		case AST_NODE_TYPES.WhileStatement:
 		case AST_NODE_TYPES.ForStatement:
@@ -91,6 +90,5 @@ function isFunctionExpression(node) {
 	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) return true;
 	return false;
 }
-
 //#endregion
-export { no_return_to_void_default as default };
+export { no_return_to_void_default as default };

package/dist/rules/no-self-object-assign.d.mts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint55 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-self-object-assign.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint55.RuleModule<"noSelfObjectAssign" | "noDuplicateSources", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint55.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noSelfObjectAssign" | "noDuplicateSources", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-self-object-assign.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/no-self-object-assign.ts
 const { name } = path.parse(import.meta.filename);
 var no_self_object_assign_default = createRule({
@@ -51,6 +50,5 @@ function getDuplicateEntries(entries) {
 	else seen.add(k);
 	return duplicates;
 }
-
 //#endregion
-export { no_self_object_assign_default as default };
+export { no_self_object_assign_default as default };

package/dist/rules/no-sloppy-length-check.d.mts

@@ -1,9 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint57 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-sloppy-length-check.d.ts
-
-declare const _default: _typescript_eslint_utils_ts_eslint57.RuleModule<"noSloppyLengthCheck" | "noRedundantLengthCheck" | "noConstantLengthCheck", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint57.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noSloppyLengthCheck" | "noRedundantLengthCheck" | "noConstantLengthCheck", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion