docling-parse 7.7.1__tar.gz → 7.8.1__tar.gz

{docling_parse-7.7.1 → docling_parse-7.8.1}/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [v7.8.1](https://github.com/docling-project/docling-parse/releases/tag/v7.8.1) - 2026-07-20
+
+### Fix
+
+* Report document load failures instead of deferring them as -1 page count ([#301](https://github.com/docling-project/docling-parse/issues/301)) ([`77eab80`](https://github.com/docling-project/docling-parse/commit/77eab80a6b37df2231299fc59867abc3158bce97))
+* Resolve core-14 font aliases to their standard metrics ([#294](https://github.com/docling-project/docling-parse/issues/294)) ([`109ce27`](https://github.com/docling-project/docling-parse/commit/109ce278db1def7b835b484453e5a34761314d3e))
+
+## [v7.8.0](https://github.com/docling-project/docling-parse/releases/tag/v7.8.0) - 2026-07-10
+
+### Feature
+
+* Adding new top-level methods for page content geometry queries ([#297](https://github.com/docling-project/docling-parse/issues/297)) ([`ef41562`](https://github.com/docling-project/docling-parse/commit/ef415624593d546806423e72fb2b812d811d8161))
+
 ## [v7.7.1](https://github.com/docling-project/docling-parse/releases/tag/v7.7.1) - 2026-07-10
 
 ### Fix

{docling_parse-7.7.1 → docling_parse-7.8.1}/PKG-INFO

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

@@ -569,6 +569,21 @@ PYBIND11_MODULE(pdf_parsers, m) {
 	 "Check if word cells have been created")
     .def("has_line_cells", &pdflib::pdf_decoder<pdflib::PAGE>::has_line_cells,
 	 "Check if line cells have been created")
+    .def("intersects_with", &pdflib::pdf_decoder<pdflib::PAGE>::intersects_with,
+         pybind11::arg("bbox"),
+         pybind11::arg("chars") = false,
+         pybind11::arg("shapes") = true,
+         pybind11::arg("bitmaps") = true,
+         "Check whether visible chars, shapes, or bitmaps intersect [left, bottom, right, top]")
+    .def("get_shape_lines", &pdflib::pdf_decoder<pdflib::PAGE>::get_shape_lines,
+         pybind11::arg("horizontal") = true,
+         pybind11::arg("vertical") = true,
+         pybind11::arg("tolerance") = 1e-3,
+         "Return visible horizontal and/or vertical stroked shape segments as [left, bottom, right, top]")
+    .def("get_connected_shape_bounding_boxes",
+         &pdflib::pdf_decoder<pdflib::PAGE>::get_connected_shape_bounding_boxes,
+         pybind11::arg("tolerance") = 0.0,
+         "Return bboxes of visible shapes connected through overlapping bboxes")
     .def("get_timings", [](pdflib::pdf_decoder<pdflib::PAGE>& self) {
 	   // Return as Dict[str, float] (sums) for backward compatibility
 	   return self.get_timings().to_sum_map();

{docling_parse-7.7.1 → docling_parse-7.8.1}/docling_parse/pdf_parser.py

@@ -1221,6 +1221,62 @@ class PageParseResult:
         """Return structured timing data for this page parse."""
         return self._timings
 
+    def intersects_with(
+        self,
+        *,
+        bbox: BoundingBox,
+        chars: bool = False,
+        shapes: bool = True,
+        bitmaps: bool = True,
+    ) -> bool:
+        """Return whether visible page content intersects bbox.
+
+        bbox may use top-left or bottom-left coordinates. Native code expects
+        page coordinates with bottom-left origin as [left, bottom, right, top].
+        """
+        bbox_bl = bbox.to_bottom_left_origin(page_height=self.page_height)
+        left = min(bbox_bl.l, bbox_bl.r)
+        right = max(bbox_bl.l, bbox_bl.r)
+        bottom = min(bbox_bl.b, bbox_bl.t)
+        top = max(bbox_bl.b, bbox_bl.t)
+
+        return self._require_page_decoder().intersects_with(
+            [left, bottom, right, top],
+            chars=chars,
+            shapes=shapes,
+            bitmaps=bitmaps,
+        )
+
+    def get_shape_lines(
+        self,
+        *,
+        horizontal: bool = True,
+        vertical: bool = True,
+        tolerance: float = 1e-3,
+    ) -> List[BoundingBox]:
+        """Return visible horizontal and/or vertical stroked shape segments."""
+        return [
+            _to_bounding_box(tuple(bbox))
+            for bbox in self._require_page_decoder().get_shape_lines(
+                horizontal=horizontal,
+                vertical=vertical,
+                tolerance=tolerance,
+            )
+        ]
+
+    def get_connected_shape_bounding_boxes(
+        self,
+        *,
+        tolerance: float = 0.0,
+    ) -> List[BoundingBox]:
+        """Return bboxes of visible shapes connected by overlapping bboxes."""
+        return [
+            _to_bounding_box(tuple(bbox))
+            for bbox in self._require_page_decoder().get_connected_shape_bounding_boxes(
+                tolerance=tolerance,
+            )
+        ]
+
     def _rendering_config(self) -> RenderConfig:
         if self._render_config is None:
             raise RuntimeError(

{docling_parse-7.7.1 → docling_parse-7.8.1}/docling_parse.egg-info/PKG-INFO

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

@@ -666,8 +666,10 @@ tests/constants.py
 tests/data_utils.py
 tests/rendering_regression.py
 tests/test_embedded_fonts.py
+tests/test_load_failure.py
 tests/test_locale_safety.py
 tests/test_parse.py
+tests/test_standard_font_widths.py
 tests/test_threaded_parse.py
 tests/test_threaded_render.py
 tests/update_groundtruth.py

{docling_parse-7.7.1 → docling_parse-7.8.1}/pyproject.toml

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

{docling_parse-7.7.1 → docling_parse-7.8.1}/src/parse/pdf_decoders/page.h

@@ -54,6 +54,16 @@ namespace pdflib
     bool has_word_cells() const { return word_cells_created; }
     bool has_line_cells() const { return line_cells_created; }
 
+    bool intersects_with(std::array<double, 4> bbox,
+                         bool chars = false,
+                         bool shapes = true,
+                         bool bitmaps = true);
+    std::vector<std::array<double, 4>> get_shape_lines(bool horizontal = true,
+                                                       bool vertical = true,
+                                                       double tolerance = 1e-3);
+    std::vector<std::array<double, 4>>
+    get_connected_shape_bounding_boxes(double tolerance = 0.0);
+
     // Create word/line cells from page_cells
     void create_word_cells(const decode_config& config);
     void create_line_cells(const decode_config& config);
@@ -248,6 +258,438 @@ namespace pdflib
     return orig_page_number;
   }
 
+  namespace
+  {
+    inline bool bbox_intersects(std::array<double, 4> a,
+                                std::array<double, 4> b)
+    {
+      if(a[0] > a[2]) { std::swap(a[0], a[2]); }
+      if(a[1] > a[3]) { std::swap(a[1], a[3]); }
+      if(b[0] > b[2]) { std::swap(b[0], b[2]); }
+      if(b[1] > b[3]) { std::swap(b[1], b[3]); }
+
+      return a[0] < b[2] and a[2] > b[0] and
+             a[1] < b[3] and a[3] > b[1];
+    }
+
+    inline std::array<double, 4> clipped_bbox(std::array<double, 4> bbox,
+                                              const clip_state_instruction& clip_state,
+                                              bool& visible)
+    {
+      visible = true;
+      if(not clip_state.has_clip()) { return bbox; }
+
+      std::array<double, 4> result = bbox;
+      bool applied_clip = false;
+      for(const auto& path : clip_state.get_paths())
+        {
+          if(path.empty()) { continue; }
+
+          const auto& xs = path.get_x();
+          const auto& ys = path.get_y();
+          std::array<double, 4> clip_bbox = {
+            *std::min_element(xs.begin(), xs.end()),
+            *std::min_element(ys.begin(), ys.end()),
+            *std::max_element(xs.begin(), xs.end()),
+            *std::max_element(ys.begin(), ys.end())
+          };
+
+          if(not bbox_intersects(result, clip_bbox))
+            {
+              visible = false;
+              return bbox;
+            }
+          result = {
+            std::max(result[0], clip_bbox[0]),
+            std::max(result[1], clip_bbox[1]),
+            std::min(result[2], clip_bbox[2]),
+            std::min(result[3], clip_bbox[3])
+          };
+          applied_clip = true;
+        }
+
+      if(not applied_clip)
+        {
+          visible = false;
+          return bbox;
+        }
+
+      return result;
+    }
+
+    inline bool shape_instruction_visible(const shape_instruction& instr)
+    {
+      const auto mode = instr.get_paint_mode();
+      const bool paints_fill =
+        mode == SHAPE_PAINT_FILL or mode == SHAPE_PAINT_FILL_STROKE;
+      const bool paints_stroke =
+        mode == SHAPE_PAINT_STROKE or mode == SHAPE_PAINT_FILL_STROKE;
+      return (paints_fill and instr.get_fill_alpha() > 0.0) or
+             (paints_stroke and instr.get_stroke_alpha() > 0.0);
+    }
+
+    inline bool shape_instruction_strokes_visible(const shape_instruction& instr)
+    {
+      const auto mode = instr.get_paint_mode();
+      const bool paints_stroke =
+        mode == SHAPE_PAINT_STROKE or mode == SHAPE_PAINT_FILL_STROKE;
+      return paints_stroke and instr.get_stroke_alpha() > 0.0;
+    }
+
+    inline bool bbox_overlaps_with_tolerance(const std::array<double, 4>& a,
+                                             const std::array<double, 4>& b,
+                                             double tolerance)
+    {
+      return a[0] <= b[2] + tolerance and a[2] + tolerance >= b[0] and
+             a[1] <= b[3] + tolerance and a[3] + tolerance >= b[1];
+    }
+
+    inline bool shape_visible_bbox(const shape_instruction& instr,
+                                   std::array<double, 4>& bbox)
+    {
+      if(not shape_instruction_visible(instr)) { return false; }
+
+      bool have_point = false;
+      auto include_point = [&](double x, double y) {
+        if(not have_point)
+          {
+            bbox = {x, y, x, y};
+            have_point = true;
+            return;
+          }
+        bbox[0] = std::min(bbox[0], x);
+        bbox[1] = std::min(bbox[1], y);
+        bbox[2] = std::max(bbox[2], x);
+        bbox[3] = std::max(bbox[3], y);
+      };
+
+      for(const auto& subpath : instr.get_subpaths())
+        {
+          include_point(subpath.get_x0(), subpath.get_y0());
+          const auto& xs = subpath.get_px();
+          const auto& ys = subpath.get_py();
+          for(size_t i = 0; i < std::min(xs.size(), ys.size()); ++i)
+            {
+              include_point(xs[i], ys[i]);
+            }
+        }
+
+      if(not have_point) { return false; }
+
+      const double stroke_pad = shape_instruction_strokes_visible(instr)
+        ? std::max(0.0, instr.get_line_width()) * 0.5
+        : 0.0;
+      bbox[0] -= stroke_pad;
+      bbox[1] -= stroke_pad;
+      bbox[2] += stroke_pad;
+      bbox[3] += stroke_pad;
+
+      bool visible = true;
+      bbox = clipped_bbox(bbox, instr.get_clip_state(), visible);
+      return visible;
+    }
+
+    inline bool clip_axis_aligned_segment(double x0,
+                                          double y0,
+                                          double x1,
+                                          double y1,
+                                          const clip_state_instruction& clip_state,
+                                          double tolerance,
+                                          std::array<double, 4>& bbox)
+    {
+      bbox = {
+        std::min(x0, x1),
+        std::min(y0, y1),
+        std::max(x0, x1),
+        std::max(y0, y1)
+      };
+
+      if(not clip_state.has_clip()) { return true; }
+
+      bool applied_clip = false;
+      for(const auto& path : clip_state.get_paths())
+        {
+          if(path.empty()) { continue; }
+
+          const auto& xs = path.get_x();
+          const auto& ys = path.get_y();
+          std::array<double, 4> clip_bbox = {
+            *std::min_element(xs.begin(), xs.end()),
+            *std::min_element(ys.begin(), ys.end()),
+            *std::max_element(xs.begin(), xs.end()),
+            *std::max_element(ys.begin(), ys.end())
+          };
+
+          const bool is_horizontal = std::abs(y1 - y0) <= tolerance;
+          const bool is_vertical = std::abs(x1 - x0) <= tolerance;
+
+          if(is_horizontal)
+            {
+              if(y0 < clip_bbox[1] - tolerance or y0 > clip_bbox[3] + tolerance)
+                {
+                  return false;
+                }
+
+              bbox[0] = std::max(bbox[0], clip_bbox[0]);
+              bbox[2] = std::min(bbox[2], clip_bbox[2]);
+              if(bbox[0] > bbox[2] + tolerance) { return false; }
+              applied_clip = true;
+            }
+          else if(is_vertical)
+            {
+              if(x0 < clip_bbox[0] - tolerance or x0 > clip_bbox[2] + tolerance)
+                {
+                  return false;
+                }
+
+              bbox[1] = std::max(bbox[1], clip_bbox[1]);
+              bbox[3] = std::min(bbox[3], clip_bbox[3]);
+              if(bbox[1] > bbox[3] + tolerance) { return false; }
+              applied_clip = true;
+            }
+          else
+            {
+              return false;
+            }
+        }
+
+      return applied_clip;
+    }
+  }
+
+  bool pdf_decoder<PAGE>::intersects_with(std::array<double, 4> bbox,
+                                          bool chars,
+                                          bool shapes,
+                                          bool bitmaps)
+  {
+    if(bbox[0] > bbox[2]) { std::swap(bbox[0], bbox[2]); }
+    if(bbox[1] > bbox[3]) { std::swap(bbox[1], bbox[3]); }
+
+    if(chars)
+      {
+        for(auto& cell : page_cells)
+          {
+            if(not cell.active or cell.text.empty()) { continue; }
+            if(cell.rendering_mode == 3 or cell.rendering_mode == 7) { continue; }
+
+            std::array<double, 4> cell_bbox = {
+              std::min({cell.r_x0, cell.r_x1, cell.r_x2, cell.r_x3}),
+              std::min({cell.r_y0, cell.r_y1, cell.r_y2, cell.r_y3}),
+              std::max({cell.r_x0, cell.r_x1, cell.r_x2, cell.r_x3}),
+              std::max({cell.r_y0, cell.r_y1, cell.r_y2, cell.r_y3})
+            };
+            if(bbox_intersects(bbox, cell_bbox)) { return true; }
+          }
+      }
+
+    if(shapes)
+      {
+        for(const auto& instr : instructions.get_shape_instructions())
+          {
+            if(not shape_instruction_visible(instr)) { continue; }
+
+            bool have_point = false;
+            std::array<double, 4> shape_bbox = {0.0, 0.0, 0.0, 0.0};
+            auto include_point = [&](double x, double y) {
+              if(not have_point)
+                {
+                  shape_bbox = {x, y, x, y};
+                  have_point = true;
+                  return;
+                }
+              shape_bbox[0] = std::min(shape_bbox[0], x);
+              shape_bbox[1] = std::min(shape_bbox[1], y);
+              shape_bbox[2] = std::max(shape_bbox[2], x);
+              shape_bbox[3] = std::max(shape_bbox[3], y);
+            };
+
+            for(const auto& subpath : instr.get_subpaths())
+              {
+                include_point(subpath.get_x0(), subpath.get_y0());
+                const auto& xs = subpath.get_px();
+                const auto& ys = subpath.get_py();
+                for(size_t i = 0; i < std::min(xs.size(), ys.size()); ++i)
+                  {
+                    include_point(xs[i], ys[i]);
+                  }
+              }
+
+            if(not have_point) { continue; }
+            const double stroke_pad = shape_instruction_strokes_visible(instr)
+              ? std::max(0.0, instr.get_line_width()) * 0.5
+              : 0.0;
+            shape_bbox[0] -= stroke_pad;
+            shape_bbox[1] -= stroke_pad;
+            shape_bbox[2] += stroke_pad;
+            shape_bbox[3] += stroke_pad;
+
+            bool shape_visible = true;
+            const std::array<double, 4> visible_shape_bbox =
+              clipped_bbox(shape_bbox, instr.get_clip_state(), shape_visible);
+
+            if(shape_visible and bbox_intersects(bbox, visible_shape_bbox))
+              {
+                return true;
+              }
+          }
+      }
+
+    if(bitmaps)
+      {
+        for(auto& image : page_images)
+          {
+            if(not image.is_visible) { continue; }
+
+            std::array<double, 4> image_bbox = image.has_visible_bbox
+              ? std::array<double, 4>{image.visible_x0, image.visible_y0,
+                                      image.visible_x1, image.visible_y1}
+              : std::array<double, 4>{image.x0, image.y0, image.x1, image.y1};
+            if(bbox_intersects(bbox, image_bbox)) { return true; }
+          }
+      }
+
+    return false;
+  }
+
+  std::vector<std::array<double, 4>>
+  pdf_decoder<PAGE>::get_shape_lines(bool horizontal,
+                                     bool vertical,
+                                     double tolerance)
+  {
+    std::vector<std::array<double, 4>> result;
+    if(not horizontal and not vertical) { return result; }
+
+    const double tol = std::max(0.0, tolerance);
+
+    for(const auto& instr : instructions.get_shape_instructions())
+      {
+        if(not shape_instruction_strokes_visible(instr)) { continue; }
+
+        for(const auto& subpath : instr.get_subpaths())
+          {
+            double curr_x = subpath.get_x0();
+            double curr_y = subpath.get_y0();
+            double last_x = curr_x;
+            double last_y = curr_y;
+
+            const auto& ops = subpath.get_ops();
+            const auto& xs = subpath.get_px();
+            const auto& ys = subpath.get_py();
+            size_t point_index = 0;
+
+            auto maybe_add_line = [&](double x0, double y0,
+                                      double x1, double y1) {
+              const bool is_horizontal = std::abs(y1 - y0) <= tol;
+              const bool is_vertical = std::abs(x1 - x0) <= tol;
+
+              if(is_horizontal and is_vertical) { return; }
+
+              if((is_horizontal and not horizontal) or
+                 (is_vertical and not vertical) or
+                 (not is_horizontal and not is_vertical))
+                {
+                  return;
+                }
+
+              std::array<double, 4> bbox = {0.0, 0.0, 0.0, 0.0};
+              if(clip_axis_aligned_segment(x0, y0, x1, y1,
+                                           instr.get_clip_state(), tol, bbox))
+                {
+                  result.push_back(bbox);
+                }
+            };
+
+            for(const auto op : ops)
+              {
+                if(op == SEGMENT_LINE_TO)
+                  {
+                    if(point_index >= std::min(xs.size(), ys.size())) { break; }
+
+                    const double next_x = xs[point_index];
+                    const double next_y = ys[point_index];
+                    maybe_add_line(curr_x, curr_y, next_x, next_y);
+
+                    curr_x = next_x;
+                    curr_y = next_y;
+                    last_x = curr_x;
+                    last_y = curr_y;
+                    point_index += 1;
+                  }
+                else if(op == SEGMENT_CUBIC_TO)
+                  {
+                    if(point_index + 2 >= std::min(xs.size(), ys.size())) { break; }
+
+                    curr_x = xs[point_index + 2];
+                    curr_y = ys[point_index + 2];
+                    last_x = curr_x;
+                    last_y = curr_y;
+                    point_index += 3;
+                  }
+              }
+
+            if(subpath.get_closing_type() == CLOSED)
+              {
+                maybe_add_line(last_x, last_y, subpath.get_x0(), subpath.get_y0());
+              }
+          }
+      }
+
+    return result;
+  }
+
+  std::vector<std::array<double, 4>>
+  pdf_decoder<PAGE>::get_connected_shape_bounding_boxes(double tolerance)
+  {
+    std::vector<std::array<double, 4>> boxes;
+    const double tol = std::max(0.0, tolerance);
+
+    for(const auto& instr : instructions.get_shape_instructions())
+      {
+        std::array<double, 4> bbox = {0.0, 0.0, 0.0, 0.0};
+        if(shape_visible_bbox(instr, bbox))
+          {
+            boxes.push_back(bbox);
+          }
+      }
+
+    std::vector<bool> consumed(boxes.size(), false);
+    std::vector<std::array<double, 4>> result;
+
+    for(size_t i = 0; i < boxes.size(); ++i)
+      {
+        if(consumed[i]) { continue; }
+
+        consumed[i] = true;
+        std::array<double, 4> component = boxes[i];
+
+        bool changed = true;
+        while(changed)
+          {
+            changed = false;
+            for(size_t j = 0; j < boxes.size(); ++j)
+              {
+                if(consumed[j]) { continue; }
+
+                if(bbox_overlaps_with_tolerance(component, boxes[j], tol))
+                  {
+                    component = {
+                      std::min(component[0], boxes[j][0]),
+                      std::min(component[1], boxes[j][1]),
+                      std::max(component[2], boxes[j][2]),
+                      std::max(component[3], boxes[j][3])
+                    };
+                    consumed[j] = true;
+                    changed = true;
+                  }
+              }
+          }
+
+        result.push_back(component);
+      }
+
+    return result;
+  }
+
   void pdf_decoder<PAGE>::save_pdf_page(std::filesystem::path const& out_path) const
   {
     std::filesystem::create_directories(out_path.parent_path());

{docling_parse-7.7.1 → docling_parse-7.8.1}/src/parse/pdf_resources/page_font/base_fonts.h

@@ -42,6 +42,8 @@ namespace pdflib
 
     std::string read_fontname(std::string filename);
 
+    void register_standard_aliases();
+
   private:
 
     bool initialized;
@@ -236,6 +238,8 @@ namespace pdflib
 	  }
       }
 
+    register_standard_aliases();
+
     initialized = true;
   }
 
@@ -289,6 +293,45 @@ namespace pdflib
     return fontname;
   }
 
+  void base_fonts::register_standard_aliases()
+  {
+    // A PDF may name a Core-14 font by a common family alias (Arial for
+    // Helvetica, Times New Roman for Times, Courier New for Courier) and ship it
+    // without a /Widths table. The resolver only matches when the canonical
+    // PostScript name is contained in the font name, which these aliases are
+    // not, so bind them to the Core-14 metrics that viewers substitute.
+    static const std::vector<std::pair<std::string, std::string> > aliases =
+      {
+        {"arial",                    "helvetica"},
+        {"arial-bold",               "helvetica-bold"},
+        {"arial-italic",             "helvetica-oblique"},
+        {"arial-bolditalic",         "helvetica-boldoblique"},
+        {"couriernew",               "courier"},
+        {"couriernew-bold",          "courier-bold"},
+        {"couriernew-italic",        "courier-oblique"},
+        {"couriernew-bolditalic",    "courier-boldoblique"},
+        {"times",                    "times-roman"},
+        {"timesnewroman",            "times-roman"},
+        {"timesnewroman-bold",       "times-bold"},
+        {"timesnewroman-italic",     "times-italic"},
+        {"timesnewroman-bolditalic", "times-bolditalic"},
+      };
+
+    for(auto& alias : aliases)
+      {
+        if(name_to_basefont.count(alias.first)==1 or
+           name_to_basefont.count(alias.second)==0)
+          {
+            continue;
+          }
+
+        base_font bf = name_to_basefont.at(alias.second);
+        name_to_basefont.emplace(alias.first, bf);
+
+        core_14_fonts.insert(alias.first);
+      }
+  }
+
 }
 
 #endif