@dogsbay/format-docusaurus 0.2.0-beta.78

package/dist/parse-mdx.js

@@ -0,0 +1,765 @@
+/**
+ * Generic Docusaurus MDX parser.
+ *
+ * Reads a standard Docusaurus `.mdx`/`.md` body and produces TreeNode[].
+ * Handles only built-in Docusaurus syntax:
+ *   - :::admonitions (note/tip/info/warning/danger/caution) with optional title
+ *   - <Tabs> / <TabItem value label>
+ *   - <details> / <summary>
+ *   - <CodeBlock> and fenced code with metastrings (title/{ranges}/showLineNumbers)
+ *   - <DocCardList> / <DocCard> (theme built-ins → placeholder + warning)
+ *   - import/export MDX statements (stripped)
+ *
+ * Site-specific components, variable substitution, and partial includes are
+ * the job of an injected `DocusaurusAdapter` — never this file.
+ */
+import { posix } from "node:path";
+import MarkdownIt from "markdown-it";
+import mdxJsx, { normalizeJsxLines } from "@dogsbay/markdown-it-mdx-jsx";
+import { extractFrontmatter } from "./frontmatter.js";
+import { parseCodeMeta } from "./code-meta.js";
+// ── Standard Docusaurus components ──────────────────────
+const DOCUSAURUS_COMPONENTS = {
+    Tabs: { type: "tabs", container: true },
+    TabItem: {
+        type: "tab",
+        container: true,
+        propsFromAttrs: (attrs) => ({ title: attrs.label || attrs.value || "" }),
+    },
+    // Docusaurus admonitions are converted to <Admonition> before parsing.
+    Admonition: {
+        type: "callout",
+        container: true,
+        propsFromAttrs: (attrs) => ({
+            variant: mapAdmonitionType(attrs.type || "note"),
+            title: attrs.title || undefined,
+        }),
+    },
+    // Native collapsible. <details>/<summary> are lowercase HTML tags, which the
+    // mdx-jsx plugin (uppercase-only) ignores, so they are rewritten to these
+    // capitalized component names before parsing (see rewriteNativeHtml).
+    Details: { type: "details", container: true },
+    Summary: { type: "summary", container: true },
+    // Docusaurus theme code component.
+    CodeBlock: {
+        type: "code",
+        container: true,
+        propsFromAttrs: (attrs) => ({
+            lang: attrs.language || "plaintext",
+            title: attrs.title,
+        }),
+    },
+    // Theme card components — auto-generated from the sidebar at runtime, so we
+    // can't reproduce them statically. Emit a placeholder and warn (see D2).
+    DocCardList: { type: "__doc-card-list", container: true },
+    DocCard: { type: "__doc-card-list", container: true },
+};
+const CORE_SELF_CLOSING = ["DocCardList", "DocCard"];
+/** Map a Docusaurus admonition type to a Dogsbay callout variant. */
+function mapAdmonitionType(type) {
+    const map = {
+        note: "note",
+        tip: "tip",
+        info: "info",
+        warning: "warning",
+        danger: "danger",
+        caution: "warning",
+        important: "warning",
+    };
+    return map[type.toLowerCase()] ?? "note";
+}
+function buildComponentMap(adapter) {
+    const map = { ...DOCUSAURUS_COMPONENTS };
+    const selfClosing = [...CORE_SELF_CLOSING];
+    if (adapter?.components) {
+        Object.assign(map, adapter.components);
+    }
+    for (const tag of adapter?.selfClosingTags ?? []) {
+        selfClosing.push(tag);
+    }
+    return { components: Object.keys(map), selfClosing, map };
+}
+// ── Pre-processing ──────────────────────────────────────
+function applyInlineTransforms(source, adapter) {
+    if (!adapter?.inlineTransforms)
+        return source;
+    let result = source;
+    for (const [regex, replacement] of adapter.inlineTransforms) {
+        result = result.replace(regex, replacement);
+    }
+    return result;
+}
+/**
+ * Strip top-level `export ...` MDX statements (the mdx-jsx plugin already
+ * strips `import`). Fence-aware so `export` lines inside code blocks survive.
+ */
+function stripExports(source) {
+    const lines = source.split("\n");
+    const out = [];
+    let inFence = false;
+    let fenceMarker = "";
+    for (const line of lines) {
+        const fence = line.match(/^(\s*)(```+|~~~+)/);
+        if (fence) {
+            const marker = fence[2];
+            if (!inFence) {
+                inFence = true;
+                fenceMarker = marker[0];
+            }
+            else if (marker[0] === fenceMarker) {
+                inFence = false;
+            }
+            out.push(line);
+            continue;
+        }
+        if (!inFence && /^export\s+(const|let|var|default|function|async|\{)/.test(line)) {
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join("\n");
+}
+/**
+ * Rewrite native lowercase `<details>`/`<summary>` HTML tags to capitalized
+ * component tags so the uppercase-only mdx-jsx plugin tokenizes them. Fence-aware
+ * so literal `<details>` inside a code block is left intact.
+ */
+function rewriteNativeHtml(source) {
+    const lines = source.split("\n");
+    const out = [];
+    let inFence = false;
+    let fenceMarker = "";
+    for (const line of lines) {
+        const fence = line.match(/^(\s*)(```+|~~~+)/);
+        if (fence) {
+            const marker = fence[2][0];
+            if (!inFence) {
+                inFence = true;
+                fenceMarker = marker;
+            }
+            else if (marker === fenceMarker) {
+                inFence = false;
+            }
+            out.push(line);
+            continue;
+        }
+        if (inFence) {
+            out.push(line);
+            continue;
+        }
+        out.push(line
+            .replace(/<details(\s[^>]*)?>/g, "<Details>")
+            .replace(/<\/details>/g, "</Details>")
+            .replace(/<summary(\s[^>]*)?>/g, "<Summary>")
+            .replace(/<\/summary>/g, "</Summary>"));
+    }
+    return out.join("\n");
+}
+/**
+ * Convert Docusaurus `:::type[Title]` / `:::type Title` admonition directives
+ * to `<Admonition type="..." title="...">` so the JSX pipeline handles them.
+ * Supports 3+ colons (nested admonitions use more colons).
+ */
+function convertAdmonitions(source) {
+    const lines = source.split("\n");
+    const result = [];
+    const open = [];
+    for (const line of lines) {
+        const openMatch = line.match(/^(\s*)(:{3,})(note|tip|info|warning|danger|caution|important)(?:\[([^\]]*)\]|\s+(.+?))?\s*$/);
+        const closeMatch = line.match(/^(\s*)(:{3,})\s*$/);
+        if (openMatch) {
+            const indent = openMatch[1] || "";
+            const colons = openMatch[2];
+            const type = openMatch[3];
+            const title = (openMatch[4] ?? openMatch[5] ?? "").trim();
+            const titleAttr = title ? ` title="${title.replace(/"/g, "&quot;")}"` : "";
+            result.push(`${indent}<Admonition type="${type}"${titleAttr}>`);
+            open.push({ indent, colons });
+            continue;
+        }
+        if (closeMatch && open.length > 0 && closeMatch[2] === open[open.length - 1].colons) {
+            const { indent } = open.pop();
+            result.push(`${indent}</Admonition>`);
+            continue;
+        }
+        result.push(line);
+    }
+    return result.join("\n");
+}
+// ── Token → TreeNode conversion ─────────────────────────
+function tokensToTree(tokens, ctx) {
+    const { componentMap } = ctx;
+    const tree = [];
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        // ── JSX self-closing ──
+        if (token.type === "jsx_self_closing") {
+            const mapping = componentMap[token.tag];
+            if (mapping && !mapping.strip) {
+                if (mapping.type === "__doc-card-list") {
+                    tree.push(ctx.docCardListCards ?? docCardListPlaceholder(ctx));
+                }
+                else if (mapping.type === "__placeholder") {
+                    tree.push(componentPlaceholder(ctx, token.tag));
+                }
+                else {
+                    const attrs = token.meta?.attrs || {};
+                    const props = mapping.propsFromAttrs?.(attrs) || {};
+                    tree.push({ type: mapping.type, props, children: [] });
+                }
+            }
+            i++;
+            continue;
+        }
+        // ── JSX open ──
+        if (token.type === "jsx_open") {
+            const tag = token.tag;
+            const mapping = componentMap[tag];
+            const children = [];
+            let depth = 1;
+            i++;
+            while (i < tokens.length && depth > 0) {
+                if (tokens[i].type === "jsx_open" && tokens[i].tag === tag)
+                    depth++;
+                else if (tokens[i].type === "jsx_close" && tokens[i].tag === tag) {
+                    depth--;
+                    if (depth === 0) {
+                        i++;
+                        break;
+                    }
+                }
+                children.push(tokens[i]);
+                i++;
+            }
+            if (mapping) {
+                if (mapping.type === "__doc-card-list") {
+                    tree.push(ctx.docCardListCards ?? docCardListPlaceholder(ctx));
+                }
+                else if (mapping.type === "__placeholder") {
+                    tree.push(componentPlaceholder(ctx, tag));
+                }
+                else if (mapping.strip) {
+                    if (mapping.container && children.length > 0) {
+                        tree.push(...tokensToTree(children, ctx));
+                    }
+                }
+                else if (mapping.type === "code") {
+                    // <CodeBlock>...</CodeBlock>: inner content is the code text.
+                    const attrs = token.meta?.attrs || {};
+                    const props = mapping.propsFromAttrs?.(attrs) || {};
+                    const code = children
+                        .filter((t) => t.type === "inline" || t.type === "fence" || t.type === "code_block")
+                        .map((t) => t.content)
+                        .join("");
+                    tree.push({ type: "code", props: { ...props, code: code.replace(/\n$/, "") } });
+                }
+                else {
+                    const attrs = token.meta?.attrs || {};
+                    const props = mapping.propsFromAttrs?.(attrs) || {};
+                    tree.push({ type: mapping.type, props, children: tokensToTree(children, ctx) });
+                }
+            }
+            else {
+                // Unknown component — keep inner content, drop the wrapper.
+                tree.push(...tokensToTree(children, ctx));
+            }
+            continue;
+        }
+        if (token.type === "jsx_close") {
+            i++;
+            continue;
+        }
+        // ── Standard markdown ──
+        if (token.type === "heading_open") {
+            const level = parseInt(token.tag.slice(1), 10);
+            const inline = tokens[i + 1];
+            const text = inline?.content || "";
+            const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+            tree.push({
+                type: "heading",
+                props: { level, text, slug },
+                inline: inline ? inlineTokensToInline(inline.children || []) : [],
+            });
+            i += 3;
+            continue;
+        }
+        if (token.type === "paragraph_open") {
+            const inline = tokens[i + 1];
+            if (inline?.children?.length) {
+                tree.push({
+                    type: "paragraph",
+                    children: [{ type: "prose", inline: inlineTokensToInline(inline.children) }],
+                });
+            }
+            i += 3;
+            continue;
+        }
+        if (token.type === "fence") {
+            const meta = parseCodeMeta(token.info || "");
+            const props = {
+                code: token.content.replace(/\n$/, ""),
+                lang: meta.lang,
+            };
+            if (meta.title)
+                props.title = meta.title;
+            if (meta.highlights)
+                props.highlights = meta.highlights;
+            if (meta.showLineNumbers)
+                props.showLineNumbers = true;
+            tree.push({ type: "code", props });
+            i++;
+            continue;
+        }
+        if (token.type === "code_block") {
+            tree.push({
+                type: "code",
+                props: { code: token.content.replace(/\n$/, ""), lang: "plaintext" },
+            });
+            i++;
+            continue;
+        }
+        if (token.type === "bullet_list_open" || token.type === "ordered_list_open") {
+            const listType = token.type === "ordered_list_open" ? "ordered-list" : "unordered-list";
+            const start = token.type === "ordered_list_open"
+                ? parseInt(token.attrGet("start") || "1", 10)
+                : undefined;
+            const items = [];
+            i++;
+            while (i < tokens.length &&
+                tokens[i].type !== "bullet_list_close" &&
+                tokens[i].type !== "ordered_list_close") {
+                if (tokens[i].type === "list_item_open") {
+                    i++;
+                    const itemTokens = [];
+                    let liDepth = 1;
+                    while (i < tokens.length && liDepth > 0) {
+                        if (tokens[i].type === "list_item_open")
+                            liDepth++;
+                        if (tokens[i].type === "list_item_close") {
+                            liDepth--;
+                            if (liDepth === 0)
+                                break;
+                        }
+                        itemTokens.push(tokens[i]);
+                        i++;
+                    }
+                    items.push({ type: "list-item", children: tokensToTree(itemTokens, ctx) });
+                    i++;
+                }
+                else {
+                    i++;
+                }
+            }
+            i++;
+            const listProps = start && start !== 1 ? { start } : undefined;
+            tree.push({ type: listType, props: listProps, children: items });
+            continue;
+        }
+        if (token.type === "table_open") {
+            const { node, endIndex } = parseTable(tokens, i);
+            tree.push(node);
+            i = endIndex;
+            continue;
+        }
+        if (token.type === "hr") {
+            tree.push({ type: "thematic-break" });
+            i++;
+            continue;
+        }
+        if (token.type === "blockquote_open") {
+            const children = [];
+            let depth = 1;
+            i++;
+            const inner = [];
+            while (i < tokens.length && depth > 0) {
+                if (tokens[i].type === "blockquote_open")
+                    depth++;
+                else if (tokens[i].type === "blockquote_close") {
+                    depth--;
+                    if (depth === 0)
+                        break;
+                }
+                inner.push(tokens[i]);
+                i++;
+            }
+            i++;
+            children.push(...tokensToTree(inner, ctx));
+            tree.push({ type: "blockquote", children });
+            continue;
+        }
+        if (token.type === "html_block") {
+            const trimmed = token.content.trim();
+            if (trimmed.match(/^<[A-Z]/)) {
+                i++;
+                continue;
+            }
+            tree.push({ type: "html", html: token.content });
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return tree;
+}
+function docCardListPlaceholder(ctx) {
+    ctx.onWarn("<DocCardList>/<DocCard> is auto-generated from the sidebar and cannot be reproduced statically — emitted a placeholder.");
+    return {
+        type: "callout",
+        props: { variant: "info" },
+        children: [
+            {
+                type: "paragraph",
+                children: [
+                    {
+                        type: "prose",
+                        inline: [
+                            {
+                                type: "text",
+                                text: "This section originally rendered an auto-generated card list of its sub-pages. Use the sidebar to navigate.",
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+        meta: { docusaurus: "DocCardList" },
+    };
+}
+/**
+ * Placeholder for a data-driven component an adapter can't reproduce statically
+ * (e.g. a React component that builds tables/steps from JSON). Emitting a note
+ * instead of stripping keeps containers (tabs, list items) non-empty — an empty
+ * tab otherwise loses its label — and flags the omission to the reader.
+ */
+function componentPlaceholder(ctx, name) {
+    ctx.onWarn(`<${name}> is a data-driven component and couldn't be reproduced from source — emitted a placeholder.`);
+    return {
+        type: "callout",
+        props: { variant: "info" },
+        children: [
+            {
+                type: "paragraph",
+                children: [
+                    {
+                        type: "prose",
+                        inline: [
+                            { type: "text", text: "Content generated by the " },
+                            { type: "code", text: name },
+                            { type: "text", text: " component was not reproduced in this import." },
+                        ],
+                    },
+                ],
+            },
+        ],
+        meta: { docusaurus: name },
+    };
+}
+function parseTable(tokens, start) {
+    const rows = [];
+    let i = start + 1;
+    let inHead = false;
+    while (i < tokens.length && tokens[i].type !== "table_close") {
+        if (tokens[i].type === "thead_open") {
+            inHead = true;
+            i++;
+            continue;
+        }
+        if (tokens[i].type === "thead_close") {
+            inHead = false;
+            i++;
+            continue;
+        }
+        if (tokens[i].type === "tbody_open" || tokens[i].type === "tbody_close") {
+            i++;
+            continue;
+        }
+        if (tokens[i].type === "tr_open") {
+            const cells = [];
+            i++;
+            while (i < tokens.length && tokens[i].type !== "tr_close") {
+                if (tokens[i].type === "th_open" || tokens[i].type === "td_open") {
+                    const cellType = inHead ? "th" : "td";
+                    const inline = tokens[i + 1];
+                    const inlineNodes = inline?.type === "inline" ? inlineTokensToInline(inline.children || []) : [];
+                    cells.push({ type: cellType, children: [{ type: "prose", inline: inlineNodes }] });
+                    i += 3;
+                }
+                else {
+                    i++;
+                }
+            }
+            rows.push({ type: "tr", children: cells });
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return { node: { type: "table", children: rows }, endIndex: i + 1 };
+}
+// ── Inline conversion ───────────────────────────────────
+function inlineTokensToInline(tokens) {
+    const result = [];
+    let bold = false;
+    let italic = false;
+    let inLink = false;
+    let linkHref = "";
+    let linkChildren = [];
+    const push = (node) => {
+        if (inLink)
+            linkChildren.push(node);
+        else
+            result.push(node);
+    };
+    for (const token of tokens) {
+        if (token.type === "text") {
+            push({ type: "text", text: token.content, bold, italic });
+        }
+        else if (token.type === "code_inline") {
+            push({ type: "code", text: token.content });
+        }
+        else if (token.type === "softbreak" || token.type === "hardbreak") {
+            push({ type: "text", text: "\n" });
+        }
+        else if (token.type === "strong_open") {
+            bold = true;
+        }
+        else if (token.type === "strong_close") {
+            bold = false;
+        }
+        else if (token.type === "em_open") {
+            italic = true;
+        }
+        else if (token.type === "em_close") {
+            italic = false;
+        }
+        else if (token.type === "link_open") {
+            linkHref = token.attrGet("href") || "";
+            linkChildren = [];
+            inLink = true;
+        }
+        else if (token.type === "link_close") {
+            if (inLink) {
+                result.push({ type: "link", href: linkHref, children: linkChildren });
+                inLink = false;
+                linkHref = "";
+                linkChildren = [];
+            }
+        }
+        else if (token.type === "image") {
+            push({
+                type: "image",
+                src: token.attrGet("src") || "",
+                alt: token.content || token.attrGet("alt") || "",
+            });
+        }
+        else if (token.type === "html_inline") {
+            push({ type: "text", text: token.content });
+        }
+        // Inline JSX tokens (jsx_inline_*) are intentionally skipped.
+    }
+    return result;
+}
+// ── Post-processing ─────────────────────────────────────
+/** Hoist a <details>'s <summary> child into props.title. */
+function hoistDetailsSummary(nodes) {
+    for (const node of nodes) {
+        if (node.children)
+            node.children = hoistDetailsSummary(node.children);
+        if (node.type === "details" && node.children) {
+            const idx = node.children.findIndex((c) => c.type === "summary");
+            if (idx !== -1) {
+                const summary = node.children[idx];
+                node.props = { ...node.props, title: summaryText(summary) };
+                node.children.splice(idx, 1);
+            }
+        }
+    }
+    return nodes;
+}
+function summaryText(node) {
+    const parts = [];
+    const walk = (n) => {
+        if (n.inline) {
+            for (const inl of n.inline)
+                if (inl.type === "text" || inl.type === "code")
+                    parts.push(inl.text);
+        }
+        if (n.children)
+            n.children.forEach(walk);
+    };
+    walk(node);
+    return parts.join("").trim();
+}
+/**
+ * Rewrite internal doc links to served URLs.
+ *
+ * Docusaurus authors cross-references as links to source files — relative
+ * (`../foo/bar.mdx`) or root-absolute (`/calico/foo`). The browser can't follow
+ * a `.mdx` path, and relative depths don't match the served (trailing-slash) URL
+ * structure, so Docusaurus resolves these to absolute URLs at build time. We do
+ * the same: strip `.mdx`/`.md` (+ `/index`), resolve relatives against the
+ * current page's slug, and emit a root-absolute `<hrefPrefix>/<slug>` href.
+ *
+ * `currentSlug` is the importing file's slug (e.g.
+ * "getting-started/kubernetes/managed-public-cloud/eks") — relatives resolve
+ * against its directory.
+ */
+function rewriteLinks(nodes, routeBasePath, hrefPrefix, currentSlug) {
+    const base = "/" + routeBasePath.replace(/^\/|\/$/g, "");
+    const prefix = hrefPrefix.replace(/\/$/, "");
+    const currentDir = posix.dirname("/" + currentSlug).replace(/^\//, "");
+    const cleanSlug = (p) => p.replace(/\.mdx?$/, "").replace(/\/index$/, "");
+    const fix = (href) => {
+        if (/^[a-z]+:\/\//i.test(href) || href.startsWith("#") || href.startsWith("mailto:")) {
+            return href;
+        }
+        // Preserve a trailing #anchor / ?query.
+        const split = href.match(/^([^#?]*)([#?].*)?$/);
+        const path = split?.[1] ?? href;
+        const suffix = split?.[2] ?? "";
+        if (!path)
+            return href; // bare "#anchor" already handled above
+        const isDoc = /\.mdx?$/.test(path);
+        if (path.startsWith("/")) {
+            // Root-absolute. Map the instance's routeBasePath onto hrefPrefix; strip
+            // doc extensions either way (non-routeBasePath links are cross-product —
+            // left as-is beyond ext stripping, like Starlight).
+            let p = path;
+            if (base !== "/" && (p === base || p.startsWith(base + "/"))) {
+                p = prefix + cleanSlug(p.slice(base.length));
+            }
+            else if (isDoc) {
+                p = cleanSlug(p);
+            }
+            else {
+                return href;
+            }
+            return p + suffix;
+        }
+        if (isDoc) {
+            // Relative doc link → resolve against the current page's dir → absolute.
+            const resolved = cleanSlug(posix.normalize(posix.join(currentDir, path)));
+            return `${prefix}/${resolved}${suffix}`;
+        }
+        return href; // relative non-doc (rare) — leave untouched
+    };
+    const walkInline = (inl) => {
+        for (const node of inl) {
+            if (node.type === "link") {
+                node.href = fix(node.href);
+                walkInline(node.children);
+            }
+        }
+    };
+    const walk = (n) => {
+        if (n.inline)
+            walkInline(n.inline);
+        if (n.children)
+            n.children.forEach(walk);
+    };
+    nodes.forEach(walk);
+    return nodes;
+}
+/**
+ * Rewrite root-absolute image srcs onto the Dogsbay `_assets` convention.
+ * Docusaurus serves `static/` at the site root, so `static/img/x` is referenced
+ * as `/img/x`; mapped to `/_assets/img/x` (docs/images.md) so it gets correct
+ * basePath prefixing and the copied `static/` tree under `_assets/` resolves.
+ */
+function rewriteImageSrcs(nodes, assetPrefix) {
+    const prefix = assetPrefix.replace(/\/$/, "");
+    const fix = (src) => {
+        if (!src.startsWith("/") || src.startsWith("//"))
+            return src; // relative/protocol-relative/external
+        if (src.startsWith(prefix + "/"))
+            return src; // already mounted
+        return prefix + src;
+    };
+    const walkInline = (inl) => {
+        for (const node of inl) {
+            if (node.type === "image")
+                node.src = fix(node.src);
+            else if (node.type === "link")
+                walkInline(node.children);
+        }
+    };
+    const walk = (n) => {
+        if (n.inline)
+            walkInline(n.inline);
+        if (n.children)
+            n.children.forEach(walk);
+    };
+    nodes.forEach(walk);
+    return nodes;
+}
+/**
+ * Resolve `card` nodes that carry a `docId` (e.g. from `<DocCardLink docId=…>`):
+ * fill in `href` and `title` from the target doc via the injected resolver, so
+ * the card isn't emitted empty. An explicit title/href already on the node wins.
+ */
+function resolveCardDocs(nodes, resolveDoc) {
+    const walk = (n) => {
+        if (n.type === "card" && typeof n.props?.docId === "string") {
+            const r = resolveDoc(n.props.docId);
+            if (r) {
+                if (!n.props.href)
+                    n.props.href = r.href;
+                if (!n.props.title)
+                    n.props.title = r.title;
+            }
+            delete n.props.docId;
+        }
+        n.children?.forEach(walk);
+    };
+    nodes.forEach(walk);
+    return nodes;
+}
+/** Build a `cards` grid TreeNode from a sidebar category's child nav items. */
+function navItemsToCards(items) {
+    const cards = items
+        .filter((it) => it.href || (it.children && it.children.length))
+        .map((it) => ({
+        type: "card",
+        props: { title: it.label, href: it.href ?? it.children?.[0]?.href },
+    }));
+    return { type: "cards", children: cards };
+}
+export function docusaurusToTree(source, options = {}) {
+    const adapter = options.adapter;
+    const onWarn = options.onWarn ?? (() => { });
+    const { components, selfClosing, map: componentMap } = buildComponentMap(adapter);
+    const { body } = extractFrontmatter(source);
+    // Adapter preprocessing runs first: $[var] substitution, partial inlining, etc.
+    let cleaned = adapter?.preprocess
+        ? adapter.preprocess(body, options.preprocessContext ?? {})
+        : body;
+    cleaned = cleaned.replace(/\t/g, "    ");
+    cleaned = applyInlineTransforms(cleaned, adapter);
+    cleaned = stripExports(cleaned);
+    cleaned = convertAdmonitions(cleaned);
+    cleaned = rewriteNativeHtml(cleaned);
+    cleaned = normalizeJsxLines(cleaned);
+    const md = new MarkdownIt({ html: true, linkify: true }).use(mdxJsx, {
+        components,
+        selfClosing,
+    });
+    const tokens = md.parse(cleaned, {});
+    // If this page is a category index, build the DocCardList grid from its
+    // sidebar children up front so tokensToTree can emit it in place.
+    const cardListItems = options.resolveDocCardList?.(options.currentSlug ?? "");
+    const docCardListCards = cardListItems && cardListItems.length > 0 ? navItemsToCards(cardListItems) : undefined;
+    const ctx = { componentMap, onWarn, docCardListCards };
+    let tree = tokensToTree(tokens, ctx);
+    tree = hoistDetailsSummary(tree);
+    if (options.routeBasePath) {
+        tree = rewriteLinks(tree, options.routeBasePath, options.hrefPrefix ?? "/docs", options.currentSlug ?? "");
+    }
+    if (options.assetPrefix) {
+        tree = rewriteImageSrcs(tree, options.assetPrefix);
+    }
+    if (options.resolveDoc) {
+        tree = resolveCardDocs(tree, options.resolveDoc);
+    }
+    return tree;
+}