@bfra.me/doc-sync 0.1.0

package/lib/chunk-G5KKGJYO.js

@@ -0,0 +1,1560 @@
+import {
+  SENTINEL_MARKERS
+} from "./chunk-ROLA7SBB.js";
+
+// src/generators/api-reference-generator.ts
+function generateAPIReference(api) {
+  const sections = [];
+  if (api.functions.length > 0) {
+    sections.push("### Functions");
+    sections.push("");
+    sections.push(generateFunctionsTable(api.functions));
+    sections.push("");
+    sections.push(generateFunctionDetails(api.functions));
+  }
+  if (api.types.length > 0) {
+    sections.push("### Types");
+    sections.push("");
+    sections.push(generateTypesTable(api.types));
+    sections.push("");
+    sections.push(generateTypeDetails(api.types));
+  }
+  return sections.join("\n");
+}
+function generateFunctionsTable(functions) {
+  const lines = [];
+  lines.push("| Function | Description |");
+  lines.push("| -------- | ----------- |");
+  for (const fn of functions) {
+    const name = formatFunctionName(fn);
+    const description = fn.jsdoc?.description ?? "";
+    const firstLine = getFirstLine(description);
+    lines.push(`| ${name} | ${escapeTableCell(firstLine)} |`);
+  }
+  return lines.join("\n");
+}
+function generateFunctionDetails(functions) {
+  const sections = [];
+  for (const fn of functions) {
+    sections.push(generateFunctionDetail(fn));
+  }
+  return sections.join("\n\n");
+}
+function generateFunctionDetail(fn) {
+  const lines = [];
+  lines.push(`#### \`${fn.name}\``);
+  lines.push("");
+  if (fn.jsdoc?.description !== void 0) {
+    lines.push(fn.jsdoc.description);
+    lines.push("");
+  }
+  lines.push("```typescript");
+  lines.push(fn.signature);
+  lines.push("```");
+  if (fn.parameters.length > 0) {
+    lines.push("");
+    lines.push("**Parameters:**");
+    lines.push("");
+    lines.push("| Name | Type | Description |");
+    lines.push("| ---- | ---- | ----------- |");
+    for (const param of fn.parameters) {
+      const paramDoc = fn.jsdoc?.params?.find((p) => p.name === param.name);
+      const description = paramDoc?.description ?? "";
+      const optional = param.optional ? " (optional)" : "";
+      lines.push(
+        `| \`${param.name}\`${optional} | \`${escapeCode(param.type)}\` | ${escapeTableCell(description)} |`
+      );
+    }
+  }
+  if (fn.returnType !== "void") {
+    lines.push("");
+    lines.push(`**Returns:** \`${escapeCode(fn.returnType)}\``);
+    if (fn.jsdoc?.returns !== void 0) {
+      lines.push("");
+      lines.push(fn.jsdoc.returns);
+    }
+  }
+  if (fn.jsdoc?.deprecated !== void 0) {
+    lines.push("");
+    lines.push(`:::caution[Deprecated]`);
+    lines.push(fn.jsdoc.deprecated);
+    lines.push(":::");
+  }
+  if (fn.jsdoc?.since !== void 0) {
+    lines.push("");
+    lines.push(`*Since: ${fn.jsdoc.since}*`);
+  }
+  return lines.join("\n");
+}
+function generateTypesTable(types) {
+  const lines = [];
+  lines.push("| Type | Kind | Description |");
+  lines.push("| ---- | ---- | ----------- |");
+  for (const type of types) {
+    const name = `[\`${type.name}\`](#${type.name.toLowerCase()})`;
+    const kind = type.kind;
+    const description = type.jsdoc?.description ?? "";
+    const firstLine = getFirstLine(description);
+    lines.push(`| ${name} | ${kind} | ${escapeTableCell(firstLine)} |`);
+  }
+  return lines.join("\n");
+}
+function generateTypeDetails(types) {
+  const sections = [];
+  for (const type of types) {
+    sections.push(generateTypeDetail(type));
+  }
+  return sections.join("\n\n");
+}
+function generateTypeDetail(type) {
+  const lines = [];
+  lines.push(`#### \`${type.name}\``);
+  lines.push("");
+  if (type.jsdoc?.description !== void 0) {
+    lines.push(type.jsdoc.description);
+    lines.push("");
+  }
+  lines.push("```typescript");
+  lines.push(type.definition);
+  lines.push("```");
+  if (type.typeParameters !== void 0 && type.typeParameters.length > 0) {
+    lines.push("");
+    lines.push(`**Type Parameters:** ${type.typeParameters.map((t) => `\`${t}\``).join(", ")}`);
+  }
+  if (type.jsdoc?.deprecated !== void 0) {
+    lines.push("");
+    lines.push(`:::caution[Deprecated]`);
+    lines.push(type.jsdoc.deprecated);
+    lines.push(":::");
+  }
+  if (type.jsdoc?.since !== void 0) {
+    lines.push("");
+    lines.push(`*Since: ${type.jsdoc.since}*`);
+  }
+  return lines.join("\n");
+}
+function formatFunctionName(fn) {
+  const name = `[\`${fn.name}\`](#${fn.name.toLowerCase()})`;
+  const badges = [];
+  if (fn.isAsync) {
+    badges.push('<Badge text="async" variant="note" size="small" />');
+  }
+  if (fn.isGenerator) {
+    badges.push('<Badge text="generator" variant="tip" size="small" />');
+  }
+  if (fn.isDefault) {
+    badges.push('<Badge text="default" variant="caution" size="small" />');
+  }
+  return badges.length > 0 ? `${name} ${badges.join(" ")}` : name;
+}
+function getFirstLine(text) {
+  const firstLine = text.split("\n")[0]?.trim() ?? "";
+  if (firstLine.length > 100) {
+    const truncated = firstLine.slice(0, 97);
+    const lastSpace = truncated.lastIndexOf(" ");
+    if (lastSpace > 50) {
+      return `${truncated.slice(0, lastSpace)}...`;
+    }
+    return `${truncated}...`;
+  }
+  return firstLine;
+}
+function escapeTableCell(content) {
+  return content.replaceAll("|", String.raw`\|`).replaceAll("\n", " ");
+}
+function escapeCode(code) {
+  return code.replaceAll("`", "\\`");
+}
+function generateAPICompact(api) {
+  const lines = [];
+  if (api.functions.length > 0) {
+    lines.push("**Functions:**");
+    for (const fn of api.functions) {
+      lines.push(`- \`${fn.name}(${formatParameterList(fn)})\` \u2192 \`${fn.returnType}\``);
+    }
+  }
+  if (api.types.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push("**Types:**");
+    for (const type of api.types) {
+      lines.push(`- \`${type.name}\` (${type.kind})`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatParameterList(fn) {
+  return fn.parameters.map((p) => p.optional ? `${p.name}?` : p.name).join(", ");
+}
+function generateCategoryReference(functions, types, categoryName) {
+  const sections = [];
+  sections.push(`### ${categoryName}`);
+  sections.push("");
+  if (functions.length > 0) {
+    sections.push("#### Functions");
+    sections.push("");
+    sections.push(generateFunctionsTable(functions));
+    sections.push("");
+    sections.push(generateFunctionDetails(functions));
+  }
+  if (types.length > 0) {
+    sections.push("#### Types");
+    sections.push("");
+    sections.push(generateTypesTable(types));
+    sections.push("");
+    sections.push(generateTypeDetails(types));
+  }
+  return sections.join("\n");
+}
+
+// src/generators/code-example-formatter.ts
+var DEFAULT_OPTIONS = {
+  defaultLanguage: "typescript",
+  includeTitle: true,
+  maxExamplesPerFunction: 3,
+  collapsible: false
+};
+function formatCodeExamples(api, options = {}) {
+  const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+  const examples = [];
+  for (const fn of api.functions) {
+    const fnExamples = formatFunctionExamples(fn, mergedOptions);
+    if (fnExamples.length > 0) {
+      examples.push(fnExamples);
+    }
+  }
+  for (const type of api.types) {
+    const typeExamples = formatTypeExamples(type, mergedOptions);
+    if (typeExamples.length > 0) {
+      examples.push(typeExamples);
+    }
+  }
+  return examples.join("\n\n");
+}
+function formatFunctionExamples(fn, options = {}) {
+  const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+  if (fn.jsdoc?.examples === void 0 || fn.jsdoc.examples.length === 0) {
+    return "";
+  }
+  const exampleCount = Math.min(fn.jsdoc.examples.length, mergedOptions.maxExamplesPerFunction);
+  const examples = fn.jsdoc.examples.slice(0, exampleCount);
+  const sections = [];
+  if (mergedOptions.includeTitle) {
+    sections.push(`### ${fn.name}`);
+    sections.push("");
+  }
+  for (const [index, example] of examples.entries()) {
+    const formattedExample = formatCodeBlock(example, mergedOptions.defaultLanguage);
+    if (mergedOptions.collapsible && examples.length > 1) {
+      sections.push(`<details>`);
+      sections.push(`<summary>Example ${index + 1}</summary>`);
+      sections.push("");
+      sections.push(formattedExample);
+      sections.push("");
+      sections.push(`</details>`);
+    } else {
+      sections.push(formattedExample);
+    }
+    if (index < examples.length - 1) {
+      sections.push("");
+    }
+  }
+  return sections.join("\n");
+}
+function formatTypeExamples(type, options = {}) {
+  const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+  if (type.jsdoc?.examples === void 0 || type.jsdoc.examples.length === 0) {
+    return "";
+  }
+  const exampleCount = Math.min(type.jsdoc.examples.length, mergedOptions.maxExamplesPerFunction);
+  const examples = type.jsdoc.examples.slice(0, exampleCount);
+  const sections = [];
+  if (mergedOptions.includeTitle) {
+    sections.push(`### ${type.name}`);
+    sections.push("");
+  }
+  for (const [index, example] of examples.entries()) {
+    const formattedExample = formatCodeBlock(example, mergedOptions.defaultLanguage);
+    if (mergedOptions.collapsible && examples.length > 1) {
+      sections.push(`<details>`);
+      sections.push(`<summary>Example ${index + 1}</summary>`);
+      sections.push("");
+      sections.push(formattedExample);
+      sections.push("");
+      sections.push(`</details>`);
+    } else {
+      sections.push(formattedExample);
+    }
+    if (index < examples.length - 1) {
+      sections.push("");
+    }
+  }
+  return sections.join("\n");
+}
+function formatCodeBlock(code, language = "typescript") {
+  const cleanedCode = cleanCodeExample(code);
+  const detectedLanguage = detectLanguage(cleanedCode) ?? language;
+  return `\`\`\`${detectedLanguage}
+${cleanedCode}
+\`\`\``;
+}
+function cleanCodeExample(code) {
+  let cleaned = code.trim();
+  if (cleaned.startsWith("```")) {
+    const lines2 = cleaned.split("\n");
+    lines2.shift();
+    if (lines2.at(-1)?.trim() === "```") {
+      lines2.pop();
+    }
+    cleaned = lines2.join("\n");
+  }
+  cleaned = cleaned.split("\n").map((line) => {
+    if (line.startsWith(" * ")) {
+      return line.slice(3);
+    }
+    if (line.startsWith("* ")) {
+      return line.slice(2);
+    }
+    return line;
+  }).join("\n");
+  const lines = cleaned.split("\n");
+  const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
+  if (nonEmptyLines.length === 0) {
+    return cleaned;
+  }
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => {
+      const match = /^(\s*)/.exec(line);
+      return match?.[1]?.length ?? 0;
+    })
+  );
+  if (minIndent > 0) {
+    cleaned = lines.map((line) => line.slice(minIndent)).join("\n");
+  }
+  return cleaned.trim();
+}
+function detectLanguage(code) {
+  if (code.includes("import ") || code.includes("export ") || code.includes(": ")) {
+    if (code.includes("<") && code.includes("/>")) {
+      return "tsx";
+    }
+    return "typescript";
+  }
+  if (code.includes("const ") || code.includes("let ") || code.includes("function ")) {
+    if (code.includes("<") && code.includes("/>")) {
+      return "jsx";
+    }
+    return "javascript";
+  }
+  if (code.startsWith("{") || code.startsWith("[")) {
+    return "json";
+  }
+  if (code.includes("$ ") || code.includes("npm ") || code.includes("pnpm ")) {
+    return "bash";
+  }
+  return void 0;
+}
+function formatUsageExample(fn) {
+  const params = fn.parameters.map((p) => {
+    if (p.optional && p.defaultValue !== void 0) {
+      return `${p.name} = ${p.defaultValue}`;
+    }
+    if (p.optional) {
+      return `${p.name}?`;
+    }
+    return p.name;
+  });
+  const call = `${fn.name}(${params.join(", ")})`;
+  if (fn.isAsync) {
+    return `const result = await ${call}`;
+  }
+  if (fn.returnType !== "void") {
+    return `const result = ${call}`;
+  }
+  return call;
+}
+function groupExamplesByCategory(api) {
+  const categories = /* @__PURE__ */ new Map();
+  for (const fn of api.functions) {
+    if (fn.jsdoc?.examples === void 0 || fn.jsdoc.examples.length === 0) {
+      continue;
+    }
+    const category = inferCategory(fn.name);
+    const existing = categories.get(category) ?? { functions: [], types: [] };
+    existing.functions.push(fn);
+    categories.set(category, existing);
+  }
+  for (const type of api.types) {
+    if (type.jsdoc?.examples === void 0 || type.jsdoc.examples.length === 0) {
+      continue;
+    }
+    const category = inferCategory(type.name);
+    const existing = categories.get(category) ?? { functions: [], types: [] };
+    existing.types.push(type);
+    categories.set(category, existing);
+  }
+  return categories;
+}
+function inferCategory(name) {
+  const prefixes = ["create", "get", "set", "is", "has", "parse", "format", "validate", "build"];
+  for (const prefix of prefixes) {
+    if (name.toLowerCase().startsWith(prefix)) {
+      return capitalizeFirst(prefix);
+    }
+  }
+  return "General";
+}
+function capitalizeFirst(str) {
+  if (str.length === 0) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatGroupedExamples(api, options = {}) {
+  const categories = groupExamplesByCategory(api);
+  const sections = [];
+  for (const [category, items] of categories) {
+    sections.push(`### ${category}`);
+    sections.push("");
+    for (const fn of items.functions) {
+      const examples = formatFunctionExamples(fn, { ...options, includeTitle: false });
+      if (examples.length > 0) {
+        sections.push(`#### \`${fn.name}\``);
+        sections.push("");
+        sections.push(examples);
+        sections.push("");
+      }
+    }
+    for (const type of items.types) {
+      const examples = formatTypeExamples(type, { ...options, includeTitle: false });
+      if (examples.length > 0) {
+        sections.push(`#### \`${type.name}\``);
+        sections.push("");
+        sections.push(examples);
+        sections.push("");
+      }
+    }
+  }
+  return sections.join("\n").trim();
+}
+
+// src/utils/sanitization.ts
+import { sanitizeInput } from "@bfra.me/es/validation";
+import escapeHtml from "escape-html";
+function sanitizeForMDX(content) {
+  const escaped = sanitizeInput(content, { trim: false });
+  return escaped.replaceAll("{", "&#123;").replaceAll("}", "&#125;");
+}
+function sanitizeAttribute(value) {
+  return escapeHtml(value);
+}
+function parseJSXAttributes(tag) {
+  const attrs = [];
+  const spaceIndex = tag.indexOf(" ");
+  if (spaceIndex === -1) return attrs;
+  const closeIndex = tag.lastIndexOf(">");
+  if (closeIndex === -1) return attrs;
+  const attrRegion = tag.slice(spaceIndex + 1, closeIndex).trim();
+  let i = 0;
+  while (i < attrRegion.length) {
+    while (i < attrRegion.length && /\s/.test(attrRegion.charAt(i))) i++;
+    if (i >= attrRegion.length) break;
+    let name = "";
+    while (i < attrRegion.length && /[\w-]/.test(attrRegion.charAt(i))) {
+      name += attrRegion[i];
+      i++;
+    }
+    if (!name) break;
+    while (i < attrRegion.length && /\s/.test(attrRegion.charAt(i))) i++;
+    if (i >= attrRegion.length || attrRegion[i] !== "=") {
+      attrs.push({ name, value: null });
+      continue;
+    }
+    i++;
+    while (i < attrRegion.length && /\s/.test(attrRegion.charAt(i))) i++;
+    if (i >= attrRegion.length) {
+      attrs.push({ name, value: "" });
+      break;
+    }
+    let value = "";
+    const quote = attrRegion[i];
+    if (quote === '"' || quote === "'") {
+      i++;
+      while (i < attrRegion.length && attrRegion[i] !== quote) {
+        value += attrRegion[i];
+        i++;
+      }
+      if (i < attrRegion.length) i++;
+    } else {
+      while (i < attrRegion.length && !/[\s/>]/.test(attrRegion.charAt(i))) {
+        value += attrRegion[i];
+        i++;
+      }
+    }
+    attrs.push({ name, value });
+  }
+  return attrs;
+}
+function sanitizeJSXTag(tag) {
+  const tagMatch = tag.match(/^<([A-Z][a-zA-Z0-9]*)/);
+  if (!tagMatch || typeof tagMatch[1] !== "string" || tagMatch[1].length === 0) {
+    return escapeHtml(tag);
+  }
+  const tagName = tagMatch[1];
+  const selfClosing = tag.endsWith("/>");
+  const attributes = parseJSXAttributes(tag);
+  const sanitizedAttrs = attributes.map(({ name, value }) => {
+    if (value === null) return name;
+    const escaped = escapeHtml(value);
+    return `${name}="${escaped}"`;
+  });
+  const attrString = sanitizedAttrs.length > 0 ? ` ${sanitizedAttrs.join(" ")}` : "";
+  return `<${tagName}${attrString}${selfClosing ? " />" : ">"}`;
+}
+
+// src/generators/component-mapper.ts
+var DEFAULT_CONFIG = {
+  featureSections: ["features", "highlights", "key features"],
+  tabSections: ["installation", "getting started", "setup"],
+  excludeSections: ["license", "contributing", "contributors", "changelog"]
+};
+function mapToStarlightComponents(readme, packageInfo, config = {}) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const sections = [];
+  if (readme.preamble !== void 0 && readme.preamble.trim().length > 0) {
+    sections.push(readme.preamble);
+    sections.push("");
+  }
+  for (const section of readme.sections) {
+    const output = mapSection(section, packageInfo, mergedConfig);
+    if (output.length > 0) {
+      sections.push(output);
+      sections.push("");
+    }
+  }
+  return sections.join("\n").trim();
+}
+function mapSection(section, packageInfo, config) {
+  const normalizedHeading = section.heading.toLowerCase().trim();
+  if (isExcludedSection(normalizedHeading, config.excludeSections, packageInfo)) {
+    return "";
+  }
+  if (config.customMappings?.[normalizedHeading] !== void 0) {
+    return config.customMappings[normalizedHeading](section, packageInfo);
+  }
+  if (isFeatureSection(normalizedHeading, config.featureSections)) {
+    return mapFeatureSection(section);
+  }
+  if (isInstallationSection(normalizedHeading, config.tabSections)) {
+    return mapInstallationSection(section, packageInfo);
+  }
+  return mapDefaultSection(section, packageInfo, config);
+}
+function isExcludedSection(heading, excludeSections, packageInfo) {
+  if (excludeSections.some((excluded) => heading.includes(excluded.toLowerCase()))) {
+    return true;
+  }
+  if (packageInfo.docsConfig?.excludeSections !== void 0) {
+    return packageInfo.docsConfig.excludeSections.some(
+      (excluded) => heading.includes(excluded.toLowerCase())
+    );
+  }
+  return false;
+}
+function isFeatureSection(heading, featureSections) {
+  return featureSections.some((feature) => heading.includes(feature.toLowerCase()));
+}
+function isInstallationSection(heading, tabSections) {
+  return tabSections.some((tab) => heading.includes(tab.toLowerCase()));
+}
+function mapFeatureSection(section) {
+  const lines = [];
+  lines.push(`## ${section.heading}`);
+  lines.push("");
+  const features = extractFeatureItems(section.content);
+  if (features.length > 0) {
+    lines.push("<CardGrid>");
+    for (const feature of features) {
+      const icon = inferFeatureIcon(feature.title, feature.emoji);
+      lines.push(`  <Card title="${sanitizeAttribute(feature.title)}" icon="${icon}">`);
+      lines.push(`    ${feature.description}`);
+      lines.push("  </Card>");
+    }
+    lines.push("</CardGrid>");
+  } else {
+    lines.push(section.content);
+  }
+  return lines.join("\n");
+}
+var EMOJI_TO_ICON_MAP = {
+  "\u{1F4DD}": "document",
+  "\u{1F4D6}": "document",
+  "\u{1F504}": "seti:refresh",
+  "\u{1F441}\uFE0F": "eye-open",
+  "\u2728": "star",
+  "\u{1F6E1}\uFE0F": "shield",
+  "\u{1F3A8}": "seti:settings",
+  "\u{1F512}": "lock"
+};
+function extractFeatureItems(content) {
+  const features = [];
+  const boldListPattern = /^[-*] ([^*\r\n]*)\*\*([^*\r\n]+)\*\* ?[:—–-] ?([^\r\n]+)$/gm;
+  for (const match of content.matchAll(boldListPattern)) {
+    if (match[2] !== void 0 && match[3] !== void 0) {
+      const prefix = match[1] ?? "";
+      const emoji = extractEmoji(prefix);
+      features.push({
+        title: match[2].trim(),
+        description: match[3].trim(),
+        emoji
+      });
+    }
+  }
+  if (features.length === 0) {
+    const dashSeparatedPattern = /^[-*] ([^—–\n]+)[—–] (.+)$/gm;
+    for (const match of content.matchAll(dashSeparatedPattern)) {
+      if (match[1] !== void 0 && match[2] !== void 0) {
+        const rawTitle = match[1].trim();
+        const description = match[2].trim();
+        const emoji = extractEmoji(rawTitle);
+        const title = rawTitle.replace(
+          /^[\p{Emoji_Presentation}\p{Extended_Pictographic}]+\s*/u,
+          ""
+        );
+        if (title.length > 0 && description.length > 0 && description.length < 300) {
+          features.push({ title, description, emoji });
+        }
+      }
+    }
+  }
+  if (features.length === 0) {
+    const boldPattern = /\*\*([^*]+)\*\*/g;
+    const boldMatches = [...content.matchAll(boldPattern)];
+    for (const match of boldMatches) {
+      if (match[1] !== void 0) {
+        const title = match[1].trim();
+        const afterMatch = content.slice((match.index ?? 0) + match[0].length);
+        const description = afterMatch.split(/\n\n|\*\*/)[0]?.trim() ?? "";
+        if (description.length > 0 && description.length < 200) {
+          features.push({ title, description });
+        }
+      }
+    }
+  }
+  return features;
+}
+function extractEmoji(text) {
+  const emojiMatch = text.match(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}]+/u);
+  return emojiMatch?.[0];
+}
+function inferFeatureIcon(title, emoji) {
+  if (emoji !== void 0 && EMOJI_TO_ICON_MAP[emoji] !== void 0) {
+    return EMOJI_TO_ICON_MAP[emoji];
+  }
+  const lowerTitle = title.toLowerCase();
+  const keywordIconMap = {
+    typescript: "approve-check",
+    type: "approve-check",
+    test: "approve-check",
+    fast: "rocket",
+    speed: "rocket",
+    performance: "rocket",
+    tree: "seti:plan",
+    modular: "puzzle",
+    plugin: "puzzle",
+    extensible: "puzzle",
+    document: "document",
+    doc: "document",
+    config: "setting",
+    setting: "setting",
+    star: "star",
+    feature: "star",
+    safe: "approve-check",
+    secure: "approve-check",
+    error: "warning",
+    async: "rocket",
+    result: "approve-check",
+    function: "puzzle",
+    watch: "eye-open",
+    incremental: "seti:refresh",
+    preservation: "shield",
+    mdx: "document",
+    parsing: "document"
+  };
+  for (const [keyword, icon] of Object.entries(keywordIconMap)) {
+    if (lowerTitle.includes(keyword)) {
+      return icon;
+    }
+  }
+  return "star";
+}
+function mapInstallationSection(section, packageInfo) {
+  const lines = [];
+  lines.push(`## ${section.heading}`);
+  lines.push("");
+  const hasPnpm = /\bpnpm\b/.test(section.content);
+  const hasNpm = /\bnpm\b/.test(section.content);
+  const hasYarn = /\byarn\b/.test(section.content);
+  const packageManagerCount = [hasPnpm, hasNpm, hasYarn].filter(Boolean).length;
+  const hasExistingTabs = section.content.includes("```bash");
+  const hasMultiplePackageManagers = packageManagerCount >= 2;
+  if (hasExistingTabs && hasMultiplePackageManagers) {
+    lines.push(section.content);
+  } else {
+    lines.push(generateInstallTabs(packageInfo.name));
+    const contentWithoutInstall = removeInstallCommand(section.content);
+    if (contentWithoutInstall.trim().length > 0) {
+      lines.push("");
+      lines.push(contentWithoutInstall);
+    }
+  }
+  return lines.join("\n");
+}
+function generateInstallTabs(packageName) {
+  return `<Tabs>
+  <TabItem label="pnpm">
+    \`\`\`bash
+    pnpm add ${packageName}
+    \`\`\`
+  </TabItem>
+  <TabItem label="npm">
+    \`\`\`bash
+    npm install ${packageName}
+    \`\`\`
+  </TabItem>
+  <TabItem label="yarn">
+    \`\`\`bash
+    yarn add ${packageName}
+    \`\`\`
+  </TabItem>
+</Tabs>`;
+}
+function removeInstallCommand(content) {
+  return content.replaceAll(/```(?:bash|sh)\n(?:npm|pnpm|yarn)\s+(?:install|add|i)\s+\S+\n```/g, "").trim();
+}
+function mapDefaultSection(section, packageInfo, config) {
+  const lines = [];
+  const headingLevel = "#".repeat(Math.min(section.level + 1, 6));
+  lines.push(`${headingLevel} ${section.heading}`);
+  lines.push("");
+  lines.push(section.content);
+  for (const child of section.children) {
+    const childOutput = mapSection(child, packageInfo, config);
+    if (childOutput.length > 0) {
+      lines.push("");
+      lines.push(childOutput);
+    }
+  }
+  return lines.join("\n");
+}
+function createBadge(text, variant = "note") {
+  return `<Badge text="${sanitizeAttribute(text)}" variant="${variant}" />`;
+}
+function createCard(title, content, icon) {
+  const iconAttr = icon === void 0 ? "" : ` icon="${icon}"`;
+  return `<Card title="${sanitizeAttribute(title)}"${iconAttr}>
+  ${content}
+</Card>`;
+}
+function createCardGrid(cards) {
+  const cardElements = cards.map((card) => createCard(card.title, card.content, card.icon));
+  return `<CardGrid>
+${cardElements.map((c) => `  ${c}`).join("\n")}
+</CardGrid>`;
+}
+function createTabs(items) {
+  const tabItems = items.map(
+    (item) => `  <TabItem label="${sanitizeAttribute(item.label)}">
+    ${item.content}
+  </TabItem>`
+  );
+  return `<Tabs>
+${tabItems.join("\n")}
+</Tabs>`;
+}
+
+// src/generators/content-merger.ts
+import { err, ok } from "@bfra.me/es/result";
+function mergeContent(existingContent, newContent, options = {}) {
+  const { conflictStrategy = "keep-manual", preserveEmptyManual = true } = options;
+  try {
+    const existingManualSections = extractManualSections(existingContent);
+    const newAutoSections = extractAutoSections(newContent);
+    if (existingManualSections.length === 0 && newAutoSections.length === 0) {
+      const hasChanges2 = existingContent.trim() !== newContent.trim();
+      return ok({
+        content: newContent,
+        preservedCount: 0,
+        updatedCount: hasChanges2 ? 1 : 0,
+        hasChanges: hasChanges2
+      });
+    }
+    let merged = newContent;
+    let preservedCount = 0;
+    for (const manual of existingManualSections) {
+      if (!preserveEmptyManual && manual.content.trim().length === 0) {
+        continue;
+      }
+      const manualMarker = `${SENTINEL_MARKERS.MANUAL_START}
+${manual.content}
+${SENTINEL_MARKERS.MANUAL_END}`;
+      if (!merged.includes(SENTINEL_MARKERS.MANUAL_START)) {
+        const autoEndIndex = merged.indexOf(SENTINEL_MARKERS.AUTO_END);
+        if (autoEndIndex === -1) {
+          merged = `${merged}
+
+${manualMarker}`;
+        } else {
+          merged = `${merged.slice(0, autoEndIndex + SENTINEL_MARKERS.AUTO_END.length)}
+
+${manualMarker}
+${merged.slice(autoEndIndex + SENTINEL_MARKERS.AUTO_END.length)}`;
+        }
+      } else if (conflictStrategy === "keep-manual") {
+        const existingManualInNew = extractManualSections(merged);
+        if (existingManualInNew.length > 0) {
+          const firstManualInNew = existingManualInNew[0];
+          if (firstManualInNew !== void 0) {
+            merged = replaceSection(merged, firstManualInNew, manual.content);
+          }
+        }
+      }
+      preservedCount++;
+    }
+    const hasChanges = existingContent.trim() !== merged.trim();
+    return ok({
+      content: merged,
+      preservedCount,
+      updatedCount: newAutoSections.length,
+      hasChanges
+    });
+  } catch (error) {
+    return err({
+      code: "GENERATION_ERROR",
+      message: `Failed to merge content: ${error instanceof Error ? error.message : String(error)}`,
+      cause: error
+    });
+  }
+}
+function extractManualSections(content) {
+  const sections = [];
+  let searchStart = 0;
+  while (searchStart < content.length) {
+    const startIndex = content.indexOf(SENTINEL_MARKERS.MANUAL_START, searchStart);
+    if (startIndex === -1) break;
+    const endIndex = content.indexOf(SENTINEL_MARKERS.MANUAL_END, startIndex);
+    if (endIndex === -1) break;
+    const contentStart = startIndex + SENTINEL_MARKERS.MANUAL_START.length;
+    const sectionContent = content.slice(contentStart, endIndex).trim();
+    sections.push({
+      type: "manual",
+      content: sectionContent,
+      startIndex,
+      endIndex: endIndex + SENTINEL_MARKERS.MANUAL_END.length
+    });
+    searchStart = endIndex + SENTINEL_MARKERS.MANUAL_END.length;
+  }
+  return sections;
+}
+function extractAutoSections(content) {
+  const sections = [];
+  let searchStart = 0;
+  while (searchStart < content.length) {
+    const startIndex = content.indexOf(SENTINEL_MARKERS.AUTO_START, searchStart);
+    if (startIndex === -1) break;
+    const endIndex = content.indexOf(SENTINEL_MARKERS.AUTO_END, startIndex);
+    if (endIndex === -1) break;
+    const contentStart = startIndex + SENTINEL_MARKERS.AUTO_START.length;
+    const sectionContent = content.slice(contentStart, endIndex).trim();
+    sections.push({
+      type: "auto",
+      content: sectionContent,
+      startIndex,
+      endIndex: endIndex + SENTINEL_MARKERS.AUTO_END.length
+    });
+    searchStart = endIndex + SENTINEL_MARKERS.AUTO_END.length;
+  }
+  return sections;
+}
+function replaceSection(content, section, newContent) {
+  const marker = section.type === "manual" ? SENTINEL_MARKERS.MANUAL_START : SENTINEL_MARKERS.AUTO_START;
+  const endMarker = section.type === "manual" ? SENTINEL_MARKERS.MANUAL_END : SENTINEL_MARKERS.AUTO_END;
+  const before = content.slice(0, section.startIndex);
+  const after = content.slice(section.endIndex);
+  return `${before}${marker}
+${newContent}
+${endMarker}${after}`;
+}
+function hasManualContent(content) {
+  return content.includes(SENTINEL_MARKERS.MANUAL_START);
+}
+function hasAutoContent(content) {
+  return content.includes(SENTINEL_MARKERS.AUTO_START);
+}
+function wrapManualSection(content) {
+  return `${SENTINEL_MARKERS.MANUAL_START}
+${content}
+${SENTINEL_MARKERS.MANUAL_END}`;
+}
+function wrapAutoSection(content) {
+  return `${SENTINEL_MARKERS.AUTO_START}
+${content}
+${SENTINEL_MARKERS.AUTO_END}`;
+}
+function stripSentinelMarkers(content) {
+  return content.replaceAll(SENTINEL_MARKERS.AUTO_START, "").replaceAll(SENTINEL_MARKERS.AUTO_END, "").replaceAll(SENTINEL_MARKERS.MANUAL_START, "").replaceAll(SENTINEL_MARKERS.MANUAL_END, "").replaceAll(/\n{3,}/g, "\n\n").trim();
+}
+function validateMarkerPairing(content) {
+  const autoStartCount = countOccurrences(content, SENTINEL_MARKERS.AUTO_START);
+  const autoEndCount = countOccurrences(content, SENTINEL_MARKERS.AUTO_END);
+  const manualStartCount = countOccurrences(content, SENTINEL_MARKERS.MANUAL_START);
+  const manualEndCount = countOccurrences(content, SENTINEL_MARKERS.MANUAL_END);
+  if (autoStartCount !== autoEndCount) {
+    return err({
+      code: "VALIDATION_ERROR",
+      message: `Mismatched AUTO-GENERATED markers: ${autoStartCount} starts, ${autoEndCount} ends`
+    });
+  }
+  if (manualStartCount !== manualEndCount) {
+    return err({
+      code: "VALIDATION_ERROR",
+      message: `Mismatched MANUAL-CONTENT markers: ${manualStartCount} starts, ${manualEndCount} ends`
+    });
+  }
+  const autoNesting = checkNesting(content, SENTINEL_MARKERS.AUTO_START, SENTINEL_MARKERS.AUTO_END);
+  if (!autoNesting) {
+    return err({
+      code: "VALIDATION_ERROR",
+      message: "AUTO-GENERATED markers are improperly nested"
+    });
+  }
+  const manualNesting = checkNesting(
+    content,
+    SENTINEL_MARKERS.MANUAL_START,
+    SENTINEL_MARKERS.MANUAL_END
+  );
+  if (!manualNesting) {
+    return err({
+      code: "VALIDATION_ERROR",
+      message: "MANUAL-CONTENT markers are improperly nested"
+    });
+  }
+  return ok(true);
+}
+function countOccurrences(content, substring) {
+  let count = 0;
+  let position = content.indexOf(substring, 0);
+  while (position !== -1) {
+    count++;
+    position = content.indexOf(substring, position + substring.length);
+  }
+  return count;
+}
+function checkNesting(content, startMarker, endMarker) {
+  let depth = 0;
+  let position = 0;
+  while (position < content.length) {
+    const startPos = content.indexOf(startMarker, position);
+    const endPos = content.indexOf(endMarker, position);
+    if (startPos === -1 && endPos === -1) break;
+    if (startPos !== -1 && (endPos === -1 || startPos < endPos)) {
+      depth++;
+      position = startPos + startMarker.length;
+    } else {
+      depth--;
+      if (depth < 0) return false;
+      position = endPos + endMarker.length;
+    }
+  }
+  return depth === 0;
+}
+function createDiffSummary(oldContent, newContent) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const added = newLines.filter((line) => !oldLines.includes(line)).length;
+  const removed = oldLines.filter((line) => !newLines.includes(line)).length;
+  return `${added} lines added, ${removed} lines removed`;
+}
+
+// src/generators/frontmatter-generator.ts
+function generateFrontmatter(packageInfo, readme, overrides) {
+  const title = resolveTitle(packageInfo, readme, overrides?.title);
+  const description = resolveDescription(packageInfo, readme, overrides?.description);
+  const frontmatter = {
+    title,
+    ...description !== void 0 && { description },
+    ...overrides?.sidebar !== void 0 && { sidebar: overrides.sidebar },
+    ...overrides?.tableOfContents !== void 0 && { tableOfContents: overrides.tableOfContents },
+    ...overrides?.template !== void 0 && { template: overrides.template },
+    ...overrides?.hero !== void 0 && { hero: overrides.hero }
+  };
+  if (packageInfo.docsConfig?.sidebar !== void 0) {
+    frontmatter.sidebar = {
+      ...packageInfo.docsConfig.sidebar,
+      ...frontmatter.sidebar
+    };
+  }
+  if (packageInfo.docsConfig?.frontmatter !== void 0) {
+    const customFrontmatter = packageInfo.docsConfig.frontmatter;
+    return { ...customFrontmatter, ...frontmatter };
+  }
+  return frontmatter;
+}
+function resolveTitle(packageInfo, readme, override) {
+  if (override !== void 0) {
+    return override;
+  }
+  if (packageInfo.docsConfig?.title !== void 0) {
+    return packageInfo.docsConfig.title;
+  }
+  if (readme?.title !== void 0) {
+    return readme.title;
+  }
+  return packageInfo.name;
+}
+function resolveDescription(packageInfo, readme, override) {
+  if (override !== void 0) {
+    return override;
+  }
+  if (packageInfo.docsConfig?.description !== void 0) {
+    return packageInfo.docsConfig.description;
+  }
+  if (packageInfo.description !== void 0) {
+    return packageInfo.description;
+  }
+  if (readme?.preamble !== void 0) {
+    return extractFirstSentence(readme.preamble);
+  }
+  return void 0;
+}
+function extractFirstSentence(text) {
+  const cleaned = text.trim().replaceAll(/\s+/g, " ");
+  const sentenceEnd = cleaned.search(/[.!?](?:\s|$)/);
+  if (sentenceEnd > 0) {
+    return cleaned.slice(0, sentenceEnd + 1);
+  }
+  if (cleaned.length > 160) {
+    const truncated = cleaned.slice(0, 157);
+    const lastSpace = truncated.lastIndexOf(" ");
+    if (lastSpace > 100) {
+      return `${truncated.slice(0, lastSpace)}...`;
+    }
+    return `${truncated}...`;
+  }
+  return cleaned;
+}
+function stringifyFrontmatter(frontmatter) {
+  const lines = [];
+  lines.push(`title: ${yamlString(frontmatter.title)}`);
+  if (frontmatter.description !== void 0) {
+    lines.push(`description: ${yamlString(frontmatter.description)}`);
+  }
+  if (frontmatter.sidebar !== void 0) {
+    lines.push("sidebar:");
+    const sidebar = frontmatter.sidebar;
+    if (sidebar.label !== void 0) {
+      lines.push(`  label: ${yamlString(sidebar.label)}`);
+    }
+    if (sidebar.order !== void 0) {
+      lines.push(`  order: ${sidebar.order}`);
+    }
+    if (sidebar.hidden !== void 0) {
+      lines.push(`  hidden: ${sidebar.hidden}`);
+    }
+    if (sidebar.badge !== void 0) {
+      if (typeof sidebar.badge === "string") {
+        lines.push(`  badge: ${yamlString(sidebar.badge)}`);
+      } else {
+        lines.push("  badge:");
+        lines.push(`    text: ${yamlString(sidebar.badge.text)}`);
+        if (sidebar.badge.variant !== void 0) {
+          lines.push(`    variant: ${sidebar.badge.variant}`);
+        }
+      }
+    }
+  }
+  if (frontmatter.tableOfContents !== void 0) {
+    if (typeof frontmatter.tableOfContents === "boolean") {
+      lines.push(`tableOfContents: ${frontmatter.tableOfContents}`);
+    } else {
+      lines.push("tableOfContents:");
+      if (frontmatter.tableOfContents.minHeadingLevel !== void 0) {
+        lines.push(`  minHeadingLevel: ${frontmatter.tableOfContents.minHeadingLevel}`);
+      }
+      if (frontmatter.tableOfContents.maxHeadingLevel !== void 0) {
+        lines.push(`  maxHeadingLevel: ${frontmatter.tableOfContents.maxHeadingLevel}`);
+      }
+    }
+  }
+  if (frontmatter.template !== void 0) {
+    lines.push(`template: ${frontmatter.template}`);
+  }
+  if (frontmatter.hero !== void 0) {
+    lines.push("hero:");
+    const hero = frontmatter.hero;
+    if (hero.title !== void 0) {
+      lines.push(`  title: ${yamlString(hero.title)}`);
+    }
+    if (hero.tagline !== void 0) {
+      lines.push(`  tagline: ${yamlString(hero.tagline)}`);
+    }
+    if (hero.image !== void 0) {
+      lines.push("  image:");
+      lines.push(`    src: ${yamlString(hero.image.src)}`);
+      lines.push(`    alt: ${yamlString(hero.image.alt)}`);
+    }
+    if (hero.actions !== void 0 && hero.actions.length > 0) {
+      lines.push("  actions:");
+      for (const action of hero.actions) {
+        lines.push(`    - text: ${yamlString(action.text)}`);
+        lines.push(`      link: ${yamlString(action.link)}`);
+        if (action.icon !== void 0) {
+          lines.push(`      icon: ${yamlString(action.icon)}`);
+        }
+        if (action.variant !== void 0) {
+          lines.push(`      variant: ${action.variant}`);
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function yamlString(value) {
+  if (needsQuoting(value)) {
+    return `'${value.replaceAll("'", "''")}'`;
+  }
+  return value;
+}
+function needsQuoting(value) {
+  if (value.length === 0) {
+    return true;
+  }
+  if (value.startsWith(" ") || value.endsWith(" ")) {
+    return true;
+  }
+  const specialChars = /[:#{}[\]&*?|<>=!%@`"',]/;
+  if (specialChars.test(value)) {
+    return true;
+  }
+  const reserved = ["true", "false", "null", "yes", "no", "on", "off"];
+  if (reserved.includes(value.toLowerCase())) {
+    return true;
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+    return true;
+  }
+  return false;
+}
+function parseFrontmatter(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith("title:")) {
+      const value = trimmedLine.slice(6).trim();
+      result.title = stripQuotes(value);
+    }
+    if (trimmedLine.startsWith("description:")) {
+      const value = trimmedLine.slice(12).trim();
+      result.description = stripQuotes(value);
+    }
+  }
+  return result;
+}
+function stripQuotes(value) {
+  if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+// src/generators/mdx-generator.ts
+import { err as err2, ok as ok2 } from "@bfra.me/es/result";
+
+// src/utils/safe-patterns.ts
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+function createHeadingPattern(level) {
+  if (level < 1 || level > 6) {
+    throw new Error("Heading level must be between 1 and 6");
+  }
+  const hashes = "#".repeat(level);
+  return new RegExp(`^${hashes} ([^\r
+]+)$`, "gm");
+}
+function hasComponent(content, componentName) {
+  const escaped = componentName.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+  const pattern = new RegExp(String.raw`<${escaped}(?:\s[^>]*)?(?:>|\/>)`);
+  return pattern.test(content);
+}
+function extractCodeBlocks(content) {
+  const processor = unified().use(remarkParse);
+  let tree;
+  try {
+    tree = processor.parse(content);
+  } catch {
+    return [];
+  }
+  const blocks = [];
+  function visit(node) {
+    if (node.type === "code") {
+      const lang = node.lang ?? "";
+      const value = node.value ?? "";
+      blocks.push(`\`\`\`${lang}
+${value}
+\`\`\``);
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) {
+        visit(child);
+      }
+    }
+  }
+  visit(tree);
+  return blocks;
+}
+function parseJSXTags(content) {
+  const results = [];
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] !== "<") {
+      i++;
+      continue;
+    }
+    const startIndex = i;
+    i++;
+    if (i >= content.length) break;
+    const isClosing = content[i] === "/";
+    if (isClosing) {
+      i++;
+      if (i >= content.length) break;
+    }
+    if (!/^[A-Z]/.test(content[i] ?? "")) {
+      continue;
+    }
+    let tagName = "";
+    while (i < content.length && /^[a-z0-9]/i.test(content[i] ?? "")) {
+      tagName += content[i];
+      i++;
+    }
+    if (tagName.length === 0) {
+      continue;
+    }
+    if (isClosing) {
+      if (i < content.length && content[i] === ">") {
+        results.push({
+          tag: `</${tagName}>`,
+          index: startIndex,
+          isClosing: true,
+          isSelfClosing: false
+        });
+        i++;
+      }
+      continue;
+    }
+    let depth = 0;
+    let foundEnd = false;
+    let isSelfClosing = false;
+    while (i < content.length && !foundEnd) {
+      const char = content[i];
+      if ((char === '"' || char === "'") && depth === 0) {
+        const quote = char;
+        i++;
+        while (i < content.length && content[i] !== quote) {
+          if (content[i] === "\\" && i + 1 < content.length) {
+            i += 2;
+          } else {
+            i++;
+          }
+        }
+        if (i < content.length) i++;
+        continue;
+      }
+      if (char === "{") {
+        depth++;
+        i++;
+        continue;
+      }
+      if (char === "}") {
+        depth = Math.max(0, depth - 1);
+        i++;
+        continue;
+      }
+      if (depth === 0) {
+        if (char === "/" && i + 1 < content.length && content[i + 1] === ">") {
+          isSelfClosing = true;
+          foundEnd = true;
+          i += 2;
+          continue;
+        }
+        if (char === ">") {
+          foundEnd = true;
+          i++;
+          continue;
+        }
+      }
+      i++;
+    }
+    if (foundEnd) {
+      const fullTag = content.slice(startIndex, i);
+      results.push({ tag: fullTag, index: startIndex, isClosing: false, isSelfClosing });
+    }
+  }
+  return results;
+}
+function findEmptyMarkdownLinks(content) {
+  const positions = [];
+  let pos = 0;
+  while (pos < content.length) {
+    const openBracket = content.indexOf("[", pos);
+    if (openBracket === -1) break;
+    let bracketDepth = 1;
+    let closeBracket = openBracket + 1;
+    while (closeBracket < content.length && bracketDepth > 0) {
+      if (content[closeBracket] === "[") {
+        bracketDepth++;
+      } else if (content[closeBracket] === "]") {
+        bracketDepth--;
+      }
+      closeBracket++;
+    }
+    if (bracketDepth !== 0) {
+      pos = openBracket + 1;
+      continue;
+    }
+    closeBracket--;
+    if (closeBracket + 1 < content.length && content[closeBracket + 1] === "(") {
+      let parenPos = closeBracket + 2;
+      let isEmptyOrWhitespace = true;
+      while (parenPos < content.length && content[parenPos] !== ")") {
+        if (!/^\s/.test(content[parenPos] ?? "")) {
+          isEmptyOrWhitespace = false;
+          break;
+        }
+        parenPos++;
+      }
+      if (isEmptyOrWhitespace && parenPos < content.length && content[parenPos] === ")") {
+        positions.push(openBracket);
+      }
+    }
+    pos = closeBracket + 1;
+  }
+  return positions;
+}
+
+// src/generators/mdx-generator.ts
+var DEFAULT_OPTIONS2 = {
+  includeAPI: true,
+  includeExamples: true,
+  preserveManualContent: true
+};
+var STARLIGHT_IMPORTS = `import { Badge, Card, CardGrid, Tabs, TabItem } from '@astrojs/starlight/components';`;
+function generateMDXDocument(packageInfo, readme, api, options = {}) {
+  const mergedOptions = { ...DEFAULT_OPTIONS2, ...options };
+  try {
+    const frontmatter = generateFrontmatter(packageInfo, readme, options.frontmatterOverrides);
+    const contentSections = buildContentSections(packageInfo, readme, api, mergedOptions);
+    const content = contentSections.join("\n\n");
+    const rendered = renderMDXDocument(frontmatter, content);
+    return ok2({
+      frontmatter,
+      content,
+      rendered
+    });
+  } catch (error) {
+    return err2({
+      code: "GENERATION_ERROR",
+      message: `Failed to generate MDX for ${packageInfo.name}: ${error instanceof Error ? error.message : String(error)}`,
+      packageName: packageInfo.name,
+      cause: error
+    });
+  }
+}
+function buildContentSections(packageInfo, readme, api, options) {
+  const sections = [];
+  sections.push(STARLIGHT_IMPORTS);
+  sections.push("");
+  sections.push(generatePackageHeader(packageInfo));
+  if (readme !== void 0) {
+    const mappedContent = mapToStarlightComponents(readme, packageInfo);
+    sections.push(mappedContent);
+  }
+  if (options.includeAPI && api !== void 0 && hasAPIContent(api)) {
+    sections.push(SENTINEL_MARKERS.AUTO_START);
+    sections.push("");
+    sections.push("## API Reference");
+    sections.push("");
+    sections.push(generateAPIReference(api));
+    if (options.includeExamples) {
+      const examples = formatCodeExamples(api);
+      if (examples.length > 0) {
+        sections.push("");
+        sections.push("## Examples");
+        sections.push("");
+        sections.push(examples);
+      }
+    }
+    sections.push("");
+    sections.push(SENTINEL_MARKERS.AUTO_END);
+  }
+  return sections;
+}
+function generatePackageHeader(packageInfo) {
+  const lines = [];
+  lines.push(`# ${packageInfo.name}`);
+  lines.push("");
+  const badges = [];
+  if (packageInfo.keywords?.includes("cli")) {
+    badges.push(`<Badge text="CLI Tool" variant="tip" />`);
+  } else if (packageInfo.keywords?.includes("library")) {
+    badges.push(`<Badge text="Library" variant="tip" />`);
+  } else if (packageInfo.keywords?.includes("config")) {
+    badges.push(`<Badge text="Config" variant="tip" />`);
+  }
+  badges.push(`<Badge text="${sanitizeAttribute(`v${packageInfo.version}`)}" variant="note" />`);
+  if (badges.length > 0) {
+    lines.push(badges.join("\n"));
+    lines.push("");
+  }
+  if (packageInfo.description !== void 0) {
+    lines.push(packageInfo.description);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function hasAPIContent(api) {
+  return api.functions.length > 0 || api.types.length > 0;
+}
+function renderMDXDocument(frontmatter, content) {
+  const frontmatterYaml = stringifyFrontmatter(frontmatter);
+  return `---
+${frontmatterYaml}
+---
+
+${content}
+`;
+}
+function sanitizeContent(content) {
+  return sanitizeForMDX(content);
+}
+function sanitizeTextContent(content) {
+  const jsxTags = parseJSXTags(content);
+  const parts = [];
+  let lastIndex = 0;
+  for (const { tag, index, isClosing } of jsxTags) {
+    if (index > lastIndex) {
+      parts.push(sanitizeContent(content.slice(lastIndex, index)));
+    }
+    if (isClosing) {
+      parts.push(tag);
+    } else {
+      parts.push(sanitizeJSXTag(tag));
+    }
+    lastIndex = index + tag.length;
+  }
+  if (lastIndex < content.length) {
+    parts.push(sanitizeContent(content.slice(lastIndex)));
+  }
+  return parts.join("");
+}
+function validateMDXSyntax(mdx) {
+  const unclosedTags = checkForUnclosedTags(mdx);
+  if (unclosedTags.length > 0) {
+    return err2({
+      code: "VALIDATION_ERROR",
+      message: `Unclosed MDX tags: ${unclosedTags.join(", ")}`
+    });
+  }
+  const invalidFrontmatter = checkFrontmatter(mdx);
+  if (invalidFrontmatter !== void 0) {
+    return err2({
+      code: "VALIDATION_ERROR",
+      message: invalidFrontmatter
+    });
+  }
+  return ok2(true);
+}
+function checkForUnclosedTags(mdx) {
+  const unclosed = [];
+  const tagStack = [];
+  const codeBlocks = extractCodeBlocks(mdx);
+  let contentWithoutCodeBlocks = mdx;
+  for (const block of codeBlocks) {
+    const lineCount = block.split("\n").length;
+    const placeholder = "\n".repeat(lineCount);
+    contentWithoutCodeBlocks = contentWithoutCodeBlocks.replace(block, placeholder);
+  }
+  const jsxTags = parseJSXTags(contentWithoutCodeBlocks);
+  for (const { tag, isClosing, isSelfClosing } of jsxTags) {
+    const tagNameMatch = isClosing ? tag.match(/^<\/([A-Z][a-zA-Z0-9]*)>$/) : tag.match(/^<([A-Z][a-zA-Z0-9]*)/);
+    const tagName = tagNameMatch?.[1];
+    if (tagName === void 0) continue;
+    if (isClosing) {
+      const lastOpenTag = tagStack.pop();
+      if (lastOpenTag !== tagName && lastOpenTag !== void 0) {
+        unclosed.push(lastOpenTag);
+      }
+    } else if (!isSelfClosing) {
+      tagStack.push(tagName);
+    }
+  }
+  unclosed.push(...tagStack);
+  return unclosed;
+}
+function checkFrontmatter(mdx) {
+  if (!mdx.startsWith("---")) {
+    return "MDX document must start with frontmatter";
+  }
+  const secondDashIndex = mdx.indexOf("---", 3);
+  if (secondDashIndex === -1) {
+    return "Frontmatter is not properly closed";
+  }
+  const frontmatterContent = mdx.slice(3, secondDashIndex).trim();
+  if (frontmatterContent.length === 0) {
+    return "Frontmatter cannot be empty";
+  }
+  if (!frontmatterContent.includes("title:")) {
+    return "Frontmatter must include a title";
+  }
+  return void 0;
+}
+
+export {
+  generateAPIReference,
+  generateAPICompact,
+  generateCategoryReference,
+  formatCodeExamples,
+  formatFunctionExamples,
+  formatTypeExamples,
+  formatCodeBlock,
+  cleanCodeExample,
+  detectLanguage,
+  formatUsageExample,
+  groupExamplesByCategory,
+  formatGroupedExamples,
+  mapToStarlightComponents,
+  generateInstallTabs,
+  createBadge,
+  createCard,
+  createCardGrid,
+  createTabs,
+  mergeContent,
+  extractManualSections,
+  extractAutoSections,
+  hasManualContent,
+  hasAutoContent,
+  wrapManualSection,
+  wrapAutoSection,
+  stripSentinelMarkers,
+  validateMarkerPairing,
+  createDiffSummary,
+  generateFrontmatter,
+  stringifyFrontmatter,
+  parseFrontmatter,
+  createHeadingPattern,
+  hasComponent,
+  extractCodeBlocks,
+  findEmptyMarkdownLinks,
+  generateMDXDocument,
+  sanitizeContent,
+  sanitizeTextContent,
+  validateMDXSyntax
+};
+//# sourceMappingURL=chunk-G5KKGJYO.js.map