@mintlify/scraping 4.0.907 → 4.0.908

package/src/sdk/converters/sphinx.ts

@@ -0,0 +1,277 @@
+import fse from 'fs-extra';
+import type { Element, ElementContent, Root as HastRoot } from 'hast';
+import path from 'node:path';
+import { visit, SKIP } from 'unist-util-visit';
+
+import { htmlToHast } from '../../pipeline/root.js';
+import { turnChildrenIntoMdx } from '../../utils/children.js';
+import { removeHastComments } from '../../utils/hastComments.js';
+import { hastToMdx } from '../convert.js';
+import type { SdkNavGroup, SdkPage, SdkReference } from '../types.js';
+
+const SKIP_PAGES = new Set(['genindex', 'search', 'py-modindex']);
+const LANG_MARKER = '@@mintlang:';
+const FENCE_MARKER = /(`{3,})[^\S\n]*\n[> ]*@@mintlang:([\w+-]+)@@[^\S\n]*\n/g;
+const ADMONITION_TAGS: Record<string, string> = {
+  note: 'Note',
+  hint: 'Tip',
+  tip: 'Tip',
+  important: 'Info',
+  seealso: 'Info',
+  warning: 'Warning',
+  caution: 'Warning',
+  danger: 'Warning',
+  error: 'Warning',
+  attention: 'Warning',
+};
+
+type SphinxDoc = { slug: string; title: string; body: string; tag?: string };
+
+export async function convertSphinx(sourcePath: string): Promise<SdkReference> {
+  const docs = await loadDocs(sourcePath);
+  const slugs = new Set(docs.map((doc) => doc.slug));
+
+  const guides = docs
+    .filter((doc) => !doc.tag)
+    .sort((left, right) =>
+      left.slug === 'index' ? -1 : right.slug === 'index' ? 1 : left.slug.localeCompare(right.slug)
+    );
+  const modules = docs
+    .filter((doc) => doc.tag)
+    .sort((left, right) => left.slug.localeCompare(right.slug));
+
+  const pages = [...guides, ...modules].map((doc) => renderPage(doc, slugs));
+  const groups: SdkNavGroup[] = [];
+  if (guides.length) groups.push({ group: 'Getting Started', pages: guides.map((d) => d.slug) });
+  if (modules.length) groups.push({ group: 'API Reference', pages: modules.map((d) => d.slug) });
+
+  return { pages, groups };
+}
+
+async function loadDocs(sourcePath: string): Promise<SphinxDoc[]> {
+  const docs: SphinxDoc[] = [];
+  for (const file of await collectFjsonFiles(sourcePath)) {
+    const raw = (await fse.readJson(file)) as {
+      body?: string;
+      title?: string;
+      current_page_name?: string;
+    };
+    const slug =
+      raw.current_page_name ??
+      path
+        .relative(sourcePath, file)
+        .split(path.sep)
+        .join('/')
+        .replace(/\.fjson$/, '');
+    if (SKIP_PAGES.has(slug) || slug.startsWith('_modules')) continue;
+    if (!raw.body?.trim()) continue;
+    docs.push({
+      slug,
+      title: cleanTitle(raw.title ?? slug),
+      body: raw.body,
+      tag: /<dl class="py[ "]/.test(raw.body) ? 'MODULE' : undefined,
+    });
+  }
+  return docs;
+}
+
+async function collectFjsonFiles(dir: string): Promise<string[]> {
+  const files: string[] = [];
+  for (const entry of await fse.readdir(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith('_')) continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...(await collectFjsonFiles(fullPath)));
+    else if (entry.name.endsWith('.fjson')) files.push(fullPath);
+  }
+  return files.sort();
+}
+
+function renderPage(doc: SphinxDoc, slugs: Set<string>): SdkPage {
+  const hast = htmlToHast(doc.body);
+  removeHastComments(hast);
+  removeSphinxChrome(hast);
+  const description = extractDescription(hast);
+  rewriteLinks(hast, doc.slug, slugs);
+  transformAdmonitions(hast);
+  markHighlightLanguages(hast);
+  transformPyDls(hast, 0);
+  const content = hastToMdx(hast)
+    .replace(FENCE_MARKER, '$1$2\n')
+    .replace(/^[> ]*@@mintlang:[\w+-]+@@\n?/gm, '');
+  return {
+    slug: doc.slug,
+    title: doc.title,
+    description,
+    tag: doc.tag,
+    content,
+  };
+}
+
+function removeSphinxChrome(hast: HastRoot): void {
+  let removedH1 = false;
+  visit(hast, 'element', (node: Element, index, parent) => {
+    if (!parent || typeof index !== 'number') return;
+    const isHeaderlink = node.tagName === 'a' && classList(node).includes('headerlink');
+    const isViewcode =
+      node.tagName === 'a' &&
+      node.children.some(
+        (child) => child.type === 'element' && classList(child).includes('viewcode-link')
+      );
+    const isFirstH1 = node.tagName === 'h1' && !removedH1;
+    if (isFirstH1) removedH1 = true;
+    if (isHeaderlink || isViewcode || isFirstH1) {
+      parent.children.splice(index, 1);
+      return index;
+    }
+  });
+}
+
+function rewriteLinks(hast: HastRoot, fromSlug: string, slugs: Set<string>): void {
+  visit(hast, 'element', (node: Element) => {
+    if (node.tagName !== 'a' || typeof node.properties.href !== 'string') return;
+    const rewritten = rewriteHref(node.properties.href, fromSlug, slugs);
+    if (rewritten === undefined) delete node.properties.href;
+    else node.properties.href = rewritten;
+  });
+}
+
+function rewriteHref(href: string, fromSlug: string, slugs: Set<string>): string | undefined {
+  if (/^(https?:|mailto:|#)/.test(href)) return href;
+  const [target = ''] = href.split('#');
+  let resolved = path.posix
+    .normalize(path.posix.join(path.posix.dirname(fromSlug), target))
+    .replace(/\/$/, '')
+    .replace(/\.html?$/, '');
+  if (resolved === '.' || resolved === '') resolved = 'index';
+  return slugs.has(resolved) ? `/${resolved}` : undefined;
+}
+
+function transformAdmonitions(hast: HastRoot): void {
+  visit(hast, 'element', (node: Element) => {
+    if (node.tagName !== 'div' || !classList(node).includes('admonition')) return;
+    const type = classList(node).find((name) => name in ADMONITION_TAGS);
+    const children = node.children.filter(
+      (child) => !(child.type === 'element' && classList(child).includes('admonition-title'))
+    );
+    node.tagName = ADMONITION_TAGS[type ?? ''] ?? 'Note';
+    node.properties = {};
+    node.children = turnChildrenIntoMdx(children) as ElementContent[];
+    return SKIP;
+  });
+}
+
+function markHighlightLanguages(hast: HastRoot): void {
+  visit(hast, 'element', (node: Element) => {
+    const lang = classList(node)
+      .find((name) => name.startsWith('highlight-'))
+      ?.slice('highlight-'.length);
+    if (!lang || lang === 'default' || lang === 'none') return;
+    visit(node, 'element', (inner: Element) => {
+      if (inner.tagName !== 'pre') return;
+      inner.children.unshift({ type: 'text', value: `${LANG_MARKER}${lang}@@\n` });
+      return SKIP;
+    });
+    return SKIP;
+  });
+}
+
+function transformPyDls(node: HastRoot | Element, depth: number): void {
+  const children: ElementContent[] = [];
+  for (const child of node.children as ElementContent[]) {
+    if (child.type === 'element' && child.tagName === 'dl' && classList(child).includes('py')) {
+      children.push(...explodePyDl(child, depth));
+    } else {
+      if (child.type === 'element') transformPyDls(child, depth);
+      children.push(child);
+    }
+  }
+  node.children = children;
+}
+
+function explodePyDl(dl: Element, depth: number): ElementContent[] {
+  const callable = classList(dl).some((name) => ['method', 'function'].includes(name));
+  const out: ElementContent[] = [];
+  for (const child of dl.children) {
+    if (child.type !== 'element') continue;
+    if (child.tagName === 'dt' && classList(child).includes('sig')) {
+      const name = findDescName(child);
+      if (name) out.push(heading(Math.min(3 + depth, 6), callable ? `${name}()` : name));
+      out.push(pythonCodeBlock(textOf(child).replace(/\s+/g, ' ').trim()));
+    } else if (child.tagName === 'dd') {
+      transformPyDls(child, depth + 1);
+      out.push(...child.children);
+    }
+  }
+  return out;
+}
+
+function findDescName(node: Element): string | undefined {
+  let name: string | undefined;
+  visit(node, 'element', (inner: Element) => {
+    if (!classList(inner).includes('descname')) return;
+    name = textOf(inner).trim();
+    return SKIP;
+  });
+  return name;
+}
+
+function heading(level: number, text: string): Element {
+  return {
+    type: 'element',
+    tagName: `h${level}`,
+    properties: {},
+    children: [{ type: 'text', value: text }],
+  };
+}
+
+function pythonCodeBlock(code: string): Element {
+  return {
+    type: 'element',
+    tagName: 'pre',
+    properties: {},
+    children: [{ type: 'text', value: `${LANG_MARKER}python@@\n${code}` }],
+  };
+}
+
+function extractDescription(hast: HastRoot): string | undefined {
+  let description: string | undefined;
+  visit(hast, 'element', (node: Element, _index, parent) => {
+    if (description || node.tagName !== 'p') return;
+    if (parent && parent.type === 'element' && parent.tagName === 'li') return SKIP;
+    const text = textOf(node).replace(/\s+/g, ' ').trim();
+    if (!text || text.startsWith('Bases:')) return;
+    const sentence = text.split(/(?<=\.)\s/)[0] ?? text;
+    description = sentence.length > 160 ? `${sentence.slice(0, 159)}…` : sentence;
+  });
+  return description;
+}
+
+function textOf(node: ElementContent): string {
+  if (node.type === 'text') return node.value;
+  if ('children' in node) return node.children.map(textOf).join('');
+  return '';
+}
+
+function classList(node: Element): string[] {
+  const value = node.properties.className;
+  return Array.isArray(value)
+    ? value.map(String)
+    : typeof value === 'string'
+      ? value.split(' ')
+      : [];
+}
+
+function cleanTitle(title: string): string {
+  return title
+    .replace(/<[^>]+>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#(\d+);/g, (_, code: string) => {
+      const codePoint = Number(code);
+      return codePoint <= 0x10ffff ? String.fromCodePoint(codePoint) : `&#${code};`;
+    })
+    .replace(/\s+/g, ' ')
+    .trim();
+}

