hexapdf 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2889ba1d03e2c351efd694b1583063023fff97c0da636ff5103f88538255735c
-  data.tar.gz: 6fb4727db05900e8fccba2ad4e093d1092e17305e5b5616ded97a76cf835673c
+  metadata.gz: 44eb3afec42bc0c5e0645c0ff6eb48f211083694866fb7c355a0b4ca3e3ad24a
+  data.tar.gz: 864792c029e975b0d8167d80326815ea6a7ebff90bc360c4d550c8a2d4a28003
 SHA512:
-  metadata.gz: 00be8ed2c306a88e5bfc0eada97a7e6bf802ec269e832bb21b3521d4077b18ecad11946ddc6f8a6d575820e66339059e59ba2c4cdd2b74d6c7d6defd0f2f5256
-  data.tar.gz: 94c6a8178ead2a986921b72b07ef5dc388a5fa6a67945573eec921db30c9940d241d3f47591c8fbbf9bdcf313df0dda536f0fc78e0e946e27dfa3bc13dad9a28
+  metadata.gz: 19d415762cb49abfaf31df0d6dc8455c5a6a8b1eee40f18cc4d56b7a18e4d9e9aded8d5826a4f5a265bbc639d61f5a2fe081b1e672b626984d4be719115f4c9a
+  data.tar.gz: 6c8d31294566e9c408cb0fe8512ca4898d583edebe750191fda6d42fcb0a6cb44d83de90359abcac6cca1cf7b47f38e3515b5c94246456b485091d3d72c0be5c

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+## 1.0.1 - 2024-11-05
+
+### Added
+
+* [HexaPDF::Type::CMap] for representing CMap streams
+
+### Fixed
+
+* Checksum calculation for TrueType tables
+* Automatic wrapping of dictionary entry /CIDToGIDMap for CID fonts
+* Performance regression when encoding char codes for TrueType fonts
+* PDF/A validation regression for PDFs using TrueType fonts
+
+
+## 1.0.1 - 2024-11-04
+
+### Changed
+
+* Informational output on errors when running CLI commands to provide more
+  details
+
+### Fixed
+
+* Parsing of indirect objects the value of which is an indirect reference
+* Writing of the initial cross-reference section to ensure a single subsection
+* [HexaPDF::Utils::SortedTreeNode] to wrap all /Kids entries with the correct
+  type class
+
+
 ## 1.0.0 - 2024-10-26
 
 ### Added

data/lib/hexapdf/cli.rb

@@ -64,8 +64,21 @@ module HexaPDF
     rescue StandardError => e
       $stderr.puts "Problem encountered: #{e.message}"
       unless e.kind_of?(HexaPDF::Error)
+        $stderr.puts "Backtrace (last 10 lines):"
+        $stderr.puts e.backtrace[0, 10]
+        $stderr.puts
         $stderr.puts "--> The problem might indicate a faulty PDF or a bug in HexaPDF."
-        $stderr.puts "--> Please report this at https://github.com/gettalong/hexapdf/issues - thanks!"
+        $stderr.puts "--> Please report this at"
+        $stderr.puts "-->"
+        $stderr.puts "-->     https://github.com/gettalong/hexapdf/issues"
+        $stderr.puts "-->"
+        $stderr.puts "--> and include the information above as well as the output of running"
+        $stderr.puts "--> the following command on the input PDF:"
+        $stderr.puts "-->"
+        $stderr.puts "-->     hexapdf info --check INPUT.PDF"
+        $stderr.puts "-->"
+        $stderr.puts "--> If possible, please also provide the input PDF."
+        $stderr.puts "--> Thanks!"
       end
       exit(1)
     end

data/lib/hexapdf/configuration.rb

@@ -722,6 +722,7 @@ module HexaPDF
                         OutputIntent: 'HexaPDF::Type::OutputIntent',
                         XXDestOutputProfileRef: 'HexaPDF::Type::OutputIntent::DestOutputProfileRef',
                         ExData: 'HexaPDF::Type::Annotations::MarkupAnnotation::ExData',
