docling-parse 7.13.0__tar.gz → 7.14.0__tar.gz

{docling_parse-7.13.0 → docling_parse-7.14.0}/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [v7.14.0](https://github.com/docling-project/docling-parse/releases/tag/v7.14.0) - 2026-08-18
+
+### Feature
+
+* **render:** Clip paths, masks, CMYK/Indexed images, font fallback, Symbol brackets ([#321](https://github.com/docling-project/docling-parse/issues/321)) ([`366c913`](https://github.com/docling-project/docling-parse/commit/366c9138019ad1ed2f844ace75fc15839af2c1a0))
+
+### Fix
+
+* Emit glyph marker instead of fabricated encoding text for symbolic-font cmap misses ([#299](https://github.com/docling-project/docling-parse/issues/299)) ([`13e2ee3`](https://github.com/docling-project/docling-parse/commit/13e2ee331eab71bd39d171a5680e88b8a1680e25))
+* Emit glyph marker for glyph-index names instead of leaking them as text ([#302](https://github.com/docling-project/docling-parse/issues/302)) ([`54ad7cc`](https://github.com/docling-project/docling-parse/commit/54ad7ccac66198ed9ecc5d8be866852f440931f6))
+
 ## [v7.13.0](https://github.com/docling-project/docling-parse/releases/tag/v7.13.0) - 2026-08-14
 
 ### Feature

{docling_parse-7.13.0 → docling_parse-7.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.13.0
+Version: 7.14.0
 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.13.0 → docling_parse-7.14.0}/app/pybind_parse.cpp

@@ -138,6 +138,7 @@ namespace
       pybind11::dict row;
       row["type"] = instruction_name(pdflib::BITMAP_RENDER_INSTRUCTION);
       row["xobject_key"] = instr.get_key();
+      row["source"] = pdflib::to_string(instr.get_source());
       row["shape"] = instr.get_shape();
       row["pixel_format"] = pixel_format_name(instr.get_pixel_format());
       row["image_mask"] = instr.is_image_mask();
@@ -239,6 +240,7 @@ namespace
       pybind11::dict row;
       row["index"] = bitmap_index;
       row["xobject_key"] = instr.get_key();
+      row["source"] = pdflib::to_string(instr.get_source());
       row["shape"] = instr.get_shape();
       row["pixel_format"] = pixel_format_name(instr.get_pixel_format());
       row["image_mask"] = instr.is_image_mask();

{docling_parse-7.13.0 → docling_parse-7.14.0}/docling_parse.egg-info/PKG-INFO

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

@@ -680,6 +680,8 @@ tests/test_colorspace.py
 tests/test_colorspaces.py
 tests/test_embedded_fonts.py
 tests/test_font_fallback.py
+tests/test_font_name_resolution.py
+tests/test_gid_glyph_names.py
 tests/test_indexed_images.py
 tests/test_load_failure.py
 tests/test_locale_safety.py
@@ -692,7 +694,9 @@ tests/test_standard_font_widths.py
 tests/test_text_render_modes.py
 tests/test_threaded_parse.py
 tests/test_threaded_render.py
+tests/test_tounicode_fallback.py
 tests/test_transparency.py
 tests/test_type3_fonts.py
 tests/test_vertical_writing.py
+tests/test_widget_appearances.py
 tests/update_groundtruth.py

{docling_parse-7.13.0 → docling_parse-7.14.0}/pyproject.toml

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

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/enums.h

@@ -297,6 +297,29 @@ namespace pdflib
     BLEND_MODE_LUMINOSITY,
   };
 
+  // What a bitmap instruction is a picture OF. A Type3 glyph procedure is
+  // rasterised into an image mask and painted through the very same bitmap
+  // path as page artwork (see pdf_state<TEXT>), so without this the two are
+  // indistinguishable downstream: one page of Type3 text yields a bitmap per
+  // painted character, drowning the handful of real images among them.
+  enum bitmap_source {
+    BITMAP_SOURCE_XOBJECT,      // an image XObject painted by `Do`
+    BITMAP_SOURCE_INLINE,       // an inline image (BI ... ID ... EI)
+    BITMAP_SOURCE_TYPE3_GLYPH,  // the mask of one Type3 glyph procedure
+  };
+
+  inline std::string to_string(bitmap_source source)
+  {
+    switch(source)
+      {
+      case BITMAP_SOURCE_XOBJECT:     return "xobject";
+      case BITMAP_SOURCE_INLINE:      return "inline";
+      case BITMAP_SOURCE_TYPE3_GLYPH: return "type3_glyph";
+      }
+
+    return "unknown";
+  }
+
   // State of an ExtGState /SMask entry. A present soft mask is the one
   // transparency parameter whose omission makes the output wrong rather than
   // merely approximate, so absent and /None are kept apart.

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/page_items/page_image.h

@@ -77,6 +77,8 @@ namespace pdflib
     std::shared_ptr<Buffer>  raw_stream_data;
     std::shared_ptr<Buffer>  decoded_stream_data;
     std::shared_ptr<std::vector<uint8_t>> soft_mask_data;
+    int soft_mask_width = 0;
+    int soft_mask_height = 0;
 
     // PDF image semantics copied from XObject
     bool decode_present = false;

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/page_items/render_instructions.h

@@ -42,7 +42,16 @@ namespace pdflib
     clip_path_instruction(std::vector<double> x,
                           std::vector<double> y,
                           page_shape_closing_type closing_type,
-                          page_shape_type shape_type);
+                          page_shape_type shape_type,
+                          int clip_group = 0);
+
+    // Subpaths captured by ONE W/W* operation share a group: together they
+    // form a single clip path under the clip's fill rule. Only paths of
+    // DIFFERENT groups intersect. Treating each subpath as its own clip and
+    // intersecting turned any multi-subpath clip (an outline-art stencil, a
+    // text-shaped clip) into an empty region, and the fill through it
+    // disappeared.
+    int get_clip_group() const { return clip_group; }
 
     const std::vector<double>& get_x() const { return x; }
     const std::vector<double>& get_y() const { return y; }
@@ -60,7 +69,7 @@ namespace pdflib
       for(auto& v : x_) { v += dx; }
       for(auto& v : y_) { v += dy; }
       return clip_path_instruction(std::move(x_), std::move(y_),
-                                   closing_type, shape_type);
+                                   closing_type, shape_type, clip_group);
     }
 
   private:
@@ -68,6 +77,7 @@ namespace pdflib
     std::vector<double> y;
     page_shape_closing_type closing_type;
     page_shape_type shape_type;
+    int clip_group = 0;
   };
 
   inline clip_path_instruction::clip_path_instruction():
@@ -80,11 +90,13 @@ namespace pdflib
   inline clip_path_instruction::clip_path_instruction(std::vector<double> x_,
                                                       std::vector<double> y_,
                                                       page_shape_closing_type closing_type_,
-                                                      page_shape_type shape_type_):
+                                                      page_shape_type shape_type_,
+                                                      int clip_group_):
     x(std::move(x_)),
     y(std::move(y_)),
     closing_type(closing_type_),
-    shape_type(shape_type_)
+    shape_type(shape_type_),
+    clip_group(clip_group_)
   {}
 
   class clip_state_instruction
@@ -479,6 +491,7 @@ namespace pdflib
                        double r_x1, double r_y1,
                        double r_x2, double r_y2,
                        double r_x3, double r_y3,
+                       bitmap_source source = BITMAP_SOURCE_XOBJECT,
                        clip_state_instruction clip_state = clip_state_instruction()):
       xobject_key(xobject_key),
       data(std::move(data)),
