linkml-reference-validator 0.5.0__tar.gz → 0.5.1__tar.gz

{linkml_reference_validator-0.5.0 → linkml_reference_validator-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: linkml_reference_validator
-Version: 0.5.0
+Version: 0.5.1
 Summary: Validation of supporting text from references and publications
 Author-email: Chris Mungall <cjmungall@lbl.gov>
 License-Expression: Apache-2.0

{linkml_reference_validator-0.5.0 → linkml_reference_validator-0.5.1}/src/linkml_reference_validator/etl/extract/xml.py

@@ -119,6 +119,53 @@ BLOCK_ELEMENTS = frozenset(
 )
 
 
+#: Dashes that can join the numbers of a citation range ("1-3", "1–3").
+_DASHES = "-\u2010\u2011\u2012\u2013\u2014\u2015\u2212"
+
+
+def _is_citation_marker(tag: Tag) -> bool:
+    """Whether ``tag`` is a bibliographic citation marker.
+
+    A JATS ``<xref ref-type="bibr">``, or a ``<sup>`` holding only such xrefs
+    and the commas and dashes between them. Inline markup is otherwise kept
+    contiguous (``H<sub>2</sub>O``), but a citation glued to the word before it
+    (``FOXL2<sup>8</sup>``) reads as another word, and one after a full stop
+    (``PGE2.<sup>41</sup>``) as a decimal number.
+
+    Examples:
+        >>> soup = BeautifulSoup('<p>A<sup><xref ref-type="bibr">8</xref></sup>'
+        ...     '10<sup>6</sup></p>', "xml")
+        >>> [_is_citation_marker(sup) for sup in soup.find_all("sup")]
+        [True, False]
+    """
+    if tag.name == "xref":
+        return tag.get("ref-type") == "bibr"
+    if tag.name != "sup":
+        return False
+    xrefs = tag.find_all("xref")
+    if not xrefs or any(xref.get("ref-type") != "bibr" for xref in xrefs):
+        return False
+    loose = "".join(
+        str(child) for child in tag.children if type(child) in (NavigableString, CData)
+    )
+    return re.fullmatch(rf"[\s,;{re.escape(_DASHES)}]*", loose) is not None
+
+
+def _welded_to_next_word(tag: Tag) -> bool:
+    """Whether the text right after ``tag`` starts with a letter, with no space.
+
+    That is what makes a bold lead-in a welded label (``R 2.6</bold>We``)
+    rather than part of a word (``IL</bold>-6``) or already spaced.
+
+    Examples:
+        >>> soup = BeautifulSoup("<x><p><bold>R 2.6</bold>We</p><p><bold>IL</bold>-6</p></x>", "xml")
+        >>> [_welded_to_next_word(b) for b in soup.find_all("bold")]
+        [True, False]
+    """
+    following = tag.next_sibling
+    return isinstance(following, NavigableString) and str(following)[:1].isalpha()
+
+
 def _block_text(node: Tag) -> str:
     """Keep inline text contiguous, separating blocks and excluding nested tables.
 
@@ -137,8 +184,27 @@ def _block_text(node: Tag) -> str:
                 parts.append(str(child))
             elif isinstance(child, Tag) and child.name not in {"table", "table-wrap"}:
                 value = walk(child)
+                lead_in = (
+                    tag.name == "p"
+                    and child.name == "bold"
+                    and not "".join(parts).strip()
+                    and _welded_to_next_word(child)
+                )
                 if child.name in BLOCK_ELEMENTS:
                     value = " " + value + " "
+                elif _is_citation_marker(child):
+                    # No space before a dash that follows: "[1</xref>-3]" is
+                    # a range, and " -3" would read as a minus sign.
+                    following = child.next_sibling
+                    dash_next = (
+                        isinstance(following, NavigableString)
+                        and str(following)[:1] in _DASHES
+                    )
+                    value = " " + value + ("" if dash_next else " ")
+                elif lead_in:
+                    # A paragraph's bold lead-in label ("<bold>R 2.6</bold>We
+                    # recommend") is not part of the sentence after it.
+                    value = value + " "
                 parts.append(value)
         return "".join(parts)
 

{linkml_reference_validator-0.5.0 → linkml_reference_validator-0.5.1}/src/linkml_reference_validator/etl/sources/doi.py

@@ -12,6 +12,7 @@ Examples:
 """
 
 import logging
+import re
 import time
 from typing import Optional
 
@@ -33,6 +34,16 @@ from linkml_reference_validator.etl.sources.utils import (
 logger = logging.getLogger(__name__)
 
 
+#: JATS elements that end a run of text in a Crossref abstract. Their local
+#: names, so ``jats:p`` and a bare ``p`` both count.
+_JATS_ABSTRACT_BLOCKS = frozenset(
+    {
+        "title", "p", "sec", "list", "list-item", "label", "caption", "def-item",
+        "disp-quote", "div", "br",
+    }
+)
+
+
 @ReferenceSourceRegistry.register
 class DOISource(ReferenceSource):
     """Fetch references from Crossref using DOI, with DataCite fallback.
@@ -515,6 +526,15 @@ class DOISource(ReferenceSource):
     def _clean_abstract(self, abstract: str) -> str:
         """Clean JATS/XML markup from abstract text.
 
+        Block elements (titles, paragraphs, sections, list items, and HTML
+        ``div`` and ``br``) become paragraphs separated by a blank line.
+        Crossref nests a structured abstract's sections as ``<jats:title>`` and
+        ``<jats:p>`` with no text between them, so stripping the tags alone
+        welded each heading onto the next sentence ("AbstractDisease
+        overviewAcute myeloid..."), and a quote beginning at that sentence
+        failed whole-word matching. Whitespace inside a paragraph is
+        collapsed; inline markup stays contiguous.
+
         Args:
             abstract: Abstract text potentially containing JATS markup
 
@@ -525,8 +545,18 @@ class DOISource(ReferenceSource):
             >>> source = DOISource()
             >>> source._clean_abstract("<jats:p>Test abstract.</jats:p>")
             'Test abstract.'
+            >>> source._clean_abstract(
+            ...     "<jats:title>Abstract</jats:title><jats:sec><jats:title>Aim"
+            ...     "</jats:title><jats:p>To test <jats:italic>it</jats:italic>.</jats:p>"
+            ...     "</jats:sec>")
+            'Abstract\\n\\nAim\\n\\nTo test it.'
         """
         if not abstract:
             return ""
         soup = BeautifulSoup(abstract, "html.parser")
-        return soup.get_text().strip()
+        for tag in soup.find_all(True):
+            if tag.name.rpartition(":")[2] in _JATS_ABSTRACT_BLOCKS:
+                tag.insert_before("\n\n")
+                tag.insert_after("\n\n")
+        paragraphs = (" ".join(chunk.split()) for chunk in re.split(r"\n\s*\n", soup.get_text()))
+        return "\n\n".join(paragraph for paragraph in paragraphs if paragraph)

{linkml_reference_validator-0.5.0 → linkml_reference_validator-0.5.1}/src/linkml_reference_validator/etl/sources/pmid.py

@@ -37,6 +37,54 @@ from linkml_reference_validator.etl.sources.utils import (
 logger = logging.getLogger(__name__)
 
 
+#: Section headings of structured abstracts. PubMed sometimes stores them
+#: welded onto the next sentence with no markup at all ("IntroductionThe black
+#: widow spider..."), which no tag can mark.
+_ABSTRACT_HEADINGS = (
+    "Abstract|Background|Introduction|Objectives?|Aims?|Purpose|Importance|"
+    "Context|Design|Setting|Participants|Patients|Methods|Materials and Methods|"
+    "Interventions?|Measurements|Main Outcome Measures|Results|Findings|"
+    "Observations|Case Report|Case Presentation|Discussion|Interpretation|"
+    "Conclusions?|Conclusions and Relevance|Significance|Limitations"
+)
+_WELDED_HEADING = re.compile(
+    rf"(?:^|(?<=[.!?])|(?<=: ))[ \t]*({_ABSTRACT_HEADINGS})(?=[A-Z])"
+)
+
+
+def _set_off_welded_headings(text: str) -> str:
+    """Split a heading welded onto its sentence into a ``"Heading: "`` label.
+
+    Only a listed heading, at the start of the text or right after a sentence
+    ends, and directly followed by a capital letter, so "The Results were"
+    and "Methodsical" are left alone. A heading right after ": " also counts,
+    which splits chained headings ("AbstractBackgroundIt" becomes "Abstract:
+    Background: It") and a welded heading after any earlier label ("Aim:
+    MethodsWe"). Title-case headings only, on purpose: all-caps welds
+    ("RESULTSThe") and welds after a bracket ("exposures)Conclusions") are
+    left as they are.
+
+    Examples:
+        >>> _set_off_welded_headings("IntroductionThe spider. ResultsA total.")
+        'Introduction: The spider.\\n\\nResults: A total.'
+        >>> _set_off_welded_headings("The Results were striking.")
+        'The Results were striking.'
+    """
+
+    def label(match: re.Match[str]) -> str:
+        after_label = text[: match.start()].endswith(": ")
+        lead = "" if match.start() == 0 or after_label else "\n\n"
+        return lead + match.group(1) + ": "
+
+    # Repeat for chained headings: "AbstractBackgroundIt began." only exposes
+    # "Background" once "Abstract" has been split off.
+    while True:
+        updated = _WELDED_HEADING.sub(label, text)
+        if updated == text:
+            return text
+        text = updated
+
+
 @ReferenceSourceRegistry.register
 class PMIDSource(ReferenceSource):
     """Fetch references from PubMed using PMID.
@@ -236,7 +284,9 @@ class PMIDSource(ReferenceSource):
         """
         sections = []
         for node in element.find_all("AbstractText"):
-            text = node.get_text().strip()
+            # Edits the parsed node in place; nothing reads it again.
+            PMIDSource._set_off_inline_headings(node)
+            text = _set_off_welded_headings(node.get_text().strip())
             if not text:
                 continue
             label = node.get("Label")
@@ -245,6 +295,49 @@ class PMIDSource(ReferenceSource):
         joined = "\n\n".join(sections)
         return joined if joined else None
 
+    @staticmethod
+    def _set_off_inline_headings(node: Any) -> None:
+        """Turn inline bold section headings into ``"Heading: "`` labels, in place.
+
+        Some publishers supply a structured abstract as one ``AbstractText``
+        whose headings are inline ``<b>``, with no space after them
+        (``<b>Background</b>Neuroblastoma can arise...``), so ``get_text()``
+        welds each heading onto the next word and a quote beginning at that
+        word fails whole-word matching. A ``<b>`` or ``<strong>`` counts as a
+        heading only at the start of the text or right after a sentence ends,
+        and only when the text after it starts with a letter; bold inside a
+        sentence, or not welded to the next word, is left as it is.
+
+        Args:
+            node: An ``AbstractText`` element, modified in place
+
+        Examples:
+            >>> from bs4 import BeautifulSoup
+            >>> xml = ("<AbstractText><b>Background</b>It began."
+            ...        "<b>Results</b>It worked.</AbstractText>")
+            >>> node = BeautifulSoup(xml, "xml").find("AbstractText")
+            >>> PMIDSource._set_off_inline_headings(node)
+            >>> node.get_text()
+            'Background: It began.\\n\\nResults: It worked.'
+        """
+        for bold in node.find_all(["b", "strong"]):
+            before = "".join(
+                str(sibling.get_text() if hasattr(sibling, "get_text") else sibling)
+                for sibling in reversed(list(bold.previous_siblings))
+            ).rstrip()
+            if before and not before.endswith((".", "!", "?")):
+                continue
+            # Only a real weld: the next text starts with a letter, no space.
+            # "<b>IL</b>-6" and "<b>Importantly</b>," are not headings.
+            following = bold.next_sibling
+            if not (isinstance(following, str) and following[:1].isalpha()):
+                continue
+            heading = bold.get_text().strip()
+            if not heading:
+                continue
+            label = heading if heading.endswith(":") else f"{heading}:"
+            bold.replace_with(f"{chr(10) * 2 if before else ''}{label} ")
+
     def _parse_abstract(self, soup: BeautifulSoup) -> Optional[str]:
         """Parse the abstract from a PubMed article XML document.
 

{linkml_reference_validator-0.5.0 → linkml_reference_validator-0.5.1}/src/linkml_reference_validator/validation/supporting_text_validator.py

@@ -62,6 +62,10 @@ def is_blank_text(value: object) -> bool:
     return isinstance(value, str) and not value.strip()
 
 
+#: Digits a citation marker welded onto a word can carry: decimal digits and
+#: the superscript digits that text printing the marker itself uses (``ears¹``).
+_CITATION_DIGITS = r"\d¹²³⁴⁵⁶⁷⁸⁹⁰"
+
 #: Characters typesetters print for a minus sign: "-", the Unicode hyphens
 #: U+2010 and U+2011, the figure dash U+2012, the en dash, "−" (U+2212) and the
 #: small and fullwidth hyphen-minus. The em dash is left out: it is a
@@ -627,8 +631,9 @@ class SupportingTextValidator:
         One allowance: when the part ends in a letter, the reference word it
         ends on may carry trailing digits. Extraction welds superscript
         citations onto the word before them (JATS ``suppressor<sup>12</sup>``,
-        PMC HTML and PDF text all give ``suppressor12``), and a quote of that
-        sentence must not fail on its last word. A part ending in a digit gets
+        PMC HTML and PDF text all give ``suppressor12``, and text that prints
+        the citation itself as superscript gives ``ears¹``), and a quote of
+        that sentence must not fail on its last word. A part ending in a digit gets
         no allowance, so ``10`` never matches ``105``.
 
         An empty part (one that was all punctuation) is found, as with a
@@ -657,6 +662,8 @@ class SupportingTextValidator:
             True
             >>> SupportingTextValidator.contains_words("a dose of 10", "a dose of 105 mg")
             False
+            >>> SupportingTextValidator.contains_words("small ears", "small ears¹ ³ both")
+            True
             >>> SupportingTextValidator.contains_words("", "anything")
             True
         """
@@ -666,7 +673,7 @@ class SupportingTextValidator:
             return True
         if not part[-1].isalpha():
             return False
-        citation = rf"(?:^| ){re.escape(part)}\d[\d,]*(?: |$)"
+        citation = rf"(?:^| ){re.escape(part)}[{_CITATION_DIGITS}][{_CITATION_DIGITS},]*(?: |$)"
         return re.search(citation, text) is not None
 
     def generate_suggested_fix(

linkml_reference_validator-0.5.1/tests/test_inline_abstract_headings.py

@@ -0,0 +1,127 @@
+"""Inline section headings in a PubMed abstract stay separate words.
+
+Some publishers supply a structured abstract as one ``AbstractText`` whose
+section headings are inline bold, with no space after them:
+``<b>Background</b>Neuroblastoma can arise...``. ``get_text()`` then welds the
+heading onto the first word ("BackgroundNeuroblastoma"), and since matching
+became whole-word (#150) a correct quote beginning at that word fails.
+PMID:33307929 is the real record this comes from.
+"""
+
+from bs4 import BeautifulSoup
+
+from linkml_reference_validator.etl.sources.pmid import PMIDSource
+from linkml_reference_validator.models import ReferenceContent, ReferenceValidationConfig
+from linkml_reference_validator.validation.supporting_text_validator import SupportingTextValidator
+
+PMID_33307929 = (
+    "<Abstract><AbstractText><b>Background</b>Neuroblastoma can arise from "
+    "extra-adrenal sites in the paraspinal sympathetic chain, including the "
+    "presacral region, where they must be differentiated from an immature or "
+    "malignant neural lesion arising from a teratoma.<b>Case Report</b>We "
+    "describe two congenital presacral neuroblastomas.</AbstractText></Abstract>"
+)
+
+
+def render(xml: str) -> str:
+    """The abstract text the PMID source would cache for ``xml``."""
+    rendered = PMIDSource()._parse_abstract(BeautifulSoup(xml, "xml"))
+    assert rendered is not None
+    return rendered
+
+
+def found(quote: str, content: str) -> bool:
+    """Whether ``quote`` validates against ``content``."""
+    validator = SupportingTextValidator(ReferenceValidationConfig())
+    reference = ReferenceContent(reference_id="PMID:1", content=content)
+    return validator.find_text_in_reference(quote, reference).found
+
+
+def test_inline_headings_are_set_off_as_labels():
+    text = render(PMID_33307929)
+    assert text.startswith("Background: Neuroblastoma can arise")
+    assert "a teratoma.\n\nCase Report: We describe two" in text
+
+
+def test_quotes_beginning_after_an_inline_heading_match():
+    text = render(PMID_33307929)
+    assert found("Neuroblastoma can arise from extra-adrenal sites", text)
+    assert found("We describe two congenital presacral neuroblastomas.", text)
+
+
+def test_bold_inside_a_sentence_is_left_alone():
+    xml = (
+        "<Abstract><AbstractText>Variants in <b>BRCA1</b> and "
+        "<b>BRCA2</b>were found.</AbstractText></Abstract>"
+    )
+    assert render(xml) == "Variants in BRCA1 and BRCA2were found."
+
+
+def test_a_heading_already_followed_by_a_space_or_colon_is_unchanged_in_words():
+    xml = (
+        "<Abstract><AbstractText><b>Background:</b> It began. "
+        "<b>Results</b> It worked.</AbstractText></Abstract>"
+    )
+    text = render(xml)
+    assert found("It began", text) and found("It worked", text)
+    assert "Background:" in text and "::" not in text
+
+
+def test_labelled_abstract_text_is_unchanged():
+    xml = (
+        '<Abstract><AbstractText Label="METHODS">We ran a trial.</AbstractText>'
+        '<AbstractText Label="RESULTS">It worked.</AbstractText></Abstract>'
+    )
+    assert render(xml) == "METHODS: We ran a trial.\n\nRESULTS: It worked."
+
+
+# PubMed itself sometimes stores the headings welded with no markup at all
+# (PMID:39670790): "IntroductionThe black widow spider ... exposures.Conclusions
+# Poison center data ...".
+WELDED_PLAIN = (
+    "<Abstract><AbstractText>IntroductionThe black widow spider is common. "
+    "ResultsA total of 15,000 exposures were reported in 3.4% (n=521) of exposures."
+    "ConclusionsPoison center data indicate that most exposures are minor."
+    "</AbstractText></Abstract>"
+)
+
+
+def test_plain_welded_headings_are_set_off():
+    text = render(WELDED_PLAIN)
+    assert text.startswith("Introduction: The black widow spider")
+    assert "of exposures.\n\nConclusions: Poison center data" in text
+    assert found("The black widow spider is common", text)
+    assert found("Poison center data indicate that most exposures are minor", text)
+    assert found("A total of 15,000 exposures", text)
+
+
+def test_heading_words_inside_sentences_are_left_alone():
+    xml = (
+        "<Abstract><AbstractText>The Results were striking. Methodsical work "
+        "followed.</AbstractText></Abstract>"
+    )
+    text = render(xml)
+    assert "The Results were striking." in text
+    assert "Methodsical work" in text
+
+
+def test_leading_bold_followed_by_a_hyphen_is_not_a_label():
+    text = render("<Abstract><AbstractText><b>IL</b>-6 levels were raised.</AbstractText></Abstract>")
+    assert found("IL-6 levels were raised", text), text
+    assert "IL:" not in text
+
+
+def test_bold_after_a_full_stop_but_not_welded_is_not_a_label():
+    xml = (
+        "<Abstract><AbstractText>It was observed. <b>Importantly</b>, the effect held, "
+        "vs. <b>BRCA2</b> carriers.</AbstractText></Abstract>"
+    )
+    text = render(xml)
+    assert "Importantly:" not in text and "BRCA2:" not in text
+    assert found("observed. Importantly, the effect held", text)
+
+
+def test_chained_welded_headings_are_all_split():
+    text = render("<Abstract><AbstractText>AbstractBackgroundIt began.</AbstractText></Abstract>")
+    assert found("It began", text), text
+    assert text == "Abstract: Background: It began."

linkml_reference_validator-0.5.1/tests/test_welded_markers.py

@@ -0,0 +1,184 @@
+"""Citation markers, lead-in labels and section titles stay separate words.
+
+Matching became whole-word in #150, so text an extractor welds together now
+fails a correct quote where a substring test used to pass it. Each case here is
+from a real cached reference that a downstream knowledge base quoted:
+
+- a JATS citation ``FOXL2<sup><xref ref-type="bibr">8</xref></sup>.`` read as
+  ``FOXL28.`` (PMC6851130), and ``PGE2.<sup>41</sup>`` as the number ``pge2.41``;
+- a paragraph's bold lead-in label ``<bold>R 2.6</bold>We recommend`` read as
+  ``2.6We`` (PMC9066594);
+- a Crossref JATS abstract ``<jats:title>Abstract</jats:title><jats:sec>
+  <jats:title>Disease overview</jats:title><jats:p>Acute myeloid...`` read as
+  ``AbstractDisease overviewAcute myeloid`` (DOI:10.1002/ajh.26822);
+- a superscript citation range ``ears¹⁻³`` (PMID:21358632), which the
+  trailing-citation allowance did not cover because ``¹`` is not a decimal
+  digit.
+"""
+
+import pytest
+
+from linkml_reference_validator.etl.extract.xml import XMLExtractor
+from linkml_reference_validator.etl.sources.doi import DOISource
+from linkml_reference_validator.models import ReferenceContent, ReferenceValidationConfig
+from linkml_reference_validator.validation.supporting_text_validator import (
+    SupportingTextValidator,
+)
+
+
+def extract(body: str) -> str:
+    text = XMLExtractor().extract(f"<article><body>{body}</body></article>".encode())
+    assert text is not None
+    return text
+
+
+def found(quote: str, content: str) -> bool:
+    validator = SupportingTextValidator(ReferenceValidationConfig())
+    reference = ReferenceContent(reference_id="PMID:1", content=content)
+    return validator.find_text_in_reference(quote, reference).found
+
+
+# --- JATS citation markers -------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "body,quote",
+    [
+        (
+            '<p>It inhibits the expression of FOXL2<sup><xref ref-type="bibr" '
+            'rid="CR8">8</xref></sup>. Here we add PITX2.</p>',
+            "inhibits the expression of FOXL2",
+        ),
+        (
+            '<p>caused by mutations in KCNA1<xref ref-type="bibr" rid="B18">18</xref>). '
+            "At last follow up.</p>",
+            "caused by mutations in KCNA1",
+        ),
+        (
+            '<p>and a deficiency of PGE2.<sup><xref ref-type="bibr" rid="B41">41</xref></sup>'
+            " Next sentence.</p>",
+            "a deficiency of PGE2",
+        ),
+        (
+            '<p>if left untreated.<sup><xref ref-type="bibr" rid="B2">2</xref>,'
+            '<xref ref-type="bibr" rid="B8">8</xref></sup>Damage to major organs.</p>',
+            "Damage to major organs",
+        ),
+    ],
+)
+def test_citation_markers_do_not_weld(body, quote):
+    text = extract(body)
+    assert found(quote, text), text
+
+
+def test_citation_marker_still_reads_as_its_number():
+    text = extract('<p>shown before<sup><xref ref-type="bibr" rid="B8">8</xref></sup>.</p>')
+    assert "shown before 8" in text
+
+
+def test_non_citation_superscripts_stay_attached():
+    """A unit exponent or a figure link is not a citation; only bibr is padded."""
+    text = extract(
+        '<p>at 10<sup>6</sup> cells, see <xref ref-type="fig" rid="F1">Figure 1</xref>'
+        "a, and H<sub>2</sub>O.</p>"
+    )
+    assert "10⁶" in text or "106" in text
+    assert "H2O" in text
+
+
+# --- Bold lead-in labels ---------------------------------------------------
+
+
+def test_leading_bold_label_is_set_off():
+    text = extract(
+        "<p><bold>R 2.6</bold>We recommend to use 17β-oestradiol for puberty induction.</p>"
+    )
+    assert found("We recommend to use 17β-oestradiol", text), text
+
+
+def test_bold_inside_a_sentence_is_left_alone():
+    text = extract("<p>Variants in <bold>BRCA1</bold>were found.</p>")
+    assert "BRCA1were" in text
+
+
+# --- Crossref JATS abstracts -----------------------------------------------
+
+CROSSREF_ABSTRACT = (
+    "<jats:title>Abstract</jats:title>\n"
+    "                  <jats:sec>\n"
+    "                    <jats:title>Disease overview</jats:title>\n"
+    "                    <jats:p>Acute myeloid leukemia (AML) is a frequently fatal "
+    "bone marrow stem cell cancer.</jats:p>\n"
+    "                  </jats:sec>\n"
+    "                  <jats:sec><jats:title>Diagnosis</jats:title>"
+    "<jats:p>One updated and one <jats:italic>new</jats:italic> classification.</jats:p>"
+    "</jats:sec>"
+)
+
+
+def test_crossref_abstract_sections_are_separate_paragraphs():
+    text = DOISource()._clean_abstract(CROSSREF_ABSTRACT)
+    assert text.split("\n\n") == [
+        "Abstract",
+        "Disease overview",
+        "Acute myeloid leukemia (AML) is a frequently fatal bone marrow stem cell cancer.",
+        "Diagnosis",
+        "One updated and one new classification.",
+    ]
+    assert found("Acute myeloid leukemia (AML) is a frequently fatal", text)
+    assert found("One updated and one new classification", text)
+
+
+def test_crossref_plain_paragraph_is_unchanged():
+    assert DOISource()._clean_abstract("<jats:p>Test abstract.</jats:p>") == "Test abstract."
+
+
+# --- Superscript citations in plain text -----------------------------------
+
+
+@pytest.mark.parametrize(
+    "quote,content",
+    [
+        ("markedly small ears", "patellae and markedly small ears¹⁻³. Both pre-"),
+        ("markedly small ears", "patellae and markedly small ears²³ and"),
+    ],
+)
+def test_superscript_citation_after_a_word_is_allowed(quote, content):
+    assert found(quote, content)
+
+
+def test_superscript_does_not_extend_a_number():
+    """The allowance stays letter-only: a quote ending in a digit gets none."""
+    assert not found("a dose of 10", "a dose of 10⁶ cells")
+
+
+@pytest.mark.parametrize(
+    "body,quote",
+    [
+        ("<p><bold>IL</bold>-6 levels were raised.</p>", "IL-6 levels were raised"),
+        ("<p><bold>BRCA1</bold> mutations were found.</p>", "BRCA1 mutations were found"),
+    ],
+)
+def test_leading_bold_that_is_not_welded_is_left_alone(body, quote):
+    """Only a bold followed directly by a letter is a welded label (IL-6 is not)."""
+    text = extract(body)
+    assert found(quote, text), text
+
+
+def test_crossref_html_breaks_and_divs_separate_paragraphs():
+    text = DOISource()._clean_abstract("<div>First part.</div><div>Second part.</div>a<br/>b")
+    assert text.split("\n\n") == ["First part.", "Second part.", "a", "b"]
+
+
+@pytest.mark.parametrize(
+    "body,quote",
+    [
+        ("<p>shown (<xref ref-type=\"bibr\" rid=\"B1\">1</xref>-3) before.</p>", "shown (1-3) before"),
+        ('<p>small ears<sup><xref ref-type="bibr" rid="B1">1</xref>–3</sup> in all.</p>', "small ears"),
+    ],
+)
+def test_citation_range_with_its_first_number_linked_keeps_its_dash(body, quote):
+    """A dash after a padded marker must not become a minus sign."""
+    text = extract(body)
+    assert found(quote, text), text
+    assert "neg" not in SupportingTextValidator.normalize_text(text), text