docling-parse 7.22.0__tar.gz → 7.22.2__tar.gz

{docling_parse-7.22.0 → docling_parse-7.22.2}/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [v7.22.2](https://github.com/docling-project/docling-parse/releases/tag/v7.22.2) - 2026-10-05
+
+### Fix
+
+* Ignore malformed ToUnicode bfranges instead of reserving ~4G map entries ([#381](https://github.com/docling-project/docling-parse/issues/381)) ([`6d7ccf2`](https://github.com/docling-project/docling-parse/commit/6d7ccf26d09a38a86a08a8fadaf46987766b53e0))
+* Take the pattern name by value in do_pattern_fill ([#382](https://github.com/docling-project/docling-parse/issues/382)) ([`92ee655`](https://github.com/docling-project/docling-parse/commit/92ee6553b102a7984998abbe4ddea646b45db6c8))
+* Read font directory env vars wide on Windows ([#364](https://github.com/docling-project/docling-parse/issues/364)) ([`0c0eff2`](https://github.com/docling-project/docling-parse/commit/0c0eff2def1b7a594bcb536e7b0dc546524ae5d9))
+* Translate widget and hyperlink rects to the page boundary ([#376](https://github.com/docling-project/docling-parse/issues/376)) ([`6b5b6fd`](https://github.com/docling-project/docling-parse/commit/6b5b6fd0c70fbcde43bc35d0dad004047fdee7a2))
+
+## [v7.22.1](https://github.com/docling-project/docling-parse/releases/tag/v7.22.1) - 2026-09-28
+
+### Fix
+
+* Updated the page_item_sanitators/cells.h and its associated ground-truth ([#361](https://github.com/docling-project/docling-parse/issues/361)) ([`96960c3`](https://github.com/docling-project/docling-parse/commit/96960c3f13af88dd89037fd6fb681fdb5281a497))
+* **sanitizer:** Fold curly double quotes to `"`, not `'` ([#349](https://github.com/docling-project/docling-parse/issues/349)) ([`ea4a14d`](https://github.com/docling-project/docling-parse/commit/ea4a14d3ed1bab7fb3521b3e8f4db38f83a32eaf))
+
 ## [v7.22.0](https://github.com/docling-project/docling-parse/releases/tag/v7.22.0) - 2026-09-26
 
 ### Feature

{docling_parse-7.22.0 → docling_parse-7.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.22.0
+Version: 7.22.2
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.22.0 → docling_parse-7.22.2}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.22.0
+Version: 7.22.2
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.22.0 → docling_parse-7.22.2}/docling_parse.egg-info/SOURCES.txt

@@ -767,6 +767,7 @@ tests/test_unit_load_failure.py
 tests/test_unit_nul_mapping.py
 tests/test_unit_page_count.py
 tests/test_unit_patterns.py
+tests/test_unit_quote_sanitization.py
 tests/test_unit_rotated_cell_contraction.py
 tests/test_unit_shading.py
 tests/test_unit_shadings.py

{docling_parse-7.22.0 → docling_parse-7.22.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.22.0"
+version = "7.22.2"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]
@@ -46,7 +46,8 @@ requires = [
     "cibuildwheel>=2.19.2,<4.0.0; python_version >= '3.11'",
     "wheel>=0.43.0,<1.0.0",
     "delocate>=0.11.0,<1.0.0",
-    "cmake>=3.27.0,<4.0.0"
+    "cmake>=3.27.0,<5.0.0; sys_platform != 'win32'",
+    "cmake>=4.2.0,<5.0.0; sys_platform == 'win32'"
 ]
 build-backend = "setuptools.build_meta"
 
@@ -58,7 +59,8 @@ build = [
     "cibuildwheel>=2.19.2,<4.0.0; python_version >= '3.11'",
     "wheel>=0.43.0,<1.0.0",
     "delocate>=0.11.0,<1.0.0",
-    "cmake>=3.27.0,<4.0.0"
+    "cmake>=3.27.0,<5.0.0; sys_platform != 'win32'",
+    "cmake>=4.2.0,<5.0.0; sys_platform == 'win32'"
 ]
 dev = [
     "pytest>=9.0.3,<10.0.0",
@@ -155,6 +157,7 @@ max-complexity = 30
 combine-as-imports = true
 
 [tool.mypy]
+exclude = "^tests/data/"
 pretty = true
 no_implicit_optional = true
 namespace_packages = true

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/page_item_sanitators/cells.h

@@ -374,9 +374,9 @@ namespace pdflib
      * two-cluster k-means separates ordinary character gaps from dilated word
      * gaps. Sparse or insufficiently separated samples use a conservative
      * default threshold of 0.25; valid inferred thresholds are clamped to at
-     * least 0.18. Runs containing explicit spaces do not use this inferred
-     * threshold: those source-level boundaries are authoritative, with only
-     * jumps larger than one character advance allowed to add a boundary.
+     * least 0.18. Contraction caps the resulting threshold at 0.35 so a much
+     * larger gap elsewhere in a short line cannot hide a word boundary.
+     * Runs containing explicit spaces use the same cap for unmarked gaps.
      *
      * @param run One line of cells in source order.
      * @return Dimensionless normalized gap above which a new word begins.
@@ -408,9 +408,8 @@ namespace pdflib
      *
      * Builds line runs and treats explicit space cells as authoritative
      * boundaries. Runs without them infer a line-local cursor-placement gap
-     * threshold. Runs with them tolerate ordinary inner-word placement
-     * variation, while still splitting absolute-positioned fields separated
-     * by more than one neighboring character advance. Words are then merged
+     * threshold. Both kinds of runs split unmarked gaps above 0.35 neighboring
+     * character advances. Words are then merged
      * with normalized spaces into one line. Both levels retain maximum
      * enclosing rotation-aligned bounding boxes.
      * Visible glyphs without a recoverable Unicode mapping retain their U+FFFD
@@ -464,7 +463,7 @@ namespace pdflib
   inline bool page_item_sanitator<PAGE_CELLS>::is_semantic_space(
       const page_item<PAGE_CELL>& cell)
   {
-    return cell.is_pdf_word_space or
+    return (cell.is_pdf_word_space and cell.text_is_suppressed_glyph) or
            (not cell.text_is_suppressed_glyph and
             utils::string::is_space(cell.text));
   }
@@ -892,19 +891,18 @@ namespace pdflib
     contraction_result result;
     for(auto& run : collect_line_runs(cells))
       {
-        // Explicit PDF spaces are authoritative normal boundaries. On those
-        // lines only a jump larger than a complete neighboring advance may
-        // add another boundary; this still separates absolutely positioned
-        // table fields without splitting a word merely because its glyph ink
-        // or placement has an irregular space-sized gap.
-        const double word_gap = run.has_semantic_spaces
-          ? 1.0 : infer_word_gap(run);
+        // Explicit PDF spaces remain authoritative boundaries. Cap unmarked
+        // gaps as well: a large section-number gap can otherwise raise the
+        // inferred threshold past every word gap in a short heading.
+        const double word_gap = std::min(
+          0.35, run.has_semantic_spaces ? 1.0 : infer_word_gap(run));
         std::vector<page_item<PAGE_CELL>> words;
         page_item<PAGE_CELL>* previous_visible = nullptr;
         bool explicit_boundary = false;
 
-        for(auto& cell : run.cells)
+        for(std::size_t index = 0; index < run.cells.size(); ++index)
           {
+            auto& cell = run.cells[index];
             if(is_semantic_space(cell))
               {
                 explicit_boundary = true;
@@ -912,6 +910,19 @@ namespace pdflib
               }
 
             bool starts_word = words.empty() or explicit_boundary;
+            // TOC leaders may omit the boundary before their first dot while
+            // explicitly spacing every subsequent dot. Keep that first dot
+            // with the leader instead of attaching it to the heading.
+            if(not starts_word and cell.text == "." and
+               index + 4 < run.cells.size() and
+               is_semantic_space(run.cells[index + 1]) and
+               run.cells[index + 2].text == "." and
+               is_semantic_space(run.cells[index + 3]) and
+               run.cells[index + 4].text == "." and
+               previous_visible != nullptr and previous_visible->text != ".")
+              {
+                starts_word = true;
+              }
             if(not starts_word and previous_visible != nullptr)
               {
                 if(not word_baselines_compatible(*previous_visible, cell))

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/page_item_sanitators/page_dimension.h

@@ -22,6 +22,12 @@ namespace pdflib
 
     void sanitize(page_item<PAGE_IMAGES>& images, std::string page_boundary);
 
+    // Annotation rectangles (widgets, hyperlinks) are only moved onto the
+    // page boundary, never dropped: a form field outside the crop box is
+    // still part of the form.
+    template<typename annots_type>
+    void translate(annots_type& annots, std::string page_boundary);
+
   private:
 
     std::array<double, 4> get_page_boundary(std::string page_boundary);
@@ -410,6 +416,22 @@ namespace pdflib
     */
   }
 
+  template<typename annots_type>
+  void page_item_sanitator<PAGE_DIMENSION>::translate(annots_type& annots, std::string page_boundary)
+  {
+    LOG_S(INFO) << __FUNCTION__;
+
+    std::array<double, 4> page_bbox = get_page_boundary(page_boundary);
+
+    for(auto& annot : annots)
+      {
+        annot.x0 -= page_bbox[0];
+        annot.y0 -= page_bbox[1];
+        annot.x1 -= page_bbox[0];
+        annot.y1 -= page_bbox[1];
+      }
+  }
+
   void page_item_sanitator<PAGE_DIMENSION>::transform(std::array<double, 2>& v,
 						std::array<double, 2>& r)
   {

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/page_items/page_hyperlink.h

@@ -59,6 +59,10 @@ namespace pdflib
 
     utils::values::translate_inplace(delta, x0, y0);
     utils::values::translate_inplace(delta, x1, y1);
+
+    // the two corners rotate independently: restore bottom-left/top-right
+    if(x1 < x0) { std::swap(x0, x1); }
+    if(y1 < y0) { std::swap(y0, y1); }
   }
 
 }

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/page_items/page_widget.h

@@ -79,6 +79,10 @@ namespace pdflib
 
     utils::values::translate_inplace(delta, x0, y0);
     utils::values::translate_inplace(delta, x1, y1);
+
+    // the two corners rotate independently: restore bottom-left/top-right
+    if(x1 < x0) { std::swap(x0, x1); }
+    if(y1 < y0) { std::swap(y0, y1); }
   }
 
 }

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/pdf_decoders/page.h

@@ -920,6 +920,8 @@ namespace pdflib
       sanitator.sanitize(page_cells, config.page_boundary);
       sanitator.sanitize(page_shapes, config.page_boundary);
       sanitator.sanitize(page_images, config.page_boundary);
+      sanitator.translate(page_widgets, config.page_boundary);
+      sanitator.translate(page_hyperlinks, config.page_boundary);
 
       // the same boundary the sanitator subtracted from the cells, read after
       // rotate_contents() so it is already in the rotated space

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/pdf_decoders/stream.h

@@ -103,7 +103,11 @@ namespace pdflib
     // `scn` naming a tiling pattern: replay the pattern cell across the page
     // box, clipped to the path being filled. `even_odd` is that path's fill
     // rule. Returns false when the pattern cannot be resolved or painted.
-    bool do_pattern_fill(const std::string& pattern_name, bool even_odd);
+    // `pattern_name` is taken by value: callers pass the fill pattern name
+    // held by the current graphics state, and painting the pattern pushes a
+    // new state (`q`), which can reallocate the state stack and leave a
+    // reference dangling.
+    bool do_pattern_fill(std::string pattern_name, bool even_odd);
     bool do_coons_patch_pattern_fill(const std::string& pattern_name,
                                      pdf_resource<PAGE_PATTERN>& pattern,
                                      bool even_odd);
@@ -1256,7 +1260,7 @@ namespace pdflib
   // 8.7.4.5: `sh` paints the named shading over the whole current clip
   // region, taking its colours from the shading's own colour space and
   // function rather than from the current fill colour.
-  bool pdf_decoder<STREAM>::do_pattern_fill(const std::string& pattern_name,
+  bool pdf_decoder<STREAM>::do_pattern_fill(std::string pattern_name,
                                             bool even_odd)
   {
     if(not page_patterns or page_patterns->count(pattern_name) == 0)

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/pdf_resources/page_font/cmap.h

@@ -55,6 +55,14 @@ namespace pdflib
                    const std::string              src_end,
                    const std::vector<std::string> tgt);
 
+    // A bfrange is expanded code by code, so a corrupt bound (srcCode2 below
+    // srcCode1, or a span far wider than any code space) must be rejected
+    // before `end - begin + 1` wraps around and becomes a multi-gigabyte
+    // reservation. Same limit as the cidrange parser in font_cid.h.
+    static constexpr uint32_t max_range_length = 65536;
+
+    static bool is_valid_range(uint32_t begin, uint32_t end);
+
     // Helper to remove trailing null bytes from a string
     static void remove_trailing_nulls(std::string& str);
 
@@ -816,6 +824,19 @@ namespace pdflib
     _map[c] = tgt;
   }
 
+  bool cmap_parser::is_valid_range(uint32_t begin, uint32_t end)
+  {
+    if(begin <= end and (end - begin) < max_range_length)
+      {
+        return true;
+      }
+
+    LOG_S(WARNING) << "ignoring malformed bfrange: begin=" << begin
+                   << ", end=" << end << " (end must be >= begin and the range at most "
+                   << max_range_length << " codes)";
+    return false;
+  }
+
   void cmap_parser::set_range(const std::string src_begin,
                               const std::string src_end,
                               const std::string tgt)
@@ -840,6 +861,11 @@ namespace pdflib
                        << "'" << src_end << "' -> " << end;
       }
 
+    if(not is_valid_range(begin, end))
+      {
+        return;
+      }
+
     //LOG_S(INFO) << __FUNCTION__ << "\t"
     //<< "beg: " << begin << ", "
     //<< "end: " << end << "\t tgt: `" << tgt << "` with size: " << tgt.size();
@@ -896,6 +922,11 @@ namespace pdflib
     auto itr_end = src_end.begin();
     uint32_t end = utf8::next(itr_end, src_end.end());
 
+    if(not is_valid_range(begin, end))
+      {
+        return;
+      }
+
     // Pre-reserve capacity to avoid rehashing during bulk insertions
     _map.reserve(_map.size() + (end - begin + 1));
 

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/parse/pdf_sanitators/constants.h

@@ -66,10 +66,10 @@ namespace pdflib
       {"\u2019", "'"},
       {"\u201A", ","},
       {"\u201B", "'"},
-      {"\u201C", "'"},
-      {"\u201D", "'"},
-      {"\u201E", "'"},
-      {"\u201F", "'"},
+      {"\u201C", "\""},
+      {"\u201D", "\""},
+      {"\u201E", "\""},
+      {"\u201F", "\""},
       
       {"\u2212", "-"},
     };

{docling_parse-7.22.0 → docling_parse-7.22.2}/src/render/blend2d_font_resolver.h

@@ -183,7 +183,9 @@ namespace pdflib
     static int stem_weight(const std::string& stem);
     static bool stem_is_italic(const std::string& stem);
 
-    static std::optional<std::string> getenv_string(const char* name);
+    // Read wide on Windows: narrow getenv() yields ANSI-codepage bytes, which
+    // libstdc++ re-decodes as UTF-8 and rejects non-ASCII (docling-parse#354).
+    static std::optional<std::filesystem::path> getenv_path(const char* name);
     static void append_env_path(std::vector<std::filesystem::path>& paths,
                                 const char* env_name,
                                 const std::filesystem::path& suffix = {});
@@ -616,11 +618,19 @@ namespace pdflib
     return static_cast<int>(std::lround(cutoff * 10000.0f));
   }
 
-  inline std::optional<std::string> blend2d_font_resolver::getenv_string(const char* name)
+  inline std::optional<std::filesystem::path> blend2d_font_resolver::getenv_path(const char* name)
   {
+#if defined(_WIN32)
+    // Variable names are ASCII; widen them without a codepage conversion.
+    const std::wstring wide_name(name, name + std::char_traits<char>::length(name));
+    const wchar_t* value = _wgetenv(wide_name.c_str());
+    if (value == nullptr or value[0] == L'\0') { return std::nullopt; }
+    return std::filesystem::path(value);
+#else
     const char* value = std::getenv(name);
     if (value == nullptr or value[0] == '\0') { return std::nullopt; }
-    return std::string(value);
+    return std::filesystem::path(value);
+#endif
   }
 
   inline void blend2d_font_resolver::append_env_path(
@@ -628,11 +638,10 @@ namespace pdflib
                                                      const char* env_name,
                                                      const std::filesystem::path& suffix)
   {
-    auto value = getenv_string(env_name);
-    if (not value.has_value()) { return; }
-    std::filesystem::path path(*value);
-    if (not suffix.empty()) { path /= suffix; }
-    paths.push_back(path);
+    auto path = getenv_path(env_name);
+    if (not path.has_value()) { return; }
+    if (not suffix.empty()) { *path /= suffix; }
+    paths.push_back(*path);
   }
 
   inline std::vector<std::filesystem::path> blend2d_font_resolver::system_font_directories()
@@ -677,9 +686,9 @@ namespace pdflib
     namespace fs = std::filesystem;
     std::vector<fs::path> paths;
 
-    if (auto override_path = getenv_string("DOCLING_PARSE_FALLBACK_FONT"))
+    if (auto override_path = getenv_path("DOCLING_PARSE_FALLBACK_FONT"))
       {
-        paths.emplace_back(*override_path);
+        paths.push_back(*override_path);
       }
 
     // Bundled fonts: sans before serif before mono (not alphabetical), so a
@@ -793,9 +802,9 @@ namespace pdflib
     namespace fs = std::filesystem;
     std::vector<fs::path> paths;
 
-    if (auto override_path = getenv_string("DOCLING_PARSE_ARABIC_FALLBACK_FONT"))
+    if (auto override_path = getenv_path("DOCLING_PARSE_ARABIC_FALLBACK_FONT"))
       {
-        paths.emplace_back(*override_path);
+        paths.push_back(*override_path);
       }
 
     // Filename stems of faces that carry Arabic, best first. The generic
@@ -1156,9 +1165,9 @@ namespace pdflib
     namespace fs = std::filesystem;
     std::vector<fs::path> paths;
 
-    if (auto override_path = getenv_string("DOCLING_PARSE_CJK_FALLBACK_FONT"))
+    if (auto override_path = getenv_path("DOCLING_PARSE_CJK_FALLBACK_FONT"))
       {
-        paths.emplace_back(*override_path);
+        paths.push_back(*override_path);
       }
 
     // Faces with CJK coverage, best first. Each entry is matched against both

{docling_parse-7.22.0 → docling_parse-7.22.2}/tests/README.md

@@ -131,10 +131,10 @@ helpers rather than `open()` when touching groundtruth:
 
 ```python
 from tests.groundtruth_io import (
-    groundtruth_exists,      # true for either encoding
-    load_groundtruth_json,   # read, auto-detecting encoding
-    dump_groundtruth_json,   # write, following DOCLING_PARSE_GT_FORMAT
-    load_segmented_page,     # SegmentedPdfPage from either encoding
+    groundtruth_exists,  # true for either encoding
+    load_groundtruth_json,  # read, auto-detecting encoding
+    dump_groundtruth_json,  # write, following DOCLING_PARSE_GT_FORMAT
+    load_segmented_page,  # SegmentedPdfPage from either encoding
     read_groundtruth_text,
     write_groundtruth_text,
     resolve_groundtruth_path,  # the path actually on disk, for error messages

{docling_parse-7.22.0 → docling_parse-7.22.2}/tests/constants.py

@@ -1,7 +1,7 @@
 from tests.regression_page_selection import REGRESSION_PAGE_SELECTION
 
 HF_DATASET_REPO_ID = "docling-project/regression-dataset-for-docling-parse"
-HF_DATASET_REVISION = "65fd81c730024c5b989907bae9621603ba86b1b2"
+HF_DATASET_REVISION = "6d3458e2a6a729defd700a7b91e57b6cb2ce0290"
 
 REGRESSION_DIR = "tests/data/regression"
 

{docling_parse-7.22.0 → docling_parse-7.22.2}/tests/test_regression_cell_contraction.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 """Targeted regressions for adaptive character-to-word contraction."""
 
+from io import BytesIO
 from pathlib import Path
 
 from docling_parse.pdf_parser import DecodeConfig, DoclingPdfParser
@@ -8,6 +9,53 @@ from docling_parse.pdf_parser import DecodeConfig, DoclingPdfParser
 DATA = Path(__file__).parent / "data" / "regression"
 
 
+def _pdf_with_code_32_period() -> BytesIO:
+    """Map source byte 32 to a dot through /ToUnicode."""
+    cmap = (
+        b"/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n"
+        b"/CMapName /Repro def\n/CMapType 2 def\n"
+        b"1 begincodespacerange\n<00> <FF>\nendcodespacerange\n"
+        b"1 beginbfchar\n<20> <002E>\nendbfchar\n"
+        b"endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend\n"
+    )
+    content = b"BT /F1 24 Tf 72 700 Td <3820383331> Tj ET"
+
+    def stream(data: bytes) -> bytes:
+        return f"<< /Length {len(data)} >>\nstream\n".encode() + data + b"\nendstream"
+
+    objects = [
+        b"<< /Type /Catalog /Pages 2 0 R >>",
+        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+        b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] "
+        b"/Resources << /Font << /F1 4 0 R >> >> /Contents 6 0 R >>",
+        b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /ToUnicode 5 0 R >>",
+        stream(cmap),
+        stream(content),
+    ]
+    pdf = bytearray(b"%PDF-1.7\n")
+    offsets = []
+    for number, obj in enumerate(objects, 1):
+        offsets.append(len(pdf))
+        pdf += f"{number} 0 obj\n".encode() + obj + b"\nendobj\n"
+    xref = len(pdf)
+    pdf += f"xref\n0 {len(objects) + 1}\n0000000000 65535 f \n".encode()
+    for offset in offsets:
+        pdf += f"{offset:010d} 00000 n \n".encode()
+    pdf += (
+        f"trailer\n<< /Size {len(objects) + 1} /Root 1 0 R >>\n"
+        f"startxref\n{xref}\n%%EOF\n"
+    ).encode()
+    return BytesIO(pdf)
+
+
+def test_source_code_32_can_decode_to_a_visible_glyph():
+    document = DoclingPdfParser(loglevel="fatal").load(_pdf_with_code_32_period())
+    try:
+        assert [cell.text for cell in document.get_page(1).word_cells] == ["8.831"]
+    finally:
+        document.unload()
+
+
 def _page(filename: str, page_no: int, *, keep_glyphs: bool = False):
     document = DoclingPdfParser(loglevel="fatal").load(
         path_or_stream=DATA / filename,
@@ -31,6 +79,39 @@ def test_newspaper_uses_local_dilation_for_word_boundaries():
     assert all(" " not in word for word in words)
 
 
+def test_short_headings_keep_inferred_word_boundaries():
+    page = _page("2305.03393v1-pg9.pdf", 1)
+    lines = [cell.text for cell in page.textline_cells]
+
+    assert "5.1 Hyper Parameter Optimization" in lines
+    assert "5.2 Quantitative Results" in lines
+
+
+def test_positioned_prose_and_headers_keep_word_boundaries():
+    paper = _page("2203.01017v2.pdf", 1)
+    assert any("custom OCR decoders" in cell.text for cell in paper.textline_cells)
+
+    details = _page("2203.01017v2.pdf", 6)
+    assert "5.1. Implementation Details" in [
+        cell.text for cell in details.textline_cells
+    ]
+
+    layout = _page("2206.01062.pdf", 3)
+    assert any(
+        "DocLayNet: A Large Human-Annotated Dataset for Document-Layout Analysis"
+        in cell.text
+        for cell in layout.textline_cells
+    )
+
+
+def test_first_toc_leader_dot_does_not_attach_to_heading():
+    page = _page("redp5110_sampled.pdf", 2)
+    words = [cell.text for cell in page.word_cells]
+
+    assert "Roles" in words
+    assert "Roles." not in words
+
+
 def test_elsevier_reference_words_do_not_contract_together():
     page = _page("elsevier-00.pdf", 9)
     words = [cell.text for cell in page.word_cells]

{docling_parse-7.22.0 → docling_parse-7.22.2}/tests/test_unit_acroform_widgets.py

@@ -3,7 +3,8 @@
 
 from io import BytesIO
 
-from docling_core.types.doc.page import PdfWidget
+import pytest
+from docling_core.types.doc.page import PdfPageBoundaryType, PdfWidget
 
 from docling_parse.pdf_parser import (
     DecodeConfig,
@@ -118,3 +119,50 @@ def test_acroform_widget_contract_matches_threaded_parser():
 
     assert [_widget_data(widget) for widget in sequential] == expected
     assert [_widget_data(widget) for widget in threaded] == expected
+
+
+def _shifted_crop_box_pdf(rotate: int) -> bytes:
+    # Media box at the origin, crop box at (50, 40). The widget and the link
+    # both frame the word ``Hello`` drawn at user-space (100, 120).
+    return build_pdf(
+        [
+            "<< /Type /Catalog /Pages 2 0 R /AcroForm << /Fields [6 0 R] >> >>",
+            "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+            "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 400 300] "
+            f"/CropBox [50 40 350 240] /Rotate {rotate} "
+            "/Resources << /Font << /F1 5 0 R >> >> "
+            "/Contents 4 0 R /Annots [6 0 R 7 0 R] >>",
+            content_stream("BT /F1 12 Tf 100 120 Td (Hello) Tj ET\n"),
+            "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+            "<< /Type /Annot /Subtype /Widget /FT /Tx /T (name) "
+            "/Rect [95 110 145 140] >>",
+            "<< /Type /Annot /Subtype /Link /Rect [95 110 145 140] "
+            "/A << /S /URI /URI (https://example.com) >> >>",
+        ]
+    )
+
+
+@pytest.mark.parametrize("rotate", [0, 90, 180, 270])
+@pytest.mark.parametrize(
+    "boundary_type", [PdfPageBoundaryType.CROP_BOX, PdfPageBoundaryType.MEDIA_BOX]
+)
+def test_widgets_and_hyperlinks_share_the_text_cells_boundary_frame(
+    rotate: int, boundary_type: PdfPageBoundaryType
+):
+    document = DoclingPdfParser(loglevel="fatal").load(
+        BytesIO(_shifted_crop_box_pdf(rotate)),
+        boundary_type=boundary_type,
+        decode_config=DecodeConfig(keep_qpdf_warnings=False),
+    )
+    page = document.get_page(1)
+
+    word = next(c for c in page.word_cells if c.text == "Hello").rect.to_bounding_box()
+    (widget,) = page.widgets
+    (hyperlink,) = page.hyperlinks
+
+    for annot in (widget, hyperlink):
+        box = annot.rect.to_bounding_box()
+        assert (annot.rect.r_x0, annot.rect.r_y0) == pytest.approx((box.l, box.b))
+        assert sorted((box.width, box.height)) == pytest.approx([30.0, 50.0])
+        assert box.l <= word.l and word.r <= box.r
+        assert box.b <= min(word.b, word.t) and max(word.b, word.t) <= box.t