eslint-plugin-absolute 0.1.6 → 0.2.0

package/dist/index.js

@@ -1,62 +1,76 @@
 // @bun
-// src/rules/no-nested-jsx-return.js
-var no_nested_jsx_return_default = {
+// 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",
-      recommended: false
+      description: "Disallow nested functions that return non-component, non-singular JSX to enforce one component per file"
     },
-    schema: []
+    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 === "JSXElement" || node.type === "JSXFragment");
+      return !!node && (node.type === AST_NODE_TYPES.JSXElement || node.type === AST_NODE_TYPES.JSXFragment);
+    }
+    function getLeftmostJSXIdentifier(name) {
+      let current = name;
+      while (current.type === AST_NODE_TYPES.JSXMemberExpression) {
+        current = current.object;
+      }
+      if (current.type === AST_NODE_TYPES.JSXIdentifier) {
+        return current;
+      }
+      return null;
     }
     function isJSXComponentElement(node) {
-      if (node && node.type === "JSXElement") {
-        const opening = node.openingElement;
-        if (opening && opening.name) {
-          if (opening.name.type === "JSXIdentifier") {
-            return /^[A-Z]/.test(opening.name.name);
-          }
-          if (opening.name.type === "JSXMemberExpression") {
-            let current = opening.name;
-            while (current && current.type === "JSXMemberExpression") {
-              current = current.object;
-            }
-            return current && current.type === "JSXIdentifier" && /^[A-Z]/.test(current.name);
-          }
-        }
+      if (!node || node.type !== AST_NODE_TYPES.JSXElement) {
         return false;
       }
-      return false;
+      const opening = node.openingElement;
+      const nameNode = opening.name;
+      if (nameNode.type === AST_NODE_TYPES.JSXIdentifier) {
+        return /^[A-Z]/.test(nameNode.name);
+      }
+      const leftmost = getLeftmostJSXIdentifier(nameNode);
+      if (!leftmost) {
+        return false;
+      }
+      return /^[A-Z]/.test(leftmost.name);
     }
     function isSingularJSXReturn(node) {
       if (!isJSX(node))
         return false;
-      let children = [];
-      if (node.type === "JSXElement" || node.type === "JSXFragment") {
-        children = node.children.filter((child) => {
-          if (child.type === "JSXText") {
-            return child.value.trim() !== "";
-          }
-          return true;
-        });
-        if (children.length === 1) {
-          const child = children[0];
-          if (child.type === "JSXElement" || child.type === "JSXFragment") {
-            const innerChildren = child.children.filter((innerChild) => {
-              if (innerChild.type === "JSXText") {
-                return innerChild.value.trim() !== "";
-              }
-              return true;
-            });
-            return innerChildren.length === 0;
-          }
-          return true;
+      const children = node.children.filter((child) => {
+        if (child.type === AST_NODE_TYPES.JSXText) {
+          return child.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 children.length === 0;
+        return true;
       }
       return false;
     }
@@ -71,36 +85,49 @@ var no_nested_jsx_return_default = {
       "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
         pushFunction(node);
       },
-      "FunctionDeclaration:exit"(node) {
+      "FunctionDeclaration:exit"(_node) {
         popFunction();
       },
-      "FunctionExpression:exit"(node) {
+      "FunctionExpression:exit"(_node) {
         popFunction();
       },
-      "ArrowFunctionExpression:exit"(node) {
+      "ArrowFunctionExpression:exit"(_node) {
         popFunction();
       },
       ReturnStatement(node) {
-        if (functionStack.length > 1 && isJSX(node.argument) && !isJSXComponentElement(node.argument) && !isSingularJSXReturn(node.argument)) {
+        if (functionStack.length <= 1) {
+          return;
+        }
+        const argument = node.argument;
+        if (!isJSX(argument)) {
+          return;
+        }
+        if (!isJSXComponentElement(argument) && !isSingularJSXReturn(argument)) {
           context.report({
             node,
-            message: "Nested function returning non-component, non-singular JSX detected. Extract it into its own component."
+            messageId: "nestedFunctionJSX"
           });
         }
       },
       "ArrowFunctionExpression > JSXElement"(node) {
-        if (functionStack.length > 1 && !isJSXComponentElement(node) && !isSingularJSXReturn(node)) {
+        if (functionStack.length <= 1) {
+          return;
+        }
+        if (!isJSXComponentElement(node) && !isSingularJSXReturn(node)) {
           context.report({
             node,
-            message: "Nested arrow function returning non-component, non-singular JSX detected. Extract it into its own component."
+            messageId: "nestedArrowJSX"
           });
         }
       },
       "ArrowFunctionExpression > JSXFragment"(node) {
-        if (functionStack.length > 1 && !isSingularJSXReturn(node)) {
+        if (functionStack.length <= 1) {
+          return;
+        }
+        if (!isSingularJSXReturn(node)) {
           context.report({
             node,
-            message: "Nested arrow function returning a non-singular JSX fragment detected. Extract it into its own component."
+            messageId: "nestedArrowFragment"
           });
         }
       }
@@ -108,39 +135,49 @@ var no_nested_jsx_return_default = {
   }
 };
 
-// src/rules/explicit-object-types.js
-var explicit_object_types_default = {
+// 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",
-      recommended: false
+      description: "Require explicit type annotations for object literals and arrays of object literals"
     },
-    schema: []
+    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";
+      return !!node && node.type === "ObjectExpression";
     }
     return {
       VariableDeclarator(node) {
         if (!node.init)
           return;
-        if (node.id && node.id.typeAnnotation)
+        if (node.id.type === "Identifier" && node.id.typeAnnotation)
           return;
         if (isObjectLiteral(node.init)) {
-          context.report({
-            node: node.id,
-            message: "Object literal must have an explicit type annotation."
-          });
+          if (node.id.type === "Identifier") {
+            context.report({
+              node: node.id,
+              messageId: "objectLiteralNeedsType"
+            });
+          }
           return;
         }
         if (node.init.type === "ArrayExpression") {
-          const hasObjectLiteral = node.init.elements.some((element) => element && isObjectLiteral(element));
-          if (hasObjectLiteral) {
+          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({
               node: node.id,
-              message: "Array of object literals must have an explicit type annotation."
+              messageId: "arrayOfObjectLiteralsNeedsType"
             });
           }
         }
@@ -149,13 +186,12 @@ var explicit_object_types_default = {
   }
 };
 
-// src/rules/sort-keys-fixable.js
-var sort_keys_fixable_default = {
+// src/rules/sort-keys-fixable.ts
+var sortKeysFixable = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "enforce sorted keys in object literals with auto-fix (limited to simple cases, preserving comments)",
-      recommended: false
+      description: "enforce sorted keys in object literals with auto-fix (limited to simple cases, preserving comments)"
     },
     fixable: "code",
     schema: [
@@ -163,6 +199,7 @@ var sort_keys_fixable_default = {
         type: "object",
         properties: {
           order: {
+            type: "string",
             enum: ["asc", "desc"]
           },
           caseSensitive: {
@@ -186,14 +223,15 @@ var sort_keys_fixable_default = {
       unsorted: "Object keys are not sorted."
     }
   },
+  defaultOptions: [{}],
   create(context) {
-    const sourceCode = context.getSourceCode();
-    const options = context.options[0] || {};
-    const order = options.order || "asc";
-    const caseSensitive = options.caseSensitive !== undefined ? options.caseSensitive : false;
-    const natural = options.natural !== undefined ? options.natural : false;
-    const minKeys = options.minKeys !== undefined ? options.minKeys : 2;
-    const variablesBeforeFunctions = options.variablesBeforeFunctions !== undefined ? options.variablesBeforeFunctions : false;
+    const sourceCode = context.sourceCode;
+    const option = context.options[0];
+    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;
@@ -202,41 +240,116 @@ var sort_keys_fixable_default = {
         keyB = keyB.toLowerCase();
       }
       if (natural) {
-        return keyA.localeCompare(keyB, undefined, { numeric: true });
+        return keyA.localeCompare(keyB, undefined, {
+          numeric: true
+        });
       }
       return keyA.localeCompare(keyB);
     }
     function isFunctionProperty(prop) {
-      return prop.value && (prop.value.type === "FunctionExpression" || prop.value.type === "ArrowFunctionExpression" || prop.method === true);
+      const value = prop.value;
+      return !!value && (value.type === "FunctionExpression" || value.type === "ArrowFunctionExpression" || prop.method === true);
+    }
+    function getPropertyKeyName(prop) {
+      const key = prop.key;
+      if (key.type === "Identifier") {
+        return key.name;
+      }
+      if (key.type === "Literal") {
+        const value = key.value;
+        if (typeof value === "string") {
+          return value;
+        }
+        return String(value);
+      }
+      return "";
+    }
+    function 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 buildSortedText(fixableProps) {
-      const sorted = fixableProps.slice().sort((a, b) => {
+    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 after;
+    }
+    function 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;
+        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 text = sourceCode.text.slice(chunkStart, fullEnd);
+        chunks.push({ prop, text });
+      }
+      const sorted = chunks.slice().sort((a, b) => {
         if (variablesBeforeFunctions) {
-          const aIsFunc = isFunctionProperty(a);
-          const bIsFunc = isFunctionProperty(b);
+          const aIsFunc = isFunctionProperty(a.prop);
+          const bIsFunc = isFunctionProperty(b.prop);
           if (aIsFunc !== bIsFunc) {
             return aIsFunc ? 1 : -1;
           }
         }
-        const keyA = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
-        const keyB = b.key.type === "Identifier" ? b.key.name : String(b.key.value);
-        let res = compareKeys(keyA, keyB);
+        const aKey = getPropertyKeyName(a.prop);
+        const bKey = getPropertyKeyName(b.prop);
+        let res = compareKeys(aKey, bKey);
         if (order === "desc") {
           res = -res;
         }
         return res;
       });
-      return sorted.map((prop) => {
-        const leadingComments = sourceCode.getCommentsBefore(prop) || [];
-        const trailingComments = sourceCode.getCommentsAfter(prop) || [];
-        const leadingText = leadingComments.length > 0 ? leadingComments.map((comment) => sourceCode.getText(comment)).join(`
-`) + `
-` : "";
-        const trailingText = trailingComments.length > 0 ? `
-` + trailingComments.map((comment) => sourceCode.getText(comment)).join(`
-`) : "";
-        return leadingText + sourceCode.getText(prop) + trailingText;
-      }).join(", ");
+      const firstPropLine = fixableProps[0].loc.start.line;
+      const lastPropLine = fixableProps[fixableProps.length - 1].loc.start.line;
+      const isMultiline = firstPropLine !== lastPropLine;
+      let separator;
+      if (isMultiline) {
+        const col = fixableProps[0].loc.start.column;
+        const indent = sourceCode.text.slice(fixableProps[0].range[0] - col, fixableProps[0].range[0]);
+        separator = `,
+` + indent;
+      } else {
+        separator = ", ";
+      }
+      return sorted.map((chunk, i) => {
+        if (i === 0) {
+          const originalFirstChunk = chunks[0];
+          const originalLeadingWs = originalFirstChunk.text.match(/^(\s*)/)?.[1] ?? "";
+          const stripped2 = chunk.text.replace(/^\s*/, "");
+          return originalLeadingWs + stripped2;
+        }
+        const stripped = chunk.text.replace(/^\s*/, "");
+        return separator + stripped;
+      }).join("");
     }
     function checkObjectExpression(node) {
       if (node.properties.length < minKeys) {
@@ -253,140 +366,171 @@ var sort_keys_fixable_default = {
           if (prop.key.type === "Identifier") {
             keyName = prop.key.name;
           } else if (prop.key.type === "Literal") {
-            keyName = String(prop.key.value);
+            const value = prop.key.value;
+            keyName = typeof value === "string" ? value : String(value);
           } else {
             autoFixable = false;
           }
-          if (prop.value) {
-            if (prop.value.type === "FunctionExpression" || prop.value.type === "ArrowFunctionExpression" || prop.method === true) {
-              isFunc = true;
-            }
+          if (isFunctionProperty(prop)) {
+            isFunc = true;
           }
         } else {
           autoFixable = false;
         }
-        return { keyName, node: prop, isFunction: isFunc };
+        return {
+          keyName,
+          node: prop,
+          isFunction: isFunc
+        };
       });
+      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;
+      };
       let fixProvided = false;
       for (let i = 1;i < keys.length; i++) {
         const prev = keys[i - 1];
         const curr = keys[i];
+        if (!prev || !curr) {
+          continue;
+        }
         if (prev.keyName === null || curr.keyName === null) {
           continue;
         }
+        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) {
-            context.report({
-              node: curr.node.key,
-              messageId: "unsorted",
-              fix: !fixProvided && autoFixable ? (fixer) => {
-                const fixableProps = node.properties.filter((prop) => prop.type === "Property" && !prop.computed && (prop.key.type === "Identifier" || prop.key.type === "Literal") || false);
-                if (fixableProps.length < minKeys) {
-                  return null;
-                }
-                const sortedText = buildSortedText(fixableProps);
-                const firstProp = fixableProps[0];
-                const lastProp = fixableProps[fixableProps.length - 1];
-                return fixer.replaceTextRange([
-                  firstProp.range[0],
-                  lastProp.range[1]
-                ], sortedText);
-              } : null
-            });
-            fixProvided = true;
+            reportWithFix();
             continue;
-          } else if (prev.isFunction === curr.isFunction) {
-            if (compareKeys(prev.keyName, curr.keyName) > 0) {
-              context.report({
-                node: curr.node.key,
-                messageId: "unsorted",
-                fix: !fixProvided && autoFixable ? (fixer) => {
-                  const fixableProps = node.properties.filter((prop) => prop.type === "Property" && !prop.computed && (prop.key.type === "Identifier" || prop.key.type === "Literal") || false);
-                  if (fixableProps.length < minKeys) {
-                    return null;
-                  }
-                  const sortedText = buildSortedText(fixableProps);
-                  const firstProp = fixableProps[0];
-                  const lastProp = fixableProps[fixableProps.length - 1];
-                  return fixer.replaceTextRange([
-                    firstProp.range[0],
-                    lastProp.range[1]
-                  ], sortedText);
-                } : null
-              });
-              fixProvided = true;
-            }
+          }
+          if (prev.isFunction === curr.isFunction && compareKeys(prev.keyName, curr.keyName) > 0) {
+            reportWithFix();
           }
         } else {
           if (compareKeys(prev.keyName, curr.keyName) > 0) {
-            context.report({
-              node: curr.node.key,
-              messageId: "unsorted",
-              fix: !fixProvided && autoFixable ? (fixer) => {
-                const fixableProps = node.properties.filter((prop) => prop.type === "Property" && !prop.computed && (prop.key.type === "Identifier" || prop.key.type === "Literal") || false);
-                if (fixableProps.length < minKeys) {
-                  return null;
-                }
-                const sortedText = buildSortedText(fixableProps);
-                const firstProp = fixableProps[0];
-                const lastProp = fixableProps[fixableProps.length - 1];
-                return fixer.replaceTextRange([
-                  firstProp.range[0],
-                  lastProp.range[1]
-                ], sortedText);
-              } : null
-            });
-            fixProvided = true;
+            reportWithFix();
           }
         }
       }
     }
     function checkJSXAttributeObject(attr) {
-      if (attr.value && attr.value.type === "JSXExpressionContainer" && attr.value.expression && attr.value.expression.type === "ObjectExpression") {
-        checkObjectExpression(attr.value.expression);
+      const value = attr.value;
+      if (value && value.type === "JSXExpressionContainer") {
+        const expr = value.expression;
+        if (expr && expr.type === "ObjectExpression") {
+          checkObjectExpression(expr);
+        }
       }
     }
     function checkJSXOpeningElement(node) {
       const attrs = node.attributes;
-      if (attrs.length < minKeys)
+      if (attrs.length < minKeys) {
         return;
-      if (attrs.some((a) => a.type !== "JSXAttribute"))
+      }
+      if (attrs.some((a) => a.type !== "JSXAttribute")) {
         return;
-      if (attrs.some((a) => a.name.type !== "JSXIdentifier"))
+      }
+      if (attrs.some((a) => a.type === "JSXAttribute" && a.name.type !== "JSXIdentifier")) {
         return;
-      const names = attrs.map((a) => a.name.name);
+      }
+      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);
-        return order === "desc" ? -res : res;
+        if (order === "desc") {
+          res = -res;
+        }
+        return res;
       };
       let outOfOrder = false;
       for (let i = 1;i < names.length; i++) {
-        if (cmp(names[i - 1], names[i]) > 0) {
+        const prevName = names[i - 1];
+        const currName = names[i];
+        if (!prevName || !currName) {
+          continue;
+        }
+        if (cmp(prevName, currName) > 0) {
           outOfOrder = true;
           break;
         }
       }
-      if (!outOfOrder)
+      if (!outOfOrder) {
         return;
+      }
       for (let i = 1;i < attrs.length; i++) {
-        const between = sourceCode.text.slice(attrs[i - 1].range[1], attrs[i].range[0]);
+        const prevAttr = attrs[i - 1];
+        const currAttr = attrs[i];
+        if (!prevAttr || !currAttr) {
+          continue;
+        }
+        const between = sourceCode.text.slice(prevAttr.range[1], currAttr.range[0]);
         if (between.includes("{")) {
           context.report({
-            node: attrs[i].name,
+            node: currAttr.type === "JSXAttribute" ? currAttr.name : currAttr,
             messageId: "unsorted"
           });
           return;
         }
       }
-      const sorted = attrs.slice().sort((a, b) => cmp(a.name.name, b.name.name));
-      const first = attrs[0];
-      const last = attrs[attrs.length - 1];
-      const replacement = sorted.map((a) => sourceCode.getText(a)).join(" ");
+      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 firstAttr = attrs[0];
+      const lastAttr = attrs[attrs.length - 1];
+      if (!firstAttr || !lastAttr) {
+        return;
+      }
+      const replacement = sortedAttrs.map((a) => sourceCode.getText(a)).join(" ");
       context.report({
-        node: first.name,
+        node: firstAttr.type === "JSXAttribute" ? firstAttr.name : firstAttr,
         messageId: "unsorted",
         fix(fixer) {
-          return fixer.replaceTextRange([first.range[0], last.range[1]], replacement);
+          return fixer.replaceTextRange([firstAttr.range[0], lastAttr.range[1]], replacement);
         }
       });
     }
@@ -400,21 +544,21 @@ var sort_keys_fixable_default = {
   }
 };
 
-// src/rules/no-transition-cssproperties.js
-var no_transition_cssproperties_default = {
+// src/rules/no-transition-cssproperties.ts
+var noTransitionCSSProperties = {
   meta: {
     type: "problem",
     docs: {
-      description: "Objects typed as CSSProperties must not include a 'transition' property as it conflicts with react-spring.",
-      recommended: false
+      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.getSourceCode();
+    const sourceCode = context.sourceCode;
     return {
       VariableDeclarator(node) {
         if (!node.id || node.id.type !== "Identifier" || !node.id.typeAnnotation) {
@@ -423,10 +567,10 @@ var no_transition_cssproperties_default = {
         let isStyleType = false;
         const typeAnnotation = node.id.typeAnnotation.typeAnnotation;
         if (typeAnnotation && typeAnnotation.type === "TSTypeReference") {
-          const { typeName } = typeAnnotation;
+          const typeName = typeAnnotation.typeName;
           if (typeName.type === "Identifier" && typeName.name === "CSSProperties") {
             isStyleType = true;
-          } else if (typeName.type === "TSQualifiedName" && typeName.right && typeName.right.name === "CSSProperties") {
+          } else if (typeName.type === "TSQualifiedName" && typeName.right && typeName.right.type === "Identifier" && typeName.right.name === "CSSProperties") {
             isStyleType = true;
           }
         }
@@ -439,80 +583,100 @@ var no_transition_cssproperties_default = {
         if (!isStyleType) {
           return;
         }
-        if (node.init && node.init.type === "ObjectExpression") {
-          node.init.properties.forEach((prop) => {
-            if (prop.type !== "Property") {
-              return;
-            }
-            if (prop.computed) {
-              return;
-            }
-            let keyName = null;
-            if (prop.key.type === "Identifier") {
-              keyName = prop.key.name;
-            } else if (prop.key.type === "Literal") {
+        const init = node.init;
+        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"
-              });
-            }
-          });
+          }
+          if (keyName === "transition") {
+            context.report({
+              node: prop,
+              messageId: "forbiddenTransition"
+            });
+          }
         }
       }
     };
   }
 };
 
-// src/rules/no-explicit-return-types.js
-var no_explicit_return_types_default = {
+// 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).",
-      recommended: false
+      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;
+          }
+        }
+      }
+      return returnCount === 1 && returnedObject !== null;
+    }
     return {
       "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression"(node) {
-        if (node.returnType) {
-          const typeAnnotation = node.returnType.typeAnnotation;
-          if (typeAnnotation && typeAnnotation.type === "TSTypePredicate") {
-            return;
-          }
-          if (node.type === "ArrowFunctionExpression" && node.expression && node.body && node.body.type === "ObjectExpression") {
+        const returnType = node.returnType;
+        if (!returnType) {
+          return;
+        }
+        const typeAnnotation = returnType.typeAnnotation;
+        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") {
-            const returns = node.body.body.filter((stmt) => stmt.type === "ReturnStatement");
-            if (returns.length === 1 && returns[0].argument && returns[0].argument.type === "ObjectExpression") {
-              return;
-            }
-          }
-          context.report({
-            node: node.returnType,
-            messageId: "noExplicitReturnType"
-          });
         }
+        context.report({
+          node: returnType,
+          messageId: "noExplicitReturnType"
+        });
       }
     };
   }
 };
 
-// src/rules/max-jsx-nesting.js
-var max_jsx_nesting_default = {
+// src/rules/max-jsx-nesting.ts
+var maxJSXNesting = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "Warn when JSX elements are nested too deeply, suggesting refactoring into a separate component.",
-      recommended: false
+      description: "Warn when JSX elements are nested too deeply, suggesting refactoring into a separate component."
     },
     schema: [
       {
@@ -524,8 +688,10 @@ var max_jsx_nesting_default = {
       tooDeeplyNested: "JSX element is nested too deeply ({{level}} levels, allowed is {{maxAllowed}} levels). Consider refactoring into a separate component."
     }
   },
+  defaultOptions: [1],
   create(context) {
-    const maxAllowed = context.options[0];
+    const option = context.options[0];
+    const maxAllowed = typeof option === "number" ? option : 1;
     function getJSXNestingLevel(node) {
       let level = 1;
       let current = node.parent;
@@ -552,68 +718,74 @@ var max_jsx_nesting_default = {
   }
 };
 
-// src/rules/seperate-style-files.js
-var seperate_style_files_default = {
+// 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.",
-      recommended: false
+      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.getFilename();
+    const filename = context.filename;
     if (!filename.endsWith(".tsx") && !filename.endsWith(".jsx")) {
       return {};
     }
     return {
       VariableDeclarator(node) {
-        if (!node.id || node.id.type !== "Identifier")
+        if (!node.id || node.id.type !== "Identifier") {
           return;
+        }
         const identifier = node.id;
-        if (!identifier.typeAnnotation)
+        const idTypeAnnotation = identifier.typeAnnotation;
+        if (!idTypeAnnotation || idTypeAnnotation.type !== "TSTypeAnnotation") {
           return;
-        const typeNode = identifier.typeAnnotation.typeAnnotation;
-        if (typeNode.type === "TSTypeReference" && typeNode.typeName) {
-          let typeName = null;
-          if (typeNode.typeName.type === "Identifier") {
-            typeName = typeNode.typeName.name;
-          } else if (typeNode.typeName.type === "TSQualifiedName") {
-            typeName = typeNode.typeName.right.name;
-          }
-          if (typeName === "CSSProperties") {
-            context.report({
-              node,
-              messageId: "moveToFile",
-              data: {
-                name: identifier.name,
-                typeName
-              }
-            });
-          }
+        }
+        const typeNode = idTypeAnnotation.typeAnnotation;
+        if (!typeNode || typeNode.type !== "TSTypeReference") {
+          return;
+        }
+        const typeNameNode = typeNode.typeName;
+        let typeName = null;
+        if (typeNameNode.type === "Identifier") {
+          typeName = typeNameNode.name;
+        } else if (typeNameNode.type === "TSQualifiedName") {
+          const right = typeNameNode.right;
+          typeName = right.name;
+        }
+        if (typeName === "CSSProperties") {
+          context.report({
+            node,
+            messageId: "moveToFile",
+            data: {
+              name: identifier.name,
+              typeName
+            }
+          });
         }
       }
     };
   }
 };
 
-// src/rules/no-unnecessary-key.js
-var no_unnecessary_key_default = {
+// src/rules/no-unnecessary-key.ts
+var noUnnecessaryKey = {
   meta: {
     type: "problem",
     docs: {
-      description: "enforce that the key prop is only used on components rendered as part of a mapping",
-      recommended: false
+      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 ancestors = [];
@@ -625,23 +797,38 @@ var no_unnecessary_key_default = {
       return ancestors;
     }
     function isInsideMapCall(ancestors) {
-      return ancestors.some((node) => {
-        if (node.type === "CallExpression" && node.callee && node.callee.type === "MemberExpression") {
+      for (const node of ancestors) {
+        if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
           const property = node.callee.property;
-          return property.type === "Identifier" && property.name === "map" || property.type === "Literal" && property.value === "map";
+          if (property.type === "Identifier" && property.name === "map") {
+            return true;
+          }
+          if (property.type === "Literal" && property.value === "map") {
+            return true;
+          }
         }
-        return false;
-      });
+      }
+      return false;
     }
     function isReturnedFromFunction(ancestors) {
-      return ancestors.some((node) => node.type === "ReturnStatement");
+      for (const node of ancestors) {
+        if (node.type === "ReturnStatement") {
+          return true;
+        }
+      }
+      return false;
     }
     function checkJSXOpeningElement(node) {
-      const keyAttribute = node.attributes.find((attr) => attr.type === "JSXAttribute" && attr.name && attr.name.name === "key");
+      const keyAttribute = node.attributes.find((attr) => attr.type === "JSXAttribute" && attr.name.type === "JSXIdentifier" && attr.name.name === "key");
       if (!keyAttribute) {
         return;
       }
-      const ancestors = typeof context.getAncestors === "function" ? context.getAncestors() : getAncestors(node);
+      let ancestors;
+      if (typeof context.getAncestors === "function") {
+        ancestors = context.getAncestors();
+      } else {
+        ancestors = getAncestors(node);
+      }
       if (isInsideMapCall(ancestors)) {
         return;
       }
@@ -659,14 +846,12 @@ var no_unnecessary_key_default = {
   }
 };
 
-// src/rules/sort-exports.js
-var sort_exports_default = {
+// src/rules/sort-exports.ts
+var sortExports = {
   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",
-      category: "Stylistic Issues",
-      recommended: false
+      description: "Enforce that top-level export declarations are sorted by exported name and, optionally, that variable exports come before function exports"
     },
     fixable: "code",
     schema: [
@@ -674,6 +859,7 @@ var sort_exports_default = {
         type: "object",
         properties: {
           order: {
+            type: "string",
             enum: ["asc", "desc"]
           },
           caseSensitive: {
@@ -698,14 +884,15 @@ var sort_exports_default = {
       variablesBeforeFunctions: "Non-function exports should come before function exports."
     }
   },
+  defaultOptions: [{}],
   create(context) {
-    const sourceCode = context.getSourceCode();
-    const options = context.options[0] || {};
-    const order = options.order || "asc";
-    const caseSensitive = options.caseSensitive !== undefined ? options.caseSensitive : false;
-    const natural = options.natural !== undefined ? options.natural : false;
-    const minKeys = options.minKeys !== undefined ? options.minKeys : 2;
-    const variablesBeforeFunctions = options.variablesBeforeFunctions !== undefined ? options.variablesBeforeFunctions : false;
+    const sourceCode = context.sourceCode;
+    const option = context.options[0];
+    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*$/, ";");
     }
@@ -716,48 +903,66 @@ var sort_exports_default = {
         strA = strA.toLowerCase();
         strB = strB.toLowerCase();
       }
-      let cmp = natural ? strA.localeCompare(strB, undefined, { numeric: true }) : strA.localeCompare(strB);
+      const cmp = natural ? strA.localeCompare(strB, undefined, { numeric: true }) : strA.localeCompare(strB);
       return order === "asc" ? cmp : -cmp;
     }
     function getExportName(node) {
-      if (node.declaration) {
-        const decl = node.declaration;
-        if (decl.type === "VariableDeclaration") {
-          if (decl.declarations.length === 1) {
-            const id = decl.declarations[0].id;
-            if (id.type === "Identifier") {
-              return id.name;
+      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 (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
-          if (decl.id && decl.id.type === "Identifier") {
-            return decl.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 && node.specifiers.length === 1) {
+      } else if (node.specifiers.length === 1) {
         const spec = node.specifiers[0];
-        return spec.exported.name || spec.exported.value;
+        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) {
-      if (node.declaration) {
-        const decl = node.declaration;
-        if (decl.type === "VariableDeclaration") {
-          if (decl.declarations.length === 1) {
-            const init = decl.declarations[0].init;
-            return init && (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression");
-          }
-        } else if (decl.type === "FunctionDeclaration") {
-          return true;
+      const declaration = node.declaration;
+      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";
+      const kindA = a.node.exportKind ?? "value";
+      const kindB = b.node.exportKind ?? "value";
       if (kindA !== kindB) {
         return kindA === "type" ? -1 : 1;
       }
@@ -768,33 +973,11 @@ var sort_exports_default = {
       }
       return compareStrings(a.name, b.name);
     }
-    function hasForwardDependency(node, laterNames, visited = new WeakSet) {
-      if (!node || typeof node !== "object") {
-        return false;
-      }
-      if (visited.has(node)) {
-        return false;
-      }
-      visited.add(node);
-      if (node.type === "Identifier" && laterNames.has(node.name)) {
-        return true;
-      }
-      for (const key in node) {
-        if (Object.prototype.hasOwnProperty.call(node, key)) {
-          const value = node[key];
-          if (Array.isArray(value)) {
-            for (const element of value) {
-              if (element && typeof element === "object") {
-                if (hasForwardDependency(element, laterNames, visited)) {
-                  return true;
-                }
-              }
-            }
-          } else if (value && typeof value === "object") {
-            if (hasForwardDependency(value, laterNames, visited)) {
-              return true;
-            }
-          }
+    function hasForwardDependency(node, laterNames) {
+      const text = sourceCode.getText(node);
+      for (const name of laterNames) {
+        if (text.includes(name)) {
+          return true;
         }
       }
       return false;
@@ -803,18 +986,19 @@ var sort_exports_default = {
       if (block.length < minKeys) {
         return;
       }
-      const items = block.map((node) => {
+      const items = [];
+      for (const node of block) {
         const name = getExportName(node);
-        if (name === null) {
-          return null;
+        if (!name) {
+          continue;
         }
-        return {
+        items.push({
           name,
           node,
           isFunction: isFunctionExport(node),
           text: sourceCode.getText(node)
-        };
-      }).filter(Boolean);
+        });
+      }
       if (items.length < minKeys) {
         return;
       }
@@ -822,9 +1006,14 @@ var sort_exports_default = {
       let reportNeeded = false;
       let messageId = "alphabetical";
       for (let i = 1;i < items.length; i++) {
-        if (sortComparator(items[i - 1], items[i]) > 0) {
+        const prev = items[i - 1];
+        const current = items[i];
+        if (!prev || !current) {
+          continue;
+        }
+        if (sortComparator(prev, current) > 0) {
           reportNeeded = true;
-          if (variablesBeforeFunctions && items[i - 1].isFunction && !items[i].isFunction) {
+          if (variablesBeforeFunctions && prev.isFunction && !current.isFunction) {
             messageId = "variablesBeforeFunctions";
           }
           break;
@@ -835,66 +1024,85 @@ var sort_exports_default = {
       }
       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 = items[i].node.declaration || items[i].node;
+        const nodeToCheck = item.node.declaration ?? item.node;
         if (hasForwardDependency(nodeToCheck, laterNames)) {
           return;
         }
       }
       const expectedOrder = sortedItems.map((item) => item.name).join(", ");
+      const firstNode = block[0];
+      const lastNode = block[block.length - 1];
+      if (!firstNode || !lastNode) {
+        return;
+      }
       context.report({
-        node: items[0].node,
+        node: firstNode,
         messageId,
         data: {
           expectedOrder
         },
         fix(fixer) {
-          const fixableNodes = block.filter((n) => {
-            if (n.declaration) {
-              if (n.declaration.type === "VariableDeclaration" && n.declaration.declarations.length === 1 && n.declaration.declarations[0].id.type === "Identifier") {
-                return true;
+          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 ((n.declaration.type === "FunctionDeclaration" || n.declaration.type === "ClassDeclaration") && n.declaration.id && n.declaration.id.type === "Identifier") {
-                return true;
+              if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && declaration.id && declaration.id.type === "Identifier") {
+                fixableNodes.push(n);
+                continue;
               }
-              return false;
+              continue;
             }
-            if (n.specifiers && n.specifiers.length === 1) {
-              return true;
+            if (n.specifiers.length === 1) {
+              fixableNodes.push(n);
             }
-            return false;
-          });
+          }
           if (fixableNodes.length < minKeys) {
             return null;
           }
           const sortedText = sortedItems.map((item) => generateExportText(item.node)).join(`
 `);
-          const first = block[0].range[0];
-          const last = block[block.length - 1].range[1];
-          const originalText = sourceCode.getText().slice(first, last);
+          const rangeStart = firstNode.range[0];
+          const rangeEnd = lastNode.range[1];
+          const fullText = sourceCode.getText();
+          const originalText = fullText.slice(rangeStart, rangeEnd);
           if (originalText === sortedText) {
             return null;
           }
-          return fixer.replaceTextRange([first, last], sortedText);
+          return fixer.replaceTextRange([rangeStart, rangeEnd], sortedText);
         }
       });
     }
     return {
       "Program:exit"(node) {
         const body = node.body;
-        let block = [];
+        const block = [];
         for (let i = 0;i < body.length; i++) {
-          const n = body[i];
-          if (n.type === "ExportNamedDeclaration" && !n.source && getExportName(n) !== null) {
-            block.push(n);
+          const stmt = body[i];
+          if (!stmt) {
+            continue;
+          }
+          if (stmt.type === "ExportNamedDeclaration" && !stmt.source && getExportName(stmt) !== null) {
+            block.push(stmt);
           } else {
-            if (block.length) {
+            if (block.length > 0) {
               processExportBlock(block);
-              block = [];
+              block.length = 0;
             }
           }
         }
-        if (block.length) {
+        if (block.length > 0) {
           processExportBlock(block);
         }
       }
@@ -902,47 +1110,73 @@ var sort_exports_default = {
   }
 };
 
-// src/rules/localize-react-props.js
-var localize_react_props_default = {
+// 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.",
-      category: "Best Practices",
-      recommended: false
+      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 getJSXElementName(jsxElement) {
-      if (!jsxElement || !jsxElement.openingElement || !jsxElement.openingElement.name) {
-        return "";
+    function getSingleSetElement(set) {
+      for (const value of set) {
+        return value;
       }
-      const nameNode = jsxElement.openingElement.name;
-      if (nameNode.type === "JSXIdentifier") {
-        return nameNode.name;
+      return null;
+    }
+    function getRightmostJSXIdentifier(name) {
+      let current = name;
+      while (current.type === AST_NODE_TYPES2.JSXMemberExpression) {
+        current = current.property;
       }
-      if (nameNode.type === "JSXMemberExpression") {
-        let current = nameNode;
-        while (current.property) {
-          current = current.property;
-        }
-        if (current && current.type === "JSXIdentifier") {
-          return current.name;
-        }
+      if (current.type === AST_NODE_TYPES2.JSXIdentifier) {
+        return current;
       }
-      return "";
+      return null;
+    }
+    function getLeftmostJSXIdentifier(name) {
+      let current = name;
+      while (current.type === AST_NODE_TYPES2.JSXMemberExpression) {
+        current = current.object;
+      }
+      if (current.type === AST_NODE_TYPES2.JSXIdentifier) {
+        return current;
+      }
+      return null;
+    }
+    function getJSXElementName(jsxElement) {
+      if (!jsxElement || !jsxElement.openingElement || !jsxElement.openingElement.name) {
+        return "";
+      }
+      const nameNode = jsxElement.openingElement.name;
+      if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
+        return nameNode.name;
+      }
+      const rightmost = getRightmostJSXIdentifier(nameNode);
+      if (rightmost) {
+        return rightmost.name;
+      }
+      return "";
     }
     function isUseStateCall(node) {
-      return node && node.type === "CallExpression" && node.callee && (node.callee.type === "Identifier" && node.callee.name === "useState" || node.callee.type === "MemberExpression" && node.callee.property && node.callee.property.name === "useState");
+      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 && node.type === "CallExpression" && node.callee && node.callee.type === "Identifier" && /^use[A-Z]/.test(node.callee.name) && node.callee.name !== "useState";
+      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) {
       let current = node.parent;
       while (current) {
-        if (current.type === "JSXElement") {
+        if (current.type === AST_NODE_TYPES2.JSXElement) {
           return current;
         }
         current = current.parent;
@@ -952,21 +1186,18 @@ var localize_react_props_default = {
     function isContextProviderValueProp(node) {
       let current = node.parent;
       while (current) {
-        if (current.type === "JSXAttribute" && current.name && current.name.name === "value") {
-          if (current.parent && current.parent.type === "JSXOpeningElement") {
+        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 === "JSXIdentifier") {
+            if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
               const tagName = nameNode.name;
               if (tagName.endsWith("Provider") || tagName.endsWith("Context")) {
                 return true;
               }
-            } else if (nameNode.type === "JSXMemberExpression") {
-              let currentMember = nameNode;
-              while (currentMember.type === "JSXMemberExpression") {
-                currentMember = currentMember.property;
-              }
-              if (currentMember && currentMember.type === "JSXIdentifier") {
-                if (currentMember.name.endsWith("Provider") || currentMember.name.endsWith("Context")) {
+            } else {
+              const rightmost = getRightmostJSXIdentifier(nameNode);
+              if (rightmost) {
+                if (rightmost.name.endsWith("Provider") || rightmost.name.endsWith("Context")) {
                   return true;
                 }
               }
@@ -982,120 +1213,105 @@ var localize_react_props_default = {
         return false;
       }
       const nameNode = jsxElement.openingElement.name;
-      if (nameNode.type === "JSXIdentifier") {
+      if (nameNode.type === AST_NODE_TYPES2.JSXIdentifier) {
         return /^[A-Z]/.test(nameNode.name);
       }
-      if (nameNode.type === "JSXMemberExpression") {
-        let current = nameNode;
-        while (current.object) {
-          current = current.object;
-        }
-        return current.type === "JSXIdentifier" && /^[A-Z]/.test(current.name);
+      const leftmost = getLeftmostJSXIdentifier(nameNode);
+      if (leftmost && /^[A-Z]/.test(leftmost.name)) {
+        return true;
       }
       return false;
     }
     function getComponentFunction(node) {
       let current = node;
       while (current) {
-        if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+        if (current.type === AST_NODE_TYPES2.FunctionDeclaration || current.type === AST_NODE_TYPES2.FunctionExpression || current.type === AST_NODE_TYPES2.ArrowFunctionExpression) {
           return current;
         }
         current = current.parent;
       }
       return null;
     }
-    function analyzeVariableUsage(declarationNode, varName, componentFunction) {
-      const usage = { jsxUsageSet: new Set, hasOutsideUsage: false };
-      const sourceCode = context.getSourceCode();
-      const visitorKeys = sourceCode.visitorKeys || {};
-      const stack = [];
-      if (componentFunction.body.type === "BlockStatement") {
-        for (let i = 0;i < componentFunction.body.body.length; i++) {
-          stack.push(componentFunction.body.body[i]);
+    function findVariableForIdentifier(id) {
+      let scope = context.sourceCode.getScope(id);
+      while (scope) {
+        for (const variable of scope.variables) {
+          for (const def of variable.defs) {
+            if (def.name === id) {
+              return variable;
+            }
+          }
         }
-      } else {
-        stack.push(componentFunction.body);
+        scope = scope.upper ?? null;
       }
-      while (stack.length) {
-        const currentNode = stack.pop();
-        if (!currentNode)
+      return null;
+    }
+    function analyzeVariableUsage(declarationId) {
+      const variable = findVariableForIdentifier(declarationId);
+      if (!variable) {
+        return {
+          jsxUsageSet: new Set,
+          hasOutsideUsage: false
+        };
+      }
+      const jsxUsageSet = new Set;
+      let hasOutsideUsage = false;
+      for (const reference of variable.references) {
+        const identifier = reference.identifier;
+        if (identifier === declarationId) {
           continue;
-        if (currentNode.type === "Identifier" && currentNode.name === varName && currentNode !== declarationNode) {
-          if (isContextProviderValueProp(currentNode)) {} else {
-            const jsxAncestor = getJSXAncestor(currentNode);
-            if (jsxAncestor && isCustomJSXElement(jsxAncestor)) {
-              usage.jsxUsageSet.add(jsxAncestor);
-            } else {
-              usage.hasOutsideUsage = true;
-            }
-          }
         }
-        const isFunction = currentNode.type === "FunctionDeclaration" || currentNode.type === "FunctionExpression" || currentNode.type === "ArrowFunctionExpression";
-        if (isFunction && currentNode !== componentFunction) {
-          let shadows = false;
-          if (currentNode.params && currentNode.params.length > 0) {
-            for (let i = 0;i < currentNode.params.length; i++) {
-              const param = currentNode.params[i];
-              if (param.type === "Identifier" && param.name === varName) {
-                shadows = true;
-                break;
-              }
-            }
-          }
-          if (shadows)
-            continue;
+        if (isContextProviderValueProp(identifier)) {
+          continue;
         }
-        const keys = visitorKeys[currentNode.type] || [];
-        for (let i = 0;i < keys.length; i++) {
-          const key = keys[i];
-          const child = currentNode[key];
-          if (Array.isArray(child)) {
-            for (let j = 0;j < child.length; j++) {
-              if (child[j] && typeof child[j].type === "string") {
-                stack.push(child[j]);
-              }
-            }
-          } else if (child && typeof child.type === "string") {
-            stack.push(child);
-          }
+        const jsxAncestor = getJSXAncestor(identifier);
+        if (jsxAncestor && isCustomJSXElement(jsxAncestor)) {
+          jsxUsageSet.add(jsxAncestor);
+        } else {
+          hasOutsideUsage = true;
         }
       }
-      return usage;
+      return {
+        jsxUsageSet,
+        hasOutsideUsage
+      };
     }
     const componentHookVars = new WeakMap;
     function getHookSet(componentFunction) {
-      if (!componentHookVars.has(componentFunction)) {
-        componentHookVars.set(componentFunction, new Set);
+      let hookSet = componentHookVars.get(componentFunction);
+      if (!hookSet) {
+        hookSet = new Set;
+        componentHookVars.set(componentFunction, hookSet);
       }
-      return componentHookVars.get(componentFunction);
+      return hookSet;
     }
     function hasHookDependency(node, hookSet) {
-      const sourceCode = context.getSourceCode();
-      const visitorKeys = sourceCode.visitorKeys || {};
-      const stack = [node];
-      while (stack.length) {
-        const currentNode = stack.pop();
-        if (!currentNode)
-          continue;
-        if (currentNode.type === "Identifier") {
-          if (hookSet.has(currentNode.name)) {
-            return true;
+      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;
           }
-        }
-        const keys = visitorKeys[currentNode.type] || [];
-        for (let i = 0;i < keys.length; i++) {
-          const key = keys[i];
-          const child = currentNode[key];
-          if (Array.isArray(child)) {
-            for (let j = 0;j < child.length; j++) {
-              if (child[j] && typeof child[j].type === "string") {
-                stack.push(child[j]);
-              }
+          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;
             }
-          } else if (child && typeof child.type === "string") {
-            stack.push(child);
           }
         }
+        scope = scope.upper ?? null;
       }
       return false;
     }
@@ -1104,30 +1320,34 @@ var localize_react_props_default = {
         const componentFunction = getComponentFunction(node);
         if (!componentFunction || !componentFunction.body)
           return;
-        if (node.init && node.id && node.id.type === "Identifier" && node.init.type === "CallExpression" && isHookCall(node.init)) {
+        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 === "ArrayPattern" && node.id.elements.length >= 2) {
+        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 !== "Identifier" || !setterElem || setterElem.type !== "Identifier") {
+          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, stateVarName, componentFunction);
-          const setterUsage = analyzeVariableUsage(setterElem, setterVarName, componentFunction);
+          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 && [...stateUsage.jsxUsageSet][0] === [...setterUsage.jsxUsageSet][0]) {
-            context.report({
-              node,
-              message: "State variable '{{stateVarName}}' and its setter '{{setterVarName}}' are only passed to a single custom child component. Consider moving the state into that component.",
-              data: { stateVarName, setterVarName }
-            });
+          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 === "Identifier") {
+        } else if (node.id && node.id.type === AST_NODE_TYPES2.Identifier) {
           const varName = node.id.name;
           if (node.init) {
             const hookSet = getHookSet(componentFunction);
@@ -1135,9 +1355,9 @@ var localize_react_props_default = {
               return;
             }
           }
-          const usage = analyzeVariableUsage(node.id, varName, componentFunction);
+          const usage = analyzeVariableUsage(node.id);
           if (!usage.hasOutsideUsage && usage.jsxUsageSet.size === 1) {
-            const target = [...usage.jsxUsageSet][0];
+            const target = getSingleSetElement(usage.jsxUsageSet);
             const componentName = getJSXElementName(target);
             candidateVariables.push({
               node,
@@ -1149,244 +1369,367 @@ var localize_react_props_default = {
       },
       "Program:exit"() {
         const groups = new Map;
-        candidateVariables.forEach((candidate) => {
+        for (const candidate of candidateVariables) {
           const key = candidate.componentName;
-          if (!groups.has(key)) {
-            groups.set(key, []);
+          const existing = groups.get(key);
+          if (existing) {
+            existing.push(candidate);
+          } else {
+            groups.set(key, [candidate]);
           }
-          groups.get(key).push(candidate);
-        });
-        groups.forEach((candidates) => {
+        }
+        for (const candidates of groups.values()) {
           if (candidates.length === 1) {
             const candidate = candidates[0];
+            if (!candidate) {
+              continue;
+            }
             context.report({
               node: candidate.node,
-              message: "Variable '{{varName}}' is only passed to a single custom child component. Consider moving it to that component.",
+              messageId: "variableToChild",
               data: { varName: candidate.varName }
             });
           }
-        });
+        }
       }
     };
   }
 };
 
-// src/rules/no-or-none-component.js
-var no_or_none_component_default = {
+// 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.",
-      recommended: false
+      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;
-        if (alternate && (alternate.type === "Literal" && alternate.value === null || alternate.type === "Identifier" && alternate.name === "undefined")) {
-          if (node.parent && node.parent.type === "JSXExpressionContainer") {
-            const containerParent = node.parent.parent;
-            if (containerParent && containerParent.type !== "JSXAttribute") {
-              context.report({
-                node,
-                messageId: "useLogicalAnd"
-              });
-            }
-          }
+        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;
+        if (!parent || parent.type !== "JSXExpressionContainer") {
+          return;
+        }
+        const containerParent = parent.parent;
+        if (containerParent && containerParent.type !== "JSXAttribute") {
+          context.report({
+            node,
+            messageId: "useLogicalAnd"
+          });
         }
       }
     };
   }
 };
 
-// src/rules/no-button-navigation.js
-var no_button_navigation_default = {
+// 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).",
-      category: "Best Practices",
-      recommended: false
+      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: []
+    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) {
-    function urlUsesAllowedLocation(argNode) {
-      let allowed = false;
-      const visited = new WeakSet;
-      function check(n) {
-        if (allowed || !n || typeof n !== "object" || visited.has(n))
+    const handlerStack = [];
+    function getCurrentHandler() {
+      const state = handlerStack[handlerStack.length - 1];
+      if (!state) {
+        return null;
+      }
+      return state;
+    }
+    function isOnClickButtonHandler(node) {
+      const parent = node.parent;
+      if (!parent || parent.type !== "JSXExpressionContainer") {
+        return null;
+      }
+      const attributeCandidate = parent.parent;
+      if (!attributeCandidate || attributeCandidate.type !== "JSXAttribute") {
+        return null;
+      }
+      const attr = attributeCandidate;
+      if (!attr.name || attr.name.type !== "JSXIdentifier" || attr.name.name !== "onClick") {
+        return null;
+      }
+      const openingElementCandidate = attr.parent;
+      if (!openingElementCandidate || openingElementCandidate.type !== "JSXOpeningElement") {
+        return null;
+      }
+      const openingElement = openingElementCandidate;
+      const tagNameNode = openingElement.name;
+      if (tagNameNode.type !== "JSXIdentifier" || tagNameNode.name !== "button") {
+        return null;
+      }
+      return attr;
+    }
+    function isWindowLocationMember(member) {
+      const object = member.object;
+      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;
+      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 false;
+    }
+    return {
+      ArrowFunctionExpression(node) {
+        const attr = isOnClickButtonHandler(node);
+        if (!attr) {
           return;
-        visited.add(n);
-        if (n.type === "MemberExpression" && n.object.type === "MemberExpression" && n.object.object.type === "Identifier" && n.object.object.name === "window" && n.object.property.type === "Identifier" && n.object.property.name === "location" && n.property.type === "Identifier" && (n.property.name === "pathname" || n.property.name === "search" || n.property.name === "hash")) {
-          allowed = true;
+        }
+        handlerStack.push({
+          attribute: attr,
+          reason: null,
+          sawReplaceCall: false,
+          sawAllowedLocationRead: false
+        });
+      },
+      "ArrowFunctionExpression:exit"(node) {
+        const attr = isOnClickButtonHandler(node);
+        if (!attr) {
           return;
         }
-        for (const key of Object.keys(n)) {
-          if (key === "parent")
-            continue;
-          const child = n[key];
-          if (Array.isArray(child)) {
-            child.forEach((c) => check(c));
-          } else {
-            check(child);
-          }
+        const state = handlerStack.pop();
+        if (!state) {
+          return;
         }
-      }
-      check(argNode);
-      return allowed;
-    }
-    function containsWindowNavigation(node) {
-      let reason = null;
-      const visited = new WeakSet;
-      let sawReplaceCall = false;
-      let sawAllowedLocationRead = false;
-      function inspect(n, parent) {
-        if (reason || !n || typeof n !== "object" || visited.has(n))
+        const reason = state.reason;
+        const sawReplaceCall = state.sawReplaceCall;
+        const sawAllowedLocationRead = state.sawAllowedLocationRead;
+        if (reason) {
+          context.report({
+            node: state.attribute,
+            messageId: "noButtonNavigation",
+            data: { reason }
+          });
           return;
-        visited.add(n);
-        if (n.type === "MemberExpression" && n.object.type === "Identifier" && n.object.name === "window" && n.property.type === "Identifier" && n.property.name === "open") {
-          reason = "window.open";
+        }
+        if (sawReplaceCall && !sawAllowedLocationRead) {
+          context.report({
+            node: state.attribute,
+            messageId: "noButtonNavigation",
+            data: {
+              reason: "history.replaceState/pushState without reading window.location"
+            }
+          });
+        }
+      },
+      FunctionExpression(node) {
+        const attr = isOnClickButtonHandler(node);
+        if (!attr) {
           return;
         }
-        if (n.type === "AssignmentExpression" && n.left.type === "MemberExpression") {
-          const left = n.left;
-          if (left.object.type === "Identifier" && left.object.name === "window" && left.property.type === "Identifier" && left.property.name === "location") {
-            reason = "assignment to window.location";
-            return;
+        handlerStack.push({
+          attribute: attr,
+          reason: null,
+          sawReplaceCall: false,
+          sawAllowedLocationRead: false
+        });
+      },
+      "FunctionExpression:exit"(node) {
+        const attr = isOnClickButtonHandler(node);
+        if (!attr) {
+          return;
+        }
+        const state = handlerStack.pop();
+        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"
+            }
+          });
+        }
+      },
+      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 (left.object.type === "MemberExpression" && left.object.object.type === "Identifier" && left.object.object.name === "window" && left.object.property.type === "Identifier" && left.object.property.name === "location") {
-            reason = "assignment to window.location sub-property";
-            return;
+        }
+        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 (n.type === "MemberExpression" && n.object.type === "MemberExpression" && n.object.object.type === "Identifier" && n.object.object.name === "window" && n.object.property.type === "Identifier" && n.object.property.name === "location" && n.property.type === "Identifier" && n.property.name === "replace") {
-          if (parent && parent.type === "CallExpression") {
-            reason = "window.location.replace";
-            return;
+        if (isWindowLocationMember(left)) {
+          if (!state.reason) {
+            state.reason = "assignment to window.location sub-property";
           }
         }
-        if (n.type === "MemberExpression" && n.object.type === "MemberExpression" && n.object.object.type === "Identifier" && n.object.object.name === "window" && n.object.property.type === "Identifier" && n.object.property.name === "history" && n.property.type === "Identifier" && (n.property.name === "pushState" || n.property.name === "replaceState")) {
-          sawReplaceCall = true;
+      },
+      CallExpression(node) {
+        const state = getCurrentHandler();
+        if (!state) {
+          return;
         }
-        if (n.type === "MemberExpression" && n.object.type === "MemberExpression" && n.object.object.type === "Identifier" && n.object.object.name === "window" && n.object.property.type === "Identifier" && n.object.property.name === "location" && n.property.type === "Identifier" && (n.property.name === "search" || n.property.name === "pathname" || n.property.name === "hash")) {
-          sawAllowedLocationRead = true;
+        const callee = node.callee;
+        if (callee.type !== "MemberExpression") {
+          return;
         }
-        for (const key of Object.keys(n)) {
-          if (key === "parent" || reason)
-            continue;
-          const child = n[key];
-          if (Array.isArray(child)) {
-            child.forEach((c) => inspect(c, n));
-          } else {
-            inspect(child, n);
+        if (isWindowLocationMember(callee) && callee.property.type === "Identifier" && callee.property.name === "replace") {
+          if (!state.reason) {
+            state.reason = "window.location.replace";
           }
-          if (reason)
-            return;
+          return;
         }
-      }
-      inspect(node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" ? node.body : node, null);
-      if (reason) {
-        return { shouldReport: true, reason };
-      }
-      if (sawReplaceCall && !sawAllowedLocationRead) {
-        return {
-          shouldReport: true,
-          reason: "history.replace/pushState without reading window.location"
-        };
-      }
-      return { shouldReport: false, reason: null };
-    }
-    return {
-      JSXElement(node) {
-        const { openingElement } = node;
-        if (openingElement.name.type === "JSXIdentifier" && openingElement.name.name === "button") {
-          for (const attr of openingElement.attributes) {
-            if (attr.type === "JSXAttribute" && attr.name.name === "onClick" && attr.value?.type === "JSXExpressionContainer") {
-              const expr = attr.value.expression;
-              if (expr.type === "ArrowFunctionExpression" || expr.type === "FunctionExpression") {
-                const { shouldReport, reason } = containsWindowNavigation(expr);
-                if (shouldReport) {
-                  context.report({
-                    node: attr,
-                    message: `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.`
-                  });
-                }
-              }
-            }
-          }
+        if (isWindowHistoryMember(callee) && callee.property.type === "Identifier" && (callee.property.name === "pushState" || callee.property.name === "replaceState")) {
+          state.sawReplaceCall = true;
         }
       }
     };
   }
 };
 
-// src/rules/no-multi-style-objects.js
-var no_multi_style_objects_default = {
+// src/rules/no-multi-style-objects.ts
+var noMultiStyleObjects = {
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow grouping CSS style objects in a single export; export each style separately.",
-      category: "Best Practices",
-      recommended: false
+      description: "Disallow grouping CSS style objects in a single export; export each style separately."
     },
-    schema: []
+    schema: [],
+    messages: {
+      noMultiStyleObjects: "Do not group CSS style objects in a single export; export each style separately."
+    }
   },
+  defaultOptions: [],
   create(context) {
     function checkObjectExpression(node) {
-      if (node.properties && node.properties.length > 0) {
-        const cssStyleProperties = node.properties.filter((prop) => {
-          if (prop.key) {
-            if (prop.key.type === "Identifier") {
-              return prop.key.name.endsWith("Style");
-            }
-            if (prop.key.type === "Literal" && typeof prop.key.value === "string") {
-              return prop.key.value.endsWith("Style");
-            }
-          }
-          return false;
-        });
-        if (cssStyleProperties.length > 1) {
-          context.report({
-            node,
-            message: "Do not group CSS style objects in a single export; export each style separately."
-          });
+      if (!node.properties.length) {
+        return;
+      }
+      const cssStyleProperties = [];
+      for (const prop of node.properties) {
+        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);
         }
       }
+      if (cssStyleProperties.length > 1) {
+        context.report({
+          node,
+          messageId: "noMultiStyleObjects"
+        });
+      }
     }
     return {
       ExportDefaultDeclaration(node) {
-        if (node.declaration && node.declaration.type === "ObjectExpression") {
-          checkObjectExpression(node.declaration);
+        const declaration = node.declaration;
+        if (declaration && declaration.type === "ObjectExpression") {
+          checkObjectExpression(declaration);
         }
       },
       ReturnStatement(node) {
-        if (node.argument && node.argument.type === "ObjectExpression") {
-          checkObjectExpression(node.argument);
+        const argument = node.argument;
+        if (argument && argument.type === "ObjectExpression") {
+          checkObjectExpression(argument);
         }
       }
     };
   }
 };
 
-// src/rules/no-useless-function.js
-var no_useless_function_default = {
+// 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).",
-      category: "Best Practices",
-      recommended: false
+      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)."
     },
-    fixable: null
+    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) {
-      return node.parent && node.parent.type === "CallExpression" && node.parent.arguments.includes(node);
+      const parent = node.parent;
+      if (!parent || parent.type !== "CallExpression") {
+        return false;
+      }
+      for (const arg of parent.arguments) {
+        if (arg === node) {
+          return true;
+        }
+      }
+      return false;
     }
     return {
       ArrowFunctionExpression(node) {
@@ -1396,7 +1739,7 @@ var no_useless_function_default = {
           }
           context.report({
             node,
-            message: "This function has no parameters and simply returns an object. Consider exporting the object directly instead of wrapping it in a function."
+            messageId: "uselessFunction"
           });
         }
       }
@@ -1404,13 +1747,12 @@ var no_useless_function_default = {
   }
 };
 
-// src/rules/min-var-length.js
-var min_var_length_default = {
+// src/rules/min-var-length.ts
+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.",
-      recommended: false
+      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: [
       {
@@ -1436,11 +1778,14 @@ var min_var_length_default = {
       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.getSourceCode();
-    const options = context.options[0] || {};
-    const minLength = typeof options.minLength === "number" ? options.minLength : 1;
-    const allowedVars = options.allowedVars || [];
+    const sourceCode = context.sourceCode;
+    const options = context.options[0];
+    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 ancestors = [];
       let current = node.parent;
@@ -1451,7 +1796,15 @@ var min_var_length_default = {
       return ancestors;
     }
     function getScope(node) {
-      return sourceCode.scopeManager.acquire(node) || sourceCode.scopeManager.globalScope;
+      const scopeManager = sourceCode.scopeManager;
+      if (!scopeManager) {
+        return null;
+      }
+      const acquired = scopeManager.acquire(node);
+      if (acquired) {
+        return acquired;
+      }
+      return scopeManager.globalScope ?? null;
     }
     function getVariablesInNearestBlock(node) {
       let current = node.parent;
@@ -1459,7 +1812,7 @@ var min_var_length_default = {
         current = current.parent;
       }
       const names = [];
-      if (current && Array.isArray(current.body)) {
+      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) {
@@ -1490,8 +1843,9 @@ var min_var_length_default = {
           break;
         case "ArrayPattern":
           for (const element of pattern.elements) {
-            if (element)
+            if (element) {
               extractIdentifiersFromPattern(element, identifiers);
+            }
           }
           break;
         case "AssignmentPattern":
@@ -1503,8 +1857,8 @@ var min_var_length_default = {
       return identifiers;
     }
     function hasOuterCorrespondingIdentifier(shortName, node) {
-      let currentScope = getScope(node);
-      let outer = currentScope.upper;
+      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)) {
@@ -1550,7 +1904,7 @@ var min_var_length_default = {
     }
     function checkIdentifier(node) {
       const name = node.name;
-      if (typeof name === "string" && name.length < minLength) {
+      if (name.length < minLength) {
         if (allowedVars.includes(name)) {
           return;
         }
@@ -1581,8 +1935,9 @@ var min_var_length_default = {
           break;
         case "ArrayPattern":
           for (const element of pattern.elements) {
-            if (element)
+            if (element) {
               checkPattern(element);
+            }
           }
           break;
         case "AssignmentPattern":
@@ -1612,23 +1967,26 @@ var min_var_length_default = {
   }
 };
 
-// src/rules/max-depth-extended.js
-var max_depth_extended_default = {
+// src/rules/max-depth-extended.ts
+var maxDepthExtended = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "disallow too many nested blocks except when the block only contains an early exit (return or throw)",
-      category: "Best Practices",
-      recommended: false
+      description: "disallow too many nested blocks except when the block only contains an early exit (return or throw)"
     },
     schema: [
       {
         type: "number"
       }
-    ]
+    ],
+    messages: {
+      tooDeep: "Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}} or an early exit."
+    }
   },
+  defaultOptions: [1],
   create(context) {
-    const maxDepth = typeof context.options[0] === "number" ? context.options[0] : 1;
+    const option = context.options[0];
+    const maxDepth = typeof option === "number" ? option : 1;
     const functionStack = [];
     function getAncestors(node) {
       const ancestors = [];
@@ -1640,13 +1998,44 @@ var max_depth_extended_default = {
       return ancestors;
     }
     function isEarlyExitBlock(node) {
-      return node.body.length === 1 && (node.body[0].type === "ReturnStatement" || node.body[0].type === "ThrowStatement");
+      if (node.body.length !== 1) {
+        return false;
+      }
+      const first = node.body[0];
+      if (!first) {
+        return false;
+      }
+      return first.type === "ReturnStatement" || first.type === "ThrowStatement";
+    }
+    function incrementCurrentDepth() {
+      if (functionStack.length === 0) {
+        return null;
+      }
+      const index = functionStack.length - 1;
+      const currentDepth = functionStack[index];
+      if (typeof currentDepth !== "number") {
+        return null;
+      }
+      const nextDepth = currentDepth + 1;
+      functionStack[index] = nextDepth;
+      return nextDepth;
+    }
+    function decrementCurrentDepth() {
+      if (functionStack.length === 0) {
+        return;
+      }
+      const index = functionStack.length - 1;
+      const currentDepth = functionStack[index];
+      if (typeof currentDepth !== "number") {
+        return;
+      }
+      functionStack[index] = currentDepth - 1;
     }
     function checkDepth(node, depth) {
       if (depth > maxDepth) {
         context.report({
           node,
-          message: "Blocks are nested too deeply ({{depth}}). Maximum allowed is {{maxDepth}} or an early exit.",
+          messageId: "tooDeep",
           data: { depth, maxDepth }
         });
       }
@@ -1663,30 +2052,28 @@ var max_depth_extended_default = {
       },
       BlockStatement(node) {
         const ancestors = getAncestors(node);
-        const parent = ancestors[0];
+        const parent = ancestors.length > 0 ? ancestors[0] : undefined;
         if (parent && (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && node === parent.body) {
           return;
         }
         if (isEarlyExitBlock(node)) {
           return;
         }
-        if (functionStack.length > 0) {
-          functionStack[functionStack.length - 1]++;
-          checkDepth(node, functionStack[functionStack.length - 1]);
+        const depth = incrementCurrentDepth();
+        if (depth !== null) {
+          checkDepth(node, depth);
         }
       },
       "BlockStatement:exit"(node) {
         const ancestors = getAncestors(node);
-        const parent = ancestors[0];
+        const parent = ancestors.length > 0 ? ancestors[0] : undefined;
         if (parent && (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && node === parent.body) {
           return;
         }
         if (isEarlyExitBlock(node)) {
           return;
         }
-        if (functionStack.length > 0) {
-          functionStack[functionStack.length - 1]--;
-        }
+        decrementCurrentDepth();
       },
       "FunctionDeclaration:exit"() {
         functionStack.pop();
@@ -1701,88 +2088,103 @@ var max_depth_extended_default = {
   }
 };
 
-// src/rules/spring-naming-convention.js
-var spring_naming_convention_default = {
+// src/rules/spring-naming-convention.ts
+var springNamingConvention = {
   meta: {
     type: "problem",
     docs: {
-      description: "Enforce correct naming for useSpring and useSprings hook destructuring",
-      category: "Stylistic Issues",
-      recommended: false
+      description: "Enforce correct naming for useSpring and useSprings hook destructuring"
     },
-    schema: []
+    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) {
-        if (node.init && node.init.type === "CallExpression" && node.init.callee && node.init.callee.type === "Identifier" && (node.init.callee.name === "useSpring" || node.init.callee.name === "useSprings")) {
-          const hookName = node.init.callee.name;
-          if (node.id && node.id.type === "ArrayPattern") {
-            const elements = node.id.elements;
-            if (elements.length < 2) {
-              return;
-            }
-            const firstElem = elements[0];
-            const secondElem = elements[1];
-            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,
-                  message: "The first variable from useSpring must end with 'Springs'."
-                });
-              } else {
-                const base = firstName.slice(0, -"Springs".length);
-                if (!base) {
-                  context.report({
-                    node: firstElem,
-                    message: "The first variable must have a non-empty name before 'Springs'."
-                  });
-                  return;
-                }
-                const expectedSecond = base + "Api";
-                if (secondName !== expectedSecond) {
-                  context.report({
-                    node: secondElem,
-                    message: `The second variable from useSpring must be named '${expectedSecond}'.`
-                  });
-                }
-              }
-            } else if (hookName === "useSprings") {
-              if (!firstName.endsWith("Springs")) {
-                context.report({
-                  node: firstElem,
-                  message: "The first variable from useSprings must end with 'Springs'."
-                });
-              } else {
-                const basePlural = firstName.slice(0, -"Springs".length);
-                if (!basePlural) {
-                  context.report({
-                    node: firstElem,
-                    message: "The first variable must have a non-empty name before 'Springs'."
-                  });
-                  return;
-                }
-                if (!basePlural.endsWith("s")) {
-                  context.report({
-                    node: firstElem,
-                    message: "The first variable for useSprings should be a plural name (ending with an 's') before 'Springs'."
-                  });
-                } else {
-                  const expectedSecond = basePlural + "Api";
-                  if (secondName !== expectedSecond) {
-                    context.report({
-                      node: secondElem,
-                      message: `The second variable from useSprings must be named '${expectedSecond}'.`
-                    });
-                  }
-                }
-              }
-            }
+        const init = node.init;
+        if (!init || init.type !== "CallExpression" || init.callee.type !== "Identifier") {
+          return;
+        }
+        const hookName = init.callee.name;
+        if (hookName !== "useSpring" && hookName !== "useSprings") {
+          return;
+        }
+        if (node.id.type !== "ArrayPattern") {
+          return;
+        }
+        const elements = node.id.elements;
+        if (elements.length < 2) {
+          return;
+        }
+        const firstElem = elements[0];
+        const secondElem = elements[1];
+        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 }
+            });
+          }
+          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 }
+            });
           }
         }
       }
@@ -1790,14 +2192,12 @@ var spring_naming_convention_default = {
   }
 };
 
-// src/rules/inline-style-limit.js
-var inline_style_limit_default = {
+// src/rules/inline-style-limit.ts
+var inlineStyleLimit = {
   meta: {
     type: "suggestion",
     docs: {
-      description: "Disallow inline style objects with too many keys and encourage extracting them",
-      category: "Best Practices",
-      recommended: false
+      description: "Disallow inline style objects with too many keys and encourage extracting them"
     },
     schema: [
       {
@@ -1822,12 +2222,13 @@ var inline_style_limit_default = {
       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.name !== "style") {
+        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") {
@@ -1846,23 +2247,22 @@ var inline_style_limit_default = {
   }
 };
 
-// src/rules/no-inline-prop-types.js
-var no_inline_prop_types_default = {
+// 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.",
-      category: "Best Practices",
-      recommended: false
+      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 && param.type === "ObjectPattern" && param.typeAnnotation && param.typeAnnotation.type === "TSTypeAnnotation") {
+      if (param.type === "ObjectPattern" && param.typeAnnotation && param.typeAnnotation.type === "TSTypeAnnotation") {
         const annotation = param.typeAnnotation.typeAnnotation;
         if (annotation.type === "TSTypeLiteral") {
           context.report({
@@ -1874,70 +2274,98 @@ var no_inline_prop_types_default = {
     }
     return {
       "FunctionDeclaration, ArrowFunctionExpression, FunctionExpression"(node) {
+        if (node.params.length === 0) {
+          return;
+        }
         const firstParam = node.params[0];
-        if (firstParam) {
-          checkParameter(firstParam);
+        if (!firstParam) {
+          return;
         }
+        checkParameter(firstParam);
       }
     };
   }
 };
 
-// src/rules/no-unnecessary-div.js
-var no_unnecessary_div_default = {
+// 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.",
-      category: "Best Practices",
-      recommended: false
+      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 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);
+        }
+      }
+      return result;
+    }
     return {
       JSXElement(node) {
-        if (node.openingElement.name && node.openingElement.name.name === "div") {
-          const meaningfulChildren = node.children.filter((child) => {
-            if (child.type === "JSXText") {
-              return child.value.trim() !== "";
-            }
-            return true;
+        if (!isDivElement(node)) {
+          return;
+        }
+        const meaningfulChildren = getMeaningfulChildren(node);
+        if (meaningfulChildren.length !== 1) {
+          return;
+        }
+        const onlyChild = meaningfulChildren[0];
+        if (!onlyChild) {
+          return;
+        }
+        if (onlyChild.type === AST_NODE_TYPES3.JSXElement) {
+          context.report({
+            node,
+            messageId: "unnecessaryDivWrapper"
           });
-          if (meaningfulChildren.length === 1 && meaningfulChildren[0].type === "JSXElement") {
-            context.report({
-              node,
-              message: "Unnecessary <div> wrapper detected. Remove it if not needed, or replace with a semantic element that reflects its purpose."
-            });
-          }
         }
       }
     };
   }
 };
 
-// src/index.js
+// src/index.ts
 var src_default = {
   rules: {
-    "no-nested-jsx-return": no_nested_jsx_return_default,
-    "explicit-object-types": explicit_object_types_default,
-    "sort-keys-fixable": sort_keys_fixable_default,
-    "no-transition-cssproperties": no_transition_cssproperties_default,
-    "no-explicit-return-type": no_explicit_return_types_default,
-    "max-jsxnesting": max_jsx_nesting_default,
-    "seperate-style-files": seperate_style_files_default,
-    "no-unnecessary-key": no_unnecessary_key_default,
-    "sort-exports": sort_exports_default,
-    "localize-react-props": localize_react_props_default,
-    "no-or-none-component": no_or_none_component_default,
-    "no-button-navigation": no_button_navigation_default,
-    "no-multi-style-objects": no_multi_style_objects_default,
-    "no-useless-function": no_useless_function_default,
-    "min-var-length": min_var_length_default,
-    "max-depth-extended": max_depth_extended_default,
-    "spring-naming-convention": spring_naming_convention_default,
-    "inline-style-limit": inline_style_limit_default,
-    "no-inline-prop-types": no_inline_prop_types_default,
-    "no-unnecessary-div": no_unnecessary_div_default
+    "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,
+    "localize-react-props": localizeReactProps,
+    "no-or-none-component": noOrNoneComponent,
+    "no-button-navigation": noButtonNavigation,
+    "no-multi-style-objects": noMultiStyleObjects,
+    "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
   }
 };
 export {