@sarj/eslint-plugin 7.0.0 → 7.1.0

package/dist/index.cjs

@@ -5032,29 +5032,61 @@ var no_trailing_value_narration_default = createRule({
   }
 });
 
-// src/rules/no-type-member-comment-wall.ts
+// src/rules/no-declaration-comment-wall.ts
+var import_utils35 = require("@typescript-eslint/utils");
+
+// src/rules/_comment-wall.ts
 var import_utils34 = require("@typescript-eslint/utils");
-var DEFAULTS = {
+var WALL_DEFAULTS = {
   // Below three rows "a wall" is not a fair description of what the reader sees.
   minCommentedMembers: 3,
   // A minority of commented members is a GROUP LABEL, not a wall.
   minCommentedRatio: 0.6,
-  // Room for one substantive row in four; a type where a quarter of the comments
-  // say something real is a type someone was documenting, not decorating.
+  // Room for one substantive row in four; a declaration where a quarter of the
+  // comments say something real is one someone was documenting, not decorating.
   minRestatedRatio: 0.75,
-  // One word beyond the member's own text. Zero is `no-restated-jsdoc`'s
-  // test and is already covered there; two admits definitions ("Partial match"
-  // beside "Exact match"), which the evidence file counts.
+  // One word beyond the member's own text. Zero is `no-restated-jsdoc`'s test
+  // and is already covered there; two admits definitions ("Partial match"
+  // beside "Exact match").
   maxNovelWords: 1
 };
+var WALL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    minCommentedMembers: {
+      type: "integer",
+      minimum: 2,
+      description: "Fewest commented members that can count as a wall."
+    },
+    minCommentedRatio: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      description: "Least share of the members that must be commented; below it the comments are group labels."
+    },
+    minRestatedRatio: {
+      type: "number",
+      minimum: 0,
+      maximum: 1,
+      description: "Least share of the member comments that must be restatements."
+    },
+    maxNovelWords: {
+      type: "integer",
+      minimum: 0,
+      description: "Most content words a comment may add beyond its member's own source and still count as a restatement."
+    }
+  }
+};
 var VALUE_TAG_RE = /@(?:deprecated|see|example|throws|remarks|since|default|defaultvalue|link|internal|alpha|beta|experimental|template|typeparam|inheritdoc|todo|fixme|override)\b/i;
 var DEFAULT_RE = /^\s*@?default\b|\bdefaults? (?:to|:)/i;
 var DIGIT_RE = /\d/;
 var UNIT_WORD_RE = /\b(?:ms|milliseconds?|seconds?|minutes?|hours?|days?|weeks?|months?|years?|bytes?|kb|mb|gb|percent|pixels?|px|utc|epoch)\b/i;
 var EXAMPLE_RE = /["'`]|\be\.g\.|\bi\.e\./;
+var TAG_TOKEN_RE = /@\w+/g;
 var BANNER_RE = /[=\-─-╿*#~_.]{3,}/;
 var NON_ASCII_LETTER_RE2 = /[^\p{ASCII}\p{N}\p{P}\p{Z}]/u;
-var STOPWORDS4 = new Set(
+var WALL_STOPWORDS = new Set(
   `the a an of to for in on with and or as at by is are was be been being
    this that it its if whether when where which what will would can could should
    must may into from over about not no does do done has have had used use uses
@@ -5069,15 +5101,22 @@ var BARE_LABEL_RE = /^[A-Za-z][A-Za-z0-9]*$/;
 function labelStems(body) {
   return splitIdentifier(body).map(stem).join(" ");
 }
-function isNamedMember(node) {
-  return (node.type === import_utils34.AST_NODE_TYPES.TSPropertySignature || node.type === import_utils34.AST_NODE_TYPES.TSMethodSignature) && !node.computed;
-}
 function commentBody(comment) {
   return comment.value.replace(/^\*+/, "").replace(/^[ \t]*\*[ \t]?/gm, "").trim();
 }
 function carriesValue(body) {
   return isProtected(body) || VALUE_TAG_RE.test(body) || DEFAULT_RE.test(body) || DIGIT_RE.test(body) || UNIT_WORD_RE.test(body) || EXAMPLE_RE.test(body) || BANNER_RE.test(body) || NON_ASCII_LETTER_RE2.test(body);
 }
+function isLabel(body) {
+  let content = 0;
+  for (const word of body.match(WORD_RE4) ?? []) {
+    if (word.length >= 2 && !WALL_STOPWORDS.has(word.toLowerCase())) content += 1;
+  }
+  return content <= 1;
+}
+function isTagsOnly(body) {
+  return body.length > 0 && body.replace(TAG_TOKEN_RE, "").trim().length === 0;
+}
 function knownTokens(source) {
   const tokens = /* @__PURE__ */ new Set();
   for (const identifier of source.match(/[A-Za-z_$][\w$]*/g) ?? []) {
@@ -5092,11 +5131,146 @@ function novelWords(body, known) {
   let novel = 0;
   for (const word of body.match(WORD_RE4) ?? []) {
     const lower = word.toLowerCase();
-    if (lower.length < 2 || STOPWORDS4.has(lower)) continue;
+    if (lower.length < 2 || WALL_STOPWORDS.has(lower)) continue;
     if (!known.has(lower) && !known.has(stem(lower))) novel += 1;
   }
   return novel;
 }
+function isWall(members, commented, restated, options) {
+  return commented >= options.minCommentedMembers && commented / members >= options.minCommentedRatio && restated / commented >= options.minRestatedRatio;
+}
+var OPAQUE_VALUE_TYPES = /* @__PURE__ */ new Set([
+  import_utils34.AST_NODE_TYPES.FunctionExpression,
+  import_utils34.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils34.AST_NODE_TYPES.ObjectExpression,
+  import_utils34.AST_NODE_TYPES.ArrayExpression
+]);
+function declarationRange(member) {
+  const body = bodyOf(member);
+  if (body === void 0) return [member.range[0], member.range[1]];
+  return [member.range[0], body.range[0]];
+}
+function bodyOf(member) {
+  if (member.type === import_utils34.AST_NODE_TYPES.MethodDefinition || member.type === import_utils34.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+    return member.value.body ?? void 0;
+  }
+  if (member.type === import_utils34.AST_NODE_TYPES.Property || member.type === import_utils34.AST_NODE_TYPES.PropertyDefinition) {
+    const value = member.value;
+    if (value !== null && OPAQUE_VALUE_TYPES.has(value.type)) return value;
+  }
+  return void 0;
+}
+
+// src/rules/no-declaration-comment-wall.ts
+function named(node) {
+  switch (node.type) {
+    case import_utils35.AST_NODE_TYPES.TSEnumMember:
+      return { node, key: node.id };
+    case import_utils35.AST_NODE_TYPES.PropertyDefinition:
+    case import_utils35.AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case import_utils35.AST_NODE_TYPES.MethodDefinition:
+    case import_utils35.AST_NODE_TYPES.TSAbstractMethodDefinition:
+      return node.computed ? void 0 : { node, key: node.key };
+    default:
+      return void 0;
+  }
+}
+var no_declaration_comment_wall_default = createRule({
+  name: "no-declaration-comment-wall",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Flag an enum body or class body whose member comments mostly re-spell the members' own names."
+    },
+    schema: [WALL_SCHEMA],
+    messages: {
+      commentWall: "{{restated}} of this declaration's {{commented}} member comments only re-spell the member's own name \u2014 delete them, and keep the rows that say what the name cannot."
+    }
+  },
+  defaultOptions: [WALL_DEFAULTS],
+  create(context, [provided]) {
+    const options = { ...WALL_DEFAULTS, ...provided };
+    const sourceCode = context.sourceCode;
+    if (isGeneratedFile(context.filename, sourceCode.text) || isTestFile(context.filename) || isStoryFile(context.filename)) {
+      return {};
+    }
+    const endingOn = /* @__PURE__ */ new Map();
+    const startingOn = /* @__PURE__ */ new Map();
+    for (const comment of sourceCode.getAllComments()) {
+      endingOn.set(comment.loc.end.line, comment);
+      if (!startingOn.has(comment.loc.start.line)) startingOn.set(comment.loc.start.line, comment);
+    }
+    function documentingComment(member) {
+      const beforeMember = sourceCode.getTokenBefore(member, { includeComments: false });
+      const ownsItsLine = beforeMember === null || beforeMember.loc.end.line < member.loc.start.line;
+      const lead = ownsItsLine ? endingOn.get(member.loc.start.line - 1) : void 0;
+      if (lead !== void 0) {
+        const before = sourceCode.getTokenBefore(lead, { includeComments: false });
+        if (before === null || before.loc.end.line < lead.loc.start.line) return lead;
+      }
+      const trail = startingOn.get(member.loc.end.line);
+      return trail !== void 0 && trail.range[0] > member.range[0] ? trail : void 0;
+    }
+    function isGroupLabel(comment, member, headsRun) {
+      if (comment.loc.end.line >= member.node.loc.start.line) return false;
+      const body = commentBody(comment);
+      if (!BARE_LABEL_RE.test(body)) return false;
+      if (labelStems(body) === labelStems(sourceCode.getText(member.key))) return false;
+      const lineAbove = sourceCode.lines[comment.loc.start.line - 2];
+      return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
+    }
+    function check(node, members) {
+      const judged = members.map(named).filter((member) => member !== void 0);
+      if (judged.length === 0) return;
+      const documented = judged.map((member) => ({
+        member,
+        comment: documentingComment(member.node)
+      }));
+      let commented = 0;
+      let restated = 0;
+      for (const [index, { member, comment }] of documented.entries()) {
+        if (comment === void 0) continue;
+        const next = documented[index + 1];
+        if (isGroupLabel(comment, member, next !== void 0 && next.comment === void 0)) {
+          continue;
+        }
+        commented += 1;
+        const body = commentBody(comment);
+        if (body.length === 0 || carriesValue(body) || isTagsOnly(body) || isLabel(body)) {
+          continue;
+        }
+        const [start, end] = declarationRange(member.node);
+        if (novelWords(body, knownTokens(sourceCode.text.slice(start, end))) <= options.maxNovelWords) {
+          restated += 1;
+        }
+      }
+      if (!isWall(judged.length, commented, restated, options)) return;
+      context.report({
+        node,
+        loc: {
+          start: node.loc.start,
+          end: { line: node.loc.start.line, column: node.loc.start.column + 1 }
+        },
+        messageId: "commentWall",
+        data: { restated: String(restated), commented: String(commented) }
+      });
+    }
+    return {
+      ClassBody: (node) => {
+        check(node, node.body);
+      },
+      TSEnumDeclaration: (node) => {
+        check(node, node.body.members);
+      }
+    };
+  }
+});
+
+// src/rules/no-type-member-comment-wall.ts
+var import_utils36 = require("@typescript-eslint/utils");
+function isNamedMember(node) {
+  return (node.type === import_utils36.AST_NODE_TYPES.TSPropertySignature || node.type === import_utils36.AST_NODE_TYPES.TSMethodSignature) && !node.computed;
+}
 var no_type_member_comment_wall_default = createRule({
   name: "no-type-member-comment-wall",
   meta: {
@@ -5104,43 +5278,14 @@ var no_type_member_comment_wall_default = createRule({
     docs: {
       description: "Flag an object type whose member comments mostly re-spell the members' own names and types."
     },
-    schema: [
-      {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-          minCommentedMembers: {
-            type: "integer",
-            minimum: 2,
-            description: "Fewest commented members that can count as a wall."
-          },
-          minCommentedRatio: {
-            type: "number",
-            minimum: 0,
-            maximum: 1,
-            description: "Least share of the type's members that must be commented; below it the comments are group labels."
-          },
-          minRestatedRatio: {
-            type: "number",
-            minimum: 0,
-            maximum: 1,
-            description: "Least share of the member comments that must be restatements."
-          },
-          maxNovelWords: {
-            type: "integer",
-            minimum: 0,
-            description: "Most content words a comment may add beyond its member's own source and still count as a restatement."
-          }
-        }
-      }
-    ],
+    schema: [WALL_SCHEMA],
     messages: {
       commentWall: "{{restated}} of this type's {{commented}} member comments only re-spell the member's own name and type \u2014 delete them, and keep the rows that say what the name cannot."
     }
   },
-  defaultOptions: [DEFAULTS],
+  defaultOptions: [WALL_DEFAULTS],
   create(context, [provided]) {
-    const options = { ...DEFAULTS, ...provided };
+    const options = { ...WALL_DEFAULTS, ...provided };
     const sourceCode = context.sourceCode;
     if (isGeneratedFile(context.filename, sourceCode.text) || isTestFile(context.filename) || isStoryFile(context.filename)) {
       return {};
@@ -5171,10 +5316,10 @@ var no_type_member_comment_wall_default = createRule({
       return headsRun || lineAbove !== void 0 && lineAbove.trim().length === 0;
     }
     function check(node) {
-      const members = node.type === import_utils34.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
-      const named = members.filter(isNamedMember);
-      if (named.length === 0) return;
-      const documented = named.map((member) => ({ member, comment: documentingComment(member) }));
+      const members = node.type === import_utils36.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
+      const named2 = members.filter(isNamedMember);
+      if (named2.length === 0) return;
+      const documented = named2.map((member) => ({ member, comment: documentingComment(member) }));
       let commented = 0;
       let restated = 0;
       const claimed = /* @__PURE__ */ new Set();
@@ -5192,9 +5337,7 @@ var no_type_member_comment_wall_default = createRule({
           restated += 1;
         }
       }
-      if (commented < options.minCommentedMembers || commented / named.length < options.minCommentedRatio || restated / commented < options.minRestatedRatio) {
-        return;
-      }
+      if (!isWall(named2.length, commented, restated, options)) return;
       context.report({
         node,
         loc: {
@@ -5213,7 +5356,7 @@ var no_type_member_comment_wall_default = createRule({
 });
 
 // src/rules/no-unnecessary-use-client.ts
-var import_utils35 = require("@typescript-eslint/utils");
+var import_utils37 = require("@typescript-eslint/utils");
 var HOOK_REGEX = /^use([A-Z]|$)/;
 var EVENT_PROP_REGEX = /^on[A-Z]/;
 var ERROR_FILE_REGEX = /\b(?:global-)?error\.[jt]sx?$/;
@@ -5239,13 +5382,13 @@ var CLIENT_ONLY_PACKAGES_REGEX = /^(?:@radix-ui\/|framer-motion|react-dom|react-
 var isBareSpecifier = (source) => !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/") && !source.startsWith("~");
 var jsxRootName = (name) => {
   let current = name;
-  while (current.type === import_utils35.AST_NODE_TYPES.JSXMemberExpression) {
+  while (current.type === import_utils37.AST_NODE_TYPES.JSXMemberExpression) {
     current = current.object;
   }
-  return current.type === import_utils35.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
+  return current.type === import_utils37.AST_NODE_TYPES.JSXIdentifier ? current.name : "";
 };
 var subtreeReadsImportedBinding = (node, imported) => {
-  if (node.type === import_utils35.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils37.AST_NODE_TYPES.Identifier) {
     return imported.has(node.name);
   }
   for (const key of Object.keys(node)) {
@@ -5260,16 +5403,16 @@ var subtreeReadsImportedBinding = (node, imported) => {
   return false;
 };
 var isUseClientDirective = (node) => {
-  return node.type === import_utils35.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils35.AST_NODE_TYPES.Literal && node.expression.value === "use client";
+  return node.type === import_utils37.AST_NODE_TYPES.ExpressionStatement && node.expression.type === import_utils37.AST_NODE_TYPES.Literal && node.expression.value === "use client";
 };
 var isGlobalReference = (node, context) => {
   if (!BROWSER_GLOBALS.has(node.name)) return false;
   const parent = node.parent;
   if (parent !== void 0) {
-    if (parent.type === import_utils35.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
+    if (parent.type === import_utils37.AST_NODE_TYPES.MemberExpression && parent.property === node && !parent.computed) {
       return false;
     }
-    if (parent.type === import_utils35.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
+    if (parent.type === import_utils37.AST_NODE_TYPES.Property && parent.key === node && !parent.computed) {
       return false;
     }
     if (parent.type.startsWith("TS")) {
@@ -5309,13 +5452,13 @@ var no_unnecessary_use_client_default = createRule({
     const importedLocals = /* @__PURE__ */ new Set();
     const externalLocals = /* @__PURE__ */ new Set();
     const markIfHookOrContext = (callee) => {
-      if (callee.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils37.AST_NODE_TYPES.Identifier) {
         if (HOOK_REGEX.test(callee.name) || callee.name === "createContext") {
           hasClientIndicator = true;
         }
         return;
       }
-      if (callee.type === import_utils35.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils35.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils37.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils37.AST_NODE_TYPES.Identifier) {
         const name = callee.property.name;
         if (HOOK_REGEX.test(name) || name === "createContext") {
           hasClientIndicator = true;
@@ -5325,7 +5468,7 @@ var no_unnecessary_use_client_default = createRule({
     return {
       Program(node) {
         for (const stmt of node.body) {
-          if (stmt.type !== import_utils35.AST_NODE_TYPES.ExpressionStatement) break;
+          if (stmt.type !== import_utils37.AST_NODE_TYPES.ExpressionStatement) break;
           if (isUseClientDirective(stmt)) {
             directiveNode = stmt;
             break;
@@ -5338,7 +5481,7 @@ var no_unnecessary_use_client_default = createRule({
       },
       JSXAttribute(node) {
         if (directiveNode === null) return;
-        if (node.name.type === import_utils35.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
+        if (node.name.type === import_utils37.AST_NODE_TYPES.JSXIdentifier && EVENT_PROP_REGEX.test(node.name.name)) {
           hasClientIndicator = true;
         }
       },
@@ -5405,18 +5548,18 @@ var no_unnecessary_use_client_default = createRule({
 });
 
 // src/rules/no-unsafe-mock-casting.ts
-var import_utils36 = require("@typescript-eslint/utils");
-var import_utils37 = require("@typescript-eslint/utils");
+var import_utils38 = require("@typescript-eslint/utils");
+var import_utils39 = require("@typescript-eslint/utils");
 function isMockTypeReference(node) {
-  if (node.type !== import_utils37.AST_NODE_TYPES.TSTypeReference) {
+  if (node.type !== import_utils39.AST_NODE_TYPES.TSTypeReference) {
     return false;
   }
   const typeName = node.typeName;
-  if (typeName.type === import_utils37.AST_NODE_TYPES.Identifier) {
+  if (typeName.type === import_utils39.AST_NODE_TYPES.Identifier) {
     const name = typeName.name;
     return name === "Mock" || name === "MockInstance" || name === "SpyInstance";
   }
-  if (typeName.type === import_utils37.AST_NODE_TYPES.TSQualifiedName) {
+  if (typeName.type === import_utils39.AST_NODE_TYPES.TSQualifiedName) {
     const rightName = typeName.right.name;
     return rightName === "Mock" || rightName === "MockInstance" || rightName === "SpyInstance";
   }
@@ -5452,7 +5595,7 @@ var no_unsafe_mock_casting_default = createRule({
 });
 
 // src/rules/no-zod-native-enum.ts
-var import_utils38 = require("@typescript-eslint/utils");
+var import_utils40 = require("@typescript-eslint/utils");
 var ts = __toESM(require("typescript"), 1);
 var IGNORE_PATTERNS = [
   /[\\/]generated[\\/]/,
@@ -5470,7 +5613,7 @@ function isZodModule(source) {
   return /(^|[/@-])zod([/-]|$)/.test(source);
 }
 function unwrap2(node) {
-  if (node.type === import_utils38.AST_NODE_TYPES.TSAsExpression || node.type === import_utils38.AST_NODE_TYPES.TSSatisfiesExpression) {
+  if (node.type === import_utils40.AST_NODE_TYPES.TSAsExpression || node.type === import_utils40.AST_NODE_TYPES.TSSatisfiesExpression) {
     return unwrap2(node.expression);
   }
   return node;
@@ -5478,14 +5621,14 @@ function unwrap2(node) {
 function stringValueTexts(node, sourceCode) {
   const texts = [];
   for (const prop of node.properties) {
-    if (prop.type !== import_utils38.AST_NODE_TYPES.Property) {
+    if (prop.type !== import_utils40.AST_NODE_TYPES.Property) {
       return null;
     }
     if (prop.computed || prop.shorthand || prop.method || prop.kind !== "init") {
       return null;
     }
     const value = prop.value;
-    if (value.type !== import_utils38.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+    if (value.type !== import_utils40.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
       return null;
     }
     const text = sourceCode.getText(value);
@@ -5501,7 +5644,7 @@ function resolvesToLocalEnum(node, scope) {
     const variable = current.variables.find((v) => v.name === node.name);
     if (variable !== void 0) {
       return variable.defs.some(
-        (def) => def.node.type === import_utils38.AST_NODE_TYPES.TSEnumDeclaration
+        (def) => def.node.type === import_utils40.AST_NODE_TYPES.TSEnumDeclaration
       );
     }
     current = current.upper;
@@ -5546,32 +5689,32 @@ var no_zod_native_enum_default = createRule({
     }
     let services;
     try {
-      services = import_utils38.ESLintUtils.getParserServices(context);
+      services = import_utils40.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
     const zodImportedNames = /* @__PURE__ */ new Map();
     function isZodMemberCall(node, api) {
       const callee = node.callee;
-      if (callee.type === import_utils38.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils38.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils40.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils40.AST_NODE_TYPES.Identifier) {
         return callee.property.name === api;
       }
-      if (callee.type === import_utils38.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils40.AST_NODE_TYPES.Identifier) {
         return zodImportedNames.get(callee.name) === api;
       }
       return false;
     }
     function buildFix(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils38.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils38.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils40.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils40.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const arg = node.arguments[0];
-      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils38.AST_NODE_TYPES.SpreadElement) {
+      if (arg === void 0 || node.arguments.length !== 1 || arg.type === import_utils40.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const inner = unwrap2(arg);
-      if (inner.type !== import_utils38.AST_NODE_TYPES.ObjectExpression) {
+      if (inner.type !== import_utils40.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const values = stringValueTexts(inner, sourceCode);
@@ -5591,7 +5734,7 @@ var no_zod_native_enum_default = createRule({
           return;
         }
         for (const spec of node.specifiers) {
-          if (spec.type === import_utils38.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils38.AST_NODE_TYPES.Identifier) {
+          if (spec.type === import_utils40.AST_NODE_TYPES.ImportSpecifier && spec.imported.type === import_utils40.AST_NODE_TYPES.Identifier) {
             zodImportedNames.set(spec.local.name, spec.imported.name);
           }
         }
@@ -5610,7 +5753,7 @@ var no_zod_native_enum_default = createRule({
           return;
         }
         const arg = node.arguments[0];
-        if (arg === void 0 || arg.type !== import_utils38.AST_NODE_TYPES.Identifier) {
+        if (arg === void 0 || arg.type !== import_utils40.AST_NODE_TYPES.Identifier) {
           return;
         }
         const isEnum = resolvesToLocalEnum(arg, sourceCode.getScope(arg)) || services !== null && resolvesToImportedEnum(arg, services);
@@ -5627,7 +5770,7 @@ var no_zod_native_enum_default = createRule({
 });
 
 // src/rules/prefer-constant-time-secret-compare.ts
-var import_utils39 = require("@typescript-eslint/utils");
+var import_utils41 = require("@typescript-eslint/utils");
 var EQUALITY_OPERATORS = /* @__PURE__ */ new Set(["===", "!==", "==", "!="]);
 var SENTINEL_IDENTIFIERS = /* @__PURE__ */ new Set(["undefined", "NaN"]);
 var SENTINEL_WORDS = /(^|_)(SENTINEL|EMPTY|NONE|NULL|UNSET|MISSING|PLACEHOLDER|DUMMY|FAKE|EXAMPLE)(_|$)/;
@@ -5640,36 +5783,36 @@ function isConstantReference(identifier) {
 }
 function isExcludedOperand(node) {
   switch (node.type) {
-    case import_utils39.AST_NODE_TYPES.Literal:
+    case import_utils41.AST_NODE_TYPES.Literal:
       return true;
-    case import_utils39.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils41.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0;
-    case import_utils39.AST_NODE_TYPES.Identifier:
+    case import_utils41.AST_NODE_TYPES.Identifier:
       return SENTINEL_IDENTIFIERS.has(node.name) || SENTINEL_PREFIX_RE.test(node.name) || isConstantReference(node.name);
-    case import_utils39.AST_NODE_TYPES.MemberExpression:
-      return !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
+    case import_utils41.AST_NODE_TYPES.MemberExpression:
+      return !node.computed && node.property.type === import_utils41.AST_NODE_TYPES.Identifier && (SENTINEL_PREFIX_RE.test(node.property.name) || isConstantReference(node.property.name));
     default:
       return false;
   }
 }
 function operandName(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils41.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils39.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils39.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils41.AST_NODE_TYPES.MemberExpression && !node.computed && node.property.type === import_utils41.AST_NODE_TYPES.Identifier) {
     return node.property.name;
   }
   return null;
 }
 function isSecretOperand(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils41.AST_NODE_TYPES.TemplateLiteral) {
     return node.expressions.some((expression) => isSecretOperand(expression));
   }
   const name = operandName(node);
   return name !== null && isAuthSecretName(name);
 }
 function secretNameOf(node) {
-  if (node.type === import_utils39.AST_NODE_TYPES.TemplateLiteral) {
+  if (node.type === import_utils41.AST_NODE_TYPES.TemplateLiteral) {
     for (const expression of node.expressions) {
       const nested = secretNameOf(expression);
       if (nested !== null) {
@@ -5721,8 +5864,8 @@ var prefer_constant_time_secret_compare_default = createRule({
 });
 
 // src/rules/prefer-discriminated-union.ts
-var import_utils40 = require("@typescript-eslint/utils");
-var import_utils41 = require("@typescript-eslint/utils");
+var import_utils42 = require("@typescript-eslint/utils");
+var import_utils43 = require("@typescript-eslint/utils");
 var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
   "success",
   "ok",
@@ -5732,27 +5875,27 @@ var STATUS_MEMBER_NAMES = /* @__PURE__ */ new Set([
 ]);
 var MIN_OPTIONAL_MEMBERS = 2;
 function getMemberName(member) {
-  if (member.type !== import_utils41.AST_NODE_TYPES.TSPropertySignature) {
+  if (member.type !== import_utils43.AST_NODE_TYPES.TSPropertySignature) {
     return null;
   }
   const { key } = member;
-  if (key.type === import_utils41.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils43.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils41.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils43.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isBooleanTyped(member) {
-  return member.typeAnnotation?.typeAnnotation.type === import_utils41.AST_NODE_TYPES.TSBooleanKeyword;
+  return member.typeAnnotation?.typeAnnotation.type === import_utils43.AST_NODE_TYPES.TSBooleanKeyword;
 }
 function looksLikeMutuallyExclusiveState(typeLiteral) {
   let hasStatusBoolean = false;
   let optionalCount = 0;
   let optionalPayloadCount = 0;
   for (const member of typeLiteral.members) {
-    if (member.type !== import_utils41.AST_NODE_TYPES.TSPropertySignature) {
+    if (member.type !== import_utils43.AST_NODE_TYPES.TSPropertySignature) {
       continue;
     }
     if (member.optional) {
@@ -5794,7 +5937,7 @@ var prefer_discriminated_union_default = createRule({
       TSInterfaceDeclaration(node) {
         const synthetic = {
           ...node.body,
-          type: import_utils41.AST_NODE_TYPES.TSTypeLiteral,
+          type: import_utils43.AST_NODE_TYPES.TSTypeLiteral,
           members: node.body.body
         };
         checkTypeLiteral(synthetic, node);
@@ -5807,7 +5950,7 @@ var prefer_discriminated_union_default = createRule({
 });
 
 // src/rules/prefer-module-level-constant.ts
-var import_utils42 = require("@typescript-eslint/utils");
+var import_utils44 = require("@typescript-eslint/utils");
 var DEFAULT_MIN_ELEMENTS = 3;
 var MAX_LITERAL_DEPTH = 4;
 var IGNORE_PATTERNS2 = [
@@ -5836,9 +5979,9 @@ var MUTATING_METHODS = /* @__PURE__ */ new Set([
   "assign"
 ]);
 var FUNCTION_TYPES5 = /* @__PURE__ */ new Set([
-  import_utils42.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils42.AST_NODE_TYPES.FunctionExpression,
-  import_utils42.AST_NODE_TYPES.ArrowFunctionExpression
+  import_utils44.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils44.AST_NODE_TYPES.FunctionExpression,
+  import_utils44.AST_NODE_TYPES.ArrowFunctionExpression
 ]);
 var COLLECTION_CONSTRUCTORS = /* @__PURE__ */ new Set(["Set", "Map"]);
 function isIgnoredFile2(filename, sourceText) {
@@ -5851,14 +5994,14 @@ function isLocalFixtureFile(filename) {
   return isTestFile(filename) || isStoryFile(filename);
 }
 function unwrap3(node) {
-  if (node.type === import_utils42.AST_NODE_TYPES.TSAsExpression || node.type === import_utils42.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils42.AST_NODE_TYPES.TSNonNullExpression) {
+  if (node.type === import_utils44.AST_NODE_TYPES.TSAsExpression || node.type === import_utils44.AST_NODE_TYPES.TSSatisfiesExpression || node.type === import_utils44.AST_NODE_TYPES.TSNonNullExpression) {
     return unwrap3(node.expression);
   }
   return node;
 }
 var HAS_STATEFUL_FLAG_RE = /[gy]/;
 function isRegexLiteral(node) {
-  return node.type === import_utils42.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
+  return node.type === import_utils44.AST_NODE_TYPES.Literal && "regex" in node && node.regex !== void 0;
 }
 function isLiteralOnly(node, depth) {
   if (depth > MAX_LITERAL_DEPTH) {
@@ -5866,29 +6009,29 @@ function isLiteralOnly(node, depth) {
   }
   const inner = unwrap3(node);
   switch (inner.type) {
-    case import_utils42.AST_NODE_TYPES.Literal: {
+    case import_utils44.AST_NODE_TYPES.Literal: {
       return !(isRegexLiteral(inner) && HAS_STATEFUL_FLAG_RE.test(inner.regex.flags));
     }
-    case import_utils42.AST_NODE_TYPES.TemplateLiteral: {
+    case import_utils44.AST_NODE_TYPES.TemplateLiteral: {
       return inner.expressions.length === 0;
     }
-    case import_utils42.AST_NODE_TYPES.UnaryExpression: {
-      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils42.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
+    case import_utils44.AST_NODE_TYPES.UnaryExpression: {
+      return (inner.operator === "-" || inner.operator === "+") && inner.argument.type === import_utils44.AST_NODE_TYPES.Literal && typeof inner.argument.value === "number";
     }
-    case import_utils42.AST_NODE_TYPES.ArrayExpression: {
+    case import_utils44.AST_NODE_TYPES.ArrayExpression: {
       return inner.elements.every(
-        (el) => el !== null && el.type !== import_utils42.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
+        (el) => el !== null && el.type !== import_utils44.AST_NODE_TYPES.SpreadElement && isLiteralOnly(el, depth + 1)
       );
     }
-    case import_utils42.AST_NODE_TYPES.ObjectExpression: {
+    case import_utils44.AST_NODE_TYPES.ObjectExpression: {
       return inner.properties.every((prop) => {
-        if (prop.type !== import_utils42.AST_NODE_TYPES.Property) {
+        if (prop.type !== import_utils44.AST_NODE_TYPES.Property) {
           return false;
         }
         if (prop.shorthand || prop.method || prop.kind !== "init") {
           return false;
         }
-        if (prop.computed && prop.key.type !== import_utils42.AST_NODE_TYPES.Literal) {
+        if (prop.computed && prop.key.type !== import_utils44.AST_NODE_TYPES.Literal) {
           return false;
         }
         return isLiteralOnly(prop.value, depth + 1);
@@ -5901,7 +6044,7 @@ function isLiteralOnly(node, depth) {
 }
 function unwrapObjectFreeze(node) {
   const inner = unwrap3(node);
-  if (inner.type === import_utils42.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils42.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils42.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils42.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils42.AST_NODE_TYPES.SpreadElement) {
+  if (inner.type === import_utils44.AST_NODE_TYPES.CallExpression && inner.callee.type === import_utils44.AST_NODE_TYPES.MemberExpression && !inner.callee.computed && inner.callee.object.type === import_utils44.AST_NODE_TYPES.Identifier && inner.callee.object.name === "Object" && inner.callee.property.type === import_utils44.AST_NODE_TYPES.Identifier && inner.callee.property.name === "freeze" && inner.arguments.length === 1 && inner.arguments[0] !== void 0 && inner.arguments[0].type !== import_utils44.AST_NODE_TYPES.SpreadElement) {
     return unwrap3(inner.arguments[0]);
   }
   return inner;
@@ -5917,19 +6060,19 @@ function classify(init, checkRegex) {
     }
     return { kind: "regex", size: 1 };
   }
-  if (node.type === import_utils42.AST_NODE_TYPES.ArrayExpression) {
+  if (node.type === import_utils44.AST_NODE_TYPES.ArrayExpression) {
     return isLiteralOnly(node, 0) ? { kind: "array", size: node.elements.length } : null;
   }
-  if (node.type === import_utils42.AST_NODE_TYPES.ObjectExpression) {
+  if (node.type === import_utils44.AST_NODE_TYPES.ObjectExpression) {
     return isLiteralOnly(node, 0) ? { kind: "object", size: node.properties.length } : null;
   }
-  if (node.type === import_utils42.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils42.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
+  if (node.type === import_utils44.AST_NODE_TYPES.NewExpression && node.callee.type === import_utils44.AST_NODE_TYPES.Identifier && COLLECTION_CONSTRUCTORS.has(node.callee.name)) {
     const arg = node.arguments[0];
-    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils42.AST_NODE_TYPES.SpreadElement) {
+    if (node.arguments.length !== 1 || arg === void 0 || arg.type === import_utils44.AST_NODE_TYPES.SpreadElement) {
       return null;
     }
     const entries = unwrap3(arg);
-    if (entries.type !== import_utils42.AST_NODE_TYPES.ArrayExpression) {
+    if (entries.type !== import_utils44.AST_NODE_TYPES.ArrayExpression) {
       return null;
     }
     return isLiteralOnly(entries, 0) ? { kind: node.callee.name === "Set" ? "Set" : "Map", size: entries.elements.length } : null;
@@ -5958,10 +6101,10 @@ var NON_RETAINING_BUILTINS = /* @__PURE__ */ new Map(
 );
 function isNonRetainingBuiltinCall(node, argument) {
   const callee = node.callee;
-  if (callee.type === import_utils42.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
+  if (callee.type === import_utils44.AST_NODE_TYPES.Identifier && callee.name === "structuredClone") {
     return true;
   }
-  if (callee.type !== import_utils42.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils42.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils42.AST_NODE_TYPES.Identifier) {
+  if (callee.type !== import_utils44.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils44.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils44.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const members = NON_RETAINING_BUILTINS.get(callee.object.name);
@@ -5975,38 +6118,38 @@ function isNonRetainingBuiltinCall(node, argument) {
 }
 function isSafeRead(identifier) {
   const parent = identifier.parent;
-  if (parent.type === import_utils42.AST_NODE_TYPES.MemberExpression) {
+  if (parent.type === import_utils44.AST_NODE_TYPES.MemberExpression) {
     if (parent.object !== identifier) {
       return true;
     }
     const grandparent = parent.parent;
-    if (grandparent.type === import_utils42.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
+    if (grandparent.type === import_utils44.AST_NODE_TYPES.AssignmentExpression && grandparent.left === parent) {
       return false;
     }
-    if (grandparent.type === import_utils42.AST_NODE_TYPES.UpdateExpression) {
+    if (grandparent.type === import_utils44.AST_NODE_TYPES.UpdateExpression) {
       return false;
     }
-    if (grandparent.type === import_utils42.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
+    if (grandparent.type === import_utils44.AST_NODE_TYPES.UnaryExpression && grandparent.operator === "delete") {
       return false;
     }
-    if (!parent.computed && parent.property.type === import_utils42.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils42.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
+    if (!parent.computed && parent.property.type === import_utils44.AST_NODE_TYPES.Identifier && MUTATING_METHODS.has(parent.property.name) && grandparent.type === import_utils44.AST_NODE_TYPES.CallExpression && grandparent.callee === parent) {
       return false;
     }
     return true;
   }
-  if (parent.type === import_utils42.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
+  if (parent.type === import_utils44.AST_NODE_TYPES.ForOfStatement && parent.right === identifier) {
     return true;
   }
-  if (parent.type === import_utils42.AST_NODE_TYPES.SpreadElement) {
+  if (parent.type === import_utils44.AST_NODE_TYPES.SpreadElement) {
     return true;
   }
-  if (parent.type === import_utils42.AST_NODE_TYPES.BinaryExpression) {
+  if (parent.type === import_utils44.AST_NODE_TYPES.BinaryExpression) {
     return true;
   }
-  if (parent.type === import_utils42.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
+  if (parent.type === import_utils44.AST_NODE_TYPES.CallExpression && parent.arguments.includes(identifier) && isNonRetainingBuiltinCall(parent, identifier)) {
     return true;
   }
-  if (parent.type === import_utils42.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
+  if (parent.type === import_utils44.AST_NODE_TYPES.UnaryExpression && parent.operator !== "delete") {
     return true;
   }
   return false;
@@ -6061,7 +6204,7 @@ var prefer_module_level_constant_default = createRule({
         if (reference.isWrite()) {
           return false;
         }
-        if (reference.identifier.type !== import_utils42.AST_NODE_TYPES.Identifier) {
+        if (reference.identifier.type !== import_utils44.AST_NODE_TYPES.Identifier) {
           return false;
         }
         if (!isSafeRead(reference.identifier)) {
@@ -6073,10 +6216,10 @@ var prefer_module_level_constant_default = createRule({
     return {
       VariableDeclarator(node) {
         const declaration = node.parent;
-        if (declaration.type !== import_utils42.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
+        if (declaration.type !== import_utils44.AST_NODE_TYPES.VariableDeclaration || declaration.kind !== "const" || declaration.declare === true) {
           return;
         }
-        if (node.id.type !== import_utils42.AST_NODE_TYPES.Identifier || node.init === null) {
+        if (node.id.type !== import_utils44.AST_NODE_TYPES.Identifier || node.init === null) {
           return;
         }
         if (enclosingFunction2(node) === null) {
@@ -6103,7 +6246,7 @@ var prefer_module_level_constant_default = createRule({
 });
 
 // src/rules/prefer-module-level-schema.ts
-var import_utils43 = require("@typescript-eslint/utils");
+var import_utils45 = require("@typescript-eslint/utils");
 
 // src/rules/_zod.ts
 var ZOD_PREFIX_RE = /^Z[A-Z]/;
@@ -6141,9 +6284,9 @@ var TERMINAL_METHODS = /* @__PURE__ */ new Set([
   "spa"
 ]);
 var FUNCTION_TYPES6 = /* @__PURE__ */ new Set([
-  import_utils43.AST_NODE_TYPES.ArrowFunctionExpression,
-  import_utils43.AST_NODE_TYPES.FunctionDeclaration,
-  import_utils43.AST_NODE_TYPES.FunctionExpression
+  import_utils45.AST_NODE_TYPES.ArrowFunctionExpression,
+  import_utils45.AST_NODE_TYPES.FunctionDeclaration,
+  import_utils45.AST_NODE_TYPES.FunctionExpression
 ]);
 function schemaExpression(node) {
   let current = node;
@@ -6152,10 +6295,10 @@ function schemaExpression(node) {
     if (parent === void 0) {
       return current;
     }
-    if (parent.type === import_utils43.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils43.AST_NODE_TYPES.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
+    if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.computed && parent.property.type === import_utils45.AST_NODE_TYPES.Identifier && TERMINAL_METHODS.has(parent.property.name)) {
       return current;
     }
-    if (parent.type === import_utils43.AST_NODE_TYPES.MemberExpression && parent.object === current || parent.type === import_utils43.AST_NODE_TYPES.CallExpression && parent.callee === current || parent.type === import_utils43.AST_NODE_TYPES.TSAsExpression && parent.expression === current || parent.type === import_utils43.AST_NODE_TYPES.TSNonNullExpression && parent.expression === current) {
+    if (parent.type === import_utils45.AST_NODE_TYPES.MemberExpression && parent.object === current || parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.callee === current || parent.type === import_utils45.AST_NODE_TYPES.TSAsExpression && parent.expression === current || parent.type === import_utils45.AST_NODE_TYPES.TSNonNullExpression && parent.expression === current) {
       current = parent;
       continue;
     }
@@ -6189,7 +6332,7 @@ function readsReceiver(node) {
     if (typeof candidate.type !== "string") {
       return;
     }
-    if (candidate.type === import_utils43.AST_NODE_TYPES.ThisExpression || candidate.type === import_utils43.AST_NODE_TYPES.Super || candidate.type === import_utils43.AST_NODE_TYPES.Identifier && candidate.name === "arguments") {
+    if (candidate.type === import_utils45.AST_NODE_TYPES.ThisExpression || candidate.type === import_utils45.AST_NODE_TYPES.Super || candidate.type === import_utils45.AST_NODE_TYPES.Identifier && candidate.name === "arguments") {
       found = true;
       return;
     }
@@ -6257,15 +6400,15 @@ var prefer_module_level_schema_default = createRule({
     }
     const zodNamespaces = /* @__PURE__ */ new Set();
     function isZodCall(node) {
-      return node.type === import_utils43.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils43.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils43.AST_NODE_TYPES.Identifier && zodNamespaces.has(node.callee.object.name);
+      return node.type === import_utils45.AST_NODE_TYPES.CallExpression && node.callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !node.callee.computed && node.callee.object.type === import_utils45.AST_NODE_TYPES.Identifier && zodNamespaces.has(node.callee.object.name);
     }
     function isCovered(node) {
       let current = node.parent ?? void 0;
       while (current !== void 0) {
-        if (current !== node && isZodCall(current) && current.callee.type === import_utils43.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils43.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
+        if (current !== node && isZodCall(current) && current.callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && current.callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && factories.has(current.callee.property.name)) {
           return true;
         }
-        if (current.type === import_utils43.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils43.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils43.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils43.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
+        if (current.type === import_utils45.AST_NODE_TYPES.CallExpression && (current.callee.type === import_utils45.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.name) || current.callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !current.callee.computed && current.callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && MEMO_CALLEES.has(current.callee.property.name))) {
           return true;
         }
         current = current.parent ?? void 0;
@@ -6300,13 +6443,13 @@ var prefer_module_level_schema_default = createRule({
     }
     function ownerName(enclosing) {
       const parent = enclosing.parent ?? void 0;
-      if (enclosing.type === import_utils43.AST_NODE_TYPES.FunctionDeclaration && enclosing.id !== null) {
+      if (enclosing.type === import_utils45.AST_NODE_TYPES.FunctionDeclaration && enclosing.id !== null) {
         return enclosing.id.name;
       }
-      if (parent !== void 0 && parent.type === import_utils43.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils43.AST_NODE_TYPES.Identifier) {
+      if (parent !== void 0 && parent.type === import_utils45.AST_NODE_TYPES.VariableDeclarator && parent.id.type === import_utils45.AST_NODE_TYPES.Identifier) {
         return parent.id.name;
       }
-      if (parent !== void 0 && (parent.type === import_utils43.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils43.AST_NODE_TYPES.Property) && parent.key.type === import_utils43.AST_NODE_TYPES.Identifier) {
+      if (parent !== void 0 && (parent.type === import_utils45.AST_NODE_TYPES.MethodDefinition || parent.type === import_utils45.AST_NODE_TYPES.Property) && parent.key.type === import_utils45.AST_NODE_TYPES.Identifier) {
         return parent.key.name;
       }
       return "this function";
@@ -6317,7 +6460,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils43.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils43.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils43.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils43.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils45.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils45.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils45.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils45.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -6327,7 +6470,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const callee = node.callee;
-        if (callee.property.type !== import_utils43.AST_NODE_TYPES.Identifier) {
+        if (callee.property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
           return;
         }
         const factory = callee.property.name;
@@ -6342,7 +6485,7 @@ var prefer_module_level_schema_default = createRule({
           return;
         }
         const shape = node.arguments[0];
-        if (shape !== void 0 && shape.type === import_utils43.AST_NODE_TYPES.ObjectExpression && shape.properties.length < minProperties) {
+        if (shape !== void 0 && shape.type === import_utils45.AST_NODE_TYPES.ObjectExpression && shape.properties.length < minProperties) {
           return;
         }
         const expression = schemaExpression(node);
@@ -6363,20 +6506,20 @@ var prefer_module_level_schema_default = createRule({
 });
 
 // src/rules/prefer-non-nullable-collection.ts
-var import_utils44 = require("@typescript-eslint/utils");
+var import_utils46 = require("@typescript-eslint/utils");
 var ARRAY_TYPE_NAMES = /* @__PURE__ */ new Set(["Array", "ReadonlyArray"]);
 function propertyName(node) {
   const key = node.key;
-  if (key.type === import_utils44.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils44.AST_NODE_TYPES.Literal) return String(key.value);
+  if (key.type === import_utils46.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils46.AST_NODE_TYPES.Literal) return String(key.value);
   return "collection";
 }
 function isArrayType(node) {
-  if (node.type === import_utils44.AST_NODE_TYPES.TSArrayType) return true;
-  return node.type === import_utils44.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils44.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
+  if (node.type === import_utils46.AST_NODE_TYPES.TSArrayType) return true;
+  return node.type === import_utils46.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils46.AST_NODE_TYPES.Identifier && ARRAY_TYPE_NAMES.has(node.typeName.name);
 }
 function isNullishType(node) {
-  return node.type === import_utils44.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils44.AST_NODE_TYPES.TSUndefinedKeyword;
+  return node.type === import_utils46.AST_NODE_TYPES.TSNullKeyword || node.type === import_utils46.AST_NODE_TYPES.TSUndefinedKeyword;
 }
 function isNullableArrayOnly(node) {
   const values = node.types.filter((member) => !isNullishType(member));
@@ -6403,7 +6546,7 @@ var prefer_non_nullable_collection_default = createRule({
     function checkOptionalProperty(node) {
       const annotation = node.typeAnnotation?.typeAnnotation;
       if (annotation === void 0) return;
-      if (annotation.type !== import_utils44.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
+      if (annotation.type !== import_utils46.AST_NODE_TYPES.TSUnionType || !isNullableArrayOnly(annotation)) {
         return;
       }
       context.report({
@@ -6416,7 +6559,7 @@ var prefer_non_nullable_collection_default = createRule({
       TSPropertySignature: checkOptionalProperty,
       PropertyDefinition: checkOptionalProperty,
       TSTypeAliasDeclaration(node) {
-        if (node.typeAnnotation.type !== import_utils44.AST_NODE_TYPES.TSUnionType) return;
+        if (node.typeAnnotation.type !== import_utils46.AST_NODE_TYPES.TSUnionType) return;
         if (!isNullableArrayOnly(node.typeAnnotation)) return;
         context.report({
           node,
@@ -6429,13 +6572,13 @@ var prefer_non_nullable_collection_default = createRule({
 });
 
 // src/rules/prefer-schema-for-api-payload.ts
-var import_utils45 = require("@typescript-eslint/utils");
+var import_utils47 = require("@typescript-eslint/utils");
 var unwrap4 = (node) => {
   let current = node;
   while (current !== null && current !== void 0) {
-    if (current.type === import_utils45.AST_NODE_TYPES.TSAsExpression || current.type === import_utils45.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils45.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression) {
+    if (current.type === import_utils47.AST_NODE_TYPES.TSAsExpression || current.type === import_utils47.AST_NODE_TYPES.TSTypeAssertion || current.type === import_utils47.AST_NODE_TYPES.TSNonNullExpression || current.type === import_utils47.AST_NODE_TYPES.TSSatisfiesExpression) {
       current = current.expression;
-    } else if (current.type === import_utils45.AST_NODE_TYPES.ChainExpression) {
+    } else if (current.type === import_utils47.AST_NODE_TYPES.ChainExpression) {
       current = current.expression;
     } else {
       break;
@@ -6450,23 +6593,23 @@ var PROMISE_CHAIN_METHODS = /* @__PURE__ */ new Set([
 ]);
 var isSchemaParseReference = (node) => {
   const inner = unwrap4(node);
-  return inner !== null && inner.type === import_utils45.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils45.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
+  return inner !== null && inner.type === import_utils47.AST_NODE_TYPES.MemberExpression && !inner.computed && inner.property.type === import_utils47.AST_NODE_TYPES.Identifier && (inner.property.name === "parse" || inner.property.name === "safeParse");
 };
 var isRawPayloadSource = (node) => {
   let current = unwrap4(node);
   if (current === null) return false;
-  if (current.type === import_utils45.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils47.AST_NODE_TYPES.AwaitExpression) {
     current = unwrap4(current.argument);
   }
-  if (current === null || current.type !== import_utils45.AST_NODE_TYPES.CallExpression) {
+  if (current === null || current.type !== import_utils47.AST_NODE_TYPES.CallExpression) {
     return false;
   }
   const callee = unwrap4(current.callee);
-  if (callee === null || callee.type !== import_utils45.AST_NODE_TYPES.MemberExpression) {
+  if (callee === null || callee.type !== import_utils47.AST_NODE_TYPES.MemberExpression) {
     return false;
   }
   const property = unwrap4(callee.property);
-  if (property === null || property.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+  if (property === null || property.type !== import_utils47.AST_NODE_TYPES.Identifier) {
     return false;
   }
   if (property.name === "json") {
@@ -6476,7 +6619,7 @@ var isRawPayloadSource = (node) => {
     return !current.arguments.some(isSchemaParseReference) && isRawPayloadSource(callee.object);
   }
   const object = unwrap4(callee.object);
-  return property.name === "parse" && object !== null && object.type === import_utils45.AST_NODE_TYPES.Identifier && object.name === "JSON" && // ...but not `JSON.parse(readFileSync(p, "utf8"))` — see isLocalFileRead.
+  return property.name === "parse" && object !== null && object.type === import_utils47.AST_NODE_TYPES.Identifier && object.name === "JSON" && // ...but not `JSON.parse(readFileSync(p, "utf8"))` — see isLocalFileRead.
   !isLocalFileRead(current.arguments[0]);
 };
 var FILE_READ_RE = /^(readFile|readFileSync|readJson|readJsonSync|readJSON)$/;
@@ -6484,9 +6627,9 @@ var isLocalFileRead = (node) => {
   let found = false;
   const visit = (current) => {
     if (found || current === null || current === void 0) return;
-    if (current.type === import_utils45.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils47.AST_NODE_TYPES.CallExpression) {
       const callee = unwrap4(current.callee);
-      const name = callee?.type === import_utils45.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils45.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils45.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+      const name = callee?.type === import_utils47.AST_NODE_TYPES.Identifier ? callee.name : callee?.type === import_utils47.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils47.AST_NODE_TYPES.Identifier ? callee.property.name : null;
       if (name !== null && FILE_READ_RE.test(name)) {
         found = true;
         return;
@@ -6508,15 +6651,15 @@ var isLocalFileRead = (node) => {
 var ASSERTION_CALLEE_RE = /^(expect|assert|should|invariant)$/;
 var isInsideAssertion = (node) => {
   for (let current = node.parent; current !== void 0 && current !== null; current = current.parent) {
-    if (current.type !== import_utils45.AST_NODE_TYPES.CallExpression) continue;
+    if (current.type !== import_utils47.AST_NODE_TYPES.CallExpression) continue;
     let callee = current.callee;
-    while (callee.type === import_utils45.AST_NODE_TYPES.MemberExpression) {
+    while (callee.type === import_utils47.AST_NODE_TYPES.MemberExpression) {
       callee = callee.object;
     }
-    if (callee.type === import_utils45.AST_NODE_TYPES.CallExpression) {
+    if (callee.type === import_utils47.AST_NODE_TYPES.CallExpression) {
       callee = callee.callee;
     }
-    if (callee.type === import_utils45.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
+    if (callee.type === import_utils47.AST_NODE_TYPES.Identifier && ASSERTION_CALLEE_RE.test(callee.name)) {
       return true;
     }
   }
@@ -6535,39 +6678,39 @@ var GUARD_NAME_RE = /^(?:is|validate|parse|assert|decode|coerce)[A-Z]/;
 var isValidationRead = (node) => {
   let current = node;
   let parent = current.parent;
-  while (parent !== null && parent !== void 0 && (parent.type === import_utils45.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils45.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils45.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils45.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils45.AST_NODE_TYPES.ChainExpression)) {
+  while (parent !== null && parent !== void 0 && (parent.type === import_utils47.AST_NODE_TYPES.TSAsExpression || parent.type === import_utils47.AST_NODE_TYPES.TSTypeAssertion || parent.type === import_utils47.AST_NODE_TYPES.TSNonNullExpression || parent.type === import_utils47.AST_NODE_TYPES.TSSatisfiesExpression || parent.type === import_utils47.AST_NODE_TYPES.ChainExpression)) {
     current = parent;
     parent = parent.parent;
   }
   if (parent === null || parent === void 0) return false;
-  if (parent.type === import_utils45.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
+  if (parent.type === import_utils47.AST_NODE_TYPES.UnaryExpression && parent.operator === "typeof" && parent.argument === current) {
     return true;
   }
-  if (parent.type !== import_utils45.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
+  if (parent.type !== import_utils47.AST_NODE_TYPES.CallExpression || !parent.arguments.some((arg) => arg === current)) {
     return false;
   }
   const callee = parent.callee;
-  if (callee.type === import_utils45.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils45.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils45.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
+  if (callee.type === import_utils47.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === import_utils47.AST_NODE_TYPES.Identifier && callee.object.name === "Array" && callee.property.type === import_utils47.AST_NODE_TYPES.Identifier && callee.property.name === "isArray") {
     return parent.arguments.length === 1;
   }
-  return callee.type === import_utils45.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
+  return callee.type === import_utils47.AST_NODE_TYPES.Identifier && GUARD_NAME_RE.test(callee.name);
 };
 var isGuardTestPosition = (node) => {
   let current = node;
   let parent = current.parent;
   while (parent !== void 0 && parent !== null) {
     switch (parent.type) {
-      case import_utils45.AST_NODE_TYPES.UnaryExpression:
-      case import_utils45.AST_NODE_TYPES.LogicalExpression:
-      case import_utils45.AST_NODE_TYPES.ChainExpression:
+      case import_utils47.AST_NODE_TYPES.UnaryExpression:
+      case import_utils47.AST_NODE_TYPES.LogicalExpression:
+      case import_utils47.AST_NODE_TYPES.ChainExpression:
         current = parent;
         parent = parent.parent;
         continue;
-      case import_utils45.AST_NODE_TYPES.IfStatement:
-      case import_utils45.AST_NODE_TYPES.ConditionalExpression:
-      case import_utils45.AST_NODE_TYPES.WhileStatement:
-      case import_utils45.AST_NODE_TYPES.DoWhileStatement:
-      case import_utils45.AST_NODE_TYPES.ForStatement:
+      case import_utils47.AST_NODE_TYPES.IfStatement:
+      case import_utils47.AST_NODE_TYPES.ConditionalExpression:
+      case import_utils47.AST_NODE_TYPES.WhileStatement:
+      case import_utils47.AST_NODE_TYPES.DoWhileStatement:
+      case import_utils47.AST_NODE_TYPES.ForStatement:
         return parent.test === current;
       default:
         return false;
@@ -6577,7 +6720,7 @@ var isGuardTestPosition = (node) => {
 };
 var isUnvalidatedVariableRef = (node, scope, tracked) => {
   const unwrapped = unwrap4(node);
-  if (unwrapped === null || unwrapped.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+  if (unwrapped === null || unwrapped.type !== import_utils47.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const variable = findVariable2(scope, unwrapped.name);
@@ -6620,11 +6763,11 @@ var prefer_schema_for_api_payload_default = createRule({
     return {
       VariableDeclarator(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.id.type === import_utils45.AST_NODE_TYPES.Identifier) {
+        if (node.id.type === import_utils47.AST_NODE_TYPES.Identifier) {
           trackInitializer(node);
           return;
         }
-        if (node.id.type === import_utils45.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils45.AST_NODE_TYPES.ArrayPattern) {
+        if (node.id.type === import_utils47.AST_NODE_TYPES.ObjectPattern || node.id.type === import_utils47.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.init)) {
             if (!isFullyNarrowedPattern(node)) {
               context.report({ node: node.id, messageId: "unparsedJsonAccess" });
@@ -6638,7 +6781,7 @@ var prefer_schema_for_api_payload_default = createRule({
       },
       AssignmentExpression(node) {
         const scope = context.sourceCode.getScope(node);
-        if (node.left.type === import_utils45.AST_NODE_TYPES.Identifier) {
+        if (node.left.type === import_utils47.AST_NODE_TYPES.Identifier) {
           const variable = findVariable2(scope, node.left.name);
           if (variable === null) return;
           if (isRawPayloadSource(node.right)) {
@@ -6648,7 +6791,7 @@ var prefer_schema_for_api_payload_default = createRule({
           }
           return;
         }
-        if (node.left.type === import_utils45.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils45.AST_NODE_TYPES.ArrayPattern) {
+        if (node.left.type === import_utils47.AST_NODE_TYPES.ObjectPattern || node.left.type === import_utils47.AST_NODE_TYPES.ArrayPattern) {
           if (isRawPayloadSource(node.right)) {
             context.report({
               node: node.left,
@@ -6665,15 +6808,15 @@ var prefer_schema_for_api_payload_default = createRule({
         }
       },
       CallExpression(node) {
-        if (node.callee.type !== import_utils45.AST_NODE_TYPES.Identifier) return;
+        if (node.callee.type !== import_utils47.AST_NODE_TYPES.Identifier) return;
         if (!GUARD_NAME_RE.test(node.callee.name) && !isGuardTestPosition(node)) {
           return;
         }
         const scope = context.sourceCode.getScope(node);
         for (const arg of node.arguments) {
-          if (arg.type === import_utils45.AST_NODE_TYPES.SpreadElement) continue;
+          if (arg.type === import_utils47.AST_NODE_TYPES.SpreadElement) continue;
           const unwrapped = unwrap4(arg);
-          if (unwrapped === null || unwrapped.type !== import_utils45.AST_NODE_TYPES.Identifier) {
+          if (unwrapped === null || unwrapped.type !== import_utils47.AST_NODE_TYPES.Identifier) {
             continue;
           }
           const variable = findVariable2(scope, unwrapped.name);
@@ -6687,13 +6830,13 @@ var prefer_schema_for_api_payload_default = createRule({
         const obj = unwrap4(node.object);
         if (isRawPayloadSource(obj)) {
           const parent = node.parent;
-          if (parent.type === import_utils45.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils45.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
+          if (parent.type === import_utils47.AST_NODE_TYPES.CallExpression && parent.callee === node && node.property.type === import_utils47.AST_NODE_TYPES.Identifier && (node.property.name === "parse" || node.property.name === "safeParse" || PROMISE_CHAIN_METHODS.has(node.property.name))) {
             return;
           }
           context.report({ node, messageId: "unparsedJsonAccess" });
           return;
         }
-        if (obj !== null && obj.type === import_utils45.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
+        if (obj !== null && obj.type === import_utils47.AST_NODE_TYPES.Identifier && isUnvalidatedVariableRef(obj, scope, unvalidatedVariables)) {
           context.report({ node, messageId: "unparsedJsonAccess" });
           const variable = findVariable2(scope, obj.name);
           if (variable !== null) {
@@ -6706,7 +6849,7 @@ var prefer_schema_for_api_payload_default = createRule({
 });
 
 // src/rules/prefer-semantic-colors.ts
-var import_utils46 = require("@typescript-eslint/utils");
+var import_utils48 = require("@typescript-eslint/utils");
 var import_fs = require("fs");
 var import_path = require("path");
 
@@ -6783,8 +6926,8 @@ var SVG_EXEMPT_COLOR_VALUES = /* @__PURE__ */ new Set([
 ]);
 function jsxElementName(node) {
   const name = node.openingElement.name;
-  if (name.type === import_utils46.AST_NODE_TYPES.JSXIdentifier) return name.name;
-  if (name.type === import_utils46.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils46.AST_NODE_TYPES.JSXIdentifier) {
+  if (name.type === import_utils48.AST_NODE_TYPES.JSXIdentifier) return name.name;
+  if (name.type === import_utils48.AST_NODE_TYPES.JSXMemberExpression && name.property.type === import_utils48.AST_NODE_TYPES.JSXIdentifier) {
     return name.property.name;
   }
   return null;
@@ -6810,7 +6953,7 @@ var EMAIL_OR_PDF_IMPORT_RE = /@react-(?:email|pdf)\//;
 var isInsideSvg = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils46.AST_NODE_TYPES.JSXElement) {
+    if (current.type === import_utils48.AST_NODE_TYPES.JSXElement) {
       const name = jsxElementName(current);
       if (name !== null && isSvgLikeElementName(name)) return true;
     }
@@ -6821,7 +6964,7 @@ var isInsideSvg = (node) => {
 var isInsideIconFactoryPath = (node) => {
   let current = node.parent;
   while (current !== void 0 && current !== null) {
-    if (current.type === import_utils46.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils46.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils46.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils46.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
+    if (current.type === import_utils48.AST_NODE_TYPES.Property && propName(current.key) === "path" && current.parent.type === import_utils48.AST_NODE_TYPES.ObjectExpression && current.parent.parent.type === import_utils48.AST_NODE_TYPES.CallExpression && current.parent.parent.callee.type === import_utils48.AST_NODE_TYPES.Identifier && current.parent.parent.callee.name === "createIcon") {
       return true;
     }
     current = current.parent;
@@ -6871,8 +7014,8 @@ var hasSemanticTokenSystem = (filename) => {
   return answer;
 };
 var propName = (key) => {
-  if (key.type === import_utils46.AST_NODE_TYPES.Identifier) return key.name;
-  if (key.type === import_utils46.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+  if (key.type === import_utils48.AST_NODE_TYPES.Identifier) return key.name;
+  if (key.type === import_utils48.AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
   return null;
 };
 var prefer_semantic_colors_default = createRule({
@@ -6917,27 +7060,27 @@ var prefer_semantic_colors_default = createRule({
     const checkClassNode = (node) => {
       if (node === null) return;
       switch (node.type) {
-        case import_utils46.AST_NODE_TYPES.Literal:
+        case import_utils48.AST_NODE_TYPES.Literal:
           if (typeof node.value === "string") reportClasses(node.value, node);
           break;
-        case import_utils46.AST_NODE_TYPES.TemplateLiteral:
+        case import_utils48.AST_NODE_TYPES.TemplateLiteral:
           for (const quasi of node.quasis) reportClasses(quasi.value.cooked ?? "", quasi);
           break;
-        case import_utils46.AST_NODE_TYPES.ArrayExpression:
+        case import_utils48.AST_NODE_TYPES.ArrayExpression:
           for (const element of node.elements) {
-            if (element !== null && element.type !== import_utils46.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
+            if (element !== null && element.type !== import_utils48.AST_NODE_TYPES.SpreadElement) checkClassNode(element);
           }
           break;
-        case import_utils46.AST_NODE_TYPES.ObjectExpression:
+        case import_utils48.AST_NODE_TYPES.ObjectExpression:
           for (const property of node.properties) {
-            if (property.type === import_utils46.AST_NODE_TYPES.Property) checkClassNode(property.value);
+            if (property.type === import_utils48.AST_NODE_TYPES.Property) checkClassNode(property.value);
           }
           break;
-        case import_utils46.AST_NODE_TYPES.ConditionalExpression:
+        case import_utils48.AST_NODE_TYPES.ConditionalExpression:
           checkClassNode(node.consequent);
           checkClassNode(node.alternate);
           break;
-        case import_utils46.AST_NODE_TYPES.LogicalExpression:
+        case import_utils48.AST_NODE_TYPES.LogicalExpression:
           checkClassNode(node.right);
           break;
         default:
@@ -6945,29 +7088,29 @@ var prefer_semantic_colors_default = createRule({
       }
     };
     const checkColorValueNode = (node) => {
-      if (node.type === import_utils46.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
+      if (node.type === import_utils48.AST_NODE_TYPES.Literal && typeof node.value === "string" && RAW_COLOR_VALUE_RE.test(node.value) && !CSS_VAR_REFERENCE_RE.test(node.value)) {
         context.report({ node, messageId: "inlineColor", data: { value: node.value } });
       }
     };
     return {
       "JSXAttribute[name.name='className']"(node) {
         if (node.value === null) return;
-        if (node.value.type === import_utils46.AST_NODE_TYPES.Literal) checkClassNode(node.value);
-        else if (node.value.type === import_utils46.AST_NODE_TYPES.JSXExpressionContainer) {
-          if (node.value.expression.type !== import_utils46.AST_NODE_TYPES.JSXEmptyExpression) {
+        if (node.value.type === import_utils48.AST_NODE_TYPES.Literal) checkClassNode(node.value);
+        else if (node.value.type === import_utils48.AST_NODE_TYPES.JSXExpressionContainer) {
+          if (node.value.expression.type !== import_utils48.AST_NODE_TYPES.JSXEmptyExpression) {
             checkClassNode(node.value.expression);
           }
         }
       },
       CallExpression(node) {
-        if (node.callee.type === import_utils46.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
+        if (node.callee.type === import_utils48.AST_NODE_TYPES.Identifier && CLASS_FNS.has(node.callee.name)) {
           for (const arg of node.arguments) {
-            if (arg.type !== import_utils46.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
+            if (arg.type !== import_utils48.AST_NODE_TYPES.SpreadElement) checkClassNode(arg);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type === import_utils46.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
+        if (node.id.type === import_utils48.AST_NODE_TYPES.Identifier && CLASS_NAME_RE.test(node.id.name)) {
           checkClassNode(node.init);
         }
       },
@@ -6979,9 +7122,9 @@ var prefer_semantic_colors_default = createRule({
       // Neutral drawing literals and anything inside an SVG defs container are
       // structural, not UI tokens, so they never fire.
       "JSXAttribute[name.name=/^(fill|stroke|color)$/]"(node) {
-        if (node.value?.type !== import_utils46.AST_NODE_TYPES.Literal) return;
+        if (node.value?.type !== import_utils48.AST_NODE_TYPES.Literal) return;
         const owner = node.parent.name;
-        if (owner.type === import_utils46.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
+        if (owner.type === import_utils48.AST_NODE_TYPES.JSXIdentifier && SVG_SHAPE_PRIMITIVES.has(owner.name)) {
           return;
         }
         if (typeof node.value.value === "string" && SVG_EXEMPT_COLOR_VALUES.has(node.value.value.toLowerCase())) {
@@ -6999,7 +7142,7 @@ var prefer_semantic_colors_default = createRule({
 });
 
 // src/rules/prefer-server-actions.ts
-var import_utils47 = require("@typescript-eslint/utils");
+var import_utils49 = require("@typescript-eslint/utils");
 var MUTATION_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE", "PATCH"]);
 var AXIOS_MUTATION_METHODS = /* @__PURE__ */ new Set(["post", "put", "delete", "patch"]);
 var SKIP_FILE_REGEX = /(?:\.test\.[jt]sx?$|\.spec\.[jt]sx?$|-(?:test|spec)\.[jt]sx?$|\/tests?\/|\/__tests__\/|\/__testfixtures__\/|\/scripts?\/|\/app\/api\/.*\/route\.[jt]sx?$|\/pages\/api\/)/;
@@ -7152,7 +7295,7 @@ var prefer_server_actions_default = createRule({
 });
 
 // src/rules/prefer-string-literal-union.ts
-var import_utils48 = require("@typescript-eslint/utils");
+var import_utils50 = require("@typescript-eslint/utils");
 var ts2 = __toESM(require("typescript"), 1);
 var CHOICE_TOKENS = /* @__PURE__ */ new Set([
   "status",
@@ -7195,19 +7338,19 @@ function isChoiceLikeName(name) {
   return CHOICE_TOKENS.has(lastWord(name));
 }
 function keyName(key) {
-  if (key.type === import_utils48.AST_NODE_TYPES.Identifier) {
+  if (key.type === import_utils50.AST_NODE_TYPES.Identifier) {
     return key.name;
   }
-  if (key.type === import_utils48.AST_NODE_TYPES.Literal && typeof key.value === "string") {
+  if (key.type === import_utils50.AST_NODE_TYPES.Literal && typeof key.value === "string") {
     return key.value;
   }
   return null;
 }
 function isStringLiteralMember(t) {
-  return t.type === import_utils48.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils48.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
+  return t.type === import_utils50.AST_NODE_TYPES.TSLiteralType && t.literal.type === import_utils50.AST_NODE_TYPES.Literal && typeof t.literal.value === "string";
 }
 function isStringLiteralUnion(node) {
-  if (node?.type !== import_utils48.AST_NODE_TYPES.TSUnionType) {
+  if (node?.type !== import_utils50.AST_NODE_TYPES.TSUnionType) {
     return false;
   }
   return node.types.filter(isStringLiteralMember).length >= MIN_CLUSTER_SIZE;
@@ -7236,12 +7379,12 @@ function bindingSourceExpression(decl) {
   return ts2.isForOfStatement(node) ? node.expression : node.initializer;
 }
 function refKey(node) {
-  if (node.type === import_utils48.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils50.AST_NODE_TYPES.Identifier) {
     return node.name;
   }
-  if (node.type === import_utils48.AST_NODE_TYPES.MemberExpression && !node.computed) {
+  if (node.type === import_utils50.AST_NODE_TYPES.MemberExpression && !node.computed) {
     const inner = refKey(node.object);
-    if (inner === null || node.property.type !== import_utils48.AST_NODE_TYPES.Identifier) {
+    if (inner === null || node.property.type !== import_utils50.AST_NODE_TYPES.Identifier) {
       return null;
     }
     return `${inner}.${node.property.name}`;
@@ -7249,7 +7392,7 @@ function refKey(node) {
   return null;
 }
 function strLiteral(node) {
-  if (node.type === import_utils48.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node.type === import_utils50.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
   return null;
@@ -7290,7 +7433,7 @@ var prefer_string_literal_union_default = createRule({
     );
     let services;
     try {
-      services = import_utils48.ESLintUtils.getParserServices(context);
+      services = import_utils50.ESLintUtils.getParserServices(context);
     } catch {
       services = null;
     }
@@ -7402,7 +7545,7 @@ var prefer_string_literal_union_default = createRule({
         containersWithUnion.add(container);
         return;
       }
-      if (typeNode?.type !== import_utils48.AST_NODE_TYPES.TSStringKeyword) {
+      if (typeNode?.type !== import_utils50.AST_NODE_TYPES.TSStringKeyword) {
         return;
       }
       const name = keyName(key);
@@ -7490,10 +7633,10 @@ var prefer_string_literal_union_default = createRule({
       }
     };
     function refKeyText(node) {
-      if (node.type === import_utils48.AST_NODE_TYPES.BinaryExpression) {
+      if (node.type === import_utils50.AST_NODE_TYPES.BinaryExpression) {
         return refKey(node.left) ?? refKey(node.right) ?? "value";
       }
-      if (node.type === import_utils48.AST_NODE_TYPES.SwitchStatement) {
+      if (node.type === import_utils50.AST_NODE_TYPES.SwitchStatement) {
         return refKey(node.discriminant) ?? "value";
       }
       return "value";
@@ -7502,7 +7645,7 @@ var prefer_string_literal_union_default = createRule({
 });
 
 // src/rules/prefer-whole-object-assertion.ts
-var import_utils49 = require("@typescript-eslint/utils");
+var import_utils51 = require("@typescript-eslint/utils");
 var MERGEABLE_MATCHERS = /* @__PURE__ */ new Set(["toBe", "toEqual", "toStrictEqual"]);
 var ARRAY_MATCHERS = /* @__PURE__ */ new Set(["toEqual", "toStrictEqual"]);
 var COLLECTION_PROPERTIES = /* @__PURE__ */ new Set(["length", "size"]);
@@ -7510,11 +7653,11 @@ var NUMERIC_SIGNS2 = /* @__PURE__ */ new Set(["-", "+"]);
 var MIN_RUN_LENGTH = 2;
 function literalText(node, getText) {
   switch (node.type) {
-    case import_utils49.AST_NODE_TYPES.Literal:
+    case import_utils51.AST_NODE_TYPES.Literal:
       return "regex" in node ? null : getText(node);
-    case import_utils49.AST_NODE_TYPES.TemplateLiteral:
+    case import_utils51.AST_NODE_TYPES.TemplateLiteral:
       return node.expressions.length === 0 ? getText(node) : null;
-    case import_utils49.AST_NODE_TYPES.UnaryExpression:
+    case import_utils51.AST_NODE_TYPES.UnaryExpression:
       return NUMERIC_SIGNS2.has(node.operator) && literalText(node.argument, getText) !== null ? getText(node) : null;
     default:
       return null;
@@ -7522,15 +7665,15 @@ function literalText(node, getText) {
 }
 function isPureReceiver(node) {
   switch (node.type) {
-    case import_utils49.AST_NODE_TYPES.Identifier:
-    case import_utils49.AST_NODE_TYPES.ThisExpression:
+    case import_utils51.AST_NODE_TYPES.Identifier:
+    case import_utils51.AST_NODE_TYPES.ThisExpression:
       return true;
-    case import_utils49.AST_NODE_TYPES.MemberExpression:
+    case import_utils51.AST_NODE_TYPES.MemberExpression:
       if (node.optional) {
         return false;
       }
       if (node.computed) {
-        return node.property.type === import_utils49.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
+        return node.property.type === import_utils51.AST_NODE_TYPES.Literal && isPureReceiver(node.object);
       }
       return isPureReceiver(node.object);
     default:
@@ -7538,7 +7681,7 @@ function isPureReceiver(node) {
   }
 }
 function literalIndex(node) {
-  if (node.type !== import_utils49.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
+  if (node.type !== import_utils51.AST_NODE_TYPES.Literal || typeof node.value !== "number") {
     return null;
   }
   return Number.isInteger(node.value) && node.value >= 0 ? node.value : null;
@@ -7564,24 +7707,24 @@ var prefer_whole_object_assertion_default = createRule({
     }
     const { sourceCode } = context;
     function parseAssertion(statement) {
-      if (statement.type !== import_utils49.AST_NODE_TYPES.ExpressionStatement) {
+      if (statement.type !== import_utils51.AST_NODE_TYPES.ExpressionStatement) {
         return null;
       }
       const call = statement.expression;
-      if (call.type !== import_utils49.AST_NODE_TYPES.CallExpression) {
+      if (call.type !== import_utils51.AST_NODE_TYPES.CallExpression) {
         return null;
       }
       const callee = call.callee;
-      if (callee.type !== import_utils49.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils49.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils51.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils51.AST_NODE_TYPES.Identifier) {
         return null;
       }
       const matcher = callee.property.name;
       const expectCall = callee.object;
-      if (expectCall.type !== import_utils49.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils49.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
+      if (expectCall.type !== import_utils51.AST_NODE_TYPES.CallExpression || expectCall.callee.type !== import_utils51.AST_NODE_TYPES.Identifier || expectCall.callee.name !== "expect" || expectCall.arguments.length !== 1) {
         return null;
       }
       const actual = expectCall.arguments[0];
-      if (actual === void 0 || actual.type !== import_utils49.AST_NODE_TYPES.MemberExpression || actual.optional) {
+      if (actual === void 0 || actual.type !== import_utils51.AST_NODE_TYPES.MemberExpression || actual.optional) {
         return null;
       }
       if (!isPureReceiver(actual.object)) {
@@ -7595,7 +7738,7 @@ var prefer_whole_object_assertion_default = createRule({
         }
         key = { kind: "index", index };
       } else {
-        if (actual.property.type !== import_utils49.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(actual.property.name)) {
+        if (actual.property.type !== import_utils51.AST_NODE_TYPES.Identifier || COLLECTION_PROPERTIES.has(actual.property.name)) {
           return null;
         }
         key = { kind: "property", name: actual.property.name };
@@ -7607,7 +7750,7 @@ var prefer_whole_object_assertion_default = createRule({
         return null;
       }
       const expected = call.arguments[0];
-      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils49.AST_NODE_TYPES.SpreadElement) {
+      if (call.arguments.length !== 1 || expected === void 0 || expected.type === import_utils51.AST_NODE_TYPES.SpreadElement) {
         return null;
       }
       const literal = literalText(expected, (node) => sourceCode.getText(node));
@@ -7717,7 +7860,7 @@ var prefer_whole_object_assertion_default = createRule({
 });
 
 // src/rules/prefer-zod-enum.ts
-var import_utils50 = require("@typescript-eslint/utils");
+var import_utils52 = require("@typescript-eslint/utils");
 var prefer_zod_enum_default = createRule({
   name: "prefer-zod-enum",
   meta: {
@@ -7737,20 +7880,20 @@ var prefer_zod_enum_default = createRule({
     const zodNamespaces = /* @__PURE__ */ new Set();
     function enumValues(node) {
       const callee = node.callee;
-      if (callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils50.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
+      if (callee.type !== import_utils52.AST_NODE_TYPES.MemberExpression || callee.computed || callee.object.type !== import_utils52.AST_NODE_TYPES.Identifier || !zodNamespaces.has(callee.object.name) || callee.property.type !== import_utils52.AST_NODE_TYPES.Identifier || callee.property.name !== "union" || node.arguments.length !== 1) {
         return null;
       }
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils50.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
+      if (argument === void 0 || argument.type !== import_utils52.AST_NODE_TYPES.ArrayExpression || argument.elements.length === 0) {
         return null;
       }
       const values = [];
       for (const element of argument.elements) {
-        if (element === null || element.type !== import_utils50.AST_NODE_TYPES.CallExpression || element.arguments.length !== 1 || element.callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils50.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
+        if (element === null || element.type !== import_utils52.AST_NODE_TYPES.CallExpression || element.arguments.length !== 1 || element.callee.type !== import_utils52.AST_NODE_TYPES.MemberExpression || element.callee.computed || element.callee.object.type !== import_utils52.AST_NODE_TYPES.Identifier || !zodNamespaces.has(element.callee.object.name) || element.callee.property.type !== import_utils52.AST_NODE_TYPES.Identifier || element.callee.property.name !== "literal") {
           return null;
         }
         const value = element.arguments[0];
-        if (value === void 0 || value.type !== import_utils50.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
+        if (value === void 0 || value.type !== import_utils52.AST_NODE_TYPES.Literal || typeof value.value !== "string") {
           return null;
         }
         values.push(value);
@@ -7759,11 +7902,11 @@ var prefer_zod_enum_default = createRule({
     }
     function buildFix(node, values) {
       const argument = node.arguments[0];
-      if (argument === void 0 || argument.type !== import_utils50.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
+      if (argument === void 0 || argument.type !== import_utils52.AST_NODE_TYPES.ArrayExpression || sourceCode.getCommentsInside(argument).length > 0) {
         return void 0;
       }
       const callee = node.callee;
-      if (callee.type !== import_utils50.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils50.AST_NODE_TYPES.Identifier) {
+      if (callee.type !== import_utils52.AST_NODE_TYPES.MemberExpression || callee.property.type !== import_utils52.AST_NODE_TYPES.Identifier) {
         return void 0;
       }
       return (fixer) => [
@@ -7780,7 +7923,7 @@ var prefer_zod_enum_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils50.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils50.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils50.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils50.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils52.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils52.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils52.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils52.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
@@ -7802,7 +7945,7 @@ var prefer_zod_enum_default = createRule({
 });
 
 // src/rules/prefer-zod-infer.ts
-var import_utils51 = require("@typescript-eslint/utils");
+var import_utils53 = require("@typescript-eslint/utils");
 var SHAPE_PRESERVING_METHODS = /* @__PURE__ */ new Set([
   "describe",
   "refine",
@@ -7839,44 +7982,44 @@ var ZOD_TYPE_CONSTRAINTS = /* @__PURE__ */ new Set([
   "Schema"
 ]);
 var LEAF_NODE_TYPES = {
-  string: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  email: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  url: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  uuid: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  ulid: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  cuid: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  cuid2: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  nanoid: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  iso: [import_utils51.AST_NODE_TYPES.TSStringKeyword],
-  number: [import_utils51.AST_NODE_TYPES.TSNumberKeyword],
-  int: [import_utils51.AST_NODE_TYPES.TSNumberKeyword],
-  float32: [import_utils51.AST_NODE_TYPES.TSNumberKeyword],
-  float64: [import_utils51.AST_NODE_TYPES.TSNumberKeyword],
-  boolean: [import_utils51.AST_NODE_TYPES.TSBooleanKeyword],
-  bigint: [import_utils51.AST_NODE_TYPES.TSBigIntKeyword],
-  symbol: [import_utils51.AST_NODE_TYPES.TSSymbolKeyword],
-  any: [import_utils51.AST_NODE_TYPES.TSAnyKeyword],
-  unknown: [import_utils51.AST_NODE_TYPES.TSUnknownKeyword],
-  never: [import_utils51.AST_NODE_TYPES.TSNeverKeyword],
-  void: [import_utils51.AST_NODE_TYPES.TSVoidKeyword],
-  null: [import_utils51.AST_NODE_TYPES.TSNullKeyword],
-  undefined: [import_utils51.AST_NODE_TYPES.TSUndefinedKeyword],
-  literal: [import_utils51.AST_NODE_TYPES.TSLiteralType],
-  date: [import_utils51.AST_NODE_TYPES.TSTypeReference],
-  array: [import_utils51.AST_NODE_TYPES.TSArrayType, import_utils51.AST_NODE_TYPES.TSTypeReference],
-  tuple: [import_utils51.AST_NODE_TYPES.TSTupleType],
-  object: [import_utils51.AST_NODE_TYPES.TSTypeLiteral, import_utils51.AST_NODE_TYPES.TSTypeReference],
-  strictObject: [import_utils51.AST_NODE_TYPES.TSTypeLiteral, import_utils51.AST_NODE_TYPES.TSTypeReference],
-  looseObject: [import_utils51.AST_NODE_TYPES.TSTypeLiteral, import_utils51.AST_NODE_TYPES.TSTypeReference],
-  record: [import_utils51.AST_NODE_TYPES.TSTypeReference, import_utils51.AST_NODE_TYPES.TSTypeLiteral],
-  map: [import_utils51.AST_NODE_TYPES.TSTypeReference],
-  set: [import_utils51.AST_NODE_TYPES.TSTypeReference],
-  promise: [import_utils51.AST_NODE_TYPES.TSTypeReference],
-  enum: [import_utils51.AST_NODE_TYPES.TSUnionType, import_utils51.AST_NODE_TYPES.TSTypeReference, import_utils51.AST_NODE_TYPES.TSLiteralType],
-  nativeEnum: [import_utils51.AST_NODE_TYPES.TSUnionType, import_utils51.AST_NODE_TYPES.TSTypeReference, import_utils51.AST_NODE_TYPES.TSLiteralType],
-  union: [import_utils51.AST_NODE_TYPES.TSUnionType, import_utils51.AST_NODE_TYPES.TSTypeReference],
-  discriminatedUnion: [import_utils51.AST_NODE_TYPES.TSUnionType, import_utils51.AST_NODE_TYPES.TSTypeReference],
-  intersection: [import_utils51.AST_NODE_TYPES.TSIntersectionType, import_utils51.AST_NODE_TYPES.TSTypeReference]
+  string: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  email: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  url: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  uuid: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  ulid: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  cuid: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  cuid2: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  nanoid: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  iso: [import_utils53.AST_NODE_TYPES.TSStringKeyword],
+  number: [import_utils53.AST_NODE_TYPES.TSNumberKeyword],
+  int: [import_utils53.AST_NODE_TYPES.TSNumberKeyword],
+  float32: [import_utils53.AST_NODE_TYPES.TSNumberKeyword],
+  float64: [import_utils53.AST_NODE_TYPES.TSNumberKeyword],
+  boolean: [import_utils53.AST_NODE_TYPES.TSBooleanKeyword],
+  bigint: [import_utils53.AST_NODE_TYPES.TSBigIntKeyword],
+  symbol: [import_utils53.AST_NODE_TYPES.TSSymbolKeyword],
+  any: [import_utils53.AST_NODE_TYPES.TSAnyKeyword],
+  unknown: [import_utils53.AST_NODE_TYPES.TSUnknownKeyword],
+  never: [import_utils53.AST_NODE_TYPES.TSNeverKeyword],
+  void: [import_utils53.AST_NODE_TYPES.TSVoidKeyword],
+  null: [import_utils53.AST_NODE_TYPES.TSNullKeyword],
+  undefined: [import_utils53.AST_NODE_TYPES.TSUndefinedKeyword],
+  literal: [import_utils53.AST_NODE_TYPES.TSLiteralType],
+  date: [import_utils53.AST_NODE_TYPES.TSTypeReference],
+  array: [import_utils53.AST_NODE_TYPES.TSArrayType, import_utils53.AST_NODE_TYPES.TSTypeReference],
+  tuple: [import_utils53.AST_NODE_TYPES.TSTupleType],
+  object: [import_utils53.AST_NODE_TYPES.TSTypeLiteral, import_utils53.AST_NODE_TYPES.TSTypeReference],
+  strictObject: [import_utils53.AST_NODE_TYPES.TSTypeLiteral, import_utils53.AST_NODE_TYPES.TSTypeReference],
+  looseObject: [import_utils53.AST_NODE_TYPES.TSTypeLiteral, import_utils53.AST_NODE_TYPES.TSTypeReference],
+  record: [import_utils53.AST_NODE_TYPES.TSTypeReference, import_utils53.AST_NODE_TYPES.TSTypeLiteral],
+  map: [import_utils53.AST_NODE_TYPES.TSTypeReference],
+  set: [import_utils53.AST_NODE_TYPES.TSTypeReference],
+  promise: [import_utils53.AST_NODE_TYPES.TSTypeReference],
+  enum: [import_utils53.AST_NODE_TYPES.TSUnionType, import_utils53.AST_NODE_TYPES.TSTypeReference, import_utils53.AST_NODE_TYPES.TSLiteralType],
+  nativeEnum: [import_utils53.AST_NODE_TYPES.TSUnionType, import_utils53.AST_NODE_TYPES.TSTypeReference, import_utils53.AST_NODE_TYPES.TSLiteralType],
+  union: [import_utils53.AST_NODE_TYPES.TSUnionType, import_utils53.AST_NODE_TYPES.TSTypeReference],
+  discriminatedUnion: [import_utils53.AST_NODE_TYPES.TSUnionType, import_utils53.AST_NODE_TYPES.TSTypeReference],
+  intersection: [import_utils53.AST_NODE_TYPES.TSIntersectionType, import_utils53.AST_NODE_TYPES.TSTypeReference]
 };
 function normalizeSchemaName(name) {
   return name.replace(/Schema$/i, "").replace(/^Z(?=[A-Z])/, "").toLowerCase();
@@ -7885,20 +8028,20 @@ function normalizeTypeName(name) {
   return name.replace(/Type$/, "").toLowerCase();
 }
 function unwrapNullish(annotation) {
-  if (annotation.type !== import_utils51.AST_NODE_TYPES.TSUnionType) {
+  if (annotation.type !== import_utils53.AST_NODE_TYPES.TSUnionType) {
     return {
       core: annotation,
-      nullable: annotation.type === import_utils51.AST_NODE_TYPES.TSNullKeyword
+      nullable: annotation.type === import_utils53.AST_NODE_TYPES.TSNullKeyword
     };
   }
   const rest = [];
   let nullable = false;
   for (const member of annotation.types) {
-    if (member.type === import_utils51.AST_NODE_TYPES.TSNullKeyword) {
+    if (member.type === import_utils53.AST_NODE_TYPES.TSNullKeyword) {
       nullable = true;
       continue;
     }
-    if (member.type === import_utils51.AST_NODE_TYPES.TSUndefinedKeyword) {
+    if (member.type === import_utils53.AST_NODE_TYPES.TSUndefinedKeyword) {
       continue;
     }
     rest.push(member);
@@ -7963,14 +8106,14 @@ var prefer_zod_infer_default = createRule({
     function zodCallChain(node) {
       const chain = [];
       let current = node;
-      while (current.type === import_utils51.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils53.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils51.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier) {
           return null;
         }
         chain.push(current);
         const receiver = callee.object;
-        if (receiver.type === import_utils51.AST_NODE_TYPES.Identifier) {
+        if (receiver.type === import_utils53.AST_NODE_TYPES.Identifier) {
           return zodNamespaces.has(receiver.name) ? chain.reverse() : null;
         }
         current = receiver;
@@ -7979,19 +8122,19 @@ var prefer_zod_infer_default = createRule({
     }
     function methodName(call) {
       const callee = call.callee;
-      return callee.type === import_utils51.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils51.AST_NODE_TYPES.Identifier ? callee.property.name : "";
+      return callee.type === import_utils53.AST_NODE_TYPES.MemberExpression && callee.property.type === import_utils53.AST_NODE_TYPES.Identifier ? callee.property.name : "";
     }
     function schemaField(node) {
       const modifiers = [];
       let current = node;
       let leaf = null;
-      while (current.type === import_utils51.AST_NODE_TYPES.CallExpression) {
+      while (current.type === import_utils53.AST_NODE_TYPES.CallExpression) {
         const callee = current.callee;
-        if (callee.type !== import_utils51.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils51.AST_NODE_TYPES.Identifier) {
+        if (callee.type !== import_utils53.AST_NODE_TYPES.MemberExpression || callee.computed || callee.property.type !== import_utils53.AST_NODE_TYPES.Identifier) {
           break;
         }
         const receiver = callee.object;
-        if (receiver.type === import_utils51.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
+        if (receiver.type === import_utils53.AST_NODE_TYPES.Identifier && zodNamespaces.has(receiver.name)) {
           leaf = callee.property.name;
           break;
         }
@@ -8022,16 +8165,16 @@ var prefer_zod_infer_default = createRule({
         return null;
       }
       const shape = base.arguments[0];
-      if (shape === void 0 || shape.type !== import_utils51.AST_NODE_TYPES.ObjectExpression) {
+      if (shape === void 0 || shape.type !== import_utils53.AST_NODE_TYPES.ObjectExpression) {
         return null;
       }
       const fields = /* @__PURE__ */ new Map();
       for (const property of shape.properties) {
-        if (property.type !== import_utils51.AST_NODE_TYPES.Property || property.computed) {
+        if (property.type !== import_utils53.AST_NODE_TYPES.Property || property.computed) {
           return null;
         }
         const { key } = property;
-        const name = key.type === import_utils51.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils51.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils53.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils53.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -8042,11 +8185,11 @@ var prefer_zod_infer_default = createRule({
     function typeMembers(members) {
       const result = /* @__PURE__ */ new Map();
       for (const member of members) {
-        if (member.type !== import_utils51.AST_NODE_TYPES.TSPropertySignature || member.computed) {
+        if (member.type !== import_utils53.AST_NODE_TYPES.TSPropertySignature || member.computed) {
           return null;
         }
         const { key } = member;
-        const name = key.type === import_utils51.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils51.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
+        const name = key.type === import_utils53.AST_NODE_TYPES.Identifier ? key.name : key.type === import_utils53.AST_NODE_TYPES.Literal && typeof key.value === "string" ? key.value : null;
         if (name === null) {
           return null;
         }
@@ -8060,8 +8203,8 @@ var prefer_zod_infer_default = createRule({
       return result.size === 0 ? null : result;
     }
     function collectConstrainedNames(node) {
-      if (node.type === import_utils51.AST_NODE_TYPES.TSTypeReference) {
-        if (node.typeName.type === import_utils51.AST_NODE_TYPES.Identifier) {
+      if (node.type === import_utils53.AST_NODE_TYPES.TSTypeReference) {
+        if (node.typeName.type === import_utils53.AST_NODE_TYPES.Identifier) {
           constrainedTypeNames.add(node.typeName.name);
         }
         for (const argument of node.typeArguments?.params ?? []) {
@@ -8069,11 +8212,11 @@ var prefer_zod_infer_default = createRule({
         }
         return;
       }
-      if (node.type === import_utils51.AST_NODE_TYPES.TSArrayType) {
+      if (node.type === import_utils53.AST_NODE_TYPES.TSArrayType) {
         collectConstrainedNames(node.elementType);
         return;
       }
-      if (node.type === import_utils51.AST_NODE_TYPES.TSUnionType || node.type === import_utils51.AST_NODE_TYPES.TSIntersectionType) {
+      if (node.type === import_utils53.AST_NODE_TYPES.TSUnionType || node.type === import_utils53.AST_NODE_TYPES.TSIntersectionType) {
         for (const member of node.types) {
           collectConstrainedNames(member);
         }
@@ -8117,13 +8260,13 @@ var prefer_zod_infer_default = createRule({
           return;
         }
         for (const specifier of node.specifiers) {
-          if (specifier.type === import_utils51.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils51.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils51.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils51.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
+          if (specifier.type === import_utils53.AST_NODE_TYPES.ImportNamespaceSpecifier || specifier.type === import_utils53.AST_NODE_TYPES.ImportDefaultSpecifier || specifier.type === import_utils53.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === import_utils53.AST_NODE_TYPES.Identifier && specifier.imported.name === "z") {
             zodNamespaces.add(specifier.local.name);
           }
         }
       },
       VariableDeclarator(node) {
-        if (node.id.type !== import_utils51.AST_NODE_TYPES.Identifier || node.init == null) {
+        if (node.id.type !== import_utils53.AST_NODE_TYPES.Identifier || node.init == null) {
           return;
         }
         const fields = schemaFields(node.init);
@@ -8133,14 +8276,14 @@ var prefer_zod_infer_default = createRule({
       },
       /** Guard (f): `XSchema.transform(...)` anywhere in the module. */
       "MemberExpression[computed=false]"(node) {
-        if (node.object.type === import_utils51.AST_NODE_TYPES.Identifier && node.property.type === import_utils51.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
+        if (node.object.type === import_utils53.AST_NODE_TYPES.Identifier && node.property.type === import_utils53.AST_NODE_TYPES.Identifier && MODULE_LEVEL_RESHAPERS.has(node.property.name)) {
           reshapedSchemaNames.add(node.object.name);
         }
       },
       /** Guard (c): `z.ZodType<T>` and every other type argument it carries. */
       TSTypeReference(node) {
         const { typeName } = node;
-        const referenced = typeName.type === import_utils51.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils51.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils51.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
+        const referenced = typeName.type === import_utils53.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils53.AST_NODE_TYPES.TSQualifiedName && typeName.right.type === import_utils53.AST_NODE_TYPES.Identifier ? typeName.right.name : null;
         if (referenced === null || !ZOD_TYPE_CONSTRAINTS.has(referenced)) {
           return;
         }
@@ -8158,7 +8301,7 @@ var prefer_zod_infer_default = createRule({
         }
       },
       TSTypeAliasDeclaration(node) {
-        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils51.AST_NODE_TYPES.TSTypeLiteral) {
+        if (node.typeParameters !== void 0 || node.typeAnnotation.type !== import_utils53.AST_NODE_TYPES.TSTypeLiteral) {
           return;
         }
         const members = typeMembers(node.typeAnnotation.members);
@@ -8203,36 +8346,36 @@ var prefer_zod_infer_default = createRule({
 });
 
 // src/rules/require-assert-never.ts
-var import_utils52 = require("@typescript-eslint/utils");
+var import_utils54 = require("@typescript-eslint/utils");
 var isAssertNeverCall = (expression) => {
-  if (expression.type !== import_utils52.AST_NODE_TYPES.CallExpression) return false;
+  if (expression.type !== import_utils54.AST_NODE_TYPES.CallExpression) return false;
   const callee = expression.callee;
-  if (callee.type === import_utils52.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils54.AST_NODE_TYPES.Identifier) {
     return callee.name === "assertNever";
   }
-  if (callee.type === import_utils52.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils52.AST_NODE_TYPES.Identifier) {
+  if (callee.type === import_utils54.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils54.AST_NODE_TYPES.Identifier) {
     return callee.property.name === "assertNever";
   }
   return false;
 };
 var statementContainsAssertNever = (statement) => {
-  if (statement.type === import_utils52.AST_NODE_TYPES.ExpressionStatement) {
+  if (statement.type === import_utils54.AST_NODE_TYPES.ExpressionStatement) {
     return isAssertNeverCall(statement.expression);
   }
-  if (statement.type === import_utils52.AST_NODE_TYPES.ThrowStatement) {
+  if (statement.type === import_utils54.AST_NODE_TYPES.ThrowStatement) {
     return isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils52.AST_NODE_TYPES.ReturnStatement) {
+  if (statement.type === import_utils54.AST_NODE_TYPES.ReturnStatement) {
     return statement.argument !== null && isAssertNeverCall(statement.argument);
   }
-  if (statement.type === import_utils52.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils54.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(statementContainsAssertNever);
   }
   return false;
 };
 var isRuntimeHandlingStatement = (statement) => {
-  if (statement.type === import_utils52.AST_NODE_TYPES.EmptyStatement) return false;
-  if (statement.type === import_utils52.AST_NODE_TYPES.BlockStatement) {
+  if (statement.type === import_utils54.AST_NODE_TYPES.EmptyStatement) return false;
+  if (statement.type === import_utils54.AST_NODE_TYPES.BlockStatement) {
     return statement.body.some(isRuntimeHandlingStatement);
   }
   return true;
@@ -8248,7 +8391,7 @@ var isCommentOnlyNoopDefault = (defaultCase, sourceCode) => {
     return colonToken !== null && sourceCode.getCommentsAfter(colonToken).length > 0;
   }
   const only = defaultCase.consequent[0];
-  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils52.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
+  if (only !== void 0 && defaultCase.consequent.length === 1 && only.type === import_utils54.AST_NODE_TYPES.BlockStatement && only.body.length === 0) {
     return sourceCode.getCommentsInside(only).length > 0;
   }
   return false;
@@ -8289,7 +8432,7 @@ var require_assert_never_default = createRule({
 });
 
 // src/rules/require-fetch-timeout.ts
-var import_utils53 = require("@typescript-eslint/utils");
+var import_utils55 = require("@typescript-eslint/utils");
 var CODEMOD_FIXTURE_RE = /[\\/]__testfixtures__[\\/]/;
 var GLOBAL_OBJECTS2 = /* @__PURE__ */ new Set([
   "globalThis",
@@ -8306,14 +8449,14 @@ function matchesAnyPattern3(filename, patterns) {
   return false;
 }
 function initProvablyLacksSignal(init) {
-  if (init.type !== import_utils53.AST_NODE_TYPES.ObjectExpression) {
+  if (init.type !== import_utils55.AST_NODE_TYPES.ObjectExpression) {
     return false;
   }
   for (const prop of init.properties) {
-    if (prop.type === import_utils53.AST_NODE_TYPES.SpreadElement) {
+    if (prop.type === import_utils55.AST_NODE_TYPES.SpreadElement) {
       return false;
     }
-    if (prop.key.type === import_utils53.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils53.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
+    if (prop.key.type === import_utils55.AST_NODE_TYPES.Identifier && prop.key.name === "signal" || prop.key.type === import_utils55.AST_NODE_TYPES.Literal && prop.key.value === "signal") {
       return false;
     }
     if (prop.computed) {
@@ -8323,7 +8466,7 @@ function initProvablyLacksSignal(init) {
   return true;
 }
 function isStringish(node) {
-  return node.type === import_utils53.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils53.AST_NODE_TYPES.TemplateLiteral;
+  return node.type === import_utils55.AST_NODE_TYPES.Literal && typeof node.value === "string" || node.type === import_utils55.AST_NODE_TYPES.TemplateLiteral;
 }
 var require_fetch_timeout_default = createRule({
   name: "require-fetch-timeout",
@@ -8360,14 +8503,14 @@ var require_fetch_timeout_default = createRule({
     }
     function resolvesToGlobal(identifier) {
       const scope = context.sourceCode.getScope(identifier);
-      const variable = import_utils53.ASTUtils.findVariable(scope, identifier.name);
+      const variable = import_utils55.ASTUtils.findVariable(scope, identifier.name);
       return variable === null || variable.defs.length === 0;
     }
     function isGlobalFetchCall2(callee) {
-      if (callee.type === import_utils53.AST_NODE_TYPES.Identifier) {
+      if (callee.type === import_utils55.AST_NODE_TYPES.Identifier) {
         return callee.name === "fetch" && resolvesToGlobal(callee);
       }
-      return callee.type === import_utils53.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils53.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils53.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
+      return callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && callee.property.name === "fetch" && callee.object.type === import_utils55.AST_NODE_TYPES.Identifier && GLOBAL_OBJECTS2.has(callee.object.name) && resolvesToGlobal(callee.object);
     }
     return {
       CallExpression(node) {
@@ -8387,26 +8530,26 @@ var require_fetch_timeout_default = createRule({
 });
 
 // src/rules/require-interface-for-injected-service.ts
-var import_utils54 = require("@typescript-eslint/utils");
+var import_utils56 = require("@typescript-eslint/utils");
 var CONFIGISH_TYPE_RE = /(?:Options|Opts|Config|Configuration|Settings|Params|Props|Args|Env|Environment|Callbacks|Flags)$/;
 var CONFIGISH_NAME_RE = /^(?:options|opts|config|configuration|settings|params|props|args|env|environment|callbacks|flags|logger|log|clock)$/i;
 var HTTP_TRANSPORT_TYPE_RE = /^(?:KyInstance|AxiosInstance|Session)$/;
 var TRANSPORT_WRAPPER_NAME_RE = /Client$/;
 var ROUTER_FACTORY_NAME = "Router";
 var FRAMEWORK_HTTP_TYPES = /* @__PURE__ */ new Set(["Request", "Response", "NextFunction"]);
-var isExportedClass = (node) => node.parent.type === import_utils54.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils54.AST_NODE_TYPES.ExportDefaultDeclaration;
-var qualifiedName = (name) => name.type === import_utils54.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils54.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
+var isExportedClass = (node) => node.parent.type === import_utils56.AST_NODE_TYPES.ExportNamedDeclaration || node.parent.type === import_utils56.AST_NODE_TYPES.ExportDefaultDeclaration;
+var qualifiedName = (name) => name.type === import_utils56.AST_NODE_TYPES.Identifier ? name.name : name.type === import_utils56.AST_NODE_TYPES.TSQualifiedName ? `${qualifiedName(name.left)}.${name.right.name}` : "";
 var typeReferenceName = (annotated) => {
   let target = annotated;
-  if (target.type === import_utils54.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
-  if (target.type === import_utils54.AST_NODE_TYPES.AssignmentPattern) target = target.left;
-  if (target.type !== import_utils54.AST_NODE_TYPES.Identifier) return null;
+  if (target.type === import_utils56.AST_NODE_TYPES.TSParameterProperty) target = target.parameter;
+  if (target.type === import_utils56.AST_NODE_TYPES.AssignmentPattern) target = target.left;
+  if (target.type !== import_utils56.AST_NODE_TYPES.Identifier) return null;
   const annotation = target.typeAnnotation?.typeAnnotation;
-  if (annotation === void 0 || annotation.type !== import_utils54.AST_NODE_TYPES.TSTypeReference) {
+  if (annotation === void 0 || annotation.type !== import_utils56.AST_NODE_TYPES.TSTypeReference) {
     return null;
   }
   const { typeName } = annotation;
-  const rightmost = typeName.type === import_utils54.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils54.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
+  const rightmost = typeName.type === import_utils56.AST_NODE_TYPES.Identifier ? typeName.name : typeName.type === import_utils56.AST_NODE_TYPES.TSQualifiedName ? typeName.right.name : null;
   if (rightmost === null) return null;
   return { name: target.name, typeName: rightmost, display: qualifiedName(typeName) };
 };
@@ -8416,17 +8559,17 @@ var readConstructor = (ctor) => {
   let constructedFields = 0;
   if (body !== null && body !== void 0) {
     for (const statement of body.body) {
-      if (statement.type !== import_utils54.AST_NODE_TYPES.ExpressionStatement) continue;
+      if (statement.type !== import_utils56.AST_NODE_TYPES.ExpressionStatement) continue;
       const expression = statement.expression;
-      if (expression.type !== import_utils54.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils54.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils54.AST_NODE_TYPES.ThisExpression) {
+      if (expression.type !== import_utils56.AST_NODE_TYPES.AssignmentExpression || expression.operator !== "=" || expression.left.type !== import_utils56.AST_NODE_TYPES.MemberExpression || expression.left.object.type !== import_utils56.AST_NODE_TYPES.ThisExpression) {
         continue;
       }
       const source = expression.right;
-      if (source.type === import_utils54.AST_NODE_TYPES.NewExpression) {
+      if (source.type === import_utils56.AST_NODE_TYPES.NewExpression) {
         constructedFields += 1;
-      } else if (source.type === import_utils54.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils56.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.name);
-      } else if (source.type === import_utils54.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils54.AST_NODE_TYPES.Identifier) {
+      } else if (source.type === import_utils56.AST_NODE_TYPES.MemberExpression && source.object.type === import_utils56.AST_NODE_TYPES.Identifier) {
         storedFrom.add(source.object.name);
       }
     }
@@ -8435,7 +8578,7 @@ var readConstructor = (ctor) => {
   for (const parameter of ctor.value.params) {
     const reference = typeReferenceName(parameter);
     if (reference === null) continue;
-    const stored = parameter.type === import_utils54.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
+    const stored = parameter.type === import_utils56.AST_NODE_TYPES.TSParameterProperty || storedFrom.has(reference.name);
     if (!stored) continue;
     if (CONFIGISH_TYPE_RE.test(reference.typeName)) continue;
     if (CONFIGISH_NAME_RE.test(reference.name)) continue;
@@ -8465,19 +8608,19 @@ var subtreeHas = (root, found) => {
   return hit;
 };
 var isFrameworkWiring = (body) => subtreeHas(body, (node) => {
-  if (node.type === import_utils54.AST_NODE_TYPES.CallExpression) {
+  if (node.type === import_utils56.AST_NODE_TYPES.CallExpression) {
     const { callee } = node;
-    if (callee.type === import_utils54.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
-    return callee.type === import_utils54.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils54.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
+    if (callee.type === import_utils56.AST_NODE_TYPES.Identifier) return callee.name === ROUTER_FACTORY_NAME;
+    return callee.type === import_utils56.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils56.AST_NODE_TYPES.Identifier && callee.property.name === ROUTER_FACTORY_NAME;
   }
-  return node.type === import_utils54.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils54.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
+  return node.type === import_utils56.AST_NODE_TYPES.TSTypeReference && node.typeName.type === import_utils56.AST_NODE_TYPES.TSQualifiedName && FRAMEWORK_HTTP_TYPES.has(node.typeName.right.name);
 });
 var stem2 = (name) => name.replace(/^I(?=[A-Z])/, "").replace(/Impl$/, "");
 var fileInterfaceNames = (program) => {
   const names = [];
   for (const statement of program.body) {
-    const declaration = statement.type === import_utils54.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
-    if (declaration?.type === import_utils54.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
+    const declaration = statement.type === import_utils56.AST_NODE_TYPES.ExportNamedDeclaration ? statement.declaration : statement;
+    if (declaration?.type === import_utils56.AST_NODE_TYPES.TSInterfaceDeclaration) names.push(declaration.id.name);
   }
   return names;
 };
@@ -8495,11 +8638,11 @@ var isTransportWrapper = (className, collaborators, program) => {
 var publicMethodNames = (body) => {
   const names = [];
   for (const member of body.body) {
-    if (member.type !== import_utils54.AST_NODE_TYPES.MethodDefinition) continue;
+    if (member.type !== import_utils56.AST_NODE_TYPES.MethodDefinition) continue;
     if (member.kind !== "method" || member.static) continue;
     if (member.accessibility === "private" || member.accessibility === "protected") continue;
-    if (member.key.type === import_utils54.AST_NODE_TYPES.PrivateIdentifier) continue;
-    if (member.key.type === import_utils54.AST_NODE_TYPES.Identifier) names.push(member.key.name);
+    if (member.key.type === import_utils56.AST_NODE_TYPES.PrivateIdentifier) continue;
+    if (member.key.type === import_utils56.AST_NODE_TYPES.Identifier) names.push(member.key.name);
     else names.push("\u2026");
   }
   return names;
@@ -8530,7 +8673,7 @@ var require_interface_for_injected_service_default = createRule({
         if (node.implements.length > 0) return;
         if (node.decorators.length > 0) return;
         const ctor = node.body.body.find(
-          (member) => member.type === import_utils54.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
+          (member) => member.type === import_utils56.AST_NODE_TYPES.MethodDefinition && member.kind === "constructor"
         );
         if (ctor === void 0) return;
         const { collaborators, constructedFields } = readConstructor(ctor);
@@ -8555,18 +8698,18 @@ var require_interface_for_injected_service_default = createRule({
 });
 
 // src/rules/require-zod-form-validation.ts
-var import_utils55 = require("@typescript-eslint/utils");
+var import_utils57 = require("@typescript-eslint/utils");
 var looksLikeZodSchema = (node) => {
   let current = node;
   while (true) {
-    if (current.type === import_utils55.AST_NODE_TYPES.Identifier) {
+    if (current.type === import_utils57.AST_NODE_TYPES.Identifier) {
       return current.name === "z" || ZOD_SCHEMA_NAME_RE.test(current.name);
     }
-    if (current.type === import_utils55.AST_NODE_TYPES.CallExpression) {
+    if (current.type === import_utils57.AST_NODE_TYPES.CallExpression) {
       current = current.callee;
       continue;
     }
-    if (current.type === import_utils55.AST_NODE_TYPES.MemberExpression) {
+    if (current.type === import_utils57.AST_NODE_TYPES.MemberExpression) {
       current = current.object;
       continue;
     }
@@ -8574,23 +8717,23 @@ var looksLikeZodSchema = (node) => {
   }
 };
 var isZodParseCall = (node) => {
-  if (node.type !== import_utils55.AST_NODE_TYPES.CallExpression) return false;
+  if (node.type !== import_utils57.AST_NODE_TYPES.CallExpression) return false;
   const callee = node.callee;
-  if (callee.type !== import_utils55.AST_NODE_TYPES.MemberExpression) return false;
+  if (callee.type !== import_utils57.AST_NODE_TYPES.MemberExpression) return false;
   if (callee.computed) return false;
-  if (callee.property.type !== import_utils55.AST_NODE_TYPES.Identifier) return false;
+  if (callee.property.type !== import_utils57.AST_NODE_TYPES.Identifier) return false;
   const method = callee.property.name;
   if (method !== "parse" && method !== "safeParse") return false;
   return looksLikeZodSchema(callee.object);
 };
 var isFormDataMethodCall = (node) => {
   let current = node;
-  if (current.type === import_utils55.AST_NODE_TYPES.AwaitExpression) {
+  if (current.type === import_utils57.AST_NODE_TYPES.AwaitExpression) {
     current = current.argument;
   }
-  if (current.type !== import_utils55.AST_NODE_TYPES.CallExpression) return false;
+  if (current.type !== import_utils57.AST_NODE_TYPES.CallExpression) return false;
   const callee = current.callee;
-  return callee.type === import_utils55.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils55.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
+  return callee.type === import_utils57.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils57.AST_NODE_TYPES.Identifier && callee.property.name === "formData";
 };
 var require_zod_form_validation_default = createRule({
   name: "require-zod-form-validation",
@@ -8610,14 +8753,14 @@ var require_zod_form_validation_default = createRule({
       return {};
     }
     const isFormSourceIdentifier = (node) => {
-      if (node.type !== import_utils55.AST_NODE_TYPES.Identifier) return false;
+      if (node.type !== import_utils57.AST_NODE_TYPES.Identifier) return false;
       if (/formdata/i.test(node.name)) return true;
       let scope = context.sourceCode.getScope(node);
       while (scope !== null) {
         const variable = scope.set.get(node.name);
         if (variable !== void 0 && variable.defs.length === 1) {
           const def = variable.defs[0];
-          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils55.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
+          if (def !== void 0 && def.type === "Variable" && def.node.type === import_utils57.AST_NODE_TYPES.VariableDeclarator && def.node.init !== null) {
             return isFormDataMethodCall(def.node.init);
           }
           return false;
@@ -8628,8 +8771,8 @@ var require_zod_form_validation_default = createRule({
     };
     const isFormDataGetCall = (node) => {
       const callee = node.callee;
-      if (callee.type !== import_utils55.AST_NODE_TYPES.MemberExpression) return false;
-      if (callee.property.type !== import_utils55.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
+      if (callee.type !== import_utils57.AST_NODE_TYPES.MemberExpression) return false;
+      if (callee.property.type !== import_utils57.AST_NODE_TYPES.Identifier || callee.property.name !== "get") {
         return false;
       }
       return isFormSourceIdentifier(callee.object);
@@ -8644,11 +8787,11 @@ var require_zod_form_validation_default = createRule({
     };
     const isInstanceofNarrowing = (node) => {
       const parent = node.parent;
-      return parent !== null && parent !== void 0 && parent.type === import_utils55.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node;
+      return parent !== null && parent !== void 0 && parent.type === import_utils57.AST_NODE_TYPES.BinaryExpression && parent.operator === "instanceof" && parent.left === node;
     };
     const boundDeclarator = (node) => {
       const parent = node.parent;
-      if (parent.type === import_utils55.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils55.AST_NODE_TYPES.Identifier) {
+      if (parent.type === import_utils57.AST_NODE_TYPES.VariableDeclarator && parent.init === node && parent.id.type === import_utils57.AST_NODE_TYPES.Identifier) {
         return parent;
       }
       return null;
@@ -8676,7 +8819,7 @@ var require_zod_form_validation_default = createRule({
 });
 
 // src/rules/store-insert-requires-on-conflict.ts
-var import_utils56 = require("@typescript-eslint/utils");
+var import_utils58 = require("@typescript-eslint/utils");
 var INSERT_WRITE = /\bINSERT\s+(?:OR\s+\w+\s+)?INTO\s+[\w."'`?$:@-]+\s*(?:\([^)]*\)\s*)?(?:VALUES|SELECT|DEFAULT\s+VALUES)\b/i;
 var CONFLICT_HANDLED = /\bON\s+CONFLICT\b|\bON\s+DUPLICATE\s+KEY\b|\bINSERT\s+OR\s+(?:IGNORE|REPLACE)\b/i;
 var INSERT_GATE = /insert/i;
@@ -8707,7 +8850,7 @@ var store_insert_requires_on_conflict_default = createRule({
 });
 
 // src/rules/zod-naming-convention.ts
-var import_utils57 = require("@typescript-eslint/utils");
+var import_utils59 = require("@typescript-eslint/utils");
 var CONVENTIONS = {
   prefix: { test: ZOD_PREFIX_RE, messageId: "zPrefix" },
   suffix: { test: ZOD_SUFFIX_RE, messageId: "schemaSuffix" },
@@ -8732,15 +8875,15 @@ var NON_SCHEMA_TERMINALS = /* @__PURE__ */ new Set([
   "registry",
   "implement"
 ]);
-var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils57.AST_NODE_TYPES.Identifier ? callee.property.name : null;
+var terminalMethodName = (callee) => !callee.computed && callee.property.type === import_utils59.AST_NODE_TYPES.Identifier ? callee.property.name : null;
 var calleeChainStartsWithZ = (node) => {
   let current = node;
-  while (current.type === import_utils57.AST_NODE_TYPES.MemberExpression) {
+  while (current.type === import_utils59.AST_NODE_TYPES.MemberExpression) {
     const receiver = current.object;
-    if (receiver.type === import_utils57.AST_NODE_TYPES.Identifier && receiver.name === "z") {
+    if (receiver.type === import_utils59.AST_NODE_TYPES.Identifier && receiver.name === "z") {
       return true;
     }
-    if (receiver.type === import_utils57.AST_NODE_TYPES.CallExpression) {
+    if (receiver.type === import_utils59.AST_NODE_TYPES.CallExpression) {
       current = receiver.callee;
       continue;
     }
@@ -8785,13 +8928,13 @@ var zod_naming_convention_default = createRule({
       VariableDeclarator(node) {
         const init = node.init;
         if (init === null || init === void 0) return;
-        if (init.type !== import_utils57.AST_NODE_TYPES.CallExpression) return;
+        if (init.type !== import_utils59.AST_NODE_TYPES.CallExpression) return;
         const callee = init.callee;
-        if (callee.type !== import_utils57.AST_NODE_TYPES.MemberExpression) return;
+        if (callee.type !== import_utils59.AST_NODE_TYPES.MemberExpression) return;
         if (!calleeChainStartsWithZ(callee)) return;
         const terminal = terminalMethodName(callee);
         if (terminal !== null && NON_SCHEMA_TERMINALS.has(terminal)) return;
-        if (node.id.type !== import_utils57.AST_NODE_TYPES.Identifier) return;
+        if (node.id.type !== import_utils59.AST_NODE_TYPES.Identifier) return;
         if (test.test(node.id.name)) return;
         if (acceptsSchemaWord && CONTAINS_SCHEMA_RE.test(node.id.name)) return;
         context.report({
@@ -8842,6 +8985,7 @@ var rules = {
   "no-string-concat-in-loop": no_string_concat_in_loop_default,
   "no-tautological-expect": no_tautological_expect_default,
   "no-trailing-value-narration": no_trailing_value_narration_default,
+  "no-declaration-comment-wall": no_declaration_comment_wall_default,
   "no-type-member-comment-wall": no_type_member_comment_wall_default,
   "no-unnecessary-use-client": no_unnecessary_use_client_default,
   "no-unsafe-mock-casting": no_unsafe_mock_casting_default,
@@ -8867,7 +9011,7 @@ var rules = {
 };
 var meta = {
   name: "@sarj/eslint-plugin",
-  version: "7.0.0"
+  version: "7.1.0"
 };
 var renames = renamedRules;
 var deprecatedAliases = Object.fromEntries(
@@ -8916,6 +9060,7 @@ var recommendedRules = {
   "@sarj/no-string-concat-in-loop": "warn",
   "@sarj/no-tautological-expect": "warn",
   "@sarj/no-trailing-value-narration": "warn",
+  "@sarj/no-declaration-comment-wall": "warn",
   "@sarj/no-type-member-comment-wall": "warn",
   "@sarj/no-unnecessary-use-client": "warn",
   "@sarj/no-unsafe-mock-casting": "warn",
@@ -8969,6 +9114,7 @@ var strictRules = {
   "@sarj/no-string-concat-in-loop": "error",
   "@sarj/no-tautological-expect": "error",
   "@sarj/no-trailing-value-narration": "error",
+  "@sarj/no-declaration-comment-wall": "error",
   "@sarj/no-type-member-comment-wall": "error",
   "@sarj/no-unnecessary-use-client": "error",
   "@sarj/no-unsafe-mock-casting": "error",