eslint-plugin-wyrm 0.0.10 → 0.0.13

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

package/dist/rules/as-unknown-as.mjs

@@ -0,0 +1,30 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/as-unknown-as.ts
+const { name } = path.parse(import.meta.filename);
+var as_unknown_as_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid `as unknown as`",
+			strict: true
+		},
+		schema: [],
+		messages: { noAsUnknownAs: "`as unknown as` is unsafe" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { TSAsExpression(node) {
+			if (node.parent.type !== AST_NODE_TYPES.TSAsExpression) return;
+			if (node.typeAnnotation.type !== AST_NODE_TYPES.TSUnknownKeyword) return;
+			context.report({
+				node,
+				messageId: "noAsUnknownAs"
+			});
+		} };
+	}
+});
+//#endregion
+export { as_unknown_as_default as default };

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

package/dist/rules/await-promise-resolve.mjs

@@ -0,0 +1,41 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/await-promise-resolve.ts
+const { name } = path.parse(import.meta.filename);
+var await_promise_resolve_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid `await Promise.resolve()`",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noAwaitPromiseResolve: "`await Promise.resolve()` is most likely pointless" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { AwaitExpression(node) {
+			if (node.argument.type !== AST_NODE_TYPES.CallExpression) return;
+			if (node.argument.callee.type !== AST_NODE_TYPES.MemberExpression) return;
+			if (node.argument.callee.object.type !== AST_NODE_TYPES.Identifier) return;
+			if (node.argument.callee.property.type !== AST_NODE_TYPES.Identifier) return;
+			if (node.argument.callee.object.name !== "Promise") return;
+			if (node.argument.callee.property.name !== "resolve") return;
+			const args = node.argument.arguments;
+			context.report({
+				node,
+				messageId: "noAwaitPromiseResolve",
+				fix(fixer) {
+					if (args[0]) return fixer.replaceText(node.argument, context.sourceCode.getText(args[0]));
+					if (node.parent.type === AST_NODE_TYPES.ExpressionStatement) return fixer.remove(node.parent);
+					return fixer.replaceText(node, "undefined");
+				}
+			});
+		} };
+	}
+});
+//#endregion
+export { await_promise_resolve_default as default };

package/dist/rules/boolean-coalescing.d.mts

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

package/dist/rules/boolean-coalescing.mjs