@@ -493,10 +506,17 @@ namespace pdflib
       r_x1(r_x1), r_y1(r_y1),
       r_x2(r_x2), r_y2(r_y2),
       r_x3(r_x3), r_y3(r_y3),
+      source(source),
       clip_state(std::move(clip_state)) {}
 
     const std::string& get_key() const { return xobject_key; }
 
+    // Whether this bitmap is page artwork or a rasterised Type3 glyph. The
+    // key spells it out too (`type3:...`, `__inline_image_...`), but that is
+    // a naming convention; this is the fact itself.
+    bitmap_source get_source() const { return source; }
+    bool is_glyph() const { return source == BITMAP_SOURCE_TYPE3_GLYPH; }
+
     const std::shared_ptr<std::vector<uint8_t> >& get_data() const { return data; }
     const std::shared_ptr<std::vector<uint8_t> >& get_alpha_data() const { return alpha_data; }
     cmyk_convention get_cmyk_convention() const { return cmyk_conv; }
@@ -555,6 +575,7 @@ namespace pdflib
     const double r_x3;
     const double r_y3;
 
+    const bitmap_source source;
     const clip_state_instruction clip_state;
   };
 

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/pdf_decoders/page.h

@@ -1802,8 +1802,64 @@ namespace pdflib
         page_shapes.push_back(shape);
       }
 
