@mantra-ai/core 0.1.0

package/dist/normalization/jats/utils/collectors/back.js

@@ -0,0 +1,801 @@
+import { poText } from "../po/text";
+import { poChildren } from "../po/nodes";
+import { poSerialize } from "../po/serialize";
+import { poSerializeMinimal } from "../po/serialize";
+import { poFindFirstByLocal } from "../po/query";
+import { poFindDescendantsByLocal } from "../po/query";
+import { poGetAttr } from "../po/nodes";
+import { poIsTextNode, poTagName, poMatchesLocal } from "../po/nodes";
+import { asString } from "../strings";
+import { getText } from "../xml";
+import { normalizeArray } from "../strings";
+import { nsArray } from "../xml";
+import { cleanHeading } from "../strings";
+import { poFindSectionById } from "../po/query";
+import { poCollectSectionTexts } from "../po/text";
+import { collectSectionNode } from "./sections";
+import { classifySection } from "../category";
+export function collectAckRich(back, domPO) {
+    const out = { text: [] };
+    const pushText = (s) => {
+        if (s && s.trim())
+            out.text.push(s.trim());
+    };
+    const pushXml = (pNode) => {
+        const t = poText(poChildren(pNode)) || poText(pNode);
+        if (t && t.trim())
+            out.text.push(t.trim());
+        const x = poSerialize(pNode);
+        if (x && x.trim())
+            (out.xml = out.xml || []).push(x);
+        const xm = poSerializeMinimal(pNode);
+        if (xm && xm.trim())
+            (out.xml_minimal = out.xml_minimal || []).push(xm);
+    };
+    // PO path: prefer preserveOrder for accurate inline content
+    if (domPO) {
+        const backPO = poFindFirstByLocal(domPO, "back");
+        if (backPO) {
+            for (const ackPO of poFindDescendantsByLocal(backPO, "ack")) {
+                // Capture ack title when present
+                const tnode = poFindFirstByLocal(ackPO, "title") ||
+                    poFindFirstByLocal(ackPO, "label");
+                const t = (tnode && (poText(poChildren(tnode)) || poText(tnode))) || undefined;
+                if (t && !out.title)
+                    out.title = t;
+                const pNodes = poFindDescendantsByLocal(ackPO, "p");
+                if (pNodes.length) {
+                    for (const p of pNodes)
+                        pushXml(p);
+                }
+                else {
+                    const t = poText(poChildren(ackPO)) || poText(ackPO);
+                    pushText(t || undefined);
+                }
+            }
+            // Also consider back > sec[@sec-type contains 'ack']
+            for (const secPO of poFindDescendantsByLocal(backPO, "sec")) {
+                const secType = (poGetAttr(secPO, "sec-type") || "").toLowerCase();
+                const titleNode = poFindFirstByLocal(secPO, "title") ||
+                    poFindFirstByLocal(secPO, "label");
+                const title = (titleNode && (poText(poChildren(titleNode)) || poText(titleNode))) ||
+                    "";
+                if (title && !out.title)
+                    out.title = title;
+                const hit = secType.includes("ack") || /acknowledg(e)?ments?/i.test(title || "");
+                if (hit) {
+                    const pNodes = poFindDescendantsByLocal(secPO, "p");
+                    if (pNodes.length) {
+                        for (const p of pNodes)
+                            pushXml(p);
+                    }
+                    else {
+                        const t = poText(poChildren(secPO)) || poText(secPO);
+                        pushText(t || undefined);
+                    }
+                }
+            }
+        }
+    }
+    // Fallback to object-mode if we didn't capture anything
+    if (!out.text.length) {
+        const ack = back?.ack;
+        if (!out.title)
+            out.title = asString(ack?.title) || undefined;
+        if (ack) {
+            const paras = normalizeArray(ack?.p)
+                .map((p) => getText(p))
+                .filter(Boolean);
+            if (paras.length)
+                out.text.push(...paras);
+            else
+                pushText(getText(ack));
+        }
+        for (const sec of nsArray(back, "sec")) {
+            const st = asString(sec?.["@_sec-type"]) ||
+                cleanHeading(getText(sec?.title) || getText(sec?.label));
+            if (!st)
+                continue;
+            const stLow = String(st).toLowerCase();
+            if (stLow.includes("ack")) {
+                if (!out.title)
+                    out.title = getText(sec?.title) || getText(sec?.label) || undefined;
+                for (const p of nsArray(sec, "p"))
+                    pushText(getText(p));
+                if (!nsArray(sec, "p").length)
+                    pushText(getText(sec));
+            }
+        }
+    }
+    return out;
+}
+export function collectBackSecRich(back, secTypes, domPO) {
+    const out = { text: [] };
+    const pushText = (s) => {
+        if (s && s.trim())
+            out.text.push(s.trim());
+    };
+    const pushXml = (pNode) => {
+        const t = poText(poChildren(pNode)) || poText(pNode);
+        if (t && t.trim())
+            out.text.push(t.trim());
+        const x = poSerialize(pNode);
+        if (x && x.trim())
+            (out.xml = out.xml || []).push(x);
+        const xm = poSerializeMinimal(pNode);
+        if (xm && xm.trim())
+            (out.xml_minimal = out.xml_minimal || []).push(xm);
+    };
+    const targets = new Set(secTypes.map((x) => x.toLowerCase()));
+    const backPO = domPO ? poFindFirstByLocal(domPO, "back") : undefined;
+    for (const sec of nsArray(back, "sec")) {
+        const st = (asString(sec?.["@_sec-type"]) || "").toLowerCase();
+        const title = cleanHeading(getText(sec?.title) || getText(sec?.label) || "") || "";
+        const tLow = title.toLowerCase();
+        const nameHit = targets.has(st);
+        const titleHit = (targets.has("supplementary-material") && /supplementary/.test(tLow)) ||
+            (targets.has("data-availability") &&
+                /(data\s*availability|availability\s*of\s*data)/.test(tLow)) ||
+            (targets.has("funding") &&
+                /(funding|funds|financial\s+support)/.test(tLow));
+        if (nameHit || titleHit) {
+            // Try preserveOrder extraction for accurate inline order and XML variants
+            const secId = asString(sec?.["@_id"]) ||
+                asString(sec?.id) ||
+                asString(sec?.["@_hwp:id"]) ||
+                undefined;
+            let pushed = false;
+            // Capture title from object-mode
+            if (!out.title)
+                out.title = getText(sec?.title) || undefined;
+            if (backPO && secId) {
+                const secPO = poFindSectionById(backPO, secId) || poFindSectionById(domPO, secId);
+                if (secPO) {
+                    // Capture title from PO if available
+                    const tnode = poFindFirstByLocal(secPO, "title") ||
+                        poFindFirstByLocal(secPO, "label");
+                    const t = (tnode && (poText(poChildren(tnode)) || poText(tnode))) ||
+                        undefined;
+                    if (t && !out.title)
+                        out.title = t;
+                    // Special handling for supplementary: avoid pulling <p> under <fig> to prevent duplicating legends
+                    if (targets.has("supplementary-material")) {
+                        const collected = poCollectSectionTexts(secPO);
+                        if (collected.paragraphs.length) {
+                            for (const p of collected.paragraphs)
+                                pushText(p);
+                            pushed = true;
+                        }
+                    }
+                    else {
+                        const pNodes = poFindDescendantsByLocal(secPO, "p");
+                        if (pNodes.length) {
+                            for (const p of pNodes)
+                                pushXml(p);
+                            pushed = true;
+                        }
+                    }
+                    if (!pushed) {
+                        const t = (poText(poChildren(secPO)) || poText(secPO))?.trim();
+                        if (t) {
+                            pushText(t);
+                            pushed = true;
+                        }
+                    }
+                }
+            }
+            if (!pushed) {
+                const ps = nsArray(sec, "p")
+                    .map((p) => getText(p))
+                    .filter(Boolean);
+                if (ps.length)
+                    out.text.push(...ps);
+                else
+                    pushText(getText(sec));
+            }
+        }
+    }
+    return out;
+}
+export function collectNotesRich(back, domPO) {
+    const out = { text: [] };
+    const pushText = (s) => {
+        if (s && s.trim())
+            out.text.push(s.trim());
+    };
+    const pushXml = (pNode) => {
+        const t = poText(poChildren(pNode)) || poText(pNode);
+        if (t && t.trim())
+            out.text.push(t.trim());
+        const x = poSerialize(pNode);
+        if (x && x.trim())
+            (out.xml = out.xml || []).push(x);
+        const xm = poSerializeMinimal(pNode);
+        if (xm && xm.trim())
+            (out.xml_minimal = out.xml_minimal || []).push(xm);
+    };
+    // Try preserveOrder
+    if (domPO) {
+        const backPO = poFindFirstByLocal(domPO, "back");
+        if (backPO) {
+            for (const fng of poFindDescendantsByLocal(backPO, "fn-group")) {
+                for (const fn of poFindDescendantsByLocal(fng, "fn")) {
+                    const pNodes = poFindDescendantsByLocal(fn, "p");
+                    if (pNodes.length) {
+                        for (const p of pNodes)
+                            pushXml(p);
+                    }
+                    else {
+                        const t = poText(poChildren(fn)) || poText(fn);
+                        pushText(t || undefined);
+                    }
+                }
+            }
+        }
+    }
+    if (!out.text.length) {
+        const fng = back?.["fn-group"];
+        const fns = normalizeArray(fng?.fn);
+        for (const fn of fns) {
+            const txt = getText(fn);
+            if (txt)
+                out.text.push(txt);
+        }
+    }
+    return out;
+}
+export function collectSupplementary(body, back) {
+    const items = [
+        ...normalizeArray(body?.["supplementary-material"]),
+        ...normalizeArray(back?.["supplementary-material"]),
+    ];
+    return items.map((x) => ({
+        href: x?.["@_xlink:href"] || x?.["@_href"] || undefined,
+        content_type: x?.["@_content-type"] || undefined,
+    }));
+}
+// Collect supplementary graphics from figures and tables labeled/typed as supplementary
+export function collectSupplementaryGraphics(domPO) {
+    const out = [];
+    const articlePO = poFindFirstByLocal(domPO, "article") || domPO;
+    if (!articlePO)
+        return out;
+    // Figures
+    for (const f of poFindDescendantsByLocal(articlePO, "fig")) {
+        const figId = poGetAttr(f, "id") || poGetAttr(f, "hwp:id");
+        const labelNode = poFindFirstByLocal(f, "label");
+        const label = (labelNode && (poText(poChildren(labelNode)) || poText(labelNode))) ||
+            undefined;
+        const isSupp = (figId && /^figs/i.test(figId)) ||
+            (label || "").toLowerCase().includes("supplementary");
+        if (!isSupp)
+            continue;
+        const caption = poFindFirstByLocal(f, "caption");
+        let titleText;
+        const capParas = [];
+        const capXml = [];
+        const capXmlMin = [];
+        if (caption) {
+            const titleNode = poFindFirstByLocal(caption, "title");
+            titleText =
+                (titleNode && (poText(poChildren(titleNode)) || poText(titleNode))) ||
+                    undefined;
+            const pNodes = poFindDescendantsByLocal(caption, "p");
+            for (const pn of pNodes) {
+                const t = (poText(poChildren(pn)) || poText(pn) || "").trim();
+                if (t)
+                    capParas.push(t);
+                const x = poSerialize(pn);
+                if (x && x.trim())
+                    capXml.push(x);
+                const xm = poSerializeMinimal(pn);
+                if (xm && xm.trim())
+                    capXmlMin.push(xm);
+            }
+            if (!capParas.length) {
+                const tAll = (poText(poChildren(caption)) || poText(caption) || "").trim();
+                if (tAll)
+                    capParas.push(tAll);
+                const xAll = poSerialize(caption);
+                if (xAll && xAll.trim())
+                    capXml.push(xAll);
+                const xmAll = poSerializeMinimal(caption);
+                if (xmAll && xmAll.trim())
+                    capXmlMin.push(xmAll);
+            }
+        }
+        const slugNode = poFindDescendantsByLocal(f, "object-id").find((n) => {
+            const sub = poGetAttr(n, "hwp:sub-type");
+            return (sub || "").toLowerCase() === "slug";
+        });
+        const slug = (slugNode && (poText(poChildren(slugNode)) || poText(slugNode))) ||
+            undefined;
+        const figCaption = {
+            ...(capParas.length ? { paragraphs: capParas } : {}),
+            ...(capXml.length ? { xml: capXml } : {}),
+            ...(capXmlMin.length ? { xml_minimal: capXmlMin } : {}),
+        };
+        out.push({
+            kind: "figure",
+            ...(figId ? { id: figId } : {}),
+            ...(label && label.trim() ? { label: label.trim() } : {}),
+            ...(titleText && titleText.trim() ? { title: titleText.trim() } : {}),
+            ...(slug && slug.trim() ? { slug: slug.trim() } : {}),
+            ...(Object.keys(figCaption).length ? { caption: figCaption } : {}),
+        });
+    }
+    // Tables
+    for (const t of poFindDescendantsByLocal(articlePO, "table-wrap")) {
+        const tblId = poGetAttr(t, "id") || poGetAttr(t, "hwp:id");
+        const labelNode = poFindFirstByLocal(t, "label");
+        const label = (labelNode && (poText(poChildren(labelNode)) || poText(labelNode))) ||
+            undefined;
+        const isSupp = (tblId && /^tbls/i.test(tblId)) ||
+            (label || "").toLowerCase().includes("supplementary");
+        if (!isSupp)
+            continue;
+        const caption = poFindFirstByLocal(t, "caption");
+        const titleNode = caption ? poFindFirstByLocal(caption, "title") : undefined;
+        const title = titleNode
+            ? (poText(poChildren(titleNode)) || poText(titleNode) || undefined)
+            : undefined;
+        const capParas = [];
+        const capXml = [];
+        const capXmlMin = [];
+        if (caption) {
+            const pNodes = poFindDescendantsByLocal(caption, "p");
+            for (const pn of pNodes) {
+                const txt = (poText(poChildren(pn)) || poText(pn) || "").trim();
+                if (!txt)
+                    continue;
+                capParas.push(txt);
+                const x = poSerialize(pn);
+                if (x && x.trim())
+                    capXml.push(x);
+                const xm = poSerializeMinimal(pn);
+                if (xm && xm.trim())
+                    capXmlMin.push(xm);
+            }
+        }
+        const tblSlugNode = poFindDescendantsByLocal(t, "object-id").find((n) => {
+            const sub = poGetAttr(n, "hwp:sub-type");
+            return (sub || "").toLowerCase() === "slug";
+        });
+        const tblSlug = (tblSlugNode && (poText(poChildren(tblSlugNode)) || poText(tblSlugNode))) ||
+            undefined;
+        const tblCaption = {
+            ...(capParas.length ? { paragraphs: capParas } : {}),
+            ...(capXml.length ? { xml: capXml } : {}),
+            ...(capXmlMin.length ? { xml_minimal: capXmlMin } : {}),
+        };
+        out.push({
+            kind: "table",
+            ...(tblId ? { id: tblId } : {}),
+            ...(label && label.trim() ? { label: label.trim() } : {}),
+            ...(title && title.trim() ? { title: title.trim() } : {}),
+            ...(tblSlug && tblSlug.trim() ? { slug: tblSlug.trim() } : {}),
+            ...(Object.keys(tblCaption).length ? { caption: tblCaption } : {}),
+        });
+    }
+    return out;
+}
+// Build a structured Supplementary Figures section with one child per <fig> that appears to be supplementary
+export function collectSupplementaryFiguresSections(domPO) {
+    const articlePO = poFindFirstByLocal(domPO, "article") || domPO;
+    if (!articlePO)
+        return undefined;
+    const figs = poFindDescendantsByLocal(articlePO, "fig");
+    const blocks = [];
+    for (const f of figs) {
+        const figId = poGetAttr(f, "id");
+        const labelNode = poFindFirstByLocal(f, "label");
+        const label = (labelNode && (poText(poChildren(labelNode)) || poText(labelNode))) ||
+            undefined;
+        const isSupp = (figId && /^figs/i.test(figId)) ||
+            (label || "").toLowerCase().includes("supplementary");
+        if (!isSupp)
+            continue;
+        // Caption extraction
+        const caption = poFindFirstByLocal(f, "caption");
+        let titleText;
+        const capParas = [];
+        const capXml = [];
+        const capXmlMin = [];
+        if (caption) {
+            const titleNode = poFindFirstByLocal(caption, "title");
+            titleText =
+                (titleNode && (poText(poChildren(titleNode)) || poText(titleNode))) ||
+                    undefined;
+            const pNodes = poFindDescendantsByLocal(caption, "p");
+            for (const pn of pNodes) {
+                const t = poText(poChildren(pn)) || poText(pn);
+                if (t && t.trim())
+                    capParas.push(t.trim());
+                const x = poSerialize(pn);
+                if (x && x.trim())
+                    capXml.push(x);
+                const xm = poSerializeMinimal(pn);
+                if (xm && xm.trim())
+                    capXmlMin.push(xm);
+            }
+            // Fallback when caption has no <p>
+            if (!capParas.length) {
+                const tAll = (poText(poChildren(caption)) ||
+                    poText(caption) ||
+                    "").trim();
+                if (tAll)
+                    capParas.push(tAll);
+                const xAll = poSerialize(caption);
+                if (xAll && xAll.trim())
+                    capXml.push(xAll);
+                const xmAll = poSerializeMinimal(caption);
+                if (xmAll && xmAll.trim())
+                    capXmlMin.push(xmAll);
+            }
+        }
+        const slugNode = poFindDescendantsByLocal(f, "object-id").find((n) => {
+            const sub = poGetAttr(n, "hwp:sub-type");
+            return (sub || "").toLowerCase() === "slug";
+        });
+        const slug = (slugNode && (poText(poChildren(slugNode)) || poText(slugNode))) ||
+            undefined;
+        const figCaption = {
+            ...(capParas.length ? { paragraphs: capParas } : {}),
+            ...(capXml.length ? { xml: capXml } : {}),
+            ...(capXmlMin.length ? { xml_minimal: capXmlMin } : {}),
+        };
+        const figBlock = {
+            kind: "figure",
+            ...(figId ? { id: figId } : {}),
+            ...(label && label.trim() ? { label: label.trim() } : {}),
+            ...(titleText && titleText.trim() ? { title: titleText.trim() } : {}),
+            ...(slug && slug.trim() ? { slug: slug.trim() } : {}),
+            ...(Object.keys(figCaption).length ? { caption: figCaption } : {}),
+        };
+        blocks.push(figBlock);
+    }
+    if (!blocks.length)
+        return undefined;
+    const parent = {
+        title: "Supplementary Figures",
+        normalized_title: "Supplementary Material",
+        category: "supplementary",
+        blocks,
+    };
+    return parent;
+}
+// Build a structured Supplementary Tables section with one table block per <table-wrap> that appears to be supplementary
+export function collectSupplementaryTablesSections(domPO) {
+    const articlePO = poFindFirstByLocal(domPO, "article") || domPO;
+    if (!articlePO)
+        return undefined;
+    const tables = poFindDescendantsByLocal(articlePO, "table-wrap");
+    const blocks = [];
+    for (const t of tables) {
+        const tblId = poGetAttr(t, "id") || poGetAttr(t, "hwp:id");
+        const labelNode = poFindFirstByLocal(t, "label");
+        const label = (labelNode && (poText(poChildren(labelNode)) || poText(labelNode))) ||
+            undefined;
+        const isSupp = (tblId && /^tbls/i.test(tblId)) ||
+            (label || "").toLowerCase().includes("supplementary");
+        if (!isSupp)
+            continue;
+        const caption = poFindFirstByLocal(t, "caption");
+        const titleNode = caption
+            ? poFindFirstByLocal(caption, "title")
+            : undefined;
+        const title = titleNode
+            ? poText(poChildren(titleNode)) || poText(titleNode) || undefined
+            : undefined;
+        const capParas = [];
+        const capXml = [];
+        const capXmlMin = [];
+        if (caption) {
+            const pNodes = poFindDescendantsByLocal(caption, "p");
+            for (const pn of pNodes) {
+                const txt = (poText(poChildren(pn)) || poText(pn) || "").trim();
+                if (!txt)
+                    continue;
+                capParas.push(txt);
+                const x = poSerialize(pn);
+                if (x && x.trim())
+                    capXml.push(x);
+                const xm = poSerializeMinimal(pn);
+                if (xm && xm.trim())
+                    capXmlMin.push(xm);
+            }
+        }
+        const tblSlugNode = poFindDescendantsByLocal(t, "object-id").find((n) => {
+            const sub = poGetAttr(n, "hwp:sub-type");
+            return (sub || "").toLowerCase() === "slug";
+        });
+        const tblSlug = (tblSlugNode &&
+            (poText(poChildren(tblSlugNode)) || poText(tblSlugNode))) ||
+            undefined;
+        const tblCaption = {
+            ...(capParas.length ? { paragraphs: capParas } : {}),
+            ...(capXml.length ? { xml: capXml } : {}),
+            ...(capXmlMin.length ? { xml_minimal: capXmlMin } : {}),
+        };
+        const tblBlock = {
+            kind: "table",
+            ...(tblId ? { id: tblId } : {}),
+            ...(label && label.trim() ? { label: label.trim() } : {}),
+            ...(title && title.trim() ? { title: title.trim() } : {}),
+            ...(tblSlug && tblSlug.trim() ? { slug: tblSlug.trim() } : {}),
+            ...(Object.keys(tblCaption).length ? { caption: tblCaption } : {}),
+        };
+        blocks.push(tblBlock);
+    }
+    if (!blocks.length)
+        return undefined;
+    const parent = {
+        title: "Supplementary Tables",
+        normalized_title: "Supplementary Material",
+        category: "supplementary",
+        blocks,
+    };
+    return parent;
+}
+// Collect generic back <sec> sections that are not handled by specific buckets
+// like acknowledgements, data availability, funding, notes, or supplementary.
+export function collectGenericBackSections(back, domPO) {
+    const out = [];
+    try {
+        const backPO = poFindFirstByLocal(domPO, "back");
+        const seenIds = new Set();
+        for (const sec of nsArray(back, "sec")) {
+            const id = asString(sec?.["@_id"]) ||
+                asString(sec?.id) ||
+                asString(sec?.["@_hwp:id"]) ||
+                undefined;
+            const sec_type = asString(sec?.["@_sec-type"]) || undefined;
+            const titleRaw = getText(sec?.title) || getText(sec?.label) || undefined;
+            const { category: cat, normalized_title: norm } = classifySection(titleRaw, sec_type, 0, undefined);
+            // Skip sections handled elsewhere and supplementary here
+            if (cat === "acknowledgements" ||
+                cat === "data_availability" ||
+                cat === "funding" ||
+                cat === "notes" ||
+                cat === "supplementary")
+                continue;
+            if (id) {
+                if (seenIds.has(id))
+                    continue;
+                seenIds.add(id);
+            }
+            const blocks = [];
+            let paragraphs = [];
+            let paragraphs_xml = [];
+            let paragraphs_xml_minimal = [];
+            if (backPO && id) {
+                const secPO = poFindSectionById(backPO, id) || poFindSectionById(domPO, id);
+                if (secPO) {
+                    const subObjs = nsArray(sec, "sec");
+                    let poSecIdx = 0;
+                    for (const ch of poChildren(secPO)) {
+                        if (poIsTextNode(ch)) {
+                            const t = (poText(ch) || "").trim();
+                            if (t)
+                                blocks.push({ kind: "paragraph", text: t });
+                            continue;
+                        }
+                        const nm = poTagName(ch) || "";
+                        if (poMatchesLocal(nm, "title") || poMatchesLocal(nm, "label"))
+                            continue;
+                        if (poMatchesLocal(nm, "sec")) {
+                            const os = subObjs[poSecIdx];
+                            const sub = os
+                                ? collectSectionNode(os, 1, undefined, domPO, secPO, poSecIdx)
+                                : { title: undefined, paragraphs: [] };
+                            blocks.push({ kind: "section", section: sub });
+                            poSecIdx += 1;
+                            continue;
+                        }
+                        if (poMatchesLocal(nm, "p")) {
+                            const t = (poText(poChildren(ch)) || poText(ch) || "").trim();
+                            if (!t)
+                                continue;
+                            const x = poSerialize(ch);
+                            const xm = poSerializeMinimal(ch);
+                            blocks.push({
+                                kind: "paragraph",
+                                text: t,
+                                ...(x && x.trim() ? { xml: x } : {}),
+                                ...(xm && xm.trim() ? { xml_minimal: xm } : {}),
+                            });
+                            continue;
+                        }
+                        if (poMatchesLocal(nm, "list")) {
+                            for (const it of poFindDescendantsByLocal(ch, "list-item")) {
+                                const p = poFindFirstByLocal(it, "p");
+                                const t = ((p && (poText(poChildren(p)) || poText(p))) ||
+                                    poText(it) ||
+                                    "").trim();
+                                if (!t)
+                                    continue;
+                                const x = p ? poSerialize(p) : undefined;
+                                const xm = p ? poSerializeMinimal(p) : undefined;
+                                blocks.push({
+                                    kind: "paragraph",
+                                    text: t,
+                                    ...(x && x?.trim() ? { xml: x } : {}),
+                                    ...(xm && xm?.trim() ? { xml_minimal: xm } : {}),
+                                });
+                            }
+                            continue;
+                        }
+                        if (poMatchesLocal(nm, "boxed-text")) {
+                            for (const p of poFindDescendantsByLocal(ch, "p")) {
+                                const t = (poText(poChildren(p)) || poText(p) || "").trim();
+                                if (!t)
+                                    continue;
+                                const x = poSerialize(p);
+                                const xm = poSerializeMinimal(p);
+                                blocks.push({
+                                    kind: "paragraph",
+                                    text: t,
+                                    ...(x && x.trim() ? { xml: x } : {}),
+                                    ...(xm && xm.trim() ? { xml_minimal: xm } : {}),
+                                });
+                            }
+                            continue;
+                        }
+                        if (poMatchesLocal(nm, "fig")) {
+                            const figId = poGetAttr(ch, "id") || poGetAttr(ch, "hwp:id");
+                            const labelNode = poFindFirstByLocal(ch, "label");
+                            const label = (labelNode &&
+                                (poText(poChildren(labelNode)) || poText(labelNode))) ||
+                                undefined;
+                            const cap = poFindFirstByLocal(ch, "caption");
+                            const titleNode = cap ? poFindFirstByLocal(cap, "title") : undefined;
+                            const title = titleNode
+                                ? poText(poChildren(titleNode)) || poText(titleNode) || undefined
+                                : undefined;
+                            const capParas = [];
+                            const capXml = [];
+                            const capXmlMin = [];
+                            if (cap) {
+                                for (const p of poFindDescendantsByLocal(cap, "p")) {
+                                    const t = (poText(poChildren(p)) || poText(p) || "").trim();
+                                    if (!t)
+                                        continue;
+                                    capParas.push(t);
+                                    const x = poSerialize(p);
+                                    const xm = poSerializeMinimal(p);
+                                    if (x && x.trim())
+                                        capXml.push(x);
+                                    if (xm && xm.trim())
+                                        capXmlMin.push(xm);
+                                }
+                            }
+                            const figCaption = {
+                                ...(capParas.length ? { paragraphs: capParas } : {}),
+                                ...(capXml.length ? { xml: capXml } : {}),
+                                ...(capXmlMin.length ? { xml_minimal: capXmlMin } : {}),
+                            };
+                            const figBlock = {
+                                kind: "figure",
+                                ...(figId ? { id: figId } : {}),
+                                ...(label && label.trim() ? { label: label.trim() } : {}),
+                                ...(title && title.trim() ? { title: title.trim() } : {}),
+                                ...(Object.keys(figCaption).length ? { caption: figCaption } : {}),
+                            };
+                            blocks.push(figBlock);
+                            continue;
+                        }
+                        if (poMatchesLocal(nm, "table-wrap")) {
+                            const tblId = poGetAttr(ch, "id") || poGetAttr(ch, "hwp:id");
+                            const labelNode = poFindFirstByLocal(ch, "label");
+                            const label = (labelNode &&
+                                (poText(poChildren(labelNode)) || poText(labelNode))) ||
+                                undefined;
+                            const cap = poFindFirstByLocal(ch, "caption");
+                            const titleNode = cap ? poFindFirstByLocal(cap, "title") : undefined;
+                            const title = titleNode
+                                ? poText(poChildren(titleNode)) || poText(titleNode) || undefined
+                                : undefined;
+                            const capParas = [];
+                            const capXml = [];
+                            const capXmlMin = [];
+                            if (cap) {
+                                for (const p of poFindDescendantsByLocal(cap, "p")) {
+                                    const t = (poText(poChildren(p)) || poText(p) || "").trim();
+                                    if (!t)
+                                        continue;
+                                    capParas.push(t);
+                                    const x = poSerialize(p);
+                                    const xm = poSerializeMinimal(p);
+                                    if (x && x.trim())
+                                        capXml.push(x);
+                                    if (xm && xm.trim())
+                                        capXmlMin.push(xm);
+                                }
+                            }
+                            const tblCaption = {
+                                ...(capParas.length ? { paragraphs: capParas } : {}),
+                                ...(capXml.length ? { xml: capXml } : {}),
+                                ...(capXmlMin.length ? { xml_minimal: capXmlMin } : {}),
+                            };
+                            const tblBlock = {
+                                kind: "table",
+                                ...(tblId ? { id: tblId } : {}),
+                                ...(label && label.trim() ? { label: label.trim() } : {}),
+                                ...(title && title.trim() ? { title: title.trim() } : {}),
+                                ...(Object.keys(tblCaption).length ? { caption: tblCaption } : {}),
+                            };
+                            blocks.push(tblBlock);
+                            continue;
+                        }
+                        if (poMatchesLocal(nm, "def-list")) {
+                            for (const di of poFindDescendantsByLocal(ch, "def-item")) {
+                                const term = poFindFirstByLocal(di, "term");
+                                const defn = poFindFirstByLocal(di, "def");
+                                const line = [
+                                    poText(poChildren(term)) || poText(term),
+                                    poText(poChildren(defn)) || poText(defn),
+                                ]
+                                    .filter(Boolean)
+                                    .map((s) => String(s).trim())
+                                    .filter(Boolean)
+                                    .join(" – ");
+                                if (line)
+                                    blocks.push({ kind: "paragraph", text: line });
+                            }
+                            continue;
+                        }
+                        if (poMatchesLocal(nm, "disp-formula")) {
+                            const t = (poText(poChildren(ch)) || poText(ch) || "").trim();
+                            if (t)
+                                blocks.push({ kind: "paragraph", text: t });
+                            continue;
+                        }
+                    }
+                    // Derive legacy arrays from blocks
+                    if (blocks.length) {
+                        for (const b of blocks) {
+                            if (b.kind === "paragraph") {
+                                paragraphs.push(b.text);
+                                if (b.xml)
+                                    paragraphs_xml.push(b.xml);
+                                if (b.xml_minimal)
+                                    paragraphs_xml_minimal.push(b.xml_minimal);
+                            }
+                        }
+                    }
+                }
+            }
+            if (!paragraphs.length) {
+                for (const p of nsArray(sec, "p")) {
+                    const t = getText(p);
+                    if (t)
+                        paragraphs.push(t);
+                }
+                if (!paragraphs.length) {
+                    const t = getText(sec);
+                    if (t)
+                        paragraphs.push(t);
+                }
+            }
+            if (!paragraphs.length)
+                continue;
+            const section = { id, sec_type, title: titleRaw };
+            if (norm)
+                section.normalized_title = norm;
+            if (cat)
+                section.category = cat;
+            if (blocks.length)
+                section.blocks = blocks;
+            if (paragraphs.length)
+                section.paragraphs = paragraphs;
+            if (paragraphs_xml.length)
+                section.paragraphs_xml = paragraphs_xml;
+            if (paragraphs_xml_minimal.length)
+                section.paragraphs_xml_minimal = paragraphs_xml_minimal;
+            out.push(section);
+        }
+    }
+    catch { }
+    return out;
+}
+//# sourceMappingURL=back.js.map