@@ -0,0 +1,141 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import * as ts$1 from "typescript";
+//#region lib/rules/boolean-coalescing.ts
+const { name } = path.parse(import.meta.filename);
+var boolean_coalescing_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Prefer distributing boolean casts over nullish coalescing expressions",
+			strict: true,
+			requiresTypeChecking: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { booleanCoalescing: "Distribute boolean casts over this nullish coalescing expression" }
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		return { LogicalExpression(node) {
+			if (node.operator !== "??") return;
+			if (!(isInSimpleNegation(node) || isInBooleanCast(node) || isInCondition(node) || isReturnedFromPredicate(node))) return;
+			if (!isSafeLeftType(getServices().getTypeAtLocation(node.left))) return;
+			context.report({
+				node,
+				messageId: "booleanCoalescing",
+				*fix(fixer) {
+					const range = [node.left.range[1], node.right.range[0]];
+					yield fixer.replaceTextRange(range, " || ");
+					const leftText = context.sourceCode.getText(node.left);
+					yield fixer.replaceText(node.left, `!!(${leftText})`);
+					const rightText = context.sourceCode.getText(node.right);
+					yield fixer.replaceText(node.right, `!!(${rightText})`);
+				}
+			});
+		} };
+	}
+});
+function isSafeLeftType(type) {
+	if (type.isUnion()) return type.types.every((t) => !isFalsyNotNullish(t));
+	return !isFalsyNotNullish(type);
+}
+function isPossiblyFalsy(type) {
+	return (type.flags & ts$1.TypeFlags.PossiblyFalsy) !== 0;
+}
+function isNullish(type) {
+	return (type.flags & (ts$1.TypeFlags.Null | ts$1.TypeFlags.Undefined)) !== 0;
+}
+function isFalsyNotNullish(type) {
+	return isPossiblyFalsy(type) && !isNullish(type);
+}
+function isInBooleanCast(node) {
+	/* v8 ignore if -- @preserve */
+	if (!node.parent) return false;
+	switch (node.parent.type) {
+		case AST_NODE_TYPES.LogicalExpression:
+		case AST_NODE_TYPES.TSAsExpression:
+		case AST_NODE_TYPES.TSNonNullExpression:
+		case AST_NODE_TYPES.TSSatisfiesExpression: return isInBooleanCast(node.parent);
+		case AST_NODE_TYPES.UnaryExpression: return isDoubleNegation(node.parent);
+		case AST_NODE_TYPES.CallExpression: return isBooleanCall(node.parent);
+		default: return false;
+	}
+}
+function isInSimpleNegation(node) {
+	if (!node.parent) return false;
+	if (node.parent.type !== AST_NODE_TYPES.UnaryExpression) return false;
+	if (node.parent.operator !== "!") return false;
+	return true;
+}
+function isDoubleNegation(node) {
+	if (node.operator !== "!") return false;
+	if (node.parent.type !== AST_NODE_TYPES.UnaryExpression) return false;
+	if (node.parent.operator !== "!") return false;
+	return true;
+}
+function isBooleanCall(node) {
+	if (node.callee.type !== AST_NODE_TYPES.Identifier) return false;
+	if (node.callee.name !== "Boolean") return false;
+	return true;
+}
+function isInCondition(node) {
+	/* v8 ignore if -- @preserve */
+	if (!node.parent) return false;
+	switch (node.parent.type) {
+		case AST_NODE_TYPES.LogicalExpression:
+		case AST_NODE_TYPES.TSAsExpression:
+		case AST_NODE_TYPES.TSNonNullExpression:
+		case AST_NODE_TYPES.TSSatisfiesExpression: return isInCondition(node.parent);
+		case AST_NODE_TYPES.IfStatement:
+		case AST_NODE_TYPES.ConditionalExpression:
+		case AST_NODE_TYPES.DoWhileStatement:
+		case AST_NODE_TYPES.WhileStatement: return node === node.parent.test;
+		default: return false;
+	}
+}
+function isPredicate(fn) {
+	if (fn.parent.type !== AST_NODE_TYPES.CallExpression) return false;
+	if (fn.parent.arguments[0] !== fn) return false;
+	if (fn.parent.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (fn.parent.callee.property.type !== AST_NODE_TYPES.Identifier) return false;
+	if (![
+		"every",
+		"some",
+		"filter",
+		"find",
+		"findIndex",
+		"findLast",
+		"findLastIndex"
+	].includes(fn.parent.callee.property.name)) return false;
+	return true;
+}
+function isReturnedFromPredicate(node) {
+	/* v8 ignore if -- @preserve */
+	if (!node.parent) return false;
+	switch (node.parent.type) {
+		case AST_NODE_TYPES.LogicalExpression:
+		case AST_NODE_TYPES.TSAsExpression:
+		case AST_NODE_TYPES.TSNonNullExpression:
+		case AST_NODE_TYPES.TSSatisfiesExpression:
+		case AST_NODE_TYPES.ReturnStatement: return isReturnedFromPredicate(node.parent);
+		case AST_NODE_TYPES.BlockStatement:
+			if (node.parent.parent.type === AST_NODE_TYPES.FunctionExpression || node.parent.parent.type === AST_NODE_TYPES.ArrowFunctionExpression) return isPredicate(node.parent.parent);
+			return false;
+		case AST_NODE_TYPES.ArrowFunctionExpression: return isPredicate(node.parent);
+		case AST_NODE_TYPES.IfStatement:
+		case AST_NODE_TYPES.ConditionalExpression:
+			if (node === node.parent.test) return false;
+			return isReturnedFromPredicate(node.parent);
+		default: return false;
+	}
+}
+//#endregion
+export { boolean_coalescing_default as default };

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

package/dist/rules/comment-duplicate-leading-space.mjs

@@ -0,0 +1,34 @@
+import { createRule } from "../utils/createRule.mjs";
+import path from "node:path";
+//#region lib/rules/comment-duplicate-leading-space.ts
+const { name } = path.parse(import.meta.filename);
+var comment_duplicate_leading_space_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid duplicate leading space in comments",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { duplicateSpace: "Remove this duplicate leading space" }
+	},
+	defaultOptions: [],
+	create(context) {
+		if (typeof context.sourceCode.getAllComments === "undefined") return {};
+		const comments = context.sourceCode.getAllComments();
+		for (const comment of comments) if (/^ {2}\w/u.test(comment.value)) context.report({
+			node: comment,
+			messageId: "duplicateSpace",
+			fix(fixer) {
+				const start = comment.range[0];
+				const range = [start + 2, start + 3];
+				return fixer.removeRange(range);
+			}
+		});
+		return {};
+	}
+});
+//#endregion
+export { comment_duplicate_leading_space_default as default };

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