+    // The frame a field draws around itself is form chrome rather than page
+    // content, and painting it is what puts empty squares on a page: a
+    // producer that cannot embed a glyph is free to leave a bordered
+    // placeholder button in its place, and every one of those came out as a
+    // box no other renderer draws -- pdfium paints none of this even with the
+    // form environment initialised and form drawing asked for.
+    //
+    // What a field draws *inside* itself is content and is kept, a checkbox
+    // tick being the case that matters. The two are told apart by geometry:
+    // in appearance-stream coordinates the widget occupies (0, 0)-(w, h), so
+    // a subpath whose extent is that rectangle is the frame. The tolerance is
+    // the line width because a stroked border is inset by half of it, and it
+    // never reaches half the field, so a tick cannot be mistaken for a frame.
+    //
+    // Only the painting is dropped. The shape stays in the parsed output
+    // above, where it describes the field for anything reading geometry.
+    const double widget_w = bbox[2] - bbox[0];
+    const double widget_h = bbox[3] - bbox[1];
+
+    auto traces_the_widget_rect = [&](const shape_instruction& shape_instr)
+    {
+      if(widget_w <= 0.0 or widget_h <= 0.0) { return false; }
+
+      bool seen = false;
+      double x0 = 0.0, y0 = 0.0, x1 = 0.0, y1 = 0.0;
+
+      for(const auto& subpath : shape_instr.get_subpaths())
+        {
+          std::vector<double> xs = subpath.get_px();
+          std::vector<double> ys = subpath.get_py();
+          xs.push_back(subpath.get_x0());
+          ys.push_back(subpath.get_y0());
+
+          for(std::size_t l = 0; l < xs.size(); l++)
+            {
+              if(not seen) { x0 = x1 = xs[l]; y0 = y1 = ys[l]; seen = true; }
+              x0 = std::min(x0, xs[l]); x1 = std::max(x1, xs[l]);
+              y0 = std::min(y0, ys[l]); y1 = std::max(y1, ys[l]);
+            }
+        }
+
+      if(not seen) { return false; }
+
+      const double tol = std::max(1.0, shape_instr.get_line_width());
+      return (std::abs(x0 - 0.0)      <= tol and
+              std::abs(y0 - 0.0)      <= tol and
+              std::abs(x1 - widget_w) <= tol and
+              std::abs(y1 - widget_h) <= tol);
+    };
+
     for(const auto& shape_instr : ap_instructions.get_shape_instructions())
       {
+        if(traces_the_widget_rect(shape_instr))
+          {
+            LOG_S(INFO) << "skipping the frame of a widget appearance stream";
+            continue;
+          }
+
         instructions.add_shape_instruction(shape_instr.translated(ox, oy));
       }
 

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/pdf_decoders/stream.h

@@ -84,8 +84,9 @@ namespace pdflib
     void do_shading(const std::string& sh_name);
 
     // `scn` naming a tiling pattern: replay the pattern cell across the page
-    // box. Returns false when the pattern cannot be resolved or painted.
-    bool do_pattern_fill(const std::string& pattern_name);
+    // 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);
 
     // marked-content (BMC/BDC ... EMC) tracking, used to honor /ActualText
     // replacement text (PDF 32000-1, section 14.9.4)
@@ -645,7 +646,8 @@ 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(const std::string& pattern_name,
+                                            bool even_odd)
   {
     if(not page_patterns or page_patterns->count(pattern_name) == 0)
       {
@@ -780,6 +782,23 @@ namespace pdflib
         if(res.hasKey("/XObject"))   { QPDFObjectHandle o = res.getKey("/XObject");   page_xobjects_->set(o, timings); }
       }
 
+    // The path being filled bounds the pattern (PDF 32000-1, 8.7.3.1): the
+    // cells paint only inside it. Without this the lattice covered the whole
+    // page box, so a page whose pattern fill was one small shape came out with
+    // a block of cells in the corner that no other renderer draws.
+    //
+    // The capture has to happen before the cell placement matrix goes on:
+    // clips are transformed by the matrix current when they are captured, and
+    // after the `cm` below that is pattern space, not the space the path was
+    // built in.
+    this->q();
+    {
+      std::vector<qpdf_stream_instruction> no_parameters;
+      if(even_odd) { current_shape_state().WStar(no_parameters); }
+      else         { current_shape_state().W(no_parameters);     }
+      current_shape_state().n(no_parameters);
+    }
+
     bool painted = false;
 
     for(int iy = iy0; iy <= iy1; iy++)
@@ -831,6 +850,8 @@ namespace pdflib
           }
       }
 
