npm - eslint-plugin-nextfriday - Versions diffs - 1.23.1 → 2.0.0 - Mend

eslint-plugin-nextfriday 1.23.1 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/CHANGELOG.md +16 -0
package/README.md +4 -1
package/docs/rules/JSX_SPREAD_PROPS_LAST.md +42 -0
package/lib/index.cjs +355 -311
package/lib/index.cjs.map +1 -1
package/lib/index.d.cts +42 -0
package/lib/index.d.ts +42 -0
package/lib/index.js +355 -311
package/lib/index.js.map +1 -1
package/package.json +4 -5

package/lib/index.cjs CHANGED Viewed

@@ -42,7 +42,7 @@ var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "1.23.1",
+  version: "2.0.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -117,7 +117,7 @@ var package_default = {
     "@changesets/cli": "^2.31.0",
     "@commitlint/cli": "^20.5.2",
     "@commitlint/config-conventional": "^20.5.0",
-    "@eslint/js": "^9.39.4",
+    "@eslint/js": "^10.0.1",
     "@jest/globals": "^30.3.0",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@swc/core": "^1.15.32",
@@ -128,8 +128,7 @@ var package_default = {
     "@types/ramda": "^0.31.1",
     "@typescript-eslint/parser": "^8.59.1",
     "@typescript-eslint/rule-tester": "^8.59.1",
-    eslint: "^9.39.4",
-    "eslint-config-airbnb-extended": "^3.0.1",
+    eslint: "^10.2.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.4",
     "eslint-plugin-import-x": "^4.16.2",
@@ -146,7 +145,7 @@ var package_default = {
     "typescript-eslint": "^8.59.1"
   },
   peerDependencies: {
-    eslint: "^9.0.0"
+    eslint: "^10.0.0"
   },
   packageManager: "pnpm@9.12.0",
   engines: {
@@ -1871,13 +1870,55 @@ var jsxSortProps = createRule22({
 });
 var jsx_sort_props_default = jsxSortProps;
-// src/rules/newline-after-multiline-block.ts
+// src/rules/jsx-spread-props-last.ts
 var import_utils25 = require("@typescript-eslint/utils");
 var createRule23 = import_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
+var jsxSpreadPropsLast = createRule23({
+  name: "jsx-spread-props-last",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Enforce JSX spread attributes appear after all other props"
+    },
+    messages: {
+      spreadNotLast: "JSX spread attributes must come after all other props."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        const { attributes } = node;
+        let lastNonSpreadIndex = -1;
+        attributes.forEach((attribute, index) => {
+          if (attribute.type !== import_utils25.AST_NODE_TYPES.JSXSpreadAttribute) {
+            lastNonSpreadIndex = index;
+          }
+        });
+        attributes.forEach((attribute, index) => {
+          if (attribute.type === import_utils25.AST_NODE_TYPES.JSXSpreadAttribute && index < lastNonSpreadIndex) {
+            context.report({
+              node: attribute,
+              messageId: "spreadNotLast"
+            });
+          }
+        });
+      }
+    };
+  }
+});
+var jsx_spread_props_last_default = jsxSpreadPropsLast;
+// src/rules/newline-after-multiline-block.ts
+var import_utils26 = require("@typescript-eslint/utils");
+var createRule24 = import_utils26.ESLintUtils.RuleCreator(
+  (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
+);
 function isImportDeclaration(node) {
-  return node.type === import_utils25.AST_NODE_TYPES.ImportDeclaration;
+  return node.type === import_utils26.AST_NODE_TYPES.ImportDeclaration;
 }
 function checkStatements(statements, context) {
   const { sourceCode } = context;
@@ -1912,7 +1953,7 @@ function checkStatements(statements, context) {
     }
   });
 }