package/dist/rules/conditional-boolean.mjs

@@ -0,0 +1,70 @@
+import { createRule } from "../utils/createRule.mjs";
+import { areTokensEqual } from "../utils/compareTokens.mjs";
+import { None, Option, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+//#region lib/rules/conditional-boolean.ts
+const { name } = path.parse(import.meta.filename);
+var conditional_boolean_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid if/else branches where the only difference is a boolean literal",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noConditionalBoolean: "Collapse this condition to a single statement by using the test as a boolean" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			const { consequent, alternate } = node;
+			if (!alternate) return;
+			const maybeConsequentStmt = getUniqueStatement(consequent);
+			if (!maybeConsequentStmt.some) return;
+			const consequentStmt = maybeConsequentStmt.value;
+			const maybeAlternateStmt = getUniqueStatement(alternate);
+			if (!maybeAlternateStmt.some) return;
+			const alternateStmt = maybeAlternateStmt.value;
+			const consequentTokens = context.sourceCode.getTokens(consequentStmt);
+			const alternateTokens = context.sourceCode.getTokens(alternateStmt);
+			if (consequentTokens.length !== alternateTokens.length) return;
+			const booleanTokens = /* @__PURE__ */ new Set();
+			for (const [i, consequentTok] of consequentTokens.entries()) {
+				const alternateTok = alternateTokens[i];
+				if (!alternateTok) return;
+				if (consequentTok.type !== alternateTok.type) return;
+				if (consequentTok.type === AST_TOKEN_TYPES.Boolean && alternateTok.type === AST_TOKEN_TYPES.Boolean && consequentTok.value !== alternateTok.value) {
+					booleanTokens.add(consequentTok);
+					continue;
+				}
+				if (!areTokensEqual(consequentTok, alternateTok)) return;
+			}
+			if (!booleanTokens.size) return;
+			context.report({
+				node,
+				messageId: "noConditionalBoolean",
+				*fix(fixer) {
+					const testTxt = context.sourceCode.getText(node.test);
+					for (const tok of booleanTokens) {
+						const replacement = tok.value === "true" ? `!!(${testTxt})` : `!(${testTxt})`;
+						yield fixer.replaceTextRange(tok.range, replacement);
+					}
+					const ifRange = [node.range[0], consequentStmt.range[0]];
+					yield fixer.removeRange(ifRange);
+					const elseRange = [consequentStmt.range[1], node.range[1]];
+					yield fixer.removeRange(elseRange);
+				}
+			});
+		} };
+	}
+});
+function getUniqueStatement(stmt) {
+	if (stmt.type !== AST_NODE_TYPES.BlockStatement) return Some(stmt);
+	if (stmt.body.length !== 1) return None;
+	return Option.fromUndef(stmt.body[0]);
+}
+//#endregion
+export { conditional_boolean_default as default };

package/dist/rules/constant-boolean-cast.d.mts

@@ -0,0 +1,9 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/constant-boolean-cast.d.ts
+declare const _default: ESLintUtils.RuleModule<"alwaysFalsy" | "alwaysTruthy" | "truthyPredicate" | "falsyPredicate" | "useFalse" | "useTrue", [], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };

package/dist/rules/constant-boolean-cast.mjs

