eslint-plugin-wyrm 0.0.10 → 0.0.13

package/dist/rules/no-sloppy-length-check.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/no-sloppy-length-check.ts
 /**
 * @fileoverview
@@ -58,7 +57,8 @@ var no_sloppy_length_check_default = createRule({
 			checkFlags(flags, info, node);
 		}
 		function getFlagsForLogicalOrBinaryExpression(node) {
-			if (isSymmetricBinaryExpression(node)) return getFlagsForBinaryExpression(node);
+			const expr = getSymmetricBinaryExpression(node);
+			if (expr) return getFlagsForBinaryExpression(expr);
 			if (node.type === AST_NODE_TYPES.LogicalExpression) return getFlagsForLogicalExpression(node);
 			return None;
 		}
@@ -95,15 +95,16 @@ var no_sloppy_length_check_default = createRule({
 				checkLogicalExpression(node);
 			},
 			BinaryExpression(node) {
-				if (!isSymmetricBinaryExpression(node)) return;
-				checkBinaryExpression(node);
+				const expr = getSymmetricBinaryExpression(node);
+				if (!expr) return;
+				checkBinaryExpression(expr);
 			}
 		};
 	}
 });
 function getFlagsForBinaryExpression(node) {
-	const { operator } = node;
-	if (!isComparisonOperator(operator)) return None;
+	const operator = getComparisonOperator(node.operator);
+	if (!operator) return None;
 	const maybeInfo = extractComparisonInfo({
 		...node,
 		operator
@@ -114,12 +115,12 @@ function getFlagsForBinaryExpression(node) {
 		info: maybeInfo.value
 	});
 }
-var Flags = /* @__PURE__ */ function(Flags$1) {
-	Flags$1[Flags$1["UNKNOWN"] = 0] = "UNKNOWN";
-	Flags$1[Flags$1["INFERIOR_TO_ZERO"] = 1] = "INFERIOR_TO_ZERO";
-	Flags$1[Flags$1["EQUAL_TO_ZERO"] = 2] = "EQUAL_TO_ZERO";
-	Flags$1[Flags$1["SUPERIOR_TO_ZERO"] = 4] = "SUPERIOR_TO_ZERO";
-	return Flags$1;
+var Flags = /* @__PURE__ */ function(Flags) {
+	Flags[Flags["UNKNOWN"] = 0] = "UNKNOWN";
+	Flags[Flags["INFERIOR_TO_ZERO"] = 1] = "INFERIOR_TO_ZERO";
+	Flags[Flags["EQUAL_TO_ZERO"] = 2] = "EQUAL_TO_ZERO";
+	Flags[Flags["SUPERIOR_TO_ZERO"] = 4] = "SUPERIOR_TO_ZERO";
+	return Flags;
 }(Flags || {});
 function getFlags(info) {
 	const { op, value } = info;
@@ -135,11 +136,10 @@ function getFlags(info) {
 		case ">": return Flags.SUPERIOR_TO_ZERO;
 		case "<=": return Flags.EQUAL_TO_ZERO | Flags.INFERIOR_TO_ZERO;
 		case ">=": return Flags.EQUAL_TO_ZERO | Flags.SUPERIOR_TO_ZERO;
-		default: {
-			const check = op;
-			console.error(`Unexpected binary operator: ${check}`);
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected binary operator: ${op}`);
 			return Flags.UNKNOWN;
-		}
 	}
 }
 function extractNumberLiteralValue(node) {
@@ -153,10 +153,10 @@ function extractNumberLiteralValue(node) {
 	if (!n.some) return None;
 	return Some(-n.value);
 }
-var SizeProperty = /* @__PURE__ */ function(SizeProperty$1) {
-	SizeProperty$1["SIZE"] = "size";
-	SizeProperty$1["LENGTH"] = "length";
-	return SizeProperty$1;
+var SizeProperty = /* @__PURE__ */ function(SizeProperty) {
+	SizeProperty["SIZE"] = "size";
+	SizeProperty["LENGTH"] = "length";
+	return SizeProperty;
 }(SizeProperty || {});
 function getSizeProperty(propertyName) {
 	switch (propertyName) {
@@ -176,11 +176,10 @@ function reverseOperator(op) {
 		case "<=": return ">=";
 		case ">": return "<";
 		case ">=": return "<=";
-		default: {
-			const check = op;
-			console.error(`Unexpected binary operator: ${check}`);
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected binary operator: ${op}`);
 			return op;
-		}
 	}
 }
 function extractComparisonInfo(node, reversed = false) {
@@ -207,11 +206,12 @@ function extractComparisonInfo(node, reversed = false) {
 		op: reversed ? reverseOperator(operator) : operator
 	});
 }
