eslint-plugin-absolute 0.2.0 → 0.2.2

package/dist/index.js

@@ -2,24 +2,9 @@
 // src/rules/no-nested-jsx-return.ts
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 var noNestedJSXReturn = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow nested functions that return non-component, non-singular JSX to enforce one component per file"
-    },
-    schema: [],
-    messages: {
-      nestedFunctionJSX: "Nested function returning non-component, non-singular JSX detected. Extract it into its own component.",
-      nestedArrowJSX: "Nested arrow function returning non-component, non-singular JSX detected. Extract it into its own component.",
-      nestedArrowFragment: "Nested arrow function returning a non-singular JSX fragment detected. Extract it into its own component."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function isJSX(node) {
-      return !!node && (node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment);
-    }
-    function getLeftmostJSXIdentifier(name) {
+    const isJSX = (node) => node !== null && node !== undefined && (node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment);
+    const getLeftmostJSXIdentifier = (name) => {
       let current = name;
       while (current.type === AST_NODE_TYPES.JSXMemberExpression) {
         current = current.object;
@@ -28,8 +13,8 @@ var noNestedJSXReturn = {
         return current;
       }
       return null;
-    }
-    function isJSXComponentElement(node) {
+    };
+    const isJSXComponentElement = (node) => {
       if (!node || node.type !== AST_NODE_TYPES.JSXElement) {
         return false;
       }
@@ -43,286 +28,334 @@ var noNestedJSXReturn = {
         return false;
       }
       return /^[A-Z]/.test(leftmost.name);
-    }
-    function isSingularJSXReturn(node) {
-      if (!isJSX(node))
-        return false;
-      const children = node.children.filter((child) => {
+    };
+    const hasNoMeaningfulChildren = (children) => {
+      const filtered = children.filter((child) => {
         if (child.type === AST_NODE_TYPES.JSXText) {
           return child.value.trim() !== "";
         }
         return true;
       });
+      return filtered.length === 0;
+    };
+    const isSingularJSXReturn = (node) => {
+      if (!isJSX(node))
+        return false;
+      const children = node.children.filter((child2) => {
+        if (child2.type === AST_NODE_TYPES.JSXText) {
+          return child2.value.trim() !== "";
+        }
+        return true;
+      });
       if (children.length === 0) {
         return true;
       }
-      if (children.length === 1) {
-        const child = children[0];
-        if (!child) {
-          return false;
-        }
-        if (child.type === AST_NODE_TYPES.JSXElement || child.type === AST_NODE_TYPES.JSXFragment) {
-          const innerChildren = child.children.filter((innerChild) => {
-            if (innerChild.type === AST_NODE_TYPES.JSXText) {
-              return innerChild.value.trim() !== "";
-            }
-            return true;
-          });
-          return innerChildren.length === 0;
-        }
-        return true;
+      if (children.length !== 1) {
+        return false;
       }
-      return false;
-    }
+      const [child] = children;
+      if (!child) {
+        return false;
+      }
+      if (child.type === AST_NODE_TYPES.JSXElement || child.type === AST_NODE_TYPES.JSXFragment) {
+        return hasNoMeaningfulChildren(child.children);
+      }
+      return true;
+    };
     const functionStack = [];
-    function pushFunction(node) {
+    const pushFunction = (node) => {
       functionStack.push(node);
-    }
-    function popFunction() {
+    };
+    const popFunction = () => {
       functionStack.pop();
-    }
+    };
     return {
-      "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
-        pushFunction(node);
-      },
-      "FunctionDeclaration:exit"(_node) {
-        popFunction();
-      },
-      "FunctionExpression:exit"(_node) {
-        popFunction();
-      },
-      "ArrowFunctionExpression:exit"(_node) {
-        popFunction();
-      },
-      ReturnStatement(node) {
+      "ArrowFunctionExpression > JSXElement"(node) {
         if (functionStack.length <= 1) {
           return;
         }
-        const argument = node.argument;
-        if (!isJSX(argument)) {
-          return;
-        }
-        if (!isJSXComponentElement(argument) && !isSingularJSXReturn(argument)) {
+        if (!isJSXComponentElement(node) && !isSingularJSXReturn(node)) {
           context.report({
-            node,
-            messageId: "nestedFunctionJSX"
+            messageId: "nestedArrowJSX",
+            node
           });
         }
       },
-      "ArrowFunctionExpression > JSXElement"(node) {
+      "ArrowFunctionExpression > JSXFragment"(node) {
         if (functionStack.length <= 1) {
           return;
         }
-        if (!isJSXComponentElement(node) && !isSingularJSXReturn(node)) {
+        if (!isSingularJSXReturn(node)) {
           context.report({
-            node,
-            messageId: "nestedArrowJSX"
+            messageId: "nestedArrowFragment",
+            node
           });
         }
       },
-      "ArrowFunctionExpression > JSXFragment"(node) {
+      "ArrowFunctionExpression:exit"() {
+        popFunction();
+      },
+      "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
+        pushFunction(node);
+      },
+      "FunctionDeclaration:exit"() {
+        popFunction();
+      },
+      "FunctionExpression:exit"() {
+        popFunction();
+      },
+      ReturnStatement(node) {
         if (functionStack.length <= 1) {
           return;
         }
-        if (!isSingularJSXReturn(node)) {
+        const { argument } = node;
+        if (!isJSX(argument)) {
+          return;
+        }
+        if (!isJSXComponentElement(argument) && !isSingularJSXReturn(argument)) {
           context.report({
-            node,
-            messageId: "nestedArrowFragment"
+            messageId: "nestedFunctionJSX",
+            node
           });
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow nested functions that return non-component, non-singular JSX to enforce one component per file"
+    },
+    messages: {
+      nestedArrowFragment: "Nested arrow function returning a non-singular JSX fragment detected. Extract it into its own component.",
+      nestedArrowJSX: "Nested arrow function returning non-component, non-singular JSX detected. Extract it into its own component.",
+      nestedFunctionJSX: "Nested function returning non-component, non-singular JSX detected. Extract it into its own component."
+    },
+    schema: [],
+    type: "problem"
   }
 };
 
 // src/rules/explicit-object-types.ts
 var explicitObjectTypes = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Require explicit type annotations for object literals and arrays of object literals"
-    },
-    schema: [],
-    messages: {
-      objectLiteralNeedsType: "Object literal must have an explicit type annotation.",
-      arrayOfObjectLiteralsNeedsType: "Array of object literals must have an explicit type annotation."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function isObjectLiteral(node) {
-      return !!node && node.type === "ObjectExpression";
-    }
+    const isObjectLiteral = (node) => node !== null && node !== undefined && node.type === "ObjectExpression";
     return {
       VariableDeclarator(node) {
         if (!node.init)
           return;
         if (node.id.type === "Identifier" && node.id.typeAnnotation)
           return;
-        if (isObjectLiteral(node.init)) {
-          if (node.id.type === "Identifier") {
-            context.report({
-              node: node.id,
-              messageId: "objectLiteralNeedsType"
-            });
-          }
+        if (isObjectLiteral(node.init) && node.id.type === "Identifier") {
+          context.report({
+            messageId: "objectLiteralNeedsType",
+            node: node.id
+          });
+          return;
+        }
+        if (node.init.type !== "ArrayExpression") {
           return;
         }
-        if (node.init.type === "ArrayExpression") {
-          const hasObjectLiteral = node.init.elements.some((element) => {
-            if (!element || element.type === "SpreadElement")
-              return false;
-            return isObjectLiteral(element);
+        const hasObjectLiteral = node.init.elements.some((element) => {
+          if (!element || element.type === "SpreadElement")
+            return false;
+          return isObjectLiteral(element);
+        });
+        if (hasObjectLiteral && node.id.type === "Identifier") {
+          context.report({
+            messageId: "arrayOfObjectLiteralsNeedsType",
+            node: node.id
           });
-          if (hasObjectLiteral && node.id.type === "Identifier") {
-            context.report({
-              node: node.id,
-              messageId: "arrayOfObjectLiteralsNeedsType"
-            });
-          }
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Require explicit type annotations for object literals and arrays of object literals"
+    },
+    messages: {
+      arrayOfObjectLiteralsNeedsType: "Array of object literals must have an explicit type annotation.",
+      objectLiteralNeedsType: "Object literal must have an explicit type annotation."
+    },
+    schema: [],
+    type: "problem"
   }
 };
 
 // src/rules/sort-keys-fixable.ts
+var SORT_BEFORE = -1;
+var hasDuplicateNames = (names) => {
+  const seen = new Set;
+  const nonNullNames = names.flatMap((name) => name === null ? [] : [name]);
+  for (const name of nonNullNames) {
+    if (seen.has(name)) {
+      return true;
+    }
+    seen.add(name);
+  }
+  return false;
+};
+var isSafeStaticTemplate = (node) => node.expressions.length === 0;
+var isSafeArrayElement = (node) => {
+  if (!node || node.type === "SpreadElement") {
+    return false;
+  }
+  return isSafeToReorderExpression(node);
+};
+var isSafeObjectProperty = (property) => {
+  if (property.type !== "Property" || property.computed || property.kind !== "init") {
+    return false;
+  }
+  if (property.key.type !== "Identifier" && property.key.type !== "Literal") {
+    return false;
+  }
+  if (property.method) {
+    return true;
+  }
+  return isSafeToReorderExpression(property.value);
+};
+var isSafeToReorderExpression = (node) => {
+  if (!node || node.type === "PrivateIdentifier") {
+    return false;
+  }
+  switch (node.type) {
+    case "Identifier":
+    case "Literal":
+    case "ThisExpression":
+    case "FunctionExpression":
+    case "ArrowFunctionExpression":
+    case "ClassExpression":
+      return true;
+    case "TemplateLiteral":
+      return isSafeStaticTemplate(node);
+    case "UnaryExpression":
+      return isSafeToReorderExpression(node.argument);
+    case "ArrayExpression":
+      return node.elements.every(isSafeArrayElement);
+    case "ObjectExpression":
+      return node.properties.every(isSafeObjectProperty);
+    default:
+      return false;
+  }
+};
+var isSafeJSXAttributeValue = (value) => {
+  if (value === null) {
+    return true;
+  }
+  if (value.type === "Literal") {
+    return true;
+  }
+  if (value.type !== "JSXExpressionContainer") {
+    return false;
+  }
+  if (value.expression.type === "JSXEmptyExpression") {
+    return false;
+  }
+  return isSafeToReorderExpression(value.expression);
+};
 var sortKeysFixable = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "enforce sorted keys in object literals with auto-fix (limited to simple cases, preserving comments)"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          order: {
-            type: "string",
-            enum: ["asc", "desc"]
-          },
-          caseSensitive: {
-            type: "boolean"
-          },
-          natural: {
-            type: "boolean"
-          },
-          minKeys: {
-            type: "integer",
-            minimum: 2
-          },
-          variablesBeforeFunctions: {
-            type: "boolean"
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      unsorted: "Object keys are not sorted."
-    }
-  },
-  defaultOptions: [{}],
   create(context) {
-    const sourceCode = context.sourceCode;
-    const option = context.options[0];
+    const { sourceCode } = context;
+    const [option] = context.options;
     const order = option && option.order ? option.order : "asc";
     const caseSensitive = option && typeof option.caseSensitive === "boolean" ? option.caseSensitive : false;
     const natural = option && typeof option.natural === "boolean" ? option.natural : false;
     const minKeys = option && typeof option.minKeys === "number" ? option.minKeys : 2;
     const variablesBeforeFunctions = option && typeof option.variablesBeforeFunctions === "boolean" ? option.variablesBeforeFunctions : false;
-    function compareKeys(a, b) {
-      let keyA = a;
-      let keyB = b;
+    const compareKeys = (keyLeft, keyRight) => {
+      let left = keyLeft;
+      let right = keyRight;
       if (!caseSensitive) {
-        keyA = keyA.toLowerCase();
-        keyB = keyB.toLowerCase();
+        left = left.toLowerCase();
+        right = right.toLowerCase();
       }
       if (natural) {
-        return keyA.localeCompare(keyB, undefined, {
+        return left.localeCompare(right, undefined, {
           numeric: true
         });
       }
-      return keyA.localeCompare(keyB);
-    }
-    function isFunctionProperty(prop) {
-      const value = prop.value;
-      return !!value && (value.type === "FunctionExpression" || value.type === "ArrowFunctionExpression" || prop.method === true);
-    }
-    function getPropertyKeyName(prop) {
-      const key = prop.key;
+      return left.localeCompare(right);
+    };
+    const isFunctionProperty = (prop) => {
+      const { value } = prop;
+      return Boolean(value) && (value.type === "FunctionExpression" || value.type === "ArrowFunctionExpression" || prop.method === true);
+    };
+    const getPropertyKeyName = (prop) => {
+      const { key } = prop;
       if (key.type === "Identifier") {
         return key.name;
       }
       if (key.type === "Literal") {
-        const value = key.value;
+        const { value } = key;
         if (typeof value === "string") {
           return value;
         }
         return String(value);
       }
       return "";
-    }
-    function getLeadingComments(prop, prevProp) {
+    };
+    const getLeadingComments = (prop, prevProp) => {
       const comments = sourceCode.getCommentsBefore(prop);
       if (!prevProp || comments.length === 0) {
         return comments;
       }
-      return comments.filter((c) => c.loc.start.line !== prevProp.loc.end.line);
-    }
-    function getTrailingComments(prop, nextProp) {
-      const after = sourceCode.getCommentsAfter(prop).filter((c) => c.loc.start.line === prop.loc.end.line);
-      if (nextProp) {
-        const beforeNext = sourceCode.getCommentsBefore(nextProp);
-        const trailingOfPrev = beforeNext.filter((c) => c.loc.start.line === prop.loc.end.line);
-        for (const c of trailingOfPrev) {
-          if (!after.some((a) => a.range[0] === c.range[0])) {
-            after.push(c);
-          }
-        }
-      }
+      return comments.filter((comment) => comment.loc.start.line !== prevProp.loc.end.line);
+    };
+    const getTrailingComments = (prop, nextProp) => {
+      const after = sourceCode.getCommentsAfter(prop).filter((comment) => comment.loc.start.line === prop.loc.end.line);
+      if (!nextProp) {
+        return after;
+      }
+      const beforeNext = sourceCode.getCommentsBefore(nextProp);
+      const trailingOfPrev = beforeNext.filter((comment) => comment.loc.start.line === prop.loc.end.line);
+      const newComments = trailingOfPrev.filter((comment) => !after.some((existing) => existing.range[0] === comment.range[0]));
+      after.push(...newComments);
       return after;
-    }
-    function buildSortedText(fixableProps, rangeStart) {
+    };
+    const getChunkStart = (idx, fixableProps, rangeStart, fullStart) => {
+      if (idx === 0) {
+        return rangeStart;
+      }
+      const prevProp = fixableProps[idx - 1];
+      const currentProp = fixableProps[idx];
+      const prevTrailing = getTrailingComments(prevProp, currentProp);
+      const prevEnd = prevTrailing.length > 0 ? prevTrailing[prevTrailing.length - 1].range[1] : prevProp.range[1];
+      const allTokens = sourceCode.getTokensBetween(prevProp, currentProp, {
+        includeComments: false
+      });
+      const tokenAfterPrev = allTokens.find((tok) => tok.range[0] >= prevEnd) ?? null;
+      if (tokenAfterPrev && tokenAfterPrev.value === "," && tokenAfterPrev.range[1] <= fullStart) {
+        return tokenAfterPrev.range[1];
+      }
+      return prevEnd;
+    };
+    const buildSortedText = (fixableProps, rangeStart) => {
       const chunks = [];
-      for (let i = 0;i < fixableProps.length; i++) {
-        const prop = fixableProps[i];
-        const prevProp = i > 0 ? fixableProps[i - 1] : null;
-        const nextProp = i < fixableProps.length - 1 ? fixableProps[i + 1] : null;
+      for (let idx = 0;idx < fixableProps.length; idx++) {
+        const prop = fixableProps[idx];
+        const prevProp = idx > 0 ? fixableProps[idx - 1] : null;
+        const nextProp = idx < fixableProps.length - 1 ? fixableProps[idx + 1] : null;
         const leading = getLeadingComments(prop, prevProp);
         const trailing = getTrailingComments(prop, nextProp);
         const fullStart = leading.length > 0 ? leading[0].range[0] : prop.range[0];
         const fullEnd = trailing.length > 0 ? trailing[trailing.length - 1].range[1] : prop.range[1];
-        let chunkStart;
-        if (i === 0) {
-          chunkStart = rangeStart;
-        } else {
-          const prevTrailing = getTrailingComments(prevProp, prop);
-          const prevEnd = prevTrailing.length > 0 ? prevTrailing[prevTrailing.length - 1].range[1] : prevProp.range[1];
-          const tokenAfterPrev = sourceCode.getTokenAfter({
-            range: [prevEnd, prevEnd]
-          }, { includeComments: false });
-          if (tokenAfterPrev && tokenAfterPrev.value === "," && tokenAfterPrev.range[1] <= fullStart) {
-            chunkStart = tokenAfterPrev.range[1];
-          } else {
-            chunkStart = prevEnd;
-          }
-        }
+        const chunkStart = getChunkStart(idx, fixableProps, rangeStart, fullStart);
         const text = sourceCode.text.slice(chunkStart, fullEnd);
         chunks.push({ prop, text });
       }
-      const sorted = chunks.slice().sort((a, b) => {
+      const sorted = chunks.slice().sort((left, right) => {
         if (variablesBeforeFunctions) {
-          const aIsFunc = isFunctionProperty(a.prop);
-          const bIsFunc = isFunctionProperty(b.prop);
-          if (aIsFunc !== bIsFunc) {
-            return aIsFunc ? 1 : -1;
+          const leftIsFunc = isFunctionProperty(left.prop);
+          const rightIsFunc = isFunctionProperty(right.prop);
+          if (leftIsFunc !== rightIsFunc) {
+            return leftIsFunc ? 1 : SORT_BEFORE;
           }
         }
-        const aKey = getPropertyKeyName(a.prop);
-        const bKey = getPropertyKeyName(b.prop);
-        let res = compareKeys(aKey, bKey);
+        const leftKey = getPropertyKeyName(left.prop);
+        const rightKey = getPropertyKeyName(right.prop);
+        let res = compareKeys(leftKey, rightKey);
         if (order === "desc") {
           res = -res;
         }
@@ -336,12 +369,12 @@ var sortKeysFixable = {
         const col = fixableProps[0].loc.start.column;
         const indent = sourceCode.text.slice(fixableProps[0].range[0] - col, fixableProps[0].range[0]);
         separator = `,
-` + indent;
+${indent}`;
       } else {
         separator = ", ";
       }
-      return sorted.map((chunk, i) => {
-        if (i === 0) {
+      return sorted.map((chunk, idx) => {
+        if (idx === 0) {
           const originalFirstChunk = chunks[0];
           const originalLeadingWs = originalFirstChunk.text.match(/^(\s*)/)?.[1] ?? "";
           const stripped2 = chunk.text.replace(/^\s*/, "");
@@ -350,8 +383,9 @@ var sortKeysFixable = {
         const stripped = chunk.text.replace(/^\s*/, "");
         return separator + stripped;
       }).join("");
-    }
-    function checkObjectExpression(node) {
+    };
+    const getFixableProps = (node) => node.properties.filter((prop) => prop.type === "Property" && !prop.computed && (prop.key.type === "Identifier" || prop.key.type === "Literal"));
+    const checkObjectExpression = (node) => {
       if (node.properties.length < minKeys) {
         return;
       }
@@ -359,380 +393,392 @@ var sortKeysFixable = {
       const keys = node.properties.map((prop) => {
         let keyName = null;
         let isFunc = false;
-        if (prop.type === "Property") {
-          if (prop.computed) {
-            autoFixable = false;
-          }
-          if (prop.key.type === "Identifier") {
-            keyName = prop.key.name;
-          } else if (prop.key.type === "Literal") {
-            const value = prop.key.value;
-            keyName = typeof value === "string" ? value : String(value);
-          } else {
-            autoFixable = false;
-          }
-          if (isFunctionProperty(prop)) {
-            isFunc = true;
-          }
+        if (prop.type !== "Property") {
+          autoFixable = false;
+          return {
+            isFunction: isFunc,
+            keyName,
+            node: prop
+          };
+        }
+        if (prop.computed) {
+          autoFixable = false;
+        }
+        if (prop.key.type === "Identifier") {
+          keyName = prop.key.name;
+        } else if (prop.key.type === "Literal") {
+          const { value } = prop.key;
+          keyName = typeof value === "string" ? value : String(value);
         } else {
           autoFixable = false;
         }
+        if (isFunctionProperty(prop)) {
+          isFunc = true;
+        }
         return {
+          isFunction: isFunc,
           keyName,
-          node: prop,
-          isFunction: isFunc
+          node: prop
         };
       });
-      const getFixableProps = () => {
-        const props = [];
-        for (const prop of node.properties) {
-          if (prop.type !== "Property") {
-            continue;
-          }
-          if (prop.computed) {
-            continue;
-          }
-          if (prop.key.type !== "Identifier" && prop.key.type !== "Literal") {
-            continue;
-          }
-          props.push(prop);
-        }
-        return props;
-      };
+      if (hasDuplicateNames(keys.map((key) => key.keyName))) {
+        autoFixable = false;
+      }
+      if (autoFixable && keys.some((key) => key.node.type === "Property" && !isSafeToReorderExpression(key.node.value))) {
+        autoFixable = false;
+      }
       let fixProvided = false;
-      for (let i = 1;i < keys.length; i++) {
-        const prev = keys[i - 1];
-        const curr = keys[i];
-        if (!prev || !curr) {
-          continue;
+      const createReportWithFix = (curr, shouldFix) => {
+        context.report({
+          fix: shouldFix ? (fixer) => {
+            const fixableProps = getFixableProps(node);
+            if (fixableProps.length < minKeys) {
+              return null;
+            }
+            const [firstProp] = fixableProps;
+            const lastProp = fixableProps[fixableProps.length - 1];
+            if (!firstProp || !lastProp) {
+              return null;
+            }
+            const firstLeading = getLeadingComments(firstProp, null);
+            const [firstLeadingComment] = firstLeading;
+            const rangeStart = firstLeadingComment ? firstLeadingComment.range[0] : firstProp.range[0];
+            const lastTrailing = getTrailingComments(lastProp, null);
+            const rangeEnd = lastTrailing.length > 0 ? lastTrailing[lastTrailing.length - 1].range[1] : lastProp.range[1];
+            const sortedText = buildSortedText(fixableProps, rangeStart);
+            return fixer.replaceTextRange([rangeStart, rangeEnd], sortedText);
+          } : null,
+          messageId: "unsorted",
+          node: curr.node.type === "Property" ? curr.node.key : curr.node
+        });
+        fixProvided = true;
+      };
+      keys.forEach((curr, idx) => {
+        if (idx === 0) {
+          return;
         }
-        if (prev.keyName === null || curr.keyName === null) {
-          continue;
+        const prev = keys[idx - 1];
+        if (!prev || !curr || prev.keyName === null || curr.keyName === null) {
+          return;
         }
         const shouldFix = !fixProvided && autoFixable;
-        const reportWithFix = () => {
-          context.report({
-            node: curr.node.type === "Property" ? curr.node.key : curr.node,
-            messageId: "unsorted",
-            fix: shouldFix ? (fixer) => {
-              const fixableProps = getFixableProps();
-              if (fixableProps.length < minKeys) {
-                return null;
-              }
-              const firstProp = fixableProps[0];
-              const lastProp = fixableProps[fixableProps.length - 1];
-              if (!firstProp || !lastProp) {
-                return null;
-              }
-              const firstLeading = getLeadingComments(firstProp, null);
-              const rangeStart = firstLeading.length > 0 ? firstLeading[0].range[0] : firstProp.range[0];
-              const lastTrailing = getTrailingComments(lastProp, null);
-              const rangeEnd = lastTrailing.length > 0 ? lastTrailing[lastTrailing.length - 1].range[1] : lastProp.range[1];
-              const sortedText = buildSortedText(fixableProps, rangeStart);
-              return fixer.replaceTextRange([rangeStart, rangeEnd], sortedText);
-            } : null
-          });
-          fixProvided = true;
-        };
-        if (variablesBeforeFunctions) {
-          if (prev.isFunction && !curr.isFunction) {
-            reportWithFix();
-            continue;
-          }
-          if (prev.isFunction === curr.isFunction && compareKeys(prev.keyName, curr.keyName) > 0) {
-            reportWithFix();
-          }
-        } else {
-          if (compareKeys(prev.keyName, curr.keyName) > 0) {
-            reportWithFix();
-          }
+        if (variablesBeforeFunctions && prev.isFunction && !curr.isFunction) {
+          createReportWithFix(curr, shouldFix);
+          return;
         }
-      }
-    }
-    function checkJSXAttributeObject(attr) {
-      const value = attr.value;
-      if (value && value.type === "JSXExpressionContainer") {
-        const expr = value.expression;
-        if (expr && expr.type === "ObjectExpression") {
-          checkObjectExpression(expr);
+        if (variablesBeforeFunctions && prev.isFunction === curr.isFunction && compareKeys(prev.keyName, curr.keyName) > 0) {
+          createReportWithFix(curr, shouldFix);
+          return;
+        }
+        if (!variablesBeforeFunctions && compareKeys(prev.keyName, curr.keyName) > 0) {
+          createReportWithFix(curr, shouldFix);
         }
+      });
+    };
+    const checkJSXAttributeObject = (attr) => {
+      const { value } = attr;
+      if (value && value.type === "JSXExpressionContainer" && value.expression && value.expression.type === "ObjectExpression") {
+        checkObjectExpression(value.expression);
       }
-    }
-    function checkJSXOpeningElement(node) {
+    };
+    const getAttrName = (attr) => {
+      if (attr.type !== "JSXAttribute" || attr.name.type !== "JSXIdentifier") {
+        return "";
+      }
+      return attr.name.name;
+    };
+    const compareAttrNames = (nameLeft, nameRight) => {
+      let res = compareKeys(nameLeft, nameRight);
+      if (order === "desc") {
+        res = -res;
+      }
+      return res;
+    };
+    const isOutOfOrder = (names) => names.some((currName, idx) => {
+      if (idx === 0 || !currName) {
+        return false;
+      }
+      const prevName = names[idx - 1];
+      return prevName !== undefined && compareAttrNames(prevName, currName) > 0;
+    });
+    const checkJSXOpeningElement = (node) => {
       const attrs = node.attributes;
       if (attrs.length < minKeys) {
         return;
       }
-      if (attrs.some((a) => a.type !== "JSXAttribute")) {
+      if (attrs.some((attr) => attr.type !== "JSXAttribute")) {
         return;
       }
-      if (attrs.some((a) => a.type === "JSXAttribute" && a.name.type !== "JSXIdentifier")) {
+      if (attrs.some((attr) => attr.type === "JSXAttribute" && attr.name.type !== "JSXIdentifier")) {
         return;
       }
-      const names = attrs.map((a) => {
-        if (a.type !== "JSXAttribute") {
-          return "";
-        }
-        if (a.name.type !== "JSXIdentifier") {
-          return "";
-        }
-        return a.name.name;
-      });
-      const cmp = (a, b) => {
-        let res = compareKeys(a, b);
-        if (order === "desc") {
-          res = -res;
-        }
-        return res;
-      };
-      let outOfOrder = false;
-      for (let i = 1;i < names.length; i++) {
-        const prevName = names[i - 1];
-        const currName = names[i];
-        if (!prevName || !currName) {
-          continue;
-        }
-        if (cmp(prevName, currName) > 0) {
-          outOfOrder = true;
-          break;
-        }
+      const names = attrs.map((attr) => getAttrName(attr));
+      if (!isOutOfOrder(names)) {
+        return;
       }
-      if (!outOfOrder) {
+      if (hasDuplicateNames(names)) {
+        context.report({
+          messageId: "unsorted",
+          node: attrs[0].type === "JSXAttribute" ? attrs[0].name : attrs[0]
+        });
+        return;
+      }
+      if (attrs.some((attr) => attr.type === "JSXAttribute" && !isSafeJSXAttributeValue(attr.value))) {
+        context.report({
+          messageId: "unsorted",
+          node: attrs[0].type === "JSXAttribute" ? attrs[0].name : attrs[0]
+        });
         return;
       }
-      for (let i = 1;i < attrs.length; i++) {
-        const prevAttr = attrs[i - 1];
-        const currAttr = attrs[i];
-        if (!prevAttr || !currAttr) {
-          continue;
+      const braceConflict = attrs.find((currAttr, idx) => {
+        if (idx === 0) {
+          return false;
         }
-        const between = sourceCode.text.slice(prevAttr.range[1], currAttr.range[0]);
-        if (between.includes("{")) {
-          context.report({
-            node: currAttr.type === "JSXAttribute" ? currAttr.name : currAttr,
-            messageId: "unsorted"
-          });
-          return;
+        const prevAttr = attrs[idx - 1];
+        if (!prevAttr) {
+          return false;
         }
-      }
-      const sortedAttrs = attrs.slice().sort((a, b) => {
-        const aName = a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" ? a.name.name : "";
-        const bName = b.type === "JSXAttribute" && b.name.type === "JSXIdentifier" ? b.name.name : "";
-        return cmp(aName, bName);
+        const between = sourceCode.text.slice(prevAttr.range[1], currAttr.range[0]);
+        return between.includes("{");
       });
-      const firstAttr = attrs[0];
+      if (braceConflict) {
+        context.report({
+          messageId: "unsorted",
+          node: braceConflict.type === "JSXAttribute" ? braceConflict.name : braceConflict
+        });
+        return;
+      }
+      const sortedAttrs = attrs.slice().sort((left, right) => compareAttrNames(getAttrName(left), getAttrName(right)));
+      const [firstAttr] = attrs;
       const lastAttr = attrs[attrs.length - 1];
       if (!firstAttr || !lastAttr) {
         return;
       }
-      const replacement = sortedAttrs.map((a) => sourceCode.getText(a)).join(" ");
+      const replacement = sortedAttrs.map((attr) => sourceCode.getText(attr)).join(" ");
       context.report({
-        node: firstAttr.type === "JSXAttribute" ? firstAttr.name : firstAttr,
-        messageId: "unsorted",
         fix(fixer) {
           return fixer.replaceTextRange([firstAttr.range[0], lastAttr.range[1]], replacement);
-        }
+        },
+        messageId: "unsorted",
+        node: firstAttr.type === "JSXAttribute" ? firstAttr.name : firstAttr
       });
-    }
+    };
     return {
-      ObjectExpression: checkObjectExpression,
       JSXAttribute(node) {
         checkJSXAttributeObject(node);
       },
-      JSXOpeningElement: checkJSXOpeningElement
+      JSXOpeningElement: checkJSXOpeningElement,
+      ObjectExpression: checkObjectExpression
     };
+  },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description: "enforce sorted keys in object literals with auto-fix (limited to simple cases, preserving comments)"
+    },
+    fixable: "code",
+    messages: {
+      unsorted: "Object keys are not sorted."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          caseSensitive: {
+            type: "boolean"
+          },
+          minKeys: {
+            minimum: 2,
+            type: "integer"
+          },
+          natural: {
+            type: "boolean"
+          },
+          order: {
+            enum: ["asc", "desc"],
+            type: "string"
+          },
+          variablesBeforeFunctions: {
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
   }
 };
 
 // src/rules/no-transition-cssproperties.ts
+var getKeyName = (prop) => {
+  if (prop.key.type === "Identifier") {
+    return prop.key.name;
+  }
+  if (prop.key.type !== "Literal") {
+    return null;
+  }
+  return typeof prop.key.value === "string" ? prop.key.value : String(prop.key.value);
+};
+var checkPropForTransition = (context, prop) => {
+  if (prop.computed) {
+    return;
+  }
+  const keyName = getKeyName(prop);
+  if (keyName === "transition") {
+    context.report({
+      messageId: "forbiddenTransition",
+      node: prop
+    });
+  }
+};
 var noTransitionCSSProperties = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
-    },
-    schema: [],
-    messages: {
-      forbiddenTransition: "Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    const sourceCode = context.sourceCode;
+    const { sourceCode } = context;
+    const isCSSPropertiesType = (typeAnnotation) => {
+      if (typeAnnotation.type !== "TSTypeReference") {
+        return false;
+      }
+      const { typeName } = typeAnnotation;
+      if (typeName.type === "Identifier" && typeName.name === "CSSProperties") {
+        return true;
+      }
+      return typeName.type === "TSQualifiedName" && typeName.right && typeName.right.type === "Identifier" && typeName.right.name === "CSSProperties";
+    };
     return {
       VariableDeclarator(node) {
         if (!node.id || node.id.type !== "Identifier" || !node.id.typeAnnotation) {
           return;
         }
-        let isStyleType = false;
-        const typeAnnotation = node.id.typeAnnotation.typeAnnotation;
-        if (typeAnnotation && typeAnnotation.type === "TSTypeReference") {
-          const typeName = typeAnnotation.typeName;
-          if (typeName.type === "Identifier" && typeName.name === "CSSProperties") {
-            isStyleType = true;
-          } else if (typeName.type === "TSQualifiedName" && typeName.right && typeName.right.type === "Identifier" && typeName.right.name === "CSSProperties") {
-            isStyleType = true;
-          }
-        }
+        const { typeAnnotation } = node.id.typeAnnotation;
+        let isStyleType = isCSSPropertiesType(typeAnnotation);
         if (!isStyleType) {
           const annotationText = sourceCode.getText(node.id.typeAnnotation);
-          if (annotationText.includes("CSSProperties")) {
-            isStyleType = true;
-          }
+          isStyleType = annotationText.includes("CSSProperties");
         }
         if (!isStyleType) {
           return;
         }
-        const init = node.init;
+        const { init } = node;
         if (!init || init.type !== "ObjectExpression") {
           return;
         }
-        for (const prop of init.properties) {
-          if (prop.type !== "Property") {
-            continue;
-          }
-          if (prop.computed) {
-            continue;
-          }
-          let keyName = null;
-          if (prop.key.type === "Identifier") {
-            keyName = prop.key.name;
-          } else if (prop.key.type === "Literal") {
-            if (typeof prop.key.value === "string") {
-              keyName = prop.key.value;
-            } else {
-              keyName = String(prop.key.value);
-            }
-          }
-          if (keyName === "transition") {
-            context.report({
-              node: prop,
-              messageId: "forbiddenTransition"
-            });
-          }
-        }
+        const properties = init.properties.filter((prop) => prop.type === "Property");
+        properties.forEach((prop) => {
+          checkPropForTransition(context, prop);
+        });
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
+    },
+    messages: {
+      forbiddenTransition: "Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring."
+    },
+    schema: [],
+    type: "problem"
   }
 };
 
 // src/rules/no-explicit-return-types.ts
 var noExplicitReturnTypes = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow explicit return type annotations on functions, except when using type predicates for type guards or inline object literal returns (e.g., style objects)."
-    },
-    schema: [],
-    messages: {
-      noExplicitReturnType: "Explicit return types are disallowed; rely on TypeScript's inference instead."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function hasSingleObjectReturn(body) {
-      let returnCount = 0;
-      let returnedObject = null;
-      for (const stmt of body.body) {
-        if (stmt.type === "ReturnStatement") {
-          returnCount++;
-          const arg = stmt.argument;
-          if (arg && arg.type === "ObjectExpression") {
-            returnedObject = arg;
-          }
-        }
+    const hasSingleObjectReturn = (body) => {
+      const returnStatements = body.body.filter((stmt) => stmt.type === "ReturnStatement");
+      if (returnStatements.length !== 1) {
+        return false;
       }
-      return returnCount === 1 && returnedObject !== null;
-    }
+      const [returnStmt] = returnStatements;
+      return returnStmt?.argument?.type === "ObjectExpression";
+    };
     return {
       "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
-        const returnType = node.returnType;
+        const { returnType } = node;
         if (!returnType) {
           return;
         }
-        const typeAnnotation = returnType.typeAnnotation;
+        const { typeAnnotation } = returnType;
         if (typeAnnotation && typeAnnotation.type === "TSTypePredicate") {
           return;
         }
         if (node.type === "ArrowFunctionExpression" && node.expression === true && node.body.type === "ObjectExpression") {
           return;
         }
-        if (node.body && node.body.type === "BlockStatement") {
-          if (hasSingleObjectReturn(node.body)) {
-            return;
-          }
+        if (node.body && node.body.type === "BlockStatement" && hasSingleObjectReturn(node.body)) {
+          return;
         }
         context.report({
-          node: returnType,
-          messageId: "noExplicitReturnType"
+          messageId: "noExplicitReturnType",
+          node: returnType
         });
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow explicit return type annotations on functions, except when using type predicates for type guards or inline object literal returns (e.g., style objects)."
+    },
+    messages: {
+      noExplicitReturnType: "Explicit return types are disallowed; rely on TypeScript's inference instead."
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/rules/max-jsx-nesting.ts
+var isJSXAncestor = (node) => node.type === "JSXElement" || node.type === "JSXFragment";
 var maxJSXNesting = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Warn when JSX elements are nested too deeply, suggesting refactoring into a separate component."
-    },
-    schema: [
-      {
-        type: "number",
-        minimum: 1
-      }
-    ],
-    messages: {
-      tooDeeplyNested: "JSX element is nested too deeply ({{level}} levels, allowed is {{maxAllowed}} levels). Consider refactoring into a separate component."
-    }
-  },
-  defaultOptions: [1],
   create(context) {
-    const option = context.options[0];
+    const [option] = context.options;
     const maxAllowed = typeof option === "number" ? option : 1;
-    function getJSXNestingLevel(node) {
+    const getJSXNestingLevel = (node) => {
       let level = 1;
       let current = node.parent;
       while (current) {
-        if (current.type === "JSXElement" || current.type === "JSXFragment") {
-          level++;
-        }
+        level += isJSXAncestor(current) ? 1 : 0;
         current = current.parent;
       }
       return level;
-    }
+    };
     return {
       JSXElement(node) {
         const level = getJSXNestingLevel(node);
         if (level > maxAllowed) {
           context.report({
-            node,
+            data: { level, maxAllowed },
             messageId: "tooDeeplyNested",
-            data: { level, maxAllowed }
+            node
           });
         }
       }
     };
+  },
+  defaultOptions: [1],
+  meta: {
+    docs: {
+      description: "Warn when JSX elements are nested too deeply, suggesting refactoring into a separate component."
+    },
+    messages: {
+      tooDeeplyNested: "JSX element is nested too deeply ({{level}} levels, allowed is {{maxAllowed}} levels). Consider refactoring into a separate component."
+    },
+    schema: [
+      {
+        minimum: 1,
+        type: "number"
+      }
+    ],
+    type: "suggestion"
   }
 };
 
 // src/rules/seperate-style-files.ts
 var seperateStyleFiles = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Warn when a component file (.jsx or .tsx) contains a style object typed as CSSProperties. " + "Style objects should be moved to their own file under the style folder."
-    },
-    schema: [],
-    messages: {
-      moveToFile: 'Style object "{{name}}" is typed as {{typeName}}. Move it to its own file under the style folder.'
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    const filename = context.filename;
+    const { filename } = context;
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) {
       return {};
     }
@@ -755,39 +801,46 @@ var seperateStyleFiles = {
         if (typeNameNode.type === "Identifier") {
           typeName = typeNameNode.name;
         } else if (typeNameNode.type === "TSQualifiedName") {
-          const right = typeNameNode.right;
+          const { right } = typeNameNode;
           typeName = right.name;
         }
         if (typeName === "CSSProperties") {
           context.report({
-            node,
-            messageId: "moveToFile",
             data: {
               name: identifier.name,
               typeName
-            }
+            },
+            messageId: "moveToFile",
+            node
           });
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Warn when a component file (.jsx or .tsx) contains a style object typed as CSSProperties. " + "Style objects should be moved to their own file under the style folder."
+    },
+    messages: {
+      moveToFile: 'Style object "{{name}}" is typed as {{typeName}}. Move it to its own file under the style folder.'
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/rules/no-unnecessary-key.ts
+var isMapCallExpression = (node) => {
+  if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") {
+    return false;
+  }
+  const { property } = node.callee;
+  return property.type === "Identifier" && property.name === "map" || property.type === "Literal" && property.value === "map";
+};
 var noUnnecessaryKey = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "enforce that the key prop is only used on components rendered as part of a mapping"
-    },
-    schema: [],
-    messages: {
-      unnecessaryKey: "The key prop should only be used on elements that are directly rendered as part of an array mapping."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function getAncestors(node) {
+    const getAncestors = (node) => {
       const ancestors = [];
       let current = node.parent;
       while (current) {
@@ -795,40 +848,15 @@ var noUnnecessaryKey = {
         current = current.parent;
       }
       return ancestors;
-    }
-    function isInsideMapCall(ancestors) {
-      for (const node of ancestors) {
-        if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
-          const property = node.callee.property;
-          if (property.type === "Identifier" && property.name === "map") {
-            return true;
-          }
-          if (property.type === "Literal" && property.value === "map") {
-            return true;
-          }
-        }
-      }
-      return false;
-    }
-    function isReturnedFromFunction(ancestors) {
-      for (const node of ancestors) {
-        if (node.type === "ReturnStatement") {
-          return true;
-        }
-      }
-      return false;
-    }
-    function checkJSXOpeningElement(node) {
+    };
+    const isInsideMapCall = (ancestors) => ancestors.some(isMapCallExpression);
+    const isReturnedFromFunction = (ancestors) => ancestors.some((ancestor) => ancestor.type === "ReturnStatement");
+    const checkJSXOpeningElement = (node) => {
       const keyAttribute = node.attributes.find((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "key");
       if (!keyAttribute) {
         return;
       }
-      let ancestors;
-      if (typeof context.getAncestors === "function") {
-        ancestors = context.getAncestors();
-      } else {
-        ancestors = getAncestors(node);
-      }
+      const ancestors = getAncestors(node);
       if (isInsideMapCall(ancestors)) {
         return;
       }
@@ -836,304 +864,389 @@ var noUnnecessaryKey = {
         return;
       }
       context.report({
-        node: keyAttribute,
-        messageId: "unnecessaryKey"
+        messageId: "unnecessaryKey",
+        node: keyAttribute
       });
-    }
+    };
     return {
       JSXOpeningElement: checkJSXOpeningElement
     };
-  }
-};
-
-// src/rules/sort-exports.ts
-var sortExports = {
+  },
+  defaultOptions: [],
   meta: {
-    type: "suggestion",
     docs: {
-      description: "Enforce that top-level export declarations are sorted by exported name and, optionally, that variable exports come before function exports"
+      description: "enforce that the key prop is only used on components rendered as part of a mapping"
     },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          order: {
-            type: "string",
-            enum: ["asc", "desc"]
-          },
-          caseSensitive: {
-            type: "boolean"
-          },
-          natural: {
-            type: "boolean"
-          },
-          minKeys: {
-            type: "integer",
-            minimum: 2
-          },
-          variablesBeforeFunctions: {
-            type: "boolean"
-          }
-        },
-        additionalProperties: false
-      }
-    ],
     messages: {
-      alphabetical: "Export declarations are not sorted alphabetically. Expected order: {{expectedOrder}}.",
-      variablesBeforeFunctions: "Non-function exports should come before function exports."
+      unnecessaryKey: "The key prop should only be used on elements that are directly rendered as part of an array mapping."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+
+// src/rules/sort-exports.ts
+var SORT_BEFORE2 = Number.parseInt("-1", 10);
+var hasStringTypeProperty = (value) => {
+  const maybeType = Reflect.get(value, "type");
+  return typeof maybeType === "string";
+};
+var isNodeLike = (value) => value !== null && value !== undefined && typeof value === "object" && ("type" in value) && hasStringTypeProperty(value);
+var shouldSkipNodeEntry = (key, value) => key === "parent" || value === null || value === undefined;
+var visitNodeArray = (values, visit) => values.filter(isNodeLike).forEach(visit);
+var visitNodeEntryValue = (value, visit) => {
+  if (Array.isArray(value)) {
+    visitNodeArray(value, visit);
+    return;
+  }
+  if (isNodeLike(value)) {
+    visit(value);
+  }
+};
+var visitNodeEntries = (current, visit) => Object.entries(current).filter(([key, value]) => !shouldSkipNodeEntry(key, value)).forEach(([, value]) => {
+  visitNodeEntryValue(value, visit);
+});
+var getVariableDeclaratorName = (declaration) => {
+  if (declaration.declarations.length !== 1) {
+    return null;
+  }
+  const [firstDeclarator] = declaration.declarations;
+  if (firstDeclarator && firstDeclarator.id.type === "Identifier") {
+    return firstDeclarator.id.name;
+  }
+  return null;
+};
+var getDeclarationName = (declaration) => {
+  if (!declaration) {
+    return null;
+  }
+  if (declaration.type === "VariableDeclaration") {
+    return getVariableDeclaratorName(declaration);
+  }
+  if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id && declaration.id.type === "Identifier") {
+    return declaration.id.name;
+  }
+  return null;
+};
+var getSpecifierName = (node) => {
+  if (node.specifiers.length !== 1) {
+    return null;
+  }
+  const [spec] = node.specifiers;
+  if (!spec) {
+    return null;
+  }
+  if (spec.exported.type === "Identifier") {
+    return spec.exported.name;
+  }
+  if (spec.exported.type === "Literal" && typeof spec.exported.value === "string") {
+    return spec.exported.value;
+  }
+  return null;
+};
+var getExportName = (node) => getDeclarationName(node.declaration) ?? getSpecifierName(node);
+var isFixableExport = (exportNode) => {
+  const { declaration } = exportNode;
+  if (!declaration) {
+    return exportNode.specifiers.length === 1;
+  }
+  if (declaration.type === "VariableDeclaration" && declaration.declarations.length === 1) {
+    const [firstDecl] = declaration.declarations;
+    return firstDecl !== undefined && firstDecl.id.type === "Identifier";
+  }
+  return (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id !== null && declaration.id.type === "Identifier";
+};
+var visitImmediateReferences = (node, onReference) => {
+  if (!node) {
+    return;
+  }
+  const visit = (current) => {
+    if (!current) {
+      return;
     }
-  },
-  defaultOptions: [{}],
+    switch (current.type) {
+      case "Identifier":
+        onReference(current.name);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        return;
+      case "MemberExpression":
+        visit(current.object);
+        if (current.computed) {
+          visit(current.property);
+        }
+        return;
+      case "Property":
+        if (current.computed) {
+          visit(current.key);
+        }
+        visit(current.value);
+        return;
+      case "PropertyDefinition":
+        if (current.computed) {
+          visit(current.key);
+        }
+        if (current.static) {
+          visit(current.value);
+        }
+        return;
+      case "MethodDefinition":
+        if (current.computed) {
+          visit(current.key);
+        }
+        return;
+      case "StaticBlock":
+        for (const statement of current.body) {
+          visit(statement);
+        }
+        return;
+    }
+    visitNodeEntries(current, visit);
+  };
+  visit(node);
+};
+var getImmediateDependencyNames = (node) => {
+  const names = new Set;
+  const { declaration } = node;
+  const addName = names.add.bind(names);
+  const addDeclaratorDependencies = (declarator) => visitImmediateReferences(declarator.init, addName);
+  const addClassElementDependencies = (element) => visitImmediateReferences(element, addName);
+  if (!declaration) {
+    return names;
+  }
+  if (declaration.type === "VariableDeclaration") {
+    declaration.declarations.forEach(addDeclaratorDependencies);
+    return names;
+  }
+  if (declaration.type === "ClassDeclaration") {
+    visitImmediateReferences(declaration.superClass, addName);
+    declaration.body.body.forEach(addClassElementDependencies);
+  }
+  return names;
+};
+var sortExports = {
   create(context) {
-    const sourceCode = context.sourceCode;
-    const option = context.options[0];
+    const { sourceCode } = context;
+    const [option] = context.options;
     const order = option && option.order ? option.order : "asc";
     const caseSensitive = option && typeof option.caseSensitive === "boolean" ? option.caseSensitive : false;
     const natural = option && typeof option.natural === "boolean" ? option.natural : false;
     const minKeys = option && typeof option.minKeys === "number" ? option.minKeys : 2;
     const variablesBeforeFunctions = option && typeof option.variablesBeforeFunctions === "boolean" ? option.variablesBeforeFunctions : false;
-    function generateExportText(node) {
-      return sourceCode.getText(node).trim().replace(/\s*;?\s*$/, ";");
-    }
-    function compareStrings(a, b) {
-      let strA = a;
-      let strB = b;
+    const generateExportText = (node) => sourceCode.getText(node).trim().replace(/\s*;?\s*$/, ";");
+    const compareStrings = (strLeft, strRight) => {
+      let left = strLeft;
+      let right = strRight;
       if (!caseSensitive) {
-        strA = strA.toLowerCase();
-        strB = strB.toLowerCase();
+        left = left.toLowerCase();
+        right = right.toLowerCase();
       }
-      const cmp = natural ? strA.localeCompare(strB, undefined, { numeric: true }) : strA.localeCompare(strB);
+      const cmp = natural ? left.localeCompare(right, undefined, { numeric: true }) : left.localeCompare(right);
       return order === "asc" ? cmp : -cmp;
-    }
-    function getExportName(node) {
-      const declaration = node.declaration;
-      if (declaration) {
-        if (declaration.type === "VariableDeclaration") {
-          if (declaration.declarations.length === 1) {
-            const firstDeclarator = declaration.declarations[0];
-            if (firstDeclarator && firstDeclarator.id.type === "Identifier") {
-              return firstDeclarator.id.name;
-            }
-          }
-        } else if (declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") {
-          const id = declaration.id;
-          if (id && id.type === "Identifier") {
-            return id.name;
-          }
-        }
-      } else if (node.specifiers.length === 1) {
-        const spec = node.specifiers[0];
-        if (!spec) {
-          return null;
-        }
-        if (spec.exported.type === "Identifier") {
-          return spec.exported.name;
-        }
-        if (spec.exported.type === "Literal" && typeof spec.exported.value === "string") {
-          return spec.exported.value;
-        }
-      }
-      return null;
-    }
-    function isFunctionExport(node) {
-      const declaration = node.declaration;
+    };
+    const isFunctionExport = (node) => {
+      const { declaration } = node;
       if (!declaration) {
         return false;
       }
-      if (declaration.type === "VariableDeclaration") {
-        if (declaration.declarations.length === 1) {
-          const firstDeclarator = declaration.declarations[0];
-          if (!firstDeclarator) {
-            return false;
-          }
-          const init = firstDeclarator.init;
-          if (!init) {
-            return false;
-          }
-          return init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression";
-        }
-        return false;
-      }
       if (declaration.type === "FunctionDeclaration") {
         return true;
       }
-      return false;
-    }
-    function sortComparator(a, b) {
-      const kindA = a.node.exportKind ?? "value";
-      const kindB = b.node.exportKind ?? "value";
-      if (kindA !== kindB) {
-        return kindA === "type" ? -1 : 1;
+      if (declaration.type !== "VariableDeclaration") {
+        return false;
       }
-      if (variablesBeforeFunctions) {
-        if (a.isFunction !== b.isFunction) {
-          return a.isFunction ? 1 : -1;
-        }
+      if (declaration.declarations.length !== 1) {
+        return false;
       }
-      return compareStrings(a.name, b.name);
-    }
-    function hasForwardDependency(node, laterNames) {
-      const text = sourceCode.getText(node);
-      for (const name of laterNames) {
-        if (text.includes(name)) {
-          return true;
-        }
+      const [firstDeclarator] = declaration.declarations;
+      if (!firstDeclarator) {
+        return false;
       }
-      return false;
-    }
-    function processExportBlock(block) {
-      if (block.length < minKeys) {
-        return;
+      const { init } = firstDeclarator;
+      if (!init) {
+        return false;
       }
-      const items = [];
-      for (const node of block) {
-        const name = getExportName(node);
-        if (!name) {
-          continue;
-        }
-        items.push({
-          name,
-          node,
-          isFunction: isFunctionExport(node),
-          text: sourceCode.getText(node)
-        });
+      return init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression";
+    };
+    const sortComparator = (left, right) => {
+      const kindA = left.node.exportKind ?? "value";
+      const kindB = right.node.exportKind ?? "value";
+      if (kindA !== kindB) {
+        return kindA === "type" ? SORT_BEFORE2 : 1;
       }
-      if (items.length < minKeys) {
-        return;
+      if (variablesBeforeFunctions && left.isFunction !== right.isFunction) {
+        return left.isFunction ? 1 : SORT_BEFORE2;
       }
-      const sortedItems = items.slice().sort(sortComparator);
-      let reportNeeded = false;
+      return compareStrings(left.name, right.name);
+    };
+    const buildItems = (block) => block.map((node) => {
+      const name = getExportName(node);
+      if (!name) {
+        return null;
+      }
+      const item = {
+        isFunction: isFunctionExport(node),
+        name,
+        node,
+        text: sourceCode.getText(node)
+      };
+      return item;
+    }).filter((item) => item !== null);
+    const findFirstUnsorted = (items) => {
       let messageId = "alphabetical";
-      for (let i = 1;i < items.length; i++) {
-        const prev = items[i - 1];
-        const current = items[i];
-        if (!prev || !current) {
-          continue;
-        }
-        if (sortComparator(prev, current) > 0) {
-          reportNeeded = true;
-          if (variablesBeforeFunctions && prev.isFunction && !current.isFunction) {
-            messageId = "variablesBeforeFunctions";
+      const unsorted = items.some((current, idx) => {
+        if (idx === 0) {
+          return false;
+        }
+        const prev = items[idx - 1];
+        if (!prev) {
+          return false;
+        }
+        if (sortComparator(prev, current) <= 0) {
+          return false;
+        }
+        if (variablesBeforeFunctions && prev.isFunction && !current.isFunction) {
+          messageId = "variablesBeforeFunctions";
+        }
+        return true;
+      });
+      return unsorted ? messageId : null;
+    };
+    const checkForwardDependencies = (items) => {
+      const exportNames = items.map((item) => item.name);
+      return items.some((item, idx) => {
+        const laterNames = new Set(exportNames.slice(idx + 1));
+        if (laterNames.size === 0) {
+          return false;
+        }
+        const dependencies = getImmediateDependencyNames(item.node);
+        for (const dependency of dependencies) {
+          if (laterNames.has(dependency)) {
+            return true;
           }
-          break;
         }
+        return false;
+      });
+    };
+    const processExportBlock = (block) => {
+      if (block.length < minKeys) {
+        return;
       }
-      if (!reportNeeded) {
+      const items = buildItems(block);
+      if (items.length < minKeys) {
         return;
       }
-      const exportNames = items.map((item) => item.name);
-      for (let i = 0;i < items.length; i++) {
-        const item = items[i];
-        if (!item) {
-          continue;
-        }
-        const laterNames = new Set(exportNames.slice(i + 1));
-        const nodeToCheck = item.node.declaration ?? item.node;
-        if (hasForwardDependency(nodeToCheck, laterNames)) {
-          return;
-        }
+      const messageId = findFirstUnsorted(items);
+      if (!messageId) {
+        return;
+      }
+      if (checkForwardDependencies(items)) {
+        return;
       }
+      const sortedItems = items.slice().sort(sortComparator);
       const expectedOrder = sortedItems.map((item) => item.name).join(", ");
-      const firstNode = block[0];
+      const [firstNode] = block;
       const lastNode = block[block.length - 1];
       if (!firstNode || !lastNode) {
         return;
       }
       context.report({
-        node: firstNode,
-        messageId,
         data: {
           expectedOrder
         },
         fix(fixer) {
-          const fixableNodes = [];
-          for (const n of block) {
-            const declaration = n.declaration;
-            if (declaration) {
-              if (declaration.type === "VariableDeclaration" && declaration.declarations.length === 1) {
-                const firstDecl = declaration.declarations[0];
-                if (firstDecl && firstDecl.id.type === "Identifier") {
-                  fixableNodes.push(n);
-                  continue;
-                }
-              }
-              if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id && declaration.id.type === "Identifier") {
-                fixableNodes.push(n);
-                continue;
-              }
-              continue;
-            }
-            if (n.specifiers.length === 1) {
-              fixableNodes.push(n);
-            }
-          }
+          const fixableNodes = block.filter(isFixableExport);
           if (fixableNodes.length < minKeys) {
             return null;
           }
           const sortedText = sortedItems.map((item) => generateExportText(item.node)).join(`
 `);
-          const rangeStart = firstNode.range[0];
-          const rangeEnd = lastNode.range[1];
+          const [rangeStart] = firstNode.range;
+          const [, rangeEnd] = lastNode.range;
           const fullText = sourceCode.getText();
           const originalText = fullText.slice(rangeStart, rangeEnd);
           if (originalText === sortedText) {
             return null;
           }
           return fixer.replaceTextRange([rangeStart, rangeEnd], sortedText);
-        }
+        },
+        messageId,
+        node: firstNode
       });
-    }
+    };
     return {
       "Program:exit"(node) {
-        const body = node.body;
+        const { body } = node;
         const block = [];
-        for (let i = 0;i < body.length; i++) {
-          const stmt = body[i];
-          if (!stmt) {
-            continue;
-          }
+        body.forEach((stmt) => {
           if (stmt.type === "ExportNamedDeclaration" && !stmt.source && getExportName(stmt) !== null) {
             block.push(stmt);
-          } else {
-            if (block.length > 0) {
-              processExportBlock(block);
-              block.length = 0;
-            }
+            return;
           }
-        }
+          if (block.length > 0) {
+            processExportBlock(block);
+            block.length = 0;
+          }
+        });
         if (block.length > 0) {
           processExportBlock(block);
         }
       }
     };
+  },
+  defaultOptions: [{}],
+  meta: {
+    docs: {
+      description: "Enforce that top-level export declarations are sorted by exported name and, optionally, that variable exports come before function exports"
+    },
+    fixable: "code",
+    messages: {
+      alphabetical: "Export declarations are not sorted alphabetically. Expected order: {{expectedOrder}}.",
+      variablesBeforeFunctions: "Non-function exports should come before function exports."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          caseSensitive: {
+            type: "boolean"
+          },
+          minKeys: {
+            minimum: 2,
+            type: "integer"
+          },
+          natural: {
+            type: "boolean"
+          },
+          order: {
+            enum: ["asc", "desc"],
+            type: "string"
+          },
+          variablesBeforeFunctions: {
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
   }
 };
 
 // src/rules/localize-react-props.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
 var localizeReactProps = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow variables that are only passed to a single custom child component. For useState, only report if both the state and its setter are exclusively passed to a single custom child. For general variables, only report if a given child receives exactly one such candidate \u2013 if two or more are passed to the same component type, they\u2019re assumed to be settings that belong on the parent."
-    },
-    schema: [],
-    messages: {
-      stateAndSetterToChild: "State variable '{{stateVarName}}' and its setter '{{setterVarName}}' are only passed to a single custom child component. Consider moving the state into that component.",
-      variableToChild: "Variable '{{varName}}' is only passed to a single custom child component. Consider moving it to that component."
-    }
-  },
-  defaultOptions: [],
   create(context) {
     const candidateVariables = [];
-    function getSingleSetElement(set) {
+    const getSingleSetElement = (set) => {
       for (const value of set) {
         return value;
       }
       return null;
-    }
-    function getRightmostJSXIdentifier(name) {
+    };
+    const getRightmostJSXIdentifier = (name) => {
       let current = name;
       while (current.type === AST_NODE_TYPES2.JSXMemberExpression) {
         current = current.property;
@@ -1142,8 +1255,8 @@ var localizeReactProps = {
         return current;
       }
       return null;
-    }
-    function getLeftmostJSXIdentifier(name) {
+    };
+    const getLeftmostJSXIdentifier = (name) => {
       let current = name;
       while (current.type === AST_NODE_TYPES2.JSXMemberExpression) {
         current = current.object;
@@ -1152,8 +1265,8 @@ var localizeReactProps = {
         return current;
       }
       return null;
-    }
-    function getJSXElementName(jsxElement) {
+    };
+    const getJSXElementName = (jsxElement) => {
       if (!jsxElement || !jsxElement.openingElement || !jsxElement.openingElement.name) {
         return "";
       }
@@ -1166,14 +1279,10 @@ var localizeReactProps = {
         return rightmost.name;
       }
       return "";
-    }
-    function isUseStateCall(node) {
-      return node !== null && node.type === AST_NODE_TYPES2.CallExpression && node.callee !== null && (node.callee.type === AST_NODE_TYPES2.Identifier && node.callee.name === "useState" || node.callee.type === AST_NODE_TYPES2.MemberExpression && node.callee.property !== null && node.callee.property.type === AST_NODE_TYPES2.Identifier && node.callee.property.name === "useState");
-    }
-    function isHookCall(node) {
-      return node !== null && node.type === AST_NODE_TYPES2.CallExpression && node.callee !== null && node.callee.type === AST_NODE_TYPES2.Identifier && /^use[A-Z]/.test(node.callee.name) && node.callee.name !== "useState";
-    }
-    function getJSXAncestor(node) {
+    };
+    const isUseStateCall = (node) => node !== null && node.type === AST_NODE_TYPES2.CallExpression && node.callee !== null && (node.callee.type === AST_NODE_TYPES2.Identifier && node.callee.name === "useState" || node.callee.type === AST_NODE_TYPES2.MemberExpression && node.callee.property !== null && node.callee.property.type === AST_NODE_TYPES2.Identifier && node.callee.property.name === "useState");
+    const isHookCall = (node) => node !== null && node.type === AST_NODE_TYPES2.CallExpression && node.callee !== null && node.callee.type === AST_NODE_TYPES2.Identifier && /^use[A-Z]/.test(node.callee.name) && node.callee.name !== "useState";
+    const getJSXAncestor = (node) => {
       let current = node.parent;
       while (current) {
         if (current.type === AST_NODE_TYPES2.JSXElement) {
@@ -1182,33 +1291,31 @@ var localizeReactProps = {
         current = current.parent;
       }
       return null;
-    }
-    function isContextProviderValueProp(node) {
+    };
+    const getTagNameFromOpening = (openingElement) => {
+      const nameNode = openingElement.name;
+      if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
+        return nameNode.name;
+      }
+      const rightmost = getRightmostJSXIdentifier(nameNode);
+      return rightmost ? rightmost.name : null;
+    };
+    const isProviderOrContext = (tagName) => tagName.endsWith("Provider") || tagName.endsWith("Context");
+    const isValueAttributeOnProvider = (node) => node.type === AST_NODE_TYPES2.JSXAttribute && node.name && node.name.type === AST_NODE_TYPES2.JSXIdentifier && node.name.name === "value" && node.parent && node.parent.type === AST_NODE_TYPES2.JSXOpeningElement && (() => {
+      const tagName = getTagNameFromOpening(node.parent);
+      return tagName !== null && isProviderOrContext(tagName);
+    })();
+    const isContextProviderValueProp = (node) => {
       let current = node.parent;
       while (current) {
-        if (current.type === AST_NODE_TYPES2.JSXAttribute && current.name && current.name.type === AST_NODE_TYPES2.JSXIdentifier && current.name.name === "value") {
-          if (current.parent && current.parent.type === AST_NODE_TYPES2.JSXOpeningElement) {
-            const nameNode = current.parent.name;
-            if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
-              const tagName = nameNode.name;
-              if (tagName.endsWith("Provider") || tagName.endsWith("Context")) {
-                return true;
-              }
-            } else {
-              const rightmost = getRightmostJSXIdentifier(nameNode);
-              if (rightmost) {
-                if (rightmost.name.endsWith("Provider") || rightmost.name.endsWith("Context")) {
-                  return true;
-                }
-              }
-            }
-          }
+        if (isValueAttributeOnProvider(current)) {
+          return true;
         }
         current = current.parent;
       }
       return false;
-    }
-    function isCustomJSXElement(jsxElement) {
+    };
+    const isCustomJSXElement = (jsxElement) => {
       if (!jsxElement || !jsxElement.openingElement || !jsxElement.openingElement.name) {
         return false;
       }
@@ -1217,12 +1324,9 @@ var localizeReactProps = {
         return /^[A-Z]/.test(nameNode.name);
       }
       const leftmost = getLeftmostJSXIdentifier(nameNode);
-      if (leftmost && /^[A-Z]/.test(leftmost.name)) {
-        return true;
-      }
-      return false;
-    }
-    function getComponentFunction(node) {
+      return leftmost !== null && /^[A-Z]/.test(leftmost.name);
+    };
+    const getComponentFunction = (node) => {
       let current = node;
       while (current) {
         if (current.type === AST_NODE_TYPES2.FunctionDeclaration || current.type === AST_NODE_TYPES2.FunctionExpression || current.type === AST_NODE_TYPES2.ArrowFunctionExpression) {
@@ -1231,145 +1335,125 @@ var localizeReactProps = {
         current = current.parent;
       }
       return null;
-    }
-    function findVariableForIdentifier(id) {
-      let scope = context.sourceCode.getScope(id);
+    };
+    const findVariableForIdentifier = (identifier) => {
+      let scope = context.sourceCode.getScope(identifier);
       while (scope) {
-        for (const variable of scope.variables) {
-          for (const def of variable.defs) {
-            if (def.name === id) {
-              return variable;
-            }
-          }
+        const found = scope.variables.find((variable) => variable.defs.some((def) => def.name === identifier));
+        if (found) {
+          return found;
         }
         scope = scope.upper ?? null;
       }
       return null;
-    }
-    function analyzeVariableUsage(declarationId) {
+    };
+    const classifyReference = (reference, declarationId, jsxUsageSet) => {
+      const { identifier } = reference;
+      if (identifier === declarationId || isContextProviderValueProp(identifier)) {
+        return false;
+      }
+      const jsxAncestor = getJSXAncestor(identifier);
+      if (jsxAncestor && isCustomJSXElement(jsxAncestor)) {
+        jsxUsageSet.add(jsxAncestor);
+        return false;
+      }
+      return true;
+    };
+    const analyzeVariableUsage = (declarationId) => {
       const variable = findVariableForIdentifier(declarationId);
       if (!variable) {
         return {
-          jsxUsageSet: new Set,
-          hasOutsideUsage: false
+          hasOutsideUsage: false,
+          jsxUsageSet: new Set
         };
       }
       const jsxUsageSet = new Set;
-      let hasOutsideUsage = false;
-      for (const reference of variable.references) {
-        const identifier = reference.identifier;
-        if (identifier === declarationId) {
-          continue;
-        }
-        if (isContextProviderValueProp(identifier)) {
-          continue;
-        }
-        const jsxAncestor = getJSXAncestor(identifier);
-        if (jsxAncestor && isCustomJSXElement(jsxAncestor)) {
-          jsxUsageSet.add(jsxAncestor);
-        } else {
-          hasOutsideUsage = true;
-        }
-      }
+      const hasOutsideUsage = variable.references.some((ref) => classifyReference(ref, declarationId, jsxUsageSet));
       return {
-        jsxUsageSet,
-        hasOutsideUsage
+        hasOutsideUsage,
+        jsxUsageSet
       };
-    }
+    };
     const componentHookVars = new WeakMap;
-    function getHookSet(componentFunction) {
+    const getHookSet = (componentFunction) => {
       let hookSet = componentHookVars.get(componentFunction);
       if (!hookSet) {
         hookSet = new Set;
         componentHookVars.set(componentFunction, hookSet);
       }
       return hookSet;
-    }
-    function hasHookDependency(node, hookSet) {
+    };
+    const isRangeContained = (refRange, nodeRange) => refRange[0] >= nodeRange[0] && refRange[1] <= nodeRange[1];
+    const variableHasReferenceInRange = (variable, nodeRange) => variable.references.some((reference) => reference.identifier.range !== undefined && isRangeContained(reference.identifier.range, nodeRange));
+    const hasHookDependency = (node, hookSet) => {
       if (!node.range) {
         return false;
       }
       const nodeRange = node.range;
-      const nodeStart = nodeRange[0];
-      const nodeEnd = nodeRange[1];
       let scope = context.sourceCode.getScope(node);
       while (scope) {
-        for (const variable of scope.variables) {
-          if (!hookSet.has(variable.name)) {
-            continue;
-          }
-          for (const reference of variable.references) {
-            const identifier = reference.identifier;
-            if (!identifier.range) {
-              continue;
-            }
-            const refRange = identifier.range;
-            const refStart = refRange[0];
-            const refEnd = refRange[1];
-            if (refStart >= nodeStart && refEnd <= nodeEnd) {
-              return true;
-            }
-          }
+        const hookVars = scope.variables.filter((variable) => hookSet.has(variable.name));
+        if (hookVars.some((variable) => variableHasReferenceInRange(variable, nodeRange))) {
+          return true;
         }
         scope = scope.upper ?? null;
       }
       return false;
-    }
-    return {
-      VariableDeclarator(node) {
-        const componentFunction = getComponentFunction(node);
-        if (!componentFunction || !componentFunction.body)
+    };
+    const processUseStateDeclarator = (node) => {
+      if (!node.init || !isUseStateCall(node.init) || node.id.type !== AST_NODE_TYPES2.ArrayPattern || node.id.elements.length < 2) {
+        return false;
+      }
+      const [stateElem, setterElem] = node.id.elements;
+      if (!stateElem || stateElem.type !== AST_NODE_TYPES2.Identifier || !setterElem || setterElem.type !== AST_NODE_TYPES2.Identifier) {
+        return false;
+      }
+      const stateVarName = stateElem.name;
+      const setterVarName = setterElem.name;
+      const stateUsage = analyzeVariableUsage(stateElem);
+      const setterUsage = analyzeVariableUsage(setterElem);
+      const stateExclusivelySingleJSX = !stateUsage.hasOutsideUsage && stateUsage.jsxUsageSet.size === 1;
+      const setterExclusivelySingleJSX = !setterUsage.hasOutsideUsage && setterUsage.jsxUsageSet.size === 1;
+      if (!stateExclusivelySingleJSX || !setterExclusivelySingleJSX) {
+        return true;
+      }
+      const stateTarget = getSingleSetElement(stateUsage.jsxUsageSet);
+      const setterTarget = getSingleSetElement(setterUsage.jsxUsageSet);
+      if (stateTarget && stateTarget === setterTarget) {
+        context.report({
+          data: { setterVarName, stateVarName },
+          messageId: "stateAndSetterToChild",
+          node
+        });
+      }
+      return true;
+    };
+    const processGeneralVariable = (node, componentFunction) => {
+      if (!node.id || node.id.type !== AST_NODE_TYPES2.Identifier) {
+        return;
+      }
+      const varName = node.id.name;
+      if (node.init) {
+        const hookSet = getHookSet(componentFunction);
+        if (hasHookDependency(node.init, hookSet)) {
           return;
-        if (node.init && node.id && node.id.type === AST_NODE_TYPES2.Identifier && node.init.type === AST_NODE_TYPES2.CallExpression && isHookCall(node.init)) {
-          const hookSet = getHookSet(componentFunction);
-          hookSet.add(node.id.name);
-        }
-        if (node.init && isUseStateCall(node.init) && node.id.type === AST_NODE_TYPES2.ArrayPattern && node.id.elements.length >= 2) {
-          const stateElem = node.id.elements[0];
-          const setterElem = node.id.elements[1];
-          if (!stateElem || stateElem.type !== AST_NODE_TYPES2.Identifier || !setterElem || setterElem.type !== AST_NODE_TYPES2.Identifier) {
-            return;
-          }
-          const stateVarName = stateElem.name;
-          const setterVarName = setterElem.name;
-          const stateUsage = analyzeVariableUsage(stateElem);
-          const setterUsage = analyzeVariableUsage(setterElem);
-          const stateExclusivelySingleJSX = !stateUsage.hasOutsideUsage && stateUsage.jsxUsageSet.size === 1;
-          const setterExclusivelySingleJSX = !setterUsage.hasOutsideUsage && setterUsage.jsxUsageSet.size === 1;
-          if (stateExclusivelySingleJSX && setterExclusivelySingleJSX) {
-            const stateTarget = getSingleSetElement(stateUsage.jsxUsageSet);
-            const setterTarget = getSingleSetElement(setterUsage.jsxUsageSet);
-            if (stateTarget && stateTarget === setterTarget) {
-              context.report({
-                node,
-                messageId: "stateAndSetterToChild",
-                data: { stateVarName, setterVarName }
-              });
-            }
-          }
-        } else if (node.id && node.id.type === AST_NODE_TYPES2.Identifier) {
-          const varName = node.id.name;
-          if (node.init) {
-            const hookSet = getHookSet(componentFunction);
-            if (hasHookDependency(node.init, hookSet)) {
-              return;
-            }
-          }
-          const usage = analyzeVariableUsage(node.id);
-          if (!usage.hasOutsideUsage && usage.jsxUsageSet.size === 1) {
-            const target = getSingleSetElement(usage.jsxUsageSet);
-            const componentName = getJSXElementName(target);
-            candidateVariables.push({
-              node,
-              varName,
-              componentName
-            });
-          }
         }
-      },
+      }
+      const usage = analyzeVariableUsage(node.id);
+      if (!usage.hasOutsideUsage && usage.jsxUsageSet.size === 1) {
+        const target = getSingleSetElement(usage.jsxUsageSet);
+        const componentName = getJSXElementName(target);
+        candidateVariables.push({
+          componentName,
+          node,
+          varName
+        });
+      }
+    };
+    return {
       "Program:exit"() {
         const groups = new Map;
-        for (const candidate of candidateVariables) {
+        candidateVariables.forEach((candidate) => {
           const key = candidate.componentName;
           const existing = groups.get(key);
           if (existing) {
@@ -1377,87 +1461,102 @@ var localizeReactProps = {
           } else {
             groups.set(key, [candidate]);
           }
-        }
-        for (const candidates of groups.values()) {
-          if (candidates.length === 1) {
-            const candidate = candidates[0];
-            if (!candidate) {
-              continue;
-            }
-            context.report({
-              node: candidate.node,
-              messageId: "variableToChild",
-              data: { varName: candidate.varName }
-            });
+        });
+        groups.forEach((candidates) => {
+          if (candidates.length !== 1) {
+            return;
           }
+          const [candidate] = candidates;
+          if (!candidate) {
+            return;
+          }
+          context.report({
+            data: { varName: candidate.varName },
+            messageId: "variableToChild",
+            node: candidate.node
+          });
+        });
+      },
+      VariableDeclarator(node) {
+        const componentFunction = getComponentFunction(node);
+        if (!componentFunction || !componentFunction.body)
+          return;
+        if (node.init && node.id && node.id.type === AST_NODE_TYPES2.Identifier && node.init.type === AST_NODE_TYPES2.CallExpression && isHookCall(node.init)) {
+          const hookSet = getHookSet(componentFunction);
+          hookSet.add(node.id.name);
+        }
+        const wasUseState = processUseStateDeclarator(node);
+        if (!wasUseState) {
+          processGeneralVariable(node, componentFunction);
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow variables that are only passed to a single custom child component. For useState, only report if both the state and its setter are exclusively passed to a single custom child. For general variables, only report if a given child receives exactly one such candidate \u2013 if two or more are passed to the same component type, they're assumed to be settings that belong on the parent."
+    },
+    messages: {
+      stateAndSetterToChild: "State variable '{{stateVarName}}' and its setter '{{setterVarName}}' are only passed to a single custom child component. Consider moving the state into that component.",
+      variableToChild: "Variable '{{varName}}' is only passed to a single custom child component. Consider moving it to that component."
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/rules/no-or-none-component.ts
 var noOrNoneComponent = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer using logical && operator over ternary with null/undefined for conditional JSX rendering."
-    },
-    schema: [],
-    messages: {
-      useLogicalAnd: "Prefer using the logical '&&' operator instead of a ternary with null/undefined for conditional rendering."
-    }
-  },
-  defaultOptions: [],
   create(context) {
     return {
       ConditionalExpression(node) {
-        const alternate = node.alternate;
+        const { alternate } = node;
         const isNullAlternate = alternate && alternate.type === "Literal" && alternate.value === null;
         const isUndefinedAlternate = alternate && alternate.type === "Identifier" && alternate.name === "undefined";
         if (!isNullAlternate && !isUndefinedAlternate) {
           return;
         }
-        const parent = node.parent;
+        const { parent } = node;
         if (!parent || parent.type !== "JSXExpressionContainer") {
           return;
         }
         const containerParent = parent.parent;
         if (containerParent && containerParent.type !== "JSXAttribute") {
           context.report({
-            node,
-            messageId: "useLogicalAnd"
+            messageId: "useLogicalAnd",
+            node
           });
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Prefer using logical && operator over ternary with null/undefined for conditional JSX rendering."
+    },
+    messages: {
+      useLogicalAnd: "Prefer using the logical '&&' operator instead of a ternary with null/undefined for conditional rendering."
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/rules/no-button-navigation.ts
 var noButtonNavigation = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Enforce using anchor tags for navigation instead of buttons whose onClick handlers change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + \u2026)."
-    },
-    schema: [],
-    messages: {
-      noButtonNavigation: "Use an anchor tag for navigation instead of a button whose onClick handler changes the path. Detected: {{reason}}. Only query/hash updates (reading window.location.search, .pathname, or .hash) are allowed."
-    }
-  },
-  defaultOptions: [],
   create(context) {
     const handlerStack = [];
-    function getCurrentHandler() {
+    const getCurrentHandler = () => {
       const state = handlerStack[handlerStack.length - 1];
       if (!state) {
         return null;
       }
       return state;
-    }
-    function isOnClickButtonHandler(node) {
-      const parent = node.parent;
+    };
+    const isOnClickButtonHandler = (node) => {
+      const { parent } = node;
       if (!parent || parent.type !== "JSXExpressionContainer") {
         return null;
       }
@@ -1473,37 +1572,50 @@ var noButtonNavigation = {
       if (!openingElementCandidate || openingElementCandidate.type !== "JSXOpeningElement") {
         return null;
       }
-      const openingElement = openingElementCandidate;
-      const tagNameNode = openingElement.name;
+      const tagNameNode = openingElementCandidate.name;
       if (tagNameNode.type !== "JSXIdentifier" || tagNameNode.name !== "button") {
         return null;
       }
       return attr;
-    }
-    function isWindowLocationMember(member) {
-      const object = member.object;
+    };
+    const isWindowLocationMember = (member) => {
+      const { object } = member;
       if (object.type !== "MemberExpression") {
         return false;
       }
       const outerObject = object.object;
       const outerProperty = object.property;
-      if (outerObject.type === "Identifier" && outerObject.name === "window" && outerProperty.type === "Identifier" && outerProperty.name === "location") {
-        return true;
-      }
-      return false;
-    }
-    function isWindowHistoryMember(member) {
-      const object = member.object;
+      return outerObject.type === "Identifier" && outerObject.name === "window" && outerProperty.type === "Identifier" && outerProperty.name === "location";
+    };
+    const isWindowHistoryMember = (member) => {
+      const { object } = member;
       if (object.type !== "MemberExpression") {
         return false;
       }
       const outerObject = object.object;
       const outerProperty = object.property;
-      if (outerObject.type === "Identifier" && outerObject.name === "window" && outerProperty.type === "Identifier" && outerProperty.name === "history") {
-        return true;
+      return outerObject.type === "Identifier" && outerObject.name === "window" && outerProperty.type === "Identifier" && outerProperty.name === "history";
+    };
+    const reportHandlerExit = (state) => {
+      const { reason, sawReplaceCall, sawAllowedLocationRead } = state;
+      if (reason) {
+        context.report({
+          data: { reason },
+          messageId: "noButtonNavigation",
+          node: state.attribute
+        });
+        return;
       }
-      return false;
-    }
+      if (sawReplaceCall && !sawAllowedLocationRead) {
+        context.report({
+          data: {
+            reason: "history.replaceState/pushState without reading window.location"
+          },
+          messageId: "noButtonNavigation",
+          node: state.attribute
+        });
+      }
+    };
     return {
       ArrowFunctionExpression(node) {
         const attr = isOnClickButtonHandler(node);
@@ -1513,8 +1625,8 @@ var noButtonNavigation = {
         handlerStack.push({
           attribute: attr,
           reason: null,
-          sawReplaceCall: false,
-          sawAllowedLocationRead: false
+          sawAllowedLocationRead: false,
+          sawReplaceCall: false
         });
       },
       "ArrowFunctionExpression:exit"(node) {
@@ -1526,25 +1638,40 @@ var noButtonNavigation = {
         if (!state) {
           return;
         }
-        const reason = state.reason;
-        const sawReplaceCall = state.sawReplaceCall;
-        const sawAllowedLocationRead = state.sawAllowedLocationRead;
-        if (reason) {
-          context.report({
-            node: state.attribute,
-            messageId: "noButtonNavigation",
-            data: { reason }
-          });
+        reportHandlerExit(state);
+      },
+      AssignmentExpression(node) {
+        const state = getCurrentHandler();
+        if (!state) {
           return;
         }
-        if (sawReplaceCall && !sawAllowedLocationRead) {
-          context.report({
-            node: state.attribute,
-            messageId: "noButtonNavigation",
-            data: {
-              reason: "history.replaceState/pushState without reading window.location"
-            }
-          });
+        if (node.left.type !== "MemberExpression") {
+          return;
+        }
+        const { left } = node;
+        if (left.object.type === "Identifier" && left.object.name === "window" && left.property.type === "Identifier" && left.property.name === "location" && !state.reason) {
+          state.reason = "assignment to window.location";
+          return;
+        }
+        if (isWindowLocationMember(left) && !state.reason) {
+          state.reason = "assignment to window.location sub-property";
+        }
+      },
+      CallExpression(node) {
+        const state = getCurrentHandler();
+        if (!state) {
+          return;
+        }
+        const { callee } = node;
+        if (callee.type !== "MemberExpression") {
+          return;
+        }
+        if (isWindowLocationMember(callee) && callee.property.type === "Identifier" && callee.property.name === "replace" && !state.reason) {
+          state.reason = "window.location.replace";
+          return;
+        }
+        if (isWindowHistoryMember(callee) && callee.property.type === "Identifier" && (callee.property.name === "pushState" || callee.property.name === "replaceState")) {
+          state.sawReplaceCall = true;
         }
       },
       FunctionExpression(node) {
@@ -1555,8 +1682,8 @@ var noButtonNavigation = {
         handlerStack.push({
           attribute: attr,
           reason: null,
-          sawReplaceCall: false,
-          sawAllowedLocationRead: false
+          sawAllowedLocationRead: false,
+          sawReplaceCall: false
         });
       },
       "FunctionExpression:exit"(node) {
@@ -1568,159 +1695,99 @@ var noButtonNavigation = {
         if (!state) {
           return;
         }
-        const reason = state.reason;
-        const sawReplaceCall = state.sawReplaceCall;
-        const sawAllowedLocationRead = state.sawAllowedLocationRead;
-        if (reason) {
-          context.report({
-            node: state.attribute,
-            messageId: "noButtonNavigation",
-            data: { reason }
-          });
-          return;
-        }
-        if (sawReplaceCall && !sawAllowedLocationRead) {
-          context.report({
-            node: state.attribute,
-            messageId: "noButtonNavigation",
-            data: {
-              reason: "history.replaceState/pushState without reading window.location"
-            }
-          });
-        }
+        reportHandlerExit(state);
       },
       MemberExpression(node) {
         const state = getCurrentHandler();
         if (!state) {
           return;
         }
-        if (node.object.type === "Identifier" && node.object.name === "window" && node.property.type === "Identifier" && node.property.name === "open") {
-          if (!state.reason) {
-            state.reason = "window.open";
-          }
+        if (node.object.type === "Identifier" && node.object.name === "window" && node.property.type === "Identifier" && node.property.name === "open" && !state.reason) {
+          state.reason = "window.open";
         }
         if (isWindowLocationMember(node) && node.property.type === "Identifier" && (node.property.name === "search" || node.property.name === "pathname" || node.property.name === "hash")) {
           state.sawAllowedLocationRead = true;
         }
-      },
-      AssignmentExpression(node) {
-        const state = getCurrentHandler();
-        if (!state) {
-          return;
-        }
-        if (node.left.type !== "MemberExpression") {
-          return;
-        }
-        const left = node.left;
-        if (left.object.type === "Identifier" && left.object.name === "window" && left.property.type === "Identifier" && left.property.name === "location") {
-          if (!state.reason) {
-            state.reason = "assignment to window.location";
-          }
-          return;
-        }
-        if (isWindowLocationMember(left)) {
-          if (!state.reason) {
-            state.reason = "assignment to window.location sub-property";
-          }
-        }
-      },
-      CallExpression(node) {
-        const state = getCurrentHandler();
-        if (!state) {
-          return;
-        }
-        const callee = node.callee;
-        if (callee.type !== "MemberExpression") {
-          return;
-        }
-        if (isWindowLocationMember(callee) && callee.property.type === "Identifier" && callee.property.name === "replace") {
-          if (!state.reason) {
-            state.reason = "window.location.replace";
-          }
-          return;
-        }
-        if (isWindowHistoryMember(callee) && callee.property.type === "Identifier" && (callee.property.name === "pushState" || callee.property.name === "replaceState")) {
-          state.sawReplaceCall = true;
-        }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforce using anchor tags for navigation instead of buttons whose onClick handlers change the path. Allow only query/hash updates via window.location.search or history.replaceState(window.location.pathname + \u2026)."
+    },
+    messages: {
+      noButtonNavigation: "Use an anchor tag for navigation instead of a button whose onClick handler changes the path. Detected: {{reason}}. Only query/hash updates (reading window.location.search, .pathname, or .hash) are allowed."
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/rules/no-multi-style-objects.ts
+var getPropertyName = (prop) => {
+  const { key } = prop;
+  if (key.type === "Identifier") {
+    return key.name;
+  }
+  if (key.type === "Literal" && typeof key.value === "string") {
+    return key.value;
+  }
+  return null;
+};
 var noMultiStyleObjects = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow grouping CSS style objects in a single export; export each style separately."
-    },
-    schema: [],
-    messages: {
-      noMultiStyleObjects: "Do not group CSS style objects in a single export; export each style separately."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function checkObjectExpression(node) {
+    const checkObjectExpression = (node) => {
       if (!node.properties.length) {
         return;
       }
-      const cssStyleProperties = [];
-      for (const prop of node.properties) {
+      const cssStyleProperties = node.properties.filter((prop) => {
         if (prop.type !== "Property") {
-          continue;
-        }
-        const key = prop.key;
-        let name = null;
-        if (key.type === "Identifier") {
-          name = key.name;
-        } else if (key.type === "Literal" && typeof key.value === "string") {
-          name = key.value;
-        }
-        if (name && name.endsWith("Style")) {
-          cssStyleProperties.push(prop);
+          return false;
         }
-      }
+        const name = getPropertyName(prop);
+        return name !== null && name.endsWith("Style");
+      });
       if (cssStyleProperties.length > 1) {
         context.report({
-          node,
-          messageId: "noMultiStyleObjects"
+          messageId: "noMultiStyleObjects",
+          node
         });
       }
-    }
+    };
     return {
       ExportDefaultDeclaration(node) {
-        const declaration = node.declaration;
+        const { declaration } = node;
         if (declaration && declaration.type === "ObjectExpression") {
           checkObjectExpression(declaration);
         }
       },
       ReturnStatement(node) {
-        const argument = node.argument;
+        const { argument } = node;
         if (argument && argument.type === "ObjectExpression") {
           checkObjectExpression(argument);
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow grouping CSS style objects in a single export; export each style separately."
+    },
+    messages: {
+      noMultiStyleObjects: "Do not group CSS style objects in a single export; export each style separately."
+    },
+    schema: [],
+    type: "problem"
   }
 };
 
 // src/rules/no-useless-function.ts
 var noUselessFunction = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Disallow functions that have no parameters and just return an object literal; consider exporting the object directly, unless the function is used as a callback (e.g., in react-spring)."
-    },
-    schema: [],
-    messages: {
-      uselessFunction: "This function has no parameters and simply returns an object. Consider exporting the object directly instead of wrapping it in a function."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function isCallbackFunction(node) {
-      const parent = node.parent;
+    const isCallbackFunction = (node) => {
+      const { parent } = node;
       if (!parent || parent.type !== "CallExpression") {
         return false;
       }
@@ -1730,7 +1797,7 @@ var noUselessFunction = {
         }
       }
       return false;
-    }
+    };
     return {
       ArrowFunctionExpression(node) {
         if (node.params.length === 0 && node.body && node.body.type === "ObjectExpression") {
@@ -1738,55 +1805,73 @@ var noUselessFunction = {
             return;
           }
           context.report({
-            node,
-            messageId: "uselessFunction"
+            messageId: "uselessFunction",
+            node
           });
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow functions that have no parameters and just return an object literal; consider exporting the object directly, unless the function is used as a callback (e.g., in react-spring)."
+    },
+    messages: {
+      uselessFunction: "This function has no parameters and simply returns an object. Consider exporting the object directly instead of wrapping it in a function."
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/rules/min-var-length.ts
+var extractIdentifiersFromPattern = (pattern, identifiers = []) => {
+  if (!pattern)
+    return identifiers;
+  switch (pattern.type) {
+    case "Identifier":
+      identifiers.push(pattern.name);
+      break;
+    case "ObjectPattern":
+      pattern.properties.forEach((prop) => {
+        if (prop.type === "Property") {
+          extractIdentifiersFromPattern(prop.value, identifiers);
+        } else if (prop.type === "RestElement") {
+          extractIdentifiersFromPattern(prop.argument, identifiers);
+        }
+      });
+      break;
+    case "ArrayPattern":
+      pattern.elements.filter((element) => element !== null).forEach((element) => {
+        extractIdentifiersFromPattern(element, identifiers);
+      });
+      break;
+    case "AssignmentPattern":
+      extractIdentifiersFromPattern(pattern.left, identifiers);
+      break;
+    default:
+      break;
+  }
+  return identifiers;
+};
+var getDeclaratorNames = (declarations) => declarations.filter((decl) => decl.id.type === "Identifier").map((decl) => decl.id.name);
+var collectParamNames = (params) => {
+  const names = [];
+  params.forEach((param) => {
+    extractIdentifiersFromPattern(param, names);
+  });
+  return names;
+};
 var minVarLength = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow variable names shorter than the configured minimum length unless an outer variable with a longer name starting with the same characters exists. You can exempt specific variable names using the allowedVars option."
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          minLength: {
-            type: "number",
-            default: 1
-          },
-          allowedVars: {
-            type: "array",
-            items: {
-              type: "string",
-              minLength: 1
-            },
-            default: []
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      variableNameTooShort: "Variable '{{name}}' is too short. Minimum allowed length is {{minLength}} characters unless an outer variable with a longer name starting with '{{name}}' exists."
-    }
-  },
-  defaultOptions: [{}],
   create(context) {
-    const sourceCode = context.sourceCode;
-    const options = context.options[0];
+    const { sourceCode } = context;
+    const [options] = context.options;
     const configuredMinLength = options && typeof options.minLength === "number" ? options.minLength : 1;
     const configuredAllowedVars = options && Array.isArray(options.allowedVars) ? options.allowedVars : [];
     const minLength = configuredMinLength;
     const allowedVars = configuredAllowedVars;
-    function getAncestors(node) {
+    const getAncestors = (node) => {
       const ancestors = [];
       let current = node.parent;
       while (current) {
@@ -1794,9 +1879,9 @@ var minVarLength = {
         current = current.parent;
       }
       return ancestors;
-    }
-    function getScope(node) {
-      const scopeManager = sourceCode.scopeManager;
+    };
+    const getScope = (node) => {
+      const { scopeManager } = sourceCode;
       if (!scopeManager) {
         return null;
       }
@@ -1805,119 +1890,79 @@ var minVarLength = {
         return acquired;
       }
       return scopeManager.globalScope ?? null;
-    }
-    function getVariablesInNearestBlock(node) {
+    };
+    const getVariablesInNearestBlock = (node) => {
       let current = node.parent;
       while (current && current.type !== "BlockStatement") {
         current = current.parent;
       }
-      const names = [];
-      if (current && current.type === "BlockStatement" && Array.isArray(current.body)) {
-        for (const stmt of current.body) {
-          if (stmt.type === "VariableDeclaration") {
-            for (const decl of stmt.declarations) {
-              if (decl.id && decl.id.type === "Identifier") {
-                names.push(decl.id.name);
-              }
-            }
-          }
-        }
-      }
-      return names;
-    }
-    function extractIdentifiersFromPattern(pattern, identifiers = []) {
-      if (!pattern)
-        return identifiers;
-      switch (pattern.type) {
-        case "Identifier":
-          identifiers.push(pattern.name);
-          break;
-        case "ObjectPattern":
-          for (const prop of pattern.properties) {
-            if (prop.type === "Property") {
-              extractIdentifiersFromPattern(prop.value, identifiers);
-            } else if (prop.type === "RestElement") {
-              extractIdentifiersFromPattern(prop.argument, identifiers);
-            }
-          }
-          break;
-        case "ArrayPattern":
-          for (const element of pattern.elements) {
-            if (element) {
-              extractIdentifiersFromPattern(element, identifiers);
-            }
-          }
-          break;
-        case "AssignmentPattern":
-          extractIdentifiersFromPattern(pattern.left, identifiers);
-          break;
-        default:
-          break;
+      if (!current || current.type !== "BlockStatement" || !Array.isArray(current.body)) {
+        return [];
       }
-      return identifiers;
-    }
-    function hasOuterCorrespondingIdentifier(shortName, node) {
+      const varDeclarations = current.body.filter((stmt) => stmt.type === "VariableDeclaration");
+      return varDeclarations.flatMap((stmt) => getDeclaratorNames(stmt.declarations));
+    };
+    const isLongerMatchInScope = (shortName, varName) => varName.length >= minLength && varName.length > shortName.length && varName.startsWith(shortName);
+    const checkScopeVariables = (shortName, node) => {
       const startingScope = getScope(node);
       let outer = startingScope && startingScope.upper ? startingScope.upper : null;
       while (outer) {
-        for (const variable of outer.variables) {
-          if (variable.name.length >= minLength && variable.name.length > shortName.length && variable.name.startsWith(shortName)) {
-            return true;
-          }
+        if (outer.variables.some((variable) => isLongerMatchInScope(shortName, variable.name))) {
+          return true;
         }
         outer = outer.upper;
       }
+      return false;
+    };
+    const checkBlockVariables = (shortName, node) => {
       const blockVars = getVariablesInNearestBlock(node);
-      for (const name of blockVars) {
-        if (name.length >= minLength && name.length > shortName.length && name.startsWith(shortName)) {
-          return true;
-        }
+      return blockVars.some((varName) => isLongerMatchInScope(shortName, varName));
+    };
+    const checkAncestorDeclarators = (shortName, node) => {
+      const ancestors = getAncestors(node);
+      return ancestors.some((anc) => anc.type === "VariableDeclarator" && anc.id && anc.id.type === "Identifier" && isLongerMatchInScope(shortName, anc.id.name));
+    };
+    const checkFunctionAncestor = (shortName, anc) => {
+      const names = collectParamNames(anc.params);
+      return names.some((paramName) => isLongerMatchInScope(shortName, paramName));
+    };
+    const checkCatchAncestor = (shortName, anc) => {
+      if (!anc.param) {
+        return false;
       }
+      const names = extractIdentifiersFromPattern(anc.param, []);
+      return names.some((paramName) => isLongerMatchInScope(shortName, paramName));
+    };
+    const checkAncestorParams = (shortName, node) => {
       const ancestors = getAncestors(node);
-      for (const anc of ancestors) {
-        if (anc.type === "VariableDeclarator" && anc.id && anc.id.type === "Identifier") {
-          const outerName = anc.id.name;
-          if (outerName.length >= minLength && outerName.length > shortName.length && outerName.startsWith(shortName)) {
-            return true;
-          }
-        }
-        if ((anc.type === "FunctionDeclaration" || anc.type === "FunctionExpression" || anc.type === "ArrowFunctionExpression") && Array.isArray(anc.params)) {
-          for (const param of anc.params) {
-            const names = extractIdentifiersFromPattern(param, []);
-            for (const n of names) {
-              if (n.length >= minLength && n.length > shortName.length && n.startsWith(shortName)) {
-                return true;
-              }
-            }
-          }
+      return ancestors.some((anc) => {
+        if (anc.type === "FunctionDeclaration" || anc.type === "FunctionExpression" || anc.type === "ArrowFunctionExpression") {
+          return checkFunctionAncestor(shortName, anc);
         }
-        if (anc.type === "CatchClause" && anc.param) {
-          const names = extractIdentifiersFromPattern(anc.param, []);
-          for (const n of names) {
-            if (n.length >= minLength && n.length > shortName.length && n.startsWith(shortName)) {
-              return true;
-            }
-          }
+        if (anc.type === "CatchClause") {
+          return checkCatchAncestor(shortName, anc);
         }
+        return false;
+      });
+    };
+    const hasOuterCorrespondingIdentifier = (shortName, node) => checkScopeVariables(shortName, node) || checkBlockVariables(shortName, node) || checkAncestorDeclarators(shortName, node) || checkAncestorParams(shortName, node);
+    const checkIdentifier = (node) => {
+      const { name } = node;
+      if (name.length >= minLength) {
+        return;
       }
-      return false;
-    }
-    function checkIdentifier(node) {
-      const name = node.name;
-      if (name.length < minLength) {
-        if (allowedVars.includes(name)) {
-          return;
-        }
-        if (!hasOuterCorrespondingIdentifier(name, node)) {
-          context.report({
-            node,
-            messageId: "variableNameTooShort",
-            data: { name, minLength }
-          });
-        }
+      if (allowedVars.includes(name)) {
+        return;
+      }
+      if (!hasOuterCorrespondingIdentifier(name, node)) {
+        context.report({
+          data: { minLength, name },
+          messageId: "variableNameTooShort",
+          node
+        });
       }
-    }
-    function checkPattern(pattern) {
+    };
+    const checkPattern = (pattern) => {
       if (!pattern)
         return;
       switch (pattern.type) {
@@ -1925,20 +1970,18 @@ var minVarLength = {
           checkIdentifier(pattern);
           break;
         case "ObjectPattern":
-          for (const prop of pattern.properties) {
+          pattern.properties.forEach((prop) => {
             if (prop.type === "Property") {
               checkPattern(prop.value);
             } else if (prop.type === "RestElement") {
               checkPattern(prop.argument);
             }
-          }
+          });
           break;
         case "ArrayPattern":
-          for (const element of pattern.elements) {
-            if (element) {
-              checkPattern(element);
-            }
-          }
+          pattern.elements.filter((element) => element !== null).forEach((element) => {
+            checkPattern(element);
+          });
           break;
         case "AssignmentPattern":
           checkPattern(pattern.left);
@@ -1946,49 +1989,64 @@ var minVarLength = {
         default:
           break;
       }
-    }
+    };
     return {
-      VariableDeclarator(node) {
-        if (node.id) {
-          checkPattern(node.id);
+      CatchClause(node) {
+        if (node.param) {
+          checkPattern(node.param);
         }
       },
       "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
-        for (const param of node.params) {
+        node.params.forEach((param) => {
           checkPattern(param);
-        }
+        });
       },
-      CatchClause(node) {
-        if (node.param) {
-          checkPattern(node.param);
+      VariableDeclarator(node) {
+        if (node.id) {
+          checkPattern(node.id);
         }
       }
     };
-  }
-};
-
-// src/rules/max-depth-extended.ts
-var maxDepthExtended = {
+  },
+  defaultOptions: [{}],
   meta: {
-    type: "suggestion",
     docs: {
-      description: "disallow too many nested blocks except when the block only contains an early exit (return or throw)"
+      description: "Disallow variable names shorter than the configured minimum length unless an outer variable with a longer name starting with the same characters exists. You can exempt specific variable names using the allowedVars option."
+    },
+    messages: {
+      variableNameTooShort: "Variable '{{name}}' is too short. Minimum allowed length is {{minLength}} characters unless an outer variable with a longer name starting with '{{name}}' exists."
     },
     schema: [
       {
-        type: "number"
+        additionalProperties: false,
+        properties: {
+          allowedVars: {
+            default: [],
+            items: {
+              minLength: 1,
+              type: "string"
+            },
+            type: "array"
+          },
+          minLength: {
+            default: 1,
+            type: "number"
+          }
+        },
+        type: "object"
       }
     ],
-    messages: {
-      tooDeep: "Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}} or an early exit."
-    }
-  },
-  defaultOptions: [1],
+    type: "problem"
+  }
+};
+
+// src/rules/max-depth-extended.ts
+var maxDepthExtended = {
   create(context) {
-    const option = context.options[0];
+    const [option] = context.options;
     const maxDepth = typeof option === "number" ? option : 1;
     const functionStack = [];
-    function getAncestors(node) {
+    const getAncestors = (node) => {
       const ancestors = [];
       let current = node.parent;
       while (current) {
@@ -1996,18 +2054,23 @@ var maxDepthExtended = {
         current = current.parent;
       }
       return ancestors;
-    }
-    function isEarlyExitBlock(node) {
+    };
+    const isEarlyExitBlock = (node) => {
       if (node.body.length !== 1) {
         return false;
       }
-      const first = node.body[0];
+      const [first] = node.body;
       if (!first) {
         return false;
       }
       return first.type === "ReturnStatement" || first.type === "ThrowStatement";
-    }
-    function incrementCurrentDepth() {
+    };
+    const isFunctionBody = (node) => {
+      const ancestors = getAncestors(node);
+      const [parent] = ancestors;
+      return parent && (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && node === parent.body;
+    };
+    const incrementCurrentDepth = () => {
       if (functionStack.length === 0) {
         return null;
       }
@@ -2019,8 +2082,8 @@ var maxDepthExtended = {
       const nextDepth = currentDepth + 1;
       functionStack[index] = nextDepth;
       return nextDepth;
-    }
-    function decrementCurrentDepth() {
+    };
+    const decrementCurrentDepth = () => {
       if (functionStack.length === 0) {
         return;
       }
@@ -2030,30 +2093,25 @@ var maxDepthExtended = {
         return;
       }
       functionStack[index] = currentDepth - 1;
-    }
-    function checkDepth(node, depth) {
+    };
+    const checkDepth = (node, depth) => {
       if (depth > maxDepth) {
         context.report({
-          node,
+          data: { depth, maxDepth },
           messageId: "tooDeep",
-          data: { depth, maxDepth }
+          node
         });
       }
-    }
+    };
     return {
-      FunctionDeclaration() {
-        functionStack.push(0);
-      },
-      FunctionExpression() {
-        functionStack.push(0);
-      },
       ArrowFunctionExpression() {
         functionStack.push(0);
       },
+      "ArrowFunctionExpression:exit"() {
+        functionStack.pop();
+      },
       BlockStatement(node) {
-        const ancestors = getAncestors(node);
-        const parent = ancestors.length > 0 ? ancestors[0] : undefined;
-        if (parent && (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && node === parent.body) {
+        if (isFunctionBody(node)) {
           return;
         }
         if (isEarlyExitBlock(node)) {
@@ -2065,9 +2123,7 @@ var maxDepthExtended = {
         }
       },
       "BlockStatement:exit"(node) {
-        const ancestors = getAncestors(node);
-        const parent = ancestors.length > 0 ? ancestors[0] : undefined;
-        if (parent && (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && node === parent.body) {
+        if (isFunctionBody(node)) {
           return;
         }
         if (isEarlyExitBlock(node)) {
@@ -2075,39 +2131,105 @@ var maxDepthExtended = {
         }
         decrementCurrentDepth();
       },
+      FunctionDeclaration() {
+        functionStack.push(0);
+      },
       "FunctionDeclaration:exit"() {
         functionStack.pop();
       },
-      "FunctionExpression:exit"() {
-        functionStack.pop();
+      FunctionExpression() {
+        functionStack.push(0);
       },
-      "ArrowFunctionExpression:exit"() {
+      "FunctionExpression:exit"() {
         functionStack.pop();
       }
     };
+  },
+  defaultOptions: [1],
+  meta: {
+    docs: {
+      description: "disallow too many nested blocks except when the block only contains an early exit (return or throw)"
+    },
+    messages: {
+      tooDeep: "Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}} or an early exit."
+    },
+    schema: [
+      {
+        type: "number"
+      }
+    ],
+    type: "suggestion"
   }
 };
 
 // src/rules/spring-naming-convention.ts
+var SPRINGS_SUFFIX = "Springs";
+var checkUseSpring = (context, firstElem, secondElem) => {
+  const firstName = firstElem.name;
+  const secondName = secondElem.name;
+  if (!firstName.endsWith(SPRINGS_SUFFIX)) {
+    context.report({
+      messageId: "firstMustEndWithSprings",
+      node: firstElem
+    });
+    return;
+  }
+  const base = firstName.slice(0, -SPRINGS_SUFFIX.length);
+  if (!base) {
+    context.report({
+      messageId: "firstMustHaveBase",
+      node: firstElem
+    });
+    return;
+  }
+  const expectedSecond = `${base}Api`;
+  if (secondName !== expectedSecond) {
+    context.report({
+      data: { expected: expectedSecond },
+      messageId: "secondMustMatch",
+      node: secondElem
+    });
+  }
+};
+var checkUseSprings = (context, firstElem, secondElem) => {
+  const firstName = firstElem.name;
+  const secondName = secondElem.name;
+  if (!firstName.endsWith(SPRINGS_SUFFIX)) {
+    context.report({
+      messageId: "firstMustEndWithSprings",
+      node: firstElem
+    });
+    return;
+  }
+  const basePlural = firstName.slice(0, -SPRINGS_SUFFIX.length);
+  if (!basePlural) {
+    context.report({
+      messageId: "firstMustHaveBase",
+      node: firstElem
+    });
+    return;
+  }
+  if (!basePlural.endsWith("s")) {
+    context.report({
+      messageId: "pluralRequired",
+      node: firstElem
+    });
+    return;
+  }
+  const expectedSecond = `${basePlural}Api`;
+  if (secondName !== expectedSecond) {
+    context.report({
+      data: { expected: expectedSecond },
+      messageId: "secondMustMatch",
+      node: secondElem
+    });
+  }
+};
 var springNamingConvention = {
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Enforce correct naming for useSpring and useSprings hook destructuring"
-    },
-    schema: [],
-    messages: {
-      firstMustEndWithSprings: "The first variable must end with 'Springs'.",
-      firstMustHaveBase: "The first variable must have a non-empty name before 'Springs'.",
-      secondMustMatch: "The second variable must be named '{{expected}}'.",
-      pluralRequired: "The first variable for useSprings should be plural (ending with 's') before 'Springs'."
-    }
-  },
-  defaultOptions: [],
   create(context) {
     return {
       VariableDeclarator(node) {
-        const init = node.init;
+        const { init } = node;
         if (!init || init.type !== "CallExpression" || init.callee.type !== "Identifier") {
           return;
         }
@@ -2118,87 +2240,74 @@ var springNamingConvention = {
         if (node.id.type !== "ArrayPattern") {
           return;
         }
-        const elements = node.id.elements;
+        const { elements } = node.id;
         if (elements.length < 2) {
           return;
         }
-        const firstElem = elements[0];
-        const secondElem = elements[1];
+        const [firstElem, secondElem] = elements;
         if (!firstElem || firstElem.type !== "Identifier" || !secondElem || secondElem.type !== "Identifier") {
           return;
         }
-        const firstName = firstElem.name;
-        const secondName = secondElem.name;
         if (hookName === "useSpring") {
-          if (!firstName.endsWith("Springs")) {
-            context.report({
-              node: firstElem,
-              messageId: "firstMustEndWithSprings"
-            });
-            return;
-          }
-          const base = firstName.slice(0, -"Springs".length);
-          if (!base) {
-            context.report({
-              node: firstElem,
-              messageId: "firstMustHaveBase"
-            });
-            return;
-          }
-          const expectedSecond = `${base}Api`;
-          if (secondName !== expectedSecond) {
-            context.report({
-              node: secondElem,
-              messageId: "secondMustMatch",
-              data: { expected: expectedSecond }
-            });
-          }
+          checkUseSpring(context, firstElem, secondElem);
           return;
         }
         if (hookName === "useSprings") {
-          if (!firstName.endsWith("Springs")) {
-            context.report({
-              node: firstElem,
-              messageId: "firstMustEndWithSprings"
-            });
-            return;
-          }
-          const basePlural = firstName.slice(0, -"Springs".length);
-          if (!basePlural) {
-            context.report({
-              node: firstElem,
-              messageId: "firstMustHaveBase"
-            });
-            return;
-          }
-          if (!basePlural.endsWith("s")) {
-            context.report({
-              node: firstElem,
-              messageId: "pluralRequired"
-            });
-            return;
-          }
-          const expectedSecond = `${basePlural}Api`;
-          if (secondName !== expectedSecond) {
-            context.report({
-              node: secondElem,
-              messageId: "secondMustMatch",
-              data: { expected: expectedSecond }
-            });
-          }
+          checkUseSprings(context, firstElem, secondElem);
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforce correct naming for useSpring and useSprings hook destructuring"
+    },
+    messages: {
+      firstMustEndWithSprings: "The first variable must end with 'Springs'.",
+      firstMustHaveBase: "The first variable must have a non-empty name before 'Springs'.",
+      pluralRequired: "The first variable for useSprings should be plural (ending with 's') before 'Springs'.",
+      secondMustMatch: "The second variable must be named '{{expected}}'."
+    },
+    schema: [],
+    type: "problem"
   }
 };
 
 // src/rules/inline-style-limit.ts
+var DEFAULT_MAX_KEYS = 3;
 var inlineStyleLimit = {
+  create(context) {
+    const [option] = context.options;
+    const maxKeys = typeof option === "number" ? option : option && option.maxKeys || DEFAULT_MAX_KEYS;
+    return {
+      JSXAttribute(node) {
+        if (node.name.type !== "JSXIdentifier" || node.name.name !== "style") {
+          return;
+        }
+        if (!node.value || node.value.type !== "JSXExpressionContainer" || !node.value.expression || node.value.expression.type !== "ObjectExpression") {
+          return;
+        }
+        const styleObject = node.value.expression;
+        const keyCount = styleObject.properties.filter((prop) => prop.type === "Property").length;
+        if (keyCount > maxKeys) {
+          context.report({
+            data: { max: maxKeys },
+            messageId: "extractStyle",
+            node
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [DEFAULT_MAX_KEYS],
   meta: {
-    type: "suggestion",
     docs: {
       description: "Disallow inline style objects with too many keys and encourage extracting them"
     },
+    messages: {
+      extractStyle: "Inline style objects should be extracted into a separate object or file when containing more than {{max}} keys."
+    },
     schema: [
       {
         anyOf: [
@@ -2206,119 +2315,78 @@ var inlineStyleLimit = {
             type: "number"
           },
           {
-            type: "object",
+            additionalProperties: false,
             properties: {
               maxKeys: {
-                type: "number",
-                description: "Maximum number of keys allowed in an inline style object before it must be extracted."
+                description: "Maximum number of keys allowed in an inline style object before it must be extracted.",
+                type: "number"
               }
             },
-            additionalProperties: false
+            type: "object"
           }
         ]
       }
     ],
-    messages: {
-      extractStyle: "Inline style objects should be extracted into a separate object or file when containing more than {{max}} keys."
-    }
-  },
-  defaultOptions: [3],
-  create(context) {
-    const option = context.options[0];
-    const maxKeys = typeof option === "number" ? option : option && option.maxKeys || 3;
-    return {
-      JSXAttribute(node) {
-        if (node.name.type !== "JSXIdentifier" || node.name.name !== "style") {
-          return;
-        }
-        if (node.value && node.value.type === "JSXExpressionContainer" && node.value.expression && node.value.expression.type === "ObjectExpression") {
-          const styleObject = node.value.expression;
-          const keyCount = styleObject.properties.filter((prop) => prop.type === "Property").length;
-          if (keyCount > maxKeys) {
-            context.report({
-              node,
-              messageId: "extractStyle",
-              data: { max: maxKeys }
-            });
-          }
-        }
-      }
-    };
+    type: "suggestion"
   }
 };
 
 // src/rules/no-inline-prop-types.ts
 var noInlinePropTypes = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Enforce that component prop types are not defined inline (using an object literal) but rather use a named type or interface."
-    },
-    schema: [],
-    messages: {
-      noInlinePropTypes: "Inline prop type definitions are not allowed. Use a named type alias or interface instead of an inline object type."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function checkParameter(param) {
-      if (param.type === "ObjectPattern" && param.typeAnnotation && param.typeAnnotation.type === "TSTypeAnnotation") {
-        const annotation = param.typeAnnotation.typeAnnotation;
-        if (annotation.type === "TSTypeLiteral") {
-          context.report({
-            node: param,
-            messageId: "noInlinePropTypes"
-          });
-        }
+    const checkParameter = (param) => {
+      if (param.type !== "ObjectPattern" || !param.typeAnnotation || param.typeAnnotation.type !== "TSTypeAnnotation") {
+        return;
       }
-    }
+      const annotation = param.typeAnnotation.typeAnnotation;
+      if (annotation.type === "TSTypeLiteral") {
+        context.report({
+          messageId: "noInlinePropTypes",
+          node: param
+        });
+      }
+    };
     return {
       "FunctionDeclaration, ArrowFunctionExpression, FunctionExpression"(node) {
         if (node.params.length === 0) {
           return;
         }
-        const firstParam = node.params[0];
+        const [firstParam] = node.params;
         if (!firstParam) {
           return;
         }
         checkParameter(firstParam);
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforce that component prop types are not defined inline (using an object literal) but rather use a named type or interface."
+    },
+    messages: {
+      noInlinePropTypes: "Inline prop type definitions are not allowed. Use a named type alias or interface instead of an inline object type."
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/rules/no-unnecessary-div.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
 var noUnnecessaryDiv = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Flag unnecessary <div> wrappers that enclose a single JSX element. Remove the wrapper if it doesn't add semantic or functional value, or replace it with a semantic element if wrapping is needed."
-    },
-    schema: [],
-    messages: {
-      unnecessaryDivWrapper: "Unnecessary <div> wrapper detected. Remove it if not needed, or replace with a semantic element that reflects its purpose."
-    }
-  },
-  defaultOptions: [],
   create(context) {
-    function isDivElement(node) {
+    const isDivElement = (node) => {
       const nameNode = node.openingElement.name;
       return nameNode.type === AST_NODE_TYPES3.JSXIdentifier && nameNode.name === "div";
-    }
-    function getMeaningfulChildren(node) {
-      const result = [];
-      for (const child of node.children) {
-        if (child.type === AST_NODE_TYPES3.JSXText) {
-          if (child.value.trim() !== "") {
-            result.push(child);
-          }
-        } else {
-          result.push(child);
-        }
+    };
+    const isMeaningfulChild = (child) => {
+      if (child.type === AST_NODE_TYPES3.JSXText) {
+        return child.value.trim() !== "";
       }
-      return result;
-    }
+      return true;
+    };
+    const getMeaningfulChildren = (node) => node.children.filter(isMeaningfulChild);
     return {
       JSXElement(node) {
         if (!isDivElement(node)) {
@@ -2328,44 +2396,55 @@ var noUnnecessaryDiv = {
         if (meaningfulChildren.length !== 1) {
           return;
         }
-        const onlyChild = meaningfulChildren[0];
+        const [onlyChild] = meaningfulChildren;
         if (!onlyChild) {
           return;
         }
         if (onlyChild.type === AST_NODE_TYPES3.JSXElement) {
           context.report({
-            node,
-            messageId: "unnecessaryDivWrapper"
+            messageId: "unnecessaryDivWrapper",
+            node
           });
         }
       }
     };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Flag unnecessary <div> wrappers that enclose a single JSX element. Remove the wrapper if it doesn't add semantic or functional value, or replace it with a semantic element if wrapping is needed."
+    },
+    messages: {
+      unnecessaryDivWrapper: "Unnecessary <div> wrapper detected. Remove it if not needed, or replace with a semantic element that reflects its purpose."
+    },
+    schema: [],
+    type: "suggestion"
   }
 };
 
 // src/index.ts
 var src_default = {
   rules: {
-    "no-nested-jsx-return": noNestedJSXReturn,
     "explicit-object-types": explicitObjectTypes,
-    "sort-keys-fixable": sortKeysFixable,
-    "no-transition-cssproperties": noTransitionCSSProperties,
-    "no-explicit-return-type": noExplicitReturnTypes,
-    "max-jsxnesting": maxJSXNesting,
-    "seperate-style-files": seperateStyleFiles,
-    "no-unnecessary-key": noUnnecessaryKey,
-    "sort-exports": sortExports,
+    "inline-style-limit": inlineStyleLimit,
     "localize-react-props": localizeReactProps,
-    "no-or-none-component": noOrNoneComponent,
+    "max-depth-extended": maxDepthExtended,
+    "max-jsxnesting": maxJSXNesting,
+    "min-var-length": minVarLength,
     "no-button-navigation": noButtonNavigation,
+    "no-explicit-return-type": noExplicitReturnTypes,
+    "no-inline-prop-types": noInlinePropTypes,
     "no-multi-style-objects": noMultiStyleObjects,
+    "no-nested-jsx-return": noNestedJSXReturn,
+    "no-or-none-component": noOrNoneComponent,
+    "no-transition-cssproperties": noTransitionCSSProperties,
+    "no-unnecessary-div": noUnnecessaryDiv,
+    "no-unnecessary-key": noUnnecessaryKey,
     "no-useless-function": noUselessFunction,
-    "min-var-length": minVarLength,
-    "max-depth-extended": maxDepthExtended,
-    "spring-naming-convention": springNamingConvention,
-    "inline-style-limit": inlineStyleLimit,
-    "no-inline-prop-types": noInlinePropTypes,
-    "no-unnecessary-div": noUnnecessaryDiv
+    "seperate-style-files": seperateStyleFiles,
+    "sort-exports": sortExports,
+    "sort-keys-fixable": sortKeysFixable,
+    "spring-naming-convention": springNamingConvention
   }
 };
 export {