+    this->Q();
+
     return painted;
   }
 
@@ -1747,7 +1768,7 @@ namespace pdflib
           if(current_graphic_state().get_fill_is_unresolved_pattern() and
              not current_graphic_state().get_fill_pattern_name().empty())
             {
-              do_pattern_fill(current_graphic_state().get_fill_pattern_name());
+              do_pattern_fill(current_graphic_state().get_fill_pattern_name(), false);
             }
           current_shape_state().f(parameters);
         }
@@ -1766,7 +1787,7 @@ namespace pdflib
           if(current_graphic_state().get_fill_is_unresolved_pattern() and
              not current_graphic_state().get_fill_pattern_name().empty())
             {
-              do_pattern_fill(current_graphic_state().get_fill_pattern_name());
+              do_pattern_fill(current_graphic_state().get_fill_pattern_name(), true);
             }
           current_shape_state().fStar(parameters);
         }

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/pdf_resources/page_colorspace.h

@@ -30,6 +30,13 @@ namespace pdflib
     // images use it to decide whether going through the transform is worth it.
     bool has_tint_transform() const;
 
+    // Number of tint components a Separation/DeviceN colour takes: one per
+    // colorant.
+    int tint_component_count() const
+    {
+      return static_cast<int>(colorant_names_.size());
+    }
+
     // Maps the numeric SC/SCN/sc/scn operands to RGB; returns false when
     // the space cannot interpret them (pattern, unknown family, wrong
     // operand count), in which case the caller keeps its own fallback.

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/pdf_resources/page_font/glyphs.h

@@ -8,6 +8,8 @@
 #include <unordered_set>
 #include <unordered_map>
 
+#include <map>
+
 namespace pdflib
 {
 
@@ -188,6 +190,32 @@ namespace pdflib
 
             std::string val_ = preprocess(val);
 
+            // The Adobe Glyph List places the Symbol font's bracket, brace and
+            // parenthesis PIECES -- the parts a typesetter stacks to build a
+            // tall delimiter around a matrix -- in the private-use area, where
+            // they were assigned before Unicode had them. Nothing but the
+            // original Symbol font maps that range, so a fallback face draws
+            // .notdef boxes down the sides of every matrix. Unicode has had
+            // these since 3.2 (Miscellaneous Technical, U+239B..U+23AD), and
+            // ordinary text faces carry them; rewrite the legacy codes to the
+            // real ones, which fixes both the render and the extracted text.
+            {
+              static const std::map<std::string, std::string> legacy_pua = {
+                {"F8EB", "239B"}, {"F8EC", "239C"}, {"F8ED", "239D"},  // ( pieces
+                {"F8F6", "239E"}, {"F8F7", "239F"}, {"F8F8", "23A0"},  // ) pieces
+                {"F8EE", "23A1"}, {"F8EF", "23A2"}, {"F8F0", "23A3"},  // [ pieces
+                {"F8F9", "23A4"}, {"F8FA", "23A5"}, {"F8FB", "23A6"},  // ] pieces
+                {"F8F1", "23A7"}, {"F8F2", "23A8"}, {"F8F3", "23A9"},  // { pieces
+                {"F8F4", "23AA"},                                       // brace ext
+                {"F8FC", "23AB"}, {"F8FD", "23AC"}, {"F8FE", "23AD"},  // } pieces
+                {"F8F5", "23AE"},                                       // integral ext
+                {"F8E7", "23AF"},                                       // horizontal ext
+                {"F8E6", "23D0"},                                       // vertical ext
+              };
+              auto it = legacy_pua.find(val_);
+              if(it != legacy_pua.end()) { val_ = it->second; }
+            }
+
             if(val_.size()%4==0 and name_to_utf8.count(key)==0)
               {
                 name_to_utf8[key] = utils::string::hex_to_utf8(val_, 4);

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/pdf_resources/page_font.h

@@ -115,6 +115,7 @@ namespace pdflib
   private:
 
     std::string get_correct_character(uint32_t c);
+    std::string resolve_unmapped_character(uint32_t c);
     std::string get_character_from_encoding(uint32_t c);
 
     std::shared_ptr<type3_glyph> parse_type3_charproc(const std::string& src);
@@ -161,6 +162,8 @@ namespace pdflib
     void init_cmap(pdf_timings& timings);
     void init_cmap_resource();
 
+    void init_font_flags();
+
     void init_differences();
 
     void init_charprocs();
@@ -193,6 +196,7 @@ namespace pdflib
     std::string        encoding_name;
     font_encoding_name encoding;
     bool               has_explicit_encoding; // true if encoding was found in PDF, false if defaulted
+    bool               is_symbolic = false;   // /FontDescriptor /Flags bit 3 (PDF 32000-1 table 123)
 
     font_subtype_name  subtype;
 
@@ -618,7 +622,7 @@ namespace pdflib
     else if(cmap_initialized and cmap_numb_to_char.count(c)>0)
       {
         return cmap_numb_to_char.at(c);
-      }         
+      }
     else if(bfonts.has_corresponding_font(font_name))
       {
         // check if the font-name is registered as a 'special' font, eg
@@ -634,7 +638,7 @@ namespace pdflib
         if(has_explicit_encoding &&
            (encoding == MACROMAN || encoding == MACEXPERT || encoding == WINANSI || encoding == STANDARD))
           {
-            return get_character_from_encoding(c);
+            return resolve_unmapped_character(c);
           }
         else if(fm.has(c))
           {
@@ -648,7 +652,7 @@ namespace pdflib
 	      << "; Encoding: " << to_string(_encoding)
 	      << "; font-name: " << font_name;
 	    */
-	    return get_character_from_encoding(c);
+	    return resolve_unmapped_character(c);
 	  }
 	else
 	  {
@@ -670,16 +674,57 @@ namespace pdflib
 			   << "; font-name: " << font_name
 			   << " (corresponding font: " << fontname << ")";
 
-	    return get_character_from_encoding(c);
+	    return resolve_unmapped_character(c);
 	  }
       }
     else
       {
 	//LOG_S(WARNING) << "no known font: " << font_name;
-        return get_character_from_encoding(c);
+        return resolve_unmapped_character(c);
       }
   }
 
