eslint-plugin-wyrm 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.0.7](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.6...eslint-plugin-wyrm-v0.0.7) (2025-11-05)
+
+
+### Bug Fixes
+
+* add distribute-boolean-casts ([a6a7a1d](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/a6a7a1d34fe2dca977bd98fb27337797ce1b1200))
+* add prefer-catch-method ([fb1b614](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/fb1b614f2a2e53c8e2ca197b706f458cbe73ba4a))
+
+## [0.0.6](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.5...eslint-plugin-wyrm-v0.0.6) (2025-11-04)
+
+
+### Bug Fixes
+
+* add no-else-break and no-else-continue ([eb2647f](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/eb2647feb3a5d04782a86db8324259afb70a5369))
+* add no-else-throw ([cedc18e](https://github.com/mchevestrier/eslint-plugin-wyrm/commit/cedc18efd6952c3c3195d378dbd59a8772b7613d))
+
 ## [0.0.5](https://github.com/mchevestrier/eslint-plugin-wyrm/compare/eslint-plugin-wyrm-v0.0.4...eslint-plugin-wyrm-v0.0.5) (2025-11-02)
 
 

package/README.md

@@ -49,14 +49,23 @@ export default defineConfig([
 💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).\
 💭 Requires [type information](https://typescript-eslint.io/linting/typed-linting).
 
-| Name                                                                                                                                                                        | Description                                                     | 💼          | 🔧  | 💡  | 💭  |
-| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------- | :---------- | :-- | :-- | :-- |
-| [no-constant-template-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-constant-template-expression.md) | Disallow constant string expressions in template literals       | ☑️          |     | 💡  | 💭  |
-| [no-empty-comment](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-comment.md)                               | Forbid empty comments                                           | 🟪 ☑️       |     |     |     |
-| [no-empty-jsx-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-jsx-expression.md)                 | Forbid empty JSX expression containers                          | 🟩 ✅ 🟪 ☑️ |     |     |     |
-| [no-extra-nested-boolean-cast](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-extra-nested-boolean-cast.md)       | Forbid extra boolean casts in conditions and predicates         | 🟪 ☑️       |     |     |     |
-| [no-jsx-statement](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-jsx-statement.md)                               | Forbid JSX expression statements                                | 🟩 ✅ 🟪 ☑️ |     |     |     |
-| [no-ternary-return](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-ternary-return.md)                             | Disallow ternary conditions in return statements                | 🟪 ☑️       | 🔧  |     |     |
-| [unsafe-asserted-chain](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/unsafe-asserted-chain.md)                     | Disallow unsafe type assertions on optional chained expressions | ☑️          |     |     | 💭  |
+| Name                                                                                                                                                                        | Description                                                               | 💼          | 🔧  | 💡  | 💭  |
+| :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------ | :---------- | :-- | :-- | :-- |
+| [distribute-boolean-casts](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/distribute-boolean-casts.md)               | Enforce that boolean casts are distributed over logical expressions       | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-constant-template-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-constant-template-expression.md) | Disallow constant string expressions in template literals                 | ☑️          |     | 💡  | 💭  |
+| [no-else-break](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-break.md)                                     | Forbid unnecessary `else` block after a `break` statement                 | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-else-continue](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-continue.md)                               | Forbid unnecessary `else` block after a `continue` statement              | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-else-throw](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-else-throw.md)                                     | Forbid unnecessary `else` block after a `throw` statement                 | 🟩 ✅ 🟪 ☑️ | 🔧  |     |     |
+| [no-empty-comment](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-comment.md)                               | Forbid empty comments                                                     | 🟪 ☑️       |     |     |     |
+| [no-empty-jsx-expression](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-empty-jsx-expression.md)                 | Forbid empty JSX expression containers                                    | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-extra-nested-boolean-cast](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-extra-nested-boolean-cast.md)       | Forbid extra boolean casts in conditions and predicates                   | 🟪 ☑️       |     |     |     |
+| [no-invalid-date-literal](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-invalid-date-literal.md)                 | Disallow invalid date literals                                            | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-jsx-statement](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-jsx-statement.md)                               | Forbid JSX expression statements                                          | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-suspicious-jsx-semicolon](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-suspicious-jsx-semicolon.md)         | Forbid suspicious semicolons in JSX                                       | 🟩 ✅ 🟪 ☑️ |     |     |     |
+| [no-ternary-return](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-ternary-return.md)                             | Disallow ternary conditions in return statements                          | 🟪 ☑️       | 🔧  |     |     |
+| [no-useless-iife](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/no-useless-iife.md)                                 | Forbid useless IIFEs                                                      | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
+| [prefer-catch-method](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/prefer-catch-method.md)                         | Enforce usage of `Promise.prototype.catch()` when it improves readability | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
+| [prefer-repeat](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/prefer-repeat.md)                                     | Enforce usage of `String.prototype.repeat`                                | 🟩 ✅ 🟪 ☑️ |     | 💡  |     |
+| [unsafe-asserted-chain](https://github.com/mchevestrier/eslint-plugin-wyrm/blob/master/packages/eslint-plugin-wyrm/docs/rules/unsafe-asserted-chain.md)                     | Disallow unsafe type assertions on optional chained expressions           | ☑️          |     |     | 💭  |
 
 <!-- end auto-generated rules list -->

package/dist/configs/index.js

@@ -38,7 +38,7 @@ const strictOnly = createConfigWithRules(rules_exports, "strictOnly", (rule) =>
 });
 const strict = {
 	...baseConfig,
-	name: `wyrm/strict`,
+	name: "wyrm/strict",
 	rules: {
 		...recommended.rules,
 		...strictOnly.rules
@@ -51,7 +51,7 @@ const recommendedTypeCheckedOnly = createConfigWithRules(rules_exports, "recomme
 });
 const recommendedTypeChecked = {
 	...baseConfig,
-	name: `wyrm/recommendedTypeChecked`,
+	name: "wyrm/recommendedTypeChecked",
 	rules: {
 		...recommended.rules,
 		...recommendedTypeCheckedOnly.rules
@@ -64,7 +64,7 @@ const strictTypeCheckedOnly = createConfigWithRules(rules_exports, "strictTypeCh
 });
 const strictTypeChecked = {
 	...baseConfig,
-	name: `wyrm/strictTypeChecked`,
+	name: "wyrm/strictTypeChecked",
 	rules: {
 		...recommendedTypeChecked.rules,
 		...strictOnly.rules,

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

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint1 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>;
+//#endregion
+export { _default };

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

@@ -0,0 +1,83 @@
+import { createRule } from "../utils/createRule.js";
+import { None, Some } from "../utils/option.js";
+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({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Enforce that boolean casts are distributed over logical expressions",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { distributeBooleanCast: "Distribute this boolean cast over logical expressions" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { LogicalExpression(node) {
+			if (node.operator === "??") return;
+			const parentCast = getParentBooleanCast(node);
+			if (!parentCast.some) return;
+			context.report({
+				node,
+				messageId: "distributeBooleanCast",
+				fix(fixer) {
+					const left = maybeWrapInBooleanCast(node.left);
+					const right = maybeWrapInBooleanCast(node.right);
+					const newText = `${left} ${node.operator} ${right}`;
+					return fixer.replaceText(parentCast.value, newText);
+				}
+			});
+		} };
+		function maybeWrapInBooleanCast(expr) {
+			const txt = context.sourceCode.getText(expr);
+			if (isBooleanLike(expr)) return txt;
+			return `!!(${txt})`;
+		}
+	}
+});
+function isBooleanLike(expr) {
+	if (expr.type === AST_NODE_TYPES.UnaryExpression) return expr.operator === "!";
+	if (expr.type === AST_NODE_TYPES.BinaryExpression) switch (expr.operator) {
+		case "&&":
+		case "||":
+		case "!=":
+		case "!==":
+		case "==":
+		case "===":
+		case "<":
+		case "<=":
+		case ">":
+		case ">=":
+		case "in":
+		case "instanceof": return true;
+		default: return false;
+	}
+	if (expr.type === AST_NODE_TYPES.Literal) return typeof expr.value === "boolean";
+	return false;
+}
+function getParentBooleanCast(node) {
+	if (!node.parent) return None;
+	if (node.parent.type === AST_NODE_TYPES.UnaryExpression && isDoubleNegation(node.parent)) return Some(node.parent.parent);
+	if (node.parent.type === AST_NODE_TYPES.CallExpression && isBooleanCall(node.parent)) return Some(node.parent);
+	return None;
+}
+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;
+}
+
+//#endregion
+export { distribute_boolean_casts_default as default };

