@dogsbay/format-dita 0.2.0-beta.101

package/dist/blocks.js

@@ -0,0 +1,734 @@
+import { convertInline, trimInline, textOf, inlineSafeSnippet, conrefLedgerDetail, } from "./inline.js";
+const isElement = (node) => node.type === "tag";
+const isNonEmptyText = (node) => node.type === "text" && node.data.trim().length > 0;
+/** DITA note @type → callout type in the dogsbay-md vocabulary. */
+const NOTE_TYPE_MAP = {
+    note: "note",
+    tip: "tip",
+    important: "important",
+    warning: "warning",
+    caution: "warning",
+    danger: "danger",
+    attention: "warning",
+    remember: "note",
+    restriction: "important",
+    trouble: "warning",
+};
+/** Containers whose children are spliced through without a wrapper node. */
+const TRANSPARENT_CONTAINERS = new Set([
+    "body", "conbody", "refbody", "taskbody", "glossdef", "abstract", "bodydiv", "sectiondiv", "div",
+]);
+/** Children that carry no content — a conref shell with only these is empty. */
+const METADATA_ONLY = new Set(["indexterm", "data", "draft-comment", "sort-as", "topicmeta"]);
+const hasOwnContent = (el) => el.children.some((c) => (isElement(c) && !METADATA_ONLY.has(c.name.toLowerCase())) || isNonEmptyText(c));
+/** '--' is illegal inside HTML comments (and '-->' would close early). */
+const sanitizeCommentRef = (ref) => String(ref).replace(/-(?=-)/g, "- ");
+const anchorHtml = (id) => `<a id="${id.replace(/"/g, "&quot;")}"></a>`;
+/**
+ * The include directive for a snippet, wrapped in a scoped leveloffset
+ * when the snippet carries headings and the site's heading depth differs
+ * from the snippet's baked-in base level.
+ */
+export const includeDirective = (snippet, site, headingLevel) => {
+    const include = `{% include "${site.includePath(snippet)}" %}`;
+    if (snippet.headingBase !== undefined && headingLevel !== snippet.headingBase) {
+        const delta = headingLevel - snippet.headingBase;
+        return `{% leveloffset ${delta >= 0 ? "+" : ""}${delta} %}${include}{% endleveloffset %}`;
+    }
+    return include;
+};
+const withProvenance = (node, el) => {
+    const id = el.attribs?.id;
+    if (id) {
+        node.meta = { ...(node.meta ?? {}), dita: { id } };
+    }
+    return node;
+};
+const noteFilterAttrs = (el, ctx) => {
+    for (const attr of ["audience", "platform", "product", "props", "otherprops", "rev"]) {
+        if (el.attribs?.[attr]) {
+            ctx.note(`@${attr}`, `<${el.name}> ${attr}="${el.attribs[attr]}" — map to a profile condition (ifdef) manually`);
+        }
+    }
+};
+const paragraphFrom = (nodes, ctx) => {
+    const inline = trimInline(convertInline(nodes, ctx));
+    if (inline.length === 0)
+        return null;
+    return { type: "paragraph", inline };
+};
+/**
+ * <li>/<entry>/<p>-style mixed content: a leading inline run, block
+ * children, and any inline runs BETWEEN or AFTER blocks (text and inline
+ * elements alike) wrapped as paragraphs — nothing is dropped.
+ */
+const mixedContent = (el, ctx) => {
+    const blockNodes = [];
+    let leadingInline;
+    let sawBlock = false;
+    let run = [];
+    const flushRun = () => {
+        if (run.length === 0)
+            return;
+        const inline = trimInline(convertInline(run, ctx));
+        run = [];
+        if (inline.length === 0)
+            return;
+        if (!sawBlock) {
+            leadingInline = inline;
+        }
+        else {
+            blockNodes.push({ type: "paragraph", inline });
+        }
+    };
+    for (const child of el.children) {
+        if (isElement(child) && BLOCK_ELEMENTS.has(child.name.toLowerCase())) {
+            flushRun();
+            sawBlock = true;
+            blockNodes.push(...convertBlock(child, ctx));
+            continue;
+        }
+        if (isElement(child) || isNonEmptyText(child)) {
+            run.push(child);
+        }
+    }
+    flushRun();
+    return { inline: leadingInline, children: blockNodes };
+};
+/**
+ * Fallback-content check for item-level conref shells. Unlike blocks,
+ * items routinely carry DTD-required empty children (`<step conref>
+ * <cmd/></step>`), which are placeholders, not fallback content.
+ */
+const itemHasFallback = (el) => el.children.some((c) => (isElement(c) &&
+    !METADATA_ONLY.has(c.name.toLowerCase()) &&
+    (c.name.toLowerCase() !== "cmd" || hasOwnContent(c))) ||
+    isNonEmptyText(c));
+/**
+ * conref on a list item / step / substep / choice — these elements never
+ * pass through convertBlock, so without this hook a `<step conref=…/>`
+ * converted to an EMPTY step with no ledger note (silent loss). Item
+ * bodies serialize indented, so only single-line snippets can splice;
+ * everything else lands on the ledger, with a source-visible placeholder
+ * when the item has no fallback content.
+ */
+const itemConref = (el, ctx, type) => {
+    if (!el.attribs?.conref && !el.attribs?.conkeyref)
+        return null;
+    const name = el.name.toLowerCase();
+    const snippet = el.attribs.conref && !el.attribs.conrefend && !el.attribs.conaction
+        ? ctx.conref?.resolve(el.attribs.conref)
+        : undefined;
+    if (snippet && inlineSafeSnippet(snippet)) {
+        return {
+            type,
+            inline: [{ type: "text", text: `{% include "${ctx.conref.includePath(snippet)}" %}` }],
+        };
+    }
+    const ref = el.attribs.conref ?? el.attribs.conkeyref;
+    ctx.note(el.attribs.conref ? "@conref" : "@conkeyref", `<${name}> pulls content from "${ref}" — ${conrefLedgerDetail(el.attribs, snippet, ctx.conref !== undefined)}`);
+    if (itemHasFallback(el))
+        return null;
+    return {
+        type,
+        children: [
+            {
+                type: "html",
+                html: `<!-- TODO(dita-${el.attribs.conref ? "conref" : "conkeyref"}): include ${sanitizeCommentRef(ref)} -->`,
+            },
+        ],
+    };
+};
+/**
+ * conref on a line-constrained PART (<cmd>, <dt>, <dd>, table cells,
+ * titles) — content that must land on a single output line. Returns the
+ * include as an inline run when the snippet can splice; ledgers and
+ * returns null otherwise; undefined when the part has no conref at all.
+ */
+const constrainedConrefInline = (el, ctx) => {
+    if (!el.attribs?.conref && !el.attribs?.conkeyref)
+        return undefined;
+    const snippet = el.attribs.conref && !el.attribs.conrefend && !el.attribs.conaction
+        ? ctx.conref?.resolve(el.attribs.conref)
+        : undefined;
+    if (snippet && inlineSafeSnippet(snippet)) {
+        return [{ type: "text", text: `{% include "${ctx.conref.includePath(snippet)}" %}` }];
+    }
+    const ref = el.attribs.conref ?? el.attribs.conkeyref;
+    ctx.note(el.attribs.conref ? "@conref" : "@conkeyref", `<${el.name.toLowerCase()}> pulls content from "${ref}" — ${conrefLedgerDetail(el.attribs, snippet, ctx.conref !== undefined)}`);
+    return null;
+};
+/**
+ * Defining site for an extracted ITEM (<li>/<step>/<sli>): items never
+ * pass through convertBlock, so without this hook the warehouse item
+ * would keep its full text next to the snippet — two divergent copies.
+ * Single-line snippets replace the item; multi-line ones are ledgered
+ * (content kept) so the duplication is at least never silent.
+ */
+const definingItemNode = (el, ctx, type) => {
+    if (!ctx.conref || !el.attribs?.id || el.attribs?.conref || el.attribs?.conkeyref)
+        return null;
+    const snippet = ctx.conref.definingSnippet(el.attribs.id);
+    if (!snippet)
+        return null;
+    if (inlineSafeSnippet(snippet)) {
+        return {
+            type,
+            inline: [{ type: "text", text: `{% include "${ctx.conref.includePath(snippet)}" %}` }],
+        };
+    }
+    ctx.note("@conref", `<${el.name.toLowerCase()} id="${el.attribs.id}"> is reused elsewhere via "${snippet.file}" but its content is multi-line — replace it with the include manually to keep one copy`);
+    return null;
+};
+const convertListItems = (el, ctx, itemTag) => el.children
+    .filter((c) => isElement(c) && c.name.toLowerCase() === itemTag)
+    .map((li) => {
+    const viaConref = itemConref(li, ctx, "list-item") ?? definingItemNode(li, ctx, "list-item");
+    if (viaConref)
+        return withProvenance(viaConref, li);
+    const { inline, children } = mixedContent(li, { ...ctx, constrained: true });
+    const item = { type: "list-item" };
+    if (inline)
+        item.inline = inline;
+    if (children.length > 0)
+        item.children = children;
+    return withProvenance(item, li);
+});
+const convertDefList = (el, ctx, tags = { entry: "dlentry", term: "dt", def: "dd" }) => {
+    const children = [];
+    for (const entry of el.children.filter(isElement)) {
+        if (entry.name.toLowerCase() !== tags.entry)
+            continue;
+        // Entry-level conref (<dlentry conref>): a term/definition pair can't
+        // splice as an include — ledger it so the loss is never silent
+        if (entry.attribs?.conref || entry.attribs?.conkeyref) {
+            const ref = entry.attribs.conref ?? entry.attribs.conkeyref;
+            ctx.note(entry.attribs.conref ? "@conref" : "@conkeyref", `<${tags.entry}> pulls content from "${ref}" — ${conrefLedgerDetail(entry.attribs, undefined, ctx.conref !== undefined)}`);
+        }
+        for (const part of entry.children.filter(isElement)) {
+            const name = part.name.toLowerCase();
+            if (name === tags.term) {
+                // Term-level conref (<dt conref>/<pt conref>): single-line
+                // include or ledger — never a silent empty term
+                const viaConref = constrainedConrefInline(part, ctx);
+                children.push({
+                    type: "dt",
+                    inline: viaConref ?? trimInline(convertInline(part.children, ctx)),
+                });
+            }
+            else if (name === tags.def) {
+                const viaConref = constrainedConrefInline(part, ctx);
+                if (viaConref) {
+                    children.push({ type: "dd", inline: viaConref });
+                    continue;
+                }
+                const { inline, children: blocks } = mixedContent(part, { ...ctx, constrained: true });
+                const dd = { type: "dd" };
+                if (inline)
+                    dd.inline = inline;
+                if (blocks.length > 0)
+                    dd.children = blocks;
+                children.push(dd);
+            }
+        }
+    }
+    return { type: "deflist", children };
+};
+/** CALS <table> and <simpletable> → table/tr/td tree. */
+const convertTable = (el, ctx) => {
+    const rows = [];
+    const headRows = [];
+    const convertRow = (rowEl, cellTags) => {
+        // Row-level conref: a whole row can't splice as an include — ledger it
+        if (rowEl.attribs?.conref || rowEl.attribs?.conkeyref) {
+            const ref = rowEl.attribs.conref ?? rowEl.attribs.conkeyref;
+            ctx.note(rowEl.attribs.conref ? "@conref" : "@conkeyref", `<${rowEl.name.toLowerCase()}> pulls content from "${ref}" — ${conrefLedgerDetail(rowEl.attribs, undefined, ctx.conref !== undefined)}`);
+        }
+        const cells = rowEl.children
+            .filter((c) => isElement(c) && cellTags.has(c.name.toLowerCase()))
+            .map((cellEl) => {
+            for (const attr of ["namest", "nameend", "morerows"]) {
+                if (cellEl.attribs?.[attr]) {
+                    ctx.note(`@${attr}`, "table cell spans are not converted — cell emitted without span");
+                }
+            }
+            // Cell-level conref: single-line snippets splice as an inline
+            // include; anything else is ledgered
+            const cellConref = constrainedConrefInline(cellEl, ctx);
+            if (cellConref) {
+                return {
+                    type: "td",
+                    children: [{ type: "paragraph", inline: cellConref }],
+                };
+            }
+            // Cell content always lives in children (leading inline wrapped as a
+            // paragraph): the serializer's HTML-table path reads only children,
+            // and its pipe path reads children paragraphs too
+            const { inline, children } = mixedContent(cellEl, { ...ctx, constrained: true });
+            const cellChildren = [];
+            if (inline)
+                cellChildren.push({ type: "paragraph", inline });
+            cellChildren.push(...children);
+            const cell = { type: "td" };
+            if (cellChildren.length > 0)
+                cell.children = cellChildren;
+            return cell;
+        });
+        return { type: "tr", children: cells };
+    };
+    const CALS_CELLS = new Set(["entry"]);
+    const SIMPLE_CELLS = new Set(["stentry"]);
+    const CHOICE_HEAD_CELLS = new Set(["choptionhd", "chdeschd"]);
+    const CHOICE_ROW_CELLS = new Set(["choption", "chdesc"]);
+    const walk = (node) => {
+        for (const child of node.children.filter(isElement)) {
+            const name = child.name.toLowerCase();
+            // Row-set reuse (conref on tgroup/thead/tbody) can't splice into a
+            // markdown table — ledger it so the pulled rows are never silently
+            // an empty table body
+            if ((name === "tgroup" || name === "thead" || name === "tbody") &&
+                (child.attribs?.conref || child.attribs?.conkeyref)) {
+                const ref = child.attribs.conref ?? child.attribs.conkeyref;
+                ctx.note(child.attribs.conref ? "@conref" : "@conkeyref", `<${name}> pulls content from "${ref}" — ${conrefLedgerDetail(child.attribs, undefined, ctx.conref !== undefined)}`);
+            }
+            if (name === "tgroup")
+                walk(child);
+            else if (name === "thead") {
+                for (const row of child.children.filter(isElement)) {
+                    if (row.name.toLowerCase() === "row")
+                        headRows.push(convertRow(row, CALS_CELLS));
+                }
+            }
+            else if (name === "tbody") {
+                for (const row of child.children.filter(isElement)) {
+                    if (row.name.toLowerCase() === "row")
+                        rows.push(convertRow(row, CALS_CELLS));
+                }
+            }
+            else if (name === "sthead") {
+                headRows.push(convertRow(child, SIMPLE_CELLS));
+            }
+            else if (name === "strow") {
+                rows.push(convertRow(child, SIMPLE_CELLS));
+            }
+            else if (name === "chhead") {
+                headRows.push(convertRow(child, CHOICE_HEAD_CELLS));
+            }
+            else if (name === "chrow") {
+                rows.push(convertRow(child, CHOICE_ROW_CELLS));
+            }
+            else if (name === "colspec") {
+                // Column widths are presentation-only; dropped silently
+            }
+            else if (name === "title") {
+                // handled below via caption
+            }
+        }
+    };
+    walk(el);
+    const table = {
+        type: "table",
+        children: [
+            ...(headRows.length > 0 ? [{ type: "thead", children: headRows }] : []),
+            { type: "tbody", children: rows },
+        ],
+    };
+    const titleEl = el.children
+        .filter(isElement)
+        .find((c) => c.name.toLowerCase() === "title");
+    if (titleEl) {
+        // Caption is a plain-string prop — a conref'd title can't carry an
+        // include directive, so ledger it instead of emitting empty text
+        if (titleEl.attribs?.conref || titleEl.attribs?.conkeyref) {
+            const ref = titleEl.attribs.conref ?? titleEl.attribs.conkeyref;
+            ctx.note(titleEl.attribs.conref ? "@conref" : "@conkeyref", `<title> (table caption) pulls content from "${ref}" — ${conrefLedgerDetail(titleEl.attribs, undefined, ctx.conref !== undefined)}`);
+        }
+        table.props = { caption: textOf(titleEl.children).trim() };
+    }
+    return table;
+};
+/**
+ * One <step>/<substep>'s content: <cmd> as the leading inline run, the
+ * rest as block children. Shared by convertSteps (constrained context)
+ * and conref snippet extraction (standalone, unconstrained).
+ */
+export const convertStepContent = (stepEl, ctx) => {
+    let stepInline;
+    const blocks = [];
+    for (const part of stepEl.children.filter(isElement)) {
+        const name = part.name.toLowerCase();
+        if (name === "cmd") {
+            // <cmd conref=…/> is the standard reused-command pattern: include
+            // when spliceable, ledger otherwise — never a silent empty step
+            const viaConref = constrainedConrefInline(part, ctx);
+            if (viaConref) {
+                stepInline = viaConref;
+                continue;
+            }
+            stepInline = trimInline(convertInline(part.children, ctx));
+        }
+        else if (name === "info" || name === "stepresult" || name === "stepxmp" || name === "steptroubleshooting") {
+            const { inline, children: inner } = mixedContent(part, ctx);
+            if (inline)
+                blocks.push({ type: "paragraph", inline });
+            blocks.push(...inner);
+        }
+        else if (name === "substeps") {
+            blocks.push(convertSteps(part, ctx, "substeps"));
+        }
+        else if (name === "choices" || name === "choicetable") {
+            ctx.note(`<${name}>`, "step choices converted as a plain list/table");
+            blocks.push(...convertBlock(part, ctx));
+        }
+        else {
+            blocks.push(...convertBlock(part, ctx));
+        }
+    }
+    return { inline: stepInline, children: blocks };
+};
+/** Task <steps>/<substeps> → steps/substeps nodes with step children. */
+const convertSteps = (el, ctx, type) => {
+    const stepTag = type === "steps" ? "step" : "substep";
+    const children = el.children
+        .filter((c) => isElement(c) && c.name.toLowerCase() === stepTag)
+        .map((stepEl) => {
+        const viaConref = itemConref(stepEl, ctx, "step") ?? definingItemNode(stepEl, ctx, "step");
+        if (viaConref)
+            return withProvenance(viaConref, stepEl);
+        const { inline, children: blocks } = convertStepContent(stepEl, { ...ctx, constrained: true });
+        const step = { type: "step" };
+        if (inline)
+            step.inline = inline;
+        if (blocks.length > 0)
+            step.children = blocks;
+        return withProvenance(step, stepEl);
+    });
+    return { type, children };
+};
+/**
+ * Standalone content of an item-level element (<li>, <step>, …) for
+ * conref snippet extraction: leading inline as a paragraph, block
+ * children after.
+ */
+export const convertItemContent = (el, ctx) => {
+    const name = el.name.toLowerCase();
+    const { inline, children } = name === "step" || name === "substep" ? convertStepContent(el, ctx) : mixedContent(el, ctx);
+    const out = [];
+    if (inline && inline.length > 0)
+        out.push({ type: "paragraph", inline });
+    out.push(...children);
+    return out;
+};
+/** Task sections that render as a heading + content. */
+const TASK_SECTION_HEADINGS = {
+    prereq: "Before you begin",
+    result: "Result",
+    postreq: "What to do next",
+    tasktroubleshooting: "Troubleshooting",
+};
+/** Block-level DITA elements (used to split mixed content). */
+const BLOCK_ELEMENTS = new Set([
+    "p", "shortdesc", "note", "codeblock", "pre", "screen", "msgblock", "ul", "ol", "sl", "dl", "parml", "table", "simpletable",
+    "fig", "image", "section", "example", "steps", "steps-unordered", "substeps", "lq", "object",
+    "prereq", "context", "result", "postreq", "tasktroubleshooting", "choices", "choicetable",
+]);
+/** Whether an element name converts as a standalone block (conref-extractable). */
+export const isBlockTarget = (name) => BLOCK_ELEMENTS.has(name);
+export function convertBlock(el, ctx) {
+    const name = el.name.toLowerCase();
+    noteFilterAttrs(el, ctx);
+    // Defining site: this element was extracted into a reuse snippet — emit
+    // the include here too, so exactly ONE copy of the text survives
+    // migration (the DITA warehouse copy and every referent share the
+    // snippet). The element's @id must survive as a real anchor unless the
+    // snippet itself renders one (section/example heading {#id}).
+    if (ctx.conref && el.attribs?.id && !el.attribs?.conref && !el.attribs?.conkeyref) {
+        const defining = ctx.conref.definingSnippet(el.attribs.id);
+        if (defining && (!ctx.constrained || inlineSafeSnippet(defining))) {
+            const anchor = defining.carriesAnchor ? "" : anchorHtml(el.attribs.id);
+            return [
+                withProvenance({ type: "html", html: `${anchor}${includeDirective(defining, ctx.conref, ctx.headingLevel)}` }, el),
+            ];
+        }
+        if (defining) {
+            ctx.note("@conref", `<${name} id="${el.attribs.id}"> is reused elsewhere via "${defining.file}" but sits in a list/step/table cell — replace its content with the include manually`);
+        }
+    }
+    if (el.attribs?.conref || el.attribs?.conkeyref) {
+        const ref = el.attribs.conref ?? el.attribs.conkeyref;
+        const snippet = el.attribs.conref && !el.attribs.conrefend && !el.attribs.conaction
+            ? ctx.conref?.resolve(el.attribs.conref)
+            : undefined;
+        if (snippet && (!ctx.constrained || inlineSafeSnippet(snippet))) {
+            // Local children are the stale preview copy in DITA conref
+            // semantics — the include replaces the whole element. The
+            // referencing element's own @id (if any) still needs an anchor:
+            // links may target the referencing shell, not the snippet source.
+            const anchor = el.attribs?.id ? anchorHtml(el.attribs.id) : "";
+            return [
+                withProvenance({ type: "html", html: `${anchor}${includeDirective(snippet, ctx.conref, ctx.headingLevel)}` }, el),
+            ];
+        }
+        ctx.note(el.attribs.conref ? "@conref" : "@conkeyref", `<${name}> pulls content from "${ref}" — ${conrefLedgerDetail(el.attribs, snippet, ctx.conref !== undefined)}`);
+        // Content-less conref shells would render as empty blocks (an empty
+        // callout, an empty paragraph). Emit a visible source-level placeholder
+        // instead: invisible when rendered, obvious to the migrating writer.
+        // Metadata-only children (indexterm, data, …) convert to nothing, so
+        // they don't count as content; the @id (if any) must survive as both
+        // provenance and a real anchor, since links may target the shell.
+        if (!hasOwnContent(el)) {
+            const anchor = el.attribs?.id ? anchorHtml(el.attribs.id) : "";
+            return [
+                withProvenance({
+                    type: "html",
+                    html: `${anchor}<!-- TODO(dita-${el.attribs.conref ? "conref" : "conkeyref"}): include ${sanitizeCommentRef(ref)} -->`,
+                }, el),
+            ];
+        }
+    }
+    if (TRANSPARENT_CONTAINERS.has(name)) {
+        return convertChildren(el, ctx);
+    }
+    switch (name) {
+        case "p":
+        case "shortdesc": {
+            // DITA allows blocks (ul, note, pre, …) inside <p>: leading inline
+            // becomes the paragraph, block children follow as siblings
+            const { inline, children } = mixedContent(el, ctx);
+            const out = [];
+            if (inline)
+                out.push({ type: "paragraph", inline });
+            out.push(...children);
+            if (out.length > 0 && name === "p")
+                withProvenance(out[0], el);
+            return out;
+        }
+        case "note": {
+            const type = NOTE_TYPE_MAP[el.attribs?.type ?? "note"] ?? "note";
+            if (el.attribs?.type && !NOTE_TYPE_MAP[el.attribs.type]) {
+                ctx.note("@type", `<note type="${el.attribs.type}"> mapped to plain note callout`);
+            }
+            // Callouts serialize in the GitHub `> [!TYPE]` per-line-prefixed
+            // form — a constrained context for includes
+            const { inline, children } = mixedContent(el, { ...ctx, constrained: true });
+            const body = [];
+            if (inline)
+                body.push({ type: "paragraph", inline });
+            body.push(...children);
+            return [withProvenance({ type: "callout", props: { type }, children: body }, el)];
+        }
+        case "codeblock":
+        case "pre":
+        case "screen":
+        case "msgblock": {
+            const language = el.attribs?.outputclass ?? "";
+            const content = textOf(el.children).replace(/^\n/, "").replace(/\s+$/, "");
+            // Content in BOTH html and props.code: the serializer's block path
+            // reads html, its HTML-table path (code inside cells) reads props.code
+            const node = {
+                type: "code",
+                html: content,
+                props: { code: content, ...(language ? { language } : {}) },
+            };
+            return [withProvenance(node, el)];
+        }
+        case "ul":
+            return [withProvenance({ type: "unordered-list", children: convertListItems(el, ctx, "li") }, el)];
+        case "ol":
+            return [withProvenance({ type: "ordered-list", children: convertListItems(el, ctx, "li") }, el)];
+        case "sl": {
+            // Simple list → unordered list of <sli> items (same conref hooks
+            // as <li>: referencing items include or ledger, defining items
+            // hand their text to the snippet)
+            const items = el.children
+                .filter((c) => isElement(c) && c.name.toLowerCase() === "sli")
+                .map((sli) => {
+                const viaConref = itemConref(sli, ctx, "list-item") ?? definingItemNode(sli, ctx, "list-item");
+                if (viaConref)
+                    return withProvenance(viaConref, sli);
+                const inline = trimInline(convertInline(sli.children, ctx));
+                return { type: "list-item", ...(inline.length > 0 ? { inline } : {}) };
+            });
+            return [withProvenance({ type: "unordered-list", children: items }, el)];
+        }
+        case "dl":
+            return [withProvenance(convertDefList(el, ctx), el)];
+        case "parml":
+            // Parameter list — structurally a definition list
+            return [withProvenance(convertDefList(el, ctx, { entry: "plentry", term: "pt", def: "pd" }), el)];
+        case "table":
+        case "simpletable":
+            return [withProvenance(convertTable(el, ctx), el)];
+        case "fig": {
+            const titleEl = el.children
+                .filter(isElement)
+                .find((c) => c.name.toLowerCase() === "title");
+            const imageEl = el.children
+                .filter(isElement)
+                .find((c) => c.name.toLowerCase() === "image");
+            if (imageEl) {
+                const figure = {
+                    type: "figure",
+                    children: [
+                        {
+                            type: "image",
+                            props: {
+                                src: imageEl.attribs?.href ?? "",
+                                alt: imageEl.attribs?.alt ??
+                                    textOf(imageEl.children).trim() ??
+                                    "",
+                            },
+                        },
+                    ],
+                    ...(titleEl
+                        ? { props: { caption: textOf(titleEl.children).trim() } }
+                        : {}),
+                };
+                return [withProvenance(figure, el)];
+            }
+            // fig without image: treat as transparent container (keep the title as bold para)
+            const parts = [];
+            if (titleEl) {
+                parts.push({
+                    type: "paragraph",
+                    inline: [{ type: "text", text: textOf(titleEl.children).trim(), bold: true }],
+                });
+            }
+            parts.push(...convertChildren(el, ctx, new Set(["title"])));
+            return parts;
+        }
+        case "image": {
+            const src = el.attribs?.href;
+            if (!src) {
+                // Same contract as the inline path: no silent src:"" images
+                if (el.attribs?.keyref) {
+                    ctx.note("@keyref", `<image keyref="${el.attribs.keyref}"/> — key-based images cannot be resolved at conversion; insert the image manually`);
+                }
+                else {
+                    ctx.note("<image>", "image without href dropped");
+                }
+                return [];
+            }
+            const node = {
+                type: "image",
+                props: {
+                    src,
+                    alt: el.attribs?.alt ?? textOf(el.children).trim(),
+                },
+            };
+            return [withProvenance(node, el)];
+        }
+        case "section":
+        case "example": {
+            const out = [];
+            const titleEl = el.children
+                .filter(isElement)
+                .find((c) => c.name.toLowerCase() === "title");
+            if (titleEl) {
+                // <title conref=…/> — heading text pulled from elsewhere
+                const titleConref = constrainedConrefInline(titleEl, ctx);
+                out.push(withProvenance({
+                    type: "heading",
+                    // @id also as props.id so the serializer emits a {#id} anchor —
+                    // cross-topic xref fragments (renamed to #elementid) must land
+                    props: {
+                        level: ctx.headingLevel,
+                        ...(el.attribs?.id ? { id: el.attribs.id } : {}),
+                    },
+                    inline: titleConref ?? trimInline(convertInline(titleEl.children, ctx)),
+                }, el));
+            }
+            else if (name === "example") {
+                out.push({
+                    type: "heading",
+                    props: { level: ctx.headingLevel },
+                    inline: [{ type: "text", text: "Example" }],
+                });
+            }
+            const inner = { ...ctx, headingLevel: Math.min(6, ctx.headingLevel + 1) };
+            out.push(...convertChildren(el, inner, new Set(["title"])));
+            return out;
+        }
+        case "steps":
+        case "steps-unordered":
+            return [withProvenance(convertSteps(el, ctx, "steps"), el)];
+        case "substeps":
+            return [withProvenance(convertSteps(el, ctx, "substeps"), el)];
+        case "context":
+            return convertChildren(el, ctx);
+        case "prereq":
+        case "result":
+        case "postreq":
+        case "tasktroubleshooting": {
+            const heading = {
+                type: "heading",
+                props: { level: ctx.headingLevel },
+                inline: [{ type: "text", text: TASK_SECTION_HEADINGS[name] }],
+            };
+            return [heading, ...convertChildren(el, ctx)];
+        }
+        case "choices":
+            return [{ type: "unordered-list", children: convertListItems(el, ctx, "choice") }];
+        case "choicetable":
+            return [withProvenance(convertTable(el, ctx), el)];
+        case "lq": {
+            // Blockquotes serialize `> `-prefixed — constrained for includes
+            const { inline, children } = mixedContent(el, { ...ctx, constrained: true });
+            const body = [];
+            if (inline)
+                body.push({ type: "paragraph", inline });
+            body.push(...children);
+            return [{ type: "blockquote", children: body }];
+        }
+        case "title":
+            // Titles are handled by their parents (topic/section/fig/table)
+            return [];
+        case "prolog":
+        case "related-links":
+            ctx.note(`<${name}>`, "metadata/related-links dropped — links belong in the topic map (reltable design pending)");
+            return [];
+        case "draft-comment":
+        case "data":
+        case "indexterm":
+            return [];
+        default: {
+            // Unknown block: convert children if any survive, note the loss
+            const children = convertChildren(el, ctx);
+            ctx.note(`<${name}>`, children.length > 0
+                ? "unrecognized block element — children kept, wrapper dropped"
+                : "unrecognized block element dropped");
+            return children;
+        }
+    }
+}
+export function convertChildren(el, ctx, skip = new Set()) {
+    const out = [];
+    let inlineRun = [];
+    const flushInline = () => {
+        const para = paragraphFrom(inlineRun, ctx);
+        if (para)
+            out.push(para);
+        inlineRun = [];
+    };
+    for (const child of el.children) {
+        if (isElement(child)) {
+            const name = child.name.toLowerCase();
+            if (skip.has(name))
+                continue;
+            if (BLOCK_ELEMENTS.has(name) || TRANSPARENT_CONTAINERS.has(name) || name === "title" ||
+                name === "prolog" || name === "related-links" || name === "draft-comment") {
+                flushInline();
+                out.push(...convertBlock(child, ctx));
+                continue;
+            }
+            // Inline element loose in a body: accumulate into a paragraph
+            inlineRun.push(child);
+        }
+        else if (isNonEmptyText(child)) {
+            inlineRun.push(child);
+        }
+    }
+    flushInline();
+    return out;
+}
+//# sourceMappingURL=blocks.js.map