+  void pdf_resource<PAGE_FONT>::init_font_flags()
+  {
+    const int FLAG_SYMBOLIC = 1 << 2; // /Flags bit 3 (PDF 32000-1 table 123)
+
+    int flags = 0;
+    if(not qpdf_object::get_int(qpdf_font, {"/FontDescriptor", "/Flags"}, flags))
+      {
+        qpdf_object::get_int(qpdf_desc_font, {"/FontDescriptor", "/Flags"}, flags);
+      }
+
+    is_symbolic = ((flags & FLAG_SYMBOLIC) != 0);
+
+    LOG_S(INFO) << __FUNCTION__ << ": flags=" << flags
+                << ", is_symbolic=" << is_symbolic;
+  }
+
+  std::string pdf_resource<PAGE_FONT>::resolve_unmapped_character(uint32_t c)
+  {
+    // Fallback for codes that none of the authoritative sources resolved
+    // (/Encoding/Differences, the /ToUnicode or predefined CID cmap, or a
+    // known base-font table). When an explicit cmap exists but does not
+    // cover this code, and the code bears no relation to the standard
+    // Latin encodings (symbolic font, or composite font whose codes are
+    // CIDs), the encoding tables would fabricate unrelated text — e.g. an
+    // Arabic ligature glyph subsetted at code 0x23 coming out as '#'
+    // (docling#3802). Emit a glyph marker instead, so downstream consumers
+    // can detect the unresolved glyph.
+    if(cmap_initialized and (is_symbolic or subtype==TYPE_0))
+      {
+        unknown_numbs[c] += 1;
+
+        LOG_S(WARNING) << "Symbol not in the cmap of a symbolic or composite font: "
+                       << int(c) << "; font-name: " << font_name
+                       << "; emitting glyph marker instead of encoding fallback";
+
+        return "GLYPH<" + std::to_string(c) + ">";
+      }
+
+    return get_character_from_encoding(c);
+  }
+
   std::string pdf_resource<PAGE_FONT>::get_character_from_encoding(uint32_t c)
   {
     auto& base_encoding = encodings.get(encoding).get_numb_to_utf8();
@@ -762,7 +807,9 @@ namespace pdflib
       
       init_encoding();
       init_subtype();
-      
+
+      init_font_flags();
+
       init_base_font();
       
       init_font_name();
@@ -1456,18 +1503,10 @@ namespace pdflib
     // then resolve glyphs by character code, not by Unicode text.
     bool uses_builtin_encoding = false;
     {
-      const int FLAG_SYMBOLIC = 1 << 2; // /Flags bit 3
-
-      int flags = 0;
-      if(not qpdf_object::get_int(qpdf_font, {"/FontDescriptor", "/Flags"}, flags))
-        {
-          qpdf_object::get_int(qpdf_desc_font, {"/FontDescriptor", "/Flags"}, flags);
-        }
-
       const bool has_encoding = qpdf_object::has_path(qpdf_font, {"/Encoding"});
 
       uses_builtin_encoding = (subtype != TYPE_0) and
-        ((flags & FLAG_SYMBOLIC) != 0) and (not has_encoding);
+        is_symbolic and (not has_encoding);
     }
 
     font_blob = std::make_shared<const embedded_font_blob>(
@@ -2265,11 +2304,21 @@ namespace pdflib
 	and cmap_numb_to_char.at(numb)!=replacement_char;
     };
 
+    // Subset generators (FontForge, fontTools, mPDF, ...) name glyphs by
+    // bare index: /gid00043, /g43, /glyph43, /cid43, /index43. Such a name
+    // identifies the glyph inside the embedded font program but carries no
+    // reading text, so keeping it fabricates plausible-looking garbage
+    // ('gid00043gid00049...') that downstream quality gates cannot detect
+    // (docling-project/docling-parse#238).
+    std::regex re_gid(R"((gid|glyph|g|cid|index)\d+)", std::regex::icase);
+
     // Last-resort for glyph-names that neither the /ToUnicode cmap nor
     // any glyph-table could resolve (eg custom ligatures like /Th, /ft
     // or /tt in a font without cmap): keep the glyph-name itself without
-    // the leading '/' and any '.suffix' as the reading text.
-    auto resolve_unknown_name = [](const std::string& name, const std::string& name_)
+    // the leading '/' and any '.suffix' as the reading text — unless the
+    // name is a pure glyph-index, which becomes a GLYPH marker so the
+    // unresolved glyph stays detectable.
+    auto resolve_unknown_name = [&re_gid](const std::string& name, const std::string& name_)
     {
       std::string result = name_;
       if(result.empty())
@@ -2277,6 +2326,13 @@ namespace pdflib
 	  result = (name.size()>0 and name[0]=='/')? name.substr(1) : name;
 	}
 
+      if(std::regex_match(result, re_gid))
+	{
+	  LOG_S(WARNING) << "glyph-index name " << name
+			 << ": emitting marker 'GLYPH<name:" << result << ">'";
+	  return "GLYPH<name:"+result+">";
+	}
+
       LOG_S(WARNING) << "unknown glyph-name " << name
 		     << ": falling back to '" << result << "'";
       return result;

{docling_parse-7.13.0 → docling_parse-7.14.0}/src/parse/pdf_resources/page_pattern.h

@@ -38,7 +38,15 @@ namespace pdflib
 
     // Tiling only: the pattern cell's own resources and content stream.
     QPDFObjectHandle get_resources() const { return resources_; }
-    bool has_resources() const { return resources_.isDictionary(); }
+    // QPDFObjectHandle's accessors are non-const in the qpdf releases we
+    // build against, so go through a copy (the handle is a shared reference,
+    // copying it costs nothing) -- the same way page_xobject_form does.
+    bool has_resources() const
+    {
+      QPDFObjectHandle resources = resources_;
+      return resources.isDictionary();
+    }
+
     std::vector<qpdf_stream_instruction> parse_stream() const;
 
     // Shading pattern only.
@@ -136,14 +144,15 @@ namespace pdflib
   std::vector<qpdf_stream_instruction> pdf_resource<PAGE_PATTERN>::parse_stream() const
   {
     std::vector<qpdf_stream_instruction> insts;
-    if(not qpdf_pattern_.isStream())
+
+    QPDFObjectHandle stream = qpdf_pattern_;
+    if(not stream.isStream())
       {
         return insts;
       }
 
     try
       {
-        QPDFObjectHandle stream = qpdf_pattern_;
         qpdf_stream_decoder decoder(insts);
         decoder.decode(stream);
       }