@@ -0,0 +1,203 @@
+import { createRule } from "../utils/createRule.mjs";
+import { None, Option, Some } from "../utils/option.mjs";
+import path from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import ts from "typescript";
+//#region lib/rules/constant-boolean-cast.ts
+/**
+* @fileoverview
+*
+* This rule only makes sense if you have `strictNullChecks` enabled in your `tsconfig.json` (this is the default for `strict: true`).
+*/
+const { name } = path.parse(import.meta.filename);
+var constant_boolean_cast_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid boolean casts on values with constant truthiness",
+			recommended: true,
+			requiresTypeChecking: true
+		},
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			alwaysFalsy: "This value will always be false",
+			alwaysTruthy: "This value will always be true",
+			truthyPredicate: "This always returns a truthy value",
+			falsyPredicate: "This always returns a falsy value",
+			useFalse: "Replace by `false`",
+			useTrue: "Replace by `true`"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		let services;
+		function getServices() {
+			services ??= ESLintUtils.getParserServices(context);
+			return services;
+		}
+		let checker;
+		function getChecker() {
+			checker ??= getServices().program.getTypeChecker();
+			return checker;
+		}
+		return {
+			UnaryExpression(node) {
+				if (isDoubleNegation(node)) {
+					checkConstantTruthiness(node.parent, node.argument);
+					return;
+				}
+				if (node.operator !== "!") return;
+				if (node.argument.type === AST_NODE_TYPES.UnaryExpression && node.argument.operator === "!") return;
+				checkConstantTruthiness(node, node.argument, true);
+			},
+			CallExpression(node) {
+				if (!isBooleanCall(node)) return;
+				const [arg] = node.arguments;
+				if (!arg) return;
+				checkConstantTruthiness(node, arg);
+			},
+			ArrowFunctionExpression: checkFunctionExpression,
+			FunctionExpression: checkFunctionExpression
+		};
+		function checkFunctionExpression(fn) {
+			if (!isPredicate(fn)) return;
+			const maybeReturnValue = getReturnValue(fn.body);
+			if (!maybeReturnValue.some) {
+				const stmts = getAllReturnStatements(fn.body);
+				if (!stmts.length) return;
+				const returnValues = stmts.map((stmt) => stmt.argument);
+				if (returnValues.every((val) => {
+					if (!val) return false;
+					return isTypeAlwaysTruthy(getServices().getTypeAtLocation(val));
+				})) {
+					context.report({
+						node: fn,
+						messageId: "truthyPredicate"
+					});
+					return;
+				}
+				if (returnValues.every((val) => {
+					if (!val) return true;
+					return isTypeAlwaysFalsy(getServices().getTypeAtLocation(val));
+				})) context.report({
+					node: fn,
+					messageId: "falsyPredicate"
+				});
+				return;
+			}
+			const returnValue = maybeReturnValue.value;
+			if (isSimpleNegation(returnValue)) return;
+			checkConstantTruthiness(returnValue, returnValue);
+		}
+		function checkConstantTruthiness(node, value, negated = false) {
+			const type = getServices().getTypeAtLocation(value);
+			const alwaysFalsy = isTypeAlwaysFalsy(type);
+			const alwaysTruthy = isTypeAlwaysTruthy(type);
+			const nodeText = context.sourceCode.getText(node);
+			if (alwaysFalsy && !negated || alwaysTruthy && negated) context.report({
+				node,
+				messageId: "alwaysFalsy",
+				suggest: nodeText === "false" ? [] : [{
+					messageId: "useFalse",
+					fix(fixer) {
+						return fixer.replaceText(node, "false");
+					}
+				}]
+			});
+			if (alwaysTruthy && !negated || alwaysFalsy && negated) context.report({
+				node,
+				messageId: "alwaysTruthy",
+				suggest: nodeText === "true" ? [] : [{
+					messageId: "useTrue",
+					fix(fixer) {
+						return fixer.replaceText(node, "true");
+					}
+				}]
+			});
+		}
+		function isTypeAlwaysFalsy(type) {
+			if (type.isUnionOrIntersection()) return type.types.every((t) => isTypeAlwaysFalsy(t));
+			const flags = ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void;
+			if ((type.getFlags() & flags) !== 0) return true;
+			if (type.isStringLiteral() || type.isNumberLiteral()) return !type.value;
+			if (type.isLiteral() && typeof type.value === "object") return type.value.base10Value === "0";
+			if (type.getFlags() & ts.TypeFlags.BooleanLiteral) return type !== getChecker().getTrueType();
+			return false;
+		}
+		function isTypeAlwaysTruthy(type) {
+			if (type.isUnionOrIntersection()) return type.types.every((t) => isTypeAlwaysTruthy(t));
+			const flags = ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never;
+			if ((type.getFlags() & flags) !== 0) return false;
+			if ((type.getFlags() & ts.TypeFlags.PossiblyFalsy) === 0) return true;
+			if (type.isStringLiteral() || type.isNumberLiteral()) return !!type.value;
+			if (type.isLiteral() && typeof type.value === "object") return type.value.base10Value !== "0";
+			if (type.getFlags() & ts.TypeFlags.BooleanLiteral) return type !== getChecker().getFalseType();
+			return false;
+		}
+	}
+});
+function isSimpleNegation(node) {
+	if (node.type !== AST_NODE_TYPES.UnaryExpression) return false;
+	if (node.operator !== "!") return false;
+	return true;
+}
+function isDoubleNegation(node) {
+	if (node.operator !== "!") return false;
+	if (!isSimpleNegation(node.parent)) return false;
+	return true;
+}
+function isBooleanCall(node) {
+	if (node.callee.type !== AST_NODE_TYPES.Identifier) return false;
+	if (node.callee.name !== "Boolean") return false;
+	return true;
+}
+function getReturnValue(body) {
+	if (body.type !== AST_NODE_TYPES.BlockStatement) return Some(body);
+	if (body.body.length !== 1) return None;
+	const returnStatement = body.body.find((stmt) => stmt.type === AST_NODE_TYPES.ReturnStatement);
+	if (!returnStatement) return None;
+	if (!returnStatement.argument) return None;
+	return Option.fromUndef(returnStatement.argument);
+}
+function isPredicate(fn) {
+	if (fn.parent.type !== AST_NODE_TYPES.CallExpression) return false;
+	if (fn.parent.arguments[0] !== fn) return false;
+	if (fn.parent.callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (fn.parent.callee.property.type !== AST_NODE_TYPES.Identifier) return false;
+	if (![
+		"every",
+		"some",
+		"filter",
+		"find",
+		"findIndex",
+		"findLast",
+		"findLastIndex"
+	].includes(fn.parent.callee.property.name)) return false;
+	return true;
+}
+function getAllReturnStatements(node) {
+	if (!node) return [];
+	switch (node.type) {
+		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.DoWhileStatement:
+		case AST_NODE_TYPES.WhileStatement:
+		case AST_NODE_TYPES.ForStatement:
+		case AST_NODE_TYPES.ForInStatement:
+		case AST_NODE_TYPES.ForOfStatement: return getAllReturnStatements(node.body);
+		case AST_NODE_TYPES.SwitchCase: return node.consequent.flatMap((stmt) => getAllReturnStatements(stmt));
+		case AST_NODE_TYPES.SwitchStatement: return node.cases.flatMap((c) => getAllReturnStatements(c));
+		default: return [];
+	}
+}
+//#endregion
+export { constant_boolean_cast_default as default };

package/dist/rules/de-morgan.d.mts

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

package/dist/rules/de-morgan.mjs

@@ -2,7 +2,6 @@ import { createRule } from "../utils/createRule.mjs";
 import { isNegatableOperator, negateExpression } from "../utils/negateExpression.mjs";
 import path from "node:path";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
 //#region lib/rules/de-morgan.ts
 const { name } = path.parse(import.meta.filename);
 var de_morgan_default = createRule({
@@ -47,6 +46,5 @@ var de_morgan_default = createRule({
 		} };
 	}
 });
-
 //#endregion
-export { de_morgan_default as default };
+export { de_morgan_default as default };

package/dist/rules/discarded-expression-statement.d.mts

@@ -0,0 +1,14 @@
+import { WyrmPluginDocs } from "../utils/createRule.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+//#region lib/rules/discarded-expression-statement.d.ts
+declare const _default: ESLintUtils.RuleModule<"unusedExpression", [{
+  ignorePromises: boolean;
+  ignoredFunctions: string[];
+  ignoredObjects: string[];
+  ignoredMethods: string[];
+}], WyrmPluginDocs, ESLintUtils.RuleListener> & {
+  name: string;
+};
+//#endregion
+export { _default };