pasika 0.10.135 → 0.10.137

package/dist/eslint/pasika/index.js

@@ -5392,20 +5392,217 @@ var noArbitraryTailwindRule = {
 import path40 from "path";
 
 // eslint/project/jsx-class-reuse.ts
+import { readFileSync as readFileSync10 } from "fs";
+import ts9 from "typescript";
+
+// eslint/project/shared-class-compositions.ts
 import { readFileSync as readFileSync9 } from "fs";
 import ts8 from "typescript";
 var MIN_SHARED_CLASSES = 5;
+function moduleInfo(file, index, cache6) {
+  if (cache6.has(file)) return cache6.get(file);
+  try {
+    const source = ts8.createSourceFile(
+      file,
+      readFileSync9(file, "utf8"),
+      ts8.ScriptTarget.Latest,
+      true,
+      ts8.ScriptKind.TSX
+    );
+    const result = {
+      source,
+      values: /* @__PURE__ */ new Map(),
+      imports: /* @__PURE__ */ new Map(),
+      exports: /* @__PURE__ */ new Map(),
+      reexports: [],
+      stars: []
+    };
+    for (const statement of source.statements) {
+      if (ts8.isVariableStatement(statement)) {
+        const exported = (ts8.getModifiers(statement) ?? []).some((item) => item.kind === ts8.SyntaxKind.ExportKeyword);
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts8.isIdentifier(declaration.name) || !declaration.initializer) continue;
+          const name = declaration.name.text;
+          result.values.set(name, declaration.initializer);
+          if (exported) result.exports.set(name, name);
+        }
+      } else if (ts8.isImportDeclaration(statement) && ts8.isStringLiteral(statement.moduleSpecifier)) {
+        const target = resolveSpecifier(file, statement.moduleSpecifier.text, index.sourceRoot);
+        const named = statement.importClause?.namedBindings;
+        if (!target || !named || !ts8.isNamedImports(named)) continue;
+        for (const element of named.elements) {
+          result.imports.set(element.name.text, {
+            file: target,
+            name: element.propertyName?.text ?? element.name.text
+          });
+        }
+      } else if (ts8.isExportDeclaration(statement)) {
+        const target = statement.moduleSpecifier && ts8.isStringLiteral(statement.moduleSpecifier) ? resolveSpecifier(file, statement.moduleSpecifier.text, index.sourceRoot) : void 0;
+        if (statement.exportClause && ts8.isNamedExports(statement.exportClause)) {
+          for (const element of statement.exportClause.elements) {
+            const local = element.propertyName?.text ?? element.name.text;
+            if (target) result.reexports.push({ file: target, name: local, exported: element.name.text });
+            else result.exports.set(element.name.text, local);
+          }
+        } else if (target && !statement.exportClause) {
+          result.stars.push(target);
+        }
+      }
+    }
+    cache6.set(file, result);
+    return result;
+  } catch {
+    cache6.set(file, void 0);
+    return void 0;
+  }
+}
+function staticText(expression, info, visited) {
+  if (ts8.isStringLiteral(expression) || ts8.isNoSubstitutionTemplateLiteral(expression)) return expression.text;
+  if (ts8.isParenthesizedExpression(expression)) return staticText(expression.expression, info, visited);
+  if (ts8.isIdentifier(expression)) {
+    if (visited.has(expression.text)) return void 0;
+    const value = info.values.get(expression.text);
+    if (!value) return void 0;
+    visited.add(expression.text);
+    const result = staticText(value, info, visited);
+    visited.delete(expression.text);
+    return result;
+  }
+  if (ts8.isCallExpression(expression) && ts8.isIdentifier(expression.expression)) {
+    if (expression.expression.text !== "cn" && expression.expression.text !== "clsx") return void 0;
+    const parts = [];
+    for (const argument of expression.arguments) {
+      if (ts8.isSpreadElement(argument)) return void 0;
+      const value = staticText(argument, info, visited);
+      if (value === void 0) return void 0;
+      parts.push(value);
+    }
+    return parts.join(" ");
+  }
+  return void 0;
+}
+function resolveExport(file, name, index, cache6, seen) {
+  const key = `${file}\0${name}`;
+  if (seen.has(key)) return void 0;
+  seen.add(key);
+  const info = moduleInfo(file, index, cache6);
+  if (!info) return void 0;
+  const localName = info.exports.get(name);
+  if (localName) {
+    const initializer = info.values.get(localName);
+    const text = initializer ? staticText(initializer, info, /* @__PURE__ */ new Set([localName])) : void 0;
+    if (text !== void 0) {
+      const classes = [...new Set(text.split(/\s+/u).filter(Boolean))].sort();
+      if (classes.length >= MIN_SHARED_CLASSES) return { origin: file, name: localName, classes };
+    }
+    const imported = info.imports.get(localName);
+    if (imported) return resolveExport(imported.file, imported.name, index, cache6, seen);
+  }
+  for (const reexport of info.reexports) {
+    if (reexport.exported !== name) continue;
+    const target = resolveExport(reexport.file, reexport.name, index, cache6, seen);
+    if (target) return target;
+  }
+  for (const target of info.stars) {
+    const found = resolveExport(target, name, index, cache6, seen);
+    if (found) return found;
+  }
+  return void 0;
+}
+function usagesInFile(file, index, cache6) {
+  const info = moduleInfo(file, index, cache6);
+  if (!info) return [];
+  const result = [];
+  const visit = (node) => {
+    if (ts8.isJsxOpeningElement(node) || ts8.isJsxSelfClosingElement(node)) {
+      const tag = node.tagName.getText(info.source);
+      if (/^[a-z][a-z0-9-]*$/u.test(tag)) {
+        const attribute = node.attributes.properties.find(
+          (item) => ts8.isJsxAttribute(item) && ts8.isIdentifier(item.name) && item.name.text === "className"
+        );
+        if (attribute && ts8.isJsxAttribute(attribute) && attribute.initializer && ts8.isJsxExpression(attribute.initializer)) {
+          const expression = attribute.initializer.expression;
+          if (expression) {
+            const identified = /* @__PURE__ */ new Set();
+            const visitedLocals = /* @__PURE__ */ new Set();
+            const collect = (part) => {
+              if (ts8.isIdentifier(part)) {
+                const imported = info.imports.get(part.text);
+                const resolved = imported ? resolveExport(imported.file, imported.name, index, cache6, /* @__PURE__ */ new Set()) : void 0;
+                if (resolved) {
+                  const symbol = `${resolved.origin}\0${resolved.name}`;
+                  if (!identified.has(symbol)) {
+                    identified.add(symbol);
+                    const location = info.source.getLineAndCharacterOfPosition(attribute.getStart(info.source));
+                    result.push({
+                      file,
+                      line: location.line + 1,
+                      column: location.character,
+                      tag,
+                      symbol,
+                      classes: resolved.classes
+                    });
+                  }
+                } else if (!visitedLocals.has(part.text)) {
+                  const local = info.values.get(part.text);
+                  if (local) {
+                    visitedLocals.add(part.text);
+                    collect(local);
+                    visitedLocals.delete(part.text);
+                  }
+                }
+                return;
+              }
+              ts8.forEachChild(part, collect);
+            };
+            collect(expression);
+          }
+        }
+      }
+    }
+    ts8.forEachChild(node, visit);
+  };
+  visit(info.source);
+  return result;
+}
+function sharedClassReuses(index) {
+  const cache6 = /* @__PURE__ */ new Map();
+  const bySymbol = /* @__PURE__ */ new Map();
+  for (const file of [...index.modules.keys()].sort()) {
+    if (!/\.(?:tsx|jsx)$/u.test(file) || /\.(?:test|spec)\.(?:tsx|jsx)$/u.test(file)) continue;
+    for (const occurrence of usagesInFile(file, index, cache6)) {
+      const members = bySymbol.get(occurrence.symbol) ?? [];
+      members.push(occurrence);
+      bySymbol.set(occurrence.symbol, members);
+    }
+  }
+  const matches = /* @__PURE__ */ new Map();
+  for (const members of bySymbol.values()) {
+    if (new Set(members.map((member) => member.file)).size < 2) continue;
+    for (const occurrence of members.slice(1)) {
+      const original = members.find((member) => member.file !== occurrence.file);
+      if (!original) continue;
+      const entries = matches.get(occurrence.file) ?? [];
+      entries.push({ occurrence, original });
+      matches.set(occurrence.file, entries);
+    }
+  }
+  return matches;
+}
+
+// eslint/project/jsx-class-reuse.ts
+var MIN_SHARED_CLASSES2 = 5;
 var cache3 = /* @__PURE__ */ new WeakMap();
 function staticClassText(expression) {
-  if (ts8.isStringLiteral(expression) || ts8.isNoSubstitutionTemplateLiteral(expression)) {
+  if (ts9.isStringLiteral(expression) || ts9.isNoSubstitutionTemplateLiteral(expression)) {
     return expression.text;
   }
-  if (ts8.isParenthesizedExpression(expression)) return staticClassText(expression.expression);
-  if (!ts8.isCallExpression(expression) || !ts8.isIdentifier(expression.expression)) return void 0;
+  if (ts9.isParenthesizedExpression(expression)) return staticClassText(expression.expression);
+  if (!ts9.isCallExpression(expression) || !ts9.isIdentifier(expression.expression)) return void 0;
   if (expression.expression.text !== "cn") return void 0;
   const chunks = [];
   for (const arg of expression.arguments) {
-    if (ts8.isSpreadElement(arg)) return void 0;
+    if (ts9.isSpreadElement(arg)) return void 0;
     const text = staticClassText(arg);
     if (text === void 0) return void 0;
     chunks.push(text);
@@ -5413,26 +5610,26 @@ function staticClassText(expression) {
   return chunks.join(" ");
 }
 function occurrencesInFile(file) {
-  const source = ts8.createSourceFile(file, readFileSync9(file, "utf8"), ts8.ScriptTarget.Latest, true, ts8.ScriptKind.TSX);
+  const source = ts9.createSourceFile(file, readFileSync10(file, "utf8"), ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TSX);
   const result = [];
   const visit = (node) => {
-    if (ts8.isJsxOpeningElement(node) || ts8.isJsxSelfClosingElement(node)) {
+    if (ts9.isJsxOpeningElement(node) || ts9.isJsxSelfClosingElement(node)) {
       const tag = node.tagName.getText(source);
       if (/^[a-z][a-z0-9-]*$/.test(tag)) {
         const attribute = node.attributes.properties.find(
-          (item) => ts8.isJsxAttribute(item) && ts8.isIdentifier(item.name) && item.name.text === "className"
+          (item) => ts9.isJsxAttribute(item) && ts9.isIdentifier(item.name) && item.name.text === "className"
         );
-        if (attribute && ts8.isJsxAttribute(attribute)) {
+        if (attribute && ts9.isJsxAttribute(attribute)) {
           const initializer = attribute.initializer;
           let text;
-          if (initializer && ts8.isStringLiteral(initializer)) {
+          if (initializer && ts9.isStringLiteral(initializer)) {
             text = initializer.text;
-          } else if (initializer && ts8.isJsxExpression(initializer) && initializer.expression) {
+          } else if (initializer && ts9.isJsxExpression(initializer) && initializer.expression) {
             text = staticClassText(initializer.expression);
           }
           if (text !== void 0) {
             const classes = [...new Set(text.split(/\s+/).filter(Boolean))].sort();
-            if (classes.length >= MIN_SHARED_CLASSES) {
+            if (classes.length >= MIN_SHARED_CLASSES2) {
               const location = source.getLineAndCharacterOfPosition(attribute.getStart(source));
               result.push({
                 file,
@@ -5446,7 +5643,7 @@ function occurrencesInFile(file) {
         }
       }
     }
-    ts8.forEachChild(node, visit);
+    ts9.forEachChild(node, visit);
   };
   visit(source);
   return result;
@@ -5480,11 +5677,11 @@ function reuseIndex(index) {
       matches.set(occurrence.file, entries);
     }
   }
-  return { matches, groups };
+  return { matches, groups, shared: sharedClassReuses(index) };
 }
 function getJsxReuseAnalysis(sourceRoot) {
   const index = getProjectIndex(sourceRoot);
-  if (!index) return { matches: /* @__PURE__ */ new Map(), groups: [] };
+  if (!index) return { matches: /* @__PURE__ */ new Map(), groups: [], shared: /* @__PURE__ */ new Map() };
   const existing = cache3.get(index);
   if (existing) return existing;
   const result = reuseIndex(index);
@@ -5494,6 +5691,9 @@ function getJsxReuseAnalysis(sourceRoot) {
 function getJsxClassReuses(sourceRoot) {
   return getJsxReuseAnalysis(sourceRoot).matches;
 }
+function getSharedClassReuses(sourceRoot) {
+  return getJsxReuseAnalysis(sourceRoot).shared;
+}
 
 // eslint/rules/no-duplicate-jsx-classes.ts
 var noDuplicateJsxClassesRule = {
@@ -5507,7 +5707,8 @@ var noDuplicateJsxClassesRule = {
     if (!/\.(?:jsx|tsx)$/.test(file) || /\.(?:test|spec)\.(?:jsx|tsx)$/.test(file)) return {};
     const root = sourceRootOf(context);
     const matches = getJsxClassReuses(root).get(file) ?? [];
-    if (matches.length === 0) return {};
+    const shared = getSharedClassReuses(root).get(file) ?? [];
+    if (matches.length === 0 && shared.length === 0) return {};
     return {
       Program(node) {
         for (const { occurrence, original, commonClasses } of matches) {
@@ -5518,6 +5719,15 @@ var noDuplicateJsxClassesRule = {
             message: `<${occurrence.tag}> repeats the same set of ${String(commonClasses.length)} classes as ${reference}:${String(original.line)}. Extract a shared component. See docs/next-tailwind-guide/rules/tailwind-class-reuse-rule.md`
           });
         }
+        for (const { occurrence, original } of shared) {
+          const reference = path40.relative(path40.dirname(root), original.file).split(path40.sep).join("/");
+          const name = occurrence.symbol.split("\0")[1] ?? "class composition";
+          context.report({
+            node,
+            loc: { line: occurrence.line, column: occurrence.column },
+            message: `<${occurrence.tag}> reuses exported class composition "${name}" (${String(occurrence.classes.length)} classes) from ${reference}:${String(original.line)}. Extract a shared component. See docs/next-tailwind-guide/rules/tailwind-class-reuse-rule.md`
+          });
+        }
       }
     };
   }
@@ -5527,9 +5737,9 @@ var noDuplicateJsxClassesRule = {
 import path42 from "path";
 
 // eslint/project/semantic-literals.ts
-import { readFileSync as readFileSync10 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 import path41 from "path";
-import ts9 from "typescript";
+import ts10 from "typescript";
 var excludedProperties = /* @__PURE__ */ new Set([
   "label",
   "title",
@@ -5576,24 +5786,24 @@ function featureOf(file, root) {
   return `layer:${parts[0] ?? "src"}`;
 }
 function nameOf(property) {
-  if (ts9.isIdentifier(property) || ts9.isStringLiteral(property)) return property.text;
+  if (ts10.isIdentifier(property) || ts10.isStringLiteral(property)) return property.text;
   return void 0;
 }
 function literalOf(node) {
-  if (ts9.isStringLiteral(node)) return node.text;
-  if (ts9.isNumericLiteral(node)) return Number(node.text.replaceAll("_", ""));
-  if (ts9.isPrefixUnaryExpression(node) && node.operator === ts9.SyntaxKind.MinusToken && ts9.isNumericLiteral(node.operand)) {
+  if (ts10.isStringLiteral(node)) return node.text;
+  if (ts10.isNumericLiteral(node)) return Number(node.text.replaceAll("_", ""));
+  if (ts10.isPrefixUnaryExpression(node) && node.operator === ts10.SyntaxKind.MinusToken && ts10.isNumericLiteral(node.operand)) {
     return -Number(node.operand.text.replaceAll("_", ""));
   }
   return void 0;
 }
 function isLiteralRoot(node) {
-  if (ts9.isPrefixUnaryExpression(node)) return literalOf(node) !== void 0;
-  return (ts9.isStringLiteral(node) || ts9.isNumericLiteral(node)) && !(ts9.isPrefixUnaryExpression(node.parent) && node.parent.operand === node);
+  if (ts10.isPrefixUnaryExpression(node)) return literalOf(node) !== void 0;
+  return (ts10.isStringLiteral(node) || ts10.isNumericLiteral(node)) && !(ts10.isPrefixUnaryExpression(node.parent) && node.parent.operand === node);
 }
 function invocation(node) {
-  if (ts9.isIdentifier(node.expression)) return { method: node.expression.text };
-  if (ts9.isPropertyAccessExpression(node.expression)) {
+  if (ts10.isIdentifier(node.expression)) return { method: node.expression.text };
+  if (ts10.isPropertyAccessExpression(node.expression)) {
     const receiver = node.expression.expression.getText();
     if (!/^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?$/.test(receiver)) return void 0;
     return { method: node.expression.name.text, receiver };
@@ -5601,7 +5811,7 @@ function invocation(node) {
   return void 0;
 }
 function isPathname(node) {
-  return ts9.isPropertyAccessExpression(node) && node.name.text === "pathname";
+  return ts10.isPropertyAccessExpression(node) && node.name.text === "pathname";
 }
 function contextFor(node, value, file, root) {
   if (typeof value === "number" && ignoredNumbers.has(value)) return void 0;
@@ -5610,7 +5820,7 @@ function contextFor(node, value, file, root) {
   const scope = featureOf(file, root);
   const isApiRoute = typeof value === "string" && value.startsWith("/api/") && !/[?&#\s]/.test(value);
   const route = () => ({ role: "api-route", family: "api-route" });
-  if (ts9.isPropertyAssignment(parent) && parent.initializer === node) {
+  if (ts10.isPropertyAssignment(parent) && parent.initializer === node) {
     const name = nameOf(parent.name);
     if (!name) return void 0;
     if (name === "path" && isApiRoute) return route();
@@ -5619,14 +5829,14 @@ function contextFor(node, value, file, root) {
     if (isApiRoute && /route|path|endpoint/i.test(name)) return route();
     return { role: `property:${name}:${scope}`, family: `property:${name}` };
   }
-  if (ts9.isVariableDeclaration(parent) && parent.initializer === node && ts9.isIdentifier(parent.name)) {
+  if (ts10.isVariableDeclaration(parent) && parent.initializer === node && ts10.isIdentifier(parent.name)) {
     if (typeof value === "number") return void 0;
     const name = parent.name.text;
     if (excludedProperties.has(name) || !semanticVariableName.test(name)) return void 0;
     if (isApiRoute && /route|path|endpoint/i.test(name)) return route();
     return { role: `variable:${name}:${scope}`, family: `variable:${name}` };
   }
-  if (ts9.isCallExpression(parent)) {
+  if (ts10.isCallExpression(parent)) {
     const position = parent.arguments.findIndex((argument) => argument === node);
     if (position < 0) return void 0;
     const call = invocation(parent);
@@ -5645,29 +5855,29 @@ function contextFor(node, value, file, root) {
       return { role: `column:${scope}`, family: "column" };
     }
   }
-  if (isApiRoute && ts9.isBinaryExpression(parent) && (parent.operatorToken.kind === ts9.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts9.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname(parent.right) || parent.right === node && isPathname(parent.left))) {
+  if (isApiRoute && ts10.isBinaryExpression(parent) && (parent.operatorToken.kind === ts10.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts10.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname(parent.right) || parent.right === node && isPathname(parent.left))) {
     return route();
   }
-  if (isApiRoute && ts9.isCallExpression(parent) && parent.arguments[0] === node && ts9.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
+  if (isApiRoute && ts10.isCallExpression(parent) && parent.arguments[0] === node && ts10.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "startsWith" && isPathname(parent.expression.expression)) {
     return route();
   }
   return void 0;
 }
 function isExported2(node) {
-  return ts9.canHaveModifiers(node) && (ts9.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts9.SyntaxKind.ExportKeyword);
+  return ts10.canHaveModifiers(node) && (ts10.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts10.SyntaxKind.ExportKeyword);
 }
 function parse(file, root, output) {
   if (!isProductionSource(file, root)) return;
-  const source = ts9.createSourceFile(
+  const source = ts10.createSourceFile(
     file,
-    readFileSync10(file, "utf8"),
-    ts9.ScriptTarget.Latest,
+    readFileSync11(file, "utf8"),
+    ts10.ScriptTarget.Latest,
     true,
-    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts9.ScriptKind.TSX : ts9.ScriptKind.TS
+    file.endsWith(".tsx") || file.endsWith(".jsx") ? ts10.ScriptKind.TSX : ts10.ScriptKind.TS
   );
   const inConstants = path41.relative(root, file).split(path41.sep).includes("constants");
   for (const statement of source.statements) {
-    if (inConstants && ts9.isEnumDeclaration(statement) && isExported2(statement)) {
+    if (inConstants && ts10.isEnumDeclaration(statement) && isExported2(statement)) {
       for (const member of statement.members) {
         const value = member.initializer && literalOf(member.initializer);
         const memberName10 = nameOf(member.name);
@@ -5681,9 +5891,9 @@ function parse(file, root, output) {
         });
       }
     }
-    if (inConstants && ts9.isVariableStatement(statement) && isExported2(statement)) {
+    if (inConstants && ts10.isVariableStatement(statement) && isExported2(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts9.isIdentifier(declaration.name) || !declaration.initializer) continue;
+        if (!ts10.isIdentifier(declaration.name) || !declaration.initializer) continue;
         const value = literalOf(declaration.initializer);
         if (value === void 0) continue;
         output.canonicals.push({
@@ -5702,7 +5912,7 @@ function parse(file, root, output) {
         const semantic = contextFor(node, value, file, root);
         if (semantic) {
           const declaration = node.parent;
-          const isCanonicalDefinition = inConstants && (ts9.isVariableDeclaration(declaration) && ts9.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts9.isEnumMember(declaration));
+          const isCanonicalDefinition = inConstants && (ts10.isVariableDeclaration(declaration) && ts10.isVariableStatement(declaration.parent.parent) && isExported2(declaration.parent.parent) || ts10.isEnumMember(declaration));
           if ((!inConstants || semantic.family === "api-route") && !isCanonicalDefinition) {
             const position = source.getLineAndCharacterOfPosition(node.getStart(source));
             output.uses.push({
@@ -5717,7 +5927,7 @@ function parse(file, root, output) {
         }
       }
     }
-    ts9.forEachChild(node, visit);
+    ts10.forEachChild(node, visit);
   };
   visit(source);
 }
@@ -6010,7 +6220,7 @@ var noLiteralInlineStyleRule = {
 };
 
 // eslint/rules/no-mixed-concerns.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import path43 from "path";
 function isComponentSupportKind(kind) {
   return kind === "constant" || kind === "type" || kind === "schema";
@@ -6134,7 +6344,7 @@ var noMixedConcernsRule = {
               continue;
             }
             const target = typeof statement.source?.value === "string" ? resolveSpecifier(file, statement.source.value, sourceRoot) : void 0;
-            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync11(target, "utf8"), target).map((component) => component.name) : [];
+            const forwardedComponents = target?.endsWith(".tsx") ? parseComponentInfo(readFileSync12(target, "utf8"), target).map((component) => component.name) : [];
             for (const specifier of statement.specifiers) {
               if (/^type\b/.test(context.sourceCode.getText(specifier))) continue;
               if (specifier.local.type !== "Identifier") continue;
@@ -6172,7 +6382,7 @@ import path45 from "path";
 
 // eslint/rules/contract-ownership.ts
 import path44 from "path";
-import ts10 from "typescript";
+import ts11 from "typescript";
 function isTsProgram(value) {
   return typeof value === "object" && value !== null && "getTypeChecker" in value && typeof value.getTypeChecker === "function" && "getSourceFiles" in value && typeof value.getSourceFiles === "function";
 }
@@ -6206,11 +6416,11 @@ function endpointOwnership(pathValue) {
   return "unknown";
 }
 function resolvedSymbol(checker, symbol) {
-  return symbol.flags === ts10.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  return symbol.flags === ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
 }
 function propertyName5(node) {
   if (!node) return void 0;
-  if (ts10.isIdentifier(node) || ts10.isStringLiteral(node) || ts10.isNumericLiteral(node)) return node.text;
+  if (ts11.isIdentifier(node) || ts11.isStringLiteral(node) || ts11.isNumericLiteral(node)) return node.text;
   return void 0;
 }
 var ContractOwnershipIndex = class {
@@ -6234,7 +6444,7 @@ var ContractOwnershipIndex = class {
     }
     if (declarations.length > 0) return this.endpointFromDeclarations(declarations);
     let object;
-    if (ts10.isPropertyAccessExpression(node) || ts10.isElementAccessExpression(node)) object = node.expression;
+    if (ts11.isPropertyAccessExpression(node) || ts11.isElementAccessExpression(node)) object = node.expression;
     if (!object) return { kind: "missing", ownership: "unknown" };
     const type = this.checker.getTypeAtLocation(object);
     const typeDeclarations = this.typeDeclarations(type);
@@ -6242,7 +6452,7 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(typeDeclarations);
   }
   sourceBinding(node, name) {
-    if (!ts10.isVariableDeclaration(node) || !node.initializer) {
+    if (!ts11.isVariableDeclaration(node) || !node.initializer) {
       return { kind: "missing", ownership: "unknown" };
     }
     const sourceType = this.checker.getTypeAtLocation(node.initializer);
@@ -6251,11 +6461,11 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   targetProperty(node, name) {
-    if (!ts10.isPropertyAssignment(node) && !ts10.isShorthandPropertyAssignment(node)) {
+    if (!ts11.isPropertyAssignment(node) && !ts11.isShorthandPropertyAssignment(node)) {
       return { kind: "missing", ownership: "unknown" };
     }
     const object = node.parent;
-    if (!ts10.isObjectLiteralExpression(object)) return { kind: "missing", ownership: "unknown" };
+    if (!ts11.isObjectLiteralExpression(object)) return { kind: "missing", ownership: "unknown" };
     const contextualType = this.checker.getContextualType(object);
     if (!contextualType) return { kind: "missing", ownership: "unknown" };
     const declarations = this.propertyDeclarations(contextualType, name);
@@ -6263,8 +6473,8 @@ var ContractOwnershipIndex = class {
     return this.endpointFromDeclarations(declarations);
   }
   memberNameSymbol(node) {
-    if (ts10.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
-    if (ts10.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
+    if (ts11.isPropertyAccessExpression(node)) return this.checker.getSymbolAtLocation(node.name);
+    if (ts11.isElementAccessExpression(node)) return this.checker.getSymbolAtLocation(node.argumentExpression);
     return void 0;
   }
   propertyDeclarations(type, name) {
@@ -6294,14 +6504,14 @@ var ContractOwnershipIndex = class {
     if (declarations.some((declaration) => this.isDataContractField(declaration))) {
       return { kind: "data-contract", ownership };
     }
-    if (declarations.some((declaration) => ts10.isPropertySignature(declaration) || ts10.isPropertyDeclaration(declaration))) {
+    if (declarations.some((declaration) => ts11.isPropertySignature(declaration) || ts11.isPropertyDeclaration(declaration))) {
       return { kind: "typed-local", ownership };
     }
     return { kind: "non-contract", ownership };
   }
   isDataContractField(declaration) {
     if (this.isZodSchemaField(declaration)) return true;
-    if (!ts10.isPropertySignature(declaration) && !ts10.isPropertyDeclaration(declaration)) return false;
+    if (!ts11.isPropertySignature(declaration) && !ts11.isPropertyDeclaration(declaration)) return false;
     const fileName = normalizePath(declaration.getSourceFile().fileName);
     return /(?:^|\/)database(?:[-.]generated)?\.ts$/u.test(fileName);
   }
@@ -6310,10 +6520,10 @@ var ContractOwnershipIndex = class {
     return this.checker.getPropertyOfType(type, "_zod") !== void 0 && this.checker.getPropertyOfType(type, "parse") !== void 0 && this.checker.getPropertyOfType(type, "safeParse") !== void 0;
   }
   isZodSchemaField(declaration) {
-    if (!ts10.isPropertyAssignment(declaration)) return false;
+    if (!ts11.isPropertyAssignment(declaration)) return false;
     let current = declaration.parent;
-    while (!ts10.isSourceFile(current)) {
-      if (ts10.isVariableDeclaration(current) && ts10.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
+    while (!ts11.isSourceFile(current)) {
+      if (ts11.isVariableDeclaration(current) && ts11.isIdentifier(current.name) && current.name.text.endsWith("Schema")) {
         return true;
       }
       current = current.parent;
@@ -6336,7 +6546,7 @@ var ContractOwnershipIndex = class {
   }
   schemaOwnership(declaration) {
     let current = declaration;
-    while (!ts10.isSourceFile(current)) {
+    while (!ts11.isSourceFile(current)) {
       const ownership = this.schemaNodeOwnership.get(current);
       if (ownership !== void 0) return ownership;
       current = current.parent;
@@ -6347,29 +6557,29 @@ var ContractOwnershipIndex = class {
     for (const sourceFile of this.program.getSourceFiles()) {
       if (sourceFile.isDeclarationFile || !isWithin2(this.cwd, path44.resolve(sourceFile.fileName))) continue;
       const visit = (node) => {
-        if (ts10.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
-        ts10.forEachChild(node, visit);
+        if (ts11.isCallExpression(node) && this.isDefineApiContractCall(node)) this.indexApiContractCall(node);
+        ts11.forEachChild(node, visit);
       };
       visit(sourceFile);
     }
   }
   isDefineApiContractCall(node) {
-    if (ts10.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
-    return ts10.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
+    if (ts11.isIdentifier(node.expression)) return node.expression.text === "defineApiContract";
+    return ts11.isPropertyAccessExpression(node.expression) && node.expression.name.text === "defineApiContract";
   }
   indexApiContractCall(node) {
     const argument = node.arguments[0];
-    if (!argument || !ts10.isObjectLiteralExpression(argument)) return;
+    if (!argument || !ts11.isObjectLiteralExpression(argument)) return;
     let pathExpression;
     const schemaExpressions = [];
     for (const property of argument.properties) {
-      if (ts10.isPropertyAssignment(property)) {
+      if (ts11.isPropertyAssignment(property)) {
         const name = propertyName5(property.name);
         if (name === "path") pathExpression = property.initializer;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.initializer);
         continue;
       }
-      if (ts10.isShorthandPropertyAssignment(property)) {
+      if (ts11.isShorthandPropertyAssignment(property)) {
         const name = property.name.text;
         if (name === "path") pathExpression = property.name;
         if (name === "requestSchema" || name === "responseSchema") schemaExpressions.push(property.name);
@@ -6383,13 +6593,13 @@ var ContractOwnershipIndex = class {
   }
   staticString(node, seen) {
     if (!node) return void 0;
-    if (ts10.isStringLiteralLike(node)) return node.text;
-    if (ts10.isIdentifier(node)) {
+    if (ts11.isStringLiteralLike(node)) return node.text;
+    if (ts11.isIdentifier(node)) {
       const symbol = this.checker.getSymbolAtLocation(node);
       if (!symbol || seen.has(symbol)) return void 0;
       seen.add(symbol);
       for (const declaration of resolvedSymbol(this.checker, symbol).declarations ?? []) {
-        if (ts10.isVariableDeclaration(declaration) && declaration.initializer) {
+        if (ts11.isVariableDeclaration(declaration) && declaration.initializer) {
           const value = this.staticString(declaration.initializer, seen);
           if (value !== void 0) return value;
         }
@@ -6407,20 +6617,20 @@ var ContractOwnershipIndex = class {
         this.followSchemaDeclaration(declaration, ownership, seen);
       }
     }
-    ts10.forEachChild(node, (child) => {
+    ts11.forEachChild(node, (child) => {
       this.markSchemaExpression(child, ownership, seen);
     });
   }
   schemaReferenceSymbol(node) {
-    if (ts10.isIdentifier(node)) {
+    if (ts11.isIdentifier(node)) {
       if (!node.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node);
     }
-    if (ts10.isPropertyAccessExpression(node)) {
+    if (ts11.isPropertyAccessExpression(node)) {
       if (!node.name.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.name);
     }
-    if (ts10.isElementAccessExpression(node) && ts10.isStringLiteralLike(node.argumentExpression)) {
+    if (ts11.isElementAccessExpression(node) && ts11.isStringLiteralLike(node.argumentExpression)) {
       if (!node.argumentExpression.text.endsWith("Schema")) return void 0;
       return this.checker.getSymbolAtLocation(node.argumentExpression);
     }
@@ -6428,15 +6638,15 @@ var ContractOwnershipIndex = class {
   }
   followSchemaDeclaration(declaration, ownership, seen) {
     this.setSchemaOwnership(declaration, ownership);
-    if (ts10.isVariableDeclaration(declaration) && declaration.initializer) {
+    if (ts11.isVariableDeclaration(declaration) && declaration.initializer) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts10.isPropertyAssignment(declaration)) {
+    if (ts11.isPropertyAssignment(declaration)) {
       this.markSchemaExpression(declaration.initializer, ownership, seen);
       return;
     }
-    if (ts10.isShorthandPropertyAssignment(declaration)) {
+    if (ts11.isShorthandPropertyAssignment(declaration)) {
       const valueSymbol = this.checker.getShorthandAssignmentValueSymbol(declaration);
       if (!valueSymbol || seen.has(valueSymbol)) return;
       seen.add(valueSymbol);
@@ -6810,7 +7020,7 @@ function sourceRootOf3(context, filename) {
 }
 
 // eslint/rules/package-json/ci-checks.ts
-import { existsSync as existsSync6, readFileSync as readFileSync12, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync13, readdirSync as readdirSync4 } from "fs";
 import path47 from "path";
 import { parse as parse2 } from "yaml";
 function mapping(value) {
@@ -6869,7 +7079,7 @@ function readWorkflows(dir) {
   const errors = [];
   for (const file of readdirSync4(dir).filter((name) => /\.ya?ml$/i.test(name)).sort()) {
     try {
-      const parsed = parse2(readFileSync12(path47.join(dir, file), "utf8"), { uniqueKeys: true });
+      const parsed = parse2(readFileSync13(path47.join(dir, file), "utf8"), { uniqueKeys: true });
       const content = mapping(parsed);
       if (!content) throw new Error("expected a YAML mapping");
       workflows.push(content);
@@ -7153,7 +7363,7 @@ var nextjsStackRule = {
 };
 
 // eslint/rules/package-json/vitest-coverage.ts
-import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync14 } from "fs";
 import path48 from "path";
 function memberName6(member) {
   return member.name.type === "String" ? member.name.value : member.name.name;
@@ -7232,7 +7442,7 @@ var vitestCoverageRule = {
           });
           return;
         }
-        const content = readFileSync13(path48.join(context.cwd, configName), "utf8");
+        const content = readFileSync14(path48.join(context.cwd, configName), "utf8");
         for (const metric of THRESHOLD_METRICS) {
           if (!new RegExp(`\\b${metric}\\s*:\\s*[1-9]\\d*`).test(content)) {
             context.report({ node, message: `${configName} must set a coverage threshold above zero for ${metric}.` });
@@ -7280,7 +7490,7 @@ var nextjsPackageJsonRules = {
 
 // eslint/rules/prefer-enum.ts
 import path49 from "path";
-import ts11 from "typescript";
+import ts12 from "typescript";
 function isConstAssertion(node) {
   const typeAnnotation = node.typeAnnotation;
   return typeAnnotation?.type === "TSTypeReference" && typeAnnotation.typeName?.type === "Identifier" && typeAnnotation.typeName.name === "const";
@@ -7334,13 +7544,13 @@ function isLiteralTupleAssertion(node) {
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
 function isTsLiteralTupleDeclaration(declaration) {
-  if (!ts11.isVariableDeclaration(declaration) || !declaration.initializer) return false;
+  if (!ts12.isVariableDeclaration(declaration) || !declaration.initializer) return false;
   const init = declaration.initializer;
-  if (!ts11.isAsExpression(init) || !ts11.isTypeReferenceNode(init.type) || !ts11.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts11.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
+  if (!ts12.isAsExpression(init) || !ts12.isTypeReferenceNode(init.type) || !ts12.isIdentifier(init.type.typeName) || init.type.typeName.text !== "const" || !ts12.isArrayLiteralExpression(init.expression) || init.expression.elements.length < 2) {
     return false;
   }
   const values = init.expression.elements.map(
-    (element) => ts11.isStringLiteral(element) || ts11.isNumericLiteral(element) ? element.text : void 0
+    (element) => ts12.isStringLiteral(element) || ts12.isNumericLiteral(element) ? element.text : void 0
   );
   return values.every((value) => value !== void 0) && new Set(values).size >= 2;
 }
@@ -7369,7 +7579,7 @@ var preferEnumRule = {
       const checker = services.program.getTypeChecker();
       const symbol = checker.getSymbolAtLocation(tsNode);
       if (!symbol) return false;
-      const original = symbol.flags === ts11.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      const original = symbol.flags === ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
       return (original.declarations ?? []).some(isTsLiteralTupleDeclaration);
     }
     return {
@@ -7464,7 +7674,7 @@ var preferEnumRule = {
 };
 
 // eslint/rules/prefer-object-destructuring.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 var DOC7 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
 function hasTypeAnnotation(identifier) {
   return "typeAnnotation" in identifier && identifier.typeAnnotation !== void 0;
@@ -7557,8 +7767,8 @@ function enumValueResolver(context) {
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
   const isEnumSymbol = (symbol) => {
-    const resolved = symbol.flags === ts12.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
-    return (resolved.declarations ?? []).some((declaration) => ts12.isEnumDeclaration(declaration));
+    const resolved = symbol.flags === ts13.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    return (resolved.declarations ?? []).some((declaration) => ts13.isEnumDeclaration(declaration));
   };
   return (node) => {
     const tsNode = nodeMap.get(node);
@@ -7574,18 +7784,18 @@ function detachableCallResolver(context) {
   if (!services) return () => false;
   const checker = services.program.getTypeChecker();
   const { esTreeNodeToTSNodeMap: nodeMap } = services;
-  const isUnboundFunctionType = (type) => ts12.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts12.isIdentifier(parameter.name) && parameter.name.text === "this");
+  const isUnboundFunctionType = (type) => ts13.isFunctionTypeNode(type) && !type.parameters.some((parameter) => ts13.isIdentifier(parameter.name) && parameter.name.text === "this");
   return (member) => {
     const node = nodeMap.get(member);
-    if (!node || !ts12.isPropertyAccessExpression(node)) return false;
+    if (!node || !ts13.isPropertyAccessExpression(node)) return false;
     const symbol = checker.getSymbolAtLocation(node.name);
     const declarations = symbol?.declarations;
     if (!declarations?.length) return false;
     return declarations.every((declaration) => {
-      if (ts12.isPropertySignature(declaration) || ts12.isPropertyDeclaration(declaration)) {
-        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts12.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts12.isArrowFunction(declaration.initializer);
+      if (ts13.isPropertySignature(declaration) || ts13.isPropertyDeclaration(declaration)) {
+        return declaration.type !== void 0 && isUnboundFunctionType(declaration.type) || ts13.isPropertyDeclaration(declaration) && declaration.initializer !== void 0 && ts13.isArrowFunction(declaration.initializer);
       }
-      if (ts12.isPropertyAssignment(declaration)) return ts12.isArrowFunction(declaration.initializer);
+      if (ts13.isPropertyAssignment(declaration)) return ts13.isArrowFunction(declaration.initializer);
       return false;
     });
   };
@@ -8200,7 +8410,7 @@ import path53 from "path";
 
 // eslint/rules/imported-enum-literals.ts
 import path52 from "path";
-import ts13 from "typescript";
+import ts14 from "typescript";
 var columnMethods2 = /* @__PURE__ */ new Set([
   "eq",
   "neq",
@@ -8217,7 +8427,7 @@ var columnMethods2 = /* @__PURE__ */ new Set([
   "not"
 ]);
 function memberName7(name) {
-  if (ts13.isIdentifier(name) || ts13.isStringLiteral(name)) return name.text;
+  if (ts14.isIdentifier(name) || ts14.isStringLiteral(name)) return name.text;
   return void 0;
 }
 function isWithin3(root, file) {
@@ -8232,22 +8442,22 @@ function domainOf(name) {
 function importedEnums(file, checker, sourceRoot, importedNames) {
   const matches = /* @__PURE__ */ new Map();
   for (const statement of file.statements) {
-    if (!ts13.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts13.isNamedImports(statement.importClause.namedBindings)) {
+    if (!ts14.isImportDeclaration(statement) || !statement.importClause?.namedBindings || !ts14.isNamedImports(statement.importClause.namedBindings)) {
       continue;
     }
     for (const specifier of statement.importClause.namedBindings.elements) {
       if (!importedNames.has(specifier.name.text)) continue;
       const symbol = checker.getSymbolAtLocation(specifier.name);
       if (!symbol) continue;
-      const resolved = symbol.flags === ts13.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      const resolved = symbol.flags === ts14.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
       for (const declaration of resolved.declarations ?? []) {
-        if (!ts13.isEnumDeclaration(declaration)) continue;
+        if (!ts14.isEnumDeclaration(declaration)) continue;
         const declarationFile = path52.resolve(declaration.getSourceFile().fileName);
         if (!isWithin3(sourceRoot, declarationFile)) continue;
         const domain = domainOf(declaration.name.text);
         if (!domain) continue;
         for (const member of declaration.members) {
-          if (!member.initializer || !ts13.isStringLiteral(member.initializer)) continue;
+          if (!member.initializer || !ts14.isStringLiteral(member.initializer)) continue;
           const name = memberName7(member.name);
           if (!name) continue;
           const entries = matches.get(member.initializer.text) ?? [];
@@ -8264,19 +8474,19 @@ function importedEnums(file, checker, sourceRoot, importedNames) {
   return matches;
 }
 function isPathname2(node) {
-  return ts13.isPropertyAccessExpression(node) && node.name.text === "pathname";
+  return ts14.isPropertyAccessExpression(node) && node.name.text === "pathname";
 }
 function domainForUse(node) {
   const parent = node.parent;
-  if (ts13.isPropertyAssignment(parent) && parent.initializer === node && memberName7(parent.name) === "path") {
+  if (ts14.isPropertyAssignment(parent) && parent.initializer === node && memberName7(parent.name) === "path") {
     return "route";
   }
-  if (ts13.isCallExpression(parent) && parent.arguments[0] === node && ts13.isPropertyAccessExpression(parent.expression)) {
+  if (ts14.isCallExpression(parent) && parent.arguments[0] === node && ts14.isPropertyAccessExpression(parent.expression)) {
     const { expression, name } = parent.expression;
     if (columnMethods2.has(name.text)) return "column";
     if (name.text === "startsWith" && isPathname2(expression)) return "route";
   }
-  if (ts13.isBinaryExpression(parent) && (parent.operatorToken.kind === ts13.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts13.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname2(parent.right) || parent.right === node && isPathname2(parent.left))) {
+  if (ts14.isBinaryExpression(parent) && (parent.operatorToken.kind === ts14.SyntaxKind.EqualsEqualsEqualsToken || parent.operatorToken.kind === ts14.SyntaxKind.ExclamationEqualsEqualsToken) && (parent.left === node && isPathname2(parent.right) || parent.right === node && isPathname2(parent.left))) {
     return "route";
   }
   return void 0;
@@ -8298,7 +8508,7 @@ function importedEnumLiteralUses(context, root) {
   if (matches.size === 0) return [];
   const uses = [];
   const visit = (node) => {
-    if (ts13.isStringLiteral(node)) {
+    if (ts14.isStringLiteral(node)) {
       const domain = domainForUse(node);
       const candidates = matches.get(node.text)?.filter((entry) => entry.domain === domain) ?? [];
       if (candidates.length === 1) {
@@ -8315,7 +8525,7 @@ function importedEnumLiteralUses(context, root) {
         }
       }
     }
-    ts13.forEachChild(node, visit);
+    ts14.forEachChild(node, visit);
   };
   visit(file);
   return uses;
@@ -8812,7 +9022,7 @@ var rootSupportPlacementRule = {
 
 // eslint/rules/route-handler-shape.ts
 import path57 from "path";
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // eslint/rules/route-single-use-delegation.ts
 import path56 from "path";
@@ -8926,33 +9136,33 @@ function findHandler(node) {
   return void 0;
 }
 function isLoop(node) {
-  return ts14.isForStatement(node) || ts14.isForOfStatement(node) || ts14.isForInStatement(node) || ts14.isWhileStatement(node) || ts14.isDoStatement(node);
+  return ts15.isForStatement(node) || ts15.isForOfStatement(node) || ts15.isForInStatement(node) || ts15.isWhileStatement(node) || ts15.isDoStatement(node);
 }
 function isFunctionBoundary(node) {
-  return ts14.isFunctionExpression(node) || ts14.isArrowFunction(node) || ts14.isFunctionDeclaration(node);
+  return ts15.isFunctionExpression(node) || ts15.isArrowFunction(node) || ts15.isFunctionDeclaration(node);
 }
 function analyzeHandlerBody(body, sourceText) {
   const start = body.range?.[0] ?? 0;
   const end = body.range?.[1] ?? sourceText.length;
-  const sourceFile = ts14.createSourceFile(
+  const sourceFile = ts15.createSourceFile(
     "route.ts",
     sourceText.slice(start, end),
-    ts14.ScriptTarget.Latest,
+    ts15.ScriptTarget.Latest,
     true,
-    ts14.ScriptKind.TS
+    ts15.ScriptKind.TS
   );
   const kinds = /* @__PURE__ */ new Set();
   const calledNames = /* @__PURE__ */ new Set();
   const visit = (node) => {
-    if (ts14.isTryStatement(node)) kinds.add("try");
+    if (ts15.isTryStatement(node)) kinds.add("try");
     if (isLoop(node)) kinds.add("loop");
-    if (ts14.isIfStatement(node)) kinds.add("if");
-    if (ts14.isCallExpression(node) && ts14.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
+    if (ts15.isIfStatement(node)) kinds.add("if");
+    if (ts15.isCallExpression(node) && ts15.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") {
       kinds.add("map");
     }
-    if (ts14.isCallExpression(node) && ts14.isIdentifier(node.expression)) calledNames.add(node.expression.text);
+    if (ts15.isCallExpression(node) && ts15.isIdentifier(node.expression)) calledNames.add(node.expression.text);
     if (isFunctionBoundary(node)) return;
-    ts14.forEachChild(node, visit);
+    ts15.forEachChild(node, visit);
   };
   visit(sourceFile);
   return { kinds, calledNames };
@@ -9121,38 +9331,38 @@ var schemaCasingRule = {
 
 // eslint/rules/sole-state-owner.ts
 import path59 from "path";
-import ts15 from "typescript";
+import ts16 from "typescript";
 function findStateHooks(node) {
   const hooks = [];
   const visit = (child) => {
-    if (ts15.isCallExpression(child) && ts15.isIdentifier(child.expression) && child.expression.text === "useState") {
-      if (ts15.isVariableDeclaration(child.parent)) {
+    if (ts16.isCallExpression(child) && ts16.isIdentifier(child.expression) && child.expression.text === "useState") {
+      if (ts16.isVariableDeclaration(child.parent)) {
         const { name } = child.parent;
-        if (ts15.isArrayBindingPattern(name) && name.elements.length >= 2) {
+        if (ts16.isArrayBindingPattern(name) && name.elements.length >= 2) {
           const value = name.elements[0];
           const updater = name.elements[1];
-          if (value && updater && ts15.isBindingElement(value) && ts15.isBindingElement(updater)) {
+          if (value && updater && ts16.isBindingElement(value) && ts16.isBindingElement(updater)) {
             const valueName = value.name;
             const updaterName = updater.name;
-            if (ts15.isIdentifier(valueName) && ts15.isIdentifier(updaterName)) {
+            if (ts16.isIdentifier(valueName) && ts16.isIdentifier(updaterName)) {
               hooks.push({ value: valueName.text, updater: updaterName.text });
             }
           }
         }
       }
     }
-    ts15.forEachChild(child, visit);
+    ts16.forEachChild(child, visit);
   };
   visit(node);
   return hooks;
 }
 function isHookUsage(node, hook) {
-  if (ts15.isCallExpression(node) && ts15.isIdentifier(node.expression) && node.expression.text === hook.updater) {
+  if (ts16.isCallExpression(node) && ts16.isIdentifier(node.expression) && node.expression.text === hook.updater) {
     return "updater";
   }
-  if (ts15.isIdentifier(node) && node.text === hook.value) {
+  if (ts16.isIdentifier(node) && node.text === hook.value) {
     const parent = node.parent;
-    if (ts15.isBindingElement(parent) && parent.name === node || ts15.isVariableDeclaration(parent) && parent.name === node || ts15.isParameter(parent) && parent.name === node || ts15.isPropertyAccessExpression(parent) && parent.name === node || ts15.isPropertyAssignment(parent) && parent.name === node) {
+    if (ts16.isBindingElement(parent) && parent.name === node || ts16.isVariableDeclaration(parent) && parent.name === node || ts16.isParameter(parent) && parent.name === node || ts16.isPropertyAccessExpression(parent) && parent.name === node || ts16.isPropertyAssignment(parent) && parent.name === node) {
       return void 0;
     }
     return "value";
@@ -9162,61 +9372,61 @@ function isHookUsage(node, hook) {
 function topLevelJsxChildren(initial) {
   if (!initial) return void 0;
   let expression = initial;
-  while (ts15.isParenthesizedExpression(expression)) expression = expression.expression;
-  if (ts15.isJsxFragment(expression)) {
+  while (ts16.isParenthesizedExpression(expression)) expression = expression.expression;
+  if (ts16.isJsxFragment(expression)) {
     const children = expression.children.filter(
-      (c) => !ts15.isJsxText(c) && !ts15.isJsxSpreadAttribute(c)
+      (c) => !ts16.isJsxText(c) && !ts16.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
-  if (ts15.isJsxElement(expression)) {
+  if (ts16.isJsxElement(expression)) {
     const children = expression.children.filter(
-      (c) => !ts15.isJsxText(c) && !ts15.isJsxSpreadAttribute(c)
+      (c) => !ts16.isJsxText(c) && !ts16.isJsxSpreadAttribute(c)
     );
     return { root: expression, children };
   }
   return void 0;
 }
 function isSimpleDerivedExpression(node) {
-  if (ts15.isNewExpression(node) || ts15.isAwaitExpression(node) || ts15.isYieldExpression(node) || ts15.isDeleteExpression(node) || ts15.isTaggedTemplateExpression(node) || ts15.isBlock(node)) {
+  if (ts16.isNewExpression(node) || ts16.isAwaitExpression(node) || ts16.isYieldExpression(node) || ts16.isDeleteExpression(node) || ts16.isTaggedTemplateExpression(node) || ts16.isBlock(node)) {
     return false;
   }
-  if (ts15.isCallExpression(node)) {
+  if (ts16.isCallExpression(node)) {
     const callee = node.expression;
-    if (!ts15.isPropertyAccessExpression(callee) || !(/* @__PURE__ */ new Set(["filter", "map", "find", "findIndex", "some", "every", "slice", "includes"])).has(callee.name.text)) {
+    if (!ts16.isPropertyAccessExpression(callee) || !(/* @__PURE__ */ new Set(["filter", "map", "find", "findIndex", "some", "every", "slice", "includes"])).has(callee.name.text)) {
       return false;
     }
   }
-  if (ts15.isArrowFunction(node) && ts15.isBlock(node.body)) return false;
-  if (ts15.isBinaryExpression(node)) {
+  if (ts16.isArrowFunction(node) && ts16.isBlock(node.body)) return false;
+  if (ts16.isBinaryExpression(node)) {
     const operator = node.operatorToken.kind;
-    if (operator >= ts15.SyntaxKind.FirstAssignment && operator <= ts15.SyntaxKind.LastAssignment) return false;
+    if (operator >= ts16.SyntaxKind.FirstAssignment && operator <= ts16.SyntaxKind.LastAssignment) return false;
   }
-  if ((ts15.isPrefixUnaryExpression(node) || ts15.isPostfixUnaryExpression(node)) && (node.operator === ts15.SyntaxKind.PlusPlusToken || node.operator === ts15.SyntaxKind.MinusMinusToken)) {
+  if ((ts16.isPrefixUnaryExpression(node) || ts16.isPostfixUnaryExpression(node)) && (node.operator === ts16.SyntaxKind.PlusPlusToken || node.operator === ts16.SyntaxKind.MinusMinusToken)) {
     return false;
   }
   let safe = true;
-  ts15.forEachChild(node, (child) => {
+  ts16.forEachChild(node, (child) => {
     if (!isSimpleDerivedExpression(child)) safe = false;
   });
   return safe;
 }
 function isIdentifierRead(node, names) {
-  if (!ts15.isIdentifier(node) || !names.has(node.text)) return false;
+  if (!ts16.isIdentifier(node) || !names.has(node.text)) return false;
   const parent = node.parent;
-  return !(ts15.isBindingElement(parent) && parent.name === node || ts15.isVariableDeclaration(parent) && parent.name === node || ts15.isParameter(parent) && parent.name === node || ts15.isPropertyAccessExpression(parent) && parent.name === node || ts15.isPropertyAssignment(parent) && parent.name === node);
+  return !(ts16.isBindingElement(parent) && parent.name === node || ts16.isVariableDeclaration(parent) && parent.name === node || ts16.isParameter(parent) && parent.name === node || ts16.isPropertyAccessExpression(parent) && parent.name === node || ts16.isPropertyAssignment(parent) && parent.name === node);
 }
 function containsNamedRead(node, names) {
   if (isIdentifierRead(node, names)) return true;
-  return ts15.forEachChild(node, (child) => containsNamedRead(child, names)) ?? false;
+  return ts16.forEachChild(node, (child) => containsNamedRead(child, names)) ?? false;
 }
 function findDerivedState(body, hook) {
   const names = /* @__PURE__ */ new Set([hook.value]);
   const allowedInitializers = /* @__PURE__ */ new Set();
   for (const statement of body.statements) {
-    if (!ts15.isVariableStatement(statement) || statement.declarationList.flags !== ts15.NodeFlags.Const) continue;
+    if (!ts16.isVariableStatement(statement) || statement.declarationList.flags !== ts16.NodeFlags.Const) continue;
     for (const declaration of statement.declarationList.declarations) {
-      if (!ts15.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      if (!ts16.isIdentifier(declaration.name) || !declaration.initializer) continue;
       if (!containsNamedRead(declaration.initializer, names)) continue;
       if (!isSimpleDerivedExpression(declaration.initializer)) continue;
       names.add(declaration.name.text);
@@ -9232,21 +9442,21 @@ function countUsesIn(child, hook, names) {
   let count = 0;
   const visit = (node) => {
     if (isTrackedUse(node, hook, names)) count += 1;
-    if (ts15.isFunctionDeclaration(node) || ts15.isClassDeclaration(node)) return;
-    ts15.forEachChild(node, visit);
+    if (ts16.isFunctionDeclaration(node) || ts16.isClassDeclaration(node)) return;
+    ts16.forEachChild(node, visit);
   };
   visit(child);
   return count;
 }
 function jsxChildren(node) {
-  if (ts15.isJsxElement(node) || ts15.isJsxFragment(node)) {
-    return [...node.children].filter((child) => !ts15.isJsxText(child));
+  if (ts16.isJsxElement(node) || ts16.isJsxFragment(node)) {
+    return [...node.children].filter((child) => !ts16.isJsxText(child));
   }
   return void 0;
 }
 function isDecorativeSeparator(node) {
-  if (!ts15.isJsxSelfClosingElement(node) && !ts15.isJsxElement(node)) return false;
-  const tagName2 = ts15.isJsxElement(node) ? node.openingElement.tagName : node.tagName;
+  if (!ts16.isJsxSelfClosingElement(node) && !ts16.isJsxElement(node)) return false;
+  const tagName2 = ts16.isJsxElement(node) ? node.openingElement.tagName : node.tagName;
   return /(?:Divider|Separator)$/.test(tagName2.getText());
 }
 var soleStateOwnerRule = {
@@ -9283,18 +9493,18 @@ var soleStateOwnerRule = {
   }
 };
 function analyzeSoleOwner(declaration, hook) {
-  const body = ts15.isFunctionDeclaration(declaration) ? declaration.body : void 0;
-  if (!body || !ts15.isBlock(body)) return void 0;
+  const body = ts16.isFunctionDeclaration(declaration) ? declaration.body : void 0;
+  if (!body || !ts16.isBlock(body)) return void 0;
   const returns = [];
   const visit = (node) => {
-    if (node !== body && (ts15.isFunctionLike(node) || ts15.isClassLike(node))) return;
-    if (ts15.isReturnStatement(node)) returns.push(node);
-    ts15.forEachChild(node, visit);
+    if (node !== body && (ts16.isFunctionLike(node) || ts16.isClassLike(node))) return;
+    if (ts16.isReturnStatement(node)) returns.push(node);
+    ts16.forEachChild(node, visit);
   };
   visit(body);
   if (returns.length !== 1) return void 0;
   const expression = returns[0]?.expression;
-  if (!expression || !ts15.isExpression(expression)) return void 0;
+  if (!expression || !ts16.isExpression(expression)) return void 0;
   const root = topLevelJsxChildren(expression);
   if (!root) return void 0;
   const derived = findDerivedState(body, hook);
@@ -9305,7 +9515,7 @@ function analyzeSoleOwner(declaration, hook) {
     const children = jsxChildren(node);
     if (!children || children.length === 0) return void 0;
     for (const child of children) {
-      if (ts15.isJsxElement(child) || ts15.isJsxFragment(child)) {
+      if (ts16.isJsxElement(child) || ts16.isJsxFragment(child)) {
         const inner = analyzeSection(child);
         if (inner) return inner;
       }
@@ -9329,11 +9539,11 @@ function usesOutsideJsx(declaration, hook, derived, children) {
   let outside = false;
   const visit = (node) => {
     if (outside) return;
-    if (node !== declaration && (ts15.isFunctionDeclaration(node) || ts15.isClassDeclaration(node))) return;
+    if (node !== declaration && (ts16.isFunctionDeclaration(node) || ts16.isClassDeclaration(node))) return;
     if (isTrackedUse(node, hook, derived.names)) {
       let current = node;
       let allowed = false;
-      while (!ts15.isSourceFile(current)) {
+      while (!ts16.isSourceFile(current)) {
         if (children.includes(current) || derived.allowedInitializers.has(current)) {
           allowed = true;
           break;
@@ -9342,7 +9552,7 @@ function usesOutsideJsx(declaration, hook, derived, children) {
       }
       if (!allowed) outside = true;
     }
-    ts15.forEachChild(node, visit);
+    ts16.forEachChild(node, visit);
   };
   visit(declaration);
   return outside;
@@ -9766,7 +9976,7 @@ import path66 from "path";
 import { parse as parse3, toPlainObject } from "@eslint/css-tree";
 
 // eslint/rules/tailwind/source-files.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync14, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync15, statSync as statSync3 } from "fs";
 import path64 from "path";
 var CSS_EXTENSIONS = [".css"];
 var MODULE_EXTENSIONS4 = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
@@ -9797,7 +10007,7 @@ function cachedTextReader() {
     let text = texts.get(file);
     if (text === void 0) {
       try {
-        text = readFileSync14(file, "utf8");
+        text = readFileSync15(file, "utf8");
       } catch {
         text = "";
       }
@@ -10219,12 +10429,80 @@ var customUtilityApplyRule = {
 };
 
 // eslint/rules/tailwind/feature-css-placement.ts
-import { existsSync as existsSync10 } from "fs";
-import path70 from "path";
+import path71 from "path";
 
 // eslint/rules/tailwind/css-dependency-graph.ts
-import path68 from "path";
+import path69 from "path";
 import { generate, parse as parse4, walk } from "@eslint/css-tree";
+
+// eslint/rules/tailwind/tailwind-theme-classes.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync10 } from "fs";
+import path68 from "path";
+var WORKER = String.raw`
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const { names, projectRoot, moduleUrl } = JSON.parse(readFileSync(0, "utf8"));
+let resolved;
+try {
+  resolved = createRequire(path.join(projectRoot, "package.json")).resolve("@tailwindcss/node");
+} catch {
+  resolved = createRequire(moduleUrl).resolve("@tailwindcss/node");
+}
+const { __unstable__loadDesignSystem } = await import(pathToFileURL(resolved).href);
+if (typeof __unstable__loadDesignSystem !== "function") {
+  throw new Error("@tailwindcss/node design-system API is unavailable");
+}
+const css = "@theme inline {\n" + names.map((name, index) =>
+  name + "-pasika-owner-" + index + ": 1px;"
+).join("\n") + "\n}";
+const designSystem = await __unstable__loadDesignSystem(css, { base: projectRoot });
+const available = designSystem.getClassList().map(([name]) => name);
+const result = names.map((_, index) => {
+  const marker = "-pasika-owner-" + index;
+  return available.filter((name) => name.endsWith(marker)).map((name) => name.slice(0, -marker.length));
+});
+process.stdout.write(JSON.stringify(result));
+`;
+var cache5 = /* @__PURE__ */ new Map();
+var TOKEN = /^--[a-z][a-z0-9-]*$/u;
+function isStringGroups(value) {
+  return Array.isArray(value) && value.every((group) => Array.isArray(group) && group.every((item) => typeof item === "string"));
+}
+function themeClassesForTokens(names, sourceRoot) {
+  const projectRoot = path68.dirname(sourceRoot);
+  const unique = [...new Set(names)].filter((name) => TOKEN.test(name) && name !== "--spacing");
+  const missing = unique.filter((name) => !cache5.has(`${projectRoot}\0${name}`));
+  if (missing.length > 0) {
+    const child = spawnSync(process.execPath, ["--input-type=module", "--eval", WORKER], {
+      cwd: existsSync10(projectRoot) ? projectRoot : process.cwd(),
+      input: JSON.stringify({ names: missing, projectRoot, moduleUrl: import.meta.url }),
+      encoding: "utf8",
+      timeout: 3e4,
+      maxBuffer: 8 * 1024 * 1024,
+      windowsHide: true
+    });
+    if (child.error || child.status !== 0) {
+      const detail = child.error?.message ?? (child.stderr.trim() || "Tailwind could not resolve theme utilities");
+      throw new Error(`Cannot resolve Tailwind theme classes: ${detail}`);
+    }
+    const result = JSON.parse(child.stdout);
+    if (!isStringGroups(result) || result.length !== missing.length) {
+      throw new Error("Unexpected Tailwind theme class resolver output");
+    }
+    for (const [index, name] of missing.entries()) {
+      const classes = result[index];
+      if (!classes) throw new Error("Missing Tailwind theme class result");
+      cache5.set(`${projectRoot}\0${name}`, classes);
+    }
+  }
+  return new Map(unique.map((name) => [name, cache5.get(`${projectRoot}\0${name}`) ?? []]));
+}
+
+// eslint/rules/tailwind/css-dependency-graph.ts
 function lineAt(text, offset) {
   return text.slice(0, offset).split("\n").length;
 }
@@ -10235,93 +10513,15 @@ function tokenLines(content, token) {
 function pushSymbol(symbols, kind, name, file, line, value) {
   if (name) symbols.push({ kind, name, file, line, ...value === void 0 ? {} : { value } });
 }
-function themeClasses(name) {
-  if (name.includes("--", 2)) return [];
-  if (name.startsWith("--color-")) {
-    const stem = name.slice("--color-".length);
-    return [
-      "bg",
-      "text",
-      "border",
-      "ring",
-      "fill",
-      "stroke",
-      "accent",
-      "caret",
-      "decoration",
-      "outline",
-      "divide",
-      "from",
-      "via",
-      "to",
-      "shadow",
-      "ring-offset"
-    ].map((prefix) => `${prefix}-${stem}`);
-  }
-  if (name.startsWith("--background-image-")) return [`bg-${name.slice("--background-image-".length)}`];
-  if (name.startsWith("--spacing-")) {
-    const stem = name.slice("--spacing-".length);
-    return [
-      "p",
-      "px",
-      "py",
-      "pt",
-      "pr",
-      "pb",
-      "pl",
-      "ps",
-      "pe",
-      "m",
-      "mx",
-      "my",
-      "mt",
-      "mr",
-      "mb",
-      "ml",
-      "ms",
-      "me",
-      "w",
-      "h",
-      "size",
-      "min-w",
-      "min-h",
-      "max-w",
-      "max-h",
-      "gap",
-      "gap-x",
-      "gap-y",
-      "inset",
-      "inset-x",
-      "inset-y",
-      "top",
-      "right",
-      "bottom",
-      "left",
-      "start",
-      "end",
-      "space-x",
-      "space-y"
-    ].map((prefix) => `${prefix}-${stem}`);
-  }
-  if (name.startsWith("--aspect-")) return [`aspect-${name.slice("--aspect-".length)}`];
-  if (name.startsWith("--leading-")) return [`leading-${name.slice("--leading-".length)}`];
-  if (name.startsWith("--animate-")) return [`animate-${name.slice("--animate-".length)}`];
-  if (name.startsWith("--inset-shadow-")) return [`inset-shadow-${name.slice("--inset-shadow-".length)}`];
-  if (name.startsWith("--radius-")) return [`rounded-${name.slice("--radius-".length)}`];
-  if (name.startsWith("--text-") || name.startsWith("--tracking-") || name.startsWith("--font-")) {
-    return [name.slice(2)];
-  }
-  return [];
-}
 function buildCssDependencyGraph(options) {
   const definitions = [];
   const references = [];
   const imports = [];
   for (const file of options.css) {
-    const filename = path68.normalize(file.path);
+    const filename = path69.normalize(file.path);
     for (const spec of importedSpecifiers(file.content)) {
       const target = resolveSpecifier2(filename, spec, options.sourceRoot);
-      if (target) imports.push({ from: filename, to: path68.normalize(target) });
+      if (target) imports.push({ from: filename, to: path69.normalize(target) });
     }
     const ast = parse4(file.content, { positions: true, parseAtrulePrelude: false });
     const atRuleStack = [];
@@ -10423,12 +10623,16 @@ function buildCssDependencyGraph(options) {
   const selectors = new Set(definitions.filter((item) => item.kind === "selector").map((item) => item.name));
   const keyframes = new Set(definitions.filter((item) => item.kind === "keyframes").map((item) => item.name));
   const generatedClasses = /* @__PURE__ */ new Map();
+  const themeNames = definitions.filter((symbol) => symbol.kind === "theme-token").map((symbol) => symbol.name);
+  const classesByToken = themeClassesForTokens(themeNames, options.sourceRoot);
   for (const symbol of definitions) {
     if (symbol.kind !== "theme-token") continue;
-    for (const className of themeClasses(symbol.name)) generatedClasses.set(className, symbol.name);
+    for (const className of classesByToken.get(symbol.name) ?? []) {
+      generatedClasses.set(className, symbol.name);
+    }
   }
   for (const file of options.css) {
-    const filename = path68.normalize(file.path);
+    const filename = path69.normalize(file.path);
     const ast = parse4(file.content, { positions: true, parseAtrulePrelude: false });
     walk(ast, {
       enter(node) {
@@ -10481,7 +10685,7 @@ function buildCssDependencyGraph(options) {
     });
   }
   for (const file of options.modules) {
-    const filename = path68.normalize(file.path);
+    const filename = path69.normalize(file.path);
     for (const [kind, names] of [
       ["utility", utilities],
       ["keyframes", keyframes],
@@ -10506,20 +10710,20 @@ function cssSymbolUsages(graph, kind, name) {
 }
 
 // eslint/rules/tailwind/css-ownership.ts
-import path69 from "path";
+import path70 from "path";
 import { generate as generate2, parse as parse5, walk as walk2 } from "@eslint/css-tree";
 var GLOBAL = "globals.css";
 function symbolId(def) {
   return [def.file, def.kind, def.name, def.line].join("|");
 }
 function consumerFeature(file, sourceRoot) {
-  const parts = path69.relative(sourceRoot, file).split(path69.sep);
+  const parts = path70.relative(sourceRoot, file).split(path70.sep);
   return parts[0] === "features" && parts.length > 2 ? parts[1] ?? GLOBAL : GLOBAL;
 }
 function contains(text, name) {
   return new RegExp(`(?<![\\w-])${escapeRegExp(name)}(?![\\w-])`, "u").test(text);
 }
-function dependencies(text, defs) {
+function dependencies(text, defs, classesByToken) {
   const result = /* @__PURE__ */ new Set();
   const variables = new Set([...text.matchAll(/var\(\s*(?<name>--[\w-]+)/gu)].map((m) => m.groups?.name));
   const applied = [...text.matchAll(/@apply\s+(?<value>[^;}]+)/gu)].map((m) => m.groups?.value ?? "");
@@ -10530,7 +10734,7 @@ function dependencies(text, defs) {
     (m) => (m.groups?.value ?? "").replaceAll("_", " ").toLowerCase()
   );
   for (const def of defs) {
-    const match = (def.kind === "theme-token" || def.kind === "root-variable") && variables.has(def.name) || (def.kind === "utility" || def.kind === "selector") && applied.some((part) => contains(part, def.name)) || def.kind === "keyframes" && animations.some((part) => contains(part, def.name)) || def.kind === "font-face" && (families.some((part) => contains(part, def.name)) || new RegExp(`^\\s*["']?${escapeRegExp(def.name)}["']?\\s*(?:,|$)`, "iu").test(text)) || def.kind === "theme-token" && applied.some((part) => themeClasses(def.name).some((name) => contains(part, name)));
+    const match = (def.kind === "theme-token" || def.kind === "root-variable") && variables.has(def.name) || (def.kind === "utility" || def.kind === "selector") && applied.some((part) => contains(part, def.name)) || def.kind === "keyframes" && animations.some((part) => contains(part, def.name)) || def.kind === "font-face" && (families.some((part) => contains(part, def.name)) || new RegExp(`^\\s*["']?${escapeRegExp(def.name)}["']?\\s*(?:,|$)`, "iu").test(text)) || def.kind === "theme-token" && applied.some((part) => (classesByToken.get(def.name) ?? []).some((name) => contains(part, name)));
     if (match) result.add(symbolId(def));
   }
   return result;
@@ -10538,7 +10742,7 @@ function dependencies(text, defs) {
 function bodiesOf(css2, defs) {
   const bodies = /* @__PURE__ */ new Map();
   for (const src of css2) {
-    const file = path69.normalize(src.path);
+    const file = path70.normalize(src.path);
     const ast = parse5(src.content, { positions: true, parseAtrulePrelude: false });
     walk2(ast, {
       enter(node) {
@@ -10566,6 +10770,10 @@ function bodiesOf(css2, defs) {
 function inferCssOwners(options) {
   const { graph, css: css2, modules, sourceRoot } = options;
   const defs = graph.definitions;
+  const classesByToken = themeClassesForTokens(
+    defs.filter((def) => def.kind === "theme-token").map((def) => def.name),
+    sourceRoot
+  );
   const owners = new Map(defs.map((def) => [symbolId(def), /* @__PURE__ */ new Set()]));
   const counts = /* @__PURE__ */ new Map();
   for (const def of defs) {
@@ -10598,7 +10806,7 @@ function inferCssOwners(options) {
   }
   const links = /* @__PURE__ */ new Map();
   for (const [key, content] of bodiesOf(css2, defs)) {
-    const targets = dependencies(content, defs);
+    const targets = dependencies(content, defs, classesByToken);
     const def = defs.find((candidate) => symbolId(candidate) === key);
     if (def?.kind === "theme-token" && def.name.startsWith("--animate-")) {
       for (const frame of defs) {
@@ -10611,7 +10819,7 @@ function inferCssOwners(options) {
     links.set(key, targets);
   }
   for (const src of css2) {
-    if (path69.basename(src.path) !== GLOBAL) continue;
+    if (path70.basename(src.path) !== GLOBAL) continue;
     const ast = parse5(src.content, { positions: true, parseAtrulePrelude: false });
     if (ast.type !== "StyleSheet") continue;
     for (const node of ast.children) {
@@ -10619,7 +10827,7 @@ function inferCssOwners(options) {
         continue;
       }
       const body = src.content.slice(node.loc.start.offset, node.loc.end.offset);
-      for (const key of dependencies(body, defs)) owners.get(key)?.add(GLOBAL);
+      for (const key of dependencies(body, defs, classesByToken)) owners.get(key)?.add(GLOBAL);
     }
   }
   let changed = true;
@@ -10652,9 +10860,8 @@ function inferCssOwners(options) {
 }
 
 // eslint/rules/tailwind/feature-css-placement.ts
-var STYLES_DIR = path70.join("app", "styles");
+var STYLES_DIR = path71.join("app", "styles");
 var GLOBALS = "globals.css";
-var FEATURE_CSS = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*\.css$/u;
 var LABELS = {
   utility: "utility",
   "theme-token": "theme token",
@@ -10673,13 +10880,10 @@ var featureCssPlacementRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const current = path70.normalize(path70.resolve(context.filename));
-    const relative = path70.relative(sourceRoot, current);
-    const styles = path70.join(sourceRoot, STYLES_DIR);
-    if (!relative.startsWith(`${STYLES_DIR}${path70.sep}`)) return {};
-    const basename = path70.basename(current);
-    const featureName = basename.slice(0, -".css".length);
-    const isFeatureFile = path70.dirname(current) === styles && FEATURE_CSS.test(basename) && existsSync10(path70.join(sourceRoot, "features", featureName));
+    const current = path71.normalize(path71.resolve(context.filename));
+    const relative = path71.relative(sourceRoot, current);
+    const styles = path71.join(sourceRoot, STYLES_DIR);
+    if (!relative.startsWith(`${STYLES_DIR}${path71.sep}`)) return {};
     const read = cachedTextReader();
     const css2 = findFiles(sourceRoot, CSS_EXTENSIONS).map((file) => ({ path: file, content: read(file) }));
     const modules = findFiles(sourceRoot, MODULE_EXTENSIONS4).map((file) => ({ path: file, content: read(file) }));
@@ -10692,10 +10896,7 @@ var featureCssPlacementRule = {
           const owner = owners.get(symbolId(definition));
           if (!owner) continue;
           const expected = owner === GLOBALS ? GLOBALS : `${owner}.css`;
-          if (owner !== GLOBALS && (basename === GLOBALS || !isFeatureFile) && !existsSync10(path70.join(styles, expected))) {
-            continue;
-          }
-          if (basename === expected) continue;
+          if (current === path71.join(styles, expected)) continue;
           const kind = LABELS[definition.kind] ?? definition.kind;
           context.report({
             node,
@@ -10713,7 +10914,7 @@ var featureCssPlacementRule = {
 
 // eslint/rules/tailwind/global-stylesheet.ts
 import { existsSync as existsSync11 } from "fs";
-import path71 from "path";
+import path72 from "path";
 var MISSING_REGISTRATION = 'Global stylesheet must register Tailwind with @import "tailwindcss".';
 var MISSING_ENTRYPOINT = "Project CSS must have a canonical global stylesheet at src/app/styles/globals.css.";
 var globalStylesheetRule = {
@@ -10727,11 +10928,11 @@ var globalStylesheetRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const entryPoint = path71.normalize(path71.join(sourceRoot, "app", "styles", "globals.css"));
-    const current = path71.normalize(path71.resolve(context.filename));
+    const entryPoint = path72.normalize(path72.join(sourceRoot, "app", "styles", "globals.css"));
+    const current = path72.normalize(path72.resolve(context.filename));
     const isEntryPoint = current === entryPoint;
     const hasEntryPoint = existsSync11(entryPoint);
-    const isFirstStylesheet = !hasEntryPoint && [current, ...findFiles(sourceRoot, CSS_EXTENSIONS).map((file) => path71.normalize(file))].sort()[0] === current;
+    const isFirstStylesheet = !hasEntryPoint && [current, ...findFiles(sourceRoot, CSS_EXTENSIONS).map((file) => path72.normalize(file))].sort()[0] === current;
     if (!isEntryPoint && !isFirstStylesheet) return {};
     return {
       "StyleSheet:exit"(node) {
@@ -10791,7 +10992,7 @@ var noUtilityAliasRule = {
 };
 
 // eslint/rules/tailwind/root-variables.ts
-import path72 from "path";
+import path73 from "path";
 import { parse as parse6, walk as walk3 } from "@eslint/css-tree";
 
 // eslint/rules/tailwind/external-mapping.ts
@@ -10818,13 +11019,13 @@ var rootVariablesRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const current = path72.normalize(path72.resolve(context.filename));
+    const current = path73.normalize(path73.resolve(context.filename));
     const textOf = cachedTextReader();
     const stylesheets = findFiles(sourceRoot, CSS_EXTENSIONS);
     const graph = buildCssDependencyGraph({
       sourceRoot,
       css: [
-        ...stylesheets.filter((file) => path72.normalize(file) !== current).map((file) => ({ path: file, content: textOf(file) })),
+        ...stylesheets.filter((file) => path73.normalize(file) !== current).map((file) => ({ path: file, content: textOf(file) })),
         { path: current, content: context.sourceCode.text }
       ],
       modules: [],
@@ -10853,8 +11054,8 @@ var rootVariablesRule = {
       });
     }
     const mirroredTokens = /* @__PURE__ */ new Set();
-    for (const file of [...stylesheets.filter((candidate) => path72.normalize(candidate) !== current), current]) {
-      const source = (path72.normalize(file) === current ? context.sourceCode.text : textOf(file)).replace(
+    for (const file of [...stylesheets.filter((candidate) => path73.normalize(candidate) !== current), current]) {
+      const source = (path73.normalize(file) === current ? context.sourceCode.text : textOf(file)).replace(
         /\/\*[\s\S]*?\*\//gu,
         " "
       );
@@ -10874,8 +11075,8 @@ var rootVariablesRule = {
     }
     const authoredVariables = new Set(names);
     const variantNames = /* @__PURE__ */ new Set();
-    for (const file of [...stylesheets.filter((candidate) => path72.normalize(candidate) !== current), current]) {
-      const css2 = path72.normalize(file) === current ? context.sourceCode.text : textOf(file);
+    for (const file of [...stylesheets.filter((candidate) => path73.normalize(candidate) !== current), current]) {
+      const css2 = path73.normalize(file) === current ? context.sourceCode.text : textOf(file);
       const tree = parse6(css2, { parseAtrulePrelude: false });
       let variantDepth = 0;
       walk3(tree, {
@@ -10984,7 +11185,7 @@ var rootVariablesRule = {
 };
 
 // eslint/rules/tailwind/stylesheet-ordering.ts
-import path73 from "path";
+import path74 from "path";
 import { generate as generate3 } from "@eslint/css-tree";
 var SECTION_ORDER = [
   "Tailwind import",
@@ -11031,8 +11232,8 @@ var stylesheetOrderingRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const entryPoint = path73.normalize(path73.join(sourceRoot, "app", "styles", "globals.css"));
-    if (path73.normalize(path73.resolve(context.filename)) !== entryPoint) return {};
+    const entryPoint = path74.normalize(path74.join(sourceRoot, "app", "styles", "globals.css"));
+    if (path74.normalize(path74.resolve(context.filename)) !== entryPoint) return {};
     return {
       "StyleSheet:exit"(node) {
         const topLevel = [...node.children];
@@ -11104,7 +11305,7 @@ var stylesheetOrderingRule = {
 };
 
 // eslint/rules/tailwind/theme-mode.ts
-import path74 from "path";
+import path75 from "path";
 import { generate as generate4 } from "@eslint/css-tree";
 var MODE_NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
 var MODE_REFERENCE = /(?:^|[^a-z0-9-])(?<name>[a-z][a-z0-9]*(?:-[a-z0-9]+)*):(?=[a-z[(])/gu;
@@ -11143,9 +11344,9 @@ var themeModeRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const current = path74.normalize(path74.resolve(context.filename));
-    const globalFile = path74.normalize(path74.join(sourceRoot, "app", "styles", "globals.css"));
-    if (path74.dirname(current) !== path74.dirname(globalFile)) return {};
+    const current = path75.normalize(path75.resolve(context.filename));
+    const globalFile = path75.normalize(path75.join(sourceRoot, "app", "styles", "globals.css"));
+    if (path75.dirname(current) !== path75.dirname(globalFile)) return {};
     const read = cachedTextReader();
     return {
       "StyleSheet:exit"(node) {
@@ -11226,7 +11427,7 @@ var themeModeRule = {
 };
 
 // eslint/rules/tailwind/theme-reset.ts
-import path75 from "path";
+import path76 from "path";
 import { generate as generate5 } from "@eslint/css-tree";
 function isThemeReset(node) {
   if (!node) return false;
@@ -11255,9 +11456,9 @@ var themeResetRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const current = path75.normalize(path75.resolve(context.filename));
-    const entryPoint = path75.normalize(path75.join(sourceRoot, "app", "styles", "globals.css"));
-    if (path75.dirname(current) !== path75.dirname(entryPoint)) return {};
+    const current = path76.normalize(path76.resolve(context.filename));
+    const entryPoint = path76.normalize(path76.join(sourceRoot, "app", "styles", "globals.css"));
+    if (path76.dirname(current) !== path76.dirname(entryPoint)) return {};
     return {
       "StyleSheet:exit"(node) {
         const hasReset = hasThemeReset(node);
@@ -11282,7 +11483,7 @@ var themeResetRule = {
 };
 
 // eslint/rules/tailwind/unique-css-definition.ts
-import path76 from "path";
+import path77 from "path";
 function ownershipKey(symbol) {
   if (symbol.kind === "selector") return void 0;
   if (symbol.kind === "root-variable" && symbol.scope !== "default") return void 0;
@@ -11314,7 +11515,7 @@ var uniqueCssDefinitionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const current = path76.normalize(path76.resolve(context.filename));
+    const current = path77.normalize(path77.resolve(context.filename));
     const cssFiles = findFiles(sourceRoot, CSS_EXTENSIONS);
     if (cssFiles.length === 0) return {};
     const textOf = cachedTextReader();
@@ -11322,7 +11523,7 @@ var uniqueCssDefinitionRule = {
       sourceRoot,
       css: cssFiles.map((file) => ({
         path: file,
-        content: path76.normalize(file) === current ? context.sourceCode.text : textOf(file)
+        content: path77.normalize(file) === current ? context.sourceCode.text : textOf(file)
       })),
       modules: [],
       includeReferences: false
@@ -11344,7 +11545,7 @@ var uniqueCssDefinitionRule = {
           if (!canonical) continue;
           for (const symbol of definitions.slice(1)) {
             if (symbol.file !== current) continue;
-            const message = symbol.file === canonical.file ? `${symbolLabel(symbol)} "${symbol.name}" is defined more than once in this CSS file; define it only once.` : `${symbolLabel(symbol)} "${symbol.name}" is also defined in ${path76.relative(sourceRoot, canonical.file)}; define it in only one CSS file.`;
+            const message = symbol.file === canonical.file ? `${symbolLabel(symbol)} "${symbol.name}" is defined more than once in this CSS file; define it only once.` : `${symbolLabel(symbol)} "${symbol.name}" is also defined in ${path77.relative(sourceRoot, canonical.file)}; define it in only one CSS file.`;
             context.report({
               node,
               loc: {
@@ -11361,7 +11562,7 @@ var uniqueCssDefinitionRule = {
 };
 
 // eslint/rules/tailwind/unique-css-token-value.ts
-import path77 from "path";
+import path78 from "path";
 
 // eslint/rules/tailwind/css-named-colors.ts
 var CSS_NAMED_COLORS = {
@@ -11602,14 +11803,14 @@ var uniqueCssTokenValueRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const current = path77.normalize(path77.resolve(context.filename));
+    const current = path78.normalize(path78.resolve(context.filename));
     const textOf = cachedTextReader();
     const cssFiles = findFiles(sourceRoot, CSS_EXTENSIONS);
     const graph = buildCssDependencyGraph({
       sourceRoot,
       css: cssFiles.map((file) => ({
         path: file,
-        content: path77.normalize(file) === current ? context.sourceCode.text : textOf(file)
+        content: path78.normalize(file) === current ? context.sourceCode.text : textOf(file)
       })),
       modules: [],
       includeReferences: false
@@ -11642,7 +11843,7 @@ var uniqueCssTokenValueRule = {
               start: { line: definition.line, column: 1 },
               end: { line: definition.line, column: 2 }
             },
-            message: `Token "${definition.name}" duplicates the value of "${original.name}" in ${path77.relative(
+            message: `Token "${definition.name}" duplicates the value of "${original.name}" in ${path78.relative(
               sourceRoot,
               original.file
             )}:${String(original.line)}; reuse one design token.`
@@ -11655,7 +11856,7 @@ var uniqueCssTokenValueRule = {
 
 // eslint/rules/tailwind/unused-utility.ts
 import { statSync as statSync5 } from "fs";
-import path78 from "path";
+import path79 from "path";
 var unusedUtilityRule = {
   meta: {
     schema: [],
@@ -11671,7 +11872,7 @@ var unusedUtilityRule = {
     } catch {
       return {};
     }
-    const current = path78.normalize(path78.resolve(context.filename));
+    const current = path79.normalize(path79.resolve(context.filename));
     const textOf = cachedTextReader();
     const cssFiles = findFiles(sourceRoot, CSS_EXTENSIONS);
     const moduleFiles = findFiles(sourceRoot, MODULE_EXTENSIONS4);
@@ -11679,7 +11880,7 @@ var unusedUtilityRule = {
       sourceRoot,
       css: cssFiles.map((file) => ({
         path: file,
-        content: path78.normalize(file) === current ? context.sourceCode.text : textOf(file)
+        content: path79.normalize(file) === current ? context.sourceCode.text : textOf(file)
       })),
       modules: moduleFiles.map((file) => ({ path: file, content: textOf(file) }))
     });
@@ -11700,9 +11901,9 @@ var unusedUtilityRule = {
 };
 
 // eslint/rules/tailwind/utility-mapping.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync12 } from "fs";
-import path79 from "path";
+import path80 from "path";
 function applyOperationCount(utility, textOf) {
   let count = 0;
   for (const apply of atrulesNamed(utility, "apply")) {
@@ -11823,7 +12024,7 @@ function themeSupportedGenerators(candidates, cwd) {
   const cacheKey = (key) => `${cwd}\0${key}`;
   const missing = [...unique].filter(([key]) => !generatorSupportCache.has(cacheKey(key)));
   if (missing.length > 0) {
-    const child = spawnSync(process.execPath, ["--input-type=module", "--eval", THEME_GENERATOR_WORKER], {
+    const child = spawnSync2(process.execPath, ["--input-type=module", "--eval", THEME_GENERATOR_WORKER], {
       cwd,
       input: JSON.stringify(missing.map(([, candidate]) => candidate)),
       encoding: "utf8",
@@ -12057,13 +12258,13 @@ var utilityMappingRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const current = path79.normalize(path79.resolve(context.filename));
+    const current = path80.normalize(path80.resolve(context.filename));
     const textOf = cachedTextReader();
     const graph = buildCssDependencyGraph({
       sourceRoot,
       css: findFiles(sourceRoot, CSS_EXTENSIONS).map((file) => ({
         path: file,
-        content: path79.normalize(file) === current ? context.sourceCode.text : textOf(file)
+        content: path80.normalize(file) === current ? context.sourceCode.text : textOf(file)
       })),
       modules: [],
       includeReferences: false
@@ -12125,6 +12326,10 @@ var utilityMappingRule = {
             themeDefinitions.set(child.property, definitions);
           }
         }
+        const classesByToken = themeClassesForTokens(
+          [...projectTokens.map((token) => token.name), ...themeDefinitions.keys()],
+          sourceRoot
+        );
         for (const cssRule of node.children) {
           if (cssRule.type !== "Rule") continue;
           if (context.sourceCode.getText(cssRule.prelude).trim() !== ":root") continue;
@@ -12203,7 +12408,8 @@ var utilityMappingRule = {
               continue;
             }
             const generatedClass = `${candidate.prefix}-${token.name.slice(namespacePrefix.length)}`;
-            if (candidate.namespace === "color" && !themeClasses(token.name).includes(generatedClass)) continue;
+            const generatesClass = (classesByToken.get(token.name) ?? []).includes(generatedClass);
+            if (candidate.namespace === "color" && !generatesClass) continue;
             return generatedClass;
           }
           return void 0;
@@ -12211,8 +12417,8 @@ var utilityMappingRule = {
         const generatorCandidates = utilities.map(
           (utility) => themeCandidate(preludeIdentifiers(utility)[0] ?? "unknown", context.sourceCode.getText(utility))
         ).filter((candidate) => Boolean(candidate && requiresGeneratorProbe(candidate)));
-        const physicalDir = path79.dirname(context.physicalFilename);
-        const tailwindCwd = path79.isAbsolute(physicalDir) && existsSync12(physicalDir) ? physicalDir : context.cwd;
+        const physicalDir = path80.dirname(context.physicalFilename);
+        const tailwindCwd = path80.isAbsolute(physicalDir) && existsSync12(physicalDir) ? physicalDir : context.cwd;
         const themeGenerators = themeSupportedGenerators(generatorCandidates, tailwindCwd);
         for (const utility of utilities) {
           const name = preludeIdentifiers(utility)[0] ?? "unknown";
@@ -12284,7 +12490,7 @@ var utilityMappingRule = {
           if (only.type === "Atrule" && only.name === "apply") {
             const alias = /^@apply\s+(?<name>[a-z][a-z0-9-]*)\s*;?$/u.exec(declarationText)?.groups?.name;
             if (alias && [...projectTokens.map((token) => token.name), ...themeDefinitions.keys()].some(
-              (name) => themeClasses(name).includes(alias)
+              (name) => (classesByToken.get(name) ?? []).includes(alias)
             )) {
               context.report({
                 node: cssNode,
@@ -12320,9 +12526,9 @@ var utilityMappingRule = {
 };
 
 // eslint/rules/tailwind/utility-name-parity.ts
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync13 } from "fs";
-import path80 from "path";
+import path81 from "path";
 import { generate as generate6, parse as parse7, toPlainObject as toPlainObject2 } from "@eslint/css-tree";
 function numericPart(value) {
   const match = /^(?<negative>-?)(?<number>(?:\d+(?:\.\d+)?|\.\d+))(?<unit>%|px|rem|em|vw|vh|dvw|dvh|ch|fr|s|ms|deg|turn)?$/u.exec(
@@ -12387,7 +12593,7 @@ function compileApplies(applies, cwd) {
   const key = `${cwd}\0${JSON.stringify(applies)}`;
   const cached = compilerCache.get(key);
   if (cached) return cached;
-  const child = spawnSync2(process.execPath, ["--input-type=module", "--eval", TAILWIND_WORKER], {
+  const child = spawnSync3(process.execPath, ["--input-type=module", "--eval", TAILWIND_WORKER], {
     cwd,
     input: JSON.stringify(applies),
     encoding: "utf8",
@@ -12466,8 +12672,8 @@ var utilityNameParityRule = {
           return apply ? [{ utility, name, apply }] : [];
         });
         if (candidates.length === 0) return;
-        const physicalDir = path80.dirname(context.physicalFilename);
-        const cwd = path80.isAbsolute(physicalDir) && existsSync13(physicalDir) ? physicalDir : context.cwd;
+        const physicalDir = path81.dirname(context.physicalFilename);
+        const cwd = path81.isAbsolute(physicalDir) && existsSync13(physicalDir) ? physicalDir : context.cwd;
         const compiled = compileApplies(
           candidates.map((candidate) => candidate.apply),
           cwd
@@ -12535,7 +12741,7 @@ var tailwindRules = {
 };
 
 // eslint/rules/type-extraction.ts
-import path81 from "path";
+import path82 from "path";
 var typeExtractionRule = {
   meta: {
     schema: [],
@@ -12546,7 +12752,7 @@ var typeExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path81.resolve(context.filename);
+    const file = path82.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0) return {};
     const index = getProjectIndex(sourceRoot);
@@ -12685,9 +12891,9 @@ var uiStateRule = {
 };
 
 // eslint/rules/unknown-utility.ts
-import { existsSync as existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync16, statSync as statSync6 } from "fs";
 import { createRequire } from "module";
-import path82 from "path";
+import path83 from "path";
 var PREFIX_NAMESPACES = {
   bg: ["color", "background-image"],
   text: ["color", "text"],
@@ -12975,7 +13181,7 @@ function stylesheetFiles(dir) {
   }
   return entries.flatMap((entry) => {
     if (entry.startsWith(".") || entry === "node_modules") return [];
-    const entryPath = path82.join(dir, entry);
+    const entryPath = path83.join(dir, entry);
     let stats;
     try {
       stats = statSync6(entryPath);
@@ -12983,7 +13189,7 @@ function stylesheetFiles(dir) {
       return [];
     }
     if (stats.isDirectory()) return stylesheetFiles(entryPath);
-    return path82.extname(entry) === ".css" ? [entryPath] : [];
+    return path83.extname(entry) === ".css" ? [entryPath] : [];
   });
 }
 function packageNameOf(specifier) {
@@ -12994,24 +13200,24 @@ function packageNameOf(specifier) {
 function resolvePackageStylesheet(fromFile, specifier) {
   const packageName = packageNameOf(specifier);
   if (!packageName || packageName === "tailwindcss") return void 0;
-  let directory = path82.dirname(fromFile);
-  while (directory !== path82.dirname(directory)) {
-    const packageRoot = path82.join(directory, "node_modules", packageName);
-    const manifestPath = path82.join(packageRoot, "package.json");
+  let directory = path83.dirname(fromFile);
+  while (directory !== path83.dirname(directory)) {
+    const packageRoot = path83.join(directory, "node_modules", packageName);
+    const manifestPath = path83.join(packageRoot, "package.json");
     if (existsSync14(manifestPath)) {
       try {
-        const manifest = readFileSync15(manifestPath, "utf8");
+        const manifest = readFileSync16(manifestPath, "utf8");
         const stylesheet = /"style"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const main = /"main"\s*:\s*"(?<file>[^"]+\.css)"/.exec(manifest)?.groups?.file;
         const target = stylesheet ?? main;
         if (!target) return void 0;
-        const resolved = path82.resolve(packageRoot, target);
+        const resolved = path83.resolve(packageRoot, target);
         return existsSync14(resolved) ? resolved : void 0;
       } catch {
         return void 0;
       }
     }
-    directory = path82.dirname(directory);
+    directory = path83.dirname(directory);
   }
   return void 0;
 }
@@ -13020,7 +13226,7 @@ function inventoryStylesheetFiles(projectFiles) {
   for (const file of projectFiles) {
     let css2;
     try {
-      css2 = readFileSync15(file, "utf8");
+      css2 = readFileSync16(file, "utf8");
     } catch {
       continue;
     }
@@ -13087,7 +13293,7 @@ function readInventory(files) {
   for (const file of files) {
     let css2;
     try {
-      css2 = readFileSync15(file, "utf8");
+      css2 = readFileSync16(file, "utf8");
     } catch {
       continue;
     }
@@ -13292,7 +13498,7 @@ var unknownUtilityRule = {
 };
 
 // eslint/rules/util-file-name.ts
-import path83 from "path";
+import path84 from "path";
 function toKebabCase2(value) {
   return value.replace(/(?<lower>[a-z0-9])(?<upper>[A-Z])/g, "$<lower>-$<upper>").replace(/(?<first>[A-Z])(?<rest>[A-Z][a-z])/g, "$<first>-$<rest>").toLowerCase();
 }
@@ -13305,7 +13511,7 @@ var utilFileNameRule = {
     }
   },
   create(context) {
-    const filename = path83.resolve(context.filename);
+    const filename = path84.resolve(context.filename);
     const segments = filename.replace(/\\/g, "/").split("/");
     if (!segments.includes("utils")) return {};
     let module;
@@ -13319,13 +13525,13 @@ var utilFileNameRule = {
     const functionName = functions[0]?.name;
     if (!functionName) return {};
     const expected = toKebabCase2(functionName);
-    const actual = path83.basename(filename, path83.extname(filename));
+    const actual = path84.basename(filename, path84.extname(filename));
     if (!expected || actual === expected) return {};
     return {
       Program(node) {
         context.report({
           node,
-          message: `A utility file exporting ${functionName} must be named ${expected}.${path83.extname(filename).slice(1)}.`
+          message: `A utility file exporting ${functionName} must be named ${expected}.${path84.extname(filename).slice(1)}.`
         });
       }
     };
@@ -13333,7 +13539,7 @@ var utilFileNameRule = {
 };
 
 // eslint/rules/value-extraction.ts
-import path84 from "path";
+import path85 from "path";
 var valueExtractionRule = {
   meta: {
     schema: [],
@@ -13344,7 +13550,7 @@ var valueExtractionRule = {
   },
   create(context) {
     const sourceRoot = sourceRootOf(context);
-    const file = path84.resolve(context.filename);
+    const file = path85.resolve(context.filename);
     const segments = segmentsOf(file, sourceRoot);
     if (segments.length === 0 || segments[0] !== "app") return {};
     const index = getProjectIndex(sourceRoot);
@@ -13365,8 +13571,8 @@ var valueExtractionRule = {
 };
 
 // eslint/rules/vulyk/tracked-docs.ts
-import { existsSync as existsSync15, readFileSync as readFileSync16 } from "fs";
-import path85 from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync17 } from "fs";
+import path86 from "path";
 var PASIKA_REPO = "Bredansky/pasika";
 var BASE_REQUIRED_TRACKED_DOCS = [
   { name: "documentation-guide", path: "docs/documentation-guide" },
@@ -13399,8 +13605,8 @@ var trackedDocsRule = {
         if (!context.filename.endsWith("package.json")) return;
         const root = node.body;
         if (root.type !== "Object") return;
-        const projectRoot = path85.dirname(path85.resolve(context.filename));
-        const configPath = path85.join(projectRoot, "vulyk.config.ts");
+        const projectRoot = path86.dirname(path86.resolve(context.filename));
+        const configPath = path86.join(projectRoot, "vulyk.config.ts");
         if (!existsSync15(configPath)) {
           context.report({
             node,
@@ -13408,7 +13614,7 @@ var trackedDocsRule = {
           });
           return;
         }
-        const config = readFileSync16(configPath, "utf8");
+        const config = readFileSync17(configPath, "utf8");
         if (!config.includes(PASIKA_REPO)) {
           context.report({
             node,
@@ -13425,7 +13631,7 @@ var trackedDocsRule = {
             });
           }
         }
-        const agentsPath = path85.join(projectRoot, "AGENTS.md");
+        const agentsPath = path86.join(projectRoot, "AGENTS.md");
         if (!existsSync15(agentsPath)) {
           context.report({
             node,
@@ -13525,7 +13731,7 @@ var withResponseHelperRule = {
 
 // eslint/rules/zirka-baseline.ts
 import fs7 from "fs";
-import path86 from "path";
+import path87 from "path";
 var ESLINT_CONFIG = /^eslint\.config\.(?:ts|mts|cts|js|mjs|cjs)$/;
 var PRETTIER_CONFIGS = [
   "prettier.config.mjs",
@@ -13544,10 +13750,10 @@ var zirkaBaselineRule = {
     }
   },
   create(context) {
-    const filename = path86.resolve(context.filename);
-    const basename = path86.basename(filename);
+    const filename = path87.resolve(context.filename);
+    const basename = path87.basename(filename);
     if (!ESLINT_CONFIG.test(basename)) return {};
-    const projectRoot = path86.dirname(filename);
+    const projectRoot = path87.dirname(filename);
     const report3 = (message) => {
       context.report({
         node: context.sourceCode.ast,
@@ -13562,7 +13768,7 @@ var zirkaBaselineRule = {
             'ESLint config must take its configuration from zirka (import { styleguide } from "zirka") instead of restating rules locally.'
           );
         }
-        const tsconfigPath = path86.join(projectRoot, "tsconfig.json");
+        const tsconfigPath = path87.join(projectRoot, "tsconfig.json");
         if (!fs7.existsSync(tsconfigPath)) {
           report3('No tsconfig.json found. Create one extending the zirka TypeScript base config ("zirka/typescript").');
         } else {
@@ -13580,13 +13786,13 @@ var zirkaBaselineRule = {
             report3('tsconfig.json must extend the zirka TypeScript base config ("zirka/typescript").');
           }
         }
-        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path86.join(projectRoot, name)));
+        const prettierConfigFile = PRETTIER_CONFIGS.find((name) => fs7.existsSync(path87.join(projectRoot, name)));
         if (!prettierConfigFile) {
           report3(
             "No prettier config found. Create one that takes its configuration from zirka (styleguide({ prettier: true }).prettierConfig)."
           );
         } else {
-          const content = fs7.readFileSync(path86.join(projectRoot, prettierConfigFile), "utf8");
+          const content = fs7.readFileSync(path87.join(projectRoot, prettierConfigFile), "utf8");
           if (!content.includes("zirka")) {
             report3(
               "The prettier config must take its configuration from zirka (styleguide({ prettier: true }).prettierConfig) instead of restating it locally."
@@ -13732,14 +13938,14 @@ var zodSchemaValidationRule = {
 };
 
 // eslint/ts-alignment.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import { join } from "path";
 var ownRequire = createRequire2(import.meta.url);
 var majorOf = (version) => Number(version.split(".")[0]);
 function versionOf(packagePath) {
   try {
-    const parsed = JSON.parse(readFileSync17(packagePath, "utf8"));
+    const parsed = JSON.parse(readFileSync18(packagePath, "utf8"));
     if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) return null;
     return typeof parsed.version === "string" ? parsed.version : null;
   } catch {