eslint-plugin-nextfriday 2.0.0 → 3.0.0

package/lib/index.cjs

@@ -36,13 +36,11 @@ __export(index_exports, {
   rules: () => rules
 });
 module.exports = __toCommonJS(index_exports);
-var import_eslint_plugin_sonarjs = __toESM(require("eslint-plugin-sonarjs"), 1);
-var import_eslint_plugin_unicorn = __toESM(require("eslint-plugin-unicorn"), 1);
 
 // package.json
 var package_default = {
   name: "eslint-plugin-nextfriday",
-  version: "2.0.0",
+  version: "3.0.0",
   description: "A comprehensive ESLint plugin providing custom rules and configurations for Next Friday development workflows.",
   keywords: [
     "eslint",
@@ -87,6 +85,7 @@ var package_default = {
     "lib"
   ],
   scripts: {
+    audit: "pnpm audit --prod --audit-level high",
     build: "tsup",
     changeset: "changeset",
     "changeset:publish": "npm publish --provenance --access public",
@@ -108,8 +107,6 @@ var package_default = {
   dependencies: {
     "@typescript-eslint/utils": "^8.59.1",
     "emoji-regex": "^10.6.0",
-    "eslint-plugin-sonarjs": "^4.0.3",
-    "eslint-plugin-unicorn": "^64.0.0",
     tsup: "^8.5.1"
   },
   devDependencies: {
@@ -432,8 +429,20 @@ var enforceCamelCase = createRule2({
 var enforce_camel_case_default = enforceCamelCase;
 
 // src/rules/enforce-constant-case.ts
+var import_utils4 = require("@typescript-eslint/utils");
+
+// src/utils.ts
+var import_node_path = require("path");
 var import_utils3 = require("@typescript-eslint/utils");
-var createRule3 = import_utils3.ESLintUtils.RuleCreator(
+var getFileExtension = (filename) => (0, import_node_path.extname)(filename).slice(1);
+var getBaseName = (filename) => (0, import_node_path.basename)(filename, (0, import_node_path.extname)(filename));
+var isConfigFile = (filename) => {
+  const baseName = getBaseName(filename);
+  return /\.(config|rc|setup|spec|test)$/.test(baseName) || /\.(config|rc|setup|spec|test)\./.test(filename) || /^\.(eslintrc|babelrc|prettierrc)/.test(filename);
+};
+
+// src/rules/enforce-constant-case.ts
+var createRule3 = import_utils4.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SCREAMING_SNAKE_CASE_REGEX = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
@@ -450,42 +459,42 @@ var startsWithBooleanPrefix2 = (name) => BOOLEAN_PREFIXES2.some((prefix) => {
   const nextChar = name.charAt(prefix.length);
   return nextChar === nextChar.toUpperCase() && nextChar !== nextChar.toLowerCase();
 });
-var isBooleanLiteral2 = (init) => init.type === import_utils3.AST_NODE_TYPES.Literal && typeof init.value === "boolean";
-var isAsConstAssertion = (node) => node.type === import_utils3.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils3.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils3.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
+var isBooleanLiteral2 = (init) => init.type === import_utils4.AST_NODE_TYPES.Literal && typeof init.value === "boolean";
+var isAsConstAssertion = (node) => node.type === import_utils4.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils4.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils4.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
 var isStaticValue2 = (init) => {
   if (isAsConstAssertion(init)) {
     return true;
   }
-  if (init.type === import_utils3.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils4.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils3.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils3.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils4.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils4.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils3.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
+  if (init.type === import_utils4.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
     return true;
   }
-  if (init.type === import_utils3.AST_NODE_TYPES.ArrayExpression) {
-    return init.elements.every((el) => el !== null && el.type !== import_utils3.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
+  if (init.type === import_utils4.AST_NODE_TYPES.ArrayExpression) {
+    return init.elements.every((el) => el !== null && el.type !== import_utils4.AST_NODE_TYPES.SpreadElement && isStaticValue2(el));
   }
-  if (init.type === import_utils3.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type === import_utils4.AST_NODE_TYPES.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === import_utils3.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
+      (prop) => prop.type === import_utils4.AST_NODE_TYPES.Property && isStaticValue2(prop.value)
     );
   }
   return false;
 };
 var isGlobalScope2 = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils3.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils4.AST_NODE_TYPES.Program) {
     return true;
   }
-  if (parent.type === import_utils3.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils3.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils4.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils4.AST_NODE_TYPES.Program) {
     return true;
   }
   return false;
 };
-var isFunctionOrComponent = (init) => init.type === import_utils3.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils3.AST_NODE_TYPES.FunctionExpression;
+var isFunctionOrComponent = (init) => init.type === import_utils4.AST_NODE_TYPES.ArrowFunctionExpression || init.type === import_utils4.AST_NODE_TYPES.FunctionExpression;
 var enforceConstantCase = createRule3({
   name: "enforce-constant-case",
   meta: {
@@ -501,13 +510,16 @@ var enforceConstantCase = createRule3({
   },
   defaultOptions: [],
   create(context) {
+    if (isConfigFile(context.filename)) {
+      return {};
+    }
     return {
       VariableDeclaration(node) {
         if (node.kind !== "const" || !isGlobalScope2(node)) {
           return;
         }
         node.declarations.forEach((declarator) => {
-          if (declarator.id.type !== import_utils3.AST_NODE_TYPES.Identifier || !declarator.init) {
+          if (declarator.id.type !== import_utils4.AST_NODE_TYPES.Identifier || !declarator.init) {
             return;
           }
           if (isFunctionOrComponent(declarator.init)) {
@@ -543,8 +555,8 @@ var enforceConstantCase = createRule3({
 var enforce_constant_case_default = enforceConstantCase;
 
 // src/rules/enforce-curly-newline.ts
-var import_utils4 = require("@typescript-eslint/utils");
-var createRule4 = import_utils4.ESLintUtils.RuleCreator(
+var import_utils6 = require("@typescript-eslint/utils");
+var createRule4 = import_utils6.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var enforceCurlyNewline = createRule4({
@@ -570,7 +582,7 @@ var enforceCurlyNewline = createRule4({
         const startLine = node.loc.start.line;
         const endLine = node.loc.end.line;
         const isSingleLine2 = startLine === endLine;
-        const hasBraces = consequent.type === import_utils4.AST_NODE_TYPES.BlockStatement;
+        const hasBraces = consequent.type === import_utils6.AST_NODE_TYPES.BlockStatement;
         if (isSingleLine2 && hasBraces) {
           if (consequent.body.length !== 1) {
             return;
@@ -615,8 +627,8 @@ var enforce_curly_newline_default = enforceCurlyNewline;
 
 // src/rules/enforce-hook-naming.ts
 var import_path = __toESM(require("path"), 1);
-var import_utils5 = require("@typescript-eslint/utils");
-var createRule5 = import_utils5.ESLintUtils.RuleCreator(
+var import_utils7 = require("@typescript-eslint/utils");
+var createRule5 = import_utils7.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var enforceHookNaming = createRule5({
@@ -658,22 +670,22 @@ var enforceHookNaming = createRule5({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === import_utils5.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "missingUsePrefix");
         }
-        if (node.declaration?.type === import_utils5.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type === import_utils7.AST_NODE_TYPES.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === import_utils5.AST_NODE_TYPES.Identifier) {
+            if (declarator.id.type === import_utils7.AST_NODE_TYPES.Identifier) {
               checkFunctionName(declarator.id.name, declarator.id, "missingUsePrefix");
             }
           });
         }
       },
       ExportDefaultDeclaration(node) {
-        if (node.declaration.type === import_utils5.AST_NODE_TYPES.Identifier) {
+        if (node.declaration.type === import_utils7.AST_NODE_TYPES.Identifier) {
           checkFunctionName(node.declaration.name, node.declaration, "defaultExportMissingUsePrefix");
         }
-        if (node.declaration.type === import_utils5.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration.type === import_utils7.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkFunctionName(node.declaration.id.name, node.declaration.id, "defaultExportMissingUsePrefix");
         }
       }
@@ -683,20 +695,20 @@ var enforceHookNaming = createRule5({
 var enforce_hook_naming_default = enforceHookNaming;
 
 // src/rules/enforce-property-case.ts
-var import_utils6 = require("@typescript-eslint/utils");
-var createRule6 = import_utils6.ESLintUtils.RuleCreator(
+var import_utils8 = require("@typescript-eslint/utils");
+var createRule6 = import_utils8.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var SNAKE_CASE_REGEX3 = /^[a-z]+_[a-z0-9_]*$/;
 var SCREAMING_SNAKE_CASE_REGEX2 = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
 var isInsideAsConst = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils6.AST_NODE_TYPES.TSAsExpression && parent.typeAnnotation.type === import_utils6.AST_NODE_TYPES.TSTypeReference && parent.typeAnnotation.typeName.type === import_utils6.AST_NODE_TYPES.Identifier && parent.typeAnnotation.typeName.name === "const") {
+  if (parent.type === import_utils8.AST_NODE_TYPES.TSAsExpression && parent.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeReference && parent.typeAnnotation.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && parent.typeAnnotation.typeName.name === "const") {
     return true;
   }
-  if (parent.type === import_utils6.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils8.AST_NODE_TYPES.ArrayExpression) {
     const grandparent = parent.parent;
-    if (grandparent?.type === import_utils6.AST_NODE_TYPES.TSAsExpression && grandparent.typeAnnotation.type === import_utils6.AST_NODE_TYPES.TSTypeReference && grandparent.typeAnnotation.typeName.type === import_utils6.AST_NODE_TYPES.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
+    if (grandparent?.type === import_utils8.AST_NODE_TYPES.TSAsExpression && grandparent.typeAnnotation.type === import_utils8.AST_NODE_TYPES.TSTypeReference && grandparent.typeAnnotation.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && grandparent.typeAnnotation.typeName.name === "const") {
       return true;
     }
   }
@@ -718,7 +730,7 @@ var enforcePropertyCase = createRule6({
   create(context) {
     return {
       Property(node) {
-        if (node.parent.type !== import_utils6.AST_NODE_TYPES.ObjectExpression) {
+        if (node.parent.type !== import_utils8.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
         if (isInsideAsConst(node.parent)) {
@@ -727,7 +739,7 @@ var enforcePropertyCase = createRule6({
         if (node.computed) {
           return;
         }
-        if (node.key.type !== import_utils6.AST_NODE_TYPES.Identifier) {
+        if (node.key.type !== import_utils8.AST_NODE_TYPES.Identifier) {
           return;
         }
         const { name } = node.key;
@@ -746,8 +758,8 @@ var enforce_property_case_default = enforcePropertyCase;
 
 // src/rules/enforce-props-suffix.ts
 var import_path2 = __toESM(require("path"), 1);
-var import_utils7 = require("@typescript-eslint/utils");
-var createRule7 = import_utils7.ESLintUtils.RuleCreator(
+var import_utils9 = require("@typescript-eslint/utils");
+var createRule7 = import_utils9.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var enforcePropsSuffix = createRule7({
@@ -784,13 +796,13 @@ var enforcePropsSuffix = createRule7({
     };
     return {
       TSInterfaceDeclaration(node) {
-        if (node.id.type === import_utils7.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils9.AST_NODE_TYPES.Identifier) {
           checkTypeName(node.id.name, node.id);
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.id.type === import_utils7.AST_NODE_TYPES.Identifier) {
-          if (node.typeAnnotation.type === import_utils7.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.id.type === import_utils9.AST_NODE_TYPES.Identifier) {
+          if (node.typeAnnotation.type === import_utils9.AST_NODE_TYPES.TSTypeLiteral) {
             checkTypeName(node.id.name, node.id);
           }
         }
@@ -801,8 +813,8 @@ var enforcePropsSuffix = createRule7({
 var enforce_props_suffix_default = enforcePropsSuffix;
 
 // src/rules/enforce-readonly-component-props.ts
-var import_utils8 = require("@typescript-eslint/utils");
-var createRule8 = import_utils8.ESLintUtils.RuleCreator(
+var import_utils10 = require("@typescript-eslint/utils");
+var createRule8 = import_utils10.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var enforceReadonlyComponentProps = createRule8({
@@ -821,40 +833,40 @@ var enforceReadonlyComponentProps = createRule8({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      return node.consequent.type === import_utils8.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils8.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils8.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils8.AST_NODE_TYPES.JSXFragment;
+      return node.consequent.type === import_utils10.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils10.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils10.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils10.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils8.AST_NODE_TYPES.JSXElement || node.right.type === import_utils8.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils10.AST_NODE_TYPES.JSXElement || node.right.type === import_utils10.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        if (stmt.type === import_utils8.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
-          return stmt.argument.type === import_utils8.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils8.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils8.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils8.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
+        if (stmt.type === import_utils10.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils10.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils10.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils10.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils10.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      if (node.type === import_utils8.AST_NODE_TYPES.ArrowFunctionExpression) {
-        if (node.body.type === import_utils8.AST_NODE_TYPES.JSXElement || node.body.type === import_utils8.AST_NODE_TYPES.JSXFragment) {
+      if (node.type === import_utils10.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils10.AST_NODE_TYPES.JSXElement || node.body.type === import_utils10.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils8.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils10.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } else if (node.type === import_utils8.AST_NODE_TYPES.FunctionExpression || node.type === import_utils8.AST_NODE_TYPES.FunctionDeclaration) {
-        if (node.body && node.body.type === import_utils8.AST_NODE_TYPES.BlockStatement) {
+      } else if (node.type === import_utils10.AST_NODE_TYPES.FunctionExpression || node.type === import_utils10.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils10.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isNamedType(node) {
-      return node.type === import_utils8.AST_NODE_TYPES.TSTypeReference;
+      return node.type === import_utils10.AST_NODE_TYPES.TSTypeReference;
     }
     function isAlreadyReadonly(node) {
-      if (node.type === import_utils8.AST_NODE_TYPES.TSTypeReference && node.typeName) {
-        if (node.typeName.type === import_utils8.AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
+      if (node.type === import_utils10.AST_NODE_TYPES.TSTypeReference && node.typeName) {
+        if (node.typeName.type === import_utils10.AST_NODE_TYPES.Identifier && node.typeName.name === "Readonly") {
           return true;
         }
       }
@@ -868,7 +880,7 @@ var enforceReadonlyComponentProps = createRule8({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils8.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils10.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isNamedType(typeAnnotation) && !isAlreadyReadonly(typeAnnotation)) {
           const { sourceCode } = context;
@@ -893,8 +905,8 @@ var enforceReadonlyComponentProps = createRule8({
 var enforce_readonly_component_props_default = enforceReadonlyComponentProps;
 
 // src/rules/enforce-service-naming.ts
-var import_utils9 = require("@typescript-eslint/utils");
-var createRule9 = import_utils9.ESLintUtils.RuleCreator(
+var import_utils11 = require("@typescript-eslint/utils");
+var createRule9 = import_utils11.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var BANNED_PREFIXES = {
@@ -946,12 +958,12 @@ var enforceServiceNaming = createRule9({
     };
     return {
       ExportNamedDeclaration(node) {
-        if (node.declaration?.type === import_utils9.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
+        if (node.declaration?.type === import_utils11.AST_NODE_TYPES.FunctionDeclaration && node.declaration.id) {
           checkExportedFunction(node.declaration, node.declaration.id);
         }
-        if (node.declaration?.type === import_utils9.AST_NODE_TYPES.VariableDeclaration) {
+        if (node.declaration?.type === import_utils11.AST_NODE_TYPES.VariableDeclaration) {
           node.declaration.declarations.forEach((declarator) => {
-            if (declarator.id.type === import_utils9.AST_NODE_TYPES.Identifier && declarator.init?.type === import_utils9.AST_NODE_TYPES.ArrowFunctionExpression) {
+            if (declarator.id.type === import_utils11.AST_NODE_TYPES.Identifier && declarator.init?.type === import_utils11.AST_NODE_TYPES.ArrowFunctionExpression) {
               checkExportedFunction(declarator.init, declarator.id);
             }
           });
@@ -963,8 +975,8 @@ var enforceServiceNaming = createRule9({
 var enforce_service_naming_default = enforceServiceNaming;
 
 // src/rules/enforce-sorted-destructuring.ts
-var import_utils10 = require("@typescript-eslint/utils");
-var createRule10 = import_utils10.ESLintUtils.RuleCreator(
+var import_utils12 = require("@typescript-eslint/utils");
+var createRule10 = import_utils12.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var enforceSortedDestructuring = createRule10({
@@ -983,19 +995,19 @@ var enforceSortedDestructuring = createRule10({
   defaultOptions: [],
   create(context) {
     function getPropertyName(property) {
-      if (property.type === import_utils10.AST_NODE_TYPES.RestElement) {
+      if (property.type === import_utils12.AST_NODE_TYPES.RestElement) {
         return null;
       }
-      if (property.key.type === import_utils10.AST_NODE_TYPES.Identifier) {
+      if (property.key.type === import_utils12.AST_NODE_TYPES.Identifier) {
         return property.key.name;
       }
       return null;
     }
     function hasDefaultValue(property) {
-      return property.value.type === import_utils10.AST_NODE_TYPES.AssignmentPattern && Boolean(property.value.right);
+      return property.value.type === import_utils12.AST_NODE_TYPES.AssignmentPattern && Boolean(property.value.right);
     }
     function checkVariableDeclarator(node) {
-      if (node.id.type !== import_utils10.AST_NODE_TYPES.ObjectPattern) {
+      if (node.id.type !== import_utils12.AST_NODE_TYPES.ObjectPattern) {
         return;
       }
       const { properties } = node.id;
@@ -1003,7 +1015,7 @@ var enforceSortedDestructuring = createRule10({
         return;
       }
       const propertyInfo = properties.map((prop) => {
-        if (prop.type === import_utils10.AST_NODE_TYPES.RestElement) {
+        if (prop.type === import_utils12.AST_NODE_TYPES.RestElement) {
           return null;
         }
         return {
@@ -1042,15 +1054,15 @@ var enforceSortedDestructuring = createRule10({
 var enforce_sorted_destructuring_default = enforceSortedDestructuring;
 
 // src/rules/enforce-type-declaration-order.ts
-var import_utils11 = require("@typescript-eslint/utils");
-var createRule11 = import_utils11.ESLintUtils.RuleCreator(
+var import_utils13 = require("@typescript-eslint/utils");
+var createRule11 = import_utils13.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function getTypeDeclarationName(node) {
-  if (node.type === import_utils11.AST_NODE_TYPES.TSInterfaceDeclaration && node.id.type === import_utils11.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils13.AST_NODE_TYPES.TSInterfaceDeclaration && node.id.type === import_utils13.AST_NODE_TYPES.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
-  if (node.type === import_utils11.AST_NODE_TYPES.TSTypeAliasDeclaration && node.id.type === import_utils11.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils13.AST_NODE_TYPES.TSTypeAliasDeclaration && node.id.type === import_utils13.AST_NODE_TYPES.Identifier) {
     return { name: node.id.name, position: node.range[0] };
   }
   return null;
@@ -1086,7 +1098,7 @@ var enforceTypeDeclarationOrder = createRule11({
         }
       },
       "TSPropertySignature TSTypeReference": function checkTypeReference(node) {
-        if (node.typeName.type !== import_utils11.AST_NODE_TYPES.Identifier) {
+        if (node.typeName.type !== import_utils13.AST_NODE_TYPES.Identifier) {
           return;
         }
         const referencedName = node.typeName.name;
@@ -1124,8 +1136,8 @@ var enforce_type_declaration_order_default = enforceTypeDeclarationOrder;
 
 // src/rules/file-kebab-case.ts
 var import_path3 = __toESM(require("path"), 1);
-var import_utils12 = require("@typescript-eslint/utils");
-var createRule12 = import_utils12.ESLintUtils.RuleCreator(
+var import_utils14 = require("@typescript-eslint/utils");
+var createRule12 = import_utils14.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isKebabCase = (str) => {
@@ -1169,8 +1181,8 @@ var fileKebabCase = createRule12({
 var file_kebab_case_default = fileKebabCase;
 
 // src/rules/jsx-newline-between-elements.ts
-var import_utils13 = require("@typescript-eslint/utils");
-var createRule13 = import_utils13.ESLintUtils.RuleCreator(
+var import_utils15 = require("@typescript-eslint/utils");
+var createRule13 = import_utils15.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var jsxNewlineBetweenElements = createRule13({
@@ -1191,7 +1203,7 @@ var jsxNewlineBetweenElements = createRule13({
   create(context) {
     const { sourceCode } = context;
     function isSignificantJSXChild(node) {
-      return node.type === import_utils13.AST_NODE_TYPES.JSXElement || node.type === import_utils13.AST_NODE_TYPES.JSXFragment || node.type === import_utils13.AST_NODE_TYPES.JSXExpressionContainer;
+      return node.type === import_utils15.AST_NODE_TYPES.JSXElement || node.type === import_utils15.AST_NODE_TYPES.JSXFragment || node.type === import_utils15.AST_NODE_TYPES.JSXExpressionContainer;
     }
     function isMultiLine(node) {
       return node.loc.start.line !== node.loc.end.line;
@@ -1241,8 +1253,8 @@ var jsxNewlineBetweenElements = createRule13({
 var jsx_newline_between_elements_default = jsxNewlineBetweenElements;
 
 // src/rules/jsx-no-inline-object-prop.ts
-var import_utils14 = require("@typescript-eslint/utils");
-var createRule14 = import_utils14.ESLintUtils.RuleCreator(
+var import_utils16 = require("@typescript-eslint/utils");
+var createRule14 = import_utils16.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var jsxNoInlineObjectProp = createRule14({
@@ -1261,7 +1273,7 @@ var jsxNoInlineObjectProp = createRule14({
   create(context) {
     return {
       JSXAttribute(node) {
-        if (node.value?.type === import_utils14.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === import_utils14.AST_NODE_TYPES.ObjectExpression) {
+        if (node.value?.type === import_utils16.AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === import_utils16.AST_NODE_TYPES.ObjectExpression) {
           context.report({
             node: node.value,
             messageId: "noInlineObject"
@@ -1274,12 +1286,12 @@ var jsxNoInlineObjectProp = createRule14({
 var jsx_no_inline_object_prop_default = jsxNoInlineObjectProp;
 
 // src/rules/jsx-no-newline-single-line-elements.ts
-var import_utils15 = require("@typescript-eslint/utils");
-var createRule15 = import_utils15.ESLintUtils.RuleCreator(
+var import_utils17 = require("@typescript-eslint/utils");
+var createRule15 = import_utils17.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isJSXElementOrFragment(node) {
-  return node.type === import_utils15.AST_NODE_TYPES.JSXElement || node.type === import_utils15.AST_NODE_TYPES.JSXFragment;
+  return node.type === import_utils17.AST_NODE_TYPES.JSXElement || node.type === import_utils17.AST_NODE_TYPES.JSXFragment;
 }
 function isSingleLine(node) {
   return node.loc.start.line === node.loc.end.line;
@@ -1302,7 +1314,7 @@ var jsxNoNewlineSingleLineElements = createRule15({
     const { sourceCode } = context;
     function checkSiblings(children) {
       const nonWhitespace = children.filter(
-        (child) => !(child.type === import_utils15.AST_NODE_TYPES.JSXText && child.value.trim() === "")
+        (child) => !(child.type === import_utils17.AST_NODE_TYPES.JSXText && child.value.trim() === "")
       );
       nonWhitespace.forEach((next, index) => {
         if (index === 0) {
@@ -1353,15 +1365,8 @@ ${indent}`);
 var jsx_no_newline_single_line_elements_default = jsxNoNewlineSingleLineElements;
 
 // src/rules/jsx-no-non-component-function.ts
-var import_utils17 = require("@typescript-eslint/utils");
-
-// src/utils.ts
-var import_node_path = require("path");
-var import_utils16 = require("@typescript-eslint/utils");
-var getFileExtension = (filename) => (0, import_node_path.extname)(filename).slice(1);
-
-// src/rules/jsx-no-non-component-function.ts
-var createRule16 = import_utils17.ESLintUtils.RuleCreator(
+var import_utils18 = require("@typescript-eslint/utils");
+var createRule16 = import_utils18.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var jsxNoNonComponentFunction = createRule16({
@@ -1384,13 +1389,13 @@ var jsxNoNonComponentFunction = createRule16({
       return {};
     }
     function isReactComponent2(node) {
-      const functionName = node.type === import_utils17.AST_NODE_TYPES.FunctionDeclaration && node.id ? node.id.name : null;
+      const functionName = node.type === import_utils18.AST_NODE_TYPES.FunctionDeclaration && node.id ? node.id.name : null;
       if (functionName && /^[A-Z]/.test(functionName)) {
         return true;
       }
       if (node.returnType?.typeAnnotation) {
         const returnTypeNode = node.returnType.typeAnnotation;
-        if (returnTypeNode.type === import_utils17.AST_NODE_TYPES.TSTypeReference && returnTypeNode.typeName.type === import_utils17.AST_NODE_TYPES.Identifier) {
+        if (returnTypeNode.type === import_utils18.AST_NODE_TYPES.TSTypeReference && returnTypeNode.typeName.type === import_utils18.AST_NODE_TYPES.Identifier) {
           const typeName = returnTypeNode.typeName.name;
           if (typeName === "JSX" || typeName === "ReactElement" || typeName === "ReactNode") {
             return true;
@@ -1407,13 +1412,13 @@ var jsxNoNonComponentFunction = createRule16({
       if (!parent) {
         return;
       }
-      if (parent.type === import_utils17.AST_NODE_TYPES.ExportDefaultDeclaration || parent.type === import_utils17.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (parent.type === import_utils18.AST_NODE_TYPES.ExportDefaultDeclaration || parent.type === import_utils18.AST_NODE_TYPES.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.parent?.parent?.type === import_utils17.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (declaratorNode?.parent?.parent?.type === import_utils18.AST_NODE_TYPES.ExportNamedDeclaration) {
         return;
       }
-      if (declaratorNode?.id.type === import_utils17.AST_NODE_TYPES.Identifier) {
+      if (declaratorNode?.id.type === import_utils18.AST_NODE_TYPES.Identifier) {
         const varName = declaratorNode.id.name;
         if (/^[A-Z]/.test(varName)) {
           return;
@@ -1438,15 +1443,15 @@ var jsxNoNonComponentFunction = createRule16({
 var jsx_no_non_component_function_default = jsxNoNonComponentFunction;
 
 // src/rules/jsx-no-ternary-null.ts
-var import_utils19 = require("@typescript-eslint/utils");
-var createRule17 = import_utils19.ESLintUtils.RuleCreator(
+var import_utils20 = require("@typescript-eslint/utils");
+var createRule17 = import_utils20.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 function isNullOrUndefined(node) {
-  if (node.type === import_utils19.AST_NODE_TYPES.Literal && node.value === null) {
+  if (node.type === import_utils20.AST_NODE_TYPES.Literal && node.value === null) {
     return true;
   }
-  if (node.type === import_utils19.AST_NODE_TYPES.Identifier && node.name === "undefined") {
+  if (node.type === import_utils20.AST_NODE_TYPES.Identifier && node.name === "undefined") {
     return true;
   }
   return false;
@@ -1469,7 +1474,7 @@ var jsxNoTernaryNull = createRule17({
     return {
       JSXExpressionContainer(node) {
         const { expression } = node;
-        if (expression.type !== import_utils19.AST_NODE_TYPES.ConditionalExpression) {
+        if (expression.type !== import_utils20.AST_NODE_TYPES.ConditionalExpression) {
           return;
         }
         const { test, consequent, alternate } = expression;
@@ -1501,8 +1506,8 @@ var jsxNoTernaryNull = createRule17({
 var jsx_no_ternary_null_default = jsxNoTernaryNull;
 
 // src/rules/jsx-no-variable-in-callback.ts
-var import_utils20 = require("@typescript-eslint/utils");
-var createRule18 = import_utils20.ESLintUtils.RuleCreator(
+var import_utils21 = require("@typescript-eslint/utils");
+var createRule18 = import_utils21.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var jsxNoVariableInCallback = createRule18({
@@ -1522,7 +1527,7 @@ var jsxNoVariableInCallback = createRule18({
     function isInsideJSX(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === import_utils20.AST_NODE_TYPES.JSXElement || current.type === import_utils20.AST_NODE_TYPES.JSXFragment) {
+        if (current.type === import_utils21.AST_NODE_TYPES.JSXElement || current.type === import_utils21.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
         current = current.parent;
@@ -1536,11 +1541,11 @@ var jsxNoVariableInCallback = createRule18({
       if (!isInsideJSX(node)) {
         return false;
       }
-      if (node.parent.type === import_utils20.AST_NODE_TYPES.CallExpression || node.parent.type === import_utils20.AST_NODE_TYPES.JSXExpressionContainer) {
+      if (node.parent.type === import_utils21.AST_NODE_TYPES.CallExpression || node.parent.type === import_utils21.AST_NODE_TYPES.JSXExpressionContainer) {
         return true;
       }
-      if (node.parent.type === import_utils20.AST_NODE_TYPES.ArrayExpression && node.parent.parent) {
-        if (node.parent.parent.type === import_utils20.AST_NODE_TYPES.CallExpression || node.parent.parent.type === import_utils20.AST_NODE_TYPES.JSXExpressionContainer) {
+      if (node.parent.type === import_utils21.AST_NODE_TYPES.ArrayExpression && node.parent.parent) {
+        if (node.parent.parent.type === import_utils21.AST_NODE_TYPES.CallExpression || node.parent.parent.type === import_utils21.AST_NODE_TYPES.JSXExpressionContainer) {
           return true;
         }
       }
@@ -1551,11 +1556,11 @@ var jsxNoVariableInCallback = createRule18({
         return;
       }
       const { body } = node;
-      if (body.type !== import_utils20.AST_NODE_TYPES.BlockStatement) {
+      if (body.type !== import_utils21.AST_NODE_TYPES.BlockStatement) {
         return;
       }
       body.body.forEach((statement) => {
-        if (statement.type === import_utils20.AST_NODE_TYPES.VariableDeclaration) {
+        if (statement.type === import_utils21.AST_NODE_TYPES.VariableDeclaration) {
           context.report({
             node: statement,
             messageId: "noVariableInCallback"
@@ -1573,8 +1578,8 @@ var jsx_no_variable_in_callback_default = jsxNoVariableInCallback;
 
 // src/rules/jsx-pascal-case.ts
 var import_path4 = __toESM(require("path"), 1);
-var import_utils21 = require("@typescript-eslint/utils");
-var createRule19 = import_utils21.ESLintUtils.RuleCreator(
+var import_utils22 = require("@typescript-eslint/utils");
+var createRule19 = import_utils22.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var isPascalCase = (str) => /^[A-Z][a-zA-Z0-9]*$/.test(str) && !/^[A-Z]+$/.test(str);
@@ -1613,8 +1618,8 @@ var jsxPascalCase = createRule19({
 var jsx_pascal_case_default = jsxPascalCase;
 
 // src/rules/jsx-require-suspense.ts
-var import_utils22 = require("@typescript-eslint/utils");
-var createRule20 = import_utils22.ESLintUtils.RuleCreator(
+var import_utils23 = require("@typescript-eslint/utils");
+var createRule20 = import_utils23.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var jsxRequireSuspense = createRule20({
@@ -1635,7 +1640,7 @@ var jsxRequireSuspense = createRule20({
     const isInsideSuspense = (node) => {
       let current = node.parent;
       while (current) {
-        if (current.type === import_utils22.AST_NODE_TYPES.JSXElement && current.openingElement.name.type === import_utils22.AST_NODE_TYPES.JSXIdentifier && current.openingElement.name.name === "Suspense") {
+        if (current.type === import_utils23.AST_NODE_TYPES.JSXElement && current.openingElement.name.type === import_utils23.AST_NODE_TYPES.JSXIdentifier && current.openingElement.name.name === "Suspense") {
           return true;
         }
         current = current.parent;
@@ -1644,16 +1649,16 @@ var jsxRequireSuspense = createRule20({
     };
     return {
       VariableDeclarator(node) {
-        if (node.id.type === import_utils22.AST_NODE_TYPES.Identifier && node.init?.type === import_utils22.AST_NODE_TYPES.CallExpression) {
+        if (node.id.type === import_utils23.AST_NODE_TYPES.Identifier && node.init?.type === import_utils23.AST_NODE_TYPES.CallExpression) {
           const { callee } = node.init;
-          const isLazyCall = callee.type === import_utils22.AST_NODE_TYPES.Identifier && callee.name === "lazy" || callee.type === import_utils22.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils22.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils22.AST_NODE_TYPES.Identifier && callee.property.name === "lazy";
+          const isLazyCall = callee.type === import_utils23.AST_NODE_TYPES.Identifier && callee.name === "lazy" || callee.type === import_utils23.AST_NODE_TYPES.MemberExpression && callee.object.type === import_utils23.AST_NODE_TYPES.Identifier && callee.object.name === "React" && callee.property.type === import_utils23.AST_NODE_TYPES.Identifier && callee.property.name === "lazy";
           if (isLazyCall) {
             lazyComponents.add(node.id.name);
           }
         }
       },
       JSXOpeningElement(node) {
-        if (node.name.type === import_utils22.AST_NODE_TYPES.JSXIdentifier) {
+        if (node.name.type === import_utils23.AST_NODE_TYPES.JSXIdentifier) {
           const componentName = node.name.name;
           if (lazyComponents.has(componentName) && !isInsideSuspense(node)) {
             context.report({
@@ -1672,8 +1677,8 @@ var jsxRequireSuspense = createRule20({
 var jsx_require_suspense_default = jsxRequireSuspense;
 
 // src/rules/jsx-simple-props.ts
-var import_utils23 = require("@typescript-eslint/utils");
-var createRule21 = import_utils23.ESLintUtils.RuleCreator(
+var import_utils24 = require("@typescript-eslint/utils");
+var createRule21 = import_utils24.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var jsxSimpleProps = createRule21({
@@ -1691,25 +1696,25 @@ var jsxSimpleProps = createRule21({
   defaultOptions: [],
   create(context) {
     const allowedExpressionTypes = /* @__PURE__ */ new Set([
-      import_utils23.AST_NODE_TYPES.Identifier,
-      import_utils23.AST_NODE_TYPES.Literal,
-      import_utils23.AST_NODE_TYPES.JSXElement,
-      import_utils23.AST_NODE_TYPES.JSXFragment,
-      import_utils23.AST_NODE_TYPES.MemberExpression,
-      import_utils23.AST_NODE_TYPES.ArrowFunctionExpression,
-      import_utils23.AST_NODE_TYPES.FunctionExpression
+      import_utils24.AST_NODE_TYPES.Identifier,
+      import_utils24.AST_NODE_TYPES.Literal,
+      import_utils24.AST_NODE_TYPES.JSXElement,
+      import_utils24.AST_NODE_TYPES.JSXFragment,
+      import_utils24.AST_NODE_TYPES.MemberExpression,
+      import_utils24.AST_NODE_TYPES.ArrowFunctionExpression,
+      import_utils24.AST_NODE_TYPES.FunctionExpression
     ]);
     return {
       JSXAttribute(node) {
         if (!node.value) {
           return;
         }
-        if (node.value.type === import_utils23.AST_NODE_TYPES.Literal) {
+        if (node.value.type === import_utils24.AST_NODE_TYPES.Literal) {
           return;
         }
-        if (node.value.type === import_utils23.AST_NODE_TYPES.JSXExpressionContainer) {
+        if (node.value.type === import_utils24.AST_NODE_TYPES.JSXExpressionContainer) {
           const { expression } = node.value;
-          if (expression.type === import_utils23.AST_NODE_TYPES.JSXEmptyExpression) {
+          if (expression.type === import_utils24.AST_NODE_TYPES.JSXEmptyExpression) {
             return;
           }
           if (!allowedExpressionTypes.has(expression.type)) {
@@ -1726,8 +1731,8 @@ var jsxSimpleProps = createRule21({
 var jsx_simple_props_default = jsxSimpleProps;
 
 // src/rules/jsx-sort-props.ts
-var import_utils24 = require("@typescript-eslint/utils");
-var createRule22 = import_utils24.ESLintUtils.RuleCreator(
+var import_utils25 = require("@typescript-eslint/utils");
+var createRule22 = import_utils25.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var TYPE_GROUP = {
@@ -1741,15 +1746,15 @@ var TYPE_GROUP = {
   SHORTHAND: 8
 };
 var EXPRESSION_TYPE_TO_GROUP = /* @__PURE__ */ new Map([
-  [import_utils24.AST_NODE_TYPES.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [import_utils24.AST_NODE_TYPES.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
-  [import_utils24.AST_NODE_TYPES.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
-  [import_utils24.AST_NODE_TYPES.FunctionExpression, TYPE_GROUP.FUNCTION],
-  [import_utils24.AST_NODE_TYPES.JSXElement, TYPE_GROUP.JSX],
-  [import_utils24.AST_NODE_TYPES.JSXFragment, TYPE_GROUP.JSX]
+  [import_utils25.AST_NODE_TYPES.ObjectExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [import_utils25.AST_NODE_TYPES.ArrayExpression, TYPE_GROUP.OBJECT_ARRAY],
+  [import_utils25.AST_NODE_TYPES.ArrowFunctionExpression, TYPE_GROUP.FUNCTION],
+  [import_utils25.AST_NODE_TYPES.FunctionExpression, TYPE_GROUP.FUNCTION],
+  [import_utils25.AST_NODE_TYPES.JSXElement, TYPE_GROUP.JSX],
+  [import_utils25.AST_NODE_TYPES.JSXFragment, TYPE_GROUP.JSX]
 ]);
 function isHyphenatedName(node) {
-  return node.name.type === import_utils24.AST_NODE_TYPES.JSXIdentifier && node.name.name.includes("-");
+  return node.name.type === import_utils25.AST_NODE_TYPES.JSXIdentifier && node.name.name.includes("-");
 }
 function getStringGroup(node) {
   return isHyphenatedName(node) ? TYPE_GROUP.HYPHENATED_STRING : TYPE_GROUP.STRING;
@@ -1761,13 +1766,13 @@ function getLiteralValueGroup(value) {
   return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
 }
 function getExpressionGroup(expression) {
-  if (expression.type === import_utils24.AST_NODE_TYPES.Literal) {
+  if (expression.type === import_utils25.AST_NODE_TYPES.Literal) {
     return getLiteralValueGroup(expression.value);
   }
-  if (expression.type === import_utils24.AST_NODE_TYPES.TemplateLiteral) {
+  if (expression.type === import_utils25.AST_NODE_TYPES.TemplateLiteral) {
     return null;
   }
-  if (expression.type === import_utils24.AST_NODE_TYPES.Identifier && expression.name === "undefined") {
+  if (expression.type === import_utils25.AST_NODE_TYPES.Identifier && expression.name === "undefined") {
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
   return EXPRESSION_TYPE_TO_GROUP.get(expression.type) ?? TYPE_GROUP.EXPRESSION;
@@ -1776,17 +1781,17 @@ function getTypeGroup(node) {
   if (node.value === null) {
     return TYPE_GROUP.SHORTHAND;
   }
-  if (node.value.type === import_utils24.AST_NODE_TYPES.Literal) {
+  if (node.value.type === import_utils25.AST_NODE_TYPES.Literal) {
     if (typeof node.value.value === "string") {
       return getStringGroup(node);
     }
     return TYPE_GROUP.NUMBER_BOOLEAN_NULL;
   }
-  if (node.value.type !== import_utils24.AST_NODE_TYPES.JSXExpressionContainer) {
+  if (node.value.type !== import_utils25.AST_NODE_TYPES.JSXExpressionContainer) {
     return null;
   }
   const { expression } = node.value;
-  if (expression.type === import_utils24.AST_NODE_TYPES.JSXEmptyExpression) {
+  if (expression.type === import_utils25.AST_NODE_TYPES.JSXEmptyExpression) {
     return null;
   }
   const group = getExpressionGroup(expression);
@@ -1798,7 +1803,7 @@ function getTypeGroup(node) {
 function hasUnsortedProps(attributes) {
   let lastGroup = 0;
   return attributes.some((attribute) => {
-    if (attribute.type === import_utils24.AST_NODE_TYPES.JSXSpreadAttribute) {
+    if (attribute.type === import_utils25.AST_NODE_TYPES.JSXSpreadAttribute) {
       lastGroup = 0;
       return false;
     }
@@ -1822,7 +1827,7 @@ function getSegments(attributes) {
   const result = [];
   let current = [];
   attributes.forEach((attr) => {
-    if (attr.type === import_utils24.AST_NODE_TYPES.JSXSpreadAttribute) {
+    if (attr.type === import_utils25.AST_NODE_TYPES.JSXSpreadAttribute) {
       if (current.length > 0) {
         result.push(current);
         current = [];
@@ -1871,8 +1876,8 @@ var jsxSortProps = createRule22({
 var jsx_sort_props_default = jsxSortProps;
 
 // src/rules/jsx-spread-props-last.ts
-var import_utils25 = require("@typescript-eslint/utils");
-var createRule23 = import_utils25.ESLintUtils.RuleCreator(
+var import_utils26 = require("@typescript-eslint/utils");
+var createRule23 = import_utils26.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var jsxSpreadPropsLast = createRule23({
@@ -1894,12 +1899,12 @@ var jsxSpreadPropsLast = createRule23({
         const { attributes } = node;
         let lastNonSpreadIndex = -1;
         attributes.forEach((attribute, index) => {
-          if (attribute.type !== import_utils25.AST_NODE_TYPES.JSXSpreadAttribute) {
+          if (attribute.type !== import_utils26.AST_NODE_TYPES.JSXSpreadAttribute) {
             lastNonSpreadIndex = index;
           }
         });
         attributes.forEach((attribute, index) => {
-          if (attribute.type === import_utils25.AST_NODE_TYPES.JSXSpreadAttribute && index < lastNonSpreadIndex) {
+          if (attribute.type === import_utils26.AST_NODE_TYPES.JSXSpreadAttribute && index < lastNonSpreadIndex) {
             context.report({
               node: attribute,
               messageId: "spreadNotLast"
@@ -1913,12 +1918,12 @@ var jsxSpreadPropsLast = createRule23({
 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(
+var import_utils27 = require("@typescript-eslint/utils");
+var createRule24 = import_utils27.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_utils26.AST_NODE_TYPES.ImportDeclaration;
+  return node.type === import_utils27.AST_NODE_TYPES.ImportDeclaration;
 }
 function checkStatements(statements, context) {
   const { sourceCode } = context;
@@ -1981,8 +1986,8 @@ var newlineAfterMultilineBlock = createRule24({
 var newline_after_multiline_block_default = newlineAfterMultilineBlock;
 
 // src/rules/newline-before-return.ts
-var import_utils27 = require("@typescript-eslint/utils");
-var createRule25 = import_utils27.ESLintUtils.RuleCreator(
+var import_utils28 = require("@typescript-eslint/utils");
+var createRule25 = import_utils28.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var newlineBeforeReturn = createRule25({
@@ -2003,7 +2008,7 @@ var newlineBeforeReturn = createRule25({
     const { sourceCode } = context;
     function checkReturnStatement(node) {
       const { parent } = node;
-      if (!parent || parent.type !== import_utils27.AST_NODE_TYPES.BlockStatement) {
+      if (!parent || parent.type !== import_utils28.AST_NODE_TYPES.BlockStatement) {
         return;
       }
       const { body: statements } = parent;
@@ -2040,8 +2045,8 @@ var newlineBeforeReturn = createRule25({
 var newline_before_return_default = newlineBeforeReturn;
 
 // src/rules/nextjs-require-public-env.ts
-var import_utils28 = require("@typescript-eslint/utils");
-var createRule26 = import_utils28.ESLintUtils.RuleCreator(
+var import_utils29 = require("@typescript-eslint/utils");
+var createRule26 = import_utils29.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var nextjsRequirePublicEnv = createRule26({
@@ -2062,7 +2067,7 @@ var nextjsRequirePublicEnv = createRule26({
     return {
       Program(node) {
         const firstStatement = node.body[0];
-        if (firstStatement?.type === import_utils28.AST_NODE_TYPES.ExpressionStatement && firstStatement.expression.type === import_utils28.AST_NODE_TYPES.Literal && firstStatement.expression.value === "use client") {
+        if (firstStatement?.type === import_utils29.AST_NODE_TYPES.ExpressionStatement && firstStatement.expression.type === import_utils29.AST_NODE_TYPES.Literal && firstStatement.expression.value === "use client") {
           isClientComponent = true;
         }
       },
@@ -2070,7 +2075,7 @@ var nextjsRequirePublicEnv = createRule26({
         if (!isClientComponent) {
           return;
         }
-        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) {
+        if (node.object.type === import_utils29.AST_NODE_TYPES.MemberExpression && node.object.object.type === import_utils29.AST_NODE_TYPES.Identifier && node.object.object.name === "process" && node.object.property.type === import_utils29.AST_NODE_TYPES.Identifier && node.object.property.name === "env" && node.property.type === import_utils29.AST_NODE_TYPES.Identifier) {
           const envVarName = node.property.name;
           if (!envVarName.startsWith("NEXT_PUBLIC_") && envVarName !== "NODE_ENV") {
             context.report({
@@ -2089,8 +2094,8 @@ var nextjsRequirePublicEnv = createRule26({
 var nextjs_require_public_env_default = nextjsRequirePublicEnv;
 
 // src/rules/no-complex-inline-return.ts
-var import_utils29 = require("@typescript-eslint/utils");
-var createRule27 = import_utils29.ESLintUtils.RuleCreator(
+var import_utils30 = require("@typescript-eslint/utils");
+var createRule27 = import_utils30.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noComplexInlineReturn = createRule27({
@@ -2109,13 +2114,13 @@ var noComplexInlineReturn = createRule27({
   create(context) {
     const isComplexExpression = (node) => {
       if (!node) return false;
-      if (node.type === import_utils29.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils30.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils29.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils30.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils29.AST_NODE_TYPES.NewExpression) {
+      if (node.type === import_utils30.AST_NODE_TYPES.NewExpression) {
         return true;
       }
       return false;
@@ -2135,8 +2140,8 @@ var noComplexInlineReturn = createRule27({
 var no_complex_inline_return_default = noComplexInlineReturn;
 
 // src/rules/no-direct-date.ts
-var import_utils30 = require("@typescript-eslint/utils");
-var createRule28 = import_utils30.ESLintUtils.RuleCreator(
+var import_utils31 = require("@typescript-eslint/utils");
+var createRule28 = import_utils31.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noDirectDate = createRule28({
@@ -2157,7 +2162,7 @@ var noDirectDate = createRule28({
   create(context) {
     return {
       NewExpression(node) {
-        if (node.callee.type === import_utils30.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
+        if (node.callee.type === import_utils31.AST_NODE_TYPES.Identifier && node.callee.name === "Date") {
           context.report({
             node,
             messageId: "noNewDate"
@@ -2165,7 +2170,7 @@ var noDirectDate = createRule28({
         }
       },
       CallExpression(node) {
-        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) {
+        if (node.callee.type === import_utils31.AST_NODE_TYPES.MemberExpression && node.callee.object.type === import_utils31.AST_NODE_TYPES.Identifier && node.callee.object.name === "Date" && node.callee.property.type === import_utils31.AST_NODE_TYPES.Identifier) {
           const methodName = node.callee.property.name;
           if (methodName === "now") {
             context.report({
@@ -2188,8 +2193,8 @@ var no_direct_date_default = noDirectDate;
 
 // src/rules/no-emoji.ts
 var import_emoji_regex = __toESM(require("emoji-regex"), 1);
-var import_utils31 = require("@typescript-eslint/utils");
-var createRule29 = import_utils31.ESLintUtils.RuleCreator(
+var import_utils32 = require("@typescript-eslint/utils");
+var createRule29 = import_utils32.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noEmoji = createRule29({
@@ -2226,8 +2231,8 @@ var noEmoji = createRule29({
 var no_emoji_default = noEmoji;
 
 // src/rules/no-env-fallback.ts
-var import_utils32 = require("@typescript-eslint/utils");
-var createRule30 = import_utils32.ESLintUtils.RuleCreator(
+var import_utils33 = require("@typescript-eslint/utils");
+var createRule30 = import_utils33.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noEnvFallback = createRule30({
@@ -2245,16 +2250,16 @@ var noEnvFallback = createRule30({
   defaultOptions: [],
   create(context) {
     const isProcessEnvAccess = (node) => {
-      if (node.type !== import_utils32.AST_NODE_TYPES.MemberExpression) {
+      if (node.type !== import_utils33.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const { object } = node;
-      if (object.type !== import_utils32.AST_NODE_TYPES.MemberExpression) {
+      if (object.type !== import_utils33.AST_NODE_TYPES.MemberExpression) {
         return false;
       }
       const processNode = object.object;
       const envNode = object.property;
-      return processNode.type === import_utils32.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils32.AST_NODE_TYPES.Identifier && envNode.name === "env";
+      return processNode.type === import_utils33.AST_NODE_TYPES.Identifier && processNode.name === "process" && envNode.type === import_utils33.AST_NODE_TYPES.Identifier && envNode.name === "env";
     };
     return {
       LogicalExpression(node) {
@@ -2279,8 +2284,8 @@ var noEnvFallback = createRule30({
 var no_env_fallback_default = noEnvFallback;
 
 // src/rules/no-inline-default-export.ts
-var import_utils33 = require("@typescript-eslint/utils");
-var createRule31 = import_utils33.ESLintUtils.RuleCreator(
+var import_utils34 = require("@typescript-eslint/utils");
+var createRule31 = import_utils34.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noInlineDefaultExport = createRule31({
@@ -2302,7 +2307,7 @@ var noInlineDefaultExport = createRule31({
     return {
       ExportDefaultDeclaration(node) {
         const { declaration } = node;
-        if (declaration.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration) {
+        if (declaration.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2317,7 +2322,7 @@ var noInlineDefaultExport = createRule31({
             });
           }
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.ClassDeclaration) {
+        if (declaration.type === import_utils34.AST_NODE_TYPES.ClassDeclaration) {
           if (declaration.id) {
             context.report({
               node,
@@ -2332,7 +2337,7 @@ var noInlineDefaultExport = createRule31({
             });
           }
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils33.AST_NODE_TYPES.FunctionExpression) {
+        if (declaration.type === import_utils34.AST_NODE_TYPES.ArrowFunctionExpression || declaration.type === import_utils34.AST_NODE_TYPES.FunctionExpression) {
           context.report({
             node,
             messageId: "noAnonymousDefaultExport",
@@ -2345,14 +2350,14 @@ var noInlineDefaultExport = createRule31({
         if (!declaration) {
           return;
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
+        if (declaration.type === import_utils34.AST_NODE_TYPES.FunctionDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
             data: { type: "function", name: declaration.id.name }
           });
         }
-        if (declaration.type === import_utils33.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
+        if (declaration.type === import_utils34.AST_NODE_TYPES.ClassDeclaration && declaration.id) {
           context.report({
             node,
             messageId: "noInlineNamedExport",
@@ -2366,15 +2371,15 @@ var noInlineDefaultExport = createRule31({
 var no_inline_default_export_default = noInlineDefaultExport;
 
 // src/rules/no-inline-nested-object.ts
-var import_utils34 = require("@typescript-eslint/utils");
-var createRule32 = import_utils34.ESLintUtils.RuleCreator(
+var import_utils35 = require("@typescript-eslint/utils");
+var createRule32 = import_utils35.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_utils34.AST_NODE_TYPES.ObjectExpression || node.type === import_utils34.AST_NODE_TYPES.ArrayExpression || node.type === import_utils34.AST_NODE_TYPES.TSAsExpression;
+  return node.type === import_utils35.AST_NODE_TYPES.ObjectExpression || node.type === import_utils35.AST_NODE_TYPES.ArrayExpression || node.type === import_utils35.AST_NODE_TYPES.TSAsExpression;
 }
 function getInnerExpression(node) {
-  if (node.type === import_utils34.AST_NODE_TYPES.TSAsExpression) {
+  if (node.type === import_utils35.AST_NODE_TYPES.TSAsExpression) {
     return getInnerExpression(node.expression);
   }
   return node;
@@ -2383,7 +2388,7 @@ function arrayContainsOnlyPrimitives(node) {
   return node.elements.every((el) => {
     if (el === null) return true;
     const inner = getInnerExpression(el);
-    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;
+    return inner.type === import_utils35.AST_NODE_TYPES.Literal || inner.type === import_utils35.AST_NODE_TYPES.Identifier || inner.type === import_utils35.AST_NODE_TYPES.TemplateLiteral || inner.type === import_utils35.AST_NODE_TYPES.UnaryExpression;
   });
 }
 var noInlineNestedObject = createRule32({
@@ -2408,17 +2413,17 @@ var noInlineNestedObject = createRule32({
           return;
         }
         const valueNode = getInnerExpression(node.value);
-        if (valueNode.type !== import_utils34.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils34.AST_NODE_TYPES.ArrayExpression) {
+        if (valueNode.type !== import_utils35.AST_NODE_TYPES.ObjectExpression && valueNode.type !== import_utils35.AST_NODE_TYPES.ArrayExpression) {
           return;
         }
         if (!valueNode.loc) {
           return;
         }
-        const elements = valueNode.type === import_utils34.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
+        const elements = valueNode.type === import_utils35.AST_NODE_TYPES.ObjectExpression ? valueNode.properties : valueNode.elements;
         if (elements.length <= 1) {
           return;
         }
-        if (valueNode.type === import_utils34.AST_NODE_TYPES.ArrayExpression && arrayContainsOnlyPrimitives(valueNode)) {
+        if (valueNode.type === import_utils35.AST_NODE_TYPES.ArrayExpression && arrayContainsOnlyPrimitives(valueNode)) {
           return;
         }
         const isMultiline = valueNode.loc.start.line !== valueNode.loc.end.line;
@@ -2437,7 +2442,7 @@ var noInlineNestedObject = createRule32({
             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_utils34.AST_NODE_TYPES.ObjectExpression;
+            const isObject = valueNode.type === import_utils35.AST_NODE_TYPES.ObjectExpression;
             const openChar = isObject ? "{" : "[";
             const closeChar = isObject ? "}" : "]";
             const formattedElements = elementTexts.map((text) => `${innerIndent}${text},`).join("\n");
@@ -2454,15 +2459,15 @@ ${indent}${closeChar}`;
 var no_inline_nested_object_default = noInlineNestedObject;
 
 // src/rules/no-inline-return-properties.ts
-var import_utils35 = require("@typescript-eslint/utils");
-var createRule33 = import_utils35.ESLintUtils.RuleCreator(
+var import_utils36 = require("@typescript-eslint/utils");
+var createRule33 = import_utils36.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_utils35.AST_NODE_TYPES.SpreadElement) {
+  if (property.type === import_utils36.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (property.type !== import_utils35.AST_NODE_TYPES.Property) {
+  if (property.type !== import_utils36.AST_NODE_TYPES.Property) {
     return false;
   }
   return property.shorthand;
@@ -2483,20 +2488,20 @@ var noInlineReturnProperties = createRule33({
   create(context) {
     return {
       ReturnStatement(node) {
-        if (!node.argument || node.argument.type !== import_utils35.AST_NODE_TYPES.ObjectExpression) {
+        if (!node.argument || node.argument.type !== import_utils36.AST_NODE_TYPES.ObjectExpression) {
           return;
         }
         node.argument.properties.forEach((property) => {
           if (isShorthandProperty(property)) {
             return;
           }
-          if (property.type !== import_utils35.AST_NODE_TYPES.Property) {
+          if (property.type !== import_utils36.AST_NODE_TYPES.Property) {
             return;
           }
           let keyName = null;
-          if (property.key.type === import_utils35.AST_NODE_TYPES.Identifier) {
+          if (property.key.type === import_utils36.AST_NODE_TYPES.Identifier) {
             keyName = property.key.name;
-          } else if (property.key.type === import_utils35.AST_NODE_TYPES.Literal) {
+          } else if (property.key.type === import_utils36.AST_NODE_TYPES.Literal) {
             keyName = String(property.key.value);
           }
           context.report({
@@ -2512,8 +2517,8 @@ var noInlineReturnProperties = createRule33({
 var no_inline_return_properties_default = noInlineReturnProperties;
 
 // src/rules/no-lazy-identifiers.ts
-var import_utils36 = require("@typescript-eslint/utils");
-var createRule34 = import_utils36.ESLintUtils.RuleCreator(
+var import_utils37 = require("@typescript-eslint/utils");
+var createRule34 = import_utils37.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"];
@@ -2580,27 +2585,27 @@ var noLazyIdentifiers = createRule34({
       });
     };
     const checkPattern = (pattern) => {
-      if (pattern.type === import_utils36.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils37.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern);
-      } else if (pattern.type === import_utils36.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils37.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils36.AST_NODE_TYPES.Property && prop.value.type === import_utils36.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils37.AST_NODE_TYPES.Property && prop.value.type === import_utils37.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value);
-          } else if (prop.type === import_utils36.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils36.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils37.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils37.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument);
           }
         });
-      } else if (pattern.type === import_utils36.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils37.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils36.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils37.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element);
-          } else if (element?.type === import_utils36.AST_NODE_TYPES.RestElement && element.argument.type === import_utils36.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils37.AST_NODE_TYPES.RestElement && element.argument.type === import_utils37.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument);
           }
         });
-      } else if (pattern.type === import_utils36.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils36.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils37.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils37.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left);
-      } else if (pattern.type === import_utils36.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils36.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils37.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils37.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument);
       }
     };
@@ -2645,8 +2650,8 @@ var noLazyIdentifiers = createRule34({
 var no_lazy_identifiers_default = noLazyIdentifiers;
 
 // src/rules/no-logic-in-params.ts
-var import_utils37 = require("@typescript-eslint/utils");
-var createRule35 = import_utils37.ESLintUtils.RuleCreator(
+var import_utils38 = require("@typescript-eslint/utils");
+var createRule35 = import_utils38.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noLogicInParams = createRule35({
@@ -2664,20 +2669,20 @@ var noLogicInParams = createRule35({
   defaultOptions: [],
   create(context) {
     const isComplexExpression = (node) => {
-      if (node.type === import_utils37.AST_NODE_TYPES.SpreadElement) {
+      if (node.type === import_utils38.AST_NODE_TYPES.SpreadElement) {
         return false;
       }
-      if (node.type === import_utils37.AST_NODE_TYPES.ConditionalExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.ConditionalExpression) {
         return true;
       }
-      if (node.type === import_utils37.AST_NODE_TYPES.LogicalExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.LogicalExpression) {
         return true;
       }
-      if (node.type === import_utils37.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.BinaryExpression) {
         const logicalOperators = ["==", "===", "!=", "!==", "<", ">", "<=", ">=", "in", "instanceof"];
         return logicalOperators.includes(node.operator);
       }
-      if (node.type === import_utils37.AST_NODE_TYPES.UnaryExpression) {
+      if (node.type === import_utils38.AST_NODE_TYPES.UnaryExpression) {
         return node.operator === "!";
       }
       return false;
@@ -2690,7 +2695,7 @@ var noLogicInParams = createRule35({
             messageId: "noLogicInParams"
           });
         }
-        if (arg.type === import_utils37.AST_NODE_TYPES.ArrayExpression) {
+        if (arg.type === import_utils38.AST_NODE_TYPES.ArrayExpression) {
           arg.elements.forEach((element) => {
             if (element && isComplexExpression(element)) {
               context.report({
@@ -2715,41 +2720,41 @@ var noLogicInParams = createRule35({
 var no_logic_in_params_default = noLogicInParams;
 
 // src/rules/no-misleading-constant-case.ts
-var import_utils38 = require("@typescript-eslint/utils");
-var createRule36 = import_utils38.ESLintUtils.RuleCreator(
+var import_utils39 = require("@typescript-eslint/utils");
+var createRule36 = import_utils39.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_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 isAsConstAssertion2 = (node) => node.type === import_utils39.AST_NODE_TYPES.TSAsExpression && node.typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSTypeReference && node.typeAnnotation.typeName.type === import_utils39.AST_NODE_TYPES.Identifier && node.typeAnnotation.typeName.name === "const";
 var isStaticValue3 = (init) => {
   if (isAsConstAssertion2(init)) {
     return true;
   }
-  if (init.type === import_utils38.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils39.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils38.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils38.AST_NODE_TYPES.Literal) {
+  if (init.type === import_utils39.AST_NODE_TYPES.UnaryExpression && init.argument.type === import_utils39.AST_NODE_TYPES.Literal) {
     return true;
   }
-  if (init.type === import_utils38.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
+  if (init.type === import_utils39.AST_NODE_TYPES.TemplateLiteral && init.expressions.length === 0) {
     return true;
   }
-  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_utils39.AST_NODE_TYPES.ArrayExpression) {
+    return init.elements.every((el) => el !== null && el.type !== import_utils39.AST_NODE_TYPES.SpreadElement && isStaticValue3(el));
   }
-  if (init.type === import_utils38.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type === import_utils39.AST_NODE_TYPES.ObjectExpression) {
     return init.properties.every(
-      (prop) => prop.type === import_utils38.AST_NODE_TYPES.Property && isStaticValue3(prop.value)
+      (prop) => prop.type === import_utils39.AST_NODE_TYPES.Property && isStaticValue3(prop.value)
     );
   }
   return false;
 };
 var isGlobalScope3 = (node) => {
   const { parent } = node;
-  if (parent.type === import_utils38.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils39.AST_NODE_TYPES.Program) {
     return true;
   }
-  if (parent.type === import_utils38.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils38.AST_NODE_TYPES.Program) {
+  if (parent.type === import_utils39.AST_NODE_TYPES.ExportNamedDeclaration && parent.parent?.type === import_utils39.AST_NODE_TYPES.Program) {
     return true;
   }
   return false;
@@ -2773,7 +2778,7 @@ var noMisleadingConstantCase = createRule36({
     return {
       VariableDeclaration(node) {
         node.declarations.forEach((declarator) => {
-          if (declarator.id.type !== import_utils38.AST_NODE_TYPES.Identifier) {
+          if (declarator.id.type !== import_utils39.AST_NODE_TYPES.Identifier) {
             return;
           }
           const { name } = declarator.id;
@@ -2814,8 +2819,8 @@ var noMisleadingConstantCase = createRule36({
 var no_misleading_constant_case_default = noMisleadingConstantCase;
 
 // src/rules/no-nested-interface-declaration.ts
-var import_utils39 = require("@typescript-eslint/utils");
-var createRule37 = import_utils39.ESLintUtils.RuleCreator(
+var import_utils40 = require("@typescript-eslint/utils");
+var createRule37 = import_utils40.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noNestedInterfaceDeclaration = createRule37({
@@ -2839,15 +2844,15 @@ var noNestedInterfaceDeclaration = createRule37({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils40.AST_NODE_TYPES.TSTypeLiteral) {
           context.report({
             node: typeAnnotation,
             messageId: "noNestedInterface"
           });
           return;
         }
-        if (typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSArrayType) {
-          if (typeAnnotation.elementType.type === import_utils39.AST_NODE_TYPES.TSTypeLiteral) {
+        if (typeAnnotation.type === import_utils40.AST_NODE_TYPES.TSArrayType) {
+          if (typeAnnotation.elementType.type === import_utils40.AST_NODE_TYPES.TSTypeLiteral) {
             context.report({
               node: typeAnnotation.elementType,
               messageId: "noNestedInterface"
@@ -2855,9 +2860,9 @@ var noNestedInterfaceDeclaration = createRule37({
           }
           return;
         }
-        if (typeAnnotation.type === import_utils39.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
+        if (typeAnnotation.type === import_utils40.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeArguments) {
           typeAnnotation.typeArguments.params.forEach((param) => {
-            if (param.type === import_utils39.AST_NODE_TYPES.TSTypeLiteral) {
+            if (param.type === import_utils40.AST_NODE_TYPES.TSTypeLiteral) {
               context.report({
                 node: param,
                 messageId: "noNestedInterface"
@@ -2872,8 +2877,8 @@ var noNestedInterfaceDeclaration = createRule37({
 var no_nested_interface_declaration_default = noNestedInterfaceDeclaration;
 
 // src/rules/no-nested-ternary.ts
-var import_utils40 = require("@typescript-eslint/utils");
-var createRule38 = import_utils40.ESLintUtils.RuleCreator(
+var import_utils41 = require("@typescript-eslint/utils");
+var createRule38 = import_utils41.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noNestedTernary = createRule38({
@@ -2893,13 +2898,13 @@ var noNestedTernary = createRule38({
     return {
       ConditionalExpression(node) {
         const { consequent, alternate } = node;
-        if (consequent.type === import_utils40.AST_NODE_TYPES.ConditionalExpression) {
+        if (consequent.type === import_utils41.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: consequent,
             messageId: "noNestedTernary"
           });
         }
-        if (alternate.type === import_utils40.AST_NODE_TYPES.ConditionalExpression) {
+        if (alternate.type === import_utils41.AST_NODE_TYPES.ConditionalExpression) {
           context.report({
             node: alternate,
             messageId: "noNestedTernary"
@@ -2912,8 +2917,8 @@ var noNestedTernary = createRule38({
 var no_nested_ternary_default = noNestedTernary;
 
 // src/rules/no-relative-imports.ts
-var import_utils41 = require("@typescript-eslint/utils");
-var createRule39 = import_utils41.ESLintUtils.RuleCreator(
+var import_utils42 = require("@typescript-eslint/utils");
+var createRule39 = import_utils42.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var noRelativeImports = createRule39({
@@ -2940,22 +2945,22 @@ var noRelativeImports = createRule39({
     };
     return {
       ImportDeclaration(node) {
-        if (node.source.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils42.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ImportExpression(node) {
-        if (node.source.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils42.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportNamedDeclaration(node) {
-        if (node.source?.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source?.type === import_utils42.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       },
       ExportAllDeclaration(node) {
-        if (node.source.type === import_utils41.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+        if (node.source.type === import_utils42.AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
           checkImportPath(node.source.value, node);
         }
       }
@@ -2965,8 +2970,8 @@ var noRelativeImports = createRule39({
 var no_relative_imports_default = noRelativeImports;
 
 // src/rules/no-single-char-variables.ts
-var import_utils42 = require("@typescript-eslint/utils");
-var createRule40 = import_utils42.ESLintUtils.RuleCreator(
+var import_utils43 = require("@typescript-eslint/utils");
+var createRule40 = import_utils43.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"]);
@@ -2978,7 +2983,7 @@ var isForLoopInit = (node) => {
     if (!parentNode) {
       return false;
     }
-    if (parentNode.type === import_utils42.AST_NODE_TYPES.ForStatement) {
+    if (parentNode.type === import_utils43.AST_NODE_TYPES.ForStatement) {
       const { init } = parentNode;
       if (init && init === current) {
         return true;
@@ -3026,27 +3031,27 @@ var noSingleCharVariables = createRule40({
       });
     };
     const checkPattern = (pattern, declarationNode) => {
-      if (pattern.type === import_utils42.AST_NODE_TYPES.Identifier) {
+      if (pattern.type === import_utils43.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern, declarationNode);
-      } else if (pattern.type === import_utils42.AST_NODE_TYPES.ObjectPattern) {
+      } else if (pattern.type === import_utils43.AST_NODE_TYPES.ObjectPattern) {
         pattern.properties.forEach((prop) => {
-          if (prop.type === import_utils42.AST_NODE_TYPES.Property && prop.value.type === import_utils42.AST_NODE_TYPES.Identifier) {
+          if (prop.type === import_utils43.AST_NODE_TYPES.Property && prop.value.type === import_utils43.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.value, declarationNode);
-          } else if (prop.type === import_utils42.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils42.AST_NODE_TYPES.Identifier) {
+          } else if (prop.type === import_utils43.AST_NODE_TYPES.RestElement && prop.argument.type === import_utils43.AST_NODE_TYPES.Identifier) {
             checkIdentifier(prop.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils42.AST_NODE_TYPES.ArrayPattern) {
+      } else if (pattern.type === import_utils43.AST_NODE_TYPES.ArrayPattern) {
         pattern.elements.forEach((element) => {
-          if (element?.type === import_utils42.AST_NODE_TYPES.Identifier) {
+          if (element?.type === import_utils43.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element, declarationNode);
-          } else if (element?.type === import_utils42.AST_NODE_TYPES.RestElement && element.argument.type === import_utils42.AST_NODE_TYPES.Identifier) {
+          } else if (element?.type === import_utils43.AST_NODE_TYPES.RestElement && element.argument.type === import_utils43.AST_NODE_TYPES.Identifier) {
             checkIdentifier(element.argument, declarationNode);
           }
         });
-      } else if (pattern.type === import_utils42.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils42.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils43.AST_NODE_TYPES.AssignmentPattern && pattern.left.type === import_utils43.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.left, declarationNode);
-      } else if (pattern.type === import_utils42.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils42.AST_NODE_TYPES.Identifier) {
+      } else if (pattern.type === import_utils43.AST_NODE_TYPES.RestElement && pattern.argument.type === import_utils43.AST_NODE_TYPES.Identifier) {
         checkIdentifier(pattern.argument, declarationNode);
       }
     };
@@ -3080,8 +3085,8 @@ var noSingleCharVariables = createRule40({
 var no_single_char_variables_default = noSingleCharVariables;
 
 // src/rules/prefer-async-await.ts
-var import_utils43 = require("@typescript-eslint/utils");
-var createRule41 = import_utils43.ESLintUtils.RuleCreator(
+var import_utils44 = require("@typescript-eslint/utils");
+var createRule41 = import_utils44.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferAsyncAwait = createRule41({
@@ -3100,7 +3105,7 @@ var preferAsyncAwait = createRule41({
   create(context) {
     return {
       CallExpression(node) {
-        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") {
+        if (node.callee.type === import_utils44.AST_NODE_TYPES.MemberExpression && node.callee.property.type === import_utils44.AST_NODE_TYPES.Identifier && node.callee.property.name === "then") {
           context.report({
             node: node.callee.property,
             messageId: "preferAsyncAwait"
@@ -3113,8 +3118,8 @@ var preferAsyncAwait = createRule41({
 var prefer_async_await_default = preferAsyncAwait;
 
 // src/rules/prefer-destructuring-params.ts
-var import_utils44 = require("@typescript-eslint/utils");
-var createRule42 = import_utils44.ESLintUtils.RuleCreator(
+var import_utils45 = require("@typescript-eslint/utils");
+var createRule42 = import_utils45.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferDestructuringParams = createRule42({
@@ -3133,18 +3138,18 @@ var preferDestructuringParams = createRule42({
   create(context) {
     const isCallbackFunction2 = (node) => {
       const { parent } = node;
-      return parent?.type === import_utils44.AST_NODE_TYPES.CallExpression;
+      return parent?.type === import_utils45.AST_NODE_TYPES.CallExpression;
     };
     const isDeveloperFunction = (node) => {
-      if (node.type === import_utils44.AST_NODE_TYPES.FunctionDeclaration) {
+      if (node.type === import_utils45.AST_NODE_TYPES.FunctionDeclaration) {
         return true;
       }
-      if (node.type === import_utils44.AST_NODE_TYPES.FunctionExpression || node.type === import_utils44.AST_NODE_TYPES.ArrowFunctionExpression) {
+      if (node.type === import_utils45.AST_NODE_TYPES.FunctionExpression || node.type === import_utils45.AST_NODE_TYPES.ArrowFunctionExpression) {
         if (isCallbackFunction2(node)) {
           return false;
         }
         const { parent } = node;
-        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 parent?.type === import_utils45.AST_NODE_TYPES.VariableDeclarator || parent?.type === import_utils45.AST_NODE_TYPES.AssignmentExpression || parent?.type === import_utils45.AST_NODE_TYPES.Property || parent?.type === import_utils45.AST_NODE_TYPES.MethodDefinition;
       }
       return false;
     };
@@ -3156,7 +3161,7 @@ var preferDestructuringParams = createRule42({
       if (!isDeveloperFunction(node)) {
         return;
       }
-      if (node.type === import_utils44.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+      if (node.type === import_utils45.AST_NODE_TYPES.FunctionDeclaration && node.id) {
         const functionName = node.id.name;
         if (functionName.startsWith("_") || functionName.includes("$") || /^[A-Z][a-zA-Z]*$/.test(functionName)) {
           return;
@@ -3166,7 +3171,7 @@ var preferDestructuringParams = createRule42({
         return;
       }
       const hasNonDestructuredParams = node.params.some(
-        (param) => param.type !== import_utils44.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils44.AST_NODE_TYPES.RestElement
+        (param) => param.type !== import_utils45.AST_NODE_TYPES.ObjectPattern && param.type !== import_utils45.AST_NODE_TYPES.RestElement
       );
       if (hasNonDestructuredParams) {
         context.report({
@@ -3185,8 +3190,8 @@ var preferDestructuringParams = createRule42({
 var prefer_destructuring_params_default = preferDestructuringParams;
 
 // src/rules/prefer-function-declaration.ts
-var import_utils45 = require("@typescript-eslint/utils");
-var createRule43 = import_utils45.ESLintUtils.RuleCreator(
+var import_utils46 = require("@typescript-eslint/utils");
+var createRule43 = import_utils46.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");
@@ -3195,28 +3200,28 @@ var isCallbackContext = (node) => {
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.NewExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.ReturnStatement) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.ReturnStatement) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.ConditionalExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.ConditionalExpression) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.LogicalExpression) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.LogicalExpression) {
     return true;
   }
-  if (parent.type === import_utils45.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
+  if (parent.type === import_utils46.AST_NODE_TYPES.AssignmentExpression && parent.left !== node) {
     return true;
   }
   return false;
@@ -3242,14 +3247,14 @@ var preferFunctionDeclaration = createRule43({
     }
     return {
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+        if (node.id.type !== import_utils46.AST_NODE_TYPES.Identifier) {
           return;
         }
         const { init } = node;
         if (!init) {
           return;
         }
-        if (init.type === import_utils45.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (init.type === import_utils46.AST_NODE_TYPES.ArrowFunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3259,7 +3264,7 @@ var preferFunctionDeclaration = createRule43({
             data: { name: node.id.name }
           });
         }
-        if (init.type === import_utils45.AST_NODE_TYPES.FunctionExpression) {
+        if (init.type === import_utils46.AST_NODE_TYPES.FunctionExpression) {
           if (isCallbackContext(init)) {
             return;
           }
@@ -3276,8 +3281,8 @@ var preferFunctionDeclaration = createRule43({
 var prefer_function_declaration_default = preferFunctionDeclaration;
 
 // src/rules/prefer-guard-clause.ts
-var import_utils46 = require("@typescript-eslint/utils");
-var createRule44 = import_utils46.ESLintUtils.RuleCreator(
+var import_utils47 = require("@typescript-eslint/utils");
+var createRule44 = import_utils47.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferGuardClause = createRule44({
@@ -3297,8 +3302,8 @@ var preferGuardClause = createRule44({
     return {
       IfStatement(node) {
         const { consequent } = node;
-        if (consequent.type === import_utils46.AST_NODE_TYPES.BlockStatement) {
-          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils46.AST_NODE_TYPES.IfStatement);
+        if (consequent.type === import_utils47.AST_NODE_TYPES.BlockStatement) {
+          const hasNestedIf = consequent.body.some((statement) => statement.type === import_utils47.AST_NODE_TYPES.IfStatement);
           if (hasNestedIf && consequent.body.length === 1) {
             context.report({
               node,
@@ -3306,7 +3311,7 @@ var preferGuardClause = createRule44({
             });
           }
         }
-        if (consequent.type === import_utils46.AST_NODE_TYPES.IfStatement) {
+        if (consequent.type === import_utils47.AST_NODE_TYPES.IfStatement) {
           context.report({
             node,
             messageId: "preferGuardClause"
@@ -3319,8 +3324,8 @@ var preferGuardClause = createRule44({
 var prefer_guard_clause_default = preferGuardClause;
 
 // src/rules/prefer-import-type.ts
-var import_utils47 = require("@typescript-eslint/utils");
-var createRule45 = import_utils47.ESLintUtils.RuleCreator(
+var import_utils48 = require("@typescript-eslint/utils");
+var createRule45 = import_utils48.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferImportType = createRule45({
@@ -3342,22 +3347,22 @@ var preferImportType = createRule45({
       let current = node;
       while (current) {
         switch (current.type) {
-          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:
+          case import_utils48.AST_NODE_TYPES.TSTypeReference:
+          case import_utils48.AST_NODE_TYPES.TSTypeAnnotation:
+          case import_utils48.AST_NODE_TYPES.TSTypeParameterInstantiation:
+          case import_utils48.AST_NODE_TYPES.TSInterfaceHeritage:
+          case import_utils48.AST_NODE_TYPES.TSClassImplements:
+          case import_utils48.AST_NODE_TYPES.TSTypeQuery:
+          case import_utils48.AST_NODE_TYPES.TSTypeAssertion:
+          case import_utils48.AST_NODE_TYPES.TSAsExpression:
+          case import_utils48.AST_NODE_TYPES.TSSatisfiesExpression:
+          case import_utils48.AST_NODE_TYPES.TSTypeAliasDeclaration:
+          case import_utils48.AST_NODE_TYPES.TSInterfaceDeclaration:
+          case import_utils48.AST_NODE_TYPES.TSTypeParameter:
+          case import_utils48.AST_NODE_TYPES.TSQualifiedName:
             return true;
-          case import_utils47.AST_NODE_TYPES.MemberExpression:
-          case import_utils47.AST_NODE_TYPES.Identifier:
+          case import_utils48.AST_NODE_TYPES.MemberExpression:
+          case import_utils48.AST_NODE_TYPES.Identifier:
             current = current.parent;
             break;
           default:
@@ -3387,27 +3392,27 @@ var preferImportType = createRule45({
           return false;
         }
         switch (parent.type) {
-          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:
+          case import_utils48.AST_NODE_TYPES.CallExpression:
+          case import_utils48.AST_NODE_TYPES.NewExpression:
+          case import_utils48.AST_NODE_TYPES.JSXOpeningElement:
+          case import_utils48.AST_NODE_TYPES.JSXClosingElement:
+          case import_utils48.AST_NODE_TYPES.MemberExpression:
+          case import_utils48.AST_NODE_TYPES.VariableDeclarator:
+          case import_utils48.AST_NODE_TYPES.TaggedTemplateExpression:
+          case import_utils48.AST_NODE_TYPES.SpreadElement:
+          case import_utils48.AST_NODE_TYPES.ExportSpecifier:
+          case import_utils48.AST_NODE_TYPES.ArrayExpression:
+          case import_utils48.AST_NODE_TYPES.ObjectExpression:
+          case import_utils48.AST_NODE_TYPES.BinaryExpression:
+          case import_utils48.AST_NODE_TYPES.LogicalExpression:
+          case import_utils48.AST_NODE_TYPES.UnaryExpression:
+          case import_utils48.AST_NODE_TYPES.ReturnStatement:
+          case import_utils48.AST_NODE_TYPES.ArrowFunctionExpression:
+          case import_utils48.AST_NODE_TYPES.ConditionalExpression:
+          case import_utils48.AST_NODE_TYPES.AwaitExpression:
+          case import_utils48.AST_NODE_TYPES.YieldExpression:
+          case import_utils48.AST_NODE_TYPES.Property:
+          case import_utils48.AST_NODE_TYPES.JSXExpressionContainer:
             return true;
           default:
             return false;
@@ -3431,13 +3436,13 @@ var preferImportType = createRule45({
       }
       const scope = context.sourceCode.getScope(node);
       const isTypeOnlyImport2 = node.specifiers.every((specifier) => {
-        if (specifier.type === import_utils47.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        if (specifier.type === import_utils48.AST_NODE_TYPES.ImportDefaultSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils47.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        if (specifier.type === import_utils48.AST_NODE_TYPES.ImportNamespaceSpecifier) {
           return false;
         }
-        if (specifier.type === import_utils47.AST_NODE_TYPES.ImportSpecifier) {
+        if (specifier.type === import_utils48.AST_NODE_TYPES.ImportSpecifier) {
           const localName = specifier.local.name;
           return !isUsedAsValue(localName, scope);
         }
@@ -3463,16 +3468,16 @@ var preferImportType = createRule45({
 var prefer_import_type_default = preferImportType;
 
 // src/rules/prefer-inline-literal-union.ts
-var import_utils48 = require("@typescript-eslint/utils");
-var createRule46 = import_utils48.ESLintUtils.RuleCreator(
+var import_utils49 = require("@typescript-eslint/utils");
+var createRule46 = import_utils49.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_utils48.AST_NODE_TYPES.TSUnionType) {
+  if (node.type !== import_utils49.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.every(
-    (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
+    (member) => member.type === import_utils49.AST_NODE_TYPES.TSLiteralType || member.type === import_utils49.AST_NODE_TYPES.TSNullKeyword || member.type === import_utils49.AST_NODE_TYPES.TSUndefinedKeyword
   );
 }
 var preferInlineLiteralUnion = createRule46({
@@ -3502,10 +3507,10 @@ var preferInlineLiteralUnion = createRule46({
           return;
         }
         const { typeAnnotation } = node.typeAnnotation;
-        if (typeAnnotation.type !== import_utils48.AST_NODE_TYPES.TSTypeReference) {
+        if (typeAnnotation.type !== import_utils49.AST_NODE_TYPES.TSTypeReference) {
           return;
         }
-        if (typeAnnotation.typeName.type !== import_utils48.AST_NODE_TYPES.Identifier) {
+        if (typeAnnotation.typeName.type !== import_utils49.AST_NODE_TYPES.Identifier) {
           return;
         }
         const aliasName = typeAnnotation.typeName.name;
@@ -3529,11 +3534,11 @@ var preferInlineLiteralUnion = createRule46({
 var prefer_inline_literal_union_default = preferInlineLiteralUnion;
 
 // src/rules/prefer-inline-type-export.ts
-var import_utils49 = require("@typescript-eslint/utils");
-var createRule47 = import_utils49.ESLintUtils.RuleCreator(
+var import_utils50 = require("@typescript-eslint/utils");
+var createRule47 = import_utils50.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_utils49.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils49.AST_NODE_TYPES.TSTypeAliasDeclaration;
+var isTypeDeclaration = (node) => node.type === import_utils50.AST_NODE_TYPES.TSInterfaceDeclaration || node.type === import_utils50.AST_NODE_TYPES.TSTypeAliasDeclaration;
 var preferInlineTypeExport = createRule47({
   name: "prefer-inline-type-export",
   meta: {
@@ -3551,12 +3556,12 @@ var preferInlineTypeExport = createRule47({
   create(context) {
     const typeDeclarations = /* @__PURE__ */ new Map();
     function collectDeclaration(node) {
-      if (node.parent.type !== import_utils49.AST_NODE_TYPES.ExportNamedDeclaration) {
+      if (node.parent.type !== import_utils50.AST_NODE_TYPES.ExportNamedDeclaration) {
         typeDeclarations.set(node.id.name, node);
       }
     }
     function reportSpecifier(specifier, statement, declarationNode) {
-      if (specifier.local.type !== import_utils49.AST_NODE_TYPES.Identifier) {
+      if (specifier.local.type !== import_utils50.AST_NODE_TYPES.Identifier) {
         return;
       }
       const { name } = specifier.local;
@@ -3589,16 +3594,16 @@ var preferInlineTypeExport = createRule47({
     return {
       Program(node) {
         node.body.forEach((statement) => {
-          if (statement.type === import_utils49.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils49.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+          if (statement.type === import_utils50.AST_NODE_TYPES.TSInterfaceDeclaration || statement.type === import_utils50.AST_NODE_TYPES.TSTypeAliasDeclaration) {
             collectDeclaration(statement);
           }
         });
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils49.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils50.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             return;
           }
           statement.specifiers.forEach((specifier) => {
-            if (specifier.local.type !== import_utils49.AST_NODE_TYPES.Identifier) {
+            if (specifier.local.type !== import_utils50.AST_NODE_TYPES.Identifier) {
               return;
             }
             const declarationNode = typeDeclarations.get(specifier.local.name);
@@ -3615,8 +3620,8 @@ var preferInlineTypeExport = createRule47({
 var prefer_inline_type_export_default = preferInlineTypeExport;
 
 // src/rules/prefer-interface-over-inline-types.ts
-var import_utils50 = require("@typescript-eslint/utils");
-var createRule48 = import_utils50.ESLintUtils.RuleCreator(
+var import_utils51 = require("@typescript-eslint/utils");
+var createRule48 = import_utils51.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferInterfaceOverInlineTypes = createRule48({
@@ -3635,54 +3640,54 @@ var preferInterfaceOverInlineTypes = createRule48({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      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;
+      return node.consequent.type === import_utils51.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils51.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils51.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils51.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils50.AST_NODE_TYPES.JSXElement || node.right.type === import_utils50.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils51.AST_NODE_TYPES.JSXElement || node.right.type === import_utils51.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        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);
+        if (stmt.type === import_utils51.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils51.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils51.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils51.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils51.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      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) {
+      if (node.type === import_utils51.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils51.AST_NODE_TYPES.JSXElement || node.body.type === import_utils51.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils50.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils51.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } 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) {
+      } else if (node.type === import_utils51.AST_NODE_TYPES.FunctionExpression || node.type === import_utils51.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils51.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
       return false;
     }
     function isInlineTypeAnnotation(node) {
-      if (node.type === import_utils50.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils51.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      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_utils51.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils51.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils50.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils51.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => isInlineTypeAnnotation(type));
       }
       return false;
     }
     function hasInlineObjectType(node) {
-      if (node.type === import_utils50.AST_NODE_TYPES.TSTypeLiteral) {
+      if (node.type === import_utils51.AST_NODE_TYPES.TSTypeLiteral) {
         return true;
       }
-      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_utils51.AST_NODE_TYPES.TSTypeReference && node.typeArguments) {
+        return node.typeArguments.params.some((param) => param.type === import_utils51.AST_NODE_TYPES.TSTypeLiteral);
       }
-      if (node.type === import_utils50.AST_NODE_TYPES.TSUnionType) {
+      if (node.type === import_utils51.AST_NODE_TYPES.TSUnionType) {
         return node.types.some((type) => hasInlineObjectType(type));
       }
       return false;
@@ -3695,7 +3700,7 @@ var preferInterfaceOverInlineTypes = createRule48({
         return;
       }
       const param = node.params[0];
-      if (param.type === import_utils50.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+      if (param.type === import_utils51.AST_NODE_TYPES.Identifier && param.typeAnnotation) {
         const { typeAnnotation } = param.typeAnnotation;
         if (isInlineTypeAnnotation(typeAnnotation) && hasInlineObjectType(typeAnnotation)) {
           context.report({
@@ -3715,8 +3720,8 @@ var preferInterfaceOverInlineTypes = createRule48({
 var prefer_interface_over_inline_types_default = preferInterfaceOverInlineTypes;
 
 // src/rules/prefer-jsx-template-literals.ts
-var import_utils51 = require("@typescript-eslint/utils");
-var createRule49 = import_utils51.ESLintUtils.RuleCreator(
+var import_utils52 = require("@typescript-eslint/utils");
+var createRule49 = import_utils52.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferJSXTemplateLiterals = createRule49({
@@ -3788,9 +3793,9 @@ var preferJSXTemplateLiterals = createRule49({
         if (!child || !nextChild) {
           return;
         }
-        if (child.type === import_utils51.AST_NODE_TYPES.JSXText && nextChild.type === import_utils51.AST_NODE_TYPES.JSXExpressionContainer) {
+        if (child.type === import_utils52.AST_NODE_TYPES.JSXText && nextChild.type === import_utils52.AST_NODE_TYPES.JSXExpressionContainer) {
           handleTextBeforeExpression(child, nextChild);
-        } else if (child.type === import_utils51.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils51.AST_NODE_TYPES.JSXText) {
+        } else if (child.type === import_utils52.AST_NODE_TYPES.JSXExpressionContainer && nextChild.type === import_utils52.AST_NODE_TYPES.JSXText) {
           handleExpressionBeforeText(child, nextChild);
         }
       }
@@ -3803,8 +3808,8 @@ var preferJSXTemplateLiterals = createRule49({
 var prefer_jsx_template_literals_default = preferJSXTemplateLiterals;
 
 // src/rules/prefer-named-param-types.ts
-var import_utils52 = require("@typescript-eslint/utils");
-var createRule50 = import_utils52.ESLintUtils.RuleCreator(
+var import_utils53 = require("@typescript-eslint/utils");
+var createRule50 = import_utils53.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferNamedParamTypes = createRule50({
@@ -3822,16 +3827,16 @@ var preferNamedParamTypes = createRule50({
   defaultOptions: [],
   create(context) {
     function hasInlineObjectType(param) {
-      if (param.type === import_utils52.AST_NODE_TYPES.AssignmentPattern) {
+      if (param.type === import_utils53.AST_NODE_TYPES.AssignmentPattern) {
         return hasInlineObjectType(param.left);
       }
-      if (param.type === import_utils52.AST_NODE_TYPES.ObjectPattern) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils53.AST_NODE_TYPES.ObjectPattern) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils53.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
-      if (param.type === import_utils52.AST_NODE_TYPES.Identifier) {
-        if (param.typeAnnotation?.typeAnnotation.type === import_utils52.AST_NODE_TYPES.TSTypeLiteral) {
+      if (param.type === import_utils53.AST_NODE_TYPES.Identifier) {
+        if (param.typeAnnotation?.typeAnnotation.type === import_utils53.AST_NODE_TYPES.TSTypeLiteral) {
           return true;
         }
       }
@@ -3865,8 +3870,8 @@ var preferNamedParamTypes = createRule50({
 var prefer_named_param_types_default = preferNamedParamTypes;
 
 // src/rules/prefer-react-import-types.ts
-var import_utils53 = require("@typescript-eslint/utils");
-var createRule51 = import_utils53.ESLintUtils.RuleCreator(
+var import_utils54 = require("@typescript-eslint/utils");
+var createRule51 = import_utils54.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var preferReactImportTypes = createRule51({
@@ -3945,7 +3950,7 @@ var preferReactImportTypes = createRule51({
     ]);
     const allReactExports = /* @__PURE__ */ new Set([...reactTypes, ...reactRuntimeExports]);
     function checkMemberExpression(node) {
-      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)) {
+      if (node.object.type === import_utils54.AST_NODE_TYPES.Identifier && node.object.name === "React" && node.property.type === import_utils54.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"`;
@@ -3962,7 +3967,7 @@ var preferReactImportTypes = createRule51({
     return {
       MemberExpression: checkMemberExpression,
       "TSTypeReference > TSQualifiedName": (node) => {
-        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)) {
+        if (node.left.type === import_utils54.AST_NODE_TYPES.Identifier && node.left.name === "React" && node.right.type === import_utils54.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"`;
@@ -3982,8 +3987,8 @@ var preferReactImportTypes = createRule51({
 var prefer_react_import_types_default = preferReactImportTypes;
 
 // src/rules/react-props-destructure.ts
-var import_utils54 = require("@typescript-eslint/utils");
-var createRule52 = import_utils54.ESLintUtils.RuleCreator(
+var import_utils55 = require("@typescript-eslint/utils");
+var createRule52 = import_utils55.ESLintUtils.RuleCreator(
   (name) => `https://github.com/next-friday/eslint-plugin-nextfriday/blob/main/docs/rules/${name.replaceAll("-", "_").toUpperCase()}.md`
 );
 var reactPropsDestructure = createRule52({
@@ -4002,29 +4007,29 @@ var reactPropsDestructure = createRule52({
   defaultOptions: [],
   create(context) {
     function hasJSXInConditional(node) {
-      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;
+      return node.consequent.type === import_utils55.AST_NODE_TYPES.JSXElement || node.consequent.type === import_utils55.AST_NODE_TYPES.JSXFragment || node.alternate.type === import_utils55.AST_NODE_TYPES.JSXElement || node.alternate.type === import_utils55.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXInLogical(node) {
-      return node.right.type === import_utils54.AST_NODE_TYPES.JSXElement || node.right.type === import_utils54.AST_NODE_TYPES.JSXFragment;
+      return node.right.type === import_utils55.AST_NODE_TYPES.JSXElement || node.right.type === import_utils55.AST_NODE_TYPES.JSXFragment;
     }
     function hasJSXReturn(block) {
       return block.body.some((stmt) => {
-        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);
+        if (stmt.type === import_utils55.AST_NODE_TYPES.ReturnStatement && stmt.argument) {
+          return stmt.argument.type === import_utils55.AST_NODE_TYPES.JSXElement || stmt.argument.type === import_utils55.AST_NODE_TYPES.JSXFragment || stmt.argument.type === import_utils55.AST_NODE_TYPES.ConditionalExpression && hasJSXInConditional(stmt.argument) || stmt.argument.type === import_utils55.AST_NODE_TYPES.LogicalExpression && hasJSXInLogical(stmt.argument);
         }
         return false;
       });
     }
     function isReactComponent2(node) {
-      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) {
+      if (node.type === import_utils55.AST_NODE_TYPES.ArrowFunctionExpression) {
+        if (node.body.type === import_utils55.AST_NODE_TYPES.JSXElement || node.body.type === import_utils55.AST_NODE_TYPES.JSXFragment) {
           return true;
         }
-        if (node.body.type === import_utils54.AST_NODE_TYPES.BlockStatement) {
+        if (node.body.type === import_utils55.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
-      } 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) {
+      } else if (node.type === import_utils55.AST_NODE_TYPES.FunctionExpression || node.type === import_utils55.AST_NODE_TYPES.FunctionDeclaration) {
+        if (node.body && node.body.type === import_utils55.AST_NODE_TYPES.BlockStatement) {
           return hasJSXReturn(node.body);
         }
       }
@@ -4038,9 +4043,9 @@ var reactPropsDestructure = createRule52({
         return;
       }
       const param = node.params[0];
-      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) {
+      if (param.type === import_utils55.AST_NODE_TYPES.ObjectPattern) {
+        const properties = param.properties.filter((prop) => prop.type === import_utils55.AST_NODE_TYPES.Property).map((prop) => {
+          if (prop.key.type === import_utils55.AST_NODE_TYPES.Identifier) {
             return prop.key.name;
           }
           return null;
@@ -4067,52 +4072,52 @@ var reactPropsDestructure = createRule52({
 var react_props_destructure_default = reactPropsDestructure;
 
 // src/rules/require-explicit-return-type.ts
-var import_utils55 = require("@typescript-eslint/utils");
-var createRule53 = import_utils55.ESLintUtils.RuleCreator(
+var import_utils56 = require("@typescript-eslint/utils");
+var createRule53 = import_utils56.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_utils55.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === import_utils56.AST_NODE_TYPES.ArrowFunctionExpression) {
     const { parent } = node;
-    if (parent?.type === import_utils55.AST_NODE_TYPES.VariableDeclarator) {
+    if (parent?.type === import_utils56.AST_NODE_TYPES.VariableDeclarator) {
       const { id } = parent;
-      if (id.type === import_utils55.AST_NODE_TYPES.Identifier) {
+      if (id.type === import_utils56.AST_NODE_TYPES.Identifier) {
         return /^[A-Z]/.test(id.name);
       }
     }
   }
-  if (node.type === import_utils55.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils56.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return /^[A-Z]/.test(node.id.name);
   }
   return false;
 };
 var isCallbackFunction = (node) => {
-  if (node.type === import_utils55.AST_NODE_TYPES.FunctionDeclaration) {
+  if (node.type === import_utils56.AST_NODE_TYPES.FunctionDeclaration) {
     return false;
   }
   const { parent } = node;
   if (!parent) {
     return false;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
+  if (parent.type === import_utils56.AST_NODE_TYPES.CallExpression && parent.arguments.includes(node)) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.Property) {
+  if (parent.type === import_utils56.AST_NODE_TYPES.Property) {
     return true;
   }
-  if (parent.type === import_utils55.AST_NODE_TYPES.ArrayExpression) {
+  if (parent.type === import_utils56.AST_NODE_TYPES.ArrayExpression) {
     return true;
   }
   return false;
 };
 var getFunctionName = (node) => {
-  if (node.type === import_utils55.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+  if (node.type === import_utils56.AST_NODE_TYPES.FunctionDeclaration && node.id) {
     return node.id.name;
   }
-  if (node.type === import_utils55.AST_NODE_TYPES.FunctionExpression && node.id) {
+  if (node.type === import_utils56.AST_NODE_TYPES.FunctionExpression && node.id) {
     return node.id.name;
   }
-  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) {
+  if ((node.type === import_utils56.AST_NODE_TYPES.ArrowFunctionExpression || node.type === import_utils56.AST_NODE_TYPES.FunctionExpression) && node.parent?.type === import_utils56.AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === import_utils56.AST_NODE_TYPES.Identifier) {
     return node.parent.id.name;
   }
   return null;
@@ -4166,8 +4171,8 @@ var requireExplicitReturnType = createRule53({
 var require_explicit_return_type_default = requireExplicitReturnType;
 
 // src/rules/sort-exports.ts
-var import_utils56 = require("@typescript-eslint/utils");
-var createRule54 = import_utils56.ESLintUtils.RuleCreator(
+var import_utils57 = require("@typescript-eslint/utils");
+var createRule54 = import_utils57.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"];
@@ -4221,7 +4226,7 @@ var sortExports = createRule54({
       Program(node) {
         const exportGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils56.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
+          if (statement.type !== import_utils57.AST_NODE_TYPES.ExportNamedDeclaration || statement.declaration !== null) {
             if (exportGroups.length > 0) {
               checkOrder(exportGroups);
               exportGroups.length = 0;
@@ -4240,8 +4245,8 @@ var sortExports = createRule54({
 var sort_exports_default = sortExports;
 
 // src/rules/sort-imports.ts
-var import_utils57 = require("@typescript-eslint/utils");
-var createRule55 = import_utils57.ESLintUtils.RuleCreator(
+var import_utils58 = require("@typescript-eslint/utils");
+var createRule55 = import_utils58.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([
@@ -4352,7 +4357,7 @@ var sortImports = createRule55({
       Program(node) {
         const importGroups = [];
         node.body.forEach((statement) => {
-          if (statement.type !== import_utils57.AST_NODE_TYPES.ImportDeclaration) {
+          if (statement.type !== import_utils58.AST_NODE_TYPES.ImportDeclaration) {
             if (importGroups.length > 0) {
               checkOrder(importGroups);
               importGroups.length = 0;
@@ -4374,13 +4379,13 @@ var sortImports = createRule55({
 var sort_imports_default = sortImports;
 
 // src/rules/sort-type-alphabetically.ts
-var import_utils58 = require("@typescript-eslint/utils");
-var createRule56 = import_utils58.ESLintUtils.RuleCreator(
+var import_utils59 = require("@typescript-eslint/utils");
+var createRule56 = import_utils59.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_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;
@@ -4409,7 +4414,7 @@ var sortTypeAlphabetically = 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);
@@ -4446,7 +4451,7 @@ var sortTypeAlphabetically = 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;
@@ -4466,13 +4471,13 @@ var sortTypeAlphabetically = createRule56({
 var sort_type_alphabetically_default = sortTypeAlphabetically;
 
 // src/rules/sort-type-required-first.ts
-var import_utils59 = require("@typescript-eslint/utils");
-var createRule57 = import_utils59.ESLintUtils.RuleCreator(
+var import_utils60 = require("@typescript-eslint/utils");
+var createRule57 = import_utils60.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_utils59.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils59.AST_NODE_TYPES.Identifier
+    (member) => member.type === import_utils60.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils60.AST_NODE_TYPES.Identifier
   );
   if (properties.length < 2) {
     return true;
@@ -4501,7 +4506,7 @@ var sortTypeRequiredFirst = createRule57({
     function fixMembers(fixer, members) {
       const { sourceCode } = context;
       const properties = members.filter(
-        (member) => member.type === import_utils59.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils59.AST_NODE_TYPES.Identifier
+        (member) => member.type === import_utils60.AST_NODE_TYPES.TSPropertySignature && member.key.type === import_utils60.AST_NODE_TYPES.Identifier
       );
       const required = properties.filter((prop) => !prop.optional);
       const optional = properties.filter((prop) => prop.optional);
@@ -4522,7 +4527,7 @@ var sortTypeRequiredFirst = createRule57({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils59.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeAnnotation.type !== import_utils60.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const { members } = node.typeAnnotation;
@@ -4741,6 +4746,19 @@ var createConfig = (configRules) => ({
   },
   rules: configRules
 });
+var NEXTJS_ROUTING_GLOBS = [
+  "app/**/*.{jsx,tsx}",
+  "src/app/**/*.{jsx,tsx}",
+  "pages/**/*.{jsx,tsx}",
+  "src/pages/**/*.{jsx,tsx}"
+];
+var nextjsRoutingOverride = {
+  files: NEXTJS_ROUTING_GLOBS,
+  rules: {
+    "nextfriday/jsx-pascal-case": "off"
+  }
+};
+var createNextjsConfig = (configRules) => [createConfig(configRules), nextjsRoutingOverride];
 var configs = {
   base: createConfig(baseRules),
   "base/recommended": createConfig(baseRecommendedRules),
@@ -4752,55 +4770,16 @@ var configs = {
     ...baseRecommendedRules,
     ...jsxRecommendedRules
   }),
-  nextjs: createConfig({
+  nextjs: createNextjsConfig({
     ...baseRules,
     ...jsxRules,
     ...nextjsOnlyRules
   }),
-  "nextjs/recommended": createConfig({
+  "nextjs/recommended": createNextjsConfig({
     ...baseRecommendedRules,
     ...jsxRecommendedRules,
     ...nextjsOnlyRecommendedRules
-  }),
-  get sonarjs() {
-    const pluginSonarjs = import_eslint_plugin_sonarjs.default.default ?? import_eslint_plugin_sonarjs.default;
-    const sonarjsRules = pluginSonarjs.configs.recommended.rules;
-    return [
-      {
-        name: "sonarjs/config",
-        plugins: {
-          sonarjs: pluginSonarjs
-        },
-        rules: {
-          ...sonarjsRules
-        }
-      }
-    ];
-  },
-  get unicorn() {
-    const pluginUnicorn = import_eslint_plugin_unicorn.default.default ?? import_eslint_plugin_unicorn.default;
-    const unicornRules = pluginUnicorn.configs.recommended.rules;
-    return [
-      {
-        name: "unicorn/config",
-        plugins: {
-          unicorn: pluginUnicorn
-        },
-        rules: {
-          ...unicornRules,
-          "unicorn/filename-case": "off",
-          "unicorn/prevent-abbreviations": "off"
-        }
-      },
-      {
-        name: "unicorn/jsx-tsx-exceptions",
-        files: ["**/*.jsx", "**/*.tsx"],
-        rules: {
-          "unicorn/no-null": "off"
-        }
-      }
-    ];
-  }
+  })
 };
 var nextfridayPlugin = {
   meta,