package/dist/rules/index.d.ts

@@ -1,14 +1,23 @@
-import { _default } from "./no-constant-template-expression.js";
-import { _default as _default$1 } from "./no-empty-comment.js";
-import { _default as _default$2 } from "./no-empty-jsx-expression.js";
-import { _default as _default$3 } from "./no-extra-nested-boolean-cast.js";
-import { _default as _default$4 } from "./no-jsx-statement.js";
-import { _default as _default$5 } from "./no-ternary-return.js";
-import { _default as _default$6 } from "./unsafe-asserted-chain.js";
+import { _default } from "./distribute-boolean-casts.js";
+import { _default as _default$1 } from "./no-constant-template-expression.js";
+import { _default as _default$2 } from "./no-else-break.js";
+import { _default as _default$3 } from "./no-else-continue.js";
+import { _default as _default$4 } from "./no-else-throw.js";
+import { _default as _default$5 } from "./no-empty-comment.js";
+import { _default as _default$6 } from "./no-empty-jsx-expression.js";
+import { _default as _default$7 } from "./no-extra-nested-boolean-cast.js";
+import { _default as _default$8 } from "./no-invalid-date-literal.js";
+import { _default as _default$9 } from "./no-jsx-statement.js";
+import { _default as _default$10 } from "./no-suspicious-jsx-semicolon.js";
+import { _default as _default$11 } from "./no-ternary-return.js";
+import { _default as _default$12 } from "./no-useless-iife.js";
+import { _default as _default$13 } from "./prefer-catch-method.js";
+import { _default as _default$14 } from "./prefer-repeat.js";
+import { _default as _default$15 } from "./unsafe-asserted-chain.js";
 
 //#region lib/rules/index.d.ts
 declare namespace index_d_exports {
-  export { _default as "no-constant-template-expression", _default$1 as "no-empty-comment", _default$2 as "no-empty-jsx-expression", _default$3 as "no-extra-nested-boolean-cast", _default$4 as "no-jsx-statement", _default$5 as "no-ternary-return", _default$6 as "unsafe-asserted-chain" };
+  export { _default as "distribute-boolean-casts", _default$1 as "no-constant-template-expression", _default$2 as "no-else-break", _default$3 as "no-else-continue", _default$4 as "no-else-throw", _default$5 as "no-empty-comment", _default$6 as "no-empty-jsx-expression", _default$7 as "no-extra-nested-boolean-cast", _default$8 as "no-invalid-date-literal", _default$9 as "no-jsx-statement", _default$10 as "no-suspicious-jsx-semicolon", _default$11 as "no-ternary-return", _default$12 as "no-useless-iife", _default$13 as "prefer-catch-method", _default$14 as "prefer-repeat", _default$15 as "unsafe-asserted-chain" };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -1,20 +1,38 @@
 import { __export } from "../_virtual/rolldown_runtime.js";
+import distribute_boolean_casts_default from "./distribute-boolean-casts.js";
 import no_constant_template_expression_default from "./no-constant-template-expression.js";
+import no_else_break_default from "./no-else-break.js";
+import no_else_continue_default from "./no-else-continue.js";
+import no_else_throw_default from "./no-else-throw.js";
 import no_empty_comment_default from "./no-empty-comment.js";
 import no_empty_jsx_expression_default from "./no-empty-jsx-expression.js";
 import no_extra_nested_boolean_cast_default from "./no-extra-nested-boolean-cast.js";
+import no_invalid_date_literal_default from "./no-invalid-date-literal.js";
 import no_jsx_statement_default from "./no-jsx-statement.js";
+import no_suspicious_jsx_semicolon_default from "./no-suspicious-jsx-semicolon.js";
 import no_ternary_return_default from "./no-ternary-return.js";
+import no_useless_iife_default from "./no-useless-iife.js";
+import prefer_catch_method_default from "./prefer-catch-method.js";
+import prefer_repeat_default from "./prefer-repeat.js";
 import unsafe_asserted_chain_default from "./unsafe-asserted-chain.js";
 
 //#region lib/rules/index.ts
 var rules_exports = /* @__PURE__ */ __export({
+	"distribute-boolean-casts": () => distribute_boolean_casts_default,
 	"no-constant-template-expression": () => no_constant_template_expression_default,
+	"no-else-break": () => no_else_break_default,
+	"no-else-continue": () => no_else_continue_default,
+	"no-else-throw": () => no_else_throw_default,
 	"no-empty-comment": () => no_empty_comment_default,
 	"no-empty-jsx-expression": () => no_empty_jsx_expression_default,
 	"no-extra-nested-boolean-cast": () => no_extra_nested_boolean_cast_default,
+	"no-invalid-date-literal": () => no_invalid_date_literal_default,
 	"no-jsx-statement": () => no_jsx_statement_default,
+	"no-suspicious-jsx-semicolon": () => no_suspicious_jsx_semicolon_default,
 	"no-ternary-return": () => no_ternary_return_default,
+	"no-useless-iife": () => no_useless_iife_default,
+	"prefer-catch-method": () => prefer_catch_method_default,
+	"prefer-repeat": () => prefer_repeat_default,
 	"unsafe-asserted-chain": () => unsafe_asserted_chain_default
 });
 

package/dist/rules/no-else-break.d.ts

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/no-else-break.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint0.RuleModule<"noElseBreak", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-else-break.js

@@ -0,0 +1,51 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-else-break.ts
+const { name } = path.parse(import.meta.filename);
+var no_else_break_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid unnecessary `else` block after a `break` statement",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noElseBreak: "Remove this unnecessary else" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			const { alternate } = node;
+			if (!alternate) return;
+			const lastConsequentStatement = getLastStatement(node.consequent);
+			if (!lastConsequentStatement) return;
+			if (lastConsequentStatement.type === AST_NODE_TYPES.BreakStatement) context.report({
+				node: alternate,
+				messageId: "noElseBreak",
+				*fix(fixer) {
+					const firstToken = context.sourceCode.getTokenBefore(alternate);
+					if (firstToken) yield fixer.remove(firstToken);
+					yield fixer.remove(alternate);
+					if (alternate.type === AST_NODE_TYPES.BlockStatement) {
+						const bodyText$1 = alternate.body.map((stmt) => context.sourceCode.getText(stmt)).join("\n");
+						yield fixer.insertTextAfter(node, bodyText$1);
+						return;
+					}
+					const bodyText = context.sourceCode.getText(alternate);
+					yield fixer.insertTextAfter(node, bodyText);
+				}
+			});
+		} };
+	}
+});
+function getLastStatement(stmt) {
+	if (stmt.type === AST_NODE_TYPES.BlockStatement) return stmt.body.at(-1);
+	return stmt;
+}
+
+//#endregion
+export { no_else_break_default as default };