-var newlineAfterMultilineBlock = createRule23({
+var newlineAfterMultilineBlock = createRule24({
   name: "newline-after-multiline-block",
   meta: {
     type: "layout",
@@ -1940,11 +1981,11 @@ var newlineAfterMultilineBlock = createRule23({
 var newline_after_multiline_block_default = newlineAfterMultilineBlock;
 // src/rules/newline-before-return.ts
-var import_utils26 = require("@typescript-eslint/utils");
-var createRule24 = import_utils26.ESLintUtils.RuleCreator(
+var import_utils27 = require("@typescript-eslint/utils");
+var createRule25 = import_utils27.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var newlineBeforeReturn = createRule24({
+var newlineBeforeReturn = createRule25({
   name: "newline-before-return",
   meta: {
     type: "layout",
@@ -1962,7 +2003,7 @@ var newlineBeforeReturn = createRule24({
     const { sourceCode } = context;
     function checkReturnStatement(node) {
       const { parent } = node;
-      if (!parent || parent.type !== import_utils26.AST_NODE_TYPES.BlockStatement) {
+      if (!parent || parent.type !== import_utils27.AST_NODE_TYPES.BlockStatement) {
         return;
       }
       const { body: statements } = parent;
@@ -1999,11 +2040,11 @@ var newlineBeforeReturn = createRule24({
 var newline_before_return_default = newlineBeforeReturn;
 // src/rules/nextjs-require-public-env.ts
-var import_utils27 = require("@typescript-eslint/utils");
-var createRule25 = import_utils27.ESLintUtils.RuleCreator(
+var import_utils28 = require("@typescript-eslint/utils");
+var createRule26 = import_utils28.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var nextjsRequirePublicEnv = createRule25({
+var nextjsRequirePublicEnv = createRule26({
   name: "nextjs-require-public-env",
   meta: {
     type: "problem",
@@ -2021,7 +2062,7 @@ var nextjsRequirePublicEnv = createRule25({
     return {
       Program(node) {
         const firstStatement = node.body[0];
-        if (firstStatement?.type === import_utils27.AST_NODE_TYPES.ExpressionStatement && firstStatement.expression.type === import_utils27.AST_NODE_TYPES.Literal && firstStatement.expression.value === "use client") {
+        if (firstStatement?.type === import_utils28.AST_NODE_TYPES.ExpressionStatement && firstStatement.expression.type === import_utils28.AST_NODE_TYPES.Literal && firstStatement.expression.value === "use client") {
           isClientComponent = true;
         }
       },
@@ -2029,7 +2070,7 @@ var nextjsRequirePublicEnv = createRule25({
         if (!isClientComponent) {
           return;
         }
-        if (node.object.type === import_utils27.AST_NODE_TYPES.MemberExpression && node.object.object.type === import_utils27.AST_NODE_TYPES.Identifier && node.object.object.name === "process" && node.object.property.type === import_utils27.AST_NODE_TYPES.Identifier && node.object.property.name === "env" && node.property.type === import_utils27.AST_NODE_TYPES.Identifier) {
+        if (node.object.type === import_utils28.AST_NODE_TYPES.MemberExpression && node.object.object.type === import_utils28.AST_NODE_TYPES.Identifier && node.object.object.name === "process" && node.object.property.type === import_utils28.AST_NODE_TYPES.Identifier && node.object.property.name === "env" && node.property.type === import_utils28.AST_NODE_TYPES.Identifier) {
           const envVarName = node.property.name;
           if (!envVarName.startsWith("NEXT_PUBLIC_") && envVarName !== "NODE_ENV") {
             context.report({
@@ -2048,11 +2089,11 @@ var nextjsRequirePublicEnv = createRule25({
 var nextjs_require_public_env_default = nextjsRequirePublicEnv;
 // src/rules/no-complex-inline-return.ts
-var import_utils28 = require("@typescript-eslint/utils");
-var createRule26 = import_utils28.ESLintUtils.RuleCreator(
+var import_utils29 = require("@typescript-eslint/utils");
+var createRule27 = import_utils29.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noComplexInlineReturn = createRule26({
+var noComplexInlineReturn = createRule27({
   name: "no-complex-inline-return",
   meta: {
     type: "suggestion",
@@ -2068,13 +2109,13 @@ var noComplexInlineReturn = createRule26({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === import_utils28.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils29.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils28.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils29.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils28.AST_NODE_TYPES.NewExpression) {
+      if (node.type === import_utils29.AST_NODE_TYPES.NewExpression) {
         return true;
       }
       return false;
@@ -2094,11 +2135,11 @@ var noComplexInlineReturn = createRule26({
 var no_complex_inline_return_default = noComplexInlineReturn;
 // src/rules/no-direct-date.ts
-var import_utils29 = require("@typescript-eslint/utils");
-var createRule27 = import_utils29.ESLintUtils.RuleCreator(
+var import_utils30 = require("@typescript-eslint/utils");
+var createRule28 = import_utils30.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noDirectDate = createRule27({
+var noDirectDate = createRule28({
   name: "no-direct-date",
   meta: {
     type: "problem",
@@ -2116,7 +2157,7 @@ var noDirectDate = createRule27({
   create(context) {
     return {
       NewExpression(node) {
-        if (node.callee.type === import_utils29.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
+        if (node.callee.type === import_utils30.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
           context.report({
             node,
             messageId: "noNewDate"
@@ -2124,7 +2165,7 @@ var noDirectDate = createRule27({
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils29.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils29.AST_NODE_TYPES.Identifier && node.callee.object.name === "Date" && node.callee.property.type === import_utils29.AST_NODE_TYPES.Identifier) {
+        if (node.callee.type === import_utils30.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils30.AST_NODE_TYPES.Identifier && node.callee.object.name === "Date" && node.callee.property.type === import_utils30.AST_NODE_TYPES.Identifier) {
           const methodName = node.callee.property.name;
           if (methodName === "now") {
             context.report({
@@ -2147,11 +2188,11 @@ var no_direct_date_default = noDirectDate;
 // src/rules/no-emoji.ts
 var import_emoji_regex = __toESM(require("emoji-regex"), 1);
-var import_utils30 = require("@typescript-eslint/utils");
-var createRule28 = import_utils30.ESLintUtils.RuleCreator(
+var import_utils31 = require("@typescript-eslint/utils");
+var createRule29 = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEmoji = createRule28({
+var noEmoji = createRule29({
   name: "no-emoji",
   meta: {
     type: "problem",
@@ -2185,11 +2226,11 @@ var noEmoji = createRule28({
 var no_emoji_default = noEmoji;
 // src/rules/no-env-fallback.ts
-var import_utils31 = require("@typescript-eslint/utils");
-var createRule29 = import_utils31.ESLintUtils.RuleCreator(
+var import_utils32 = require("@typescript-eslint/utils");
+var createRule30 = import_utils32.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noEnvFallback = createRule29({
+var noEnvFallback = createRule30({
   name: "no-env-fallback",
   meta: {
     type: "problem",
@@ -2204,16 +2245,16 @@ var noEnvFallback = createRule29({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== import_utils31.AST_NODE_TYPES.MemberExpression) {
+      if (node.type !== import_utils32.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== import_utils31.AST_NODE_TYPES.MemberExpression) {
+      if (object.type !== import_utils32.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === import_utils31.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils31.AST_NODE_TYPES.Identifier && envNode.name === "env";
+      return processNode.type === import_utils32.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils32.AST_NODE_TYPES.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -2238,11 +2279,11 @@ var noEnvFallback = createRule29({
 var no_env_fallback_default = noEnvFallback;
 // src/rules/no-inline-default-export.ts
-var import_utils32 = require("@typescript-eslint/utils");
-var createRule30 = import_utils32.ESLintUtils.RuleCreator(
+var import_utils33 = require("@typescript-eslint/utils");
+var createRule31 = import_utils33.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noInlineDefaultExport = createRule30({
+var noInlineDefaultExport = createRule31({
   name: "no-inline-default-export",
   meta: {
     type: "suggestion",
@@ -2261,7 +2302,7 @@ var noInlineDefaultExport = createRule30({
     return {
       ExportDefaultDeclaration(node) {
         const { declaration } = node;
-        if (declaration.type === import_utils32.AST_NODE_TYPES.FunctionDeclaration) {
+        if (declaration.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2276,7 +2317,7 @@ var noInlineDefaultExport = createRule30({
             });
           }
         }
-        if (declaration.type === import_utils32.AST_NODE_TYPES.ClassDeclaration) {
+        if (declaration.type === import_utils33.AST_NODE_TYPES.ClassDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2291,7 +2332,7 @@ var noInlineDefaultExport = createRule30({
             });
           }
         }
-        if (declaration.type === import_utils32.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils32.AST_NODE_TYPES.FunctionExpression) {
+        if (declaration.type === import_utils33.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils33.AST_NODE_TYPES.FunctionExpression) {
           context.report({
             node,
             messageId: "noAnonymousDefaultExport",
@@ -2304,14 +2345,14 @@ var noInlineDefaultExport = createRule30({
         if (!declaration) {
           return;
         }
-        if (declaration.type === import_utils32.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
+        if (declaration.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
             data: { type: "function", name: declaration.id.name }
           });
         }
-        if (declaration.type === import_utils32.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
+        if (declaration.type === import_utils33.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
@@ -2325,15 +2366,15 @@ var noInlineDefaultExport = createRule30({
 var no_inline_default_export_default = noInlineDefaultExport;
 // src/rules/no-inline-nested-object.ts
-var import_utils33 = require("@typescript-eslint/utils");
-var createRule31 = import_utils33.ESLintUtils.RuleCreator(
+var import_utils34 = require("@typescript-eslint/utils");
+var createRule32 = import_utils34.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isObjectOrArray(node) {
-  return node.type === import_utils33.AST_NODE_TYPES.ObjectExpression || node.type === import_utils33.AST_NODE_TYPES.ArrayExpression || node.type === import_utils33.AST_NODE_TYPES.TSAsExpression;
+  return node.type === import_utils34.AST_NODE_TYPES.ObjectExpression || node.type === import_utils34.AST_NODE_TYPES.ArrayExpression || node.type === import_utils34.AST_NODE_TYPES.TSAsExpression;
 }
 function getInnerExpression(node) {
-  if (node.type === import_utils33.AST_NODE_TYPES.TSAsExpression) {
+  if (node.type === import_utils34.AST_NODE_TYPES.TSAsExpression) {
     return getInnerExpression(node.expression);
   }
   return node;
@@ -2342,10 +2383,10 @@ function arrayContainsOnlyPrimitives(node) {
   return node.elements.every((el) => {
     if (el === null) return true;
     const inner = getInnerExpression(el);
-    return inner.type === import_utils33.AST_NODE_TYPES.Literal || inner.type === import_utils33.AST_NODE_TYPES.Identifier || inner.type === import_utils33.AST_NODE_TYPES.TemplateLiteral || inner.type === import_utils33.AST_NODE_TYPES.UnaryExpression;
+    return inner.type === import_utils34.AST_NODE_TYPES.Literal || inner.type === import_utils34.AST_NODE_TYPES.Identifier || inner.type === import_utils34.AST_NODE_TYPES.TemplateLiteral || inner.type === import_utils34.AST_NODE_TYPES.UnaryExpression;
   });
 }
-var noInlineNestedObject = createRule31({
+var noInlineNestedObject = createRule32({
   name: "no-inline-nested-object",
   meta: {
     type: "layout",
@@ -2367,17 +2408,17 @@ var noInlineNestedObject = createRule31({
           return;
         }
         const valueNode = getInnerExpression(node.value);
-        if (valueNode.type !== import_utils33.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils33.AST_NODE_TYPES.ArrayExpression) {
+        if (valueNode.type !== import_utils34.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils34.AST_NODE_TYPES.ArrayExpression) {
           return;
         }
         if (!valueNode.loc) {
           return;
         }
-        const elements = valueNode.type === import_utils33.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
+        const elements = valueNode.type === import_utils34.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
         if (elements.length <= 1) {
           return;
         }
-        if (valueNode.type === import_utils33.AST_NODE_TYPES.ArrayExpression && arrayContainsOnlyPrimitives(valueNode)) {
+        if (valueNode.type === import_utils34.AST_NODE_TYPES.ArrayExpression && arrayContainsOnlyPrimitives(valueNode)) {
           return;
         }
         const isMultiline = valueNode.loc.start.line !== valueNode.loc.end.line;
@@ -2396,7 +2437,7 @@ var noInlineNestedObject = createRule31({
             const indent = " ".repeat(node.loc?.start.column ?? 0);
             const innerIndent = `${indent}  `;
             const elementTexts = elements.filter((el) => el !== null).map((el) => sourceCode.getText(el));
-            const isObject = valueNode.type === import_utils33.AST_NODE_TYPES.ObjectExpression;
+            const isObject = valueNode.type === import_utils34.AST_NODE_TYPES.ObjectExpression;
             const openChar = isObject ? "{" : "[";
             const closeChar = isObject ? "}" : "]";
             const formattedElements = elementTexts.map((text) => `${innerIndent}${text},`).join("\n");
@@ -2413,20 +2454,20 @@ ${indent}${closeChar}`;
 var no_inline_nested_object_default = noInlineNestedObject;
 // src/rules/no-inline-return-properties.ts
-var import_utils34 = require("@typescript-eslint/utils");
-var createRule32 = import_utils34.ESLintUtils.RuleCreator(
+var import_utils35 = require("@typescript-eslint/utils");
+var createRule33 = import_utils35.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isShorthandProperty = (property) => {
-  if (property.type === import_utils34.AST_NODE_TYPES.SpreadElement) {
+  if (property.type === import_utils35.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (property.type !== import_utils34.AST_NODE_TYPES.Property) {
+  if (property.type !== import_utils35.AST_NODE_TYPES.Property) {
     return false;
   }
   return property.shorthand;
 };
-var noInlineReturnProperties = createRule32({
+var noInlineReturnProperties = createRule33({
   name: "no-inline-return-properties",
   meta: {
     type: "suggestion",
@@ -2442,20 +2483,20 @@ var noInlineReturnProperties = createRule32({
   create(context) {
     return {
       ReturnStatement(node) {
-        if (!node.argument || node.argument.type !== import_utils34.AST_NODE_TYPES.ObjectExpression) {
+        if (!node.argument || node.argument.type !== import_utils35.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
         node.argument.properties.forEach((property) => {
           if (isShorthandProperty(property)) {
             return;
           }
-          if (property.type !== import_utils34.AST_NODE_TYPES.Property) {
+          if (property.type !== import_utils35.AST_NODE_TYPES.Property) {
             return;
           }
           let keyName = null;
-          if (property.key.type === import_utils34.AST_NODE_TYPES.Identifier) {
+          if (property.key.type === import_utils35.AST_NODE_TYPES.Identifier) {
             keyName = property.key.name;
-          } else if (property.key.type === import_utils34.AST_NODE_TYPES.Literal) {
+          } else if (property.key.type === import_utils35.AST_NODE_TYPES.Literal) {
             keyName = String(property.key.value);
           }
           context.report({
@@ -2471,8 +2512,8 @@ var noInlineReturnProperties = createRule32({
 var no_inline_return_properties_default = noInlineReturnProperties;
 // src/rules/no-lazy-identifiers.ts
-var import_utils35 = require("@typescript-eslint/utils");
-var createRule33 = import_utils35.ESLintUtils.RuleCreator(
+var import_utils36 = require("@typescript-eslint/utils");
+var createRule34 = import_utils36.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var KEYBOARD_ROWS = ["qwertyuiop", "asdfghjkl", "zxcvbnm", "1234567890"];
@@ -2513,7 +2554,7 @@ var isLazyIdentifier = (name) => {
   }
   return false;
 };
-var noLazyIdentifiers = createRule33({
+var noLazyIdentifiers = createRule34({
   name: "no-lazy-identifiers",
   meta: {
     type: "problem",
@@ -2539,27 +2580,27 @@ var noLazyIdentifiers = createRule33({
       });
     };
     const checkPattern = (pattern) => {
-      if (pattern.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils36.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern);
-      } else if (pattern.type === import_utils35.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils36.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils35.AST_NODE_TYPES.Property && prop.value.type === import_utils35.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils36.AST_NODE_TYPES.Property && prop.value.type === import_utils36.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value);
-          } else if (prop.type === import_utils35.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils35.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils36.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils36.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument);
           }
         });
-      } else if (pattern.type === import_utils35.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils36.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils35.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils36.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element);
-          } else if (element?.type === import_utils35.AST_NODE_TYPES.RestElement && element.argument.type === import_utils35.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils36.AST_NODE_TYPES.RestElement && element.argument.type === import_utils36.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument);
           }
         });
-      } else if (pattern.type === import_utils35.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils36.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils36.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left);
-      } else if (pattern.type === import_utils35.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils36.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils36.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument);
       }
     };
@@ -2604,11 +2645,11 @@ var noLazyIdentifiers = createRule33({
 var no_lazy_identifiers_default = noLazyIdentifiers;
 // src/rules/no-logic-in-params.ts
-var import_utils36 = require("@typescript-eslint/utils");
-var createRule34 = import_utils36.ESLintUtils.RuleCreator(
+var import_utils37 = require("@typescript-eslint/utils");
+var createRule35 = import_utils37.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noLogicInParams = createRule34({
+var noLogicInParams = createRule35({
   name: "no-logic-in-params",
   meta: {
     type: "suggestion",
@@ -2623,20 +2664,20 @@ var noLogicInParams = createRule34({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === import_utils36.AST_NODE_TYPES.SpreadElement) {
+      if (node.type === import_utils37.AST_NODE_TYPES.SpreadElement) {
         return false;
       }
-      if (node.type === import_utils36.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils37.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils36.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils37.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils36.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils37.AST_NODE_TYPES.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === import_utils36.AST_NODE_TYPES.UnaryExpression) {
+      if (node.type === import_utils37.AST_NODE_TYPES.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -2649,7 +2690,7 @@ var noLogicInParams = createRule34({
             messageId: "noLogicInParams"
           });
         }
-        if (arg.type === import_utils36.AST_NODE_TYPES.ArrayExpression) {
+        if (arg.type === import_utils37.AST_NODE_TYPES.ArrayExpression) {
           arg.elements.forEach((element) => {
             if (element && isComplexExpression(element)) {
               context.report({
@@ -2674,46 +2715,46 @@ var noLogicInParams = createRule34({
 var no_logic_in_params_default = noLogicInParams;
 // src/rules/no-misleading-constant-case.ts
-var import_utils37 = require("@typescript-eslint/utils");
-var createRule35 = import_utils37.ESLintUtils.RuleCreator(
+var import_utils38 = require("@typescript-eslint/utils");
+var createRule36 = import_utils38.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SCREAMING_SNAKE_CASE_REGEX3 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
-var isAsConstAssertion2 = (node) => node.type === import_utils37.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils37.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils37.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
+var isAsConstAssertion2 = (node) => node.type === import_utils38.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils38.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils38.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
 var isStaticValue3 = (init) => {
   if (isAsConstAssertion2(init)) {
     return true;
   }
-  if (init.type === import_utils37.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils38.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils37.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils37.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils38.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils38.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils37.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
+  if (init.type === import_utils38.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
     return true;
   }
-  if (init.type === import_utils37.AST_NODE_TYPES.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== import_utils37.AST_NODE_TYPES.SpreadElement && isStaticValue3(el));
+  if (init.type === import_utils38.AST_NODE_TYPES.ArrayExpression) {
+    return init.elements.every((el) => el !== null && el.type !== import_utils38.AST_NODE_TYPES.SpreadElement && isStaticValue3(el));
   }
-  if (init.type === import_utils37.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type === import_utils38.AST_NODE_TYPES.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === import_utils37.AST_NODE_TYPES.Property && isStaticValue3(prop.value)
+      (prop) => prop.type === import_utils38.AST_NODE_TYPES.Property && isStaticValue3(prop.value)
     );
   }
   return false;
 };
 var isGlobalScope3 = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils37.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils38.AST_NODE_TYPES.Program) {
     return true;
   }
-  if (parent.type === import_utils37.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils37.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils38.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils38.AST_NODE_TYPES.Program) {
     return true;
   }
   return false;
 };
-var noMisleadingConstantCase = createRule35({
+var noMisleadingConstantCase = createRule36({
   name: "no-misleading-constant-case",
   meta: {
     type: "suggestion",
@@ -2732,7 +2773,7 @@ var noMisleadingConstantCase = createRule35({
     return {
       VariableDeclaration(node) {
         node.declarations.forEach((declarator) => {
-          if (declarator.id.type !== import_utils37.AST_NODE_TYPES.Identifier) {
+          if (declarator.id.type !== import_utils38.AST_NODE_TYPES.Identifier) {
             return;
           }
           const { name } = declarator.id;
@@ -2773,11 +2814,11 @@ var noMisleadingConstantCase = createRule35({
 var no_misleading_constant_case_default = noMisleadingConstantCase;
 // src/rules/no-nested-interface-declaration.ts
-var import_utils38 = require("@typescript-eslint/utils");
-var createRule36 = import_utils38.ESLintUtils.RuleCreator(
+var import_utils39 = require("@typescript-eslint/utils");
+var createRule37 = import_utils39.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedInterfaceDeclaration = createRule36({
+var noNestedInterfaceDeclaration = createRule37({
   name: "no-nested-interface-declaration",
   meta: {
     type: "suggestion",
@@ -2798,15 +2839,15 @@ var noNestedInterfaceDeclaration = createRule36({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type === import_utils38.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSTypeLiteral) {
           context.report({
             node: typeAnnotation,
             messageId: "noNestedInterface"
           });
           return;
         }
-        if (typeAnnotation.type === import_utils38.AST_NODE_TYPES.TSArrayType) {
-          if (typeAnnotation.elementType.type === import_utils38.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSArrayType) {
+          if (typeAnnotation.elementType.type === import_utils39.AST_NODE_TYPES.TSTypeLiteral) {
             context.report({
               node: typeAnnotation.elementType,
               messageId: "noNestedInterface"
@@ -2814,9 +2855,9 @@ var noNestedInterfaceDeclaration = createRule36({
           }
           return;
         }
-        if (typeAnnotation.type === import_utils38.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
+        if (typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
           typeAnnotation.typeArguments.params.forEach((param) => {
-            if (param.type === import_utils38.AST_NODE_TYPES.TSTypeLiteral) {
+            if (param.type === import_utils39.AST_NODE_TYPES.TSTypeLiteral) {
               context.report({
                 node: param,
                 messageId: "noNestedInterface"
@@ -2831,11 +2872,11 @@ var noNestedInterfaceDeclaration = createRule36({
 var no_nested_interface_declaration_default = noNestedInterfaceDeclaration;
 // src/rules/no-nested-ternary.ts
-var import_utils39 = require("@typescript-eslint/utils");
-var createRule37 = import_utils39.ESLintUtils.RuleCreator(
+var import_utils40 = require("@typescript-eslint/utils");
+var createRule38 = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noNestedTernary = createRule37({
+var noNestedTernary = createRule38({
   name: "no-nested-ternary",
   meta: {
     type: "suggestion",
@@ -2852,13 +2893,13 @@ var noNestedTernary = createRule37({
     return {
       ConditionalExpression(node) {
         const { consequent, alternate } = node;
-        if (consequent.type === import_utils39.AST_NODE_TYPES.ConditionalExpression) {
+        if (consequent.type === import_utils40.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: consequent,
             messageId: "noNestedTernary"
           });
         }
-        if (alternate.type === import_utils39.AST_NODE_TYPES.ConditionalExpression) {
+        if (alternate.type === import_utils40.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: alternate,
             messageId: "noNestedTernary"
@@ -2871,11 +2912,11 @@ var noNestedTernary = createRule37({
 var no_nested_ternary_default = noNestedTernary;
 // src/rules/no-relative-imports.ts
-var import_utils40 = require("@typescript-eslint/utils");
-var createRule38 = import_utils40.ESLintUtils.RuleCreator(
+var import_utils41 = require("@typescript-eslint/utils");
+var createRule39 = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var noRelativeImports = createRule38({
+var noRelativeImports = createRule39({
   name: "no-relative-imports",
   meta: {
     type: "suggestion",
@@ -2899,22 +2940,22 @@ var noRelativeImports = createRule38({
     };
     return {
       ImportDeclaration(node) {
-        if (node.source.type === import_utils40.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils40.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportNamedDeclaration(node) {
-        if (node.source?.type === import_utils40.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source?.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportAllDeclaration(node) {
-        if (node.source.type === import_utils40.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       }
@@ -2924,8 +2965,8 @@ var noRelativeImports = createRule38({
 var no_relative_imports_default = noRelativeImports;
 // src/rules/no-single-char-variables.ts
-var import_utils41 = require("@typescript-eslint/utils");
-var createRule39 = import_utils41.ESLintUtils.RuleCreator(
+var import_utils42 = require("@typescript-eslint/utils");
+var createRule40 = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var ALLOWED_IN_FOR_LOOPS = /* @__PURE__ */ new Set(["i", "j", "k", "n"]);
@@ -2937,7 +2978,7 @@ var isForLoopInit = (node) => {
     if (!parentNode) {
       return false;
     }
-    if (parentNode.type === import_utils41.AST_NODE_TYPES.ForStatement) {
+    if (parentNode.type === import_utils42.AST_NODE_TYPES.ForStatement) {
       const { init } = parentNode;
       if (init && init === current) {
         return true;
@@ -2956,7 +2997,7 @@ var isAllowedInContext = (name, node) => {
   }
   return false;
 };
-var noSingleCharVariables = createRule39({
+var noSingleCharVariables = createRule40({
   name: "no-single-char-variables",
   meta: {
     type: "suggestion",
@@ -2985,27 +3026,27 @@ var noSingleCharVariables = createRule39({
       });
     };
     const checkPattern = (pattern, declarationNode) => {
-      if (pattern.type === import_utils41.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils42.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern, declarationNode);
-      } else if (pattern.type === import_utils41.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils42.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils41.AST_NODE_TYPES.Property && prop.value.type === import_utils41.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils42.AST_NODE_TYPES.Property && prop.value.type === import_utils42.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value, declarationNode);
-          } else if (prop.type === import_utils41.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils41.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils42.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils42.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils41.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils42.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils41.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils42.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element, declarationNode);
-          } else if (element?.type === import_utils41.AST_NODE_TYPES.RestElement && element.argument.type === import_utils41.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils42.AST_NODE_TYPES.RestElement && element.argument.type === import_utils42.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils41.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils41.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils42.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils42.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left, declarationNode);
-      } else if (pattern.type === import_utils41.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils41.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils42.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils42.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument, declarationNode);
       }
     };
@@ -3039,11 +3080,11 @@ var noSingleCharVariables = createRule39({
 var no_single_char_variables_default = noSingleCharVariables;
 // src/rules/prefer-async-await.ts
-var import_utils42 = require("@typescript-eslint/utils");
-var createRule40 = import_utils42.ESLintUtils.RuleCreator(
+var import_utils43 = require("@typescript-eslint/utils");
+var createRule41 = import_utils43.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferAsyncAwait = createRule40({
+var preferAsyncAwait = createRule41({
   name: "prefer-async-await",
   meta: {
     type: "suggestion",
@@ -3059,7 +3100,7 @@ var preferAsyncAwait = createRule40({
   create(context) {
     return {
       CallExpression(node) {
-        if (node.callee.type === import_utils42.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils42.AST_NODE_TYPES.Identifier && node.callee.property.name === "then") {
+        if (node.callee.type === import_utils43.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils43.AST_NODE_TYPES.Identifier && node.callee.property.name === "then") {
           context.report({
             node: node.callee.property,
             messageId: "preferAsyncAwait"
@@ -3072,11 +3113,11 @@ var preferAsyncAwait = createRule40({
 var prefer_async_await_default = preferAsyncAwait;
 // src/rules/prefer-destructuring-params.ts
-var import_utils43 = require("@typescript-eslint/utils");
-var createRule41 = import_utils43.ESLintUtils.RuleCreator(
+var import_utils44 = require("@typescript-eslint/utils");
+var createRule42 = import_utils44.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferDestructuringParams = createRule41({
+var preferDestructuringParams = createRule42({
   name: "prefer-destructuring-params",
   meta: {
     type: "suggestion",
@@ -3092,18 +3133,18 @@ var preferDestructuringParams = createRule41({
   create(context) {
     const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === import_utils43.AST_NODE_TYPES.CallExpression;
+      return parent?.type === import_utils44.AST_NODE_TYPES.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === import_utils43.AST_NODE_TYPES.FunctionDeclaration) {
+      if (node.type === import_utils44.AST_NODE_TYPES.FunctionDeclaration) {
         return true;
       }
-      if (node.type === import_utils43.AST_NODE_TYPES.FunctionExpression || node.type === import_utils43.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (node.type === import_utils44.AST_NODE_TYPES.FunctionExpression || node.type === import_utils44.AST_NODE_TYPES.ArrowFunctionExpression) {
         if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        return parent?.type === import_utils43.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils43.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils43.AST_NODE_TYPES.Property || parent?.type === import_utils43.AST_NODE_TYPES.MethodDefinition;
+        return parent?.type === import_utils44.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils44.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils44.AST_NODE_TYPES.Property || parent?.type === import_utils44.AST_NODE_TYPES.MethodDefinition;
       }
       return false;
     };
@@ -3115,7 +3156,7 @@ var preferDestructuringParams = createRule41({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === import_utils43.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+      if (node.type === import_utils44.AST_NODE_TYPES.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -3125,7 +3166,7 @@ var preferDestructuringParams = createRule41({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== import_utils43.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils43.AST_NODE_TYPES.RestElement
+        (param) => param.type !== import_utils44.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils44.AST_NODE_TYPES.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -3144,8 +3185,8 @@ var preferDestructuringParams = createRule41({
 var prefer_destructuring_params_default = preferDestructuringParams;
 // src/rules/prefer-function-declaration.ts
-var import_utils44 = require("@typescript-eslint/utils");
-var createRule42 = import_utils44.ESLintUtils.RuleCreator(
+var import_utils45 = require("@typescript-eslint/utils");
+var createRule43 = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isTsFile = (filename) => filename.endsWith(".ts") && !filename.endsWith(".d.ts");
@@ -3154,33 +3195,33 @@ var isCallbackContext = (node) => {
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.ReturnStatement) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.ReturnStatement) {
     return true;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.ConditionalExpression) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.ConditionalExpression) {
     return true;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.LogicalExpression) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.LogicalExpression) {
     return true;
   }
-  if (parent.type === import_utils44.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
+  if (parent.type === import_utils45.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
     return true;
   }
   return false;
 };
-var preferFunctionDeclaration = createRule42({
+var preferFunctionDeclaration = createRule43({
   name: "prefer-function-declaration",
   meta: {
     type: "suggestion",
@@ -3201,14 +3242,14 @@ var preferFunctionDeclaration = createRule42({
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils44.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils45.AST_NODE_TYPES.Identifier) {
           return;
         }
         const { init } = node;
         if (!init) {
           return;
         }
-        if (init.type === import_utils44.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (init.type === import_utils45.AST_NODE_TYPES.ArrowFunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3218,7 +3259,7 @@ var preferFunctionDeclaration = createRule42({
             data: { name: node.id.name }
           });
         }
-        if (init.type === import_utils44.AST_NODE_TYPES.FunctionExpression) {
+        if (init.type === import_utils45.AST_NODE_TYPES.FunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3235,11 +3276,11 @@ var preferFunctionDeclaration = createRule42({
 var prefer_function_declaration_default = preferFunctionDeclaration;
 // src/rules/prefer-guard-clause.ts
-var import_utils45 = require("@typescript-eslint/utils");
-var createRule43 = import_utils45.ESLintUtils.RuleCreator(
+var import_utils46 = require("@typescript-eslint/utils");
+var createRule44 = import_utils46.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferGuardClause = createRule43({
+var preferGuardClause = createRule44({
   name: "prefer-guard-clause",
   meta: {
     type: "suggestion",
@@ -3256,8 +3297,8 @@ var preferGuardClause = createRule43({
     return {
       IfStatement(node) {
         const { consequent } = node;
-        if (consequent.type === import_utils45.AST_NODE_TYPES.BlockStatement) {
-          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils45.AST_NODE_TYPES.IfStatement);
+        if (consequent.type === import_utils46.AST_NODE_TYPES.BlockStatement) {
+          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils46.AST_NODE_TYPES.IfStatement);
           if (hasNestedIf && consequent.body.length === 1) {
             context.report({
               node,
@@ -3265,7 +3306,7 @@ var preferGuardClause = createRule43({
             });
           }
         }
-        if (consequent.type === import_utils45.AST_NODE_TYPES.IfStatement) {
+        if (consequent.type === import_utils46.AST_NODE_TYPES.IfStatement) {
           context.report({
             node,
             messageId: "preferGuardClause"
@@ -3278,11 +3319,11 @@ var preferGuardClause = createRule43({
 var prefer_guard_clause_default = preferGuardClause;
 // src/rules/prefer-import-type.ts
-var import_utils46 = require("@typescript-eslint/utils");
-var createRule44 = import_utils46.ESLintUtils.RuleCreator(
+var import_utils47 = require("@typescript-eslint/utils");
+var createRule45 = import_utils47.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferImportType = createRule44({
+var preferImportType = createRule45({
   name: "prefer-import-type",
   meta: {
     type: "suggestion",
@@ -3301,22 +3342,22 @@ var preferImportType = createRule44({
       let current = node;
       while (current) {
         switch (current.type) {
-          case import_utils46.AST_NODE_TYPES.TSTypeReference:
-          case import_utils46.AST_NODE_TYPES.TSTypeAnnotation:
-          case import_utils46.AST_NODE_TYPES.TSTypeParameterInstantiation:
-          case import_utils46.AST_NODE_TYPES.TSInterfaceHeritage:
-          case import_utils46.AST_NODE_TYPES.TSClassImplements:
-          case import_utils46.AST_NODE_TYPES.TSTypeQuery:
-          case import_utils46.AST_NODE_TYPES.TSTypeAssertion:
-          case import_utils46.AST_NODE_TYPES.TSAsExpression:
-          case import_utils46.AST_NODE_TYPES.TSSatisfiesExpression:
-          case import_utils46.AST_NODE_TYPES.TSTypeAliasDeclaration:
-          case import_utils46.AST_NODE_TYPES.TSInterfaceDeclaration:
-          case import_utils46.AST_NODE_TYPES.TSTypeParameter:
-          case import_utils46.AST_NODE_TYPES.TSQualifiedName:
+          case import_utils47.AST_NODE_TYPES.TSTypeReference:
+          case import_utils47.AST_NODE_TYPES.TSTypeAnnotation:
+          case import_utils47.AST_NODE_TYPES.TSTypeParameterInstantiation:
+          case import_utils47.AST_NODE_TYPES.TSInterfaceHeritage:
+          case import_utils47.AST_NODE_TYPES.TSClassImplements:
+          case import_utils47.AST_NODE_TYPES.TSTypeQuery:
+          case import_utils47.AST_NODE_TYPES.TSTypeAssertion:
+          case import_utils47.AST_NODE_TYPES.TSAsExpression:
+          case import_utils47.AST_NODE_TYPES.TSSatisfiesExpression:
+          case import_utils47.AST_NODE_TYPES.TSTypeAliasDeclaration:
+          case import_utils47.AST_NODE_TYPES.TSInterfaceDeclaration:
+          case import_utils47.AST_NODE_TYPES.TSTypeParameter:
+          case import_utils47.AST_NODE_TYPES.TSQualifiedName:
             return true;
-          case import_utils46.AST_NODE_TYPES.MemberExpression:
-          case import_utils46.AST_NODE_TYPES.Identifier:
+          case import_utils47.AST_NODE_TYPES.MemberExpression:
+          case import_utils47.AST_NODE_TYPES.Identifier:
             current = current.parent;
             break;
           default:
@@ -3346,27 +3387,27 @@ var preferImportType = createRule44({
           return false;
         }
         switch (parent.type) {
-          case import_utils46.AST_NODE_TYPES.CallExpression:
-          case import_utils46.AST_NODE_TYPES.NewExpression:
-          case import_utils46.AST_NODE_TYPES.JSXOpeningElement:
-          case import_utils46.AST_NODE_TYPES.JSXClosingElement:
-          case import_utils46.AST_NODE_TYPES.MemberExpression:
-          case import_utils46.AST_NODE_TYPES.VariableDeclarator:
-          case import_utils46.AST_NODE_TYPES.TaggedTemplateExpression:
-          case import_utils46.AST_NODE_TYPES.SpreadElement:
-          case import_utils46.AST_NODE_TYPES.ExportSpecifier:
-          case import_utils46.AST_NODE_TYPES.ArrayExpression:
-          case import_utils46.AST_NODE_TYPES.ObjectExpression:
-          case import_utils46.AST_NODE_TYPES.BinaryExpression:
-          case import_utils46.AST_NODE_TYPES.LogicalExpression:
-          case import_utils46.AST_NODE_TYPES.UnaryExpression:
-          case import_utils46.AST_NODE_TYPES.ReturnStatement:
-          case import_utils46.AST_NODE_TYPES.ArrowFunctionExpression:
-          case import_utils46.AST_NODE_TYPES.ConditionalExpression:
-          case import_utils46.AST_NODE_TYPES.AwaitExpression:
-          case import_utils46.AST_NODE_TYPES.YieldExpression:
-          case import_utils46.AST_NODE_TYPES.Property:
-          case import_utils46.AST_NODE_TYPES.JSXExpressionContainer:
+          case import_utils47.AST_NODE_TYPES.CallExpression:
+          case import_utils47.AST_NODE_TYPES.NewExpression:
+          case import_utils47.AST_NODE_TYPES.JSXOpeningElement:
+          case import_utils47.AST_NODE_TYPES.JSXClosingElement:
+          case import_utils47.AST_NODE_TYPES.MemberExpression:
+          case import_utils47.AST_NODE_TYPES.VariableDeclarator:
+          case import_utils47.AST_NODE_TYPES.TaggedTemplateExpression:
+          case import_utils47.AST_NODE_TYPES.SpreadElement:
+          case import_utils47.AST_NODE_TYPES.ExportSpecifier:
+          case import_utils47.AST_NODE_TYPES.ArrayExpression:
+          case import_utils47.AST_NODE_TYPES.ObjectExpression:
+          case import_utils47.AST_NODE_TYPES.BinaryExpression:
+          case import_utils47.AST_NODE_TYPES.LogicalExpression:
+          case import_utils47.AST_NODE_TYPES.UnaryExpression:
+          case import_utils47.AST_NODE_TYPES.ReturnStatement:
+          case import_utils47.AST_NODE_TYPES.ArrowFunctionExpression:
+          case import_utils47.AST_NODE_TYPES.ConditionalExpression:
+          case import_utils47.AST_NODE_TYPES.AwaitExpression:
+          case import_utils47.AST_NODE_TYPES.YieldExpression:
+          case import_utils47.AST_NODE_TYPES.Property:
+          case import_utils47.AST_NODE_TYPES.JSXExpressionContainer:
             return true;
           default:
             return false;
@@ -3390,13 +3431,13 @@ var preferImportType = createRule44({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport2 = node.specifiers.every((specifier) => {
-        if (specifier.type === import_utils46.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        if (specifier.type === import_utils47.AST_NODE_TYPES.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils46.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (specifier.type === import_utils47.AST_NODE_TYPES.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils46.AST_NODE_TYPES.ImportSpecifier) {
+        if (specifier.type === import_utils47.AST_NODE_TYPES.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -3422,19 +3463,19 @@ var preferImportType = createRule44({
 var prefer_import_type_default = preferImportType;
 // src/rules/prefer-inline-literal-union.ts
-var import_utils47 = require("@typescript-eslint/utils");
-var createRule45 = import_utils47.ESLintUtils.RuleCreator(
+var import_utils48 = require("@typescript-eslint/utils");
+var createRule46 = import_utils48.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isLiteralUnionType(node) {
-  if (node.type !== import_utils47.AST_NODE_TYPES.TSUnionType) {
+  if (node.type !== import_utils48.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.every(
-    (member) => member.type === import_utils47.AST_NODE_TYPES.TSLiteralType || member.type === import_utils47.AST_NODE_TYPES.TSNullKeyword || member.type === import_utils47.AST_NODE_TYPES.TSUndefinedKeyword
+    (member) => member.type === import_utils48.AST_NODE_TYPES.TSLiteralType || member.type === import_utils48.AST_NODE_TYPES.TSNullKeyword || member.type === import_utils48.AST_NODE_TYPES.TSUndefinedKeyword
   );
 }
-var preferInlineLiteralUnion = createRule45({
+var preferInlineLiteralUnion = createRule46({
   name: "prefer-inline-literal-union",
   meta: {
     type: "suggestion",
@@ -3461,10 +3502,10 @@ var preferInlineLiteralUnion = createRule45({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type !== import_utils47.AST_NODE_TYPES.TSTypeReference) {
+        if (typeAnnotation.type !== import_utils48.AST_NODE_TYPES.TSTypeReference) {
           return;
         }
-        if (typeAnnotation.typeName.type !== import_utils47.AST_NODE_TYPES.Identifier) {
+        if (typeAnnotation.typeName.type !== import_utils48.AST_NODE_TYPES.Identifier) {
           return;
         }
         const aliasName = typeAnnotation.typeName.name;
@@ -3488,12 +3529,12 @@ var preferInlineLiteralUnion = createRule45({
 var prefer_inline_literal_union_default = preferInlineLiteralUnion;
 // src/rules/prefer-inline-type-export.ts
-var import_utils48 = require("@typescript-eslint/utils");
-var createRule46 = import_utils48.ESLintUtils.RuleCreator(
+var import_utils49 = require("@typescript-eslint/utils");
+var createRule47 = import_utils49.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var isTypeDeclaration = (node) => node.type === import_utils48.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils48.AST_NODE_TYPES.TSTypeAliasDeclaration;
-var preferInlineTypeExport = createRule46({
+var isTypeDeclaration = (node) => node.type === import_utils49.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils49.AST_NODE_TYPES.TSTypeAliasDeclaration;
+var preferInlineTypeExport = createRule47({
   name: "prefer-inline-type-export",
   meta: {
     type: "suggestion",
@@ -3510,12 +3551,12 @@ var preferInlineTypeExport = createRule46({
   create(context) {
     const typeDeclarations = /* @__PURE__ */ new Map();
     function collectDeclaration(node) {
-      if (node.parent.type !== import_utils48.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (node.parent.type !== import_utils49.AST_NODE_TYPES.ExportNamedDeclaration) {
         typeDeclarations.set(node.id.name, node);
       }
     }
     function reportSpecifier(specifier, statement, declarationNode) {
-      if (specifier.local.type !== import_utils48.AST_NODE_TYPES.Identifier) {
+      if (specifier.local.type !== import_utils49.AST_NODE_TYPES.Identifier) {
         return;
       }
       const { name } = specifier.local;
@@ -3548,16 +3589,16 @@ var preferInlineTypeExport = createRule46({
     return {
       Program(node) {
         node.body.forEach((statement) => {
-          if (statement.type === import_utils48.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils48.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+          if (statement.type === import_utils49.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils49.AST_NODE_TYPES.TSTypeAliasDeclaration) {
             collectDeclaration(statement);
           }
         });
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils48.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils49.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             return;
           }
           statement.specifiers.forEach((specifier) => {
-            if (specifier.local.type !== import_utils48.AST_NODE_TYPES.Identifier) {
+            if (specifier.local.type !== import_utils49.AST_NODE_TYPES.Identifier) {
               return;
             }
             const declarationNode = typeDeclarations.get(specifier.local.name);
@@ -3574,11 +3615,11 @@ var preferInlineTypeExport = createRule46({
 var prefer_inline_type_export_default = preferInlineTypeExport;
 // src/rules/prefer-interface-over-inline-types.ts
-var import_utils49 = require("@typescript-eslint/utils");
-var createRule47 = import_utils49.ESLintUtils.RuleCreator(
+var import_utils50 = require("@typescript-eslint/utils");
+var createRule48 = import_utils50.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferInterfaceOverInlineTypes = createRule47({
+var preferInterfaceOverInlineTypes = createRule48({
   name: "prefer-interface-over-inline-types",
   meta: {
     type: "suggestion",
@@ -3594,54 +3635,54 @@ var preferInterfaceOverInlineTypes = createRule47({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils49.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils49.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils49.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils49.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils50.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils50.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils50.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils50.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils49.AST_NODE_TYPES.JSXElement || node.right.type === import_utils49.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils50.AST_NODE_TYPES.JSXElement || node.right.type === import_utils50.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils49.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils49.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils49.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils49.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils49.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils50.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils50.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils50.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils50.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils50.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils49.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils49.AST_NODE_TYPES.JSXElement || node.body.type === import_utils49.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils50.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils50.AST_NODE_TYPES.JSXElement || node.body.type === import_utils50.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils49.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils50.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils49.AST_NODE_TYPES.FunctionExpression || node.type === import_utils49.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils49.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils50.AST_NODE_TYPES.FunctionExpression || node.type === import_utils50.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils50.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === import_utils49.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils50.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils49.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils49.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils50.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils50.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils49.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils50.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === import_utils49.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils50.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      if (node.type === import_utils49.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
-        return node.typeArguments.params.some((param) => param.type === import_utils49.AST_NODE_TYPES.TSTypeLiteral);
+      if (node.type === import_utils50.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils50.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils49.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils50.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -3654,7 +3695,7 @@ var preferInterfaceOverInlineTypes = createRule47({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils49.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils50.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -3674,11 +3715,11 @@ var preferInterfaceOverInlineTypes = createRule47({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 // src/rules/prefer-jsx-template-literals.ts
-var import_utils50 = require("@typescript-eslint/utils");
-var createRule48 = import_utils50.ESLintUtils.RuleCreator(
+var import_utils51 = require("@typescript-eslint/utils");
+var createRule49 = import_utils51.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferJSXTemplateLiterals = createRule48({
+var preferJSXTemplateLiterals = createRule49({
   name: "prefer-jsx-template-literals",
   meta: {
     type: "suggestion",
@@ -3747,9 +3788,9 @@ var preferJSXTemplateLiterals = createRule48({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === import_utils50.AST_NODE_TYPES.JSXText && nextChild.type === import_utils50.AST_NODE_TYPES.JSXExpressionContainer) {
+        if (child.type === import_utils51.AST_NODE_TYPES.JSXText && nextChild.type === import_utils51.AST_NODE_TYPES.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === import_utils50.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils50.AST_NODE_TYPES.JSXText) {
+        } else if (child.type === import_utils51.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils51.AST_NODE_TYPES.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -3762,11 +3803,11 @@ var preferJSXTemplateLiterals = createRule48({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 // src/rules/prefer-named-param-types.ts
-var import_utils51 = require("@typescript-eslint/utils");
-var createRule49 = import_utils51.ESLintUtils.RuleCreator(
+var import_utils52 = require("@typescript-eslint/utils");
+var createRule50 = import_utils52.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferNamedParamTypes = createRule49({
+var preferNamedParamTypes = createRule50({
   name: "prefer-named-param-types",
   meta: {
     type: "suggestion",
@@ -3781,16 +3822,16 @@ var preferNamedParamTypes = createRule49({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === import_utils51.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.type === import_utils52.AST_NODE_TYPES.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === import_utils51.AST_NODE_TYPES.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils51.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils52.AST_NODE_TYPES.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === import_utils51.AST_NODE_TYPES.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils51.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils52.AST_NODE_TYPES.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
@@ -3824,11 +3865,11 @@ var preferNamedParamTypes = createRule49({
 var prefer_named_param_types_default = preferNamedParamTypes;
 // src/rules/prefer-react-import-types.ts
-var import_utils52 = require("@typescript-eslint/utils");
-var createRule50 = import_utils52.ESLintUtils.RuleCreator(
+var import_utils53 = require("@typescript-eslint/utils");
+var createRule51 = import_utils53.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var preferReactImportTypes = createRule50({
+var preferReactImportTypes = createRule51({
   name: "prefer-react-import-types",
   meta: {
     type: "suggestion",
@@ -3904,7 +3945,7 @@ var preferReactImportTypes = createRule50({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      if (node.object.type === import_utils52.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils52.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
+      if (node.object.type === import_utils53.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils53.AST_NODE_TYPES.Identifier && allReactExports.has(node.property.name)) {
         const typeName = node.property.name;
         const isType = reactTypes.has(typeName);
         const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -3921,7 +3962,7 @@ var preferReactImportTypes = createRule50({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        if (node.left.type === import_utils52.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils52.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
+        if (node.left.type === import_utils53.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils53.AST_NODE_TYPES.Identifier && allReactExports.has(node.right.name)) {
           const typeName = node.right.name;
           const isType = reactTypes.has(typeName);
           const importStatement = isType ? `import type { ${typeName} } from "react"` : `import { ${typeName} } from "react"`;
@@ -3941,11 +3982,11 @@ var preferReactImportTypes = createRule50({
 var prefer_react_import_types_default = preferReactImportTypes;
 // src/rules/react-props-destructure.ts
-var import_utils53 = require("@typescript-eslint/utils");
-var createRule51 = import_utils53.ESLintUtils.RuleCreator(
+var import_utils54 = require("@typescript-eslint/utils");
+var createRule52 = import_utils54.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
-var reactPropsDestructure = createRule51({
+var reactPropsDestructure = createRule52({
   name: "react-props-destructure",
   meta: {
     type: "suggestion",
@@ -3961,29 +4002,29 @@ var reactPropsDestructure = createRule51({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils53.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils53.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils53.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils53.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils54.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils54.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils54.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils54.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils53.AST_NODE_TYPES.JSXElement || node.right.type === import_utils53.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils54.AST_NODE_TYPES.JSXElement || node.right.type === import_utils54.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils53.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils53.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils53.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils53.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils53.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils54.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils54.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils54.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils54.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils54.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils53.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils53.AST_NODE_TYPES.JSXElement || node.body.type === import_utils53.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils54.AST_NODE_TYPES.JSXElement || node.body.type === import_utils54.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils53.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils54.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils53.AST_NODE_TYPES.FunctionExpression || node.type === import_utils53.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils53.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils54.AST_NODE_TYPES.FunctionExpression || node.type === import_utils54.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils54.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -3997,9 +4038,9 @@ var reactPropsDestructure = createRule51({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils53.AST_NODE_TYPES.ObjectPattern) {
-        const properties = param.properties.filter((prop) => prop.type === import_utils53.AST_NODE_TYPES.Property).map((prop) => {
-          if (prop.key.type === import_utils53.AST_NODE_TYPES.Identifier) {
+      if (param.type === import_utils54.AST_NODE_TYPES.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === import_utils54.AST_NODE_TYPES.Property).map((prop) => {
+          if (prop.key.type === import_utils54.AST_NODE_TYPES.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -4026,57 +4067,57 @@ var reactPropsDestructure = createRule51({
 var react_props_destructure_default = reactPropsDestructure;
 // src/rules/require-explicit-return-type.ts
-var import_utils54 = require("@typescript-eslint/utils");
-var createRule52 = import_utils54.ESLintUtils.RuleCreator(
+var import_utils55 = require("@typescript-eslint/utils");
+var createRule53 = import_utils55.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isReactComponent = (node) => {
-  if (node.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === import_utils55.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
-    if (parent?.type === import_utils54.AST_NODE_TYPES.VariableDeclarator) {
+    if (parent?.type === import_utils55.AST_NODE_TYPES.VariableDeclarator) {
       const { id } = parent;
-      if (id.type === import_utils54.AST_NODE_TYPES.Identifier) {
+      if (id.type === import_utils55.AST_NODE_TYPES.Identifier) {
         return /^[A-Z]/.test(id.name);
       }
     }
   }
-  if (node.type === import_utils54.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils55.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return /^[A-Z]/.test(node.id.name);
   }
   return false;
 };
 var isCallbackFunction = (node) => {
-  if (node.type === import_utils54.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils55.AST_NODE_TYPES.FunctionDeclaration) {
     return false;
   }
   const { parent } = node;
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils54.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils55.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils54.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils55.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils54.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils55.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
   return false;
 };
 var getFunctionName = (node) => {
-  if (node.type === import_utils54.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils55.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return node.id.name;
   }
-  if (node.type === import_utils54.AST_NODE_TYPES.FunctionExpression && node.id) {
+  if (node.type === import_utils55.AST_NODE_TYPES.FunctionExpression && node.id) {
     return node.id.name;
   }
-  if ((node.type === import_utils54.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils54.AST_NODE_TYPES.FunctionExpression) && node.parent?.type === import_utils54.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils54.AST_NODE_TYPES.Identifier) {
+  if ((node.type === import_utils55.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils55.AST_NODE_TYPES.FunctionExpression) && node.parent?.type === import_utils55.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils55.AST_NODE_TYPES.Identifier) {
     return node.parent.id.name;
   }
   return null;
 };
-var requireExplicitReturnType = createRule52({
+var requireExplicitReturnType = createRule53({
   name: "require-explicit-return-type",
   meta: {
     type: "suggestion",
@@ -4125,8 +4166,8 @@ var requireExplicitReturnType = createRule52({
 var require_explicit_return_type_default = requireExplicitReturnType;
 // src/rules/sort-exports.ts
-var import_utils55 = require("@typescript-eslint/utils");
-var createRule53 = import_utils55.ESLintUtils.RuleCreator(
+var import_utils56 = require("@typescript-eslint/utils");
+var createRule54 = import_utils56.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var GROUP_NAMES = ["", "external/alias re-export", "relative re-export", "local export"];
@@ -4140,7 +4181,7 @@ function getExportGroup(node) {
   }
   return 1;
 }
-var sortExports = createRule53({
+var sortExports = createRule54({
   name: "sort-exports",
   meta: {
     type: "suggestion",
@@ -4180,7 +4221,7 @@ var sortExports = createRule53({
       Program(node) {
         const exportGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils55.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils56.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             if (exportGroups.length > 0) {
               checkOrder(exportGroups);
               exportGroups.length = 0;
@@ -4199,8 +4240,8 @@ var sortExports = createRule53({
 var sort_exports_default = sortExports;
 // src/rules/sort-imports.ts
-var import_utils56 = require("@typescript-eslint/utils");
-var createRule54 = import_utils56.ESLintUtils.RuleCreator(
+var import_utils57 = require("@typescript-eslint/utils");
+var createRule55 = import_utils57.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var NODE_BUILTINS = /* @__PURE__ */ new Set([
@@ -4267,7 +4308,7 @@ function getImportGroup(node) {
 function isTypeOnlyImport(node) {
   return node.importKind === "type" && node.specifiers.length > 0;
 }
-var sortImports = createRule54({
+var sortImports = createRule55({
   name: "sort-imports",
   meta: {
     type: "suggestion",
@@ -4311,7 +4352,7 @@ var sortImports = createRule54({
       Program(node) {
         const importGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils56.AST_NODE_TYPES.ImportDeclaration) {
+          if (statement.type !== import_utils57.AST_NODE_TYPES.ImportDeclaration) {
             if (importGroups.length > 0) {
               checkOrder(importGroups);
               importGroups.length = 0;
@@ -4333,13 +4374,13 @@ var sortImports = createRule54({
 var sort_imports_default = sortImports;
 // src/rules/sort-type-alphabetically.ts
-var import_utils57 = require("@typescript-eslint/utils");
-var createRule55 = import_utils57.ESLintUtils.RuleCreator(
+var import_utils58 = require("@typescript-eslint/utils");
+var createRule56 = import_utils58.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isAlphabeticallySortedWithinGroups(members) {
   const properties = members.filter(
-    (member) => member.type === import_utils57.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils57.AST_NODE_TYPES.Identifier
+    (member) => member.type === import_utils58.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils58.AST_NODE_TYPES.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4350,7 +4391,7 @@ function isAlphabeticallySortedWithinGroups(members) {
   const isOptionalSorted = optional.every((name, index) => index === 0 || optional[index - 1].localeCompare(name) <= 0);
   return isRequiredSorted && isOptionalSorted;
 }
-var sortTypeAlphabetically = createRule55({
+var sortTypeAlphabetically = createRule56({
   name: "sort-type-alphabetically",
   meta: {
     type: "suggestion",
@@ -4368,7 +4409,7 @@ var sortTypeAlphabetically = createRule55({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === import_utils57.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils57.AST_NODE_TYPES.Identifier
+        (member) => member.type === import_utils58.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils58.AST_NODE_TYPES.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4405,7 +4446,7 @@ var sortTypeAlphabetically = createRule55({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils57.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils58.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4425,13 +4466,13 @@ var sortTypeAlphabetically = createRule55({
 var sort_type_alphabetically_default = sortTypeAlphabetically;
 // src/rules/sort-type-required-first.ts
-var import_utils58 = require("@typescript-eslint/utils");
-var createRule56 = import_utils58.ESLintUtils.RuleCreator(
+var import_utils59 = require("@typescript-eslint/utils");
+var createRule57 = import_utils59.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isRequiredBeforeOptional(members) {
   const properties = members.filter(
-    (member) => member.type === import_utils58.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils58.AST_NODE_TYPES.Identifier
+    (member) => member.type === import_utils59.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils59.AST_NODE_TYPES.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4442,7 +4483,7 @@ function isRequiredBeforeOptional(members) {
   }
   return properties.slice(firstOptionalIndex).every((prop) => prop.optional);
 }
-var sortTypeRequiredFirst = createRule56({
+var sortTypeRequiredFirst = createRule57({
   name: "sort-type-required-first",
   meta: {
     type: "suggestion",
@@ -4460,7 +4501,7 @@ var sortTypeRequiredFirst = createRule56({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === import_utils58.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils58.AST_NODE_TYPES.Identifier
+        (member) => member.type === import_utils59.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils59.AST_NODE_TYPES.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4481,7 +4522,7 @@ var sortTypeRequiredFirst = createRule56({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils58.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils59.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4528,6 +4569,7 @@ var rules = {
   "jsx-require-suspense": jsx_require_suspense_default,
   "jsx-simple-props": jsx_simple_props_default,
   "jsx-sort-props": jsx_sort_props_default,
+  "jsx-spread-props-last": jsx_spread_props_last_default,
   "newline-after-multiline-block": newline_after_multiline_block_default,
   "newline-before-return": newline_before_return_default,
   "nextjs-require-public-env": nextjs_require_public_env_default,
@@ -4664,6 +4706,7 @@ var jsxRules = {
   "nextfriday/jsx-require-suspense": "warn",
   "nextfriday/jsx-simple-props": "warn",
   "nextfriday/jsx-sort-props": "warn",
+  "nextfriday/jsx-spread-props-last": "warn",
   "nextfriday/prefer-interface-over-inline-types": "warn",
   "nextfriday/prefer-jsx-template-literals": "warn",
   "nextfriday/react-props-destructure": "warn"
@@ -4681,6 +4724,7 @@ var jsxRecommendedRules = {
   "nextfriday/jsx-require-suspense": "error",
   "nextfriday/jsx-simple-props": "error",
   "nextfriday/jsx-sort-props": "error",
+  "nextfriday/jsx-spread-props-last": "error",
   "nextfriday/prefer-interface-over-inline-types": "error",
   "nextfriday/prefer-jsx-template-literals": "error",
   "nextfriday/react-props-destructure": "error"