@bendyline/squisq 1.4.0 → 1.4.1

package/dist/markdown/convert.js

@@ -1,975 +0,0 @@
-/**
- * mdast ↔ Squisq Markdown Node Conversion
- *
- * Converts between the remark/mdast AST format and the squisq
- * MarkdownDocument JSON format. This is the bridge layer that allows
- * us to use the battle-tested unified/remark ecosystem for parsing
- * and serialization while exposing our own clean, well-typed interfaces.
- *
- * The conversion is designed for perfect round-tripping:
- * toMdast(fromMdast(tree)) should produce an equivalent mdast tree.
- */
-import { parseHtmlToNodes } from './htmlParse.js';
-import { resolveIcon } from '../icons/resolve.js';
-// ============================================
-// Position conversion
-// ============================================
-function convertPosition(pos) {
-    if (!pos)
-        return undefined;
-    return {
-        start: {
-            line: pos.start.line,
-            column: pos.start.column,
-            ...(pos.start.offset != null ? { offset: pos.start.offset } : {}),
-        },
-        end: {
-            line: pos.end.line,
-            column: pos.end.column,
-            ...(pos.end.offset != null ? { offset: pos.end.offset } : {}),
-        },
-    };
-}
-function toMdastPosition(pos) {
-    return {
-        start: {
-            line: pos.start.line,
-            column: pos.start.column,
-            ...(pos.start.offset != null ? { offset: pos.start.offset } : {}),
-        },
-        end: {
-            line: pos.end.line,
-            column: pos.end.column,
-            ...(pos.end.offset != null ? { offset: pos.end.offset } : {}),
-        },
-    };
-}
-/** Conditionally include position in node. */
-function posField(pos) {
-    return pos ? { position: pos } : {};
-}
-function mdastPosField(pos) {
-    return pos ? { position: toMdastPosition(pos) } : {};
-}
-// ============================================
-// mdast → Squisq (fromMdast)
-// ============================================
-/**
- * Extract plain text content from an mdast node tree.
- * Used for directive labels.
- */
-function extractText(node) {
-    if (node.value != null)
-        return node.value;
-    if (node.children) {
-        return node.children.map(extractText).join('');
-    }
-    return '';
-}
-// ============================================
-// Template annotation helpers
-// ============================================
-/**
- * Regex matching a trailing `{[templateName key=value …]}` annotation.
- * Captures the content between `{[` and `]}`.
- *
- * The trailing `[\s\]\}]*` tolerates accidental doubled `]}` that users
- * sometimes type when learning the syntax (e.g. `{[foo]}]}`). It does
- * not allow trailing word characters, so a non-trailing annotation like
- * `## The {[chart]} section` still doesn't match.
- */
-const TEMPLATE_ANNOTATION_RE = /\s*\{\[([^\]]+)\]\}[\s\]}]*$/;
-/**
- * Extract a `{[templateName key=value …]}` annotation from a heading's
- * inline children. Mutates the children array in-place: strips the
- * annotation text from the last text node (or removes the node entirely).
- *
- * @returns The parsed annotation, or null if none found.
- */
-function extractTemplateAnnotation(children) {
-    // Walk backwards to find the last text node
-    for (let i = children.length - 1; i >= 0; i--) {
-        const child = children[i];
-        if (child.type === 'text') {
-            const match = child.value.match(TEMPLATE_ANNOTATION_RE);
-            if (match) {
-                const inner = match[1].trim();
-                const annotation = parseAnnotationTokens(inner);
-                // Strip the matched portion from the text
-                const stripped = child.value.slice(0, match.index).replace(/\s+$/, '');
-                if (stripped) {
-                    child.value = stripped;
-                }
-                else {
-                    // Remove the now-empty text node
-                    children.splice(i, 1);
-                }
-                return annotation;
-            }
-            // Only check the last text node (trailing position)
-            break;
-        }
-        // If the last child isn't a text node, there's no annotation
-        break;
-    }
-    return null;
-}
-/**
- * Parse the inner content of a `{[…]}` annotation into template + params.
- *
- * Input: `"chart colorScheme=blue size=large"`
- * Output: `{ template: 'chart', params: { colorScheme: 'blue', size: 'large' } }`
- */
-function parseAnnotationTokens(inner) {
-    const tokens = inner.split(/\s+/);
-    const params = {};
-    // If the first token contains '=', there's no template name —
-    // the annotation is purely key-value (e.g., `{[audio=intro.mp3]}`).
-    const firstIsParam = tokens[0].indexOf('=') > 0;
-    const template = firstIsParam ? undefined : tokens[0];
-    const startIdx = firstIsParam ? 0 : 1;
-    for (let i = startIdx; i < tokens.length; i++) {
-        const eqIdx = tokens[i].indexOf('=');
-        if (eqIdx > 0) {
-            params[tokens[i].slice(0, eqIdx)] = tokens[i].slice(eqIdx + 1);
-        }
-    }
-    const result = {};
-    if (template) {
-        result.template = template;
-    }
-    if (Object.keys(params).length > 0) {
-        result.params = params;
-    }
-    return result;
-}
-/**
- * Serialize a HeadingTemplateAnnotation back to `{[templateName key=value …]}` text.
- */
-function serializeTemplateAnnotation(annotation) {
-    const parts = [];
-    if (annotation.template) {
-        parts.push(annotation.template);
-    }
-    if (annotation.params) {
-        for (const [key, value] of Object.entries(annotation.params)) {
-            parts.push(`${key}=${value}`);
-        }
-    }
-    return `{[${parts.join(' ')}]}`;
-}
-/**
- * Convert an mdast Root node to a MarkdownDocument.
- *
- * @param root - The mdast root node (from remark-parse)
- * @param options - Conversion options
- * @returns A MarkdownDocument
- */
-export function fromMdast(root, options) {
-    const doParseHtml = options?.parseHtml !== false;
-    return {
-        type: 'document',
-        children: convertBlockChildren(root.children ?? [], doParseHtml),
-        ...posField(convertPosition(root.position)),
-    };
-}
-function convertBlockChildren(children, parseHtml) {
-    const result = [];
-    for (const child of children) {
-        const node = convertBlockNode(child, parseHtml);
-        if (node)
-            result.push(node);
-    }
-    return result;
-}
-function convertInlineChildren(children, parseHtml, 
-/** When false, skip the inline-icon split. Headings opt out so the
- *  `extractTemplateAnnotation` pass still sees the trailing
- *  `{[…]}` in raw text form; the caller runs `splitInlineIcons`
- *  itself afterward on the remaining children. */
-applyIconSplit = true) {
-    const result = [];
-    for (const child of children) {
-        const node = convertInlineNode(child, parseHtml);
-        if (node)
-            result.push(node);
-    }
-    const mentioned = coalesceMentions(result);
-    return applyIconSplit ? splitInlineIcons(mentioned) : mentioned;
-}
-/**
- * Walk an inline-children list and split each text node on `{[token]}`
- * occurrences whose tokens resolve to known FontAwesome icons. Returns
- * a new array — unresolved tokens are left as literal text so authors
- * can write `{[notathing]}` verbatim if they really mean to.
- *
- * Exposed for the heading code path, which first strips the trailing
- * template annotation and then runs this on what remains.
- */
-export function splitInlineIcons(nodes) {
-    // First pass: reassemble `text + textDirective + text` patterns
-    // formed when a qualified token like `{[fa-solid:user]}` was split
-    // by remark-directive's colon recognition. We collapse those triples
-    // back into a single text node containing the original token so the
-    // regex below can match.
-    const recombined = recombineDirectiveTokens(nodes);
-    const out = [];
-    for (const node of recombined) {
-        if (node.type !== 'text') {
-            out.push(node);
-            continue;
-        }
-        out.push(...splitTextOnIcons(node.value, node.position));
-    }
-    return out;
-}
-/**
- * When the user types `{[fa-solid:user]}`, remark's directive plugin
- * sees `:user` and emits a `textDirective` node. The result is a
- * three-node sequence `text("…{[fa-solid") + textDirective("user") +
- * text("]}…")`. This helper detects that shape and stitches the three
- * back into one text node so downstream icon detection works on the
- * authored token.
- */
-function recombineDirectiveTokens(nodes) {
-    const out = [];
-    for (let i = 0; i < nodes.length; i++) {
-        const cur = nodes[i];
-        const next = nodes[i + 1];
-        const after = nodes[i + 2];
-        if (cur?.type === 'text' &&
-            next?.type === 'textDirective' &&
-            after?.type === 'text' &&
-            /\{\[[a-zA-Z0-9_-]+$/.test(cur.value) &&
-            /^\]\}/.test(after.value)) {
-            const directive = next;
-            const directiveName = directive.name ?? '';
-            const merged = {
-                type: 'text',
-                value: cur.value + ':' + directiveName + after.value,
-                ...(cur.position ? { position: cur.position } : {}),
-            };
-            out.push(merged);
-            i += 2;
-            continue;
-        }
-        out.push(cur);
-    }
-    return out;
-}
-const ICON_TOKEN_RE = /\{\[([a-zA-Z0-9_:-]+)\]\}/g;
-function splitTextOnIcons(value, position) {
-    if (!value)
-        return [];
-    ICON_TOKEN_RE.lastIndex = 0;
-    let lastIndex = 0;
-    let match;
-    const out = [];
-    while ((match = ICON_TOKEN_RE.exec(value)) !== null) {
-        const token = match[1];
-        const icon = resolveIcon(token);
-        if (!icon)
-            continue; // leave the literal `{[…]}` in place
-        if (match.index > lastIndex) {
-            out.push({
-                type: 'text',
-                value: value.slice(lastIndex, match.index),
-                ...(position ? { position } : {}),
-            });
-        }
-        const iconNode = {
-            type: 'inlineIcon',
-            token,
-            family: icon.family,
-            name: icon.name,
-            ...(position ? { position } : {}),
-        };
-        out.push(iconNode);
-        lastIndex = match.index + match[0].length;
-    }
-    if (lastIndex === 0) {
-        // No matches — return the original text node unchanged.
-        return [{ type: 'text', value, ...(position ? { position } : {}) }];
-    }
-    if (lastIndex < value.length) {
-        out.push({
-            type: 'text',
-            value: value.slice(lastIndex),
-            ...(position ? { position } : {}),
-        });
-    }
-    return out;
-}
-/**
- * Post-process an inline-children list to collapse `text('@') + link(scheme:id)`
- * pairs into a single `mention` node. The wire format `@[Display](scheme:id)`
- * comes back from remark as two adjacent nodes — we merge them so consumers
- * see a single atomic mention. A plain link whose URL doesn't have `scheme:id`
- * shape, or that isn't immediately preceded by `@`, is left alone so ordinary
- * links keep working.
- */
-function coalesceMentions(inlines) {
-    const out = [];
-    for (const cur of inlines) {
-        const prev = out[out.length - 1];
-        if (cur.type === 'link' &&
-            typeof cur.url === 'string' &&
-            prev &&
-            prev.type === 'text' &&
-            prev.value.endsWith('@')) {
-            const schemeMatch = cur.url.match(/^([a-z][a-z0-9+.-]*):(.+)$/i);
-            if (schemeMatch && schemeMatch[1] && schemeMatch[2]) {
-                const targetKind = schemeMatch[1];
-                const targetId = schemeMatch[2];
-                const displayName = extractInlineText(cur.children);
-                if (prev.value === '@') {
-                    out.pop();
-                }
-                else {
-                    prev.value = prev.value.slice(0, -1);
-                }
-                out.push({
-                    type: 'mention',
-                    targetKind,
-                    targetId,
-                    displayName,
-                    ...(cur.position ? { position: cur.position } : {}),
-                });
-                continue;
-            }
-        }
-        out.push(cur);
-    }
-    return out;
-}
-/** Plain-text of an inline children list — used to pull the display name
- * out of a mention link's children. */
-function extractInlineText(nodes) {
-    let out = '';
-    for (const n of nodes) {
-        if (n.type === 'text' || n.type === 'inlineCode')
-            out += n.value;
-        else if ('children' in n && Array.isArray(n.children)) {
-            out += extractInlineText(n.children);
-        }
-    }
-    return out;
-}
-function convertBlockNode(node, parseHtml) {
-    const pos = convertPosition(node.position);
-    switch (node.type) {
-        case 'heading': {
-            // Defer icon splitting so `extractTemplateAnnotation` sees the
-            // trailing `{[name]}` as plain text and can decide whether it's
-            // a template annotation. Anything that's NOT the template still
-            // needs to become an icon node, so we run `splitInlineIcons` on
-            // what's left after the template extraction.
-            const headingChildren = convertInlineChildren(node.children ?? [], parseHtml, false);
-            const annotation = extractTemplateAnnotation(headingChildren);
-            const finalChildren = splitInlineIcons(headingChildren);
-            const result = {
-                type: 'heading',
-                depth: (node.depth ?? 1),
-                children: finalChildren,
-                ...posField(pos),
-            };
-            if (annotation) {
-                result.templateAnnotation = annotation;
-            }
-            return result;
-        }
-        case 'paragraph':
-            return {
-                type: 'paragraph',
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'blockquote':
-            return {
-                type: 'blockquote',
-                children: convertBlockChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'list':
-            return {
-                type: 'list',
-                ordered: node.ordered ?? false,
-                ...(node.start != null ? { start: node.start } : {}),
-                ...(node.spread != null ? { spread: node.spread } : {}),
-                children: (node.children ?? []).map((item) => convertListItem(item, parseHtml)),
-                ...posField(pos),
-            };
-        case 'code':
-            return {
-                type: 'code',
-                ...(node.lang != null ? { lang: node.lang } : {}),
-                ...(node.meta != null ? { meta: node.meta } : {}),
-                value: node.value ?? '',
-                ...posField(pos),
-            };
-        case 'thematicBreak':
-            return {
-                type: 'thematicBreak',
-                ...posField(pos),
-            };
-        case 'table':
-            return {
-                type: 'table',
-                ...(node.align
-                    ? { align: node.align.map((a) => a) }
-                    : {}),
-                children: (node.children ?? []).map((row, i) => convertTableRow(row, i === 0, parseHtml)),
-                ...posField(pos),
-            };
-        case 'html':
-            return {
-                type: 'htmlBlock',
-                rawHtml: node.value ?? '',
-                htmlChildren: parseHtml ? parseHtmlToNodes(node.value ?? '') : [],
-                ...posField(pos),
-            };
-        case 'math':
-            return {
-                type: 'math',
-                value: node.value ?? '',
-                ...(node.meta != null ? { meta: node.meta } : {}),
-                ...posField(pos),
-            };
-        case 'definition':
-            return {
-                type: 'definition',
-                identifier: node.identifier ?? '',
-                ...(node.label != null ? { label: node.label } : {}),
-                url: node.url ?? '',
-                ...(node.title != null ? { title: node.title } : {}),
-                ...posField(pos),
-            };
-        case 'footnoteDefinition':
-            return {
-                type: 'footnoteDefinition',
-                identifier: node.identifier ?? '',
-                ...(node.label != null ? { label: node.label } : {}),
-                children: convertBlockChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'containerDirective': {
-            const allChildren = node.children ?? [];
-            let label;
-            let contentChildren = allChildren;
-            // Extract directive label (first paragraph with directiveLabel flag)
-            if (allChildren.length > 0 &&
-                allChildren[0].type === 'paragraph' &&
-                allChildren[0].data?.directiveLabel === true) {
-                label = extractText(allChildren[0]);
-                contentChildren = allChildren.slice(1);
-            }
-            return {
-                type: 'containerDirective',
-                name: node.name ?? '',
-                ...(label ? { label } : {}),
-                ...(node.attributes && Object.keys(node.attributes).length > 0
-                    ? { attributes: node.attributes }
-                    : {}),
-                children: convertBlockChildren(contentChildren, parseHtml),
-                ...posField(pos),
-            };
-        }
-        case 'leafDirective':
-            return {
-                type: 'leafDirective',
-                name: node.name ?? '',
-                ...(node.attributes && Object.keys(node.attributes).length > 0
-                    ? { attributes: node.attributes }
-                    : {}),
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'yaml':
-            // YAML frontmatter nodes are handled separately in parse.ts — skip silently
-            return null;
-        default:
-            // Unknown block node — skip with a warning
-            if (typeof console !== 'undefined') {
-                console.warn(`[squisq/markdown] Unknown mdast block node type: "${node.type}"`);
-            }
-            return null;
-    }
-}
-function convertListItem(node, parseHtml) {
-    const pos = convertPosition(node.position);
-    return {
-        type: 'listItem',
-        ...(node.checked != null ? { checked: node.checked } : {}),
-        ...(node.spread != null ? { spread: node.spread } : {}),
-        children: convertBlockChildren(node.children ?? [], parseHtml),
-        ...posField(pos),
-    };
-}
-function convertTableRow(node, isHeader, parseHtml) {
-    const pos = convertPosition(node.position);
-    return {
-        type: 'tableRow',
-        children: (node.children ?? []).map((cell) => convertTableCell(cell, isHeader, parseHtml)),
-        ...posField(pos),
-    };
-}
-function convertTableCell(node, isHeader, parseHtml) {
-    const pos = convertPosition(node.position);
-    return {
-        type: 'tableCell',
-        ...(isHeader ? { isHeader: true } : {}),
-        children: convertInlineChildren(node.children ?? [], parseHtml),
-        ...posField(pos),
-    };
-}
-function convertInlineNode(node, parseHtml) {
-    const pos = convertPosition(node.position);
-    switch (node.type) {
-        case 'text':
-            return {
-                type: 'text',
-                value: node.value ?? '',
-                ...posField(pos),
-            };
-        case 'emphasis':
-            return {
-                type: 'emphasis',
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'strong':
-            return {
-                type: 'strong',
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'delete':
-            return {
-                type: 'delete',
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'inlineCode':
-            return {
-                type: 'inlineCode',
-                value: node.value ?? '',
-                ...posField(pos),
-            };
-        case 'link':
-            return {
-                type: 'link',
-                url: node.url ?? '',
-                ...(node.title != null ? { title: node.title } : {}),
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'image':
-            return {
-                type: 'image',
-                url: node.url ?? '',
-                ...(node.alt != null ? { alt: node.alt } : {}),
-                ...(node.title != null ? { title: node.title } : {}),
-                ...posField(pos),
-            };
-        case 'break':
-            return {
-                type: 'break',
-                ...posField(pos),
-            };
-        case 'html':
-            return {
-                type: 'htmlInline',
-                rawHtml: node.value ?? '',
-                htmlChildren: parseHtml ? parseHtmlToNodes(node.value ?? '') : [],
-                ...posField(pos),
-            };
-        case 'inlineMath':
-            return {
-                type: 'inlineMath',
-                value: node.value ?? '',
-                ...posField(pos),
-            };
-        case 'footnoteReference':
-            return {
-                type: 'footnoteReference',
-                identifier: node.identifier ?? '',
-                ...(node.label != null ? { label: node.label } : {}),
-                ...posField(pos),
-            };
-        case 'linkReference':
-            return {
-                type: 'linkReference',
-                identifier: node.identifier ?? '',
-                ...(node.label != null ? { label: node.label } : {}),
-                referenceType: (node.referenceType ?? 'full'),
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        case 'imageReference':
-            return {
-                type: 'imageReference',
-                identifier: node.identifier ?? '',
-                ...(node.label != null ? { label: node.label } : {}),
-                referenceType: (node.referenceType ?? 'full'),
-                ...(node.alt != null ? { alt: node.alt } : {}),
-                ...posField(pos),
-            };
-        case 'textDirective':
-            return {
-                type: 'textDirective',
-                name: node.name ?? '',
-                ...(node.attributes && Object.keys(node.attributes).length > 0
-                    ? { attributes: node.attributes }
-                    : {}),
-                children: convertInlineChildren(node.children ?? [], parseHtml),
-                ...posField(pos),
-            };
-        default:
-            if (typeof console !== 'undefined') {
-                console.warn(`[squisq/markdown] Unknown mdast inline node type: "${node.type}"`);
-            }
-            return null;
-    }
-}
-// ============================================
-// Squisq → mdast (toMdast)
-// ============================================
-/**
- * Convert a MarkdownDocument back to an mdast Root node.
- *
- * @param doc - A MarkdownDocument
- * @returns An mdast Root node suitable for remark-stringify
- */
-export function toMdast(doc) {
-    return {
-        type: 'root',
-        children: doc.children.map((n) => blockToMdast(n)),
-        ...mdastPosField(doc.position),
-    };
-}
-function blockToMdast(node) {
-    switch (node.type) {
-        case 'heading': {
-            const mdastChildren = inlineChildrenToMdast(node.children);
-            if (node.templateAnnotation) {
-                const suffix = serializeTemplateAnnotation(node.templateAnnotation);
-                // Append to last text node, or create a new one
-                const lastChild = mdastChildren[mdastChildren.length - 1];
-                if (lastChild && lastChild.type === 'text') {
-                    lastChild.value = (lastChild.value ?? '') + ' ' + suffix;
-                }
-                else {
-                    mdastChildren.push({ type: 'text', value: ' ' + suffix });
-                }
-            }
-            return {
-                type: 'heading',
-                depth: node.depth,
-                children: mdastChildren,
-                ...mdastPosField(node.position),
-            };
-        }
-        case 'paragraph':
-            return {
-                type: 'paragraph',
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'blockquote':
-            return {
-                type: 'blockquote',
-                children: node.children.map(blockToMdast),
-                ...mdastPosField(node.position),
-            };
-        case 'list':
-            return {
-                type: 'list',
-                ordered: node.ordered,
-                ...(node.start != null ? { start: node.start } : {}),
-                ...(node.spread != null ? { spread: node.spread } : {}),
-                children: node.children.map(listItemToMdast),
-                ...mdastPosField(node.position),
-            };
-        case 'code':
-            return {
-                type: 'code',
-                ...(node.lang != null ? { lang: node.lang } : {}),
-                ...(node.meta != null ? { meta: node.meta } : {}),
-                value: node.value,
-                ...mdastPosField(node.position),
-            };
-        case 'thematicBreak':
-            return {
-                type: 'thematicBreak',
-                ...mdastPosField(node.position),
-            };
-        case 'table':
-            return {
-                type: 'table',
-                ...(node.align ? { align: node.align } : {}),
-                children: node.children.map(tableRowToMdast),
-                ...mdastPosField(node.position),
-            };
-        case 'htmlBlock':
-            return {
-                type: 'html',
-                value: node.rawHtml,
-                ...mdastPosField(node.position),
-            };
-        case 'math':
-            return {
-                type: 'math',
-                value: node.value,
-                ...(node.meta != null ? { meta: node.meta } : {}),
-                ...mdastPosField(node.position),
-            };
-        case 'definition':
-            return {
-                type: 'definition',
-                identifier: node.identifier,
-                ...(node.label != null ? { label: node.label } : {}),
-                url: node.url,
-                ...(node.title != null ? { title: node.title } : {}),
-                ...mdastPosField(node.position),
-            };
-        case 'footnoteDefinition':
-            return {
-                type: 'footnoteDefinition',
-                identifier: node.identifier,
-                ...(node.label != null ? { label: node.label } : {}),
-                children: node.children.map(blockToMdast),
-                ...mdastPosField(node.position),
-            };
-        case 'containerDirective': {
-            const children = [];
-            // Reinject label as first paragraph with directiveLabel flag
-            if (node.label) {
-                children.push({
-                    type: 'paragraph',
-                    data: { directiveLabel: true },
-                    children: [{ type: 'text', value: node.label }],
-                });
-            }
-            children.push(...node.children.map(blockToMdast));
-            return {
-                type: 'containerDirective',
-                name: node.name,
-                ...(node.attributes ? { attributes: node.attributes } : {}),
-                children,
-                ...mdastPosField(node.position),
-            };
-        }
-        case 'leafDirective':
-            return {
-                type: 'leafDirective',
-                name: node.name,
-                ...(node.attributes ? { attributes: node.attributes } : {}),
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'definitionList':
-            // Definition lists don't map to standard mdast.
-            // Convert to HTML as fallback.
-            return {
-                type: 'html',
-                value: definitionListToHtml(node),
-                ...mdastPosField(node.position),
-            };
-        default:
-            return { type: 'html', value: '' };
-    }
-}
-function listItemToMdast(item) {
-    return {
-        type: 'listItem',
-        ...(item.checked != null ? { checked: item.checked } : {}),
-        ...(item.spread != null ? { spread: item.spread } : {}),
-        children: item.children.map(blockToMdast),
-        ...mdastPosField(item.position),
-    };
-}
-function tableRowToMdast(row) {
-    return {
-        type: 'tableRow',
-        children: row.children.map(tableCellToMdast),
-        ...mdastPosField(row.position),
-    };
-}
-function tableCellToMdast(cell) {
-    return {
-        type: 'tableCell',
-        children: inlineChildrenToMdast(cell.children),
-        ...mdastPosField(cell.position),
-    };
-}
-/**
- * Serialize an array of inline nodes to mdast, flat-mapping the result so
- * a single `mention` expands to two mdast nodes (`text('@')` + `link`).
- * Use in place of `.map(inlineToMdast)` wherever we walk a children array.
- */
-function inlineChildrenToMdast(nodes) {
-    const out = [];
-    for (const n of nodes) {
-        if (n.type === 'mention') {
-            out.push({ type: 'text', value: '@' });
-            out.push({
-                type: 'link',
-                url: `${n.targetKind}:${n.targetId}`,
-                children: [{ type: 'text', value: n.displayName }],
-                ...mdastPosField(n.position),
-            });
-        }
-        else {
-            out.push(inlineToMdast(n));
-        }
-    }
-    return out;
-}
-function inlineToMdast(node) {
-    switch (node.type) {
-        case 'text':
-            return {
-                type: 'text',
-                value: node.value,
-                ...mdastPosField(node.position),
-            };
-        case 'emphasis':
-            return {
-                type: 'emphasis',
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'strong':
-            return {
-                type: 'strong',
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'delete':
-            return {
-                type: 'delete',
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'inlineCode':
-            return {
-                type: 'inlineCode',
-                value: node.value,
-                ...mdastPosField(node.position),
-            };
-        case 'link':
-            return {
-                type: 'link',
-                url: node.url,
-                ...(node.title != null ? { title: node.title } : {}),
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'image':
-            return {
-                type: 'image',
-                url: node.url,
-                ...(node.alt != null ? { alt: node.alt } : {}),
-                ...(node.title != null ? { title: node.title } : {}),
-                ...mdastPosField(node.position),
-            };
-        case 'break':
-            return {
-                type: 'break',
-                ...mdastPosField(node.position),
-            };
-        case 'htmlInline':
-            return {
-                type: 'html',
-                value: node.rawHtml,
-                ...mdastPosField(node.position),
-            };
-        case 'inlineMath':
-            return {
-                type: 'inlineMath',
-                value: node.value,
-                ...mdastPosField(node.position),
-            };
-        case 'footnoteReference':
-            return {
-                type: 'footnoteReference',
-                identifier: node.identifier,
-                ...(node.label != null ? { label: node.label } : {}),
-                ...mdastPosField(node.position),
-            };
-        case 'linkReference':
-            return {
-                type: 'linkReference',
-                identifier: node.identifier,
-                ...(node.label != null ? { label: node.label } : {}),
-                referenceType: node.referenceType,
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'imageReference':
-            return {
-                type: 'imageReference',
-                identifier: node.identifier,
-                ...(node.label != null ? { label: node.label } : {}),
-                referenceType: node.referenceType,
-                ...(node.alt != null ? { alt: node.alt } : {}),
-                ...mdastPosField(node.position),
-            };
-        case 'textDirective':
-            return {
-                type: 'textDirective',
-                name: node.name,
-                ...(node.attributes ? { attributes: node.attributes } : {}),
-                children: inlineChildrenToMdast(node.children),
-                ...mdastPosField(node.position),
-            };
-        case 'mention':
-            // Fallback: when `inlineToMdast` is called directly (not via
-            // `inlineChildrenToMdast`), collapse the mention to just the link
-            // form. The `@` prefix is lost, but the id+name still round-trip.
-            // Normal call sites go through `inlineChildrenToMdast` and get
-            // the proper text('@') + link pair.
-            return {
-                type: 'link',
-                url: `${node.targetKind}:${node.targetId}`,
-                children: [{ type: 'text', value: node.displayName }],
-                ...mdastPosField(node.position),
-            };
-        case 'inlineIcon':
-            // Serialize back to the authored token so source round-trips
-            // byte-stable. The token already carries the qualified form when
-            // required (the parser preserved it verbatim).
-            return {
-                type: 'text',
-                value: `{[${node.token}]}`,
-                ...mdastPosField(node.position),
-            };
-        default:
-            return { type: 'text', value: '' };
-    }
-}
-// ============================================
-// Helpers
-// ============================================
-/**
- * Convert a MarkdownDefinitionList to an HTML <dl> string.
- * Fallback for serialization since mdast doesn't support definition lists.
- */
-function definitionListToHtml(list) {
-    let html = '<dl>\n';
-    for (const child of list.children) {
-        if (child.type === 'definitionTerm') {
-            // Extract plain text from inline children
-            const text = child.children
-                .map((c) => c.value ?? '')
-                .join('');
-            html += `  <dt>${text}</dt>\n`;
-        }
-        else if (child.type === 'definitionDescription') {
-            html += `  <dd>...</dd>\n`;
-        }
-    }
-    html += '</dl>';
-    return html;
-}
-//# sourceMappingURL=convert.js.map