package/dist/rules/no-else-continue.d.ts

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint5 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/no-else-continue.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint5.RuleModule<"noElseContinue", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint5.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-else-continue.js

@@ -0,0 +1,51 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-else-continue.ts
+const { name } = path.parse(import.meta.filename);
+var no_else_continue_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid unnecessary `else` block after a `continue` statement",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noElseContinue: "Remove this unnecessary else" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			const { alternate } = node;
+			if (!alternate) return;
+			const lastConsequentStatement = getLastStatement(node.consequent);
+			if (!lastConsequentStatement) return;
+			if (lastConsequentStatement.type === AST_NODE_TYPES.ContinueStatement) context.report({
+				node: alternate,
+				messageId: "noElseContinue",
+				*fix(fixer) {
+					const firstToken = context.sourceCode.getTokenBefore(alternate);
+					if (firstToken) yield fixer.remove(firstToken);
+					yield fixer.remove(alternate);
+					if (alternate.type === AST_NODE_TYPES.BlockStatement) {
+						const bodyText$1 = alternate.body.map((stmt) => context.sourceCode.getText(stmt)).join("\n");
+						yield fixer.insertTextAfter(node, bodyText$1);
+						return;
+					}
+					const bodyText = context.sourceCode.getText(alternate);
+					yield fixer.insertTextAfter(node, bodyText);
+				}
+			});
+		} };
+	}
+});
+function getLastStatement(stmt) {
+	if (stmt.type === AST_NODE_TYPES.BlockStatement) return stmt.body.at(-1);
+	return stmt;
+}
+
+//#endregion
+export { no_else_continue_default as default };

package/dist/rules/no-else-throw.d.ts

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint7 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/no-else-throw.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint7.RuleModule<"noElseThrow", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint7.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-else-throw.js

@@ -0,0 +1,51 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-else-throw.ts
+const { name } = path.parse(import.meta.filename);
+var no_else_throw_default = createRule({
+	name,
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Forbid unnecessary `else` block after a `throw` statement",
+			recommended: true
+		},
+		fixable: "code",
+		schema: [],
+		messages: { noElseThrow: "Remove this unnecessary else" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return { IfStatement(node) {
+			const { alternate } = node;
+			if (!alternate) return;
+			const lastConsequentStatement = getLastStatement(node.consequent);
+			if (!lastConsequentStatement) return;
+			if (lastConsequentStatement.type === AST_NODE_TYPES.ThrowStatement) context.report({
+				node: alternate,
+				messageId: "noElseThrow",
+				*fix(fixer) {
+					const firstToken = context.sourceCode.getTokenBefore(alternate);
+					if (firstToken) yield fixer.remove(firstToken);
+					yield fixer.remove(alternate);
+					if (alternate.type === AST_NODE_TYPES.BlockStatement) {
+						const bodyText$1 = alternate.body.map((stmt) => context.sourceCode.getText(stmt)).join("\n");
+						yield fixer.insertTextAfter(node, bodyText$1);
+						return;
+					}
+					const bodyText = context.sourceCode.getText(alternate);
+					yield fixer.insertTextAfter(node, bodyText);
+				}
+			});
+		} };
+	}
+});
+function getLastStatement(stmt) {
+	if (stmt.type === AST_NODE_TYPES.BlockStatement) return stmt.body.at(-1);
+	return stmt;
+}
+
+//#endregion
+export { no_else_throw_default as default };