-function isSymmetricBinaryExpression(node) {
-	if (node.type !== AST_NODE_TYPES.BinaryExpression) return false;
-	return node.operator !== "in";
+function getSymmetricBinaryExpression(node) {
+	if (node.type !== AST_NODE_TYPES.BinaryExpression) return null;
+	if (node.operator === "in") return null;
+	return node;
 }
-function isComparisonOperator(operator) {
+function getComparisonOperator(operator) {
 	switch (operator) {
 		case "%":
 		case "&":
@@ -228,7 +228,7 @@ function isComparisonOperator(operator) {
 		case ">>>":
 		case "^":
 		case "in":
-		case "instanceof": return false;
+		case "instanceof": return null;
 		case "!=":
 		case "!==":
 		case "<":
@@ -236,14 +236,12 @@ function isComparisonOperator(operator) {
 		case "==":
 		case "===":
 		case ">":
-		case ">=": return true;
-		default: {
-			const check = operator;
-			console.error(`Unexpected binary operator: ${check}`);
-			return false;
-		}
+		case ">=": return operator;
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected binary operator: ${operator}`);
+			return null;
 	}
 }
-
 //#endregion
-export { no_sloppy_length_check_default as default };
+export { no_sloppy_length_check_default as default };

package/dist/rules/no-suspicious-jsx-semicolon.d.mts

@@ -1,9 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint59 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-suspicious-jsx-semicolon.d.ts
-
-declare const _default: _typescript_eslint_utils_ts_eslint59.RuleModule<"noSuspiciousJsxSemicolon" | "noSuspiciousJsxComma", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint59.RuleListener> & {
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noSuspiciousJsxSemicolon" | "noSuspiciousJsxComma", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-suspicious-jsx-semicolon.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-suspicious-jsx-semicolon.ts
 /**
 * @fileoverview
@@ -28,7 +27,7 @@ var no_suspicious_jsx_semicolon_default = createRule({
 		return { JSXText(node) {
 			/* v8 ignore if -- @preserve */
 			if (node.parent.type !== AST_NODE_TYPES.JSXElement && node.parent.type !== AST_NODE_TYPES.JSXFragment) {
-				const msg = `Did not expect JSXText node to be a child of ${node.parent.type}`;
+				const msg = `[wyrm] Did not expect JSXText node to be a child of ${node.parent.type}`;
 				console.warn(msg);
 				return;
 			}
@@ -52,6 +51,5 @@ var no_suspicious_jsx_semicolon_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { no_suspicious_jsx_semicolon_default as default };
+export { no_suspicious_jsx_semicolon_default as default };

package/dist/rules/no-ternary-return.d.mts

@@ -1,11 +1,10 @@
 import { WyrmPluginDocs } from "../utils/createRule.mjs";
-import * as _typescript_eslint_utils_ts_eslint61 from "@typescript-eslint/utils/ts-eslint";
+import * as _$_typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-ternary-return.d.ts
-
-declare const _default: _typescript_eslint_utils_ts_eslint61.RuleModule<"noTernaryReturn", [{
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noTernaryReturn", [{
   allowSingleLine: boolean;
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint61.RuleListener> & {
+}], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
   name: string;
 };
 //#endregion

package/dist/rules/no-ternary-return.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-ternary-return.ts
 /**
 * @fileoverview
@@ -55,6 +54,5 @@ var no_ternary_return_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { no_ternary_return_default as default };
+export { no_ternary_return_default as default };

package/dist/rules/no-type-guard.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/no-type-guard.d.ts
+declare const _default: _$_typescript_eslint_utils_ts_eslint0.RuleModule<"noTypeGuard", [], WyrmPluginDocs, _$_typescript_eslint_utils_ts_eslint0.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/no-type-guard.mjs

@@ -0,0 +1,36 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/no-type-guard.ts
+const { name } = path.parse(import.meta.filename);
+var no_type_guard_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid type guards",
+			pedantic: true
+		},
+		schema: [],
+		messages: { noTypeGuard: "Type guards are forbidden." }
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			FunctionDeclaration: checkFunction,
+			FunctionExpression: checkFunction,
+			ArrowFunctionExpression: checkFunction
+		};
+		function checkFunction(fn) {
+			if (fn.parent.type === AST_NODE_TYPES.CallExpression) return;
+			if (!fn.returnType) return;
+			if (fn.returnType.typeAnnotation.type !== AST_NODE_TYPES.TSTypePredicate) return;
+			context.report({
+				node: fn,
+				messageId: "noTypeGuard"
+			});
+		}
+	}
+});
+//#endregion
+export { no_type_guard_default as default };

package/dist/rules/no-unassigned-todo.d.mts

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

package/dist/rules/no-unassigned-todo.mjs

@@ -1,6 +1,5 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
-
 //#region lib/rules/no-unassigned-todo.ts
 const { name } = path.parse(import.meta.filename);
 var no_unassigned_todo_default = createRule({
@@ -33,6 +32,5 @@ function hasUnassignedTodo(line) {
 	if (!/^todo(?:\W|$)/u.test(value)) return false;
 	return !/^todo\([^)]+\)/u.test(value);
 }
-
 //#endregion
-export { no_unassigned_todo_default as default };
+export { no_unassigned_todo_default as default };

package/dist/rules/no-unbound-catch-error.d.mts

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

package/dist/rules/no-unbound-catch-error.mjs

@@ -1,6 +1,5 @@
 import { createRule } from "../utils/createRule.mjs";
 import path from "node:path";
-
 //#region lib/rules/no-unbound-catch-error.ts
 const { name } = path.parse(import.meta.filename);
 var no_unbound_catch_error_default = createRule({
@@ -25,6 +24,5 @@ var no_unbound_catch_error_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { no_unbound_catch_error_default as default };
+export { no_unbound_catch_error_default as default };

package/dist/rules/no-unused-mutually-referential.d.mts

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

package/dist/rules/no-unused-mutually-referential.mjs

@@ -0,0 +1,215 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { ASTUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/no-unused-mutually-referential.ts
+/**
+* @fileoverview
+*
+* If two functions both reference each other but are not used anywhere else,
+* tools like TypeScript or ESLint will not mark them as unused.
+*
+* This rule forbids all unused functions, even if they mutually reference each other.
+*/
+const { name } = path.parse(import.meta.filename);
+var no_unused_mutually_referential_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid unused functions, even if mutually referential",
+			strict: true
+		},
+		schema: [],
+		messages: { noUnusedMutuallyReferential: "This function `{{id}}` is probably unused" }
+	},
+	defaultOptions: [],
+	create(context) {
+		function getScope(node) {
+			return context.sourceCode.getScope(node);
+		}
+		function checkFunctionNode(node) {
+			const maybeFn = getIdentifiedFunction(node);
+			if (!maybeFn.value) return;
+			const fn = maybeFn.value;
+			if (!isFunctionUnused(fn, getScope)) return;
+			context.report({
+				node,
+				messageId: "noUnusedMutuallyReferential",
+				data: { id: fn.id.name }
+			});
+		}
+		return {
+			FunctionDeclaration: checkFunctionNode,
+			FunctionExpression: checkFunctionNode,
+			ArrowFunctionExpression: checkFunctionNode
+		};
+	}
+});
+var UsageKind = /* @__PURE__ */ function(UsageKind) {
+	UsageKind["DEFINITELY_USED"] = "DEFINITELY_USED";
+	UsageKind["DEFINITELY_UNUSED"] = "DEFINITELY_UNUSED";
+	UsageKind["IT_DEPENDS"] = "IT_DEPENDS";
+	return UsageKind;
+}(UsageKind || {});
+const DEFINITELY_USED = {
+	kind: UsageKind.DEFINITELY_USED,
+	isUnused: false
+};
+const DEFINITELY_UNUSED = {
+	kind: UsageKind.DEFINITELY_UNUSED,
+	isUnused: true
+};
+function itDepends(usedIn) {
+	return {
+		kind: UsageKind.IT_DEPENDS,
+		usedIn
+	};
+}
+function getFunctionUsage(fn, getScope, cache) {
+	const cached = cache.get(fn.id);
+	if (cached !== void 0) return cached;
+	if (isExported(fn)) return DEFINITELY_USED;
+	const variable = ASTUtils.findVariable(getScope(fn.id), fn.id);
+	/* v8 ignore if -- @preserve */
+	if (!variable) return DEFINITELY_UNUSED;
+	const readReferences = variable.references.filter((ref) => ref.isRead());
+	const usedIn = /* @__PURE__ */ new Map();
+	for (const ref of readReferences) {
+		const maybeParentFn = getParentFunction(ref.identifier);
+		if (!maybeParentFn.some) {
+			if (getIdentUsage(ref.identifier, getScope).kind === UsageKind.DEFINITELY_USED) return DEFINITELY_USED;
+			continue;
+		}
+		const parentFn = maybeParentFn.value;
+		if (parentFn.node === fn.node) continue;
+		usedIn.set(parentFn.id, parentFn.node);
+	}
+	if (!usedIn.size) return DEFINITELY_UNUSED;
+	return itDepends(usedIn);
+}
+function isFunctionUnused(fn, getScope) {
+	const cache = /* @__PURE__ */ new WeakMap();
+	const usage = getFunctionUsage(fn, getScope, cache);
+	cache.set(fn.id, usage);
+	if (usage.kind !== UsageKind.IT_DEPENDS) return usage.isUnused;
+	const usedIn = new Map(usage.usedIn);
+	const unusedFunctions = /* @__PURE__ */ new Set();
+	let gas = 1e3;
+	while (usedIn.size && gas > 0) {
+		gas--;
+		let newFuncsAdded = false;
+		for (const [id, func] of usedIn) {
+			const funcUsage = getFunctionUsage({
+				id,
+				node: func
+			}, getScope, cache);
+			cache.set(id, funcUsage);
+			const { kind } = funcUsage;
+			switch (kind) {
+				case UsageKind.DEFINITELY_USED: return false;
+				case UsageKind.DEFINITELY_UNUSED:
+					usedIn.delete(id);
+					unusedFunctions.add(func);
+					continue;
+				case UsageKind.IT_DEPENDS:
+					for (const [newId, newFunc] of funcUsage.usedIn) {
+						if (usedIn.has(newId)) continue;
+						if (unusedFunctions.has(newFunc)) continue;
+						usedIn.set(newId, newFunc);
+						newFuncsAdded = true;
+					}
+					continue;
+				/* v8 ignore next -- @preserve */
+				default:
+					console.error(`[wyrm] Unexpected UsageKind: ${kind} (wyrm/no-unused-mutually-referential rule)`);
+					return false;
+			}
+		}
+		if (!newFuncsAdded) break;
+	}
+	/* v8 ignore if -- @preserve */
+	if (gas === 0) console.error("[wyrm] Ran out of gas, which should probably never happen. This is probably an infinite loop bug in eslint-plugin-wyrm (wyrm/no-unused-mutually-referential rule)");
+	return true;
+}
+function getIdentUsage(node, getScope) {
+	if (node.type === AST_NODE_TYPES.JSXIdentifier) return DEFINITELY_USED;
+	switch (node.parent.type) {
+		case AST_NODE_TYPES.ExportSpecifier:
+		case AST_NODE_TYPES.ExportDefaultDeclaration: return DEFINITELY_USED;
+		case AST_NODE_TYPES.ExpressionStatement: return DEFINITELY_UNUSED;
+		case AST_NODE_TYPES.CallExpression: return DEFINITELY_USED;
+		case AST_NODE_TYPES.VariableDeclarator:
+			if (node.parent.id === node) {
+				const scope = getScope(node);
+				const variable = ASTUtils.findVariable(scope, node);
+				/* v8 ignore if -- @preserve */
+				if (!variable) return DEFINITELY_UNUSED;
+				if (!variable.references.some((ref) => ref.isRead())) return DEFINITELY_UNUSED;
+				return DEFINITELY_USED;
+			}
+			if (node.parent.id.type === AST_NODE_TYPES.Identifier) return getIdentUsage(node.parent.id, getScope);
+			return DEFINITELY_USED;
+		default: return DEFINITELY_USED;
+	}
+}
+function getIdentifiedFunction(node) {
+	const { type } = node;
+	switch (type) {
+		case AST_NODE_TYPES.FunctionDeclaration: return getIdentifiedFunctionDecl(node);
+		case AST_NODE_TYPES.FunctionExpression:
+		case AST_NODE_TYPES.ArrowFunctionExpression: return getIdentifiedFunctionExpr(node);
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected type: ${type} (wyrm/no-unused-mutually-referential rule)`);
+			return None;
+	}
+}
+function getIdentifiedFunctionDecl(decl) {
+	if (!decl.id) return None;
+	return Some({
+		id: decl.id,
+		node: decl
+	});
+}
+function getIdentifiedFunctionExpr(expr) {
+	if (expr.parent.type !== AST_NODE_TYPES.VariableDeclarator) return None;
+	if (expr.parent.id.type !== AST_NODE_TYPES.Identifier) return None;
+	return Some({
+		id: expr.parent.id,
+		node: expr
+	});
+}
+function isExported(fn) {
+	const { type } = fn.node;
+	switch (type) {
+		case AST_NODE_TYPES.FunctionDeclaration: return fn.node.parent.type === AST_NODE_TYPES.ExportNamedDeclaration || fn.node.parent.type === AST_NODE_TYPES.ExportDefaultDeclaration;
+		case AST_NODE_TYPES.FunctionExpression:
+		case AST_NODE_TYPES.ArrowFunctionExpression: {
+			let node = fn.node;
+			while (node) {
+				if (node.type === AST_NODE_TYPES.ExportNamedDeclaration) return true;
+				node = node.parent;
+			}
+			return false;
+		}
+		/* v8 ignore next -- @preserve */
+		default:
+			console.error(`[wyrm] Unexpected type: ${type} (wyrm/no-unused-mutually-referential rule)`);
+			return false;
+	}
+}
+function getParentFunction(node) {
+	let currentNode = node;
+	let gas = 1e3;
+	while (currentNode && gas > 0) {
+		gas--;
+		if (currentNode.type === AST_NODE_TYPES.FunctionDeclaration || currentNode.type === AST_NODE_TYPES.FunctionExpression || currentNode.type === AST_NODE_TYPES.ArrowFunctionExpression) return getIdentifiedFunction(currentNode);
+		currentNode = currentNode.parent;
+	}
+	/* v8 ignore if -- @preserve */
+	if (gas === 0) console.error("[wyrm] Ran out of gas while climbing up the parent chain. Unless your AST is extremely nested, this is probably an infinite loop bug in eslint-plugin-wyrm (wyrm/no-unused-mutually-referential rule)");
+	return None;
+}
+//#endregion
+export { no_unused_mutually_referential_default as default };

package/dist/rules/no-unused-param-read.d.mts

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

package/dist/rules/no-unused-param-read.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-unused-param-read.ts
 const { name } = path.parse(import.meta.filename);
 var no_unused_param_read_default = createRule({
@@ -29,6 +28,5 @@ var no_unused_param_read_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { no_unused_param_read_default as default };
+export { no_unused_param_read_default as default };

package/dist/rules/no-useless-computed-key.d.mts

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

package/dist/rules/no-useless-computed-key.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-useless-computed-key.ts
 const { name } = path.parse(import.meta.filename);
 var no_useless_computed_key_default = createRule({
@@ -34,6 +33,5 @@ var no_useless_computed_key_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { no_useless_computed_key_default as default };
+export { no_useless_computed_key_default as default };

package/dist/rules/no-useless-iife.d.mts

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

package/dist/rules/no-useless-iife.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/no-useless-iife.ts
 const { name } = path.parse(import.meta.filename);
 var no_useless_iife_default = createRule({
@@ -163,11 +162,11 @@ function nodeHasAwait(node) {
 		case AST_NODE_TYPES.ExportAllDeclaration:
 		case AST_NODE_TYPES.ExportSpecifier:
 		case AST_NODE_TYPES.ExportDefaultDeclaration: return false;
+		/* v8 ignore next -- @preserve */
 		default:
 			if (process.env["NODE_ENV"] === "test") console.error(node.type);
 			return true;
 	}
 }
-
 //#endregion
-export { no_useless_iife_default as default };
+export { no_useless_iife_default as default };

package/dist/rules/no-useless-logical-fallback.d.mts

@@ -2,7 +2,6 @@ import { WyrmPluginDocs } from "../utils/createRule.mjs";
 import { ESLintUtils } from "@typescript-eslint/utils";
 
 //#region lib/rules/no-useless-logical-fallback.d.ts
-
 declare const _default: ESLintUtils.RuleModule<"noConstantExpression" | "noUselessLogicalFallback" | "removeLogicalFallback" | "noNumberOrZero" | "replaceByIsNaNCheck" | "replaceByTrue", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
   name: string;
 };