@cyanheads/pubmed-mcp-server 2.10.19 → 2.10.21

package/dist/services/ncbi/parsing/pmc-article-parser.js

@@ -7,7 +7,7 @@
  * inline children and drops body sections for markup-heavy articles.
  * @module src/services/ncbi/parsing/pmc-article-parser
  */
-import { attrOf, childrenOf, findAll, findAllDescendants, findOne, isTextNode, rawTextContent, selectAlternative, tagNameOf, textContent, textContentExcluding, textOf, } from './pmc-xml-helpers.js';
+import { attrOf, childrenOf, findAll, findAllDescendants, findOne, IDENTIFIER_TAGS, isMathTag, isTextNode, linearMath, lineTextContent, rawTextContent, selectAlternative, TextAssembler, tagNameOf, textContent, textContentExcluding, textOf, } from './pmc-xml-helpers.js';
 /**
  * Block content extracted into a field of its own and therefore left out of the
  * prose a section contributes. Each one nested inside a `<p>` would otherwise be
@@ -116,14 +116,22 @@ function extractArticleId(articleMeta, pubIdType) {
     return;
 }
 // ─── Authors & Affiliations ─────────────────────────────────────────────────
+/**
+ * True for a `<contrib>` that is an author: `contrib-type="author"` or no type
+ * at all. Editors, reviewers and every other typed contributor are not, and
+ * neither they nor their affiliations reach the output.
+ */
+function isAuthorContrib(contrib) {
+    const contribType = attrOf(contrib, 'contrib-type');
+    return !contribType || contribType === 'author';
+}
 /** Extract authors from a single `<contrib-group>` node. Non-author contributors are skipped. */
 export function extractJatsAuthors(contribGroup) {
     if (!contribGroup)
         return [];
     const authors = [];
     for (const contrib of findAll(contribGroup, 'contrib')) {
-        const contribType = attrOf(contrib, 'contrib-type');
-        if (contribType && contribType !== 'author')
+        if (!isAuthorContrib(contrib))
             continue;
         const collab = findOne(contrib, 'collab');
         if (collab) {
@@ -144,16 +152,42 @@ export function extractJatsAuthors(contribGroup) {
     }
     return authors;
 }
+/**
+ * Every `<aff>` in the front matter, in document order: directly under
+ * `<article-meta>`, inside a `<contrib-group>`, or inside one `<contrib>` of it.
+ * Most deposits put them under `<contrib-group>` — 131 articles of a
+ * 187-article draw carried theirs only there — and reading `<article-meta>`
+ * alone returned none for those. Some deposits repeat one affiliation as a separate
+ * `<aff>` in every `<contrib>` it applies to; the text is reported once. (#196)
+ *
+ * An affiliation belongs to the authors only: an `<aff>` inside a non-author
+ * `<contrib>` (PMC10666927's reviewing editors), and one directly under a
+ * `<contrib-group>` that holds no author, are left out, as those contributors are
+ * left out of `authors`. A group mixing authors and others keeps its direct
+ * `<aff>`s.
+ */
 function extractAffiliations(articleMeta) {
     if (!articleMeta)
         return [];
-    const result = [];
-    for (const aff of findAll(articleMeta, 'aff')) {
-        const text = textContent(aff);
-        if (text)
-            result.push(text);
+    const affs = [];
+    for (const child of childrenOf(articleMeta)) {
+        const tag = tagNameOf(child);
+        if (tag === 'aff')
+            affs.push(child);
+        if (tag !== 'contrib-group')
+            continue;
+        const contribs = findAll(child, 'contrib');
+        const holdsAuthor = contribs.length === 0 || contribs.some(isAuthorContrib);
+        for (const member of childrenOf(child)) {
+            const memberTag = tagNameOf(member);
+            if (memberTag === 'aff' && holdsAuthor)
+                affs.push(member);
+            else if (memberTag === 'contrib' && isAuthorContrib(member)) {
+                affs.push(...findAll(member, 'aff'));
+            }
+        }
     }
-    return result;
+    return [...new Set(affs.map(textContent).filter(Boolean))];
 }
 // ─── Journal & Publication Date ─────────────────────────────────────────────
 function extractJournal(journalMeta, articleMeta) {
@@ -210,6 +244,8 @@ function extractPubDate(articleMeta) {
     };
 }
 // ─── Abstract & Keywords ────────────────────────────────────────────────────
+/** Closing punctuation a deposited section title can already end in. */
+const TERMINAL_PUNCTUATION_RE = /[:.?!]$/;
 /**
  * Read the article's own abstract.
  *
@@ -226,6 +262,20 @@ function extractPubDate(articleMeta) {
  * abstract leaves its marker and its caption reaches `assets[]` alone —
  * {@link extractPmcAssets} already walks `<front>` — instead of concatenating
  * into the prose, and a `<list>` renders as list lines rather than a token run.
+ * A section that opens with a list starts it on the line below its
+ * `Title:` heading. (#202)
+ *
+ * A structured abstract is read child by child in source order: each `<sec>`
+ * as `Title: text`, and each run of content outside any `<sec>` as an untitled
+ * section reads — its statements space-joined, a blank line between it and the
+ * sections around it. A lead paragraph before the first section therefore
+ * opens the abstract as a paragraph of its own above the first `Title:` line.
+ * Springer deposits the whole abstract that way, ahead of a "Supplementary
+ * Information" section (PMC11281965), and reading the `<sec>`s alone returned
+ * that notice as the abstract. (#204)
+ *
+ * A section title deposited with its own closing punctuation (`Background:`,
+ * `Study Design.`, `What is known?`) keeps it in place of the added colon. (#205)
  */
 function extractAbstract(articleMeta) {
     if (!articleMeta)
@@ -234,34 +284,82 @@ function extractAbstract(articleMeta) {
     const abstractNode = abstracts.find((node) => !attrOf(node, 'abstract-type')) ?? abstracts[0];
     if (!abstractNode)
         return;
-    const sections = findAll(abstractNode, 'sec');
-    if (sections.length > 0) {
-        const parts = [];
-        for (const sec of sections) {
-            const title = textContent(findOne(sec, 'title'));
-            const text = abstractProse(sec);
-            if (title && text)
-                parts.push(`${title}: ${text}`);
-            else if (text)
-                parts.push(text);
+    const children = childrenOf(abstractNode);
+    if (!findOne(abstractNode, 'sec'))
+        return abstractProse(children).text || undefined;
+    const parts = [];
+    let outside = [];
+    const addOutside = () => {
+        const { text } = abstractProse(outside);
+        if (text)
+            parts.push(text);
+        outside = [];
+    };
+    for (const child of children) {
+        if (tagNameOf(child) !== 'sec') {
+            outside.push(child);
+            continue;
         }
-        return parts.join('\n\n').trim() || undefined;
+        addOutside();
+        const title = textContent(findOne(child, 'title'));
+        const { ownLineFirst, text } = abstractProse(childrenOf(child));
+        const heading = TERMINAL_PUNCTUATION_RE.test(title) ? title : `${title}:`;
+        if (title && text)
+            parts.push(`${heading}${ownLineFirst ? '\n' : ' '}${text}`);
+        else if (text)
+            parts.push(text);
     }
-    return abstractProse(abstractNode) || undefined;
+    addOutside();
+    return parts.join('\n\n').trim() || undefined;
 }
 /**
- * The prose of an `<abstract>` or one of its `<sec>`s: every child but the
- * heading the caller reports separately, space-joined. The single space is the
- * spacing the paragraph-only read this replaces already produced, so a record
- * depositing one untyped abstract of plain `<p>`s comes back byte-identical.
+ * The prose of a run of abstract content — an `<abstract>`'s or a `<sec>`'s
+ * children, or what an abstract holds outside its sections — leaving out the
+ * `<title>` and `<label>` the caller reports separately or not at all.
+ * Statements are space-joined — the spacing the paragraph-only read this
+ * replaces already produced, so a record depositing one untyped abstract of
+ * plain `<p>`s comes back byte-identical.
+ *
+ * A list reads on lines of its own, as it does in a body section: a blank line
+ * rather than a space separates it from the statement before and after it, so
+ * neither its first item runs onto the text before it nor its last item onto
+ * the heading or sentence after it (PMC8533648). A delimited box does the same,
+ * so its `[Box]` and `[End of box]` lines stand alone. `ownLineFirst` reports
+ * either on the first line, which the caller starts below the section's
+ * heading (PMC10869376). (#202, #210)
+ *
+ * A run of {@link BULLET_STATEMENT} paragraphs — a "Key points" section a
+ * deposit writes as `<p>• …</p>` rather than as a `<list>` — lays out the same
+ * way: one paragraph per line with its bullet kept, set apart from the
+ * statements around it by a blank line, and the first below the heading
+ * (PMC10799778). (#218)
  */
-function abstractProse(node) {
-    const prose = childrenOf(node).filter((child) => {
-        const tag = tagNameOf(child);
+function abstractProse(nodes) {
+    const prose = nodes.filter((node) => {
+        const tag = tagNameOf(node);
         return tag !== 'title' && tag !== 'label';
     });
-    return flowBlocks(prose, STATEMENT_BLOCK_TAGS).join(' ');
+    const blocks = flowParts(prose, STATEMENT_BLOCK_TAGS);
+    const bullet = blocks.map((block) => !block.ownLineFirst && BULLET_STATEMENT.test(block.text));
+    let text = '';
+    for (const [i, block] of blocks.entries()) {
+        const previous = blocks[i - 1];
+        if (previous) {
+            const blankLine = previous.ownLineLast || block.ownLineFirst || bullet[i - 1] !== bullet[i];
+            text += blankLine ? '\n\n' : bullet[i] ? '\n' : ' ';
+        }
+        text += block.text;
+    }
+    return { ownLineFirst: (blocks[0]?.ownLineFirst ?? false) || (bullet[0] ?? false), text };
 }
+/**
+ * A statement deposited as a bullet point: its text opens with a bullet
+ * character — `•` U+2022, `‣` U+2023, `⁃` U+2043 or `◦` U+25E6 — and carries
+ * text after it. Characters that open a paragraph with another meaning stay
+ * out: `·` and `∙` (multiplication), `*` and daggers (footnote marks), hyphens
+ * and dashes (minus signs, ranges), `■` (an end-of-proof mark). (#218)
+ */
+const BULLET_STATEMENT = /^[•‣⁃◦]\s*\S/;
 function extractKeywords(articleMeta) {
     if (!articleMeta)
         return [];
@@ -278,12 +376,18 @@ function extractKeywords(articleMeta) {
 // ─── Block Rendering ────────────────────────────────────────────────────────
 /** Indent one nesting level of a `<list>`/`<def-list>` nested in a `<list-item>`. */
 const NESTED_LIST_INDENT = '  ';
+/** A {@link FlowBlock} whose edges both stand on their own lines (`ownLines`), or neither does. */
+const flowBlock = (text, ownLines = false) => ({
+    text,
+    ownLineFirst: ownLines,
+    ownLineLast: ownLines,
+});
 /** Close the prose run in progress, discarding it when it holds only whitespace. */
 function flushRun(flow) {
-    const text = flow.run.replace(/\s+/g, ' ').trim();
+    const text = flow.run.toString().replace(/\s+/g, ' ').trim();
     if (text)
-        flow.out.push(text);
-    flow.run = '';
+        flow.out.push(flowBlock(text));
+    flow.run = new TextAssembler();
 }
 /**
  * Walk a mixed-content child list, accumulating inline text into a prose run and
@@ -299,20 +403,30 @@ function flushRun(flow) {
  * prose, {@link STATEMENT_BLOCK_TAGS} for a container whose `<title>` and `<p>`
  * children are separate statements rather than one continuous sentence.
  *
- * `<tex-math>` and `<alternatives>` are the two elements whose text is not the
- * concatenation of their subtree, so this walk defers to the shared rule rather
- * than reading their children one at a time: a `<tex-math>` contributes its
- * LaTeX document body via `rawTextContent`, and an `<alternatives>` re-enters
- * this walk with its single chosen child, which keeps a `<disp-formula>` found
- * there at block position. (#135)
+ * `<tex-math>`, MathML `<math>`, `<alternatives>` and the {@link IDENTIFIER_TAGS}
+ * are the elements whose text is not the concatenation of their subtree, so
+ * this walk defers to the shared rule rather than reading their children one at
+ * a time: a `<tex-math>` contributes its LaTeX document body via
+ * `rawTextContent`, a `<math>` its TeX-style linear form via `linearMath`
+ * wherever it sits — an inline formula or directly in a `<p>` — an
+ * `<alternatives>` re-enters this walk with its single chosen child, which keeps
+ * a `<disp-formula>` found there at block position, and an `<institution-id>`
+ * in a funding statement contributes nothing. (#135, #207, #208)
+ *
+ * The run is a {@link TextAssembler}, so prose follows the separator rules every
+ * other text field does: a `<break/>`, an inline `<fn>` or a `<label>` beside its
+ * text reads as one space rather than fusing the words on either side, and a run
+ * of `<xref>` markers with nothing between them reads `[1,2,3,4]`. (#185, #197)
  */
 function walkFlow(nodes, flow, blockTags) {
     for (const node of nodes) {
         if (isTextNode(node)) {
-            flow.run += textOf(node);
+            flow.run.text(textOf(node));
             continue;
         }
         const tag = tagNameOf(node) ?? '';
+        if (IDENTIFIER_TAGS.has(tag))
+            continue;
         if (tag === 'alternatives') {
             const chosen = selectAlternative(node);
             if (chosen)
@@ -320,26 +434,36 @@ function walkFlow(nodes, flow, blockTags) {
             continue;
         }
         if (tag === 'tex-math') {
-            flow.run += rawTextContent(node);
+            flow.run.text(rawTextContent(node));
+            continue;
+        }
+        if (isMathTag(tag)) {
+            flow.run.text(linearMath(node));
             continue;
         }
         if (blockTags.has(tag)) {
             flushRun(flow);
-            const rendered = renderBlock(node);
-            if (rendered)
-                flow.out.push(rendered);
+            const block = renderBlock(node);
+            if (block.text)
+                flow.out.push(block);
             continue;
         }
+        flow.run.open(tag);
         walkFlow(childrenOf(node), flow, blockTags);
+        flow.run.close(tag);
     }
 }
-/** Ordered text blocks contributed by one `<p>` — or any other flow container. */
-function flowBlocks(nodes, blockTags = BLOCK_TAGS) {
-    const flow = { out: [], run: '' };
+/** Ordered blocks contributed by one `<p>` — or any other flow container — with their list edges. */
+function flowParts(nodes, blockTags = BLOCK_TAGS) {
+    const flow = { out: [], run: new TextAssembler() };
     walkFlow(nodes, flow, blockTags);
     flushRun(flow);
     return flow.out;
 }
+/** Ordered text blocks contributed by one `<p>` — or any other flow container. */
+function flowBlocks(nodes, blockTags = BLOCK_TAGS) {
+    return flowParts(nodes, blockTags).map((block) => block.text);
+}
 /**
  * Block tags for a container whose `<title>` and `<p>` children each carry a
  * statement of their own — a `<caption>`, an `<abstract>`, an abstract `<sec>`.
@@ -369,30 +493,42 @@ function renderCaption(caption) {
  * sat; `<ref-list>` is carried by `references[]` and likewise contributes
  * nothing, which is what keeps a `<sec>` that only wraps one from surviving as
  * an empty "References" heading. (#116, #130)
+ *
+ * A `<list>`, `<def-list>` or `<array>`, and a delimited `<boxed-text>`, stand on
+ * lines of their own at both edges; a container read through the default arm
+ * takes the edges of its first and last blocks. (#202, #206, #210)
  */
 function renderBlock(node) {
     switch (tagNameOf(node)) {
         case 'table-wrap':
         case 'ref-list':
-            return '';
+            return flowBlock('');
         case 'fig':
-            return assetMarker(node, 'Figure');
+            return flowBlock(assetMarker(node, 'Figure'));
         case 'supplementary-material':
-            return assetMarker(node, 'Supplementary');
+            return flowBlock(assetMarker(node, 'Supplementary'));
         case 'list':
-            return renderList(node, 0);
+            return flowBlock(renderList(node, 0), true);
         case 'def-list':
-            return renderDefList(node, 0);
+            return flowBlock(renderDefList(node, 0), true);
+        case 'array':
+            return flowBlock(renderArray(node), true);
         case 'disp-quote':
-            return renderDispQuote(node);
+            return flowBlock(renderDispQuote(node));
         case 'boxed-text':
-            return renderBoxedText(node);
+            return flowBlock(renderFloatingBox(node), true);
         case 'preformat':
-            return renderPreformat(node);
+            return flowBlock(renderPreformat(node));
         case 'disp-formula':
-            return renderDispFormula(node);
-        default:
-            return flowBlocks(childrenOf(node)).join('\n\n');
+            return flowBlock(renderDispFormula(node));
+        default: {
+            const blocks = flowParts(childrenOf(node));
+            return {
+                text: blocks.map((block) => block.text).join('\n\n'),
+                ownLineFirst: blocks[0]?.ownLineFirst ?? false,
+                ownLineLast: blocks.at(-1)?.ownLineLast ?? false,
+            };
+        }
     }
 }
 /**
@@ -458,6 +594,25 @@ function assetMarker(node, kind) {
  * `<def-list>` nested inside a `<list-item>` — both in the JATS content model —
  * indents one level per depth. (#130)
  *
+ * Publishers nest a sub-list either as a child of the `<list-item>` or inside
+ * the item's `<p>` (PMC12892673), and both render the same way: below the
+ * item's line, one level deeper. Read as paragraph flow instead, the inner
+ * list's first item ran onto its parent's line. The item's `<p>` is split at
+ * the lists it holds, so the item reads in document order: prose before the
+ * first nested list stays on the item's line, and prose after one — the rest
+ * of that `<p>` or a later `<p>` — keeps its place below the list on a line of
+ * its own, one level deeper, rather than running onto the last nested item
+ * (PMC8533647) or moving above the list onto the item's line. An item whose
+ * text all follows its nested list still prints its marker, alone on the
+ * item's line, so that text stays under its own item rather than reading as
+ * the item before it; an item holding nothing but a nested list prints no line
+ * of its own. (#200, #203)
+ *
+ * A `simple` list prints no marker of its own, so an item's `<label>` is its
+ * only numbering and leads the item's line (`1. Cereals …`); dropping it lost
+ * the source numbering of every labeled simple list. Other list types print
+ * their own marker and leave the label out. (#185)
+ *
  * `withTitle: false` leaves the title out, for a list whose title has become
  * the heading of the section it forms (see {@link extractBodySections}).
  */
@@ -474,26 +629,64 @@ function renderList(list, depth, withTitle = true) {
         const marker = listType === 'simple' ? '' : listType === 'order' ? `${ordinal}. ` : '- ';
         const parts = [];
         const nested = [];
+        /** Prose read after a nested list, kept below that list. */
+        let after;
+        let proseAfter = false;
+        const flushAfter = () => {
+            const text = after?.filter(Boolean).join(' ');
+            if (!text)
+                return;
+            nested.push(`${pad}${NESTED_LIST_INDENT}${text}`);
+            proseAfter = true;
+        };
+        const addNested = (block) => {
+            flushAfter();
+            nested.push(block);
+            after = [];
+        };
         for (const child of childrenOf(item)) {
             const tag = tagNameOf(child);
-            if (tag === 'label')
+            if (tag === 'label') {
+                if (listType === 'simple' && parts.length === 0)
+                    parts.push(textContent(child));
                 continue;
-            if (tag === 'list')
-                nested.push(renderList(child, depth + 1));
-            else if (tag === 'def-list')
-                nested.push(renderDefList(child, depth + 1));
-            else
-                parts.push(...flowBlocks([child]));
+            }
+            // A `<p>` is read child by child, so a list inside it splits its prose;
+            // any other child is one unit, itself a nested list or not.
+            let prose = [];
+            for (const node of tag === 'p' ? childrenOf(child) : [child]) {
+                const inner = renderNestedList(node, depth + 1);
+                if (inner === undefined) {
+                    prose.push(node);
+                    continue;
+                }
+                (after ?? parts).push(...flowBlocks(prose));
+                prose = [];
+                addNested(inner);
+            }
+            (after ?? parts).push(...flowBlocks(prose));
         }
-        const text = parts.join(' ');
+        flushAfter();
+        const text = parts.filter(Boolean).join(' ');
         if (text)
             lines.push(`${pad}${marker}${text}`);
+        else if (proseAfter && marker)
+            lines.push(`${pad}${marker.trimEnd()}`);
         for (const block of nested)
             if (block)
                 lines.push(block);
     }
     return lines.join('\n');
 }
+/** A `<list>` or `<def-list>` rendered at `depth`; undefined for any other node. (#200) */
+function renderNestedList(node, depth) {
+    const tag = tagNameOf(node);
+    if (tag === 'list')
+        return renderList(node, depth);
+    if (tag === 'def-list')
+        return renderDefList(node, depth);
+    return;
+}
 /**
  * Render a `<def-list>`: its title on a line of its own, then
  * `- term — definition` per item. `withTitle: false` leaves the title out, as
@@ -514,6 +707,28 @@ function renderDefList(defList, depth, withTitle = true) {
     }
     return lines.join('\n');
 }
+/**
+ * Render an `<array>` — tabular material with no caption of its own, such as a
+ * glossary's grid of abbreviations — one row per line, its cells joined the way
+ * {@link renderDefList} joins a term to its definition:
+ * `- RSNA — Radiological Society of North America`. Read as flow, every cell ran
+ * into the next (`RSNARadiological Society of North AmericaRT-PCR…`). (#206)
+ */
+function renderArray(array) {
+    const lines = [];
+    for (const row of findAllDescendants(array, 'tr')) {
+        const cells = childrenOf(row)
+            .filter((cell) => {
+            const tag = tagNameOf(cell);
+            return tag === 'td' || tag === 'th';
+        })
+            .map((cell) => textContent(cell))
+            .filter(Boolean);
+        if (cells.length > 0)
+            lines.push(`- ${cells.join(' — ')}`);
+    }
+    return lines.join('\n');
+}
 /** Render a `<disp-quote>`: every line quoted, its `<attrib>` as a trailing attribution line. */
 function renderDispQuote(quote) {
     const lines = [];
@@ -541,9 +756,10 @@ function renderDispQuote(quote) {
  *
  * `withTitle: false` leaves out the `<caption>`'s `<title>` — the box's title in
  * the JATS content model — for a box whose title has become the heading of the
- * section it forms (see {@link extractBodySections}).
+ * section it forms (see {@link extractBodySections}). `withLabel: false` leaves
+ * out its `<label>`, for a box whose label {@link renderFloatingBox} names it by.
  */
-function renderBoxedText(boxedText, withTitle = true) {
+function renderBoxedText(boxedText, { withLabel = true, withTitle = true } = {}) {
     const blocks = [];
     for (const child of childrenOf(boxedText)) {
         const tag = tagNameOf(child);
@@ -553,11 +769,38 @@ function renderBoxedText(boxedText, withTitle = true) {
             const parts = childrenOf(child).filter((c) => withTitle || tagNameOf(c) !== 'title');
             blocks.push(...flowBlocks(parts, STATEMENT_BLOCK_TAGS));
         }
-        else
+        else if (withLabel || tag !== 'label')
             blocks.push(...flowBlocks([child]));
     }
     return blocks.join('\n\n');
 }
+/** The line that closes a {@link renderFloatingBox} box. */
+const BOX_END = '[End of box]';
+/**
+ * Render a `<boxed-text>` that sits in the body flow — a "Box 1", a highlights
+ * panel, a sidebar — set apart from the prose around it. Read as plain
+ * paragraphs, nothing marked where the box ended, so the body text after it
+ * read as part of the box (PMC10666927). The box opens with a line naming it by
+ * its label and `<caption>` title (`[Box: Box 1. Virtual unconference format]`,
+ * or `[Box]` when it carries neither), its content follows as
+ * {@link renderBoxedText} reads it, and {@link BOX_END} closes it. A box with no
+ * readable content — a lone `<graphic>` — keeps only its opening line when it
+ * is named, and renders nothing when it is not. (#210)
+ *
+ * A box that forms a section of its own (see {@link extractBodySections})
+ * needs none of this: its title is the section heading, and the next heading
+ * ends it.
+ */
+function renderFloatingBox(boxedText) {
+    const label = textContent(findOne(boxedText, 'label'));
+    const title = textContent(findOne(findOne(boxedText, 'caption'), 'title'));
+    const heading = [label, title].filter(Boolean).join(' ');
+    const opening = heading ? `[Box: ${heading}]` : '[Box]';
+    const content = renderBoxedText(boxedText, { withLabel: false, withTitle: false });
+    if (!content)
+        return heading ? opening : '';
+    return [opening, content, BOX_END].join('\n\n');
+}
 /**
  * A `<sec>` subtree as flat text blocks: each heading on its own line above its
  * prose, descendants following in document order. Used where a section has no
@@ -597,7 +840,7 @@ function renderPreformat(preformat) {
 const DISP_FORMULA_NON_BODY = new Set(['label', 'graphic', 'media']);
 /**
  * Render a `<disp-formula>`: its label, then a `<tex-math>` where the deposit
- * carries one (directly or under `<alternatives>`) and the flattened content
+ * carries one (directly or under `<alternatives>`) and the content's text
  * otherwise — usually `<mml:math>`, which is 69 of the 78 formulae in a
  * 68-record draw against 3 for `<tex-math>`. A graphic-only deposit has no
  * fallback text and contributes nothing at all rather than a bare label on an
@@ -606,6 +849,9 @@ const DISP_FORMULA_NON_BODY = new Set(['label', 'graphic', 'media']);
  * A `<tex-math>` contributes only the expression between `\begin{document}` and
  * `\end{document}`; `textContent` applies that rule, so the LaTeX preamble
  * publishers wrap around every formula never reaches the rendered line. (#135)
+ * A MathML `<math>` reads in the TeX-style linear form `textContent` gives it
+ * (`(L & M \\ M^{T} & N)<0`), so a formula keeps its scripts and matrix cells
+ * whichever notation the deposit carries. (#207)
  */
 function renderDispFormula(formula) {
     const texMath = findOne(formula, 'tex-math') ?? findOne(findOne(formula, 'alternatives'), 'tex-math');
@@ -638,8 +884,24 @@ function renderDispFormula(formula) {
  * content and stay in untitled sections of their own. (#148)
  */
 export function extractBodySections(body) {
-    if (!body)
-        return [];
+    return body ? extractSections(childrenOf(body), false) : [];
+}
+/**
+ * Extract back-matter sections from a `<back>` node: every child but
+ * `<ref-list>` — which `references[]` carries — and `<back>`'s own label and
+ * title, in source order. Each back-matter element is read as a `<sec>` is (see
+ * {@link BACK_SECTION_TAGS}), taking the title its element names when it carries
+ * neither a title nor a label (see {@link BACK_MATTER_TITLES}). (#206)
+ */
+function extractBackSections(back) {
+    return back ? extractSections(childrenOf(back), true) : [];
+}
+/**
+ * Read the children of `<body>` — or, with `back`, of `<back>` — into sections,
+ * in document order. {@link extractBodySections} states the rules; back matter
+ * adds its own section elements and skips `<back>`'s label and title.
+ */
+function extractSections(children, back) {
     const sections = [];
     let pendingBlocks = [];
     const flushPending = () => {
@@ -648,14 +910,15 @@ export function extractBodySections(body) {
             pendingBlocks = [];
         }
     };
-    for (const child of childrenOf(body)) {
-        if (tagNameOf(child) === 'sec') {
+    for (const child of children) {
+        const nested = nestedSections(child, back);
+        if (nested) {
             flushPending();
-            const section = extractSection(child);
-            if (section)
-                sections.push(section);
+            sections.push(...nested);
             continue;
         }
+        if (back && SECTION_META_TAGS.has(tagNameOf(child) ?? ''))
+            continue;
         const title = ownBlockTitle(child);
         if (title) {
             flushPending();
@@ -667,6 +930,90 @@ export function extractBodySections(body) {
     flushPending();
     return sections;
 }
+// ─── Back Matter ────────────────────────────────────────────────────────────
+/**
+ * Back-matter elements read as sections, each mapped to the title it goes by
+ * when it carries neither a `<title>` nor a `<label>`. Most `<fn-group>`s carry
+ * neither, and without a title a section renders as `untitled section` where no
+ * `sections` filter term can reach it. The title names the element, not a fact
+ * about the article; Europe PMC titles the same `<fn-group>` `Footnotes` when it
+ * moves back matter into `<body>`. A labelled element takes no fallback, so an
+ * `Appendix A` label never reads `Appendix Appendix A`. (#206)
+ */
+const BACK_MATTER_TITLES = new Map([
+    ['ack', 'Acknowledgments'],
+    ['app', 'Appendix'],
+    ['bio', 'Biography'],
+    ['fn-group', 'Footnotes'],
+    ['glossary', 'Glossary'],
+    ['notes', 'Notes'],
+]);
+/**
+ * Elements that form a section of their own in back matter: `<sec>`,
+ * `<app-group>`, and each element {@link BACK_MATTER_TITLES} names. One nested in
+ * another is a subsection, as a `<sec>` in a `<sec>` is, so a Springer
+ * `Declarations` `<notes>` keeps its inner notes' titles out of its text. In
+ * `<body>` only a `<sec>` forms one: a `<notes>` or `<fn-group>` closing a body
+ * `<sec>` stays that section's text, as it always read. (#206)
+ */
+const BACK_SECTION_TAGS = new Set([
+    'sec',
+    'app-group',
+    ...BACK_MATTER_TITLES.keys(),
+]);
+/**
+ * True for an `<app-group>` with neither a title nor a label. It has no heading
+ * to give a section, so its children are read as if they sat in `<back>`: its
+ * `<app>`s stand as sections in its place, and the paragraphs, lists or figures
+ * JATS lets it carry ahead of them form an untitled section rather than being
+ * dropped. (#206)
+ */
+function isHeadlessAppGroup(node) {
+    return (tagNameOf(node) === 'app-group' &&
+        !textContent(findOne(node, 'title')) &&
+        !textContent(findOne(node, 'label')));
+}
+/**
+ * The sections `node` forms where it sits among a section's children, or among
+ * `<body>`'s or `<back>`'s: a `<sec>` anywhere, and in back matter each element
+ * of {@link BACK_SECTION_TAGS} — a headless `<app-group>` by way of its
+ * children (see {@link isHeadlessAppGroup}). Undefined for anything that is
+ * section content instead. (#206)
+ */
+function nestedSections(node, back) {
+    const tag = tagNameOf(node) ?? '';
+    if (tag !== 'sec' && !(back && BACK_SECTION_TAGS.has(tag)))
+        return;
+    if (isHeadlessAppGroup(node))
+        return extractSections(childrenOf(node), back);
+    const section = extractSection(node, back);
+    return section ? [section] : [];
+}
+/**
+ * The title a back-matter element with neither a `<title>` nor a `<label>` goes
+ * by (see {@link BACK_MATTER_TITLES}); undefined for every other element, a
+ * `<sec>` included. (#206)
+ */
+function fallbackTitle(node) {
+    if (textContent(findOne(node, 'label')))
+        return;
+    return BACK_MATTER_TITLES.get(tagNameOf(node) ?? '');
+}
+/**
+ * The paragraphs of a back-matter `<fn>`: each `<p>`, and each block one holds,
+ * on its own, with the footnote's `<label>` leading the first. Read as one run,
+ * a footnote whose heading sits in a `<p>` of its own fused that heading into
+ * the statement after it (`Competing interests The authors declare…`), the
+ * fusion a titled `<notes>` is kept from. (#206)
+ */
+function footnoteParagraphs(fn) {
+    const label = textContent(findOne(fn, 'label'));
+    const [first, ...rest] = flowBlocks(childrenOf(fn).filter((child) => tagNameOf(child) !== 'label'), STATEMENT_BLOCK_TAGS);
+    if (first === undefined)
+        return label ? [label] : [];
+    return [label ? `${label} ${first}` : first, ...rest];
+}
+// ─── Section Reading ────────────────────────────────────────────────────────
 /**
  * The title a block carries of its own, where the JATS content model puts one:
  * a direct `<title>` on a `<def-list>` or `<list>`, the `<caption>` title on a
@@ -706,13 +1053,14 @@ function loneTitledBlock(sec) {
     return title ? { node, title } : undefined;
 }
 /**
- * The title a `<sec>` goes by in the output: its own `<title>`, else the one
- * {@link loneTitledBlock} lifts. {@link extractSection} titles the section and
- * {@link collectSectioned} names the tables and assets inside it from this one
- * rule, so a `sections` filter keeps them together. (#169)
+ * The title a `<sec>` — or a back-matter element read as one — goes by in the
+ * output: its own `<title>`, else the one {@link loneTitledBlock} lifts, else
+ * the one {@link fallbackTitle} names. {@link extractSection} titles the section
+ * and {@link collectSectioned} names the tables and assets inside it from this
+ * one rule, so a `sections` filter keeps them together. (#169, #206)
  */
 function secTitle(sec) {
-    return textContent(findOne(sec, 'title')) || loneTitledBlock(sec)?.title;
+    return textContent(findOne(sec, 'title')) || loneTitledBlock(sec)?.title || fallbackTitle(sec);
 }
 /** A block whose {@link ownBlockTitle} became its section's title, rendered without it. */
 function renderBlockWithoutTitle(node) {
@@ -722,9 +1070,9 @@ function renderBlockWithoutTitle(node) {
         case 'list':
             return renderList(node, 0, false);
         case 'boxed-text':
-            return renderBoxedText(node, false);
+            return renderBoxedText(node, { withTitle: false });
         default:
-            return renderBlock(node);
+            return renderBlock(node).text;
     }
 }
 /**
@@ -736,8 +1084,15 @@ function renderBlockWithoutTitle(node) {
  *
  * An untitled `<sec>` whose only content is a titled block takes that block's
  * title, and the block renders without it (see {@link loneTitledBlock}). (#169)
+ *
+ * With `back`, `sec` may be any back-matter element {@link nestedSections}
+ * reads as a section: the back-matter elements among its children are
+ * subsections too, and with neither a title nor a label it takes the title its
+ * element names. Each child contributes its own block, so every `<fn>` of a
+ * `<fn-group>` is a paragraph of its own, and each `<p>` inside one too (see
+ * {@link footnoteParagraphs}). (#206)
  */
-function extractSection(sec) {
+function extractSection(sec, back = false) {
     const lone = loneTitledBlock(sec);
     if (lone) {
         const label = textContent(findOne(sec, 'label')) || undefined;
@@ -757,14 +1112,14 @@ function extractSection(sec) {
             label ??= textContent(child) || undefined;
             continue;
         }
-        if (tag === 'sec') {
-            const subsection = extractSection(child);
-            if (subsection)
-                subsections.push(subsection);
+        const nested = nestedSections(child, back);
+        if (nested) {
+            subsections.push(...nested);
             continue;
         }
-        textParts.push(...flowBlocks([child]));
+        textParts.push(...(back && tag === 'fn' ? footnoteParagraphs(child) : flowBlocks([child])));
     }
+    title ??= fallbackTitle(sec);
     const text = textParts.join('\n\n');
     // A section left empty *because* its block content was lifted into `tables[]`
     // survives as a heading-only entry: the heading is what places the table for a
@@ -787,10 +1142,10 @@ function extractSection(sec) {
  * The walk covers the whole article rather than `<body>` alone: about a quarter
  * of real tables sit in `<floats-group>`, `<back>/<sec>`, `<table-wrap-group>`
  * or `<app-group>/<app>`, so a body-scoped extractor drops them. Each table
- * names the innermost enclosing `<sec>` wherever that sits — a back-matter or
- * appendix section counts, and naming it is the reader's only positional cue
- * there. Only a table inside no `<sec>` at all, such as a `<floats-group>`
- * deposit, carries no section name.
+ * names the innermost enclosing section wherever that sits — a back-matter
+ * `<sec>`, `<app>`, `<notes>` or `<fn-group>` counts, and naming it is the
+ * reader's only positional cue there. Only a table inside no section at all,
+ * such as a `<floats-group>` deposit, carries no section name. (#206)
  *
  * Only XHTML `<tr>`/`<td>`/`<th>` bodies are read. **Decision, not an
  * oversight:** across a 283-table survey of open-access records, 276 were XHTML,
@@ -813,19 +1168,21 @@ export function extractPmcTables(root) {
  * positional cue, and an element inside no section at all gets none. A
  * recognized element is not descended into — it parses its own subtree.
  *
- * A section here is whatever {@link extractBodySections} reports as one, under
- * the title it reports: a `<sec>` by {@link secTitle}, and a titled block
- * sitting directly in `<body>` by its own title — so a figure in a titled
- * body-level box names the box, and a `sections` filter on the box keeps it.
- * A `<sec>` inside a `<boxed-text>` is no section: the box flattens it into its
- * text (see {@link renderBoxedText}), so what sits in it names the section the
- * box belongs to. (#169)
+ * A section here is whatever {@link extractBodySections} and
+ * {@link extractBackSections} report as one, under the title they report: a
+ * `<sec>` — and inside `<back>`, each back-matter element read as one — by
+ * {@link secTitle}, and a titled block sitting directly in `<body>` or `<back>`
+ * by its own title — so a figure in a titled body-level box names the box, and
+ * a `sections` filter on the box keeps it. A `<sec>` inside a `<boxed-text>` is
+ * no section: the box flattens it into its text (see {@link renderBoxedText}),
+ * so what sits in it names the section the box belongs to. (#169, #206)
  *
  * Shared by the table and asset walks so the section-title rule has one
  * definition and cannot drift between them.
  */
-function collectSectioned(node, sectionTitle, out, take, inBox = false) {
-    const inBody = tagNameOf(node) === 'body';
+function collectSectioned(node, sectionTitle, out, take, inBox = false, inBack = false) {
+    const parentTag = tagNameOf(node);
+    const atTopLevel = parentTag === 'body' || parentTag === 'back';
     for (const child of childrenOf(node)) {
         const tag = tagNameOf(child);
         if (!tag)
@@ -837,19 +1194,21 @@ function collectSectioned(node, sectionTitle, out, take, inBox = false) {
         }
         const own = inBox
             ? undefined
-            : tag === 'sec'
+            : tag === 'sec' || (inBack && BACK_SECTION_TAGS.has(tag))
                 ? secTitle(child)
-                : inBody
+                : atTopLevel
                     ? ownBlockTitle(child)
                     : undefined;
-        collectSectioned(child, own || sectionTitle, out, take, inBox || tag === 'boxed-text');
+        collectSectioned(child, own || sectionTitle, out, take, inBox || tag === 'boxed-text', inBack || tag === 'back');
     }
 }
 function parseTableWrap(tableWrap, sectionTitle) {
     const id = attrOf(tableWrap, 'id');
     const label = textContent(findOne(tableWrap, 'label')) || undefined;
     const caption = renderCaption(findOne(tableWrap, 'caption'));
-    const footnotes = textContent(findOne(tableWrap, 'table-wrap-foot')) || undefined;
+    // One line per footnote or paragraph: a footer is a list of statements, and a
+    // marker run into the previous note (`…dose.*No patient…`) misattributes it. (#185)
+    const footnotes = lineTextContent(findOne(tableWrap, 'table-wrap-foot')) || undefined;
     // Some deposits offer both renderings inside <alternatives>; prefer the markup.
     const table = findOne(tableWrap, 'table') ?? findOne(findOne(tableWrap, 'alternatives'), 'table');
     const { rows, headerRowCount } = table
@@ -940,7 +1299,8 @@ function extractTableRows(table) {
                 allHeaderCells = false;
             sourceCells += 1;
             col = drainCarried(row, col);
-            const value = textContent(cell);
+            // `\n` wherever the cell breaks a line: `1.08<break/>2.44` is two values. (#185)
+            const value = lineTextContent(cell);
             const rowspan = spanOf(cell, 'rowspan');
             const width = Math.min(spanOf(cell, 'colspan'), MAX_TABLE_COLUMNS - col);
             for (let i = 0; i < width; i++) {
@@ -985,9 +1345,10 @@ function extractTableRows(table) {
  * supplementary material sit outside `<body>` entirely — `<floats-group>`
  * deposits, `<back>/<sec>` and `<app-group>/<app>` placements, and figures
  * hanging off the abstract in `<front>`. Each asset names the innermost
- * enclosing `<sec>` wherever that sits, an untitled one inheriting its parent's
- * title, so the reader keeps a positional cue; an asset inside no `<sec>` at all
- * carries no section name. (#130)
+ * enclosing section wherever that sits — a back-matter element read as one
+ * included — an untitled `<sec>` inheriting its parent's title, so the reader
+ * keeps a positional cue; an asset inside no section at all carries no section
+ * name. (#130, #206)
  */
 export function extractPmcAssets(root) {
     if (!root)
@@ -1059,30 +1420,41 @@ function renderCitationName(node) {
  * direct children in document order, joining author names with `, ` and
  * labeling typed `<pub-id>`s, so the output reads as a citation rather than a
  * token run. (#69)
+ *
+ * Two field pairs are joined the way a citation prints them rather than by a
+ * space, which read as two unrelated numbers: an `<fpage>` followed by its
+ * `<lpage>` is a page range (`56–71`, `i1–i51`), and a `<volume>` followed by
+ * its `<issue>` reads `16(1)`. Each token is kept verbatim. (#209)
  */
 function renderElementCitation(node) {
     const parts = [];
+    /** The field element that contributed the last part; undefined after anything else. */
+    let previous;
     for (const child of childrenOf(node)) {
         const tag = tagNameOf(child);
+        let part;
         if (tag === 'person-group') {
-            const names = childrenOf(child).map(renderCitationName).filter(Boolean);
-            if (names.length > 0)
-                parts.push(names.join(', '));
+            part = childrenOf(child).map(renderCitationName).filter(Boolean).join(', ');
         }
         else if (tag === 'pub-id') {
             const value = textContent(child);
-            if (value) {
-                const label = PUB_ID_LABELS[attrOf(child, 'pub-id-type') ?? ''];
-                parts.push(label ? `${label} ${value}` : value);
-            }
+            const label = PUB_ID_LABELS[attrOf(child, 'pub-id-type') ?? ''];
+            part = value && label ? `${label} ${value}` : value;
         }
         else {
             // Element field (source, volume, year, fpage, …) or a bare text node;
             // textContent renders both, and empty results drop out of the join.
-            const text = textContent(child);
-            if (text)
-                parts.push(text);
+            part = textContent(child);
         }
+        if (!part)
+            continue;
+        if (tag === 'lpage' && previous === 'fpage')
+            parts.push(`${parts.pop()}–${part}`);
+        else if (tag === 'issue' && previous === 'volume')
+            parts.push(`${parts.pop()}(${part})`);
+        else
+            parts.push(part);
+        previous = tag;
     }
     return parts.join(' ');
 }
@@ -1096,38 +1468,138 @@ function renderElementCitation(node) {
  */
 const NAME_WRAPPER_TAGS = new Set(['name', 'string-name', 'person-group']);
 /**
- * Serialize a `<name>` / `<string-name>` / `<person-group>` subtree, applying
- * the same rule `renderMixedCitation` applies to its own children: a single
- * space between two adjacent elements that carry nothing between them, and
- * source text emitted verbatim. `<person-group>` separates its names with real
- * `, ` text nodes and `<string-name>` usually separates surname from given
- * names with a newline, so a fixed separator would double punctuation the
- * source already has — spacing only the zero-gap transitions leaves those
- * records byte-identical. Returns raw text; the caller collapses whitespace
- * once over the finished citation.
+ * The members of an author list: each names one contributor, or (`<etal>`)
+ * stands for the rest. Two of them with nothing but whitespace between them are
+ * two list entries, which the source left for the reader to separate. (#209)
+ */
+const PERSON_TAGS = new Set(['name', 'string-name', 'collab', 'etal']);
+/** What an empty `<etal/>` stands for. (#209) */
+const SUPPLIED_ETAL = 'et al.';
+/** Any character other than whitespace. */
+const VISIBLE_TEXT = /\S/;
+/** Punctuation that closes the citation field before it: `Henry L.`, `Li X,`, `(2020)`. (#219) */
+const CLOSING_PUNCTUATION = new Set(['.', ',', ';', ':', ')', ']']);
+/**
+ * How much of the citation written so far a `<pub-id>` reads for a literal
+ * prefix naming its type: the prefix, its `:` or `.`, and the whitespace around
+ * them. A bounded window keeps each read constant-time, since every `<pub-id>`
+ * in a citation asks again and reading the whole text would make the walk
+ * quadratic. (#209)
+ */
+const ID_PREFIX_WINDOW = 256;
+/**
+ * Render one child element of a `<mixed-citation>` or name wrapper. `before` is
+ * the end of the citation text written so far ({@link ID_PREFIX_WINDOW}), which
+ * a `<pub-id>` reads for a literal prefix already naming its type. An `<etal>` reads as its own text, or as
+ * `et al.` when it is empty — as nearly every deposit leaves it.
  */
-function renderNameWrapper(node) {
-    let rendered = '';
-    let prevWasElement = false;
+function renderCitationPart(child, tag, before) {
+    if (tag === 'pub-id') {
+        const value = textContent(child);
+        const type = attrOf(child, 'pub-id-type') ?? '';
+        const label = PUB_ID_LABELS[type];
+        if (value && label && !hasLiteralIdPrefix(before, type)) {
+            return { text: `${label} ${value}`, labeled: true, suppliedEtal: false };
+        }
+        return { text: value, labeled: false, suppliedEtal: false };
+    }
+    if (NAME_WRAPPER_TAGS.has(tag))
+        return { ...renderCitationRun(child, true), labeled: false };
+    const text = rawTextContent(child);
+    if (tag === 'etal' && !text)
+        return { text: SUPPLIED_ETAL, labeled: false, suppliedEtal: true };
+    return { text, labeled: false, suppliedEtal: false };
+}
+/**
+ * Serialize a `<mixed-citation>` (`wrapper: false`) or a `<name>` /
+ * `<string-name>` / `<person-group>` inside one (`wrapper: true`), emitting
+ * source text verbatim and writing a separator only where the source left
+ * none:
+ *
+ * - Two adjacent author-list members ({@link PERSON_TAGS}) with nothing but
+ *   whitespace between them are joined by `, `: `Zwierenga F, van Veggel B,
+ *   Hendriks LEL, et al.` rather than `Zwierenga F van Veggel B Hendriks LEL`.
+ *   (#209)
+ * - Any other two elements with nothing between them get one space: a
+ *   `<surname>` and its `<given-names>`, a title and the volume after it.
+ *   (#115, #123, #124)
+ * - A label this renderer inserts is separated from whatever precedes it. (#115)
+ * - A source `.` straight after a supplied `et al.` closes it rather than
+ *   doubling its period (`<etal/></person-group>. <article-title>`). (#209)
+ * - The whitespace between an element and the {@link CLOSING_PUNCTUATION}
+ *   after it is dropped when any of it lies inside the element or it holds a
+ *   line break: the indentation a pretty-printed deposit leaves before
+ *   `</person-group>` or `</string-name>`, or the line break after
+ *   `</collab>`, reads `Henry L.` rather than `Henry L .`. Spaces the
+ *   citation's own text puts there (`</source> : <volume>`) are kept. (#219)
+ *
+ * Gaps the source already fills — `, ` text between names, a newline between a
+ * `<string-name>`'s parts — are kept as written, so a fixed separator never
+ * doubles punctuation the source has. Inside a wrapper an element that renders
+ * nothing is skipped; at the citation's own level it still counts as the
+ * element the next one follows. Returns raw text; the caller collapses
+ * whitespace once over the finished citation.
+ *
+ * Whitespace is held in `gap` until what follows it decides whether it is
+ * written, so no step re-reads the text already written and the cost stays
+ * linear in the size of the citation.
+ */
+function renderCitationRun(node, wrapper) {
+    let text = '';
+    /** Whitespace not yet written: the end of the last element's text, then source whitespace after it. */
+    let gap = '';
+    /** `gap` begins inside the element written last. */
+    let gapInside = false;
+    /** The element written last, while no visible source text has followed it. */
+    let previous;
+    let suppliedEtal = false;
+    /** At least the last {@link ID_PREFIX_WINDOW} characters of `text`, at most twice that. */
+    let recent = '';
+    const write = (chunk) => {
+        text += chunk;
+        recent += chunk;
+        if (recent.length > 2 * ID_PREFIX_WINDOW)
+            recent = recent.slice(-ID_PREFIX_WINDOW);
+    };
     for (const child of childrenOf(node)) {
         if (isTextNode(child)) {
-            const raw = textOf(child);
-            if (raw) {
-                rendered += raw;
-                prevWasElement = false;
+            let raw = textOf(child);
+            if (!VISIBLE_TEXT.test(raw)) {
+                gap += raw;
+                continue;
             }
+            if (suppliedEtal)
+                raw = raw.replace(/^(\s*)\./, '$1');
+            if (previous !== undefined) {
+                const lead = raw.search(VISIBLE_TEXT);
+                if (CLOSING_PUNCTUATION.has(raw.charAt(lead)) &&
+                    (gapInside || gap.includes('\n') || raw.slice(0, lead).includes('\n'))) {
+                    gap = '';
+                    raw = raw.slice(lead);
+                }
+            }
+            write(gap + raw);
+            gap = '';
+            previous = undefined;
+            suppliedEtal = false;
             continue;
         }
         const tag = tagNameOf(child) ?? '';
-        const part = NAME_WRAPPER_TAGS.has(tag) ? renderNameWrapper(child) : rawTextContent(child);
-        if (!part)
+        const part = renderCitationPart(child, tag, recent);
+        if (!part.text && (wrapper || tag === 'pub-id'))
             continue;
-        if (prevWasElement)
-            rendered += ' ';
-        rendered += part;
-        prevWasElement = true;
+        if (previous && PERSON_TAGS.has(previous) && PERSON_TAGS.has(tag))
+            write(', ');
+        else
+            write((previous && !gap) || part.labeled ? `${gap} ` : gap);
+        const body = part.text.trimEnd();
+        write(body);
+        gap = part.text.slice(body.length);
+        gapInside = gap !== '';
+        previous = tag;
+        suppliedEtal = part.suppliedEtal;
     }
-    return rendered;
+    return { text: text + gap, suppliedEtal };
 }
 /**
  * True when the citation text emitted so far already ends with a literal prefix
@@ -1158,49 +1630,22 @@ function hasLiteralIdPrefix(rendered, pubIdType) {
  * styles routinely close the prose on punctuation (`… (2020).`, `…021]`) and a
  * label butted against that reads as one token. Source transitions that already
  * carry punctuation or whitespace are emitted unchanged; the trailing whitespace
- * collapse keeps a whitespace-only gap at one space.
+ * collapse keeps a whitespace-only gap at one space. An author list whose names
+ * the source left unseparated reads with `, ` between them and `et al.` for an
+ * empty `<etal/>` (see {@link renderCitationRun}). (#209)
  */
 function renderMixedCitation(node) {
-    let rendered = '';
-    let prevWasElement = false;
-    for (const child of childrenOf(node)) {
-        if (isTextNode(child)) {
-            const raw = textOf(child);
-            if (raw) {
-                rendered += raw;
-                prevWasElement = false;
-            }
-            continue;
-        }
-        const tag = tagNameOf(child) ?? '';
-        let part;
-        let labeled = false;
-        if (tag === 'pub-id') {
-            const value = textContent(child);
-            if (!value)
-                continue;
-            const type = attrOf(child, 'pub-id-type') ?? '';
-            const label = PUB_ID_LABELS[type];
-            if (label && !hasLiteralIdPrefix(rendered, type)) {
-                labeled = true;
-                part = `${label} ${value}`;
-            }
-            else {
-                part = value;
-            }
-        }
-        else if (NAME_WRAPPER_TAGS.has(tag)) {
-            part = renderNameWrapper(child);
-        }
-        else {
-            part = rawTextContent(child);
-        }
-        if (prevWasElement || labeled)
-            rendered += ' ';
-        rendered += part;
-        prevWasElement = true;
-    }
-    return rendered.replace(/\s+/g, ' ').trim();
+    return renderCitationRun(node, false).text.replace(/\s+/g, ' ').trim();
+}
+/**
+ * A `<ref>`'s `<label>`, without the one pair of square brackets some deposits
+ * print it in: `[19]` is reference 19, and the tool already writes each
+ * reference's label and id inside brackets of its own (`[19 R19]`, not
+ * `[[19] R19]`). Any other label — `1.`, `(3)`, `A12` — is kept as printed.
+ * (#209)
+ */
+function referenceLabel(label) {
+    return textContent(label).replace(/^\[([^[\]]+)\]$/, '$1') || undefined;
 }
 /**
  * Extract references from anywhere under `root` — pass the `<article>` node to
@@ -1247,7 +1692,7 @@ export function extractReferences(root) {
                 continue;
             if (id)
                 seenIds.add(id);
-            const label = textContent(findOne(ref, 'label')) || undefined;
+            const label = referenceLabel(findOne(ref, 'label'));
             results.push({
                 ...(id && { id }),
                 ...(label && { label }),
@@ -1269,6 +1714,7 @@ export function parsePmcArticle(articleNode) {
     const articleMeta = findOne(front, 'article-meta');
     const journalMeta = findOne(front, 'journal-meta');
     const body = findOne(articleNode, 'body');
+    const back = findOne(articleNode, 'back');
     const pmcId = extractArticleId(articleMeta, 'pmcid') ?? extractArticleId(articleMeta, 'pmc-uid') ?? '';
     const pmid = extractArticleId(articleMeta, 'pmid');
     const doi = extractArticleId(articleMeta, 'doi');
@@ -1281,6 +1727,7 @@ export function parsePmcArticle(articleNode) {
     const abstract = extractAbstract(articleMeta);
     const keywords = extractKeywords(articleMeta);
     const sections = extractBodySections(body);
+    const backSections = extractBackSections(back);
     const references = extractReferences(articleNode);
     const tables = extractPmcTables(articleNode);
     const assets = extractPmcAssets(articleNode);
@@ -1298,6 +1745,7 @@ export function parsePmcArticle(articleNode) {
         ...(abstract && { abstract }),
         ...(keywords.length > 0 && { keywords }),
         sections,
+        ...(backSections.length > 0 && { backSections }),
         ...(references.length > 0 && { references }),
         ...(tables.length > 0 && { tables }),
         ...(assets.length > 0 && { assets }),