+                        CMap: 'HexaPDF::Type::CMap',
                       },
                       'object.subtype_map' => {
                         nil => {

data/lib/hexapdf/font/true_type/subsetter.rb

@@ -63,16 +63,6 @@ module HexaPDF
         def use_glyph(glyph_id)
           return @glyph_map[glyph_id] if @glyph_map.key?(glyph_id)
           @last_id += 1
-          # Handle codes for ASCII characters \r (13), (, ) (40, 41) and \ (92) specially so that
-          # they never appear in the output (PDF serialization would need to escape them)
-          if @last_id == 13 || @last_id == 40 || @last_id == 92
-            @glyph_map[:"s#{@last_id}"] = @last_id
-            if @last_id == 40
-              @last_id += 1
-              @glyph_map[:"s#{@last_id}"] = @last_id
-            end
-            @last_id += 1
-          end
           @glyph_map[glyph_id] = @last_id
         end
 
@@ -117,7 +107,7 @@ module HexaPDF
           locations = []
 
           @glyph_map.each_key do |old_gid|
-            glyph = orig_glyf[old_gid.kind_of?(Symbol) ? 0 : old_gid]
+            glyph = orig_glyf[old_gid]
             locations << table.size
             data = glyph.raw_data
             if glyph.compound?
@@ -176,10 +166,7 @@ module HexaPDF
         # Adds the components of compound glyphs to the subset.
         def add_glyph_components
           glyf = @font[:glyf]
-          @glyph_map.keys.each do |gid|
-            next if gid.kind_of?(Symbol)
-            glyf[gid].components&.each {|cgid| use_glyph(cgid) }
-          end
+          @glyph_map.keys.each {|gid| glyf[gid].components&.each {|cgid| use_glyph(cgid) } }
         end
 
       end

data/lib/hexapdf/font/true_type/table.rb

@@ -63,7 +63,12 @@ module HexaPDF
 
         # Calculates the checksum for the given data.
         def self.calculate_checksum(data)
-          data.unpack('N*').inject(0) {|sum, long| sum + long } % 2**32
+          checksum = 0
+          if (remainder_length = data.length % 4) != 0
+            checksum = (data[-remainder_length, remainder_length] << "\0" * (4 - remainder_length)).
+              unpack1('N')
+          end
+          checksum + data.unpack('N*').inject(0) {|sum, long| sum + long } % 2**32
         end
 
         # The TrueType font object associated with this table.

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -239,6 +239,11 @@ module HexaPDF
             raise HexaPDF::MissingGlyphError.new(glyph) if glyph.kind_of?(InvalidGlyph)
             @subsetter.use_glyph(glyph.id) if @subsetter
             @last_char_code += 1
+            # Handle codes for ASCII characters \r (13), (, ) (40, 41) and \ (92) specially so that
+            # they never appear in the output (PDF serialization would need to escape them)
+            if @last_char_code == 13 || @last_char_code == 40 || @last_char_code == 92
+              @last_char_code += (@last_char_code == 40 ? 2 : 1)
+            end
             [[@last_char_code].pack('n'), @last_char_code]
           end)[0]
       end
@@ -376,7 +381,11 @@ module HexaPDF
           dict[:Encoding] = :'Identity-H'
         else
           stream = HexaPDF::StreamData.new { HexaPDF::Font::CMap.create_cid_cmap(mapping) }
-          stream_obj = document.add({}, stream: stream)
+          stream_obj = document.add({Type: :CMap,
+                                     CMapName: :Custom,
+                                     CIDSystemInfo: {Registry: "Adobe", Ordering: "Identity",
+                                                     Supplement: 0},
+                                    }, stream: stream)
           stream_obj.set_filter(:FlateDecode)
           dict[:Encoding] = stream_obj
         end

data/lib/hexapdf/parser.rb

@@ -116,7 +116,11 @@ module HexaPDF
                         "the values (#{xref_entry.oid},#{xref_entry.gen}) from the xref")
       end
 
-      @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+      if obj.kind_of?(Reference)
+        @document.deref(obj)
+      else
+        @document.wrap(obj, oid: oid, gen: gen, stream: stream)
+      end
     rescue HexaPDF::MalformedPDFError
       reconstructed_revision.object(xref_entry) ||
         @document.wrap(nil, oid: xref_entry.oid, gen: xref_entry.gen)