package/src/sdk/converters/typedoc.ts

@@ -0,0 +1,423 @@
+import fse from 'fs-extra';
+import path from 'node:path';
+
+import { markdownToMdx } from '../convert.js';
+import type { SdkNavGroup, SdkPage, SdkReference } from '../types.js';
+
+const KIND = {
+  project: 1,
+  module: 2,
+  namespace: 4,
+  enum: 8,
+  enumMember: 16,
+  variable: 32,
+  function: 64,
+  class: 128,
+  interface: 256,
+  constructor: 512,
+  property: 1024,
+  method: 2048,
+  callSignature: 4096,
+  indexSignature: 8192,
+  constructorSignature: 16384,
+  parameter: 32768,
+  typeLiteral: 65536,
+  accessor: 262144,
+  getSignature: 524288,
+  setSignature: 1048576,
+  typeAlias: 2097152,
+} as const;
+
+type CommentPart = { kind: string; text: string; target?: number | string };
+type Comment = { summary?: CommentPart[]; blockTags?: { tag: string; content: CommentPart[] }[] };
+type TypedocType = {
+  type?: string;
+  name?: string;
+  value?: unknown;
+  types?: TypedocType[];
+  elementType?: TypedocType;
+  typeArguments?: TypedocType[];
+  target?: number | TypedocType;
+  declaration?: TypedocNode;
+  elements?: TypedocType[];
+  checkType?: TypedocType;
+  extendsType?: TypedocType;
+  trueType?: TypedocType;
+  falseType?: TypedocType;
+  operator?: string;
+  indexType?: TypedocType;
+  objectType?: TypedocType;
+  qualifiedName?: string;
+  head?: string;
+  tail?: [TypedocType, string][];
+};
+type TypedocNode = {
+  id: number;
+  name: string;
+  kind: number;
+  comment?: Comment;
+  children?: TypedocNode[];
+  signatures?: TypedocNode[];
+  parameters?: TypedocNode[];
+  type?: TypedocType;
+  flags?: { isOptional?: boolean; isStatic?: boolean; isReadonly?: boolean; isPrivate?: boolean };
+  defaultValue?: string;
+  getSignature?: TypedocNode;
+  setSignature?: TypedocNode;
+  extendedTypes?: TypedocType[];
+  implementedTypes?: TypedocType[];
+  inheritedFrom?: { name: string };
+};
+
+const SECTIONS: { kind: number; group: string; dir: string; tag: string }[] = [
+  { kind: KIND.class, group: 'Classes', dir: 'classes', tag: 'CLASS' },
+  { kind: KIND.interface, group: 'Interfaces', dir: 'interfaces', tag: 'INTERFACE' },
+  { kind: KIND.enum, group: 'Enumerations', dir: 'enums', tag: 'ENUM' },
+  { kind: KIND.function, group: 'Functions', dir: 'functions', tag: 'FUNCTION' },
+  { kind: KIND.typeAlias, group: 'Type Aliases', dir: 'types', tag: 'TYPE' },
+  { kind: KIND.variable, group: 'Variables', dir: 'variables', tag: 'VARIABLE' },
+];
+
+export async function convertTypedoc(sourcePath: string): Promise<SdkReference> {
+  const project = (await fse.readJson(sourcePath)) as TypedocNode;
+  const modules =
+    project.children?.some((child) => child.kind === KIND.module) === true
+      ? (project.children?.filter((child) => child.kind === KIND.module) ?? [])
+      : [project];
+  const multiModule = modules.length > 1;
+
+  const slugById = new Map<number, string>();
+  for (const module of modules) {
+    const prefix = multiModule ? slugify(module.name) : '';
+    for (const { node, namespacePath } of collectDeclarations(module)) {
+      const section = SECTIONS.find((entry) => entry.kind === node.kind);
+      if (!section) continue;
+      slugById.set(
+        node.id,
+        path.posix.join(prefix, ...namespacePath.map(slugify), section.dir, slugify(node.name))
+      );
+    }
+  }
+
+  const renderer = new TypedocRenderer(slugById);
+  const pages: SdkPage[] = [];
+  const groups: SdkNavGroup[] = [];
+
+  for (const module of modules) {
+    const prefix = multiModule ? `${module.name} ` : '';
+    const declarations = collectDeclarations(module);
+    for (const section of SECTIONS) {
+      const entries = declarations
+        .filter(({ node }) => node.kind === section.kind && !node.flags?.isPrivate)
+        .sort((left, right) => qualifiedName(left).localeCompare(qualifiedName(right)));
+      if (entries.length === 0) continue;
+      const sectionPages = entries.map((entry) =>
+        renderer.renderPage(entry.node, section, qualifiedName(entry))
+      );
+      pages.push(...sectionPages);
+      groups.push({ group: `${prefix}${section.group}`, pages: sectionPages.map((p) => p.slug) });
+    }
+  }
+
+  return { pages, groups };
+}
+
+type Declaration = { node: TypedocNode; namespacePath: string[] };
+
+function qualifiedName({ node, namespacePath }: Declaration): string {
+  return [...namespacePath, node.name].join('.');
+}
+
+function collectDeclarations(container: TypedocNode, namespacePath: string[] = []): Declaration[] {
+  const declarations: Declaration[] = [];
+  for (const child of container.children ?? []) {
+    if (child.kind === KIND.namespace) {
+      declarations.push(...collectDeclarations(child, [...namespacePath, child.name]));
+    } else {
+      declarations.push({ node: child, namespacePath });
+    }
+  }
+  return declarations;
+}
+
+function slugify(name: string): string {
+  return name.replace(/[^a-zA-Z0-9-_.]+/g, '-').replace(/^-+|-+$/g, '') || 'item';
+}
+
+class TypedocRenderer {
+  constructor(private slugById: Map<number, string>) {}
+
+  renderPage(node: TypedocNode, section: { dir: string; tag: string }, title?: string): SdkPage {
+    const slug = this.slugById.get(node.id) ?? path.posix.join(section.dir, slugify(node.name));
+    const lines: string[] = [];
+    const summary = this.comment(node.comment);
+    if (summary) lines.push(summary);
+
+    switch (node.kind) {
+      case KIND.class:
+      case KIND.interface:
+        lines.push(...this.renderClassLike(node));
+        break;
+      case KIND.enum:
+        lines.push(...this.renderEnum(node));
+        break;
+      case KIND.function:
+        lines.push(...this.renderSignatures(node, 2));
+        break;
+      case KIND.typeAlias:
+      case KIND.variable:
+        lines.push(
+          this.codeBlock(
+            `${node.kind === KIND.variable ? 'const' : 'type'} ${node.name}${node.kind === KIND.typeAlias ? ' =' : ':'} ${this.type(node.type)}`
+          )
+        );
+        break;
+    }
+
+    return {
+      slug,
+      title: title ?? node.name,
+      description: this.firstSentence(node.comment),
+      tag: section.tag,
+      content: lines.filter(Boolean).join('\n\n'),
+    };
+  }
+
+  private renderClassLike(node: TypedocNode): string[] {
+    const lines: string[] = [];
+    const heritage = [
+      ...(node.extendedTypes?.length
+        ? [`extends ${node.extendedTypes.map((t) => this.type(t)).join(', ')}`]
+        : []),
+      ...(node.implementedTypes?.length
+        ? [`implements ${node.implementedTypes.map((t) => this.type(t)).join(', ')}`]
+        : []),
+    ];
+    if (heritage.length) {
+      lines.push(
+        this.codeBlock(
+          `${node.kind === KIND.class ? 'class' : 'interface'} ${node.name} ${heritage.join(' ')}`
+        )
+      );
+    }
+
+    const members = (node.children ?? []).filter((child) => !child.flags?.isPrivate);
+    const constructors = members.filter((child) => child.kind === KIND.constructor);
+    const properties = members
+      .filter((child) => child.kind === KIND.property || child.kind === KIND.accessor)
+      .sort((left, right) => left.name.localeCompare(right.name));
+    const methods = members
+      .filter((child) => child.kind === KIND.method)
+      .sort((left, right) => left.name.localeCompare(right.name));
+
+    for (const ctor of constructors) {
+      lines.push('## Constructor');
+      lines.push(...this.renderSignatures(ctor, 3));
+    }
+
+    if (properties.length) {
+      lines.push('## Properties');
+      for (const property of properties) {
+        const type = property.kind === KIND.accessor ? property.getSignature?.type : property.type;
+        const optional = property.flags?.isOptional === true;
+        lines.push(
+          this.responseField(
+            property.name,
+            this.type(type),
+            optional,
+            this.comment(property.comment ?? property.getSignature?.comment)
+          )
+        );
+      }
+    }
+
+    if (methods.length) {
+      lines.push('## Methods');
+      for (const method of methods) {
+        lines.push(`### ${method.name}()`);
+        lines.push(...this.renderSignatures(method, 4));
+      }
+    }
+
+    return lines;
+  }
+
+  private renderEnum(node: TypedocNode): string[] {
+    const lines: string[] = ['## Members'];
+    for (const member of node.children ?? []) {
+      lines.push(
+        this.responseField(
+          member.name,
+          member.type?.type === 'literal' ? JSON.stringify(member.type.value) : '',
+          false,
+          this.comment(member.comment)
+        )
+      );
+    }
+    return lines;
+  }
+
+  private renderSignatures(node: TypedocNode, depth: number): string[] {
+    const lines: string[] = [];
+    for (const signature of node.signatures ?? []) {
+      const params = (signature.parameters ?? [])
+        .map(
+          (param) =>
+            `${param.name}${param.flags?.isOptional || param.defaultValue !== undefined ? '?' : ''}: ${this.type(param.type)}`
+        )
+        .join(', ');
+      lines.push(this.codeBlock(`${signature.name}(${params}): ${this.type(signature.type)}`));
+      const comment = this.comment(signature.comment);
+      if (comment) lines.push(comment);
+      if (signature.parameters?.length) {
+        lines.push(`${'#'.repeat(depth)} Parameters`);
+        for (const param of signature.parameters) {
+          lines.push(
+            this.responseField(
+              param.name,
+              this.type(param.type),
+              param.flags?.isOptional === true || param.defaultValue !== undefined,
+              this.comment(param.comment)
+            )
+          );
+        }
+      }
+      const returns = signature.comment?.blockTags?.find((tag) => tag.tag === '@returns');
+      const returnType = this.type(signature.type);
+      if (returnType && returnType !== 'void') {
+        lines.push(`${'#'.repeat(depth)} Returns`);
+        lines.push(
+          `\`${escapeInlineCode(returnType)}\`${returns ? `\n\n${this.parts(returns.content)}` : ''}`
+        );
+      }
+    }
+    return lines;
+  }
+
+  private responseField(name: string, type: string, optional: boolean, body?: string): string {
+    const typeAttr = type ? ` type=${this.jsxString(truncate(type, 80))}` : '';
+    const requiredAttr = optional ? '' : ' required';
+    return `<ResponseField name=${this.jsxString(name)}${typeAttr}${requiredAttr}>\n${indent(body || '')}\n</ResponseField>`;
+  }
+
+  private jsxString(value: string): string {
+    return `{${JSON.stringify(value)}}`;
+  }
+
+  private codeBlock(code: string): string {
+    return `\`\`\`typescript\n${code}\n\`\`\``;
+  }
+
+  private comment(comment?: Comment): string {
+    if (!comment?.summary?.length) return '';
+    const markdown = this.parts(comment.summary);
+    const deprecated = comment.blockTags?.find((tag) => tag.tag === '@deprecated');
+    const example = comment.blockTags?.find((tag) => tag.tag === '@example');
+    const chunks = [markdown];
+    if (deprecated)
+      chunks.push(
+        `<Warning>Deprecated${deprecated.content.length ? `: ${this.parts(deprecated.content)}` : ''}</Warning>`
+      );
+    if (example) chunks.push(this.parts(example.content));
+    return chunks.filter(Boolean).join('\n\n');
+  }
+
+  private parts(parts: CommentPart[]): string {
+    const markdown = parts
+      .map((part) => {
+        if (part.kind === 'inline-tag') {
+          if (typeof part.target === 'number' && this.slugById.has(part.target)) {
+            return `[${part.text}](/${this.slugById.get(part.target)})`;
+          }
+          if (typeof part.target === 'string') return `[${part.text}](${part.target})`;
+          return `\`${part.text}\``;
+        }
+        return part.text;
+      })
+      .join('');
+    return markdownToMdx(markdown);
+  }
+
+  private firstSentence(comment?: Comment): string | undefined {
+    if (!comment?.summary?.length) return undefined;
+    const text = comment.summary
+      .filter((part) => part.kind === 'text')
+      .map((part) => part.text)
+      .join('')
+      .replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')
+      .replace(/[`*_]/g, '')
+      .replace(/\s+/g, ' ')
+      .trim();
+    if (!text) return undefined;
+    const sentence = text.split(/(?<=\.)\s/)[0] ?? text;
+    return truncate(sentence, 160);
+  }
+
+  type(type?: TypedocType): string {
+    if (!type) return 'void';
+    switch (type.type) {
+      case 'intrinsic':
+        return type.name ?? 'unknown';
+      case 'reference': {
+        const args = type.typeArguments?.length
+          ? `<${type.typeArguments.map((arg) => this.type(arg)).join(', ')}>`
+          : '';
+        return `${type.name ?? 'unknown'}${args}`;
+      }
+      case 'union':
+        return (type.types ?? []).map((entry) => this.type(entry)).join(' | ');
+      case 'intersection':
+        return (type.types ?? []).map((entry) => this.type(entry)).join(' & ');
+      case 'array':
+        return `${this.type(type.elementType)}[]`;
+      case 'literal':
+        return JSON.stringify(type.value);
+      case 'tuple':
+        return `[${(type.elements ?? []).map((entry) => this.type(entry)).join(', ')}]`;
+      case 'reflection':
+        return this.reflection(type.declaration);
+      case 'typeOperator':
+        return `${type.operator} ${this.type(type.target as TypedocType)}`;
+      case 'indexedAccess':
+        return `${this.type(type.objectType)}[${this.type(type.indexType)}]`;
+      case 'conditional':
+        return `${this.type(type.checkType)} extends ${this.type(type.extendsType)} ? ${this.type(type.trueType)} : ${this.type(type.falseType)}`;
+      case 'query':
+        return `typeof ${this.type(type.target as TypedocType)}`;
+      case 'templateLiteral':
+        return 'string';
+      default:
+        return type.name ?? 'unknown';
+    }
+  }
+
+  private reflection(declaration?: TypedocNode): string {
+    if (!declaration) return 'object';
+    if (declaration.signatures?.length) {
+      const signature = declaration.signatures[0]!;
+      const params = (signature.parameters ?? [])
+        .map((param) => `${param.name}: ${this.type(param.type)}`)
+        .join(', ');
+      return `(${params}) => ${this.type(signature.type)}`;
+    }
+    if (declaration.children?.length) {
+      return `{ ${declaration.children.map((child) => `${child.name}: ${this.type(child.type)}`).join('; ')} }`;
+    }
+    return 'object';
+  }
+}
+
+function indent(text: string): string {
+  return text
+    .split('\n')
+    .map((line) => (line ? `  ${line}` : line))
+    .join('\n');
+}
+
+function truncate(text: string, max: number): string {
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function escapeInlineCode(text: string): string {
+  return text.replace(/`/g, '');
+}