package/dist/rules/no-empty-comment.d.ts

@@ -1,9 +1,9 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint0 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint9 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-empty-comment.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint0.RuleModule<"noEmptyComment", [{
+declare const _default: _typescript_eslint_utils_ts_eslint9.RuleModule<"noEmptyComment", [{
   allowStacked: boolean;
-}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint0.RuleListener>;
+}], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint9.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-empty-jsx-expression.d.ts

@@ -1,7 +1,7 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint1 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint11 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-empty-jsx-expression.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint1.RuleModule<"noEmptyJsxExpression", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint1.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint11.RuleModule<"noEmptyJsxExpression", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint11.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-empty-jsx-expression.js

@@ -38,6 +38,7 @@ var no_empty_jsx_expression_default = createRule({
 						return;
 					default: return;
 				}
+				if (node.parent.type === AST_NODE_TYPES.JSXAttribute) return;
 				context.report({
 					node,
 					messageId: "noEmptyJsxExpression"

package/dist/rules/no-extra-nested-boolean-cast.d.ts

@@ -1,8 +1,8 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint3 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint15 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-extra-nested-boolean-cast.d.ts
 
-declare const _default: _typescript_eslint_utils_ts_eslint3.RuleModule<"noExtraBooleanCastInCondition" | "noExtraBooleanCastInPredicate" | "noExtraBooleanCastInsideAnother", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint3.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint15.RuleModule<"noExtraBooleanCastInCondition" | "noExtraBooleanCastInPredicate" | "noExtraBooleanCastInsideAnother", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint15.RuleListener>;
 //#endregion
 export { _default };

package/dist/rules/no-invalid-date-literal.d.ts

@@ -0,0 +1,7 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint3 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/no-invalid-date-literal.d.ts
+declare const _default: _typescript_eslint_utils_ts_eslint3.RuleModule<"noInvalidDateLiteral", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint3.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-invalid-date-literal.js

@@ -0,0 +1,70 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+
+//#region lib/rules/no-invalid-date-literal.ts
+const { name } = path.parse(import.meta.filename);
+var no_invalid_date_literal_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Disallow invalid date literals",
+			recommended: true
+		},
+		schema: [],
+		messages: { noInvalidDateLiteral: "This results in an invalid date" }
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			NewExpression(node) {
+				if (node.callee.type !== AST_NODE_TYPES.Identifier) return;
+				if (node.callee.name !== "Date") return;
+				if (node.arguments.length > 1) return;
+				const [arg] = node.arguments;
+				if (!arg) return;
+				if (arg.type === AST_NODE_TYPES.Identifier) {
+					if (["NaN", "Infinity"].includes(arg.name)) context.report({
+						node,
+						messageId: "noInvalidDateLiteral"
+					});
+					return;
+				}
+				if (arg.type !== AST_NODE_TYPES.Literal) return;
+				if (typeof arg.value === "string" || typeof arg.value === "number") {
+					if (isValidDateLiteral(arg.value)) return;
+					context.report({
+						node,
+						messageId: "noInvalidDateLiteral"
+					});
+				}
+			},
+			CallExpression(node) {
+				const { callee } = node;
+				if (callee.type !== AST_NODE_TYPES.MemberExpression) return;
+				if (callee.object.type !== AST_NODE_TYPES.Identifier) return;
+				if (callee.property.type !== AST_NODE_TYPES.Identifier) return;
+				if (callee.object.name !== "Date") return;
+				if (callee.property.name !== "parse") return;
+				const [arg] = node.arguments;
+				if (!arg) return;
+				if (arg.type !== AST_NODE_TYPES.Literal) return;
+				if (typeof arg.value === "string") {
+					if (isValidDateLiteral(arg.value)) return;
+					context.report({
+						node,
+						messageId: "noInvalidDateLiteral"
+					});
+				}
+			}
+		};
+	}
+});
+function isValidDateLiteral(literal) {
+	const value = new Date(literal).valueOf();
+	return !Number.isNaN(value);
+}
+
+//#endregion
+export { no_invalid_date_literal_default as default };