data/lib/hexapdf/type/cid_font.rb

@@ -70,7 +70,7 @@ module HexaPDF
       define_field :W,               type: PDFArray
       define_field :DW2,             type: PDFArray, default: [880, -1100]
       define_field :W2,              type: PDFArray
-      define_field :CIDToGIDMap,     type: [Symbol, Stream]
+      define_field :CIDToGIDMap,     type: [Stream, Symbol]
 
       # Returns the unscaled width of the given CID in glyph units, or 0 if the width for the CID is
       # missing.

data/lib/hexapdf/type/cmap.rb

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2014-2024 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#
+# If the GNU Affero General Public License doesn't fit your need,
+# commercial licenses are available at <https://gettalong.at/hexapdf/>.
+#++
+
+require 'hexapdf/stream'
+
+module HexaPDF
+  module Type
+
+    # Represents an embedded CMap file.
+    #
+    # See: PDF2.0 s9.7.5.3
+    class CMap < Stream
+
+      define_type :CMap
+
+      define_field :Type, type: Symbol, required: true, default: type
+      define_field :CMapName, type: Symbol, required: true
+      define_field :CIDSystemInfo, type: :XXCIDSystemInfo, required: true
+      define_field :WMode, type: Integer
+      define_field :UseCMap, type: [Stream, Symbol]
+
+    end
+
+  end
+end

data/lib/hexapdf/type.rb

@@ -82,6 +82,7 @@ module HexaPDF
     autoload(:OptionalContentConfiguration, 'hexapdf/type/optional_content_configuration')
     autoload(:Metadata, 'hexapdf/type/metadata')
     autoload(:OutputIntent, 'hexapdf/type/output_intent')
+    autoload(:CMap, 'hexapdf/type/cmap')
 
   end
 

data/lib/hexapdf/utils/sorted_tree_node.rb

@@ -174,6 +174,7 @@ module HexaPDF
           elsif node.key?(:Kids)
             index = find_in_intermediate_node(node[:Kids], key)
             node = node[:Kids][index]
+            node = document.wrap(node, type: self.class) if node
             break unless node && key >= node[:Limits][0] && key <= node[:Limits][1]
           else
             break
@@ -194,7 +195,7 @@ module HexaPDF
         container_name = leaf_node_container_name
         stack = [self]
         until stack.empty?
-          node = stack.pop
+          node = document.wrap(stack.pop, type: self.class)
           if node.key?(container_name)
             data = node[container_name]
             index = 0
@@ -217,7 +218,7 @@ module HexaPDF
       def path_to_key(node, key, stack)
         return unless node.key?(:Kids)
         index = find_in_intermediate_node(node[:Kids], key)
-        stack << node[:Kids][index]
+        stack << document.wrap(node[:Kids][index], type: self.class)
         path_to_key(stack.last, key, stack)
       end
 
@@ -307,6 +308,15 @@ module HexaPDF
         super
         container_name = leaf_node_container_name
 
+        if key?(:Kids)
+          self[:Kids].each do |kid|
+            unless kid.indirect?
+              yield("Children of sorted tree nodes must be indirect", true)
+              document.add(kid)
+            end
+          end
+        end
+
         # All keys of the container must be lexically ordered strings and the container must be
         # correctly formatted
         if key?(container_name)

data/lib/hexapdf/version.rb

@@ -37,6 +37,6 @@
 module HexaPDF
 
   # The version of HexaPDF.
-  VERSION = '1.0.0'
+  VERSION = '1.0.2'
 
 end

data/lib/hexapdf/writer.rb

@@ -149,6 +149,7 @@ module HexaPDF
       obj_to_stm = object_streams.each_with_object({}) {|stm, m| m.update(stm.write_objects(rev)) }
 
       xref_section = XRefSection.new
+      xref_section.mark_as_initial_section! unless previous_xref_pos
       xref_section.add_free_entry(0, 65535) if previous_xref_pos.nil?
       rev.each do |obj|
         if obj.null?

data/lib/hexapdf/xref_section.rb

@@ -111,6 +111,13 @@ module HexaPDF
     # used.
     private :'[]='
 
