docling-parse 7.22.1__tar.gz → 7.22.3__tar.gz

{docling_parse-7.22.1 → docling_parse-7.22.3}/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [v7.22.3](https://github.com/docling-project/docling-parse/releases/tag/v7.22.3) - 2026-10-13
+
+### Fix
+
+* Unit stroke curves ([#407](https://github.com/docling-project/docling-parse/issues/407)) ([`30ae51f`](https://github.com/docling-project/docling-parse/commit/30ae51feb4ee4b4cc69c9e9aaee78eb74d4206fd))
+* **render:** Decode JBIG2 /Mask stencils ([#360](https://github.com/docling-project/docling-parse/issues/360)) ([`e0e678c`](https://github.com/docling-project/docling-parse/commit/e0e678ce182a8a9b1b143e50251b51048ad767e4))
+
+## [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

{docling_parse-7.22.1 → docling_parse-7.22.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.22.1
+Version: 7.22.3
 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.1 → docling_parse-7.22.3}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.22.1
+Version: 7.22.3
 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.1 → docling_parse-7.22.3}/docling_parse.egg-info/SOURCES.txt

@@ -762,6 +762,7 @@ tests/test_unit_gid_glyph_names.py
 tests/test_unit_glyph_proportions.py
 tests/test_unit_indexed_images.py
 tests/test_unit_invalid_font_metrics.py
+tests/test_unit_jbig2_masks.py
 tests/test_unit_jpeg_images.py
 tests/test_unit_load_failure.py
 tests/test_unit_nul_mapping.py
@@ -774,6 +775,7 @@ tests/test_unit_shadings.py
 tests/test_unit_shape_boundary_origin.py
 tests/test_unit_shape_queries_page_frame.py
 tests/test_unit_standard_font_widths.py
+tests/test_unit_stroke_curves.py
 tests/test_unit_text_render_modes.py
 tests/test_unit_threaded_page_range.py
 tests/test_unit_tounicode_fallback.py

{docling_parse-7.22.1 → docling_parse-7.22.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.22.1"
+version = "7.22.3"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]

{docling_parse-7.22.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/src/parse/pdf_resources/page_xobject_image.h

@@ -4,6 +4,7 @@
 #define PDF_PAGE_XOBJECT_IMAGE_RESOURCE_H
 
 #include <parse/utils/ccitt/ccitt_utils.h>
+#include <third_party/pdfium_jbig2.h>
 
 #include <cstdint>
 #include <cstring>
@@ -1241,10 +1242,9 @@ namespace pdflib
         return;
       }
 
-    // A stencil mask is very often CCITTFax-compressed, which qpdf cannot
-    // defilter; decode it here. `ccitt::decode` yields one byte per pixel
-    // with 0 = dark.
-    std::vector<uint8_t> ccitt_samples;
+    // A stencil mask is very often CCITTFax- or JBIG2-compressed, which qpdf
+    // cannot defilter; decode it here into one byte per pixel with 0 = dark.
+    std::vector<uint8_t> mask_samples;
     if(not smask.has_decoded_stream_data())
       {
         QPDFObjectHandle mdict = qpdf_smask.getDict();
@@ -1269,10 +1269,10 @@ namespace pdflib
               }
 
             auto encoded = smask.get_codec_stream_data();
-            ccitt_samples = ccitt::decode(
+            mask_samples = ccitt::decode(
               reinterpret_cast<const uint8_t*>(encoded->getBuffer()),
               encoded->getSize(), sm_w, sm_h, ccitt_parms);
-            if(ccitt_samples.size() < static_cast<size_t>(sm_w) * sm_h)
+            if(mask_samples.size() < static_cast<size_t>(sm_w) * sm_h)
               {
                 LOG_S(WARNING) << "mask CCITT decode too small for xobject_key="
                                << xobject_key;
@@ -1280,6 +1280,41 @@ namespace pdflib
               }
             smask_bpc = 8;
           }
+        else if(filter.find("JBIG2Decode") != std::string::npos and
+                smask.has_codec_stream_data())
+          {
+            // MRC scans stencil their foreground layer with a JBIG2 mask.
+            // `jbig2_decode` returns packed 1bpp rows with 0 = black, so
+            // expanding each bit to 0x00/0xFF matches the CCITT samples above.
+            auto encoded = smask.get_codec_stream_data();
+            auto globals = smask.get_jbig2_globals_data();
+            const bool has_globals = globals and globals->getSize() > 0;
+            auto bits = jbig2_decode(
+              {reinterpret_cast<const uint8_t*>(encoded->getBuffer()), encoded->getSize()},
+              {has_globals ? reinterpret_cast<const uint8_t*>(globals->getBuffer()) : nullptr,
+               has_globals ? globals->getSize() : 0},
+              static_cast<uint32_t>(sm_w), static_cast<uint32_t>(sm_h));
+
+            const size_t pitch = (static_cast<size_t>(sm_w) + 7u) / 8u;
+            if(bits.size() < pitch * static_cast<size_t>(sm_h))
+              {
+                LOG_S(WARNING) << "mask JBIG2 decode failed for xobject_key="
+                               << xobject_key;
+                return;
+              }
+
+            mask_samples.resize(static_cast<size_t>(sm_w) * sm_h);
+            for(int row = 0; row < sm_h; ++row)
+              {
+                for(int col = 0; col < sm_w; ++col)
+                  {
+                    const uint8_t byte = bits[static_cast<size_t>(row) * pitch + col / 8];
+                    const bool bit = ((byte >> (7 - (col % 8))) & 1u) != 0;
+                    mask_samples[static_cast<size_t>(row) * sm_w + col] = bit ? 0xFFu : 0x00u;
+                  }
+              }
+            smask_bpc = 8;
+          }
         else
           {
             LOG_S(WARNING) << "SMask has no decoded stream data for xobject_key=" << xobject_key;
@@ -1296,7 +1331,7 @@ namespace pdflib
     // eight columns to be the whole row, so the transparent part of the image
     // keeps painting. Expand to one byte per sample first.
     std::vector<uint8_t> smask_unpacked;
-    if(smask_bpc != 8 and ccitt_samples.empty())
+    if(smask_bpc != 8 and mask_samples.empty())
       {
         const size_t row_bits = static_cast<size_t>(sm_w) * static_cast<size_t>(smask_bpc);
         const size_t row_bytes = (row_bits + 7u) / 8u;
@@ -1336,7 +1371,7 @@ namespace pdflib
       }
 
     const size_t smask_expected = static_cast<size_t>(sm_w) * sm_h;
-    if(smask_unpacked.empty() and ccitt_samples.empty()
+    if(smask_unpacked.empty() and mask_samples.empty()
        and smask_buf->getSize() < smask_expected)
       {
         LOG_S(WARNING) << "SMask decoded stream too small for xobject_key=" << xobject_key
@@ -1357,7 +1392,7 @@ namespace pdflib
     out->resize(static_cast<size_t>(dst_w) * dst_h);
 
     auto const* src =
-      not ccitt_samples.empty() ? ccitt_samples.data()
+      not mask_samples.empty() ? mask_samples.data()
       : not smask_unpacked.empty() ? smask_unpacked.data()
       : reinterpret_cast<uint8_t const*>(smask_buf->getBuffer());
     auto const decode = smask.get_decode_array();
@@ -1378,8 +1413,8 @@ namespace pdflib
                 alpha = jpeg::apply_decode_component(alpha, decode[0], decode[1]);
               }
             // Stencil (/Mask): a 1-sample masks the pixel OUT, the inverse
-            // of /SMask's alpha reading. ccitt::decode returns 0 = dark =
-            // sample 0 = painted, so the same inversion applies there.
+            // of /SMask's alpha reading. The CCITT and JBIG2 samples above use
+            // 0 = dark = sample 0 = painted, so the same inversion applies there.
             (*out)[static_cast<size_t>(row) * dst_w + col] =
               stencil ? static_cast<uint8_t>(255 - alpha) : alpha;
           }

{docling_parse-7.22.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/src/render/blend2d_renderer.h

@@ -1590,7 +1590,8 @@ namespace pdflib
     // the canvas-space bounding rectangle of all touched points. Control
     // points give a conservative bbox (a Bézier never leaves its control
     // polygon's hull), which is what the clip skip-test needs.
-    BLPath make_shape_path(const shape_instruction& instr, BLRect& bbox) const;
+    BLPath make_shape_path(const shape_instruction& instr, BLRect& bbox,
+                           bool flatten_curves = false) const;
 
     // Draws a semi-transparent yellow placeholder over the bitmap destination
     // quad. This makes missing or invalid image data visible in debug renders.
@@ -3673,10 +3674,49 @@ namespace pdflib
   // ---------------------------------------------------------------------------
 
   inline BLPath renderer<BLEND2D>::make_shape_path(const shape_instruction& instr,
-                                                   BLRect& bbox) const
+                                                   BLRect& bbox,
+                                                   bool flatten_curves) const
   {
     BLPath path;
 
+    // Blend2D's curve stroker can repeatedly split a near-cusp quadratic
+    // without making progress at floating-point precision. Feed strokes a
+    // polyline instead, keeping the original cubic geometry for fills.
+    // Comparing the controls with the chord's degree-elevated controls also
+    // detects collinear reversals and loops (distance to a line does not).
+    const auto append_flattened_cubic = [&](const auto& self,
+                                            BLPoint p0, BLPoint p1,
+                                            BLPoint p2, BLPoint p3,
+                                            unsigned depth) -> void
+    {
+      constexpr double tolerance = 0.05; // canvas pixels, independent of scale
+      constexpr unsigned max_depth = 20;
+      const double error1 = std::hypot(
+        p1.x - (p0.x * (2.0 / 3.0) + p3.x / 3.0),
+        p1.y - (p0.y * (2.0 / 3.0) + p3.y / 3.0));
+      const double error2 = std::hypot(
+        p2.x - (p0.x / 3.0 + p3.x * (2.0 / 3.0)),
+        p2.y - (p0.y / 3.0 + p3.y * (2.0 / 3.0)));
+      if (depth == max_depth or std::max(error1, error2) <= tolerance)
+        {
+          path.line_to(p3.x, p3.y);
+          return;
+        }
+
+      const auto midpoint = [](BLPoint a, BLPoint b)
+      {
+        return BLPoint(a.x * 0.5 + b.x * 0.5, a.y * 0.5 + b.y * 0.5);
+      };
+      const BLPoint p01 = midpoint(p0, p1);
+      const BLPoint p12 = midpoint(p1, p2);
+      const BLPoint p23 = midpoint(p2, p3);
+      const BLPoint p012 = midpoint(p01, p12);
+      const BLPoint p123 = midpoint(p12, p23);
+      const BLPoint mid = midpoint(p012, p123);
+      self(self, p0, p01, p012, mid, depth + 1);
+      self(self, mid, p123, p23, p3, depth + 1);
+    };
+
     double x_min = std::numeric_limits<double>::infinity();
     double y_min = std::numeric_limits<double>::infinity();
     double x_max = -std::numeric_limits<double>::infinity();
@@ -3733,7 +3773,17 @@ namespace pdflib
                 const double y3 = canvas_y(py[k + 2]);
                 k += 3;
 
-                path.cubic_to(x1, y1, x2, y2, x3, y3);
+                if (flatten_curves)
+                  {
+                    const BLPoint p0 = path.vertex_data()[path.size() - 1];
+                    append_flattened_cubic(append_flattened_cubic, p0,
+                                          BLPoint(x1, y1), BLPoint(x2, y2),
+                                          BLPoint(x3, y3), 0);
+                  }
+                else
+                  {
+                    path.cubic_to(x1, y1, x2, y2, x3, y3);
+                  }
                 accumulate(x1, y1);
                 accumulate(x2, y2);
                 accumulate(x3, y3);
@@ -3938,7 +3988,8 @@ namespace pdflib
                         << " (not implemented by the Blend2D stroker)";
           }
 
-        ctx.stroke_path(path);
+        BLRect stroke_bbox;
+        ctx.stroke_path(make_shape_path(instr, stroke_bbox, true));
       }
   }
 

{docling_parse-7.22.1 → docling_parse-7.22.3}/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.1 → docling_parse-7.22.3}/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

{docling_parse-7.22.1 → docling_parse-7.22.3}/tests/test_unit_cmap_encoding.py

@@ -47,6 +47,7 @@ def _identity_h_pdf(
     text_bytes: str,
     to_unicode: bool,
     default_width: str = "",
+    to_unicode_cmap: str = TO_UNICODE_AB,
 ) -> bytes:
     """A page setting two-byte codes in a non-embedded Identity-H font."""
     content = f"BT\n/F1 {FONT_SIZE} Tf\n20 100 Td\n<{text_bytes}> Tj\nET\n"
@@ -63,7 +64,7 @@ def _identity_h_pdf(
         "<< /Type /Font /Subtype /CIDFontType2 /BaseFont /Test-Identity "
         "/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> "
         f"/FontDescriptor 8 0 R{default_width} >>",
-        stream_object("", TO_UNICODE_AB.encode("latin-1")),
+        stream_object("", to_unicode_cmap.encode("latin-1")),
         "<< /Type /FontDescriptor /FontName /Test-Identity /Flags 4 "
         "/FontBBox [0 -200 1000 800] /ItalicAngle 0 /Ascent 800 /Descent -200 "
         "/CapHeight 700 /StemV 80 >>",
@@ -146,3 +147,42 @@ def test_explicit_dw_is_honoured():
     assert width == pytest.approx(FONT_SIZE, rel=0.2), (
         f"two glyphs at /DW 500 measured {width:.1f}pt, expected about {FONT_SIZE}pt"
     )
+
+
+TO_UNICODE_REVERSED_RANGE = """/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CMapName /Test-UCS2 def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+2 beginbfrange
+<FFFF> <00FF> <0058>
+<0001> <0002> <0041>
+endbfrange
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end"""
+
+
+def test_reversed_bfrange_is_ignored():
+    """A bfrange whose end lies below its start is skipped, not expanded.
+
+    Its size, `end - begin + 1`, wrapped around in unsigned arithmetic to about
+    four billion codes; reserving a map that large threw std::bad_alloc, or,
+    with no memory limit, used all the memory the machine had. Such ranges
+    occur in real subset fonts (seen: `<ffff> <00ff>` in a ToUnicode CMap
+    written by an optimiser). The well-formed range next to it must still map.
+    """
+    text = _text(
+        _identity_h_pdf(
+            text_bytes="00010002",
+            to_unicode=True,
+            to_unicode_cmap=TO_UNICODE_REVERSED_RANGE,
+        )
+    )
+    assert text == "AB", (
+        f"expected the valid bfrange to map the codes to 'AB', got {text!r}"
+    )