package/dist/rules/no-jsx-statement.d.ts

@@ -1,7 +1,7 @@
 import { WyrmPluginDocs } from "../utils/createRule.js";
-import * as _typescript_eslint_utils_ts_eslint5 from "@typescript-eslint/utils/ts-eslint";
+import * as _typescript_eslint_utils_ts_eslint13 from "@typescript-eslint/utils/ts-eslint";
 
 //#region lib/rules/no-jsx-statement.d.ts
-declare const _default: _typescript_eslint_utils_ts_eslint5.RuleModule<"noJsxExpressionStatement", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint5.RuleListener>;
+declare const _default: _typescript_eslint_utils_ts_eslint13.RuleModule<"noJsxExpressionStatement", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint13.RuleListener>;
 //#endregion
 export { _default };

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

@@ -0,0 +1,8 @@
+import { WyrmPluginDocs } from "../utils/createRule.js";
+import * as _typescript_eslint_utils_ts_eslint17 from "@typescript-eslint/utils/ts-eslint";
+
+//#region lib/rules/no-suspicious-jsx-semicolon.d.ts
+
+declare const _default: _typescript_eslint_utils_ts_eslint17.RuleModule<"noSuspiciousJsxSemicolon" | "noSuspiciousJsxComma", [], WyrmPluginDocs, _typescript_eslint_utils_ts_eslint17.RuleListener>;
+//#endregion
+export { _default };

package/dist/rules/no-suspicious-jsx-semicolon.js

@@ -0,0 +1,39 @@
+import { createRule } from "../utils/createRule.js";
+import path from "node:path";
+
+//#region lib/rules/no-suspicious-jsx-semicolon.ts
+const { name } = path.parse(import.meta.filename);
+var no_suspicious_jsx_semicolon_default = createRule({
+	name,
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Forbid suspicious semicolons in JSX",
+			recommended: true
+		},
+		schema: [],
+		messages: {
+			noSuspiciousJsxSemicolon: "This semicolon looks suspiciously out of place. Did you add it on purpose?",
+			noSuspiciousJsxComma: "This comma looks suspiciously out of place. Did you add it on purpose?"
+		}
+	},
+	defaultOptions: [],
+	create(context) {
+		return { JSXText(node) {
+			if (node.value.trim() === ";") {
+				context.report({
+					node,
+					messageId: "noSuspiciousJsxSemicolon"
+				});
+				return;
+			}
+			if (node.value.trimEnd() === ",") context.report({
+				node,
+				messageId: "noSuspiciousJsxComma"
+			});
+		} };
+	}
+});
+
+//#endregion
+export { no_suspicious_jsx_semicolon_default as default };