@openpkg-ts/doc-generator 0.1.0

package/dist/shared/chunk-7hg53zpt.js

@@ -0,0 +1,1160 @@
+import {
+  buildSignatureString,
+  formatParameters,
+  formatReturnType,
+  formatSchema,
+  getMethods,
+  getProperties,
+  sortByName
+} from "./chunk-taeg9090.js";
+
+// src/render/html.ts
+var defaultCSS = `
+:root {
+  --text: #1a1a1a;
+  --text-muted: #666;
+  --bg: #fff;
+  --bg-code: #f5f5f5;
+  --border: #e5e5e5;
+  --accent: #0066cc;
+  --font-mono: 'SF Mono', Monaco, 'Cascadia Code', monospace;
+  --font-sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --text: #e5e5e5;
+    --text-muted: #999;
+    --bg: #1a1a1a;
+    --bg-code: #2a2a2a;
+    --border: #333;
+    --accent: #4da6ff;
+  }
+}
+* { box-sizing: border-box; margin: 0; padding: 0; }
+body {
+  font-family: var(--font-sans);
+  line-height: 1.6;
+  color: var(--text);
+  background: var(--bg);
+  max-width: 900px;
+  margin: 0 auto;
+  padding: 2rem;
+}
+h1, h2, h3, h4 { margin-top: 2rem; margin-bottom: 1rem; }
+h1 { font-size: 2rem; border-bottom: 2px solid var(--border); padding-bottom: 0.5rem; }
+h2 { font-size: 1.5rem; color: var(--text-muted); }
+h3 { font-size: 1.1rem; }
+p { margin-bottom: 1rem; }
+code {
+  font-family: var(--font-mono);
+  background: var(--bg-code);
+  padding: 0.2em 0.4em;
+  border-radius: 4px;
+  font-size: 0.9em;
+}
+pre {
+  background: var(--bg-code);
+  padding: 1rem;
+  border-radius: 8px;
+  overflow-x: auto;
+  margin: 1rem 0;
+}
+pre code { background: none; padding: 0; }
+.signature { font-family: var(--font-mono); font-size: 0.95rem; }
+.deprecated { opacity: 0.6; }
+.deprecated::before { content: "[Deprecated] "; color: #cc6600; }
+.badge {
+  display: inline-block;
+  padding: 0.2em 0.5em;
+  font-size: 0.75rem;
+  border-radius: 4px;
+  background: var(--accent);
+  color: white;
+  margin-left: 0.5rem;
+}
+.param-table { width: 100%; border-collapse: collapse; margin: 1rem 0; }
+.param-table th, .param-table td {
+  text-align: left;
+  padding: 0.75rem;
+  border-bottom: 1px solid var(--border);
+}
+.param-table th { font-weight: 600; color: var(--text-muted); }
+.kind-section { margin-top: 3rem; }
+.export-card {
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 1.5rem;
+  margin: 1rem 0;
+}
+.export-card h3 { margin-top: 0; }
+a { color: var(--accent); text-decoration: none; }
+a:hover { text-decoration: underline; }
+nav { margin-bottom: 2rem; }
+nav ul { list-style: none; display: flex; flex-wrap: wrap; gap: 1rem; }
+nav a { padding: 0.5rem 1rem; background: var(--bg-code); border-radius: 4px; }
+`;
+function escapeHTML(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function renderSignature(exp) {
+  const sig = buildSignatureString(exp);
+  return `<pre class="signature"><code>${escapeHTML(sig)}</code></pre>`;
+}
+function renderParameters(sig) {
+  if (!sig?.parameters?.length)
+    return "";
+  const rows = sig.parameters.map((p) => {
+    const type = escapeHTML(formatSchema(p.schema));
+    const required = p.required !== false ? "required" : "optional";
+    const desc = p.description ? escapeHTML(p.description) : "-";
+    const rest = p.rest ? "..." : "";
+    return `
+        <tr>
+          <td><code>${rest}${escapeHTML(p.name)}</code></td>
+          <td><code>${type}</code></td>
+          <td>${required}</td>
+          <td>${desc}</td>
+        </tr>`;
+  }).join("");
+  return `
+    <h3>Parameters</h3>
+    <table class="param-table">
+      <thead>
+        <tr><th>Name</th><th>Type</th><th>Required</th><th>Description</th></tr>
+      </thead>
+      <tbody>${rows}</tbody>
+    </table>`;
+}
+function renderReturns(sig) {
+  if (!sig?.returns)
+    return "";
+  const type = escapeHTML(formatSchema(sig.returns.schema));
+  const desc = sig.returns.description ? `<p>${escapeHTML(sig.returns.description)}</p>` : "";
+  return `
+    <h3>Returns</h3>
+    <p><code>${type}</code></p>
+    ${desc}`;
+}
+function renderExamples(examples) {
+  if (!examples?.length)
+    return "";
+  const blocks = examples.map((ex) => {
+    if (typeof ex === "string") {
+      return `<pre><code>${escapeHTML(ex)}</code></pre>`;
+    }
+    const title = ex.title ? `<h4>${escapeHTML(ex.title)}</h4>` : "";
+    const desc = ex.description ? `<p>${escapeHTML(ex.description)}</p>` : "";
+    return `${title}${desc}<pre><code class="language-${ex.language || "ts"}">${escapeHTML(ex.code)}</code></pre>`;
+  }).join("");
+  return `<h3>Examples</h3>${blocks}`;
+}
+function renderProperties(members) {
+  const props = getProperties(members);
+  if (!props.length)
+    return "";
+  const rows = props.map((p) => {
+    const type = escapeHTML(formatSchema(p.schema));
+    const desc = p.description ? escapeHTML(p.description) : "-";
+    return `
+        <tr>
+          <td><code>${escapeHTML(p.name || "")}</code></td>
+          <td><code>${type}</code></td>
+          <td>${desc}</td>
+        </tr>`;
+  }).join("");
+  return `
+    <h3>Properties</h3>
+    <table class="param-table">
+      <thead><tr><th>Name</th><th>Type</th><th>Description</th></tr></thead>
+      <tbody>${rows}</tbody>
+    </table>`;
+}
+function renderMethods(members) {
+  const methods = getMethods(members);
+  if (!methods.length)
+    return "";
+  const items = methods.map((m) => {
+    const sig = m.signatures?.[0];
+    const params = escapeHTML(formatParameters(sig));
+    const returnType = escapeHTML(formatReturnType(sig));
+    const desc = m.description ? `<p>${escapeHTML(m.description)}</p>` : "";
+    return `
+        <div class="method">
+          <h4><code>${escapeHTML(m.name || "")}${params}: ${returnType}</code></h4>
+          ${desc}
+        </div>`;
+  }).join("");
+  return `<h3>Methods</h3>${items}`;
+}
+function renderEnumMembers(members) {
+  if (!members?.length)
+    return "";
+  const items = members.map((m) => {
+    const desc = m.description ? ` - ${escapeHTML(m.description)}` : "";
+    return `<li><code>${escapeHTML(m.name || "")}</code>${desc}</li>`;
+  }).join("");
+  return `<h3>Members</h3><ul>${items}</ul>`;
+}
+function renderExport(exp) {
+  const deprecated = exp.deprecated ? " deprecated" : "";
+  const badge = exp.deprecated ? '<span class="badge">Deprecated</span>' : "";
+  const desc = exp.description ? `<p>${escapeHTML(exp.description)}</p>` : "";
+  const primarySig = exp.signatures?.[0];
+  let content = "";
+  switch (exp.kind) {
+    case "function":
+      content = renderParameters(primarySig) + renderReturns(primarySig);
+      break;
+    case "class":
+    case "interface":
+      content = renderProperties(exp.members) + renderMethods(exp.members);
+      break;
+    case "enum":
+      content = renderEnumMembers(exp.members);
+      break;
+  }
+  content += renderExamples(exp.examples);
+  return `
+    <article class="export-card${deprecated}" id="${exp.id}">
+      <h3>${escapeHTML(exp.name)}${badge}</h3>
+      ${renderSignature(exp)}
+      ${desc}
+      ${content}
+    </article>`;
+}
+function toHTML(spec, options = {}) {
+  const { includeStyles = true, fullDocument = true, customCSS = "" } = options;
+  if (options.export) {
+    const exp = spec.exports.find((e) => e.name === options.export || e.id === options.export);
+    if (!exp) {
+      throw new Error(`Export not found: ${options.export}`);
+    }
+    const content2 = renderExport(exp);
+    if (!fullDocument)
+      return content2;
+    const title2 = options.title || `${exp.name} | ${spec.meta.name}`;
+    const styles2 = includeStyles ? `<style>${defaultCSS}${customCSS}</style>` : "";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHTML(title2)}</title>
+  ${styles2}
+  ${options.headContent || ""}
+</head>
+<body>
+  <main>
+    <h1>${escapeHTML(exp.name)}</h1>
+    ${content2}
+  </main>
+</body>
+</html>`;
+  }
+  const title = options.title || `${spec.meta.name} API Reference`;
+  const description = spec.meta.description ? `<p>${escapeHTML(spec.meta.description)}</p>` : "";
+  const byKind = {};
+  for (const exp of spec.exports) {
+    if (!byKind[exp.kind])
+      byKind[exp.kind] = [];
+    byKind[exp.kind].push(exp);
+  }
+  const navItems = Object.entries(byKind).map(([kind, exports]) => {
+    const links = exports.map((e) => `<a href="#${e.id}">${escapeHTML(e.name)}</a>`).join("");
+    return `<li><strong>${kind}s:</strong> ${links}</li>`;
+  }).join("");
+  const nav = `<nav><ul>${navItems}</ul></nav>`;
+  const kindOrder = ["function", "class", "interface", "type", "enum", "variable"];
+  const sections = kindOrder.filter((kind) => byKind[kind]?.length).map((kind) => {
+    const exports = byKind[kind].map(renderExport).join("");
+    return `
+        <section class="kind-section">
+          <h2>${kind.charAt(0).toUpperCase() + kind.slice(1)}s</h2>
+          ${exports}
+        </section>`;
+  }).join("");
+  const content = `
+    <header>
+      <h1>${escapeHTML(spec.meta.name)} API Reference</h1>
+      ${description}
+    </header>
+    ${nav}
+    ${sections}`;
+  if (!fullDocument)
+    return content;
+  const styles = includeStyles ? `<style>${defaultCSS}${customCSS}</style>` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHTML(title)}</title>
+  <meta name="description" content="${escapeHTML(spec.meta.description || "")}">
+  ${styles}
+  ${options.headContent || ""}
+</head>
+<body>
+  <main>
+    ${content}
+  </main>
+</body>
+</html>`;
+}
+
+// src/render/json.ts
+function simplifySignature(sig) {
+  if (!sig)
+    return;
+  return {
+    parameters: (sig.parameters || []).map((p) => ({
+      name: p.name,
+      type: formatSchema(p.schema),
+      required: p.required !== false,
+      description: p.description,
+      default: p.default,
+      rest: p.rest
+    })),
+    returns: sig.returns ? {
+      type: formatSchema(sig.returns.schema),
+      description: sig.returns.description
+    } : undefined,
+    description: sig.description,
+    typeParameters: sig.typeParameters?.map((tp) => `${tp.name}${tp.constraint ? ` extends ${tp.constraint}` : ""}`)
+  };
+}
+function simplifyMember(member) {
+  const isMethod = !!member.signatures?.length;
+  return {
+    name: member.name || "",
+    kind: isMethod ? "method" : "property",
+    type: isMethod ? undefined : formatSchema(member.schema),
+    description: member.description,
+    visibility: member.visibility || "public",
+    signature: isMethod ? simplifySignature(member.signatures?.[0]) : undefined
+  };
+}
+function simplifyExample(example) {
+  if (typeof example === "string") {
+    return { code: example, language: "ts" };
+  }
+  return {
+    code: example.code,
+    title: example.title,
+    description: example.description,
+    language: example.language || "ts"
+  };
+}
+function simplifyExport(exp) {
+  const primarySig = exp.signatures?.[0];
+  const simplified = {
+    id: exp.id,
+    name: exp.name,
+    kind: exp.kind,
+    signature: buildSignatureString(exp),
+    description: exp.description,
+    deprecated: exp.deprecated === true,
+    tags: (exp.tags || []).map((t) => ({ name: t.name, text: t.text })),
+    extends: exp.extends,
+    implements: exp.implements,
+    sourceFile: exp.source?.file,
+    sourceLine: exp.source?.line
+  };
+  switch (exp.kind) {
+    case "function":
+      if (primarySig) {
+        const sigData = simplifySignature(primarySig);
+        simplified.parameters = sigData?.parameters;
+        simplified.returns = sigData?.returns;
+      }
+      break;
+    case "class":
+    case "interface":
+      if (exp.members?.length) {
+        simplified.members = exp.members.map(simplifyMember);
+      }
+      break;
+    case "enum":
+      if (exp.members?.length) {
+        simplified.members = exp.members.map((m) => ({
+          name: m.name || "",
+          kind: "property",
+          description: m.description,
+          visibility: "public"
+        }));
+      }
+      break;
+  }
+  if (exp.examples?.length) {
+    simplified.examples = exp.examples.map(simplifyExample);
+  }
+  return simplified;
+}
+function toJSON(spec, options = {}) {
+  if (options.export) {
+    const exp = spec.exports.find((e) => e.name === options.export || e.id === options.export);
+    if (!exp) {
+      throw new Error(`Export not found: ${options.export}`);
+    }
+    return simplifyExport(exp);
+  }
+  const exports = spec.exports.map(simplifyExport);
+  const byKind = {};
+  for (const exp of exports) {
+    if (!byKind[exp.kind])
+      byKind[exp.kind] = [];
+    byKind[exp.kind].push(exp);
+  }
+  return {
+    name: spec.meta.name,
+    version: spec.meta.version,
+    description: spec.meta.description,
+    exports,
+    byKind,
+    totalExports: exports.length
+  };
+}
+function toJSONString(spec, options = {}) {
+  const data = toJSON(spec, options);
+  return options.pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+}
+
+// src/render/markdown.ts
+var defaultSections = {
+  signature: true,
+  description: true,
+  parameters: true,
+  returns: true,
+  examples: true,
+  members: true,
+  properties: true,
+  methods: true
+};
+function generateFrontmatter(exp, custom) {
+  const slug = exp.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  const meta = {
+    title: exp.name,
+    description: exp.description?.slice(0, 160) || `API reference for ${exp.name}`,
+    slug,
+    ...custom
+  };
+  const lines = ["---"];
+  for (const [key, value] of Object.entries(meta)) {
+    if (typeof value === "string") {
+      lines.push(`${key}: "${value.replace(/"/g, "\\\"")}"`);
+    } else if (typeof value === "boolean" || typeof value === "number") {
+      lines.push(`${key}: ${value}`);
+    } else if (Array.isArray(value)) {
+      lines.push(`${key}:`);
+      for (const item of value) {
+        lines.push(`  - ${item}`);
+      }
+    }
+  }
+  lines.push("---", "");
+  return lines.join(`
+`);
+}
+function heading(level, text, offset = 0) {
+  const actualLevel = Math.min(level + offset, 6);
+  return `${"#".repeat(actualLevel)} ${text}`;
+}
+function renderParameters2(sig, offset = 0) {
+  if (!sig?.parameters?.length)
+    return "";
+  const lines = [heading(2, "Parameters", offset), ""];
+  for (const param of sig.parameters) {
+    const type = formatSchema(param.schema);
+    const required = param.required !== false ? "" : "?";
+    const rest = param.rest ? "..." : "";
+    lines.push(`### \`${rest}${param.name}${required}\``);
+    lines.push("");
+    lines.push(`**Type:** \`${type}\``);
+    if (param.description) {
+      lines.push("");
+      lines.push(param.description);
+    }
+    if (param.default !== undefined) {
+      lines.push("");
+      lines.push(`**Default:** \`${JSON.stringify(param.default)}\``);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function renderReturns2(sig, offset = 0) {
+  if (!sig?.returns)
+    return "";
+  const lines = [heading(2, "Returns", offset), ""];
+  const type = formatSchema(sig.returns.schema);
+  lines.push(`**Type:** \`${type}\``);
+  if (sig.returns.description) {
+    lines.push("");
+    lines.push(sig.returns.description);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function renderExamples2(examples, offset = 0) {
+  if (!examples?.length)
+    return "";
+  const lines = [heading(2, "Examples", offset), ""];
+  for (const example of examples) {
+    if (typeof example === "string") {
+      lines.push("```ts");
+      lines.push(example);
+      lines.push("```");
+    } else {
+      if (example.title) {
+        lines.push(`### ${example.title}`);
+        lines.push("");
+      }
+      if (example.description) {
+        lines.push(example.description);
+        lines.push("");
+      }
+      lines.push(`\`\`\`${example.language || "ts"}`);
+      lines.push(example.code);
+      lines.push("```");
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function renderProperties2(members, offset = 0) {
+  const props = getProperties(members);
+  if (!props.length)
+    return "";
+  const lines = [heading(2, "Properties", offset), ""];
+  for (const prop of props) {
+    const type = formatSchema(prop.schema);
+    lines.push(`### \`${prop.name}\``);
+    lines.push("");
+    lines.push(`**Type:** \`${type}\``);
+    if (prop.description) {
+      lines.push("");
+      lines.push(prop.description);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function renderMethods2(members, offset = 0) {
+  const methods = getMethods(members);
+  if (!methods.length)
+    return "";
+  const lines = [heading(2, "Methods", offset), ""];
+  for (const method of methods) {
+    const sig = method.signatures?.[0];
+    const params = formatParameters(sig);
+    const returnType = formatReturnType(sig);
+    lines.push(`### \`${method.name}${params}: ${returnType}\``);
+    lines.push("");
+    if (method.description) {
+      lines.push(method.description);
+      lines.push("");
+    }
+    if (sig?.parameters?.length) {
+      lines.push("**Parameters:**");
+      lines.push("");
+      for (const param of sig.parameters) {
+        const paramType = formatSchema(param.schema);
+        const desc = param.description ? ` - ${param.description}` : "";
+        lines.push(`- \`${param.name}\`: \`${paramType}\`${desc}`);
+      }
+      lines.push("");
+    }
+    if (sig?.returns) {
+      const retType = formatSchema(sig.returns.schema);
+      const desc = sig.returns.description ? ` - ${sig.returns.description}` : "";
+      lines.push(`**Returns:** \`${retType}\`${desc}`);
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderEnumMembers2(members, offset = 0) {
+  if (!members?.length)
+    return "";
+  const lines = [heading(2, "Members", offset), ""];
+  for (const member of members) {
+    lines.push(`### \`${member.name}\``);
+    if (member.description) {
+      lines.push("");
+      lines.push(member.description);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function exportToMarkdown(exp, options = {}) {
+  const sections = { ...defaultSections, ...options.sections };
+  const offset = options.headingOffset ?? 0;
+  const parts = [];
+  if (options.frontmatter !== false) {
+    parts.push(generateFrontmatter(exp, options.customFrontmatter));
+  }
+  parts.push(heading(1, exp.name, offset));
+  parts.push("");
+  if (sections.signature) {
+    const sig = buildSignatureString(exp);
+    if (options.codeSignatures) {
+      parts.push("```ts");
+      parts.push(sig);
+      parts.push("```");
+    } else {
+      parts.push(`\`${sig}\``);
+    }
+    parts.push("");
+  }
+  if (sections.description && exp.description) {
+    parts.push(exp.description);
+    parts.push("");
+  }
+  if (exp.deprecated) {
+    parts.push("> **Deprecated**");
+    parts.push("");
+  }
+  const primarySig = exp.signatures?.[0];
+  switch (exp.kind) {
+    case "function":
+      if (sections.parameters)
+        parts.push(renderParameters2(primarySig, offset));
+      if (sections.returns)
+        parts.push(renderReturns2(primarySig, offset));
+      break;
+    case "class":
+    case "interface":
+      if (sections.properties)
+        parts.push(renderProperties2(exp.members, offset));
+      if (sections.methods)
+        parts.push(renderMethods2(exp.members, offset));
+      break;
+    case "enum":
+      if (sections.members)
+        parts.push(renderEnumMembers2(exp.members, offset));
+      break;
+    case "type":
+    case "variable":
+      break;
+  }
+  if (sections.examples) {
+    parts.push(renderExamples2(exp.examples, offset));
+  }
+  return `${parts.filter(Boolean).join(`
+`).trim()}
+`;
+}
+function toMarkdown(spec, options = {}) {
+  if (options.export) {
+    const exp = spec.exports.find((e) => e.name === options.export || e.id === options.export);
+    if (!exp) {
+      throw new Error(`Export not found: ${options.export}`);
+    }
+    return exportToMarkdown(exp, options);
+  }
+  const parts = [];
+  if (options.frontmatter !== false) {
+    const frontmatter = {
+      title: `${spec.meta.name} API Reference`,
+      description: spec.meta.description || `API documentation for ${spec.meta.name}`,
+      ...options.customFrontmatter || {}
+    };
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(frontmatter)) {
+      if (typeof value === "string") {
+        lines.push(`${key}: "${value.replace(/"/g, "\\\"")}"`);
+      } else {
+        lines.push(`${key}: ${JSON.stringify(value)}`);
+      }
+    }
+    lines.push("---", "");
+    parts.push(lines.join(`
+`));
+  }
+  parts.push(`# ${spec.meta.name} API Reference`);
+  parts.push("");
+  if (spec.meta.description) {
+    parts.push(spec.meta.description);
+    parts.push("");
+  }
+  const byKind = {};
+  for (const exp of spec.exports) {
+    if (!byKind[exp.kind])
+      byKind[exp.kind] = [];
+    byKind[exp.kind].push(exp);
+  }
+  const kindOrder = ["function", "class", "interface", "type", "enum", "variable"];
+  for (const kind of kindOrder) {
+    const exports = byKind[kind];
+    if (!exports?.length)
+      continue;
+    parts.push(`## ${kind.charAt(0).toUpperCase() + kind.slice(1)}s`);
+    parts.push("");
+    for (const exp of exports) {
+      const content = exportToMarkdown(exp, {
+        ...options,
+        frontmatter: false,
+        headingOffset: 1
+      });
+      parts.push(content);
+    }
+  }
+  return `${parts.join(`
+`).trim()}
+`;
+}
+
+// src/render/nav.ts
+var defaultKindLabels = {
+  function: "Functions",
+  class: "Classes",
+  interface: "Interfaces",
+  type: "Types",
+  enum: "Enums",
+  variable: "Variables",
+  namespace: "Namespaces",
+  module: "Modules",
+  reference: "References",
+  external: "External"
+};
+var defaultSlugify = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+function getModuleName(exp) {
+  if (exp.source?.file) {
+    const parts = exp.source.file.split("/");
+    const lastPart = parts[parts.length - 1];
+    if (lastPart === "index.ts" || lastPart === "index.tsx") {
+      return parts[parts.length - 2] || "core";
+    }
+    return lastPart.replace(/\.[jt]sx?$/, "");
+  }
+  return "core";
+}
+function getPrimaryTag(exp) {
+  const categoryTag = exp.tags?.find((t) => t.name === "category" || t.name === "@category");
+  if (categoryTag)
+    return categoryTag.text;
+  const moduleTag = exp.tags?.find((t) => t.name === "module" || t.name === "@module");
+  if (moduleTag)
+    return moduleTag.text;
+  return "Other";
+}
+function groupExports(exports, groupBy) {
+  const groups = new Map;
+  for (const exp of exports) {
+    let key;
+    switch (groupBy) {
+      case "kind":
+        key = exp.kind;
+        break;
+      case "module":
+        key = getModuleName(exp);
+        break;
+      case "tag":
+        key = getPrimaryTag(exp);
+        break;
+      default:
+        key = "all";
+    }
+    const existing = groups.get(key) ?? [];
+    existing.push(exp);
+    groups.set(key, existing);
+  }
+  return groups;
+}
+function toGenericNav(spec, options) {
+  const {
+    groupBy = "kind",
+    basePath = "/api",
+    slugify = defaultSlugify,
+    kindLabels = {},
+    sortAlphabetically = true,
+    includeGroupIndex = false
+  } = options;
+  const labels = { ...defaultKindLabels, ...kindLabels };
+  const grouped = groupExports(spec.exports, groupBy);
+  const groups = [];
+  for (const [key, exports] of grouped) {
+    const sortedExports = sortAlphabetically ? sortByName(exports) : exports;
+    const items = sortedExports.map((exp) => ({
+      title: exp.name,
+      href: `${basePath}/${slugify(exp.name)}`
+    }));
+    const title = groupBy === "kind" ? labels[key] || key : key;
+    groups.push({
+      title,
+      items,
+      index: includeGroupIndex ? `${basePath}/${slugify(key)}` : undefined
+    });
+  }
+  if (groupBy === "kind") {
+    const kindOrder = [
+      "function",
+      "class",
+      "interface",
+      "type",
+      "enum",
+      "variable",
+      "namespace",
+      "module",
+      "reference",
+      "external"
+    ];
+    groups.sort((a, b) => {
+      const aIdx = kindOrder.indexOf(a.title.toLowerCase().replace(/s$/, ""));
+      const bIdx = kindOrder.indexOf(b.title.toLowerCase().replace(/s$/, ""));
+      return aIdx - bIdx;
+    });
+  }
+  const flatItems = groupBy === "none" ? groups.flatMap((g) => g.items) : groups.map((g) => ({
+    title: g.title,
+    items: g.items
+  }));
+  return {
+    title: `${spec.meta.name} API`,
+    groups,
+    items: flatItems
+  };
+}
+function toFumadocsMeta(spec, options) {
+  const generic = toGenericNav(spec, options);
+  const { slugify = defaultSlugify } = options;
+  const pages = generic.groups.map((group) => ({
+    title: group.title,
+    pages: group.items.map((item) => slugify(item.title)),
+    defaultOpen: true
+  }));
+  return {
+    root: true,
+    title: generic.title,
+    pages
+  };
+}
+function toDocusaurusSidebar(spec, options) {
+  const generic = toGenericNav(spec, options);
+  const { slugify = defaultSlugify, basePath = "api" } = options;
+  const sidebar = generic.groups.map((group) => ({
+    type: "category",
+    label: group.title,
+    items: group.items.map((item) => ({
+      type: "doc",
+      id: `${basePath}/${slugify(item.title)}`,
+      label: item.title
+    }))
+  }));
+  return sidebar;
+}
+function toNavigation(spec, options = {}) {
+  const format = options.format ?? "generic";
+  switch (format) {
+    case "fumadocs":
+      return toFumadocsMeta(spec, options);
+    case "docusaurus":
+      return toDocusaurusSidebar(spec, options);
+    default:
+      return toGenericNav(spec, options);
+  }
+}
+function toFumadocsMetaJSON(spec, options = {}) {
+  const meta = toFumadocsMeta(spec, { ...options, format: "fumadocs" });
+  return JSON.stringify(meta, null, 2);
+}
+function toDocusaurusSidebarJS(spec, options = {}) {
+  const sidebar = toDocusaurusSidebar(spec, { ...options, format: "docusaurus" });
+  return `module.exports = ${JSON.stringify(sidebar, null, 2)};`;
+}
+
+// src/core/search.ts
+var defaultSlugify2 = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+function extractKeywords(exp, options = {}) {
+  const keywords = new Set;
+  keywords.add(exp.name);
+  keywords.add(exp.name.toLowerCase());
+  const camelParts = exp.name.split(/(?=[A-Z])/);
+  for (const part of camelParts) {
+    if (part.length > 2)
+      keywords.add(part.toLowerCase());
+  }
+  if (exp.tags) {
+    for (const tag of exp.tags) {
+      keywords.add(tag.name.replace("@", ""));
+      const tagWords = tag.text.split(/\s+/);
+      for (const word of tagWords) {
+        if (word.length > 2)
+          keywords.add(word.toLowerCase());
+      }
+    }
+  }
+  if (exp.description) {
+    const descWords = exp.description.toLowerCase().split(/\W+/).filter((w) => w.length > 2);
+    for (const word of descWords) {
+      keywords.add(word);
+    }
+  }
+  if (options.includeMembers && exp.members) {
+    for (const member of exp.members) {
+      if (member.name) {
+        keywords.add(member.name.toLowerCase());
+      }
+    }
+  }
+  if (options.includeParameters && exp.signatures) {
+    for (const sig of exp.signatures) {
+      for (const param of sig.parameters || []) {
+        keywords.add(param.name.toLowerCase());
+      }
+    }
+  }
+  return Array.from(keywords);
+}
+function buildContent(exp, options = {}) {
+  const parts = [];
+  parts.push(exp.name);
+  if (exp.description) {
+    parts.push(exp.description);
+  }
+  if (options.includeSignatures !== false) {
+    parts.push(buildSignatureString(exp));
+  }
+  if (exp.tags) {
+    parts.push(...exp.tags.map((t) => `${t.name} ${t.text}`));
+  }
+  if (options.includeMembers !== false && exp.members) {
+    const props = getProperties(exp.members);
+    const methods = getMethods(exp.members);
+    for (const prop of props) {
+      if (prop.name) {
+        parts.push(prop.name);
+        if (prop.description)
+          parts.push(prop.description);
+      }
+    }
+    for (const method of methods) {
+      if (method.name) {
+        parts.push(method.name);
+        if (method.description)
+          parts.push(method.description);
+      }
+    }
+  }
+  if (options.includeParameters !== false && exp.signatures) {
+    for (const sig of exp.signatures) {
+      for (const param of sig.parameters || []) {
+        parts.push(param.name);
+        if (param.description)
+          parts.push(param.description);
+      }
+    }
+  }
+  return parts.join(" ");
+}
+function createSearchRecord(exp, packageName, options = {}) {
+  const { baseUrl = "/api", slugify = defaultSlugify2 } = options;
+  return {
+    id: exp.id,
+    name: exp.name,
+    kind: exp.kind,
+    signature: buildSignatureString(exp),
+    description: exp.description,
+    content: buildContent(exp, options),
+    keywords: extractKeywords(exp, options),
+    url: `${baseUrl}/${slugify(exp.name)}`,
+    deprecated: exp.deprecated === true
+  };
+}
+function toSearchIndex(spec, options = {}) {
+  const records = spec.exports.map((exp) => createSearchRecord(exp, spec.meta.name, options));
+  return {
+    records,
+    version: spec.meta.version || "0.0.0",
+    generatedAt: new Date().toISOString(),
+    packageName: spec.meta.name
+  };
+}
+function toPagefindRecords(spec, options = {}) {
+  const { baseUrl = "/api", slugify = defaultSlugify2, weights = {} } = options;
+  const { name: nameWeight = 10, description: descWeight = 5, signature: sigWeight = 3 } = weights;
+  return spec.exports.map((exp) => {
+    const content = buildContent(exp, options);
+    const signature = buildSignatureString(exp);
+    const filters = {
+      kind: [exp.kind]
+    };
+    if (exp.deprecated) {
+      filters.deprecated = ["true"];
+    }
+    if (exp.tags?.length) {
+      filters.tags = exp.tags.map((t) => t.name.replace("@", ""));
+    }
+    return {
+      url: `${baseUrl}/${slugify(exp.name)}`,
+      content,
+      word_count: content.split(/\s+/).length,
+      filters,
+      meta: {
+        title: exp.name,
+        kind: exp.kind,
+        description: exp.description?.slice(0, 160),
+        signature
+      },
+      weighted_sections: [
+        { weight: nameWeight, text: exp.name },
+        ...exp.description ? [{ weight: descWeight, text: exp.description }] : [],
+        { weight: sigWeight, text: signature }
+      ]
+    };
+  });
+}
+function toAlgoliaRecords(spec, options = {}) {
+  const { baseUrl = "/api", slugify = defaultSlugify2 } = options;
+  return spec.exports.map((exp) => ({
+    objectID: exp.id,
+    name: exp.name,
+    kind: exp.kind,
+    description: exp.description,
+    signature: buildSignatureString(exp),
+    content: buildContent(exp, options),
+    tags: (exp.tags || []).map((t) => t.name.replace("@", "")),
+    deprecated: exp.deprecated === true,
+    url: `${baseUrl}/${slugify(exp.name)}`,
+    hierarchy: {
+      lvl0: spec.meta.name,
+      lvl1: `${exp.kind.charAt(0).toUpperCase() + exp.kind.slice(1)}s`,
+      lvl2: exp.name
+    }
+  }));
+}
+function toSearchIndexJSON(spec, options = {}) {
+  const index = toSearchIndex(spec, options);
+  return options.pretty ? JSON.stringify(index, null, 2) : JSON.stringify(index);
+}
+
+// src/core/loader.ts
+import * as fs from "node:fs";
+function loadSpec(spec) {
+  return createDocsInstance(spec);
+}
+function createDocs(input) {
+  const spec = typeof input === "string" ? JSON.parse(fs.readFileSync(input, "utf-8")) : input;
+  return createDocsInstance(spec);
+}
+function createDocsInstance(spec) {
+  const exportsById = new Map;
+  const typesById = new Map;
+  const exportsByTag = new Map;
+  const exportsByModule = new Map;
+  for (const exp of spec.exports) {
+    exportsById.set(exp.id, exp);
+    if (exp.tags) {
+      for (const tag of exp.tags) {
+        const tagKey = tag.name.startsWith("@") ? tag.name : `@${tag.name}`;
+        const existing = exportsByTag.get(tagKey) ?? [];
+        existing.push(exp);
+        exportsByTag.set(tagKey, existing);
+      }
+    }
+    const moduleName = extractModuleName(exp);
+    if (moduleName) {
+      const existing = exportsByModule.get(moduleName) ?? [];
+      existing.push(exp);
+      exportsByModule.set(moduleName, existing);
+    }
+  }
+  if (spec.types) {
+    for (const type of spec.types) {
+      typesById.set(type.id, type);
+    }
+  }
+  return {
+    spec,
+    getExport(id) {
+      return exportsById.get(id);
+    },
+    getType(id) {
+      return typesById.get(id);
+    },
+    getExportsByKind(kind) {
+      return spec.exports.filter((exp) => exp.kind === kind);
+    },
+    getAllExports() {
+      return spec.exports;
+    },
+    getAllTypes() {
+      return spec.types ?? [];
+    },
+    getExportsByTag(tagName) {
+      const normalizedTag = tagName.startsWith("@") ? tagName : `@${tagName}`;
+      return exportsByTag.get(normalizedTag) ?? [];
+    },
+    search(query) {
+      const lowerQuery = query.toLowerCase();
+      return spec.exports.filter((exp) => {
+        if (exp.name.toLowerCase().includes(lowerQuery))
+          return true;
+        if (exp.description?.toLowerCase().includes(lowerQuery))
+          return true;
+        if (exp.tags?.some((t) => t.text.toLowerCase().includes(lowerQuery)))
+          return true;
+        return false;
+      });
+    },
+    getModule(moduleName) {
+      return exportsByModule.get(moduleName) ?? [];
+    },
+    getDeprecated() {
+      return spec.exports.filter((exp) => exp.deprecated === true);
+    },
+    groupByKind() {
+      const groups = {};
+      for (const exp of spec.exports) {
+        if (!groups[exp.kind]) {
+          groups[exp.kind] = [];
+        }
+        groups[exp.kind].push(exp);
+      }
+      return groups;
+    },
+    toMarkdown(options) {
+      return toMarkdown(spec, options);
+    },
+    toHTML(options) {
+      return toHTML(spec, options);
+    },
+    toJSON(options) {
+      return toJSON(spec, options);
+    },
+    toNavigation(options) {
+      return toNavigation(spec, options);
+    },
+    toSearchIndex(options) {
+      return toSearchIndex(spec, options);
+    },
+    toPagefindRecords(options) {
+      return toPagefindRecords(spec, options);
+    },
+    toAlgoliaRecords(options) {
+      return toAlgoliaRecords(spec, options);
+    }
+  };
+}
+function extractModuleName(exp) {
+  if (exp.source?.file) {
+    const parts = exp.source.file.split("/");
+    const lastPart = parts[parts.length - 1];
+    if (lastPart === "index.ts" || lastPart === "index.tsx") {
+      return parts[parts.length - 2] || "root";
+    }
+    return lastPart.replace(/\.[jt]sx?$/, "");
+  }
+  if (exp.kind === "namespace" || exp.kind === "module") {
+    return exp.name;
+  }
+  return;
+}
+
+export { toHTML, toJSON, toJSONString, exportToMarkdown, toMarkdown, toNavigation, toFumadocsMetaJSON, toDocusaurusSidebarJS, toSearchIndex, toPagefindRecords, toAlgoliaRecords, toSearchIndexJSON, loadSpec, createDocs };