@dogsbay/format-mkdocs 0.2.0-beta.0

package/dist/loader.js

@@ -0,0 +1,765 @@
+import { parseToTree } from "./parse.js";
+import { walkInlineTokens } from "./inline-walker.js";
+/**
+ * Parse a MkDocs markdown string into a TreeNode[] + headings.
+ * Adapts tree node shapes to match base-astro's ContentRenderer expectations.
+ *
+ * ContentRenderer handles: prose, heading, code, callout, details, tabs, tab,
+ * table, deflist, dt, dd, steps, step, substeps.
+ *
+ * It does NOT handle: paragraph, ordered-list, unordered-list, list-item,
+ * blockquote, html, annotation-list, hr. These must be collapsed into prose
+ * nodes with pre-rendered HTML.
+ */
+export async function parseMkdocsMarkdown(source, md, options) {
+    const { tree, env } = parseToTree(md, source, options?.env);
+    // Process autodoc directives (::: module.Class) — convert to API TreeNodes
+    if (options?.autodoc) {
+        await processAutodocDirectives(tree, options.autodoc, md);
+    }
+    // Parse MkDocs attr_list syntax { #id .class data-attr="val" } into node props
+    parseAttrLists(tree);
+    // Ensure all <img> in html nodes have alt attributes (a11y)
+    ensureImgAlt(tree);
+    // Strip <script> tags from html nodes (MkDocs demo scripts don't work in our renderer)
+    stripScriptTags(tree);
+    // Parse inline content in props (tab labels, heading text, etc.)
+    parsePropsInline(tree, md);
+    // Render inline markdown to HTML in prose nodes (only needed for collapse mode)
+    if (options?.collapse !== false) {
+        renderInlineContent(tree, md, env);
+    }
+    // Expand footnote references with rendered content
+    if (env.footnotes) {
+        expandFootnotes(tree, md, env);
+    }
+    // Convert standalone YouTube links into youtube nodes (opt-in)
+    if (options?.youtubeEmbed) {
+        liftYouTubeEmbeds(tree);
+    }
+    // Render diagram code blocks (mermaid etc.) to SVG (opt-in)
+    if (options?.diagrams) {
+        await renderDiagrams(tree);
+    }
+    // Convert api-params HTML comments into structured TreeNodes
+    convertApiParams(tree, md);
+    // Extract headings (needs raw text before any collapsing)
+    const headings = extractHeadings(tree);
+    if (options?.collapse !== false) {
+        // Collapse unsupported block types into prose nodes
+        collapseForRenderer(tree);
+    }
+    // Adapt remaining structured nodes for ContentRenderer
+    adaptTree(tree);
+    return { tree, headings };
+}
+/**
+ * Convert <!-- api-params:JSON --> HTML comments into api-params TreeNodes.
+ * The JSON encodes parameter data from the autodoc markdown generator.
+ * Each param's doc field is rendered as markdown HTML for rich display.
+ */
+const API_PARAMS_RE = /^<!--\s*api-params:(.*)\s*-->$/;
+function convertApiParams(nodes, md) {
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (node.type === "html" && node.html) {
+            const match = API_PARAMS_RE.exec(node.html.trim());
+            if (match) {
+                try {
+                    const params = JSON.parse(match[1]);
+                    // Render each param's doc as markdown HTML
+                    const renderedParams = params.map((p) => ({
+                        ...p,
+                        docHtml: p.doc ? md.render(p.doc) : null,
+                    }));
+                    nodes[i] = {
+                        type: "api-params",
+                        props: { params: renderedParams },
+                    };
+                }
+                catch {
+                    // Invalid JSON — leave as HTML
+                }
+            }
+        }
+        if (node.children)
+            convertApiParams(node.children, md);
+    }
+}
+/**
+ * Process ::: autodoc directives in the tree.
+ * After md.parse(), ::: directives appear as paragraph nodes containing
+ * text like "::: fastapi.FastAPI". We find these and replace with API TreeNodes.
+ */
+const DIRECTIVE_RE = /^:::\s+(\S+)\s*$/;
+async function processAutodocDirectives(nodes, options, md) {
+    const { resolveIdentifier } = await import("./autodoc/module-resolver.js");
+    const { symbolToTreeNode } = await import("./autodoc/tree-builder.js");
+    const YAML = (await import("yaml")).default;
+    // Defaults match mkdocstrings Python handler defaults.
+    // Projects override these via mkdocs.yml handler options (passed as globalOptions).
+    const globalOpts = {
+        showRootHeading: false,
+        showRootFullPath: true,
+        showIfNoDocstring: false,
+        showBases: true,
+        showSource: true,
+        showSignature: true,
+        mergeInitIntoClass: false,
+        separateSignature: false,
+        unwrapAnnotated: false,
+        groupByCategory: true,
+        inheritedMembers: false,
+        filters: ["!^_[^_]"],
+        membersOrder: "alphabetical",
+        headingLevel: 2,
+        ...options.globalOptions,
+    };
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        // Check if this is a paragraph containing a ::: directive
+        if (node.type === "paragraph" && node.children) {
+            const proseChild = node.children.find((c) => c.type === "prose" && c.html);
+            if (proseChild?.html) {
+                const fullText = proseChild.html.trim();
+                // The first line should be "::: identifier"
+                const firstLine = fullText.split("\n")[0].trim();
+                const match = DIRECTIVE_RE.exec(firstLine);
+                if (match) {
+                    const identifier = match[1];
+                    // Extract YAML options from remaining lines (indented text after :::)
+                    let directiveOpts = { ...globalOpts };
+                    const remainingLines = fullText.split("\n").slice(1).join("\n").trim();
+                    if (remainingLines) {
+                        try {
+                            const parsed = YAML.parse(remainingLines);
+                            if (parsed?.options) {
+                                const opts = parsed.options;
+                                directiveOpts = {
+                                    ...globalOpts,
+                                    members: opts.members ?? directiveOpts.members,
+                                    showRootHeading: opts.show_root_heading ?? directiveOpts.showRootHeading,
+                                    showRootFullPath: opts.show_root_full_path ?? directiveOpts.showRootFullPath,
+                                    showIfNoDocstring: opts.show_if_no_docstring ?? directiveOpts.showIfNoDocstring,
+                                    showBases: opts.show_bases ?? directiveOpts.showBases,
+                                    showSource: opts.show_source ?? directiveOpts.showSource,
+                                    showSignature: opts.show_signature ?? directiveOpts.showSignature,
+                                    inheritedMembers: opts.inherited_members ?? directiveOpts.inheritedMembers,
+                                    mergeInitIntoClass: opts.merge_init_into_class ?? directiveOpts.mergeInitIntoClass,
+                                    separateSignature: opts.separate_signature ?? directiveOpts.separateSignature,
+                                    unwrapAnnotated: opts.unwrap_annotated ?? directiveOpts.unwrapAnnotated,
+                                    groupByCategory: opts.group_by_category ?? directiveOpts.groupByCategory,
+                                    filters: opts.filters ?? directiveOpts.filters,
+                                    membersOrder: opts.members_order ?? directiveOpts.membersOrder,
+                                };
+                            }
+                        }
+                        catch { /* not valid YAML */ }
+                    }
+                    // Resolve and replace
+                    try {
+                        const symbol = await resolveIdentifier(identifier, options.sourceRoot);
+                        if (symbol) {
+                            const apiNode = symbolToTreeNode(symbol, directiveOpts, md, identifier, options.sourceRoot);
+                            nodes[i] = apiNode;
+                        }
+                    }
+                    catch { /* leave as-is */ }
+                }
+            }
+        }
+        if (node.children) {
+            await processAutodocDirectives(node.children, options, md);
+        }
+    }
+}
+/**
+ * Diagram languages that should be rendered as SVG instead of code blocks.
+ */
+const DIAGRAM_LANGS = new Set(["mermaid"]);
+/**
+ * Render diagram code blocks to SVG.
+ * Transforms { type: "code", props: { lang: "mermaid", code: "..." } }
+ * into { type: "diagram", props: { lang: "mermaid", code: "...", svg: "..." } }.
+ * Source code is preserved for round-trip export and search.
+ */
+async function renderDiagrams(nodes) {
+    let renderMermaidSvg;
+    try {
+        const mod = await import("./renderers/mermaid.js");
+        renderMermaidSvg = mod.renderMermaidSvg;
+    }
+    catch (e) {
+        console.warn("[diagrams] could not load mermaid renderer:", e);
+        return;
+    }
+    async function walk(nodes) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (node.type === "code" &&
+                DIAGRAM_LANGS.has((node.props?.lang || "").toLowerCase())) {
+                const code = node.props.code;
+                const lang = node.props.lang;
+                try {
+                    const svg = await renderMermaidSvg(code);
+                    if (svg) {
+                        nodes[i] = {
+                            type: "diagram",
+                            props: { lang, code, svg },
+                        };
+                    }
+                }
+                catch {
+                    // Leave as code block on render failure
+                }
+            }
+            if (node.children)
+                await walk(node.children);
+        }
+    }
+    await walk(nodes);
+}
+/**
+ * Extract heading info for table of contents.
+ */
+function extractHeadings(tree) {
+    const headings = [];
+    const seen = new Map();
+    function walk(nodes) {
+        for (const node of nodes) {
+            if (node.type === "heading") {
+                const level = node.props?.level ?? 1;
+                const text = extractText(node);
+                // Use explicit { #id } from attr_list if set, otherwise auto-generate
+                let slug = node.props?.slug;
+                if (!slug) {
+                    const baseSlug = slugify(text);
+                    const count = seen.get(baseSlug) ?? 0;
+                    slug = count === 0 ? baseSlug : `${baseSlug}-${count}`;
+                    seen.set(baseSlug, count + 1);
+                }
+                // Add slug and text to heading node props
+                if (!node.props)
+                    node.props = {};
+                node.props.slug = slug;
+                node.props.text = text;
+                headings.push({ depth: level, slug, text });
+            }
+            // API symbols generate TOC entries with kind badges
+            if (node.type === "api-class" || node.type === "api-member") {
+                const name = node.props?.name || "";
+                const kind = node.props?.kind || "";
+                const level = node.type === "api-class" ? 2 : 3;
+                const baseSlug = slugify(name);
+                const count = seen.get(baseSlug) ?? 0;
+                const slug = count === 0 ? baseSlug : `${baseSlug}-${count}`;
+                seen.set(baseSlug, count + 1);
+                headings.push({ depth: level, slug, text: name, kind });
+            }
+            if (node.children)
+                walk(node.children);
+        }
+    }
+    walk(tree);
+    return headings;
+}
+/**
+ * Render inline markdown content to HTML in all prose nodes.
+ * The walker stores raw markdown in prose.html — this converts
+ * **bold**, *italic*, `code`, [links](url), etc. to HTML.
+ */
+function renderInlineContent(nodes, md, env) {
+    for (const node of nodes) {
+        if (node.type === "prose" && node.html) {
+            node.html = md.renderInline(node.html, env);
+        }
+        if (node.children)
+            renderInlineContent(node.children, md, env);
+    }
+}
+/**
+ * Node types that ContentRenderer handles natively.
+ * Everything else gets collapsed to prose with rendered HTML.
+ */
+const RENDERER_TYPES = new Set([
+    "prose", "heading", "code", "diagram", "api-class", "api-member", "api-doc", "api-params", "api-source", "callout", "details",
+    "tabs", "tab", "table", "thead", "tbody", "tr", "th", "td",
+    "deflist", "dt", "dd",
+    "steps", "step", "substeps",
+    "paragraph", "ordered-list", "unordered-list", "list-item",
+    "blockquote", "hr", "html", "html-container", "annotation-list",
+    "deflist", "dt", "dd", "youtube", "footnote-list", "footnote-def", "math-block",
+]);
+/**
+ * Collapse block types that ContentRenderer doesn't handle
+ * (paragraph, lists, blockquote, hr, html, annotation-list)
+ * into prose nodes with pre-rendered HTML.
+ *
+ * Then merge consecutive prose nodes into a single prose block
+ * so Tailwind Typography's .prose class can style them properly
+ * (spacing between paragraphs, heading sizes, list bullets, etc.)
+ */
+function collapseForRenderer(nodes) {
+    // Step 1: recurse into structured containers, collapse others to prose
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (RENDERER_TYPES.has(node.type) && node.children) {
+            collapseForRenderer(node.children);
+            continue;
+        }
+        if (!RENDERER_TYPES.has(node.type)) {
+            const html = nodeToHtml(node);
+            nodes[i] = { type: "prose", html };
+        }
+    }
+    // Step 2: merge consecutive prose nodes (if any remain after collapsing)
+    mergeConsecutiveProse(nodes);
+}
+/**
+ * Merge runs of consecutive prose nodes into a single prose node.
+ * Also absorbs heading nodes into prose runs so typography styles
+ * apply consistent heading sizes and margins.
+ */
+function mergeConsecutiveProse(nodes) {
+    let i = 0;
+    while (i < nodes.length) {
+        if (nodes[i].type === "prose") {
+            // Collect consecutive prose + heading nodes
+            const parts = [nodes[i].html ?? ""];
+            let j = i + 1;
+            while (j < nodes.length && (nodes[j].type === "prose" || nodes[j].type === "heading")) {
+                if (nodes[j].type === "heading") {
+                    const level = nodes[j].props?.level ?? 2;
+                    const slug = nodes[j].props?.slug ?? "";
+                    const text = nodes[j].props?.text ?? "";
+                    const innerHtml = nodes[j].children?.map(nodeToHtml).join("") ?? text;
+                    parts.push(`<h${level} id="${slug}">` +
+                        `<a href="#${slug}" class="heading-anchor" aria-label="Link to ${text}">` +
+                        `<span aria-hidden="true">#</span></a>` +
+                        `${innerHtml}</h${level}>`);
+                }
+                else {
+                    parts.push(nodes[j].html ?? "");
+                }
+                j++;
+            }
+            if (j > i + 1) {
+                // Replace the run with a single merged prose node
+                nodes.splice(i, j - i, { type: "prose", html: parts.join("\n") });
+            }
+        }
+        i++;
+    }
+}
+/**
+ * Render a tree node (and its children) to HTML string.
+ */
+function nodeToHtml(node) {
+    switch (node.type) {
+        case "paragraph":
+            return `<p>${childrenToHtml(node)}</p>`;
+        case "prose":
+            return node.html ?? "";
+        case "ordered-list":
+            return `<ol>${listItemsToHtml(node, "ol")}</ol>`;
+        case "unordered-list":
+            return `<ul>${listItemsToHtml(node, "ul")}</ul>`;
+        case "list-item":
+            return `<li>${childrenToHtml(node)}</li>`;
+        case "blockquote":
+            return `<blockquote>${childrenToHtml(node)}</blockquote>`;
+        case "hr":
+            return "<hr>";
+        case "html":
+            return node.html ?? "";
+        case "annotation-list":
+            return `<div class="annotation-list">${childrenToHtml(node)}</div>`;
+        case "heading": {
+            const level = node.props?.level ?? 2;
+            return `<h${level}>${childrenToHtml(node)}</h${level}>`;
+        }
+        case "code": {
+            const lang = node.props?.lang ?? "";
+            const code = node.props?.code ?? "";
+            return `<pre><code class="language-${lang}">${escapeHtml(code)}</code></pre>`;
+        }
+        default:
+            return childrenToHtml(node);
+    }
+}
+function childrenToHtml(node) {
+    if (!node.children)
+        return node.html ?? "";
+    return node.children.map(nodeToHtml).join("");
+}
+function listItemsToHtml(node, _tag) {
+    if (!node.children)
+        return "";
+    return node.children.map(nodeToHtml).join("");
+}
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/**
+ * Adapt tree node shapes so they match what base-astro's
+ * ContentRenderer.astro expects.
+ */
+function adaptTree(nodes) {
+    for (const node of nodes) {
+        // ContentRenderer expects tabs children to have props.value and props.label
+        // Our walker produces props.title
+        if (node.type === "tab") {
+            const title = node.props?.title ?? "Tab";
+            if (!node.props)
+                node.props = {};
+            node.props.value = slugify(title);
+            node.props.label = title;
+        }
+        // Details: ContentRenderer expects props.title (we already have this)
+        // Callout: ContentRenderer expects props.variant and props.title (we already have these)
+        // But it doesn't handle inline — add as class hint in meta if needed
+        // Strip frontmatter/references nodes — they're not renderable
+        // (handled at tree level, not here)
+        if (node.children)
+            adaptTree(node.children);
+    }
+    // Remove non-renderable nodes
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        if (nodes[i].type === "frontmatter" || nodes[i].type === "references") {
+            nodes.splice(i, 1);
+        }
+    }
+}
+/**
+ * Detect paragraphs that contain only a YouTube link and convert them
+ * into { type: "youtube", props: { id, title } } nodes.
+ *
+ * Uses structured inline nodes when available, falls back to html regex.
+ */
+const YT_URL_RE = /^(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/watch\?v=|youtu\.be\/)([\w-]+)/;
+const YT_LINK_RE = /<a\s+href="(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/watch\?v=|youtu\.be\/)([\w-]+)[^"]*"[^>]*>([^<]*)<\/a>/;
+function liftYouTubeEmbeds(nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (node.type === "paragraph" && node.children?.length === 1 && node.children[0].type === "prose") {
+            const prose = node.children[0];
+            // Structured inline path: check if sole meaningful content is a link to YouTube
+            if (prose.inline) {
+                const meaningful = prose.inline.filter(n => !(n.type === "text" && n.text.trim() === ""));
+                if (meaningful.length === 1 && meaningful[0].type === "link") {
+                    const link = meaningful[0];
+                    const m = YT_URL_RE.exec(link.href);
+                    if (m) {
+                        const title = extractInlineText(link.children) || "YouTube video";
+                        nodes[i] = { type: "youtube", props: { id: m[1], title } };
+                        continue;
+                    }
+                }
+            }
+            // Legacy html fallback
+            if (prose.html) {
+                const html = prose.html.trim();
+                const m = YT_LINK_RE.exec(html);
+                if (m) {
+                    const stripped = html
+                        .replace(/<\/?(?:strong|em|b|i)>/g, "")
+                        .replace(/<a\s[^>]*>[^<]*<\/a>/, "")
+                        .trim();
+                    if (stripped === "") {
+                        nodes[i] = { type: "youtube", props: { id: m[1], title: m[2] || "YouTube video" } };
+                        continue;
+                    }
+                }
+            }
+        }
+        if (node.children)
+            liftYouTubeEmbeds(node.children);
+    }
+}
+/**
+ * Expand <fn-ref data-label="X"> placeholders in prose HTML
+ * with rendered footnote content from env.footnotes.
+ */
+const FN_REF_RE = /<fn-ref data-label="([^"]+)"><\/fn-ref>/g;
+function expandFootnotes(nodes, md, env) {
+    const footnotes = env.footnotes;
+    if (!footnotes)
+        return;
+    // Render footnote content markdown to inline nodes (once per label)
+    const renderedInline = {};
+    const renderedHtml = {};
+    for (const [label, content] of Object.entries(footnotes)) {
+        renderedHtml[label] = md.renderInline(content, env);
+        // Parse footnote content into inline nodes
+        const fnTokens = md.parseInline(content, env);
+        if (fnTokens.length > 0 && fnTokens[0].children) {
+            renderedInline[label] = walkInlineTokens(fnTokens[0].children);
+        }
+        else {
+            renderedInline[label] = [{ type: "text", text: content }];
+        }
+    }
+    // Walk tree: set content on footnote-ref inline nodes, and update html for legacy path
+    function walk(nodes) {
+        for (const node of nodes) {
+            // Structured inline path: set content on footnote-ref nodes
+            if (node.inline) {
+                for (const span of node.inline) {
+                    if (span.type === "footnote-ref" && footnotes[span.label]) {
+                        span.content = renderedHtml[span.label];
+                    }
+                }
+            }
+            // Legacy html path
+            if (node.html && node.html.includes("<fn-ref")) {
+                node.html = node.html.replace(FN_REF_RE, (_match, label) => {
+                    const content = renderedHtml[label] || label;
+                    const escaped = content.replace(/"/g, "&quot;");
+                    return `<a data-footnote data-label="${label}" data-content="${escaped}" href="#fn-${label}" id="fnref-${label}" class="no-underline"><sup class="cursor-pointer text-primary hover:underline">[${label}]</sup></a>`;
+                });
+            }
+            if (node.children)
+                walk(node.children);
+        }
+    }
+    walk(nodes);
+    // Append footnote definitions as structured nodes
+    const labels = Object.keys(footnotes);
+    if (labels.length > 0) {
+        nodes.push({ type: "hr" });
+        nodes.push({
+            type: "footnote-list",
+            children: labels.map((label) => ({
+                type: "footnote-def",
+                props: { label, id: `fn-${label}`, backrefId: `fnref-${label}` },
+                inline: renderedInline[label],
+                // Legacy html fallback
+                html: renderedHtml[label],
+            })),
+        });
+    }
+}
+/**
+ * Parse inline markdown in string props that may contain shortcodes or formatting.
+ * Targets tab labels, admonition titles, and similar props that hold raw markdown.
+ */
+function parsePropsInline(nodes, md) {
+    for (const node of nodes) {
+        // Tab nodes: parse label into inline
+        if (node.type === "tab" && (node.props?.label || node.props?.title) && typeof (node.props?.label || node.props?.title) === "string") {
+            const label = (node.props.label || node.props.title);
+            if (label.includes(":") || label.includes("*") || label.includes("`")) {
+                const tokens = md.parseInline(label, {});
+                if (tokens.length > 0 && tokens[0].children) {
+                    node.inline = walkInlineTokens(tokens[0].children);
+                }
+            }
+        }
+        if (node.children)
+            parsePropsInline(node.children, md);
+    }
+}
+/**
+ * Strip <script> tags from html nodes.
+ * MkDocs content sometimes contains interactive demo scripts that
+ * reference MkDocs-specific DOM elements and cause errors in our renderer.
+ */
+const SCRIPT_TAG_RE = /<script\b[^>]*>[\s\S]*?<\/script>/gi;
+function stripScriptTags(nodes) {
+    for (const node of nodes) {
+        if (node.html && node.html.includes("<script")) {
+            node.html = node.html.replace(SCRIPT_TAG_RE, "");
+        }
+        if (node.children)
+            stripScriptTags(node.children);
+    }
+}
+/**
+ * Ensure all <img> tags in html nodes have an alt attribute.
+ * Derives alt from filename when missing.
+ */
+const IMG_NO_ALT_RE = /<img(?![^>]*\balt\b)([^>]*?)(\s*\/?>)/g;
+function ensureImgAlt(nodes) {
+    for (const node of nodes) {
+        if (node.html && node.html.includes("<img")) {
+            node.html = node.html.replace(IMG_NO_ALT_RE, (_match, attrs, close) => {
+                // Try to derive alt from src filename
+                const srcMatch = attrs.match(/src="([^"]+)"/);
+                let alt = "";
+                if (srcMatch) {
+                    const filename = srcMatch[1].split("/").pop()?.replace(/\.[^.]+$/, "") || "";
+                    alt = filename.replace(/[-_]/g, " ");
+                }
+                return `<img alt="${alt}"${attrs}${close}`;
+            });
+        }
+        if (node.children)
+            ensureImgAlt(node.children);
+    }
+}
+/**
+ * Parse MkDocs attr_list syntax { #id .class key="val" } from content
+ * and move parsed attributes into node props.
+ *
+ * For headings: sets slug/id from { #custom-id }
+ * For other nodes: stores in props.attrs for the renderer to apply
+ */
+const ATTR_LIST_TRAILING_RE = /\s*\{([^}]+)\}\s*$/;
+const ATTR_LIST_INLINE_RE = /\s*\{([^}]+)\}/g;
+function parseAttrString(attrStr) {
+    const result = {};
+    // Parse #id
+    const idMatch = attrStr.match(/#([\w-]+)/);
+    if (idMatch)
+        result.id = idMatch[1];
+    // Parse .class (multiple allowed)
+    const classMatches = attrStr.matchAll(/\.([\w-]+)/g);
+    const classes = [];
+    for (const m of classMatches)
+        classes.push(m[1]);
+    if (classes.length > 0)
+        result.classes = classes;
+    // Parse key="value" or key=value
+    const kvMatches = attrStr.matchAll(/([\w-]+)="([^"]*)"/g);
+    for (const m of kvMatches) {
+        if (!result.attrs)
+            result.attrs = {};
+        result.attrs[m[1]] = m[2];
+    }
+    return result;
+}
+function parseAttrLists(nodes) {
+    for (const node of nodes) {
+        // Handle headings: extract { #id } and set as slug
+        if (node.type === "heading" && node.children) {
+            for (const child of node.children) {
+                if (child.html) {
+                    const match = ATTR_LIST_TRAILING_RE.exec(child.html);
+                    if (match) {
+                        const parsed = parseAttrString(match[1]);
+                        child.html = child.html.replace(ATTR_LIST_TRAILING_RE, "");
+                        if (parsed.id) {
+                            if (!node.props)
+                                node.props = {};
+                            node.props.slug = parsed.id;
+                        }
+                        if (parsed.classes) {
+                            if (!node.props)
+                                node.props = {};
+                            node.props.class = parsed.classes.join(" ");
+                        }
+                    }
+                }
+                if (child.inline) {
+                    const lastText = [...child.inline].reverse().find(n => n.type === "text");
+                    if (lastText && lastText.type === "text") {
+                        const match = ATTR_LIST_TRAILING_RE.exec(lastText.text);
+                        if (match) {
+                            const parsed = parseAttrString(match[1]);
+                            lastText.text = lastText.text.replace(ATTR_LIST_TRAILING_RE, "");
+                            if (parsed.id) {
+                                if (!node.props)
+                                    node.props = {};
+                                node.props.slug = parsed.id;
+                            }
+                            if (parsed.classes) {
+                                if (!node.props)
+                                    node.props = {};
+                                node.props.class = parsed.classes.join(" ");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Handle prose/other nodes: extract attrs and store in props
+        if (node.type !== "heading") {
+            if (node.html) {
+                const match = ATTR_LIST_TRAILING_RE.exec(node.html);
+                if (match) {
+                    const parsed = parseAttrString(match[1]);
+                    node.html = node.html.replace(ATTR_LIST_TRAILING_RE, "");
+                    if (parsed.id || parsed.classes || parsed.attrs) {
+                        if (!node.props)
+                            node.props = {};
+                        if (parsed.id)
+                            node.props.id = parsed.id;
+                        if (parsed.classes)
+                            node.props.class = parsed.classes.join(" ");
+                        if (parsed.attrs)
+                            node.props.attrs = parsed.attrs;
+                    }
+                }
+            }
+            if (node.inline) {
+                for (const span of node.inline) {
+                    if (span.type === "text") {
+                        span.text = span.text.replace(ATTR_LIST_INLINE_RE, "");
+                    }
+                }
+            }
+        }
+        if (node.children)
+            parseAttrLists(node.children);
+    }
+}
+/**
+ * Extract plain text from a tree node.
+ * Prefers inline nodes when available, falls back to html stripping.
+ */
+function extractText(node) {
+    const parts = [];
+    if (node.inline) {
+        parts.push(extractInlineText(node.inline));
+    }
+    else if (node.html) {
+        parts.push(node.html.replace(/<[^>]+>/g, ""));
+    }
+    if (node.children) {
+        for (const child of node.children) {
+            parts.push(extractText(child));
+        }
+    }
+    return parts.filter(Boolean).join(" ").trim();
+}
+function extractInlineText(nodes) {
+    const parts = [];
+    for (const node of nodes) {
+        switch (node.type) {
+            case "text":
+                parts.push(node.text);
+                break;
+            case "code":
+                parts.push(node.text);
+                break;
+            case "link":
+                parts.push(extractInlineText(node.children));
+                break;
+            case "image":
+                if (node.alt)
+                    parts.push(node.alt);
+                break;
+            case "kbd":
+                parts.push(node.keys.join("+"));
+                break;
+            case "html-inline":
+                parts.push(node.html.replace(/<[^>]+>/g, ""));
+                break;
+        }
+    }
+    return parts.join("");
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .trim()
+        || "tab"; // fallback for titles that are entirely punctuation
+}
+//# sourceMappingURL=loader.js.map