docling-parse 7.10.0__tar.gz → 7.12.0__tar.gz

{docling_parse-7.10.0 → docling_parse-7.12.0}/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [v7.12.0](https://github.com/docling-project/docling-parse/releases/tag/v7.12.0) - 2026-08-11
+
+### Feature
+
+* Improving performance and robustness ([#310](https://github.com/docling-project/docling-parse/issues/310)) ([`e955929`](https://github.com/docling-project/docling-parse/commit/e9559297947fe7aa3b05cc609d600009f1947b39))
+
+### Fix
+
+* Avoid 1M cells reserve to reduce memory footprint ([#311](https://github.com/docling-project/docling-parse/issues/311)) ([`e892b85`](https://github.com/docling-project/docling-parse/commit/e892b850e719f2883ae05f7258cd885779119e2c))
+* Enable MinGW/GCC build on Windows ([#312](https://github.com/docling-project/docling-parse/issues/312)) ([`83e50c5`](https://github.com/docling-project/docling-parse/commit/83e50c5460fc72f7656740ac6ba43129bf855b39))
+
+## [v7.11.0](https://github.com/docling-project/docling-parse/releases/tag/v7.11.0) - 2026-08-07
+
+### Feature
+
+* Improve PDF rendering fidelity across color, image, transparency, and writing-mode cases ([#307](https://github.com/docling-project/docling-parse/issues/307)) ([`bc55397`](https://github.com/docling-project/docling-parse/commit/bc55397a19bcf22df50d0a45e0aa147c8b44521f))
+* Render PDF shadings (sh), parse the full ExtGState, and add rendering quality benchmarks ([#306](https://github.com/docling-project/docling-parse/issues/306)) ([`ee2e265`](https://github.com/docling-project/docling-parse/commit/ee2e265c38e1632eaee3319355e766cca5cdceda))
+
 ## [v7.10.0](https://github.com/docling-project/docling-parse/releases/tag/v7.10.0) - 2026-08-05
 
 ### Feature

{docling_parse-7.10.0 → docling_parse-7.12.0}/CMakeLists.txt

@@ -91,7 +91,7 @@ if (WIN32)
         # (e.g. the curly quotes and en/em dashes in src/parse/utils/string.h) as
         # multi-character constants -> error C2015. GCC/Clang assume UTF-8, so this
         # only bites the MSVC/arm64 build.
-        add_compile_options(/utf-8)
+        add_compile_options(/utf-8 /bigobj)
         # MSVC's <cmath> only exposes M_PI (used in src/parse/utils/values.h) when
         # _USE_MATH_DEFINES is defined before the include -> without it, C2065.
         # NOMINMAX stops <windows.h> from defining min()/max() function-like

{docling_parse-7.10.0 → docling_parse-7.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.10.0
+Version: 7.12.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.10.0 → docling_parse-7.12.0}/app/analyse.cpp

@@ -40,6 +40,7 @@ struct yellow_box_inspector
   void render_text(pdflib::text_instruction&)           {}
   void render_widget(pdflib::text_widget_instruction&)  {}
   void render_shape(pdflib::shape_instruction&)         {}
+  void render_shading(pdflib::shading_instruction&)     {}
 
   void render_bitmap(pdflib::bitmap_instruction& instr)
   {

{docling_parse-7.10.0 → docling_parse-7.12.0}/app/pybind_parse.cpp

@@ -37,6 +37,7 @@ namespace
       case pdflib::TEXT_WIDGET_RENDER_INSTRUCTION: return "widget";
       case pdflib::BITMAP_RENDER_INSTRUCTION: return "bitmap";
       case pdflib::SHAPE_RENDER_INSTRUCTION: return "shape";
+      case pdflib::SHADING_RENDER_INSTRUCTION: return "shading";
       default: return "unknown";
       }
   }
@@ -191,6 +192,33 @@ namespace
       row["fill_alpha"] = instr.get_fill_alpha();
       instructions.append(row);
     }
+
+    void render_shading(pdflib::shading_instruction& instr)
+    {
+      pybind11::dict row;
+      row["type"] = instruction_name(pdflib::SHADING_RENDER_INSTRUCTION);
+      row["shading_key"] = instr.get_key();
+      row["geometry"] = static_cast<int>(instr.get_geometry());
+      row["coords"] = instr.get_coords();
+      row["matrix"] = instr.get_matrix();
+      row["extend_start"] = instr.get_extend_start();
+      row["extend_end"] = instr.get_extend_end();
+      row["fill_alpha"] = instr.get_fill_alpha();
+
+      // The colour ramp is a fixed-resolution resampling; only its endpoints
+      // and its length are stable enough to be worth exporting.
+      pybind11::list stops;
+      for(const auto& stop : instr.get_stops())
+        {
+          pybind11::dict entry;
+          entry["offset"] = stop.get_offset();
+          entry["rgb"] = stop.get_rgb();
+          stops.append(entry);
+        }
+      row["stops"] = stops;
+
+      instructions.append(row);
+    }
   };
 
   struct bitmap_artifact_export_visitor
@@ -202,6 +230,7 @@ namespace
     void render_text(pdflib::text_instruction&) {}
     void render_widget(pdflib::text_widget_instruction&) {}
     void render_shape(pdflib::shape_instruction&) {}
+    void render_shading(pdflib::shading_instruction&) {}
 
     void render_bitmap(pdflib::bitmap_instruction& instr)
     {
@@ -1109,8 +1138,11 @@ PYBIND11_MODULE(pdf_parsers, m) {
 
     Attributes:
         render_text (bool): Render glyph outlines for text cells [default=true].
+        min_stroke_width (float): Minimum stroke width in device pixels for hairlines and sub-pixel vector strokes [default=1.0].
         draw_text_bbox (bool): Draw bounding quad for each text cell [default=false].
         draw_text_basepoint (bool): Draw the text baseline origin as a small red dot [default=false].
+        display_widgets (bool): Draw the bounds of each widget (form-field) annotation as a translucent overlay; the field content itself is rendered regardless [default=false].
+        color_widgets (list[int]): RGB triple (0-255) for the widget overlay [default=[0, 153, 255]].
         fit_glyph_bbox_to_target (bool): Uniformly rescale measured glyph outlines so the rendered bbox fits inside the target glyph bbox, with either width or height matching exactly [default=false].
         resolve_fonts (bool): Resolve PDF font names to system fonts [default=true].
         use_embedded_fonts (bool): Prefer embedded font programs (TrueType/OpenType via Blend2D, Type 1/CFF via FreeType outlines) over system font resolution [default=true].
@@ -1121,8 +1153,11 @@ PYBIND11_MODULE(pdf_parsers, m) {
     )")
     .def(pybind11::init<>())
     .def_readwrite("render_text",             &pdflib::render_config::render_text)
+    .def_readwrite("min_stroke_width",        &pdflib::render_config::min_stroke_width)
     .def_readwrite("draw_text_bbox",          &pdflib::render_config::draw_text_bbox)
     .def_readwrite("draw_text_basepoint",     &pdflib::render_config::draw_text_basepoint)
+    .def_readwrite("display_widgets",         &pdflib::render_config::display_widgets)
+    .def_readwrite("color_widgets",           &pdflib::render_config::color_widgets)
     .def_readwrite("fit_glyph_bbox_to_target",&pdflib::render_config::fit_glyph_bbox_to_target)
     .def_readwrite("resolve_fonts",           &pdflib::render_config::resolve_fonts)
     .def_readwrite("use_embedded_fonts",      &pdflib::render_config::use_embedded_fonts)

{docling_parse-7.10.0 → docling_parse-7.12.0}/app/render.cpp

@@ -211,8 +211,11 @@ int main(int argc, char* argv[])
 
         // ---- render_config ----
         ("render-text",    "Render glyph outlines for text cells (default: true)",          cxxopts::value<bool>()->implicit_value("true"))
+        ("min-stroke-width", "Minimum stroke width in device pixels for hairlines and sub-pixel vector strokes (default: 1.0)", cxxopts::value<float>())
         ("draw-text-bbox", "Draw bounding quad around each text cell",                      cxxopts::value<bool>()->implicit_value("true"))
         ("draw-text-basepoint", "Draw the text base point as a small red dot",              cxxopts::value<bool>()->implicit_value("true"))
+        ("display-widgets", "Draw the bounds of each widget (form-field) annotation",       cxxopts::value<bool>()->implicit_value("true"))
+        ("color-widgets",  "RGB triple (0-255) for the widget overlay, e.g. 0,153,255",     cxxopts::value<std::vector<int>>())
         ("fit-glyph-bbox-to-target",
          "Uniformly rescale measured glyph outlines so the rendered bbox fits inside the target glyph bbox and matches either its width or height",
          cxxopts::value<bool>()->implicit_value("true"))
@@ -317,8 +320,20 @@ int main(int argc, char* argv[])
       // --- render_config ---
       pdflib::render_config cfg;
       if (result.count("render-text"))    { cfg.render_text    = result["render-text"].as<bool>(); }
+      if (result.count("min-stroke-width")) { cfg.min_stroke_width = result["min-stroke-width"].as<float>(); }
       if (result.count("draw-text-bbox")) { cfg.draw_text_bbox = result["draw-text-bbox"].as<bool>(); }
       if (result.count("draw-text-basepoint")) { cfg.draw_text_basepoint = result["draw-text-basepoint"].as<bool>(); }
+      if (result.count("display-widgets")) { cfg.display_widgets = result["display-widgets"].as<bool>(); }
+      if (result.count("color-widgets"))
+        {
+          auto rgb = result["color-widgets"].as<std::vector<int>>();
+          if (rgb.size() != 3)
+            {
+              LOG_F(ERROR, "--color-widgets expects three comma-separated values (R,G,B).");
+              return 1;
+            }
+          cfg.color_widgets = {rgb[0], rgb[1], rgb[2]};
+        }
       if (result.count("fit-glyph-bbox-to-target")) { cfg.fit_glyph_bbox_to_target = result["fit-glyph-bbox-to-target"].as<bool>(); }
       if (result.count("resolve-fonts"))          { cfg.resolve_fonts          = result["resolve-fonts"].as<bool>(); }
       if (result.count("font-similarity-cutoff")) { cfg.font_similarity_cutoff = result["font-similarity-cutoff"].as<float>(); }

{docling_parse-7.10.0 → docling_parse-7.12.0}/app/run_scaling.cpp

@@ -313,8 +313,10 @@ namespace
   {
     pdflib::render_config config;
     config.render_text = true;
+    config.min_stroke_width = 1.0f;
     config.draw_text_bbox = false;
     config.draw_text_basepoint = false;
+    config.display_widgets = false;
     config.fit_glyph_bbox_to_target = false;
     config.resolve_fonts = true;
     config.font_similarity_cutoff = 0.75f;
@@ -760,8 +762,10 @@ namespace
               << std::setw(32) << "parameter" << "value\n"
               << std::string(44, '-') << "\n"
               << std::setw(32) << "render_text" << config.render_text << "\n"
+              << std::setw(32) << "min_stroke_width" << config.min_stroke_width << "\n"
               << std::setw(32) << "draw_text_bbox" << config.draw_text_bbox << "\n"
               << std::setw(32) << "draw_text_basepoint" << config.draw_text_basepoint << "\n"
+              << std::setw(32) << "display_widgets" << config.display_widgets << "\n"
               << std::setw(32) << "fit_glyph_bbox_to_target" << config.fit_glyph_bbox_to_target << "\n"
               << std::setw(32) << "resolve_fonts" << config.resolve_fonts << "\n"
               << std::setw(32) << "font_similarity_cutoff" << config.font_similarity_cutoff << "\n"

{docling_parse-7.10.0 → docling_parse-7.12.0}/cmake/extlib_blend2d.cmake

@@ -54,5 +54,38 @@ else()
         GIT_TAG        6dbc2cefbc996379e07104e34519a440b49b15d7
     )
     FetchContent_MakeAvailable(blend2d)
+    # Release wheels must not contain Blend2D's debug assertion path. Blend2D
+    # normally infers BL_BUILD_RELEASE from NDEBUG, but make that mode explicit
+    # for non-Debug builds so embedded builds do not depend on generator-specific
+    # CMAKE_BUILD_TYPE propagation.
+    target_compile_definitions(
+        blend2d
+        PUBLIC $<$<NOT:$<CONFIG:Debug>>:BL_BUILD_RELEASE>
+    )
+
+    # Blend2D defines bl_runtime_assertion_failure() unconditionally in
+    # runtime.cpp. BL_BUILD_RELEASE removes assertion call sites, but the helper
+    # can still be retained from the static archive unless the final extension
+    # link can discard unused sections.
+    set(BLEND2D_GNU_GC_SECTIONS "$<AND:$<NOT:$<CONFIG:Debug>>,$<OR:$<PLATFORM_ID:Linux>,$<AND:$<PLATFORM_ID:Windows>,$<CXX_COMPILER_ID:GNU>>>>")
+    target_compile_options(
+        blend2d
+        PRIVATE "$<${BLEND2D_GNU_GC_SECTIONS}:-ffunction-sections;-fdata-sections>"
+    )
+    target_link_options(
+        blend2d
+        INTERFACE "$<${BLEND2D_GNU_GC_SECTIONS}:-Wl,--gc-sections>"
+    )
+
+    # MinGW auto-exports global symbols from DLL/PYD links. If symbols from the
+    # static Blend2D archive are exported, they become linker roots and section
+    # GC cannot remove bl_runtime_assertion_failure(). Hide static-archive
+    # symbols from the final Windows GNU extension export table while preserving
+    # explicitly exported symbols such as the pybind module initializer.
+    set(BLEND2D_MINGW_EXCLUDE_STATIC_EXPORTS "$<AND:$<NOT:$<CONFIG:Debug>>,$<PLATFORM_ID:Windows>,$<CXX_COMPILER_ID:GNU>>")
+    target_link_options(
+        blend2d
+        INTERFACE "$<${BLEND2D_MINGW_EXCLUDE_STATIC_EXPORTS}:-Wl,--exclude-libs,ALL>"
+    )
     # FetchContent creates the target "blend2d" (and alias blend2d::blend2d).
 endif()

{docling_parse-7.10.0 → docling_parse-7.12.0}/cmake/extlib_lcms2.cmake

@@ -35,12 +35,16 @@ else()
     set(LCMS2_URL https://github.com/mm2/Little-CMS.git)
     set(LCMS2_TAG lcms2.17)
 
-    if(MSVC)
-        # Upstream lcms2 has no CMakeLists and its ./configure cannot run under
-        # MSVC (no Unix shell on the Windows arm64 runner). Inject a vendored
-        # CMakeLists.txt and build with the active MSVC generator. Produces
-        # lcms2.lib.
-        set(LCMS2_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/lcms2.lib)
+    if(WIN32)
+        # Windows (MSVC and MinGW): use vendored CMakeLists. Upstream has no
+        # CMakeLists and its ./configure cannot run under MSVC and is fragile
+        # under MinGW/Ninja (requires sh/make). Produces lcms2.lib (MSVC) or
+        # liblcms2.a (MinGW).
+        if(MSVC)
+            set(LCMS2_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/lcms2.lib)
+        else()
+            set(LCMS2_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/liblcms2.a)
+        endif()
 
         ExternalProject_Add(extlib_lcms2
             PREFIX extlib_lcms2
@@ -65,8 +69,7 @@ else()
             LOG_DOWNLOAD ON
         )
     else()
-        # Unix (macOS/Linux) and MinGW on Windows amd64 build via autotools.
-        # Produces liblcms2.a.
+        # Unix (macOS/Linux) build via autotools. Produces liblcms2.a.
         set(LCMS2_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/liblcms2.a)
 
         ExternalProject_Add(extlib_lcms2

{docling_parse-7.10.0 → docling_parse-7.12.0}/docling_parse/pdf_parser.py

@@ -1416,6 +1416,7 @@ class PageParseResult:
 def _copy_render_config(src: RenderConfig) -> RenderConfig:
     dst = RenderConfig()
     dst.render_text = src.render_text
+    dst.min_stroke_width = src.min_stroke_width
     dst.draw_text_bbox = src.draw_text_bbox
     dst.resolve_fonts = src.resolve_fonts
     dst.use_embedded_fonts = src.use_embedded_fonts
@@ -1437,6 +1438,8 @@ def _validate_render_config(src: RenderConfig) -> None:
         raise ValueError("render_config.canvas_width must be > 0 or -1")
     if src.canvas_height != -1 and src.canvas_height <= 0:
         raise ValueError("render_config.canvas_height must be > 0 or -1")
+    if src.min_stroke_width < 0:
+        raise ValueError("render_config.min_stroke_width must be >= 0")
     if have_scale and (have_width or have_height):
         raise ValueError(
             "render_config.scale cannot be combined with canvas_width or canvas_height"

{docling_parse-7.10.0 → docling_parse-7.12.0}/docling_parse.egg-info/PKG-INFO

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

@@ -523,10 +523,13 @@ src/parse/pdf_resources/page_font.h
 src/parse/pdf_resources/page_fonts.h
 src/parse/pdf_resources/page_grph.h
 src/parse/pdf_resources/page_grphs.h
+src/parse/pdf_resources/page_shading.h
+src/parse/pdf_resources/page_shadings.h
 src/parse/pdf_resources/page_xobject_form.h
 src/parse/pdf_resources/page_xobject_image.h
 src/parse/pdf_resources/page_xobject_postscript.h
 src/parse/pdf_resources/page_xobjects.h
+src/parse/pdf_resources/pdf_function.h
 src/parse/pdf_resources/page_font/base_font.h
 src/parse/pdf_resources/page_font/base_fonts.h
 src/parse/pdf_resources/page_font/char_description.h
@@ -547,6 +550,7 @@ src/parse/pdf_states/shape.h
 src/parse/pdf_states/text.h
 src/parse/qpdf/annots.h
 src/parse/qpdf/logger.h
+src/parse/qpdf/object.h
 src/parse/qpdf/qpdf_compat.h
 src/parse/qpdf/stream_decoder.h
 src/parse/qpdf/stream_instruction.h
@@ -560,6 +564,7 @@ src/parse/utils/timer.h
 src/parse/utils/values.h
 src/parse/utils/bitmap/bitmap_exporter.h
 src/parse/utils/ccitt/ccitt_utils.h
+src/parse/utils/color/device_cmyk.h
 src/parse/utils/color/icc_utils.h
 src/parse/utils/jpeg/jpeg_utils.h
 src/parse/utils/jpx/jpx_utils.h
@@ -666,12 +671,16 @@ tests/constants.py
 tests/data_utils.py
 tests/rendering_regression.py
 tests/test_actual_text.py
+tests/test_colorspace.py
 tests/test_embedded_fonts.py
 tests/test_load_failure.py
 tests/test_locale_safety.py
 tests/test_parse.py
 tests/test_pypdfium_render.py
+tests/test_shading.py
 tests/test_standard_font_widths.py
 tests/test_threaded_parse.py
 tests/test_threaded_render.py
+tests/test_transparency.py
+tests/test_vertical_writing.py
 tests/update_groundtruth.py

{docling_parse-7.10.0 → docling_parse-7.12.0}/local_build.py

@@ -92,14 +92,17 @@ def run(cmd: List[str], cwd: str="./"):
 def build_local(num_threads: int):
 
     USE_SYSTEM_DEPS = os.getenv("USE_SYSTEM_DEPS", "OFF")
+    CMAKE_BUILD_TYPE = os.getenv("CMAKE_BUILD_TYPE", "Release")
 
     print("python prefix: ", sys.exec_prefix)
     print("python executable: ", sys.executable)
     config_cmd = [
         "cmake",
         "-B", f"{BUILD_DIR}",
+        f"-DCMAKE_BUILD_TYPE={CMAKE_BUILD_TYPE}",
         f"-DUSE_SYSTEM_DEPS={USE_SYSTEM_DEPS}",
         f"-DPYTHON_EXECUTABLE={sys.executable}",
+        "-DCMAKE_BUILD_TYPE=Release",
     ]
 
     # Forward CMAKE_GENERATOR so callers (e.g. the CI workflow) can switch the

{docling_parse-7.10.0 → docling_parse-7.12.0}/pyproject.toml

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

{docling_parse-7.10.0 → docling_parse-7.12.0}/src/parse/config.h

@@ -8,6 +8,10 @@ namespace pdflib
 
   struct decode_config
   {
+    static constexpr double DEFAULT_HORIZONTAL_CELL_TOLERANCE = 1.0;
+    static constexpr double DEFAULT_WORD_SPACE_WIDTH_FACTOR_FOR_MERGE = 0.33;
+    static constexpr double DEFAULT_LINE_SPACE_WIDTH_FACTOR_FOR_MERGE = 1.0;
+    static constexpr double DEFAULT_LINE_SPACE_WIDTH_FACTOR_FOR_MERGE_WITH_SPACE = 0.33;
     static constexpr double DEFAULT_MIN_VISIBLE_CLIP_EXTENT = 1e-3;
 
     std::string page_boundary = "crop_box";
@@ -27,14 +31,15 @@ namespace pdflib
     bool enforce_same_font = true;      // word & line cell creation
 
     // word & line cell creation parameters
-    double horizontal_cell_tolerance = 1.0;
+    double horizontal_cell_tolerance = DEFAULT_HORIZONTAL_CELL_TOLERANCE;
 
     // word cell creation
-    double word_space_width_factor_for_merge = 0.33;
+    double word_space_width_factor_for_merge = DEFAULT_WORD_SPACE_WIDTH_FACTOR_FOR_MERGE;
 
     // line cell creation
-    double line_space_width_factor_for_merge = 1.0;
-    double line_space_width_factor_for_merge_with_space = 0.33;
+    double line_space_width_factor_for_merge = DEFAULT_LINE_SPACE_WIDTH_FACTOR_FOR_MERGE;
+    double line_space_width_factor_for_merge_with_space =
+      DEFAULT_LINE_SPACE_WIDTH_FACTOR_FOR_MERGE_WITH_SPACE;
 
     bool populate_json_objects = false;
 

{docling_parse-7.10.0 → docling_parse-7.12.0}/src/parse/enums.h

@@ -217,12 +217,143 @@ namespace pdflib
     COLOR_SPACE_LAB,        // Lab (approximated by its L* component)
 
     COLOR_SPACE_INDEXED,    // palette lookup into a base space
-    COLOR_SPACE_SEPARATION, // single tint (tint transform not evaluated)
-    COLOR_SPACE_DEVICE_N,   // multiple tints (tint transform not evaluated)
+    COLOR_SPACE_SEPARATION, // single tint, through a tint transform
+    COLOR_SPACE_DEVICE_N,   // multiple tints, through a tint transform
 
     COLOR_SPACE_PATTERN
   };
 
+  // The /ShadingType of a shading dictionary (Table 78). Only the axial and
+  // radial types are painted; the others are recognised so that an
+  // unsupported shading is reported by name instead of dropped silently.
+  enum shading_type_name {
+    SHADING_UNKNOWN               = 0,
+    SHADING_FUNCTION_BASED        = 1,
+    SHADING_AXIAL                 = 2,
+    SHADING_RADIAL                = 3,
+    SHADING_FREE_FORM_GOURAUD     = 4,
+    SHADING_LATTICE_FORM_GOURAUD  = 5,
+    SHADING_COONS_PATCH           = 6,
+    SHADING_TENSOR_PATCH          = 7,
+  };
+
+  std::string to_string(shading_type_name name)
+  {
+    switch(name)
+      {
+      case SHADING_FUNCTION_BASED:       { return "function-based (1)"; }
+      case SHADING_AXIAL:                { return "axial (2)"; }
+      case SHADING_RADIAL:               { return "radial (3)"; }
+      case SHADING_FREE_FORM_GOURAUD:    { return "free-form Gouraud triangle mesh (4)"; }
+      case SHADING_LATTICE_FORM_GOURAUD: { return "lattice-form Gouraud triangle mesh (5)"; }
+      case SHADING_COONS_PATCH:          { return "Coons patch mesh (6)"; }
+      case SHADING_TENSOR_PATCH:         { return "tensor-product patch mesh (7)"; }
+
+      default: { return "unknown (0)"; }
+      }
+  }
+
+  shading_type_name to_shading_type_name(int type)
+  {
+    switch(type)
+      {
+      case 1: { return SHADING_FUNCTION_BASED; }
+      case 2: { return SHADING_AXIAL; }
+      case 3: { return SHADING_RADIAL; }
+      case 4: { return SHADING_FREE_FORM_GOURAUD; }
+      case 5: { return SHADING_LATTICE_FORM_GOURAUD; }
+      case 6: { return SHADING_COONS_PATCH; }
+      case 7: { return SHADING_TENSOR_PATCH; }
+
+      default: { return SHADING_UNKNOWN; }
+      }
+  }
+
+  // Blend modes of an ExtGState /BM entry (11.3.5). The separable modes are
+  // composited; the four non-separable ones (Table 137) are parsed so that
+  // documents relying on them are identifiable instead of silently rendered
+  // as Normal.
+  enum blend_mode_name {
+    BLEND_MODE_UNKNOWN,
+
+    // separable blend modes (Table 136)
+    BLEND_MODE_NORMAL,
+    BLEND_MODE_MULTIPLY,
+    BLEND_MODE_SCREEN,
+    BLEND_MODE_OVERLAY,
+    BLEND_MODE_DARKEN,
+    BLEND_MODE_LIGHTEN,
+    BLEND_MODE_COLOR_DODGE,
+    BLEND_MODE_COLOR_BURN,
+    BLEND_MODE_HARD_LIGHT,
+    BLEND_MODE_SOFT_LIGHT,
+    BLEND_MODE_DIFFERENCE,
+    BLEND_MODE_EXCLUSION,
+
+    // non-separable blend modes (Table 137)
+    BLEND_MODE_HUE,
+    BLEND_MODE_SATURATION,
+    BLEND_MODE_COLOR,
+    BLEND_MODE_LUMINOSITY,
+  };
+
+  // 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.
+  enum soft_mask_state {
+    SOFT_MASK_ABSENT,   // key not in the dictionary: inherit the current mask
+    SOFT_MASK_NONE,     // /None: clear the current soft mask
+    SOFT_MASK_PRESENT,  // a mask dictionary (not applied)
+  };
+
+  std::string to_string(blend_mode_name name)
+  {
+    switch(name)
+      {
+      case BLEND_MODE_NORMAL:      { return "/Normal"; }
+      case BLEND_MODE_MULTIPLY:    { return "/Multiply"; }
+      case BLEND_MODE_SCREEN:      { return "/Screen"; }
+      case BLEND_MODE_OVERLAY:     { return "/Overlay"; }
+      case BLEND_MODE_DARKEN:      { return "/Darken"; }
+      case BLEND_MODE_LIGHTEN:     { return "/Lighten"; }
+      case BLEND_MODE_COLOR_DODGE: { return "/ColorDodge"; }
+      case BLEND_MODE_COLOR_BURN:  { return "/ColorBurn"; }
+      case BLEND_MODE_HARD_LIGHT:  { return "/HardLight"; }
+      case BLEND_MODE_SOFT_LIGHT:  { return "/SoftLight"; }
+      case BLEND_MODE_DIFFERENCE:  { return "/Difference"; }
+      case BLEND_MODE_EXCLUSION:   { return "/Exclusion"; }
+      case BLEND_MODE_HUE:         { return "/Hue"; }
+      case BLEND_MODE_SATURATION:  { return "/Saturation"; }
+      case BLEND_MODE_COLOR:       { return "/Color"; }
+      case BLEND_MODE_LUMINOSITY:  { return "/Luminosity"; }
+
+      default: { return "/Unknown"; }
+      }
+  }
+
+  // /Compatible is a deprecated synonym of /Normal (11.3.5.2)
+  blend_mode_name to_blend_mode_name(const std::string& name)
+  {
+    if(name=="/Normal" or name=="/Compatible") { return BLEND_MODE_NORMAL; }
+    if(name=="/Multiply")                      { return BLEND_MODE_MULTIPLY; }
+    if(name=="/Screen")                        { return BLEND_MODE_SCREEN; }
+    if(name=="/Overlay")                       { return BLEND_MODE_OVERLAY; }
+    if(name=="/Darken")                        { return BLEND_MODE_DARKEN; }
+    if(name=="/Lighten")                       { return BLEND_MODE_LIGHTEN; }
+    if(name=="/ColorDodge")                    { return BLEND_MODE_COLOR_DODGE; }
+    if(name=="/ColorBurn")                     { return BLEND_MODE_COLOR_BURN; }
+    if(name=="/HardLight")                     { return BLEND_MODE_HARD_LIGHT; }
+    if(name=="/SoftLight")                     { return BLEND_MODE_SOFT_LIGHT; }
+    if(name=="/Difference")                    { return BLEND_MODE_DIFFERENCE; }
+    if(name=="/Exclusion")                     { return BLEND_MODE_EXCLUSION; }
+    if(name=="/Hue")                           { return BLEND_MODE_HUE; }
+    if(name=="/Saturation")                    { return BLEND_MODE_SATURATION; }
+    if(name=="/Color")                         { return BLEND_MODE_COLOR; }
+    if(name=="/Luminosity")                    { return BLEND_MODE_LUMINOSITY; }
+
+    return BLEND_MODE_UNKNOWN;
+  }
+
 }
 
 #endif

{docling_parse-7.10.0 → docling_parse-7.12.0}/src/parse/page_item_sanitators/cells.h

@@ -352,6 +352,11 @@ namespace pdflib
       {
 	std::string& text = cells.at(i).text;
 
+	if(text.empty())
+	  {
+	    continue;
+	  }
+
 	for(const std::pair<std::string, std::string>& pair:text_constants::replacements)
 	  {
 	    utils::string::replace(text, pair.first, pair.second);
@@ -359,11 +364,16 @@ namespace pdflib
       }
 
     {
-      std::regex pattern(R"(^\/([A-Za-z])_([A-Za-z])(_([A-Za-z]))?$)");
+      static const std::regex pattern(R"(^\/([A-Za-z])_([A-Za-z])(_([A-Za-z]))?$)");
 
       for(int i=0; i<cells.size(); i++)
 	{
 	  std::string text = cells.at(i).text;
+
+	  if(text.empty() or text[0] != '/')
+	    {
+	      continue;
+	    }
 	  
 	  std::smatch match;
 	  if(std::regex_match(text, match, pattern))

{docling_parse-7.10.0 → docling_parse-7.12.0}/src/parse/page_items/page_cells.h

@@ -44,10 +44,10 @@ namespace pdflib
   };
 
   page_item<PAGE_CELLS>::page_item():
-    cells(0) // 0 elements
-  {
-    cells.reserve(1000000); // Reserve space for 1M elements
-  }
+    cells(0) // 0 elements; capacity grows on demand. No up-front reserve:
+             // several of these containers live per decoded page, so a large
+             // fixed reserve multiplies into gigabytes of committed memory.
+  {}
 
   page_item<PAGE_CELLS>::~page_item()
   {}

{docling_parse-7.10.0 → docling_parse-7.12.0}/src/parse/page_items/page_image.h

@@ -86,6 +86,13 @@ namespace pdflib
     int  device_n_components = 0; // number of components from /DeviceN names array; 0 if not DeviceN
     std::vector<std::string> device_n_names;
 
+    // /Separation and /DeviceN (8.6.6.4, 8.6.6.5): the resolved colour space,
+    // so the samples -- which are tints, not colours -- can be put through its
+    // tint transform. Null unless the space is one of those two and both its
+    // transform and its alternate space decoded.
+    std::shared_ptr<pdf_resource<PAGE_COLORSPACE>> tint_colorspace;
+    int tint_components = 0;
+
     // /Indexed color space support
     int              indexed_hival  = -1;
     std::string      indexed_base_cs;