@dogsbay/format-dogsbay-md 0.2.0-beta.0

package/dist/parse.js

@@ -0,0 +1,1076 @@
+/**
+ * Dogsbay Markdown parser: Dogsbay MD string → TreeNode[]
+ *
+ * Builds on markdown-it + community plugins + custom rules for Dogsbay
+ * directives. Not aiming for byte-perfect round-trip — the parser produces
+ * a TreeNode tree that semantically reconstructs the original content,
+ * which round-trips via the serializer.
+ */
+import MarkdownIt from "markdown-it";
+import mdAttrs from "markdown-it-attrs";
+import mdDeflist from "markdown-it-deflist";
+import mdFootnote from "markdown-it-footnote";
+import matter from "gray-matter";
+import { inlineDirectivesPlugin } from "./plugin-inline-directives.js";
+import { containersPlugin } from "./plugin-containers.js";
+import { blockLeafDirectivePlugin } from "./plugin-block-leaf.js";
+import { attrsToProps } from "./parse-attrs.js";
+import { treeToDogsbayMd } from "./serialize.js";
+/**
+ * Parse Dogsbay Markdown into TreeNode[] plus extracted frontmatter.
+ */
+export function dogsbayMdToTree(source, _options) {
+    // Extract frontmatter via gray-matter first (more reliable than markdown-it-front-matter).
+    // Fall back to parsing source as-is if frontmatter is malformed.
+    let content = source;
+    let frontmatter = {};
+    try {
+        const result = matter(source);
+        content = result.content;
+        frontmatter = result.data;
+    }
+    catch {
+        // Malformed frontmatter — treat whole source as content, no frontmatter
+    }
+    const md = createParser();
+    const tokens = md.parse(content, {});
+    const tree = tokensToTree(tokens);
+    return { tree, frontmatter };
+}
+/**
+ * Parse a single inline string to InlineNode[] (useful for testing).
+ */
+export function parseInline(source) {
+    const md = createParser();
+    const tokens = md.parseInline(source, {});
+    if (tokens.length === 0)
+        return [];
+    return tokensToInline(tokens[0].children ?? []);
+}
+function createParser() {
+    const md = new MarkdownIt({ html: true });
+    md.use(mdAttrs, {
+        leftDelimiter: "{",
+        rightDelimiter: "}",
+        allowedAttributes: [],
+    });
+    md.use(mdDeflist);
+    md.use(mdFootnote);
+    // Frontmatter extracted via gray-matter before source reaches markdown-it
+    md.use(inlineDirectivesPlugin);
+    md.use(blockLeafDirectivePlugin);
+    md.use(containersPlugin);
+    return md;
+}
+function tokensToTree(tokens) {
+    const nodes = [];
+    const ctx = { tokens, i: 0 };
+    while (ctx.i < ctx.tokens.length) {
+        const node = consumeBlock(ctx);
+        if (node) {
+            if (Array.isArray(node)) {
+                nodes.push(...node);
+            }
+            else {
+                nodes.push(node);
+            }
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    return nodes;
+}
+function consumeBlock(ctx) {
+    const tok = ctx.tokens[ctx.i];
+    if (!tok)
+        return null;
+    // Container open — custom directive
+    if (tok.type.startsWith("container_") && tok.type.endsWith("_open")) {
+        return consumeContainer(ctx);
+    }
+    // Standard block types
+    switch (tok.type) {
+        case "heading_open":
+            return consumeHeading(ctx);
+        case "paragraph_open":
+            return consumeParagraph(ctx);
+        case "bullet_list_open":
+            return consumeList(ctx, false);
+        case "ordered_list_open":
+            return consumeList(ctx, true);
+        case "blockquote_open":
+            return consumeBlockquote(ctx);
+        case "fence":
+        case "code_block":
+            return consumeCode(ctx);
+        case "hr":
+            ctx.i++;
+            return { type: "hr" };
+        case "html_block":
+            return consumeHtmlBlock(ctx);
+        case "table_open":
+            return consumeTable(ctx);
+        case "dl_open":
+            return consumeDeflist(ctx);
+        case "front_matter":
+            ctx.i++;
+            return null; // handled by gray-matter
+        case "dogsbay_block_leaf_directive":
+            return consumeBlockLeafDirective(ctx);
+        case "footnote_block_open":
+            return consumeFootnoteBlock(ctx);
+        default:
+            return null;
+    }
+}
+/**
+ * Consume a markdown-it-footnote block:
+ *
+ *   footnote_block_open
+ *     footnote_open (meta.id, meta.label?)
+ *     paragraph_open
+ *     inline { content: "<def text>" }
+ *     footnote_anchor* (one per back-reference)
+ *     paragraph_close
+ *     footnote_close
+ *     ... more footnote_open/close pairs
+ *   footnote_block_close
+ *
+ * Produces a `footnote-list` containing one `footnote-def` per
+ * footnote. The `footnote_anchor` positions are dropped — the
+ * renderer attaches a single backref via `props.backrefId` (jumping
+ * to the first reference). Multiple-backref display is deferred —
+ * see plans/footnote-support.md "Future work".
+ */
+function consumeFootnoteBlock(ctx) {
+    ctx.i++; // footnote_block_open
+    const defs = [];
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === "footnote_block_close") {
+            ctx.i++;
+            break;
+        }
+        if (tok.type === "footnote_open") {
+            defs.push(consumeFootnoteDef(ctx));
+        }
+        else {
+            // Should not happen for well-formed input, but skip safely.
+            ctx.i++;
+        }
+    }
+    return { type: "footnote-list", children: defs };
+}
+function consumeFootnoteDef(ctx) {
+    const open = ctx.tokens[ctx.i];
+    const meta = (open.meta ?? {});
+    // Named footnote keeps the writer's label; inline-sugar (`^[..]`)
+    // gets a 1-based numeric label so renderers display [1], [2], …
+    // even when no explicit label was authored.
+    const label = meta.label ?? String((meta.id ?? 0) + 1);
+    ctx.i++; // footnote_open
+    // Walk until matching footnote_close, collecting inline tokens
+    // from each paragraph in the def. Multi-paragraph defs are
+    // flattened into a single inline run (separated by line breaks)
+    // so the existing format-astro `<li>{inline}</li>` renderer
+    // doesn't need to learn about block-level def children.
+    const inline = [];
+    let firstParagraph = true;
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === "footnote_close") {
+            ctx.i++;
+            break;
+        }
+        if (tok.type === "paragraph_open") {
+            if (!firstParagraph)
+                inline.push({ type: "break" });
+            firstParagraph = false;
+            ctx.i++;
+            continue;
+        }
+        if (tok.type === "paragraph_close") {
+            ctx.i++;
+            continue;
+        }
+        if (tok.type === "inline" && tok.children) {
+            inline.push(...tokensToInline(tok.children));
+            ctx.i++;
+            continue;
+        }
+        if (tok.type === "footnote_anchor") {
+            // Single backref handled via props.backrefId — drop the
+            // per-occurrence anchor markers from the inline stream.
+            ctx.i++;
+            continue;
+        }
+        // Anything else (nested code, etc.) — preserve as html if we
+        // can; otherwise advance. Keep this conservative: the common
+        // case is single-paragraph plain prose.
+        ctx.i++;
+    }
+    return {
+        type: "footnote-def",
+        props: {
+            id: `fn-${label}`,
+            backrefId: `fnref-${label}`,
+            label,
+        },
+        inline,
+    };
+}
+function consumeBlockLeafDirective(ctx) {
+    const tok = ctx.tokens[ctx.i];
+    ctx.i++;
+    const name = tok.tag;
+    const attrs = tok.info ? JSON.parse(tok.info) : undefined;
+    // Reuse the same container-to-TreeNode mapper so leaf directives produce
+    // the same shape as their container equivalent — `::grid-item{...}` is
+    // semantically identical to `:::grid-item{...}\n:::`.
+    return mapContainerToTreeNode(name, attrs, []);
+}
+function consumeHeading(ctx) {
+    const open = ctx.tokens[ctx.i];
+    const level = parseInt(open.tag.slice(1), 10);
+    ctx.i++;
+    // Inline token
+    const inlineTok = ctx.tokens[ctx.i];
+    const inline = inlineTok?.children ? tokensToInline(inlineTok.children) : [];
+    ctx.i++;
+    // heading_close
+    ctx.i++;
+    const node = {
+        type: "heading",
+        props: { level },
+        inline,
+    };
+    // markdown-it-attrs puts attributes on the open token
+    const attrs = extractAttrs(open);
+    if (attrs.id) {
+        if (!node.props)
+            node.props = { level };
+        node.props.slug = attrs.id;
+    }
+    if (attrs.classes.length > 0) {
+        node.props.class = attrs.classes.join(" ");
+    }
+    for (const [k, v] of Object.entries(attrs.props)) {
+        node.props[k] = v;
+    }
+    return node;
+}
+function consumeParagraph(ctx) {
+    ctx.i++; // paragraph_open
+    const inlineTok = ctx.tokens[ctx.i];
+    // Check for GitHub-style alert at start of paragraph (inside blockquote)
+    // pattern: `[!NOTE]` as first token sequence in the paragraph
+    let inline = [];
+    if (inlineTok?.children) {
+        inline = tokensToInline(inlineTok.children);
+    }
+    ctx.i++; // inline
+    // paragraph_close
+    if (ctx.tokens[ctx.i]?.type === "paragraph_close")
+        ctx.i++;
+    if (inline.length === 0)
+        return null;
+    return { type: "paragraph", inline };
+}
+function consumeList(ctx, ordered) {
+    const open = ctx.tokens[ctx.i];
+    ctx.i++;
+    const items = [];
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === (ordered ? "ordered_list_close" : "bullet_list_close")) {
+            ctx.i++;
+            break;
+        }
+        if (tok.type === "list_item_open") {
+            items.push(consumeListItem(ctx));
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    const node = {
+        type: ordered ? "ordered-list" : "unordered-list",
+        children: items,
+    };
+    if (ordered) {
+        const startAttr = open.attrs?.find(([k]) => k === "start");
+        if (startAttr) {
+            node.props = { start: parseInt(startAttr[1], 10) };
+        }
+    }
+    return node;
+}
+function consumeListItem(ctx) {
+    ctx.i++; // list_item_open
+    const children = [];
+    let depth = 1;
+    while (ctx.i < ctx.tokens.length && depth > 0) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === "list_item_open") {
+            depth++;
+            const child = consumeBlock(ctx);
+            if (child) {
+                if (Array.isArray(child))
+                    children.push(...child);
+                else
+                    children.push(child);
+            }
+            else {
+                ctx.i++;
+            }
+            continue;
+        }
+        if (tok.type === "list_item_close") {
+            depth--;
+            ctx.i++;
+            if (depth === 0)
+                break;
+            continue;
+        }
+        const child = consumeBlock(ctx);
+        if (child) {
+            if (Array.isArray(child))
+                children.push(...child);
+            else
+                children.push(child);
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    // Collapse single paragraph child into inline on the list-item
+    if (children.length === 1 && children[0].type === "paragraph" && children[0].inline) {
+        return { type: "list-item", inline: children[0].inline };
+    }
+    // Two children, first is paragraph (inline), rest are blocks
+    if (children.length >= 2 && children[0].type === "paragraph" && children[0].inline) {
+        return {
+            type: "list-item",
+            inline: children[0].inline,
+            children: children.slice(1),
+        };
+    }
+    return { type: "list-item", children };
+}
+function consumeBlockquote(ctx) {
+    ctx.i++; // blockquote_open
+    const children = [];
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === "blockquote_close") {
+            ctx.i++;
+            break;
+        }
+        const child = consumeBlock(ctx);
+        if (child) {
+            if (Array.isArray(child))
+                children.push(...child);
+            else
+                children.push(child);
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    // Detect GitHub alert pattern: first child is paragraph whose first inline text is "[!TYPE]"
+    const firstChild = children[0];
+    if (firstChild?.type === "paragraph" && firstChild.inline) {
+        const alertMatch = matchGitHubAlert(firstChild.inline);
+        if (alertMatch) {
+            const { type, rest } = alertMatch;
+            const newFirst = rest.length > 0 ? { type: "paragraph", inline: rest } : null;
+            const calloutChildren = [
+                ...(newFirst ? [newFirst] : []),
+                ...children.slice(1),
+            ];
+            return {
+                type: "callout",
+                props: { type: type.toLowerCase() },
+                children: calloutChildren,
+            };
+        }
+    }
+    return { type: "blockquote", children };
+}
+function matchGitHubAlert(inline) {
+    if (inline.length === 0 || inline[0].type !== "text")
+        return null;
+    const match = inline[0].text.match(/^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*\n?/);
+    if (!match)
+        return null;
+    const type = match[1];
+    const rest = [
+        { ...inline[0], text: inline[0].text.slice(match[0].length) },
+        ...inline.slice(1),
+    ]
+        // Drop empty text nodes produced by the strip above
+        .filter((n) => !(n.type === "text" && n.text === ""));
+    // Strip leading whitespace (from the softbreak we converted to space)
+    while (rest.length > 0 && rest[0].type === "text" && rest[0].text.trim() === "") {
+        rest.shift();
+    }
+    // Also trim leading whitespace from the first remaining text node
+    if (rest.length > 0 && rest[0].type === "text") {
+        rest[0] = { ...rest[0], text: rest[0].text.replace(/^\s+/, "") };
+    }
+    return { type, rest };
+}
+function consumeCode(ctx) {
+    const tok = ctx.tokens[ctx.i];
+    ctx.i++;
+    const info = tok.info.trim();
+    const [lang, ...rest] = info.split(/\s+/);
+    const restInfo = rest.join(" ");
+    const props = {};
+    if (lang)
+        props.language = lang;
+    // Parse title="..." from rest of the info string (legacy/Starlight style)
+    const titleMatch = restInfo.match(/title\s*=\s*"([^"]*)"/);
+    if (titleMatch)
+        props.title = titleMatch[1];
+    // markdown-it-attrs consumes `{...}` blocks from the fence info string and
+    // attaches them to token.attrs. The Shiki/Expressive Code convention
+    // `{1,3-5}` (no key= prefix) becomes a single attr like ["1,3-5", ""] —
+    // we detect this shape and treat it as `highlights`.
+    if (tok.attrs) {
+        for (const [key, value] of tok.attrs) {
+            if (value === "" && /^[\d,\-\s]+$/.test(key)) {
+                // Shiki-style line range, no value
+                props.highlights = key;
+            }
+            else if (key === "class") {
+                props.class = value;
+            }
+            else if (key === "id") {
+                props.id = value;
+            }
+            else {
+                // Standard key=value attribute (highlights, lineNumbers, ins, del,
+                // mark, collapse, title, frame, etc.)
+                props[key] = value === "" ? true : value;
+            }
+        }
+    }
+    return {
+        type: "code",
+        props,
+        html: tok.content.replace(/\n$/, ""),
+    };
+}
+function consumeHtmlBlock(ctx) {
+    const tok = ctx.tokens[ctx.i];
+    ctx.i++;
+    // Detect <details> HTML and convert to details node
+    const detailsMatch = tok.content.match(/^<details[^>]*>\s*<summary[^>]*>([\s\S]*?)<\/summary>\s*([\s\S]*?)<\/details>\s*$/);
+    if (detailsMatch) {
+        const summary = detailsMatch[1].trim();
+        const innerHtml = detailsMatch[2].trim();
+        // Re-parse inner as markdown? For simplicity, put as html-container child
+        return {
+            type: "details",
+            props: { title: summary },
+            children: [{ type: "html-container", html: innerHtml }],
+        };
+    }
+    return { type: "html", html: tok.content };
+}
+function consumeTable(ctx) {
+    ctx.i++; // table_open
+    const children = [];
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === "table_close") {
+            ctx.i++;
+            break;
+        }
+        if (tok.type === "thead_open") {
+            children.push(consumeTableSection(ctx, "thead", "thead_close"));
+        }
+        else if (tok.type === "tbody_open") {
+            children.push(consumeTableSection(ctx, "tbody", "tbody_close"));
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    return { type: "table", children };
+}
+function consumeTableSection(ctx, sectionType, closeType) {
+    ctx.i++; // section_open
+    const rows = [];
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === closeType) {
+            ctx.i++;
+            break;
+        }
+        if (tok.type === "tr_open") {
+            rows.push(consumeTableRow(ctx));
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    return { type: sectionType, children: rows };
+}
+function consumeTableRow(ctx) {
+    ctx.i++; // tr_open
+    const cells = [];
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === "tr_close") {
+            ctx.i++;
+            break;
+        }
+        if (tok.type === "th_open" || tok.type === "td_open") {
+            const cellType = tok.type === "th_open" ? "th" : "td";
+            const closeType = tok.type === "th_open" ? "th_close" : "td_close";
+            ctx.i++;
+            const inlineTok = ctx.tokens[ctx.i];
+            const inline = inlineTok?.children ? tokensToInline(inlineTok.children) : [];
+            ctx.i++;
+            // skip to close
+            while (ctx.i < ctx.tokens.length && ctx.tokens[ctx.i].type !== closeType)
+                ctx.i++;
+            if (ctx.i < ctx.tokens.length)
+                ctx.i++;
+            cells.push({ type: cellType, inline });
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    return { type: "tr", children: cells };
+}
+function consumeDeflist(ctx) {
+    ctx.i++; // dl_open
+    const children = [];
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === "dl_close") {
+            ctx.i++;
+            break;
+        }
+        if (tok.type === "dt_open") {
+            ctx.i++;
+            const inlineTok = ctx.tokens[ctx.i];
+            const inline = inlineTok?.children ? tokensToInline(inlineTok.children) : [];
+            ctx.i++;
+            // skip to dt_close
+            while (ctx.i < ctx.tokens.length && ctx.tokens[ctx.i].type !== "dt_close")
+                ctx.i++;
+            if (ctx.i < ctx.tokens.length)
+                ctx.i++;
+            children.push({ type: "dt", inline });
+        }
+        else if (tok.type === "dd_open") {
+            ctx.i++;
+            const innerChildren = [];
+            while (ctx.i < ctx.tokens.length && ctx.tokens[ctx.i].type !== "dd_close") {
+                const c = consumeBlock(ctx);
+                if (c) {
+                    if (Array.isArray(c))
+                        innerChildren.push(...c);
+                    else
+                        innerChildren.push(c);
+                }
+                else {
+                    ctx.i++;
+                }
+            }
+            if (ctx.i < ctx.tokens.length)
+                ctx.i++;
+            children.push({ type: "dd", children: innerChildren });
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    return { type: "deflist", children };
+}
+function consumeContainer(ctx) {
+    const openTok = ctx.tokens[ctx.i];
+    // Derive name from token type: "container_{name}_open"
+    const name = openTok.type.replace(/^container_/, "").replace(/_open$/, "");
+    // Attrs are attached to the token by markdown-it-attrs
+    const attrs = extractAttrs(openTok);
+    ctx.i++;
+    const children = [];
+    const closeType = `container_${name}_close`;
+    while (ctx.i < ctx.tokens.length) {
+        const tok = ctx.tokens[ctx.i];
+        if (tok.type === closeType) {
+            ctx.i++;
+            break;
+        }
+        const child = consumeBlock(ctx);
+        if (child) {
+            if (Array.isArray(child))
+                children.push(...child);
+            else
+                children.push(child);
+        }
+        else {
+            ctx.i++;
+        }
+    }
+    return mapContainerToTreeNode(name, attrs, children);
+}
+/**
+ * Convert a container + children into the appropriate TreeNode(s).
+ * Handles callout type aliases, tabs definition-list recovery, cards list form, etc.
+ */
+function mapContainerToTreeNode(name, attrs, children) {
+    const props = attrs ? attrsToProps(attrs) : {};
+    // Callout type aliases — :::note, :::tip, etc. map to callout with type
+    const CALLOUT_TYPES = new Set([
+        "note",
+        "tip",
+        "info",
+        "important",
+        "warning",
+        "caution",
+        "danger",
+        "success",
+        "callout",
+    ]);
+    if (CALLOUT_TYPES.has(name)) {
+        const calloutProps = { ...props };
+        if (name !== "callout")
+            calloutProps.type = name;
+        return { type: "callout", props: calloutProps, children };
+    }
+    // Tabs — if children are a single deflist, convert each dt/dd pair to a tab
+    if (name === "tabs") {
+        return tabsFromChildren(props, children);
+    }
+    // Steps — if children are a single ordered-list, each list-item becomes a step
+    if (name === "steps") {
+        return stepsFromChildren(props, children);
+    }
+    // Cards — if children are a single list, each list-item with bold link becomes a card
+    if (name === "cards") {
+        return cardsFromChildren(props, children);
+    }
+    // Grid — generic wrapper, children pass through
+    if (name === "grid") {
+        return { type: "grid", props, children };
+    }
+    // Grid item — for col/row spanning inside a :::grid
+    if (name === "grid-item") {
+        return { type: "grid-item", props, children };
+    }
+    // Details
+    if (name === "details") {
+        return { type: "details", props, children };
+    }
+    // Button
+    if (name === "button") {
+        return { type: "link-button", props, children };
+    }
+    // Example — docs-oriented: capture inner source by re-serializing children,
+    // keep children so the renderer can also show them as live preview.
+    if (name === "example") {
+        const source = treeToDogsbayMd(children);
+        return { type: "example", props: { ...props, source }, children };
+    }
+    // Accordion — definition list children become accordion-item nodes
+    if (name === "accordion") {
+        return accordionFromChildren(props, children);
+    }
+    // Accordion item — passthrough; label can come from props or first heading
+    if (name === "accordion-item") {
+        return { type: "accordion-item", props, children };
+    }
+    // Link card — single-paragraph body becomes description prop (cleaner
+    // round-trip and matches the LinkCard component's `description` attr).
+    // Multi-block bodies fall through as children.
+    if (name === "link-card") {
+        return linkCardFromChildren(props, children);
+    }
+    // Avatar — leaf-only (block-leaf or inline-leaf). No body expected;
+    // any children are dropped.
+    if (name === "avatar") {
+        return { type: "avatar", props };
+    }
+    // Generic directive — pass through as-is
+    return { type: name, props, children };
+}
+function accordionFromChildren(props, children) {
+    // Preferred shape: a single deflist where each dt is the trigger label
+    // and each dd is the panel body.
+    if (children.length === 1 && children[0].type === "deflist") {
+        const dl = children[0];
+        const items = [];
+        const list = dl.children ?? [];
+        let counter = 1;
+        for (let i = 0; i < list.length; i++) {
+            if (list[i].type === "dt") {
+                const label = inlineText(list[i].inline ?? []);
+                const dd = list[i + 1]?.type === "dd" ? list[i + 1] : null;
+                if (dd) {
+                    items.push({
+                        type: "accordion-item",
+                        props: { value: `item-${counter++}`, label },
+                        children: dd.children ?? [],
+                    });
+                    i++;
+                }
+            }
+        }
+        return { type: "accordion", props, children: items };
+    }
+    // Directive form: explicit `:::accordion-item` children
+    const itemKids = children.filter((c) => c.type === "accordion-item");
+    if (itemKids.length > 0) {
+        return { type: "accordion", props, children: itemKids };
+    }
+    return { type: "accordion", props, children };
+}
+function linkCardFromChildren(props, children) {
+    // Single-paragraph body → fold into description prop. Lets the
+    // serializer round-trip back to the same body form.
+    if (children.length === 1 && children[0].type === "paragraph") {
+        const para = children[0];
+        if (para.inline && para.inline.length > 0) {
+            const description = inlineText(para.inline).trim();
+            const merged = { ...props };
+            if (description && !merged.description)
+                merged.description = description;
+            return { type: "link-card", props: merged };
+        }
+    }
+    // Otherwise keep children for richer body content.
+    return { type: "link-card", props, children };
+}
+function tabsFromChildren(props, children) {
+    // Preferred: children is a single deflist
+    if (children.length === 1 && children[0].type === "deflist") {
+        const dl = children[0];
+        const tabs = [];
+        const list = dl.children ?? [];
+        for (let i = 0; i < list.length; i++) {
+            if (list[i].type === "dt") {
+                const label = inlineText(list[i].inline ?? []);
+                // Find next dd
+                const dd = list[i + 1]?.type === "dd" ? list[i + 1] : null;
+                if (dd) {
+                    tabs.push({
+                        type: "tab",
+                        props: { label },
+                        children: dd.children ?? [],
+                    });
+                    i++;
+                }
+            }
+        }
+        return { type: "tabs", props, children: tabs };
+    }
+    // Directive form: children are explicit :::tab containers
+    const tabs = children.filter((c) => c.type === "tab");
+    if (tabs.length > 0) {
+        return { type: "tabs", props, children: tabs };
+    }
+    // Fallback — unknown shape
+    return { type: "tabs", props, children };
+}
+function stepsFromChildren(props, children) {
+    // Expected: children is a single ordered-list
+    if (children.length === 1 && children[0].type === "ordered-list") {
+        const list = children[0];
+        const steps = [];
+        for (const item of list.children ?? []) {
+            if (item.type === "list-item") {
+                steps.push({
+                    type: "step",
+                    inline: item.inline,
+                    children: item.children,
+                });
+            }
+        }
+        return { type: "steps", props, children: steps };
+    }
+    // Directive form: children are explicit :::step containers
+    const steps = children.filter((c) => c.type === "step");
+    if (steps.length > 0) {
+        return { type: "steps", props, children: steps };
+    }
+    return { type: "steps", props, children };
+}
+function cardsFromChildren(props, children) {
+    // Expected: children is a single unordered-list with cards-in-link form
+    if (children.length === 1 && children[0].type === "unordered-list") {
+        const list = children[0];
+        const cards = [];
+        for (const item of list.children ?? []) {
+            if (item.type === "list-item") {
+                const card = parseCardListItem(item);
+                if (card)
+                    cards.push(card);
+            }
+        }
+        if (cards.length > 0) {
+            return { type: "cards", props, children: cards };
+        }
+    }
+    // Directive form: children are explicit :::card containers
+    const cards = children.filter((c) => c.type === "card");
+    if (cards.length > 0) {
+        return { type: "cards", props, children: cards };
+    }
+    return { type: "cards", props, children };
+}
+function parseCardListItem(item) {
+    const inline = item.inline ?? [];
+    if (inline.length === 0)
+        return null;
+    // Skip leading empty text nodes (produced by bold/strong wrappers around links)
+    let idx = 0;
+    while (idx < inline.length) {
+        const n = inline[idx];
+        if (n.type === "text" && n.text === "")
+            idx++;
+        else
+            break;
+    }
+    const first = inline[idx];
+    if (!first || first.type !== "link")
+        return null;
+    const titleText = inlineText(first.children);
+    const props = {
+        title: titleText,
+        href: first.href,
+    };
+    const description = inlineRestToText(inline.slice(idx + 1));
+    if (description)
+        props.description = description;
+    const childDescription = extractCardDescription(item.children ?? []);
+    if (childDescription && !props.description) {
+        props.description = childDescription;
+    }
+    return { type: "card", props };
+}
+function extractCardDescription(children) {
+    if (children.length === 0)
+        return "";
+    const first = children[0];
+    if (first.type === "paragraph" && first.inline) {
+        return inlineText(first.inline).trim();
+    }
+    return "";
+}
+function inlineText(nodes) {
+    let out = "";
+    for (const n of nodes) {
+        if (n.type === "text")
+            out += n.text;
+        else if (n.type === "link")
+            out += inlineText(n.children);
+        else if (n.type === "highlight")
+            out += inlineText(n.children);
+        else if (n.type === "code")
+            out += n.text;
+    }
+    return out;
+}
+function inlineRestToText(nodes) {
+    return inlineText(nodes).trim();
+}
+function extractAttrs(token) {
+    const result = { classes: [], props: {} };
+    if (!token.attrs)
+        return result;
+    for (const [key, value] of token.attrs) {
+        if (key === "id")
+            result.id = value;
+        else if (key === "class")
+            result.classes.push(...value.split(/\s+/).filter(Boolean));
+        else
+            result.props[key] = value;
+    }
+    return result;
+}
+// ── Tokens → InlineNode[] ────────────────────────────────────────────────
+function tokensToInline(tokens, inheritedFmt = []) {
+    const result = [];
+    const fmtStack = [...inheritedFmt];
+    let i = 0;
+    while (i < tokens.length) {
+        const tok = tokens[i];
+        switch (tok.type) {
+            case "text": {
+                result.push(makeText(tok.content, fmtStack));
+                break;
+            }
+            case "softbreak": {
+                // Treat as space in inline output
+                result.push(makeText(" ", fmtStack));
+                break;
+            }
+            case "hardbreak": {
+                result.push({ type: "break" });
+                break;
+            }
+            case "strong_open":
+                fmtStack.push("bold");
+                break;
+            case "strong_close":
+                fmtStack.pop();
+                break;
+            case "em_open":
+                fmtStack.push("italic");
+                break;
+            case "em_close":
+                fmtStack.pop();
+                break;
+            case "s_open":
+                fmtStack.push("strike");
+                break;
+            case "s_close":
+                fmtStack.pop();
+                break;
+            case "code_inline": {
+                result.push({ type: "code", text: tok.content });
+                break;
+            }
+            case "link_open": {
+                // Collect children up to link_close. Pass formatting context so link
+                // children inside **bold** wrappers retain the bold annotation.
+                const href = tok.attrs?.find(([k]) => k === "href")?.[1] ?? "";
+                const title = tok.attrs?.find(([k]) => k === "title")?.[1];
+                const childTokens = [];
+                i++;
+                while (i < tokens.length && tokens[i].type !== "link_close") {
+                    childTokens.push(tokens[i]);
+                    i++;
+                }
+                const children = tokensToInline(childTokens, fmtStack);
+                const link = { type: "link", href, children };
+                if (title)
+                    link.title = title;
+                result.push(link);
+                break;
+            }
+            case "image": {
+                const src = tok.attrs?.find(([k]) => k === "src")?.[1] ?? "";
+                const alt = tok.content;
+                const title = tok.attrs?.find(([k]) => k === "title")?.[1];
+                const img = { type: "image", src, alt };
+                if (title)
+                    img.title = title;
+                result.push(img);
+                break;
+            }
+            case "dogsbay_inline_directive_open": {
+                const name = tok.tag;
+                const attrs = tok.info ? JSON.parse(tok.info) : null;
+                // Collect label tokens until matching close
+                const labelTokens = [];
+                i++;
+                let depth = 1;
+                while (i < tokens.length && depth > 0) {
+                    const inner = tokens[i];
+                    if (inner.type === "dogsbay_inline_directive_open")
+                        depth++;
+                    else if (inner.type === "dogsbay_inline_directive_close") {
+                        depth--;
+                        if (depth === 0)
+                            break;
+                    }
+                    labelTokens.push(inner);
+                    i++;
+                }
+                const labelInline = tokensToInline(labelTokens);
+                const labelText = inlineText(labelInline);
+                const node = inlineDirectiveToNode(name, labelText, labelInline, attrs);
+                if (node)
+                    result.push(node);
+                break;
+            }
+            case "dogsbay_leaf_directive": {
+                const name = tok.tag;
+                const attrs = tok.info ? JSON.parse(tok.info) : null;
+                const node = inlineDirectiveToNode(name, "", [], attrs);
+                if (node)
+                    result.push(node);
+                break;
+            }
+            case "html_inline": {
+                result.push({ type: "html-inline", html: tok.content });
+                break;
+            }
+            case "footnote_ref": {
+                // markdown-it-footnote attaches { id, subId, label? } to
+                // the token's meta. Named footnotes keep the writer's
+                // label; inline-sugar (^[..]) footnotes get a 1-based
+                // numeric label. The subId field (which counts repeated
+                // citations of the same footnote) is currently dropped —
+                // multiple references render with duplicate anchor ids,
+                // a known limitation tracked in plans/footnote-support.md.
+                const fnMeta = (tok.meta ?? {});
+                const label = fnMeta.label ?? String((fnMeta.id ?? 0) + 1);
+                result.push({ type: "footnote-ref", label });
+                break;
+            }
+            default:
+                // Unknown inline token — skip
+                break;
+        }
+        i++;
+    }
+    return result;
+}
+function makeText(text, fmtStack) {
+    const node = { type: "text", text };
+    if (fmtStack.includes("bold"))
+        node.bold = true;
+    if (fmtStack.includes("italic"))
+        node.italic = true;
+    if (fmtStack.includes("strike"))
+        node.strikethrough = true;
+    return node;
+}
+function inlineDirectiveToNode(name, labelText, _labelInline, attrs) {
+    switch (name) {
+        case "kbd": {
+            const keys = labelText.split(/\s*\+\s*/).filter(Boolean);
+            return { type: "kbd", keys };
+        }
+        case "icon": {
+            const [library, ...rest] = labelText.split(":");
+            if (rest.length === 0) {
+                return { type: "icon", name: library };
+            }
+            return { type: "icon", name: rest.join(":"), library };
+        }
+        case "math": {
+            return { type: "math", latex: labelText };
+        }
+        case "mark":
+        case "highlight": {
+            return {
+                type: "highlight",
+                children: [{ type: "text", text: labelText }],
+            };
+        }
+        case "button": {
+            // Inline button renders as a link
+            const href = attrs?.props.href ?? "";
+            return {
+                type: "link",
+                href,
+                children: [{ type: "text", text: labelText }],
+            };
+        }
+        default:
+            // Unknown inline directive — preserve as html
+            return { type: "html-inline", html: `:${name}[${labelText}]` };
+    }
+}
+//# sourceMappingURL=parse.js.map