+    # Marks this XRefSection object as being the first cross-reference section in a PDF file.
+    #
+    # This has the consequence that only a single sub-section is created.
+    def mark_as_initial_section!
+      @initial_section = true
+    end
+
     # Adds an in-use entry to the cross-reference section.
     #
     # See: ::in_use_entry
@@ -147,15 +154,24 @@ module HexaPDF
     # If this section contains no objects, a single empty array is yielded (corresponding to a
     # subsection with zero elements).
     #
-    # The subsections are dynamically generated based on the object numbers in this section.
+    # The subsections are dynamically generated based on the object numbers in this section. In case
+    # the section was marked as the initial section (see #mark_as_initial_section!) only a single
+    # subsection is yielded.
     def each_subsection
       return to_enum(__method__) unless block_given?
 
       temp = []
       oids.sort.each do |oid|
-        if !temp.empty? && temp[-1].oid + 1 != oid
-          yield(temp)
-          temp = []
+        expected_next_oid = !temp.empty? && temp[-1].oid + 1
+        if expected_next_oid && expected_next_oid != oid
+          if @initial_section
+            expected_next_oid.upto(oid - 1) do |free_oid|
+              temp << self.class.free_entry(free_oid, 0)
+            end
+          else
+            yield(temp)
+            temp = []
+          end
         end
         temp << self[oid]
       end

data/test/hexapdf/font/test_true_type_wrapper.rb

@@ -119,6 +119,11 @@ describe HexaPDF::Font::TrueTypeWrapper do
       assert_equal([3].pack('n'), code)
     end
 
+    it "doesn't use char codes 13, 40, 41 and 92 because they would need to be escaped" do
+      codes = 1.upto(93).map {|i| @font_wrapper.encode(@font_wrapper.glyph(i)) }.join
+      assert_equal([1..12, 14..39, 42..91, 93..97].flat_map(&:to_a).pack('n*'), codes)
+    end
+
     it "raises an error if an InvalidGlyph is encoded" do
       exp = assert_raises(HexaPDF::MissingGlyphError) do
         @font_wrapper.encode(@font_wrapper.decode_utf8("ö").first)

data/test/hexapdf/font/true_type/test_subsetter.rb

@@ -27,16 +27,6 @@ describe HexaPDF::Font::TrueType::Subsetter do
     assert_equal(value, @subsetter.subset_glyph_id(5))
   end
 
-  it "doesn't use certain subset glyph IDs for performance reasons" do
-    1.upto(93) {|i| @subsetter.use_glyph(i) }
-    # glyph 0, 93 used glyph, 4 special glyphs
-    assert_equal(1 + 93 + 4, @subsetter.instance_variable_get(:@glyph_map).size)
-    1.upto(12) {|i| assert_equal(i, @subsetter.subset_glyph_id(i), "id=#{i}") }
-    13.upto(38) {|i| assert_equal(i + 1, @subsetter.subset_glyph_id(i), "id=#{i}") }
-    39.upto(88) {|i| assert_equal(i + 3, @subsetter.subset_glyph_id(i), "id=#{i}") }
-    89.upto(93) {|i| assert_equal(i + 4, @subsetter.subset_glyph_id(i), "id=#{i}") }
-  end
-
   it "creates the subset font file" do
     gid = @font[:cmap].preferred_table[0x41]
     @subsetter.use_glyph(gid)

data/test/hexapdf/font/true_type/test_table.rb

@@ -13,6 +13,18 @@ describe HexaPDF::Font::TrueType::Table do
     @entry = HexaPDF::Font::TrueType::Table::Directory::Entry.new('tagg', 0, 0, @file.io.string.length)
   end
 
+  describe "self.calculate_checksum" do
+    it "works for data with a length divisible by four" do
+      klass = HexaPDF::Font::TrueType::Table
+      assert_equal(256, klass.calculate_checksum("\x00\x00\x00\x01\x00\x00\x00\xFF"))
+    end
+
+    it "works for data with a length not divisible by four" do
+      klass = HexaPDF::Font::TrueType::Table
+      assert_equal(512, klass.calculate_checksum("\x00\x00\x00\x01\x00\x00\x00\xFF\x00\x00\x01"))
+    end
+  end
+
   describe "initialize" do
     it "reads the data from the associated file" do
       table = TrueTypeTestTable.new(@file, @entry)

data/test/hexapdf/test_parser.rb

@@ -33,18 +33,23 @@ describe HexaPDF::Parser do
       endstream
       endobj
 
+      5 0 obj
+      1 0 R
+      endobj
+
       xref
       0 4
       0000000000 65535 f 
       0000000010 00000 n 
       0000000029 00000 n 
       0000000000 65535 f 
-      3 1
+      3 2
       0000000556 00000 n 
+      0000000308 00000 n
       trailer
       << /Test (now) >>
       startxref
-      308
+      330
       %%EOF
     EOF
   end
@@ -305,6 +310,11 @@ describe HexaPDF::Parser do
       assert_equal(0, obj.gen)
     end
 
+    it "handles the case of the value of an indirect object being an indirect reference" do
+      obj = @parser.load_object(HexaPDF::XRefSection.in_use_entry(5, 0, 308))
+      assert_equal(1, obj.oid)
+    end
+
     describe "with strict parsing" do
       it "raises an error if an indirect object has an offset of 0" do
         @document.config['parser.on_correctable_error'] = proc { true }
@@ -343,13 +353,13 @@ describe HexaPDF::Parser do
 
   describe "startxref_offset" do
     it "caches the offset value" do
-      assert_equal(308, @parser.startxref_offset)
-      @parser.instance_eval { @io }.string.sub!(/308\n/, "309\n")
-      assert_equal(308, @parser.startxref_offset)
+      assert_equal(330, @parser.startxref_offset)
+      @parser.instance_eval { @io }.string.sub!(/330\n/, "309\n")
+      assert_equal(330, @parser.startxref_offset)
     end
 
     it "returns the correct offset" do
-      assert_equal(308, @parser.startxref_offset)
+      assert_equal(330, @parser.startxref_offset)
     end
 
     it "ignores garbage at the end of the file" do

data/test/hexapdf/test_writer.rb

@@ -53,8 +53,8 @@ describe HexaPDF::Writer do
     EOF
 
     xref_stream = case HexaPDF::VERSION.length
-                  when 5 then "x\xDAcbdlc``b`\xB0\x04\x93\x93\x19\x18\x00\f\x0F\x01["
-                  when 6 then "x\xDAcbdlg``b`\xB0\x04\x93\x93\x18\x18\x00\f\e\x01["
+                  when 5 then "x\xDAcbdlg``b`\xB0\x04\x93\x93\x19\x18\x00\f\x1E\x01\\"
+                  when 6 then "x\xDAcbd\xEC```b`\xB0\x04\x93\x93\x18\x18\x00\f*\x01\\"
                   else fail
                   end
     @compressed_input_io = StringIO.new(<<~EOF.force_encoding(Encoding::BINARY))
@@ -69,8 +69,8 @@ describe HexaPDF::Writer do
       20
       endobj
       3 0 obj
-      <</Size 6/Type/XRef/W[1 1 2]/Index[0 4 5 1]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 31>>stream
-      x\xDAcb`\xF8\xFF\x9F\x89\x89\x95\x91\x91\xE9\x7F\x19\x03\x03\x13\x83\x10\x88he`\x00\x00B4\x04\x1E
+      <</Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 36>>stream
+      x\xDAcb`\xF8\xFF\x9F\x89\x89\x95\x91\x91\xE9\x7F\x19\x03\x03\x13\x83\x10\x90\xF8_\f\x14c\x14bd\x04\x00lk\a 
       endstream
       endobj
       startxref
@@ -90,7 +90,7 @@ describe HexaPDF::Writer do
       endstream
       endobj
       startxref
-      #{442 + HexaPDF::VERSION.length}
+      #{443 + HexaPDF::VERSION.length}
       %%EOF
     EOF
   end

data/test/hexapdf/test_xref_section.rb

@@ -57,5 +57,20 @@ describe HexaPDF::XRefSection do
       @xref_section.add_in_use_entry(20, 0, 0)
       assert_subsections([[1, 2], [10, 11], [20]])
     end
+
+    it "yields a single subsection if the section was marked as the initial one" do
+      @xref_section.mark_as_initial_section!
+      @xref_section.add_in_use_entry(6, 0, 0)
+      @xref_section.add_in_use_entry(7, 0, 0)
+      @xref_section.add_in_use_entry(9, 0, 0)
+      @xref_section.add_in_use_entry(1, 0, 0)
+      @xref_section.add_in_use_entry(2, 0, 0)
+      result = @xref_section.each_subsection.map {|s| s.map {|e| [e.oid, e.type] }}
+      assert_equal([[[1, :in_use], [2, :in_use],
+                     [3, :free], [4, :free], [5, :free],
+                     [6, :in_use], [7, :in_use],
+                     [8, :free],
+                     [9, :in_use]]], result)
+    end
   end
 end

data/test/hexapdf/utils/test_sorted_tree_node.rb

@@ -12,10 +12,12 @@ describe HexaPDF::Utils::SortedTreeNode do
   end
 
   def add_multilevel_entries
-    @kid11 = @doc.add({Limits: ['c', 'f'], Names: ['c', 1, 'f', 1]}, type: HexaPDF::NameTreeNode)
+    item = @doc.add(1)
+    @item_ref = HexaPDF::Reference.new(item.oid, item.gen)
+    @kid11 = @doc.add({Limits: ['c', 'f'], Names: ['c', @item_ref, 'f', 1]}, type: HexaPDF::NameTreeNode)
     @kid12 = @doc.add({Limits: ['i', 'm'], Names: ['i', 1, 'm', 1]}, type: HexaPDF::NameTreeNode)
     ref = HexaPDF::Reference.new(@kid11.oid, @kid11.gen)
-    @kid1 = @doc.add({Limits: ['c', 'm'], Kids: [ref, @kid12]}, type: HexaPDF::NameTreeNode)
+    @kid1 = @doc.add({Limits: ['c', 'm'], Kids: [ref, @kid12]})
     @kid21 = @doc.add({Limits: ['o', 'q'], Names: ['o', 1, 'q', 1]}, type: HexaPDF::NameTreeNode)
     @kid221 = @doc.add({Limits: ['s', 'u'], Names: ['s', 1, 'u', 1]}, type: HexaPDF::NameTreeNode)
     @kid22 = @doc.add({Limits: ['s', 'u'], Kids: [@kid221]}, type: HexaPDF::NameTreeNode)
@@ -75,7 +77,7 @@ describe HexaPDF::Utils::SortedTreeNode do
       @root.add_entry('v', 1)
       assert_equal(['a', 'm'], @kid1[:Limits].value)
       assert_equal(['a', 'f'], @kid11[:Limits].value)
-      assert_equal(['a', 1, 'c', 1, 'e', 1, 'f', 1], @kid11[:Names].value)
+      assert_equal(['a', 1, 'c', @item_ref, 'e', 1, 'f', 1], @kid11[:Names].value)
       assert_equal(['g', 'm'], @kid12[:Limits].value)
       assert_equal(['g', 1, 'i', 1, 'j', 1, 'm', 1], @kid12[:Names].value)
       assert_equal(['n', 'v'], @kid2[:Limits].value)
@@ -203,13 +205,12 @@ describe HexaPDF::Utils::SortedTreeNode do
     end
 
     it "checks that all kid objects are indirect objects" do
-      @root[:Kids][0] = ref = HexaPDF::Reference.new(@kid1.oid, @kid1.gen)
       assert(@root.validate)
 
-      @root[:Kids][0] = ref
+      @root[:Kids][0] = @kid1
       @kid1.oid = 0
       assert(@root.validate do |message, c|
-               assert_match(/must be an indirect object/, message)
+               assert_match(/children.*must be indirect/i, message)
                assert(c)
              end)
       assert(@kid1.indirect?)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hexapdf
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Thomas Leitner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-26 00:00:00.000000000 Z
+date: 2024-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdparse
@@ -500,6 +500,7 @@ files:
 - lib/hexapdf/type/annotations/widget.rb
 - lib/hexapdf/type/catalog.rb
 - lib/hexapdf/type/cid_font.rb
+- lib/hexapdf/type/cmap.rb
 - lib/hexapdf/type/embedded_file.rb
 - lib/hexapdf/type/file_specification.rb
 - lib/hexapdf/type/font.rb