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

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

@@ -1,3 +1,32 @@
+## [v7.22.4](https://github.com/docling-project/docling-parse/releases/tag/v7.22.4) - 2026-10-21
+
+### Fix
+
+* Allow Pillow 13 ([#420](https://github.com/docling-project/docling-parse/issues/420)) ([`fbe3190`](https://github.com/docling-project/docling-parse/commit/fbe31904e81093c4f4a4f2ea3f5d1f8d36b0962c))
+
+## [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
+
+* 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.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.22.0
+Version: 7.22.4
 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
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pillow<13.0.0,>=10.0.0
+Requires-Dist: pillow<14.0.0,>=10.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: docling-core<3.0.0,>=2.99.0
 Requires-Dist: pywin32>=305; sys_platform == "win32"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.22.0
+Version: 7.22.4
 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
@@ -23,7 +23,7 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pillow<13.0.0,>=10.0.0
+Requires-Dist: pillow<14.0.0,>=10.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: docling-core<3.0.0,>=2.99.0
 Requires-Dist: pywin32>=305; sys_platform == "win32"

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

@@ -762,17 +762,20 @@ 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
 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
 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.0 → docling_parse-7.22.4}/docling_parse.egg-info/requires.txt

@@ -1,4 +1,4 @@
-pillow<13.0.0,>=10.0.0
+pillow<14.0.0,>=10.0.0
 pydantic>=2.0.0
 docling-core<3.0.0,>=2.99.0
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.22.0"
+version = "7.22.4"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]
@@ -29,7 +29,7 @@ authors = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "pillow>=10.0.0,<13.0.0",
+    "pillow>=10.0.0,<14.0.0",
     "pydantic>=2.0.0",
     "docling-core>=2.99.0,<3.0.0",
     "pywin32>=305; sys_platform == 'win32'",
@@ -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.4}/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.4}/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.4}/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.4}/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.4}/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.4}/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.4}/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.4}/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.0 → docling_parse-7.22.4}/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.4}/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