@geonosis/oxlint-plugin-biological-architecture 3.1.0 → 3.3.0

package/dist/rules/lib/styling.js

@@ -1,5 +1,7 @@
 // src/rules/lib/styling.ts
-var attributeNamed = (node, name) => node.attributes?.find((attribute) => attribute?.type === "JSXAttribute" && attribute.name?.type === "JSXIdentifier" && attribute.name.name === name);
+import { attributeNamed } from "./jsx.js";
+var isContainer = (node) => node.type === "JSXExpressionContainer";
+var isTemplate = (node) => node?.type === "TemplateLiteral";
 var classNameOf = (node) => {
   const value = attributeNamed(node, "className")?.value;
   if (value === undefined || value === null)
@@ -8,11 +10,19 @@ var classNameOf = (node) => {
     const literal = value.value;
     return typeof literal === "string" ? literal : undefined;
   }
-  if (value.type === "JSXExpressionContainer") {
+  if (isContainer(value))
     return expressionText(unwrap(value.expression));
-  }
   return;
 };
+var staticClassNameOf = (node) => {
+  const value = attributeNamed(node, "className")?.value;
+  if (value !== undefined && value !== null && isContainer(value)) {
+    const expression = unwrap(value.expression);
+    if (isTemplate(expression) && (expression.expressions ?? []).length > 0)
+      return;
+  }
+  return classNameOf(node);
+};
 var unwrap = (node) => {
   let current = node ?? null;
   while (current !== null && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "ParenthesizedExpression")) {
@@ -55,16 +65,29 @@ var styleEntriesOf = (node) => {
     return text === undefined ? [] : [{ property: name, value: text }];
   });
 };
-var styleProperties = (node) => {
+var styleObjectOf = (node) => {
   const value = attributeNamed(node, "style")?.value;
-  if (value?.type !== "JSXExpressionContainer")
-    return [];
+  if (value === undefined || value === null || !isContainer(value))
+    return null;
   const expression = unwrap(value.expression);
-  if (expression === null || expression.type !== "ObjectExpression")
-    return [];
-  return expression.properties ?? [];
+  return expression?.type === "ObjectExpression" ? expression : null;
+};
+var styleProperties = (node) => styleObjectOf(node)?.properties ?? [];
+var withoutVariants = (token) => {
+  let depth = 0;
+  let from = 0;
+  for (const [at, char] of [...token].entries()) {
+    if (char === "[")
+      depth += 1;
+    else if (char === "]")
+      depth -= 1;
+    else if (char === ":" && depth === 0)
+      from = at + 1;
+  }
+  return token.slice(from);
 };
-var arbitraryValuesOf = (className) => className.split(/\s+/).flatMap((token) => {
+var arbitraryValuesOf = (className) => className.split(/\s+/).flatMap((classToken) => {
+  const token = withoutVariants(classToken).replace(/^!|!$/g, "");
   const open = token.indexOf("[");
   const close = token.lastIndexOf("]");
   if (open <= 0 || close <= open)
@@ -84,7 +107,10 @@ var variableOf = (value) => /^var\(\s*(--[A-Za-z0-9_-]+)/.exec(value.trim())?.[1
 export {
   arbitraryValuesOf,
   classNameOf,
+  keyOf,
   localVariablesOf,
+  staticClassNameOf,
   styleEntriesOf,
+  styleObjectOf,
   variableOf
 };

package/dist/rules/lib/tiers.d.ts

@@ -1,31 +1,18 @@
-/**
- * The tiers, and the one path pattern every rule here tests a filename against.
- *
- * `(?:features/[^/]+/)?<tier>/` is a Medusa storefront's broader form, kept when the two forks were
- * merged: it reaches a flat kit (`packages/ui/src/tissues/…`) as well as a feature-sliced app, and
- * a rule that reaches more files is the stricter rule. The `(?:^|/)` anchor is this file's
- * addition, so `subtissues/` is not read as `tissues/`.
- */
 export declare const TIERS: readonly ['atoms', 'molecules', 'compounds', 'organelles', 'cells', 'tissues'];
 export type Tier = (typeof TIERS)[number];
+export declare const APP_FOLDER: RegExp;
+export declare const LAYOUTS_FOLDER: RegExp;
+export declare const STORES_FOLDER: RegExp;
+export declare const ABOVE_ATOMS_FOLDER: RegExp;
+export declare const ORGANS_FOLDER: RegExp;
+export declare const COMPONENT_FILE_PATTERN: RegExp;
+export declare const PRIVATE_SIBLING: RegExp;
+export declare const CELL_PRIVATE_SIBLING: RegExp;
 export declare const inTier: (filename: string, tier: Tier) => boolean;
-/** The tier a path sits in, or none. The layout gives a file one tier folder, so the first wins. */
+export declare const inOrgans: (filename: string) => boolean;
+export declare const folderOf: <Name extends string>(source: string, names: readonly Name[]) => Name | undefined;
+export declare const inTiersAbove: (filename: string, tier: Tier) => boolean;
 export declare const tierOf: (filename: string) => Tier | undefined;
-/**
- * The tier a file sits DIRECTLY in — the folder that is its own parent — or none.
- *
- * `tierOf` answers for anywhere in the path, which is what a rule about IMPORTS wants. A rule about
- * the file's own folder wants the parent and nothing else: `cells/parts/helper.ts` is in `parts/`,
- * and `subtissues/` is not `tissues/` however a regex written without an anchor read it (#5).
- */
 export declare const tierFolderOf: (filename: string) => Tier | undefined;
-/**
- * The feature a path belongs to, or none — a flat kit (`packages/ui/src/atoms/`) has tiers and no
- * features, and a rule that assumed otherwise simply never fired there.
- */
 export declare const featureOf: (filename: string) => string | undefined;
-/**
- * A `scope` naming something that is not a tier matches no file, which is the inert rule the
- * option refusal exists to stop — one option along. So it is a config error, and it stops the run.
- */
 export declare const requireTiers: (rule: string, names: readonly string[]) => Tier[];

package/dist/rules/lib/tiers.js

@@ -9,7 +9,35 @@ var PATTERNS = {
   organelles: /(?:^|\/)(?:features\/[^/]+\/)?organelles\//,
   tissues: /(?:^|\/)(?:features\/[^/]+\/)?tissues\//
 };
+var APP_FOLDER = /(?:^|\/)app\//;
+var LAYOUTS_FOLDER = /(?:^|\/)layouts\//;
+var STORES_FOLDER = /(?:^|\/)stores\//;
+var ABOVE_ATOMS_FOLDER = /(?:^|\/)(molecules|compounds|organelles|cells|layouts)\//;
+var ORGANS_FOLDER = /(?:^|\/)(?:features\/[^/]+\/)?organs\//;
+var COMPONENT_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?(compounds|organelles|cells|tissues|organs)\/.+\.tsx$/;
+var SHARED_PRIVATE_SUFFIXES = [
+  "parts",
+  "sections",
+  "summary",
+  "layouts",
+  "icons",
+  "types",
+  "sidebar",
+  "data",
+  "stories",
+  "spec",
+  "test"
+];
+var privateSiblingOf = (...own) => new RegExp(`\\.(?:${[...SHARED_PRIVATE_SUFFIXES, ...own].join("|")})\\.tsx$`);
+var PRIVATE_SIBLING = privateSiblingOf("hooks", "utils", "context", "store", "config");
+var CELL_PRIVATE_SIBLING = privateSiblingOf("form", "steps");
 var inTier = (filename, tier) => PATTERNS[tier].test(normalise(filename));
+var inOrgans = (filename) => ORGANS_FOLDER.test(normalise(filename));
+var folderOf = (source, names) => {
+  const listed = new Set(names);
+  return normalise(source).split("/").find((segment) => listed.has(segment));
+};
+var inTiersAbove = (filename, tier) => TIERS.slice(TIERS.indexOf(tier) + 1).some((above) => inTier(filename, above));
 var tierOf = (filename) => TIERS.find((tier) => inTier(filename, tier));
 var tierFolderOf = (filename) => {
   const parent = normalise(filename).split("/").at(-2);
@@ -17,15 +45,27 @@ var tierFolderOf = (filename) => {
 };
 var FEATURE = /(?:^|\/)features\/([^/]+)\//;
 var featureOf = (filename) => FEATURE.exec(normalise(filename))?.[1];
+var isTier = (name) => TIERS.some((tier) => tier === name);
 var requireTiers = (rule, names) => names.map((name) => {
-  if (TIERS.includes(name))
+  if (isTier(name))
     return name;
   throw new Error(`biological-architecture/${rule} is scoped to "${name}", which is not a tier, so that scope can never match a file. The tiers are ${TIERS.join(", ")}.`);
 });
 export {
+  ABOVE_ATOMS_FOLDER,
+  APP_FOLDER,
+  CELL_PRIVATE_SIBLING,
+  COMPONENT_FILE_PATTERN,
+  LAYOUTS_FOLDER,
+  ORGANS_FOLDER,
+  PRIVATE_SIBLING,
+  STORES_FOLDER,
   TIERS,
   featureOf,
+  folderOf,
+  inOrgans,
   inTier,
+  inTiersAbove,
   requireTiers,
   tierFolderOf,
   tierOf

package/dist/rules/lib/tissue-entrypoint.d.ts

@@ -1,4 +1,3 @@
-/** `filename`'s last segment, and whether it IS the tissue arrangement entrypoint. */
 export declare const tissueEntrypointOf: (filename: string) => {
     basename: string;
     isEntrypoint: boolean;

package/dist/rules/lib/tissue-entrypoint.js

@@ -1,13 +1,12 @@
 // src/rules/lib/tissue-entrypoint.ts
-import { normalise } from "./paths.js";
-var TISSUE_FILE_PATTERN = /(?:^|\/)(?:features\/[^/]+\/)?tissues\//;
-var PRIVATE_TISSUE_SIBLING = /\.(parts|sections|summary|layouts|icons|types|hooks|utils|context|store|sidebar|data|config|stories|spec|test)\.tsx$/;
+import { fileOf, normalise } from "./paths.js";
+import { inTier, PRIVATE_SIBLING } from "./tiers.js";
 var tissueEntrypointOf = (filename) => {
   const normalized = normalise(filename);
-  const basename = normalized.split("/").pop() || normalized;
+  const basename = fileOf(normalized);
   return {
     basename,
-    isEntrypoint: TISSUE_FILE_PATTERN.test(normalized) && basename.endsWith(".tsx") && basename !== "index.tsx" && !PRIVATE_TISSUE_SIBLING.test(basename)
+    isEntrypoint: inTier(normalized, "tissues") && basename.endsWith(".tsx") && basename !== "index.tsx" && !PRIVATE_SIBLING.test(basename)
   };
 };
 export {

package/dist/rules/lib/token-layer.d.ts

@@ -0,0 +1,19 @@
+import { type ModuleNode } from './imports.js';
+import type { AnyNode } from './nodes.js';
+export declare const THEMEKIT = "@geonosis/themekit";
+export declare const PALETTE_TAKERS: readonly string[];
+export declare const PALETTE_TYPES: readonly string[];
+export declare const tokenLayerOf: () => {
+    covers: (chain: readonly AnyNode[]) => boolean;
+    enclosing: () => AnyNode[];
+    resolve: () => void;
+    visitor: {
+        CallExpression(node: AnyNode): void;
+        ImportDeclaration(node: ModuleNode): void;
+        TSAsExpression(node: AnyNode): void;
+        TSSatisfiesExpression(node: AnyNode): void;
+        ObjectExpression(node: AnyNode): void;
+        'ObjectExpression:exit'(): void;
+        VariableDeclaration(node: AnyNode): void;
+    };
+};

package/dist/rules/lib/token-layer.js

@@ -0,0 +1,170 @@
+// src/rules/lib/token-layer.ts
+import { isTypeOnly, sourceOf } from "./imports.js";
+import { propertyNameOf } from "./nodes.js";
+import { withoutTypes } from "./objects.js";
+var THEMEKIT = "@geonosis/themekit";
+var PALETTE_TAKERS = [
+  "compile",
+  "defineTheme",
+  "emitVariables",
+  "toDtcg",
+  "valueAt"
+];
+var PALETTE_TYPES = [
+  "StatusPair",
+  "Theme",
+  "ThemeColors",
+  "ThemeFonts",
+  "ThemeMode",
+  "ThemeModes",
+  "ThemeRadii",
+  "ThemeShadows",
+  "ThemeStatusColors",
+  "TokenValue"
+];
+var isNode = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var childOf = (node, key) => {
+  const child = node?.[key];
+  return isNode(child) ? child : undefined;
+};
+var childrenOf = (node, key) => {
+  const children = node[key];
+  return Array.isArray(children) ? children.filter(isNode) : [];
+};
+var nameOf = (node) => typeof node?.name === "string" ? node.name : undefined;
+var tokenLayerOf = () => {
+  const takers = new Set;
+  const namespaces = new Set;
+  const typeLocals = new Set;
+  const typeNamespaces = new Set;
+  const typed = [];
+  const objects = new Set;
+  const passed = new Set;
+  const bindings = new Map;
+  const open = [];
+  const single = (name) => {
+    const binding = bindings.get(name);
+    return binding?.declarations === 1 ? binding.object : undefined;
+  };
+  const isPaletteType = (reference) => {
+    if (reference?.type !== "TSTypeReference")
+      return false;
+    const name = childOf(reference, "typeName");
+    if (name?.type === "Identifier")
+      return typeLocals.has(nameOf(name) ?? "");
+    if (name?.type !== "TSQualifiedName")
+      return false;
+    const namespace = nameOf(childOf(name, "left"));
+    const member = nameOf(childOf(name, "right"));
+    return namespace !== undefined && member !== undefined && typeNamespaces.has(namespace) && PALETTE_TYPES.includes(member);
+  };
+  const typedObject = (expression, reference) => {
+    const object = withoutTypes(expression);
+    if (object?.type === "ObjectExpression")
+      typed.push({ object, reference });
+  };
+  const takesPalette = (callee) => {
+    if (callee?.type === "Identifier")
+      return takers.has(nameOf(callee) ?? "");
+    if (callee?.type !== "MemberExpression")
+      return false;
+    const owner = nameOf(childOf(callee, "object"));
+    const name = propertyNameOf(callee);
+    return owner !== undefined && namespaces.has(owner) && name !== null && PALETTE_TAKERS.includes(name);
+  };
+  return {
+    covers: (chain) => chain.some((one) => objects.has(one)),
+    enclosing: () => [...open],
+    resolve: () => {
+      for (const one of typed) {
+        if (isPaletteType(one.reference))
+          objects.add(one.object);
+      }
+      const queue = [...objects];
+      for (const name of passed) {
+        const held = single(name);
+        if (held !== undefined && !objects.has(held)) {
+          objects.add(held);
+          queue.push(held);
+        }
+      }
+      for (const object of queue) {
+        for (const member of childrenOf(object, "properties")) {
+          const value = withoutTypes(member.type === "SpreadElement" ? member.argument : member.value);
+          const held = value?.type === "Identifier" ? single(nameOf(value) ?? "") : undefined;
+          if (held !== undefined && !objects.has(held)) {
+            objects.add(held);
+            queue.push(held);
+          }
+        }
+      }
+    },
+    visitor: {
+      CallExpression(node) {
+        if (!takesPalette(childOf(node, "callee")))
+          return;
+        const argument = withoutTypes(childrenOf(node, "arguments")[0]);
+        if (argument?.type === "ObjectExpression")
+          objects.add(argument);
+        else if (argument?.type === "Identifier")
+          passed.add(nameOf(argument) ?? "");
+      },
+      ImportDeclaration(node) {
+        if (sourceOf(node) !== THEMEKIT)
+          return;
+        for (const specifier of node.specifiers ?? []) {
+          const local = specifier.local?.name;
+          if (local === undefined)
+            continue;
+          const typeOnly = isTypeOnly(node) || specifier.importKind === "type";
+          if (specifier.type === "ImportNamespaceSpecifier") {
+            typeNamespaces.add(local);
+            if (!typeOnly)
+              namespaces.add(local);
+            continue;
+          }
+          const imported = specifier.imported?.name;
+          if (imported === undefined)
+            continue;
+          if (PALETTE_TYPES.includes(imported))
+            typeLocals.add(local);
+          if (!typeOnly && PALETTE_TAKERS.includes(imported))
+            takers.add(local);
+        }
+      },
+      TSAsExpression(node) {
+        typedObject(node.expression, childOf(node, "typeAnnotation"));
+      },
+      TSSatisfiesExpression(node) {
+        typedObject(node.expression, childOf(node, "typeAnnotation"));
+      },
+      ObjectExpression(node) {
+        open.push(node);
+      },
+      "ObjectExpression:exit"() {
+        open.pop();
+      },
+      VariableDeclaration(node) {
+        for (const declarator of childrenOf(node, "declarations")) {
+          const id = childOf(declarator, "id");
+          const name = nameOf(id);
+          if (id?.type !== "Identifier" || name === undefined)
+            continue;
+          typedObject(declarator.init, childOf(childOf(id, "typeAnnotation"), "typeAnnotation"));
+          const init = withoutTypes(declarator.init);
+          const held = node.kind === "const" && init?.type === "ObjectExpression" ? init : undefined;
+          bindings.set(name, {
+            declarations: (bindings.get(name)?.declarations ?? 0) + 1,
+            ...held === undefined ? {} : { object: held }
+          });
+        }
+      }
+    }
+  };
+};
+export {
+  PALETTE_TAKERS,
+  PALETTE_TYPES,
+  THEMEKIT,
+  tokenLayerOf
+};

package/dist/rules/lib/tsconfig-paths.d.ts

@@ -1,5 +1 @@
-/**
- * The places `paths` says a specifier may be, best match first — as bases without extensions,
- * for the caller to find the file at. Empty when no config maps it.
- */
 export declare const aliasCandidates: (importer: string, source: string) => string[];

package/dist/rules/lib/tsconfig-paths.js

@@ -1,7 +1,7 @@
 // src/rules/lib/tsconfig-paths.ts
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { parseLooseJson } from "./module-text.js";
+import { parseLooseJson, readManifest } from "./module-text.js";
 import { longestMatch } from "./pattern-match.js";
 var CHAIN = 5;
 var configs = new Map;
@@ -26,12 +26,7 @@ var baseFileOf = (dir, base) => {
     return;
   if (rest !== "")
     return withJson(join(packageDir, rest));
-  let declared;
-  try {
-    declared = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8")).tsconfig;
-  } catch {
-    declared = undefined;
-  }
+  const declared = readManifest(join(packageDir, "package.json"))?.tsconfig;
   return join(packageDir, typeof declared === "string" ? declared : "tsconfig.json");
 };
 var packageDirAbove = (dir, name) => {
@@ -77,19 +72,56 @@ var readConfig = (file) => {
   }
   return { anchor, paths };
 };
+var GLOB = /[*?{[]/;
+var strings = (value) => Array.isArray(value) ? value.filter((one) => typeof one === "string") : [];
+var referencePathsOf = (references) => (Array.isArray(references) ? references : []).flatMap((one) => {
+  if (typeof one !== "object" || one === null || !("path" in one))
+    return [];
+  return typeof one.path === "string" ? [one.path] : [];
+});
+var includedBy = (file) => {
+  const dir = dirname(file);
+  const entries = strings(rawOf(file)?.include);
+  return entries.length === 0 ? [dir] : entries.map((entry) => {
+    const segments = entry.split("/");
+    const globAt = segments.findIndex((one) => GLOB.test(one));
+    const head = globAt === -1 ? segments : segments.slice(0, globAt);
+    const last = head.at(-1);
+    const literal = last !== undefined && /\.[a-z]+$/.test(last) ? head.slice(0, -1) : head;
+    return resolve(dir, ...literal);
+  });
+};
+var isUnder = (dir, parent) => dir === parent || dir.startsWith(`${parent}/`);
+var referencedConfig = (file, dir) => {
+  const refs = rawOf(file)?.references;
+  for (const named of referencePathsOf(refs)) {
+    const target = resolve(dirname(file), named);
+    const config = CONFIG_FILES.map((name) => join(target, name)).find((one) => existsSync(one));
+    const project = config ?? (target.endsWith(".json") ? target : withJson(target));
+    if (!existsSync(project))
+      continue;
+    if (!includedBy(project).some((included) => isUnder(dir, included)))
+      continue;
+    const found = readConfig(project);
+    if (found !== null)
+      return found;
+  }
+  return null;
+};
 var CONFIG_FILES = ["tsconfig.json", "jsconfig.json"];
+var nearestConfigFile = (dir) => {
+  const file = CONFIG_FILES.map((name) => join(dir, name)).find((one) => existsSync(one));
+  if (file !== undefined)
+    return file;
+  const parent = dirname(dir);
+  return parent === dir ? undefined : nearestConfigFile(parent);
+};
 var configFor = (dir) => {
   const known = configs.get(dir);
   if (known !== undefined)
     return known;
-  let found = null;
-  const file = CONFIG_FILES.map((name) => join(dir, name)).find((one) => existsSync(one));
-  if (file !== undefined)
-    found = readConfig(file);
-  else {
-    const parent = dirname(dir);
-    found = parent === dir ? null : configFor(parent);
-  }
+  const file = nearestConfigFile(dir);
+  const found = file === undefined ? null : readConfig(file) ?? referencedConfig(file, dir);
   configs.set(dir, found);
   return found;
 };

package/dist/rules/lib/type-members.d.ts

@@ -0,0 +1,6 @@
+export interface TypeMember {
+    name: string;
+    type: string;
+}
+export declare const membersOfNamedType: (file: string, name: string) => TypeMember[] | undefined;
+export declare const callableOrUndeclared: (type: string) => 'handler' | 'undeclared' | undefined;

package/dist/rules/lib/type-members.js

@@ -0,0 +1,165 @@
+// src/rules/lib/type-members.ts
+import { readSource } from "./module-text.js";
+var DEPTH = 4;
+var OPENERS = new Set(["(", "[", "{", "<"]);
+var CLOSERS = new Set([")", "]", "}", ">"]);
+var QUOTES = new Set(['"', "'", "`"]);
+var nextOutside = (text, from) => {
+  const quote = text[from];
+  if (quote === undefined || !QUOTES.has(quote))
+    return from;
+  let at = from + 1;
+  while (at < text.length && text[at] !== quote)
+    at += text[at] === "\\" ? 2 : 1;
+  return at;
+};
+function* scan(text, from = 0) {
+  let depth = 0;
+  for (let at = from;at < text.length; at += 1) {
+    at = nextOutside(text, at);
+    const char = text[at] ?? "";
+    const closes = CLOSERS.has(char) && !(char === ">" && text[at - 1] === "=");
+    if (OPENERS.has(char))
+      depth += 1;
+    else if (closes)
+      depth -= 1;
+    yield { at, char, closes, depth };
+  }
+}
+var closesAt = (text, open) => {
+  for (const { at, closes, depth } of scan(text, open))
+    if (closes && depth === 0)
+      return at;
+  return -1;
+};
+var splitTop = (text, separators) => {
+  const parts = [];
+  let from = 0;
+  for (const { at, char, depth } of scan(text)) {
+    if (depth === 0 && separators.has(char)) {
+      parts.push(text.slice(from, at));
+      from = at + 1;
+    }
+  }
+  parts.push(text.slice(from));
+  return parts.map((one) => one.trim()).filter((one) => one !== "");
+};
+var CONTINUES_BEFORE = /(?:[|&:=,(<]|=>)\s*$/;
+var CONTINUES_AFTER = /^\s*[|&?:.=)]/;
+var membersText = (body) => {
+  const members = [];
+  let from = 0;
+  for (const { at, char, depth } of scan(body)) {
+    if (depth !== 0)
+      continue;
+    if (char === ";" || char === ",") {
+      members.push(body.slice(from, at));
+      from = at + 1;
+    } else if (char === `
+`) {
+      const current = body.slice(from, at);
+      if (current.trim() !== "" && !CONTINUES_BEFORE.test(current) && !CONTINUES_AFTER.test(body.slice(at + 1))) {
+        members.push(current);
+        from = at + 1;
+      }
+    }
+  }
+  members.push(body.slice(from));
+  return members.map((one) => one.trim()).filter((one) => one !== "");
+};
+var KEY = /^(?:readonly\s+)?(?:(["'])(.*?)\1|([A-Za-z_$][\w$]*))\s*\??\s*(?=[:(<])/;
+var memberOf = (text) => {
+  const key = KEY.exec(text);
+  if (key === null)
+    return;
+  const name = key[2] ?? key[3] ?? "";
+  const rest = text.slice(key[0].length).trim();
+  if (rest.startsWith(":"))
+    return { name, type: rest.slice(1).trim() };
+  const generics = rest.startsWith("<") ? closesAt(rest, 0) + 1 : 0;
+  const open = generics > 0 ? generics : 0;
+  if (rest[open] !== "(")
+    return;
+  const close = closesAt(rest, open);
+  if (close === -1)
+    return;
+  const returned = rest.slice(close + 1).replace(/^\s*:\s*/, "");
+  return { name, type: `${rest.slice(0, close + 1)} => ${returned === "" ? "void" : returned}` };
+};
+var parseMembers = (body) => membersText(body).flatMap((one) => memberOf(one) ?? []);
+var escaped = (name) => name.replaceAll("$", String.raw`\$`);
+var bodyAfter = (text, from) => {
+  const open = text.indexOf("{", from);
+  if (open === -1)
+    return;
+  const close = closesAt(text, open);
+  return close === -1 ? undefined : text.slice(open + 1, close);
+};
+var aliasText = (text, from) => {
+  let end = from;
+  for (const { at, char, depth } of scan(text, from)) {
+    if (depth === 0 && (char === ";" || char === `
+`)) {
+      const scanned = text.slice(from, at);
+      if (char === ";" || scanned.trim() !== "" && !CONTINUES_BEFORE.test(scanned) && !CONTINUES_AFTER.test(text.slice(at + 1))) {
+        end = at;
+        break;
+      }
+    }
+    end = at + 1;
+  }
+  return text.slice(from, end);
+};
+var IDENTIFIER_TYPE = /^([A-Za-z_$][\w$]*)(?:<.*>)?$/s;
+var membersIn = (text, name, depth) => {
+  if (depth > DEPTH)
+    return;
+  const interfaced = new RegExp(String.raw`\binterface\s+${escaped(name)}\b`).exec(text);
+  if (interfaced !== null) {
+    const body = bodyAfter(text, interfaced.index + interfaced[0].length);
+    return body === undefined ? undefined : parseMembers(body);
+  }
+  const aliased = new RegExp(String.raw`\btype\s+${escaped(name)}\b[^=]*=\s*`).exec(text);
+  if (aliased === null)
+    return;
+  const parts = splitTop(aliasText(text, aliased.index + aliased[0].length), new Set(["&"]));
+  const found = parts.flatMap((part) => {
+    if (part.startsWith("{") && closesAt(part, 0) === part.length - 1) {
+      return [parseMembers(part.slice(1, -1))];
+    }
+    const named = IDENTIFIER_TYPE.exec(part)?.[1];
+    const inner = named === undefined ? undefined : membersIn(text, named, depth + 1);
+    return inner === undefined ? [] : [inner];
+  });
+  return found.length === 0 ? undefined : found.flat();
+};
+var membersOfNamedType = (file, name) => {
+  const text = readSource(file);
+  return text === undefined ? undefined : membersIn(text, name, 0);
+};
+var STATE_REFERENCE = /^(?:React\.)?(?:Dispatch|SetStateAction)\b|^Function$/;
+var UNDECLARED = new Set(["any", "unknown", "object", "{}"]);
+var unwrapped = (type) => {
+  let current = type.trim();
+  while (current.startsWith("(") && closesAt(current, 0) === current.length - 1) {
+    current = current.slice(1, -1).trim();
+  }
+  return current;
+};
+var isFunctionType = (type) => {
+  const from = type.startsWith("<") ? closesAt(type, 0) + 1 : 0;
+  if (type[from] !== "(")
+    return false;
+  const close = closesAt(type, from);
+  return close !== -1 && /^\s*=>/.test(type.slice(close + 1));
+};
+var callableOrUndeclared = (type) => {
+  const alternatives = splitTop(unwrapped(type), new Set(["|"])).map(unwrapped);
+  if (alternatives.some((one) => isFunctionType(one) || STATE_REFERENCE.test(one)))
+    return "handler";
+  return alternatives.some((one) => UNDECLARED.has(one.replaceAll(/\s+/g, ""))) ? "undeclared" : undefined;
+};
+export {
+  callableOrUndeclared,
+  membersOfNamedType
+};