docling-parse 7.4.0__tar.gz → 7.5.0__tar.gz

{docling_parse-7.4.0 → docling_parse-7.5.0}/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [v7.5.0](https://github.com/docling-project/docling-parse/releases/tag/v7.5.0) - 2026-07-03
+
+### Feature
+
+* Attack embedded fonts ([#291](https://github.com/docling-project/docling-parse/issues/291)) ([`f41aec4`](https://github.com/docling-project/docling-parse/commit/f41aec48e3b42b6d9a4de4afbc110a6f29664925))
+* Improve font resolver ([#290](https://github.com/docling-project/docling-parse/issues/290)) ([`a7f201f`](https://github.com/docling-project/docling-parse/commit/a7f201fdc2b1c6a629c406f38d9b1b67547db1eb))
+
 ## [v7.4.0](https://github.com/docling-project/docling-parse/releases/tag/v7.4.0) - 2026-07-01
 
 ### Feature

{docling_parse-7.4.0 → docling_parse-7.5.0}/CMakeLists.txt

@@ -113,10 +113,11 @@ include(cmake/extlib_lcms2.cmake)
 # include(cmake/extlib_qpdf_v11.cmake)
 include(cmake/extlib_qpdf_v12.cmake)
 include(cmake/extlib_blend2d.cmake)
+include(cmake/extlib_freetype.cmake)
 include(cmake/extlib_pdfium_jbig2.cmake)
 
 # aggregate the targets created by the dependencies
-set(DEPENDENCIES qpdf jpeg openjpeg lcms2 utf8 json loguru cxxopts blend2d pdfium_jbig2)
+set(DEPENDENCIES qpdf jpeg openjpeg lcms2 utf8 json loguru cxxopts blend2d freetype pdfium_jbig2)
 
 # ************************
 # *** libraries        ***

{docling_parse-7.4.0 → docling_parse-7.5.0}/PKG-INFO

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

@@ -92,6 +92,22 @@ namespace
       row["font_descent_norm"] = instr.get_font_descent_norm();
       row["base_x0"] = instr.get_base_x0();
       row["base_y0"] = instr.get_base_y0();
+      row["char_code"] = instr.get_char_code();
+      row["glyph_name"] = instr.get_glyph_name();
+      // Embedded font metadata only — never the raw font bytes.
+      row["has_embedded_font"] = instr.has_embedded_font();
+      if(instr.has_embedded_font())
+        {
+          const auto& blob = instr.get_embedded_font();
+          pybind11::dict embedded;
+          embedded["source_key"] = blob->get_source_key();
+          embedded["format"] = pdflib::to_string(blob->get_format());
+          embedded["byte_size"] = blob->byte_size();
+          embedded["cache_key"] = blob->get_cache_key();
+          embedded["is_cid_font"] = blob->get_is_cid_font();
+          embedded["cid_to_gid_identity"] = blob->get_cid_to_gid_identity();
+          row["embedded_font"] = embedded;
+        }
       row["quad"] = make_quad_dict(
         instr.get_r_x0(), instr.get_r_y0(),
         instr.get_r_x1(), instr.get_r_y1(),
@@ -298,6 +314,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def_readwrite("release_native_memory_every_n_pages", &pdflib::decode_config::release_native_memory_every_n_pages)
     .def_readwrite("keep_glyphs", &pdflib::decode_config::keep_glyphs)
     .def_readwrite("keep_qpdf_warnings", &pdflib::decode_config::keep_qpdf_warnings)
+    .def_readwrite("extract_font_programs", &pdflib::decode_config::extract_font_programs)
     .def("__copy__", [](const pdflib::decode_config& self) { return self; })
     .def("__deepcopy__", [](const pdflib::decode_config& self, pybind11::dict) { return self; });
 
@@ -1050,6 +1067,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
         draw_text_basepoint (bool): Draw the text baseline origin as a small red dot [default=false].
         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].
         font_similarity_cutoff (float): Minimum Jaccard similarity for fuzzy font matching; candidates below this threshold fall back to the default font [default=0.25].
         scale (float): Target render scale in multiples of the PDF page size; -1 disables scale-based sizing [default=-1].
         canvas_width (int): Target canvas width in pixels; -1 means use PDF page size [default=-1].
@@ -1061,6 +1079,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def_readwrite("draw_text_basepoint",     &pdflib::render_config::draw_text_basepoint)
     .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)
     .def_readwrite("font_similarity_cutoff",  &pdflib::render_config::font_similarity_cutoff)
     .def_readwrite("scale",                   &pdflib::render_config::scale)
     .def_readwrite("canvas_width",            &pdflib::render_config::canvas_width)

{docling_parse-7.4.0 → docling_parse-7.5.0}/app/render.cpp

@@ -239,6 +239,7 @@ int main(int argc, char* argv[])
         ("line-space-factor-with-space", "Space-width factor for line merging with space (default: 0.33)", cxxopts::value<double>())
         ("keep-glyphs",        "Keep unmapped GLYPH<...> tokens (default: false)",          cxxopts::value<bool>()->implicit_value("true"))
         ("keep-qpdf-warnings", "Emit QPDF warnings (default: false)",                       cxxopts::value<bool>()->implicit_value("true"))
+        ("extract-font-programs", "Extract embedded font programs for rendering (default: true)", cxxopts::value<bool>()->implicit_value("true"))
         ("populate-json",      "Populate JSON objects during decode (default: false)",       cxxopts::value<bool>()->implicit_value("true"))
         ("export-bitmaps",     "Export decoded bitmap payloads encountered on each page (default: false)",
                                cxxopts::value<bool>()->default_value("false"))
@@ -306,6 +307,9 @@ int main(int argc, char* argv[])
       if (result.count("line-space-factor-with-space")) { page_config.line_space_width_factor_for_merge_with_space = result["line-space-factor-with-space"].as<double>(); }
       if (result.count("keep-glyphs"))              { page_config.keep_glyphs               = result["keep-glyphs"].as<bool>(); }
       if (result.count("keep-qpdf-warnings"))       { page_config.keep_qpdf_warnings        = result["keep-qpdf-warnings"].as<bool>(); }
+      // This app always renders, so embedded font extraction defaults to on.
+      page_config.extract_font_programs = true;
+      if (result.count("extract-font-programs"))    { page_config.extract_font_programs     = result["extract-font-programs"].as<bool>(); }
       if (result.count("populate-json"))            { page_config.populate_json_objects      = result["populate-json"].as<bool>(); }
       bool export_bitmaps = result["export-bitmaps"].as<bool>();
       bool export_page_pdf_files = result["export-page-pdf"].as<bool>();

{docling_parse-7.4.0 → docling_parse-7.5.0}/cmake/extlib_blend2d.cmake

@@ -48,8 +48,10 @@ else()
     FetchContent_Declare(
         blend2d
         GIT_REPOSITORY https://github.com/blend2d/blend2d.git
-        GIT_TAG        master
-        GIT_SHALLOW    TRUE
+        # Pinned so the (renamed, snake_case) C++ API cannot drift under us;
+        # bump deliberately. This is the commit the font-rendering code was
+        # validated against.
+        GIT_TAG        6dbc2cefbc996379e07104e34519a440b49b15d7
     )
     FetchContent_MakeAvailable(blend2d)
     # FetchContent creates the target "blend2d" (and alias blend2d::blend2d).

docling_parse-7.5.0/cmake/extlib_freetype.cmake

@@ -0,0 +1,73 @@
+
+message(STATUS "entering in extlib_freetype.cmake")
+
+set(ext_name "freetype")
+
+if(USE_SYSTEM_DEPS)
+    # Standard CMake module; provides Freetype::Freetype.
+    find_package(Freetype REQUIRED)
+    if(NOT TARGET freetype)
+        add_library(${ext_name} ALIAS Freetype::Freetype)
+    endif()
+
+else()
+    include(ExternalProject)
+    include(CMakeParseArguments)
+
+    file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/include)
+    file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/include/freetype2)
+    file(MAKE_DIRECTORY ${EXTERNALS_PREFIX_PATH}/lib)
+
+    set(FREETYPE_URL https://github.com/freetype/freetype.git)
+    set(FREETYPE_TAG VER-2-13-3)
+    set(FREETYPE_IMPORTED_LIB ${EXTERNALS_PREFIX_PATH}/lib/libfreetype.a)
+
+    # All optional codec/shaping dependencies are disabled: the renderer only
+    # needs outline loading for Type 1 / CFF / TrueType font programs, and a
+    # dependency-free static build keeps every wheel platform (incl.
+    # windows-arm64) simple.
+    ExternalProject_Add(extlib_freetype
+
+        PREFIX extlib_freetype
+
+        UPDATE_COMMAND ""
+        GIT_REPOSITORY ${FREETYPE_URL}
+        GIT_TAG ${FREETYPE_TAG}
+
+        BUILD_ALWAYS OFF
+
+        INSTALL_DIR ${EXTERNALS_PREFIX_PATH}
+
+        CMAKE_ARGS \\
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON \\
+        -DCMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES} \\
+        -DCMAKE_C_FLAGS=${ENV_ARCHFLAGS} \\
+        # Pin the sub-build type and disable FreeType's forced "d" debug
+        # postfix: with the outer CMAKE_BUILD_TYPE=Debug (e.g. the CI checks
+        # workflow) FreeType would otherwise install libfreetyped.a and the
+        # IMPORTED_LOCATION below would dangle, breaking the final link.
+        -DCMAKE_BUILD_TYPE=Release \\
+        -DDISABLE_FORCE_DEBUG_POSTFIX=ON \\
+        -DBUILD_SHARED_LIBS=OFF \\
+        -DFT_DISABLE_ZLIB=ON \\
+        -DFT_DISABLE_BZIP2=ON \\
+        -DFT_DISABLE_PNG=ON \\
+        -DFT_DISABLE_HARFBUZZ=ON \\
+        -DFT_DISABLE_BROTLI=ON \\
+        -DCMAKE_INSTALL_LIBDIR=${EXTERNALS_PREFIX_PATH}/lib \\
+        -DCMAKE_INSTALL_PREFIX=${EXTERNALS_PREFIX_PATH}
+
+        # FreeType's CMakeLists rejects in-source builds, so (unlike the other
+        # extlibs) build in ExternalProject's separate binary directory.
+        BUILD_IN_SOURCE OFF
+        LOG_DOWNLOAD ON
+    )
+
+    add_library(${ext_name} STATIC IMPORTED)
+    add_dependencies(${ext_name} extlib_freetype)
+    set_target_properties(${ext_name} PROPERTIES
+        IMPORTED_LOCATION ${FREETYPE_IMPORTED_LIB}
+        INTERFACE_INCLUDE_DIRECTORIES "${EXTERNALS_PREFIX_PATH}/include/freetype2;${EXTERNALS_PREFIX_PATH}/include"
+    )
+
+endif()

{docling_parse-7.4.0 → docling_parse-7.5.0}/docling_parse/pdf_parser.py

@@ -1360,6 +1360,7 @@ def _copy_render_config(src: RenderConfig) -> RenderConfig:
     dst.render_text = src.render_text
     dst.draw_text_bbox = src.draw_text_bbox
     dst.resolve_fonts = src.resolve_fonts
+    dst.use_embedded_fonts = src.use_embedded_fonts
     dst.font_similarity_cutoff = src.font_similarity_cutoff
     dst.scale = src.scale
     dst.canvas_width = src.canvas_width

docling_parse-7.5.0/docling_parse/pdf_resources/glyphs/custom/TeX/glyphs_03.dat

@@ -0,0 +1,62 @@
+arrowtp;2191
+arrowbt;2193
+arrowdbltp;21D1
+arrowdblbt;21D3
+subsetornoteql;228A
+supersetornoteql;228B
+greaterornotsimilar;2275
+lessornotsimilar;2274
+parallelshort;2225
+notshortparallel;2226
+notshortbar;2224
+number;0023
+tie;0361
+breve1;0306
+yo;0451
+Yo;0401
+ye;0435
+Ye;0415
+yu;044E
+Yu;042E
+ya;044F
+Ya;042F
+zhe;0436
+Zhe;0416
+ze;0437
+Ze;0417
+zelo;0455
+Zelo;0405
+yatz;0463
+Yatz;0462
+izhitsa;0475
+Izhitsa;0474
+dj;0452
+Dj;0402
+dzh;045F
+Dzh;040F
+ishort;0439
+Ishort;0419
+soft;044C
+Soft;042C
+tsoft;045B
+Tsoft;040B
+hard;044A
+Hard;042A
+iroman;0456
+Iroman;0406
+# --- TeX glyph names with no assignment in lcdf-typetools texglyphlist.txt ---
+# (texglyphlist marks most of these "XXX"; mappings below are the closest
+# Unicode approximations for text extraction)
+# OT1 slot 040: the crossbar overlaid on l/L to build lslash; zero-width
+# space keeps extracted text clean ("suppress"+"l" -> "l")
+# suppress;200B
+# vertical extension module of big double arrows (cmex-style fonts)
+arrowvertexdbl;2016
+# MSBM short vertical bar (negation piece)
+barshort;2223
+# MSBM dashed-arrow pieces: axis-height dash segment and arrowhead pieces
+axisshort;2212
+arrowaxisleft;21E0
+arrowaxisright;21E2
+# MSAM/MSBM small filled square
+squaresmallsolid;25AA

{docling_parse-7.4.0 → docling_parse-7.5.0}/docling_parse.egg-info/PKG-INFO

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

@@ -19,6 +19,7 @@ app/render.cpp
 app/run_scaling.cpp
 cmake/extlib_blend2d.cmake
 cmake/extlib_cxxopts.cmake
+cmake/extlib_freetype.cmake
 cmake/extlib_jpeg.cmake
 cmake/extlib_json.cmake
 cmake/extlib_lcms2.cmake
@@ -498,6 +499,7 @@ src/parse/utils.h
 src/parse/page_item_sanitators/cells.h
 src/parse/page_item_sanitators/page_dimension.h
 src/parse/page_item_sanitators/shapes.h
+src/parse/page_items/embedded_font_blob.h
 src/parse/page_items/page_cell.h
 src/parse/page_items/page_cells.h
 src/parse/page_items/page_dimension.h
@@ -566,9 +568,11 @@ src/pybind/docling_threaded_renderer.h
 src/pybind/docling_threaded_results.h
 src/pybind/native_memory.h
 src/pybind/utils/pybind11_json.h
+src/render/blend2d_embedded_font_cache.h
 src/render/blend2d_font_resolver.h
 src/render/blend2d_renderer.h
 src/render/config.h
+src/render/freetype_embedded_font_cache.h
 src/render/naive_renderer.h
 src/render/template_renderer.h
 src/third_party/pdfium_jbig2.h
@@ -655,6 +659,7 @@ src/third_party/pdfium_jbig2/core/fxcrt/numerics/safe_math_shared_impl.h
 tests/__init__.py
 tests/conftest.py
 tests/data_utils.py
+tests/test_embedded_fonts.py
 tests/test_locale_safety.py
 tests/test_parse.py
 tests/test_threaded_parse.py

{docling_parse-7.4.0 → docling_parse-7.5.0}/pyproject.toml

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

{docling_parse-7.4.0 → docling_parse-7.5.0}/src/parse/config.h

@@ -38,6 +38,12 @@ namespace pdflib
 
     bool populate_json_objects = false;
 
+    // Extract embedded font programs (/FontFile, /FontFile2, /FontFile3) and
+    // attach them to text render instructions. Off by default so that
+    // parse-only workloads (text extraction) never pay for font stream
+    // decoding; the render pipeline turns it on.
+    bool extract_font_programs = false;
+
     // threading
     bool do_thread_safe = true; // slight compute/memory overhead in single threaded case
     int release_native_memory_every_n_pages = 0; // 0 disables allocator trimming
@@ -83,6 +89,7 @@ namespace pdflib
     j["line_space_width_factor_for_merge_with_space"] = line_space_width_factor_for_merge_with_space;
 
     j["populate_json_objects"] = populate_json_objects;
+    j["extract_font_programs"] = extract_font_programs;
     j["release_native_memory_every_n_pages"] = release_native_memory_every_n_pages;
 
     j["keep_glyphs"] = keep_glyphs;
@@ -117,6 +124,7 @@ namespace pdflib
     if(j.count("line_space_width_factor_for_merge_with_space")) { line_space_width_factor_for_merge_with_space = j["line_space_width_factor_for_merge_with_space"]; }
 
     if(j.count("populate_json_objects")) { populate_json_objects = j["populate_json_objects"]; }
+    if(j.count("extract_font_programs")) { extract_font_programs = j["extract_font_programs"]; }
     if(j.count("release_native_memory_every_n_pages")) { release_native_memory_every_n_pages = j["release_native_memory_every_n_pages"]; }
 
     if(j.count("keep_glyphs")) { keep_glyphs = j["keep_glyphs"]; }
@@ -173,6 +181,7 @@ namespace pdflib
        << std::setw(48) << "line_space_width_factor_for_merge" << line_space_width_factor_for_merge << "\n"
        << std::setw(48) << "line_space_width_factor_for_merge_with_space" << line_space_width_factor_for_merge_with_space << "\n"
        << std::setw(48) << "populate_json_objects" << (populate_json_objects ? "true" : "false") << "\n"
+       << std::setw(48) << "extract_font_programs" << (extract_font_programs ? "true" : "false") << "\n"
        << std::setw(48) << "release_native_memory_every_n_pages" << release_native_memory_every_n_pages << "\n"
        << std::setw(48) << "keep_glyphs" << (keep_glyphs ? "true" : "false") << "\n"
        << std::setw(48) << "keep_qpdf_warnings" << (keep_qpdf_warnings ? "true" : "false") << "\n";

{docling_parse-7.4.0 → docling_parse-7.5.0}/src/parse/enums.h

@@ -135,6 +135,35 @@ namespace pdflib
 
     return "FONT_FILE_UNKNOWN";
   }
+
+  // Distinguishes the /FontFile3 subtypes that embedded_font_file_kind folds
+  // into FONT_FILE_CFF. The renderer needs this: Blend2D loads only SFNT
+  // containers (TRUETYPE/OPENTYPE), while TYPE1/TYPE1C/CID_TYPE0C need a
+  // different backend.
+  enum class embedded_font_format
+  {
+    UNKNOWN,
+    TYPE1,      // /FontFile  (PFA/PFB)
+    TRUETYPE,   // /FontFile2
+    TYPE1C,     // /FontFile3 /Subtype /Type1C (bare CFF)
+    CID_TYPE0C, // /FontFile3 /Subtype /CIDFontType0C (CID-keyed bare CFF)
+    OPENTYPE    // /FontFile3 /Subtype /OpenType
+  };
+
+  inline std::string to_string(embedded_font_format format)
+  {
+    switch(format)
+      {
+      case embedded_font_format::UNKNOWN:    return "UNKNOWN";
+      case embedded_font_format::TYPE1:      return "TYPE1";
+      case embedded_font_format::TRUETYPE:   return "TRUETYPE";
+      case embedded_font_format::TYPE1C:     return "TYPE1C";
+      case embedded_font_format::CID_TYPE0C: return "CID_TYPE0C";
+      case embedded_font_format::OPENTYPE:   return "OPENTYPE";
+      }
+
+    return "UNKNOWN";
+  }
   
   enum xobject_subtype_name {
     XOBJECT_UNKNOWN,

{docling_parse-7.4.0 → docling_parse-7.5.0}/src/parse/page_item_sanitators/cells.h

@@ -450,7 +450,7 @@ namespace pdflib
 	  {
 	    continue;
 	  }
-	LOG_S(INFO) << "start merging cell-" << i << ": '" << cells[i].text << "'";
+	// LOG_S(INFO) << "start merging cell-" << i << ": '" << cells[i].text << "'";
 
 	for(int j=i+1; j<cells.size(); j++)
 	  {
@@ -492,6 +492,7 @@ namespace pdflib
 		// after a ligature and returns to normal once the inflated bbox is absorbed.
 		cells[i].last_merged_cell_was_ligature = utils::string::is_ligature(cells[j].text);
 		cells[j].active = false;
+
 		LOG_S(INFO) << " -> merging cell-" << i << " with " << j << " '" << cells[j].text << "'"<< ": " << cells[i].text;
 	      }
 	    else if(allow_reverse and cells[j].is_adjacent_to(cells[i], delta_0, adj_eps_d1))
@@ -536,7 +537,7 @@ namespace pdflib
 	  {
 	    continue;
 	  }
-	LOG_S(INFO) << "start merging cell-" << i << ": '" << cells[i].text << "'";
+	// LOG_S(INFO) << "start merging cell-" << i << ": '" << cells[i].text << "'";
 
 	for(int j=i-1; j>=0; j--)
 	  {

docling_parse-7.5.0/src/parse/page_items/embedded_font_blob.h

@@ -0,0 +1,139 @@
+//-*-C++-*-
+
+#ifndef PAGE_ITEM_EMBEDDED_FONT_BLOB_H
+#define PAGE_ITEM_EMBEDDED_FONT_BLOB_H
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <parse/enums.h>
+
+namespace pdflib
+{
+  // Render-facing view of an embedded font program (/FontFile, /FontFile2,
+  // /FontFile3). Deliberately free of qpdf and nlohmann types so that render
+  // instructions and the renderer can carry it without pulling in the parse
+  // dependencies. One blob is built per PDF font resource and shared (via
+  // shared_ptr) by every text instruction that uses that font; the byte
+  // buffer is immutable after construction.
+  class embedded_font_blob
+  {
+  public:
+
+    embedded_font_blob();
+    embedded_font_blob(std::string cache_key,
+                       std::string font_name,
+                       std::string base_font,
+                       std::string source_key,
+                       embedded_font_format format,
+                       bool is_cid_font,
+                       bool cid_to_gid_identity,
+                       std::shared_ptr<const std::vector<uint8_t> > bytes);
+
+    // Content-derived identity (FNV-1a over the decoded bytes + size).
+    // PDF object ids are NOT used: they are only unique within one document,
+    // and the renderer-side face cache may outlive/serve many documents.
+    const std::string& get_cache_key() const { return cache_key; }
+
+    const std::string& get_font_name() const { return font_name; }
+    const std::string& get_base_font() const { return base_font; }
+
+    // "/FontFile", "/FontFile2" or "/FontFile3"
+    const std::string& get_source_key() const { return source_key; }
+
+    embedded_font_format get_format() const { return format; }
+
+    // font belongs to a /Type0 composite font
+    bool get_is_cid_font() const { return is_cid_font; }
+
+    // /CIDToGIDMap is /Identity or absent
+    bool get_cid_to_gid_identity() const { return cid_to_gid_identity; }
+
+    const std::shared_ptr<const std::vector<uint8_t> >& get_bytes() const { return bytes; }
+
+    bool has_bytes() const;
+    size_t byte_size() const;
+
+    static std::string compute_cache_key(const std::vector<uint8_t>& data);
+
+  private:
+
+    std::string cache_key;
+
+    std::string font_name;
+    std::string base_font;
+    std::string source_key;
+
+    embedded_font_format format;
+
+    bool is_cid_font;
+    bool cid_to_gid_identity;
+
+    std::shared_ptr<const std::vector<uint8_t> > bytes;
+  };
+
+  inline embedded_font_blob::embedded_font_blob():
+    cache_key(),
+    font_name(),
+    base_font(),
+    source_key(),
+    format(embedded_font_format::UNKNOWN),
+    is_cid_font(false),
+    cid_to_gid_identity(false),
+    bytes(nullptr)
+  {}
+
+  inline embedded_font_blob::embedded_font_blob(std::string cache_key_,
+                                                std::string font_name_,
+                                                std::string base_font_,
+                                                std::string source_key_,
+                                                embedded_font_format format_,
+                                                bool is_cid_font_,
+                                                bool cid_to_gid_identity_,
+                                                std::shared_ptr<const std::vector<uint8_t> > bytes_):
+    cache_key(std::move(cache_key_)),
+    font_name(std::move(font_name_)),
+    base_font(std::move(base_font_)),
+    source_key(std::move(source_key_)),
+    format(format_),
+    is_cid_font(is_cid_font_),
+    cid_to_gid_identity(cid_to_gid_identity_),
+    bytes(std::move(bytes_))
+  {}
+
+  inline bool embedded_font_blob::has_bytes() const
+  {
+    return bytes != nullptr and not bytes->empty();
+  }
+
+  inline size_t embedded_font_blob::byte_size() const
+  {
+    return bytes ? bytes->size() : 0;
+  }
+
+  inline std::string embedded_font_blob::compute_cache_key(const std::vector<uint8_t>& data)
+  {
+    uint64_t hash = 0xcbf29ce484222325ULL; // FNV-1a 64 offset basis
+    for(uint8_t byte : data)
+      {
+        hash ^= byte;
+        hash *= 0x100000001b3ULL;
+      }
+
+    static const char* digits = "0123456789abcdef";
+
+    std::string key(16, '0');
+    for(int i = 0; i < 16; i++)
+      {
+        key[15 - i] = digits[(hash >> (4 * i)) & 0xF];
+      }
+
+    return key + "-" + std::to_string(data.size());
+  }
+
+}
+
+#endif

{docling_parse-7.4.0 → docling_parse-7.5.0}/src/parse/page_items/render_instructions.h

@@ -12,6 +12,7 @@
 #include <utility>
 
 #include <parse/enums.h>
+#include <parse/page_items/embedded_font_blob.h>
 
 namespace pdflib
 {
@@ -207,6 +208,25 @@ namespace pdflib
     double get_g_x1() const { return g_x1_; }
     double get_g_y1() const { return g_y1_; }
 
+    // Optional embedded font program shared by all text instructions of one
+    // PDF font resource. Set after construction to keep the (already long)
+    // constructor signature stable; may be null.
+    void set_embedded_font(std::shared_ptr<const embedded_font_blob> blob);
+    const std::shared_ptr<const embedded_font_blob>& get_embedded_font() const;
+    bool has_embedded_font() const;
+
+    // Optional decoded PDF character code (or CID for composite fonts) of a
+    // single-character text cell; -1 when unknown or multi-character. Needed
+    // later for glyph-identity rendering of symbolic/subset fonts.
+    void set_char_code(int64_t char_code);
+    int64_t get_char_code() const;
+
+    // Optional glyph name assigned to the character code by the PDF's
+    // /Encoding /Differences; empty when none. This is the authoritative
+    // glyph identity inside the embedded font program.
+    void set_glyph_name(std::string glyph_name);
+    const std::string& get_glyph_name() const;
+
   private:
 
     const std::string text;
@@ -238,8 +258,47 @@ namespace pdflib
     const double g_y0_;
     const double g_x1_;
     const double g_y1_;
+
+    std::shared_ptr<const embedded_font_blob> embedded_font_;
+    int64_t char_code_ = -1;
+    std::string glyph_name_;
   };
 
+  inline void text_instruction::set_embedded_font(std::shared_ptr<const embedded_font_blob> blob)
+  {
+    embedded_font_ = std::move(blob);
+  }
+
+  inline const std::shared_ptr<const embedded_font_blob>& text_instruction::get_embedded_font() const
+  {
+    return embedded_font_;
+  }
+
+  inline bool text_instruction::has_embedded_font() const
+  {
+    return embedded_font_ != nullptr and embedded_font_->has_bytes();
+  }
+
+  inline void text_instruction::set_char_code(int64_t char_code)
+  {
+    char_code_ = char_code;
+  }
+
+  inline int64_t text_instruction::get_char_code() const
+  {
+    return char_code_;
+  }
+
+  inline void text_instruction::set_glyph_name(std::string glyph_name)
+  {
+    glyph_name_ = std::move(glyph_name);
+  }
+
+  inline const std::string& text_instruction::get_glyph_name() const
+  {
+    return glyph_name_;
+  }
+
   class text_widget_instruction
   {
   public: