pdf-reader 2.9.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b4616131d0ad73c4ef2c4992ae79d4fde420d6857aba60e8dfac9b088a0b915
-  data.tar.gz: f93f481d7f76af426420dbf507a88e8ecead8ec84690781f42de3b7b5ffbd1bd
+  metadata.gz: 55bfae4c5211a0f3ac70845500183e237d3d5f9cc81d548a27f4b8c5fd5acfc9
+  data.tar.gz: 9e9000474695100c4874afd9abf5f6290ea0b59ffa773c3d03a4a3fc3d2a0a4c
 SHA512:
-  metadata.gz: 86dbe3450a11e0deb3f5db98625375b252cc25f289d76c98b5de48342d1b4957de81c1c2b6cce53d7d09738e9576bd48213c92166d48911c1f45ad6a77f195a5
-  data.tar.gz: ee852ff644a095bae93eb7cc30c6d070c8c6adda4f9bfadecf938bf3ba2723fed08c75a3bf15ba30fcf8fded7ad6a5b74dad8a3f512823798686350f24b912eb
+  metadata.gz: 2dc96f064c3b233bd499a5a8140bb6f61fd1bdadb2582ac9bc569adff911e63aaadc16188d6624e0ed766481d453912bf5e0057add84262d753681cc40f51776
+  data.tar.gz: 64dfac4dd2b73a5302be95c47e74e7ca8b94fc6daeaea30c7a33cca6b4be79b68facc571d209f44a59de2632f6241166a290fe0f2835498b2b7d611906b05a31

data/CHANGELOG

@@ -1,3 +1,14 @@
+v2.10.0 (12th May 2022)
+- Various bug fixes
+- Expanded sorbet type annotations
+
+v2.9.2 (20th February 2022)
+- Fix PDF::Reader::ObjectHash#page_references to return an Array of PDF::Reader::Reference (http://github.com/yob/pdf-reader/pull/444)
+
+v2.9.1 (4th February 2022)
+- Fix exception in Page#walk introduced in 2.9.0 (http://github.com/yob/pdf-reader/pull/442)
+- Other small bug fixes
+
 v2.9.0 (24th January 2022)
 - Support additional encryption standards (http://github.com/yob/pdf-reader/pull/419)
 - Return CropBox correctly from Page#rectangles (https://github.com/yob/pdf-reader/pull/420)

data/lib/pdf/reader/cid_widths.rb

@@ -1,9 +1,7 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
-#
-
 require 'forwardable'
 
 class PDF::Reader
@@ -33,10 +31,10 @@ class PDF::Reader
         params << array.shift
 
         if params.size == 2 && params.last.is_a?(Array)
-          widths.merge! parse_first_form(params.first, params.last)
+          widths.merge! parse_first_form(params.first.to_i, Array(params.last))
           params = []
         elsif params.size == 3
-          widths.merge! parse_second_form(params[0], params[1], params[2])
+          widths.merge! parse_second_form(params[0].to_i, params[1].to_i, params[2].to_i)
           params = []
         end
       end
@@ -54,6 +52,8 @@ class PDF::Reader
 
     # this is the form 10 20 123 where all index between 10 and 20 have width 123
     def parse_second_form(first, final, width)
+      raise MalformedPDFError, "CidWidths: #{first} must be less than #{final}" unless first < final
+
       (first..final).inject({}) { |accum, index|
         accum[index] = width
         accum

data/lib/pdf/reader/error.rb

@@ -58,10 +58,6 @@ class PDF::Reader
     def self.validate_not_nil(object, name)
       raise ArgumentError, "#{object} must not be nil" if object.nil?
     end
-    ################################################################################
-    def self.validate_not_nil_as_malformed(object, name)
-      raise MalformedPDFError, "#{object} must not be nil" if object.nil?
-    end
   end
 
   ################################################################################

data/lib/pdf/reader/filter/depredict.rb

@@ -125,7 +125,7 @@ class PDF::Reader
               row_data[index] = (byte + paeth) % 256
             end
           else
-            raise ArgumentError, "Invalid filter algorithm #{filter}"
+            raise MalformedPDFError, "Invalid filter algorithm #{filter}"
           end
 
           s = []

data/lib/pdf/reader/filter.rb

@@ -43,16 +43,15 @@ class PDF::Reader
     #
     def self.with(name, options = {})
       case name
-      when :ASCII85Decode   then PDF::Reader::Filter::Ascii85.new(options)
-      when :ASCIIHexDecode  then PDF::Reader::Filter::AsciiHex.new(options)
-      when :CCITTFaxDecode  then PDF::Reader::Filter::Null.new(options)
-      when :DCTDecode       then PDF::Reader::Filter::Null.new(options)
-      when :FlateDecode     then PDF::Reader::Filter::Flate.new(options)
-      when :Fl              then PDF::Reader::Filter::Flate.new(options)
-      when :JBIG2Decode     then PDF::Reader::Filter::Null.new(options)
-      when :JPXDecode       then PDF::Reader::Filter::Null.new(options)
-      when :LZWDecode       then PDF::Reader::Filter::Lzw.new(options)
-      when :RunLengthDecode then PDF::Reader::Filter::RunLength.new(options)
+      when :ASCII85Decode, :A85   then PDF::Reader::Filter::Ascii85.new(options)
+      when :ASCIIHexDecode, :AHx  then PDF::Reader::Filter::AsciiHex.new(options)
+      when :CCITTFaxDecode, :CCF  then PDF::Reader::Filter::Null.new(options)
+      when :DCTDecode, :DCT       then PDF::Reader::Filter::Null.new(options)
+      when :FlateDecode, :Fl      then PDF::Reader::Filter::Flate.new(options)
+      when :JBIG2Decode           then PDF::Reader::Filter::Null.new(options)
+      when :JPXDecode             then PDF::Reader::Filter::Null.new(options)
+      when :LZWDecode, :LZW       then PDF::Reader::Filter::Lzw.new(options)
+      when :RunLengthDecode, :RL  then PDF::Reader::Filter::RunLength.new(options)
       else
         raise UnsupportedFeatureError, "Unknown filter: #{name}"
       end

data/lib/pdf/reader/font.rb

@@ -205,14 +205,17 @@ class PDF::Reader
     end
 
     def extract_descendants(obj)
-      return unless obj[:DescendantFonts]
       # per PDF 32000-1:2008 pp. 280 :DescendentFonts is:
       # A one-element array specifying the CIDFont dictionary that is the
       # descendant of this Type 0 font.
-      descendants = @ohash.deref_array(obj[:DescendantFonts])
-      @descendantfonts = descendants.map { |desc|
-        PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc))
-      }
+      if obj[:DescendantFonts]
+        descendants = @ohash.deref_array(obj[:DescendantFonts])
+        @descendantfonts = descendants.map { |desc|
+          PDF::Reader::Font.new(@ohash, @ohash.deref_hash(desc))
+        }
+      else
+        @descendantfonts = []
+      end
     end
 
     def to_utf8_via_cmap(params)
@@ -226,9 +229,7 @@ class PDF::Reader
           @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR
         }.flatten.pack("U*")
       when Array
-        params.collect { |param| to_utf8_via_cmap(param) }
-      else
-        params
+        params.collect { |param| to_utf8_via_cmap(param) }.join("")
       end
     end
 
@@ -243,9 +244,7 @@ class PDF::Reader
       when String
         encoding.to_utf8(params)
       when Array
-        params.collect { |param| to_utf8_via_encoding(param) }
-      else
-        params
+        params.collect { |param| to_utf8_via_encoding(param) }.join("")
       end
     end
 

data/lib/pdf/reader/font_descriptor.rb

@@ -56,7 +56,9 @@ class PDF::Reader
         end
         char_metric = ttf_program_stream.horizontal_metrics.metrics[glyph_id]
         if char_metric
-          return char_metric.advance_width
+          char_metric.advance_width
+        else
+          0
         end
       end
     end

data/lib/pdf/reader/form_xobject.rb

@@ -45,7 +45,7 @@ module PDF
       def font_objects
         raw_fonts = @objects.deref_hash(fonts)
         ::Hash[raw_fonts.map { |label, font|
-          [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font))]
+          [label, PDF::Reader::Font.new(@objects, @objects.deref_hash(font) || {})]
         }]
       end
 
@@ -55,6 +55,9 @@ module PDF
       # See the comments on PDF::Reader::Page#walk for more detail.
       #
       def walk(*receivers)
+        receivers = receivers.map { |receiver|
+          ValidatingReceiver.new(receiver)
+        }
         content_stream(receivers, raw_content)
       end
 

data/lib/pdf/reader/lzw.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module PDF
@@ -25,12 +25,14 @@ module PDF
         def initialize(data, bits_in_chunk)
           @data = data
           @data.force_encoding("BINARY")
-          @bits_in_chunk = bits_in_chunk
+          set_bits_in_chunk(bits_in_chunk)
           @current_pos = 0
           @bits_left_in_byte = 8
         end
 
         def set_bits_in_chunk(bits_in_chunk)
+          raise MalformedPDFError, "invalid LZW bits" if bits_in_chunk < 9 || bits_in_chunk > 12
+
           @bits_in_chunk = bits_in_chunk
         end
 
@@ -39,7 +41,7 @@ module PDF
           chunk = -1
           while bits_left_in_chunk > 0 and @current_pos < @data.size
             chunk = 0 if chunk < 0
-            codepoint = @data[@current_pos, 1].unpack("C*")[0]
+            codepoint = @data[@current_pos, 1].to_s.unpack("C*")[0].to_i
             current_byte = codepoint & (2**@bits_left_in_byte - 1) #clear consumed bits
             dif = bits_left_in_chunk - @bits_left_in_byte
             if dif > 0 then  current_byte <<= dif
@@ -61,21 +63,25 @@ module PDF
       CODE_CLEAR_TABLE = 256 #clear table
 
       # stores de pairs code => string
-      class StringTable < Hash # :nodoc:
+      class StringTable
         attr_reader :string_table_pos
 
         def initialize
-          super
+          @data = Hash.new
           @string_table_pos = 258 #initial code
         end
 
         #if code less than 258 return fixed string
         def [](key)
-          if key > 257 then super else key.chr end
+          if key > 257
+            @data[key]
+          else
+            key.chr
+          end
         end
 
         def add(string)
-          store(@string_table_pos, string)
+          @data.store(@string_table_pos, string)
           @string_table_pos += 1
         end
       end
@@ -83,7 +89,7 @@ module PDF
       # Decompresses a LZW compressed string.
       #
       def self.decode(data)
-        stream = BitStream.new data.to_s, 9 # size of codes between 9 and 12 bits
+        stream = BitStream.new(data.to_s, 9) # size of codes between 9 and 12 bits
         string_table = StringTable.new
         result = "".dup
         until (code = stream.read) == CODE_EOD
@@ -119,8 +125,17 @@ module PDF
         result
       end
 
-      def self.create_new_string(string_table,some_code, other_code)
-        string_table[some_code] + string_table[other_code][0].chr
+      def self.create_new_string(string_table, some_code, other_code)
+        raise MalformedPDFError, "invalid LZW data" if some_code.nil? || other_code.nil?
+
+        item_one = string_table[some_code]
+        item_two = string_table[other_code]
+
+        if item_one && item_two
+          item_one + item_two.chr
+        else
+          raise MalformedPDFError, "invalid LZW data"
+        end
       end
       private_class_method :create_new_string
 

data/lib/pdf/reader/object_hash.rb

@@ -243,7 +243,7 @@ class PDF::Reader
 
       obj.tap { |obj|
         if !obj.is_a?(PDF::Reader::Stream)
-          raise MalformedPDFError, "expected object to be an Array or nil"
+          raise MalformedPDFError, "expected object to be a Stream or nil"
         end
       }
     end
@@ -496,7 +496,9 @@ class PDF::Reader
     def fetch_object_stream(key)
       if xref[key].is_a?(PDF::Reader::Reference)
         container_key = xref[key]
-        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(object(container_key))
+        stream = deref_stream(container_key)
+        raise MalformedPDFError, "Object Stream cannot be nil" if stream.nil?
+        object_streams[container_key] ||= PDF::Reader::ObjectStream.new(stream)
         object_streams[container_key][key.id]
       end
     end
@@ -571,12 +573,16 @@ class PDF::Reader
     # the Array is significant and matches the page ordering of the document
     #
     def get_page_objects(obj)
-      if obj[:Type] == :Page
+      derefed_obj = deref_hash(obj)
+
+      if derefed_obj.nil?
+        raise MalformedPDFError, "Expected Page or Pages object, got nil"
+      elsif derefed_obj[:Type] == :Page
         [obj]
-      elsif obj[:Kids]
-        kids = deref_array(obj[:Kids]) || []
+      elsif derefed_obj[:Kids]
+        kids = deref_array(derefed_obj[:Kids]) || []
         kids.map { |kid|
-          get_page_objects(deref_hash(kid) || {})
+          get_page_objects(kid)
         }.flatten
       else
         raise MalformedPDFError, "Expected Page or Pages object"

data/lib/pdf/reader/object_stream.rb

@@ -24,7 +24,7 @@ class PDF::Reader
     end
 
     def size
-      @dict[:N]
+      TypeCheck.cast_to_int!(@dict[:N])
     end
 
     private
@@ -40,7 +40,7 @@ class PDF::Reader
     end
 
     def first
-      @dict[:First]
+      TypeCheck.cast_to_int!(@dict[:First])
     end
 
     def buffer

data/lib/pdf/reader/page.rb

@@ -278,7 +278,9 @@ module PDF
           []
         else
           obj = objects.deref_hash(origin)
-          PDF::Reader::Error.validate_not_nil_as_malformed(obj, "parent")
+          if obj.nil?
+            raise MalformedPDFError, "parent mus not be nil"
+          end
           [ select_inheritable(obj) ] + ancestors(obj[:Parent])
         end
       end

data/lib/pdf/reader/page_state.rb

@@ -16,7 +16,7 @@ class PDF::Reader
         :h_scaling      => 1.0,
         :text_leading   => 0,
         :text_font      => nil,
-        :text_font_size => nil,
+        :text_font_size => 0,
         :text_mode      => 0,
         :text_rise      => 0,
         :text_knockout  => 0
@@ -32,6 +32,12 @@ class PDF::Reader
         @cs_stack      = [page.color_spaces]
         @stack         = [DEFAULT_GRAPHICS_STATE.dup]
         state[:ctm]  = identity_matrix
+
+        # These are only valid when inside a `BT` block and we re-initialize them on each
+        # `BT`. However, we need the instance variables set so PDFs with the text operators
+        # out order don't trigger NoMethodError when these are nil
+        @text_matrix      = identity_matrix
+        @text_line_matrix = identity_matrix
       end
 
       #####################################################

data/lib/pdf/reader/parser.rb

@@ -96,7 +96,13 @@ class PDF::Reader
     # id  - the object ID to return
     # gen - the object revision number to return
     def object(id, gen)
-      Error.assert_equal(parse_token, id)
+      idCheck = parse_token
+
+      # Sometimes the xref table is corrupt and points to an offset slightly too early in the file.
+      # check the next token, maybe we can find the start of the object we're looking for
+      if idCheck != id
+        Error.assert_equal(parse_token, id)
+      end
       Error.assert_equal(parse_token, gen)
       Error.str_assert(parse_token, "obj")
 
@@ -222,7 +228,10 @@ class PDF::Reader
       data = @buffer.read(length, :skip_eol => true)
 
       Error.str_assert(parse_token, "endstream")
-      Error.str_assert(parse_token, "endobj")
+
+      # We used to assert that the stream had the correct closing token, but it doesn't *really*
+      # matter if it's missing, and other readers seems to handle its absence just fine
+      # Error.str_assert(parse_token, "endobj")
 
       PDF::Reader::Stream.new(dict, data)
     end

data/lib/pdf/reader/resources.rb

@@ -92,7 +92,8 @@ module PDF
       #       of calling it over and over.
       #
       def xobjects
-        @objects.deref_hash!(@resources[:XObject]) || {}
+        dict = @objects.deref_hash!(@resources[:XObject]) || {}
+        TypeCheck.cast_to_pdf_dict_with_stream_values!(dict)
       end
 
     end

data/lib/pdf/reader/stream.rb

@@ -40,7 +40,7 @@ class PDF::Reader
     # Creates a new stream with the specified dictionary and data. The dictionary
     # should be a standard ruby hash, the data should be a standard ruby string.
     def initialize(hash, data)
-      @hash = hash
+      @hash = TypeCheck.cast_to_pdf_dict!(hash)
       @data = data
       @udata = nil
     end

data/lib/pdf/reader/type_check.rb

@@ -9,6 +9,18 @@ module PDF
     #
     class TypeCheck
 
+      def self.cast_to_int!(obj)
+        if obj.is_a?(Integer)
+          obj
+        elsif obj.nil?
+          0
+        elsif obj.respond_to?(:to_i)
+          obj.to_i
+        else
+          raise MalformedPDFError, "Unable to cast to integer"
+        end
+      end
+
       def self.cast_to_numeric!(obj)
         if obj.is_a?(Numeric)
           obj
@@ -46,6 +58,40 @@ module PDF
           raise MalformedPDFError, "Unable to cast to symbol"
         end
       end
+
+      def self.cast_to_symbol!(obj)
+        res = cast_to_symbol(obj)
+        if res
+          res
+        else
+          raise MalformedPDFError, "Unable to cast to symbol"
+        end
+      end
+
+      def self.cast_to_pdf_dict!(obj)
+        if obj.is_a?(Hash)
+          obj
+        elsif obj.respond_to?(:to_h)
+          obj.to_h
+        else
+          raise MalformedPDFError, "Unable to cast to hash"
+        end
+      end
+
+      def self.cast_to_pdf_dict_with_stream_values!(obj)
+        if obj.is_a?(Hash)
+          result = Hash.new
+          obj.each do |k, v|
+            raise MalformedPDFError, "Expected a stream" unless v.is_a?(PDF::Reader::Stream)
+            result[cast_to_symbol!(k)] = v
+          end
+          result
+        elsif obj.respond_to?(:to_h)
+          cast_to_pdf_dict_with_stream_values!(obj.to_h)
+        else
+          raise MalformedPDFError, "Unable to cast to hash"
+        end
+      end
     end
   end
 end

data/lib/pdf/reader/validating_receiver.rb

@@ -249,7 +249,7 @@ module PDF
       end
 
       def method_missing(methodname, *args)
-        @wrapped.call(methodname, *args)
+        @wrapped.send(methodname, *args)
       end
 
       private

data/lib/pdf/reader/width_calculator/built_in.rb

@@ -53,12 +53,13 @@ class PDF::Reader
       private
 
       def control_character?(code_point)
-        @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
+        match = @font.encoding.int_to_name(code_point).first.to_s[/\Acontrol..\Z/]
+        match ? true : false
       end
 
       def extract_basefont(font_name)
         if BUILTINS.include?(font_name)
-          font_name
+          font_name.to_s
         else
           "Times-Roman"
         end

data/lib/pdf/reader/width_calculator/composite.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -22,7 +22,11 @@ class PDF::Reader
 
         w = @widths[code_point]
         # 0 is a valid width
-        return w.to_f unless w.nil?
+        if w
+          w.to_f
+        else
+          0
+        end
       end
     end
   end

data/lib/pdf/reader/width_calculator/true_type.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -10,8 +10,8 @@ class PDF::Reader
       def initialize(font)
         @font = font
 
-        if @font.font_descriptor
-          @missing_width = @font.font_descriptor.missing_width
+        if fd = @font.font_descriptor
+          @missing_width = fd.missing_width
         else
           @missing_width = 0
         end
@@ -30,25 +30,23 @@ class PDF::Reader
 
         # in ruby a negative index is valid, and will go from the end of the array
         # which is undesireable in this case.
-        if @font.first_char && @font.first_char <= code_point
-          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        first_char = @font.first_char
+        if first_char && first_char <= code_point
+          @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f
         else
           @missing_width.to_f
         end
       end
 
       def glyph_width_from_descriptor(code_point)
-        return unless @font.font_descriptor
-
         # true type fonts will have most of their information contained
         # with-in a program inside the font descriptor, however the widths
         # may not be in standard PDF glyph widths (1000 units => 1 text space unit)
         # so this width will need to be scaled
-        w = @font.font_descriptor.glyph_width(code_point)
-        if w
-          w.to_f * @font.font_descriptor.glyph_to_pdf_scale_factor
-        else
-          nil
+        if fd = @font.font_descriptor
+          if w = fd.glyph_width(code_point)
+            w.to_f * fd.glyph_to_pdf_scale_factor.to_f
+          end
         end
       end
     end

data/lib/pdf/reader/width_calculator/type_one_or_three.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -10,8 +10,8 @@ class PDF::Reader
       def initialize(font)
         @font = font
 
-        if @font.font_descriptor
-          @missing_width = @font.font_descriptor.missing_width
+        if fd = @font.font_descriptor
+          @missing_width = fd.missing_width
         else
           @missing_width = 0
         end
@@ -23,8 +23,9 @@ class PDF::Reader
 
         # in ruby a negative index is valid, and will go from the end of the array
         # which is undesireable in this case.
-        if @font.first_char <= code_point
-          @font.widths.fetch(code_point - @font.first_char, @missing_width).to_f
+        first_char = @font.first_char
+        if first_char && first_char <= code_point
+          @font.widths.fetch(code_point - first_char, @missing_width.to_i).to_f
         else
           @missing_width.to_f
         end

data/lib/pdf/reader/width_calculator/type_zero.rb

@@ -1,5 +1,5 @@
 # coding: utf-8
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 class PDF::Reader
@@ -13,13 +13,16 @@ class PDF::Reader
 
       def initialize(font)
         @font = font
-        @descendant_font = @font.descendantfonts.first
       end
 
       def glyph_width(code_point)
         return 0 if code_point.nil? || code_point < 0
 
-        @descendant_font.glyph_width(code_point).to_f
+        if descendant_font = @font.descendantfonts.first
+          descendant_font.glyph_width(code_point).to_f
+        else
+          0
+        end
       end
     end
   end

data/rbi/pdf-reader.rbi

@@ -145,16 +145,18 @@ module PDF
     end
 
     class CidWidths
-      sig { params(default: T.untyped, array: T.untyped).void }
-      def initialize(default, array); end
+      sig { params(default: Numeric, array: T::Array[Numeric]).void }
+      def initialize(default, array)
+        @widths = T.let(T.unsafe(nil), T::Hash[Numeric, Numeric])
+      end
 
-      sig { params(default: T.untyped, array: T.untyped).returns(T.untyped) }
+      sig { params(default: Numeric, array: T::Array[Numeric]).returns(T::Hash[Numeric, Numeric]) }
       def parse_array(default, array); end
 
-      sig { params(first: T.untyped, widths: T.untyped).returns(T.untyped) }
+      sig { params(first: Integer, widths: T::Array[Numeric]).returns(T::Hash[Numeric, Numeric]) }
       def parse_first_form(first, widths); end
 
-      sig { params(first: T.untyped, final: T.untyped, width: T.untyped).returns(T.untyped) }
+      sig { params(first: Integer, final: Integer, width: Numeric).returns(T::Hash[Numeric, Numeric]) }
       def parse_second_form(first, final, width); end
     end
 
@@ -279,9 +281,6 @@ module PDF
 
       sig { params(object: Object, name: String).void }
 		  def self.validate_not_nil(object, name); end
-
-      sig { params(object: Object, name: String).void }
-		  def self.validate_not_nil_as_malformed(object, name); end
     end
 
     class MalformedPDFError < RuntimeError
@@ -300,138 +299,146 @@ module PDF
     end
 
     class Font
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Symbol)) }
       attr_accessor :subtype
 
-      sig { returns(T.untyped) }
+      sig { returns(PDF::Reader::Encoding) }
       attr_accessor :encoding
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[PDF::Reader::Font]) }
       attr_accessor :descendantfonts
 
-      sig { returns(T.untyped) }
+      sig { returns(PDF::Reader::CMap) }
       attr_accessor :tounicode
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Integer]) }
       attr_reader :widths
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Integer)) }
       attr_reader :first_char
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Integer)) }
       attr_reader :last_char
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Symbol)) }
       attr_reader :basefont
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(PDF::Reader::FontDescriptor)) }
       attr_reader :font_descriptor
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Numeric]) }
       attr_reader :cid_widths
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :cid_default_width
 
-      sig { params(ohash: T.untyped, obj: T.untyped).void }
+      sig { params(ohash: PDF::Reader::ObjectHash, obj: T::Hash[Symbol, T.untyped]).void }
       def initialize(ohash, obj); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
+      sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) }
       def to_utf8(params); end
 
-      sig { params(data: T.untyped).returns(T.untyped) }
+      sig { params(data: String).returns(T::Array[T.nilable(T.any(Numeric, String))]) }
       def unpack(data); end
 
-      sig { params(code_point: T.untyped).returns(T.untyped) }
+      sig { params(code_point: T.any(String, Integer)).returns(T.untyped) }
       def glyph_width(code_point); end
 
-      sig { params(font_name: T.untyped).returns(T.untyped) }
+      sig { params(font_name: Symbol).returns(PDF::Reader::Encoding) }
       def default_encoding(font_name); end
 
-      sig { returns(T.untyped) }
+      sig {
+        returns(
+          T.any(
+            PDF::Reader::WidthCalculator::BuiltIn,
+            PDF::Reader::WidthCalculator::Composite,
+            PDF::Reader::WidthCalculator::TrueType,
+            PDF::Reader::WidthCalculator::TypeOneOrThree,
+            PDF::Reader::WidthCalculator::TypeZero,
+          )
+        )
+      }
       def build_width_calculator; end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: T.untyped).void }
       def extract_base_info(obj); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: T.untyped).void }
       def extract_descriptor(obj); end
 
-      sig { params(obj: T.untyped).returns(T.untyped) }
+      sig { params(obj: T.untyped).void }
       def extract_descendants(obj); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
+      sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) }
       def to_utf8_via_cmap(params); end
 
-      sig { params(params: T.untyped).returns(T.untyped) }
+      sig { params(params: T.any(Integer, String, T::Array[T.untyped])).returns(String) }
       def to_utf8_via_encoding(params); end
     end
 
     class FontDescriptor
-      sig { returns(T.untyped) }
+      sig { returns(String) }
       attr_reader :font_name
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(String)) }
       attr_reader :font_family
 
-      sig { returns(T.untyped) }
+      sig { returns(Symbol) }
       attr_reader :font_stretch
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :font_weight
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Numeric]) }
       attr_reader :font_bounding_box
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :cap_height
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :ascent
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :descent
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :leading
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :avg_width
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :max_width
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       attr_reader :missing_width
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Numeric)) }
       attr_reader :italic_angle
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Numeric)) }
       attr_reader :stem_v
 
-      sig { returns(T.untyped) }
+      sig { returns(T.nilable(Numeric)) }
       attr_reader :x_height
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       attr_reader :font_flags
 
       sig { params(ohash: PDF::Reader::ObjectHash, fd_hash: T::Hash[T.untyped, T.untyped]).void }
       def initialize(ohash, fd_hash); end
 
-      sig { params(char_code: T.untyped).returns(T.untyped) }
+      sig { params(char_code: Integer).returns(Numeric) }
       def glyph_width(char_code); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Numeric) }
       def glyph_to_pdf_scale_factor; end
 
-      sig { returns(T.untyped) }
+      sig { returns(TTFunk::File) }
       def ttf_program_stream; end
     end
 
     class FormXObject
-      include ResourceMethods
-
       sig { returns(T.untyped) }
       attr_reader :xobject
 
@@ -517,34 +524,43 @@ module PDF
       CODE_CLEAR_TABLE = 256
 
       class BitStream
-        sig { params(data: T.untyped, bits_in_chunk: T.untyped).void }
-        def initialize(data, bits_in_chunk); end
+        sig { params(data: String, bits_in_chunk: Integer).void }
+        def initialize(data, bits_in_chunk)
+          @data = T.let(T.unsafe(nil), String)
+          @bits_in_chunk = T.let(T.unsafe(nil), Integer)
+          @current_pos = T.let(T.unsafe(nil), Integer)
+          @bits_left_in_byte = T.let(T.unsafe(nil), Integer)
+
+        end
 
-        sig { params(bits_in_chunk: T.untyped).returns(T.untyped) }
+        sig { params(bits_in_chunk: Integer).void }
         def set_bits_in_chunk(bits_in_chunk); end
 
-        sig { returns(T.untyped) }
+        sig { returns(Integer) }
         def read; end
       end
 
-      class StringTable < Hash
-        sig { returns(T.untyped) }
+      class StringTable
+        sig { returns(Integer) }
         attr_reader :string_table_pos
 
         sig { void }
-        def initialize; end
+        def initialize
+          @data = T.let(T.unsafe(nil), T::Hash[Integer, String])
+          @string_table_pos = T.let(T.unsafe(nil), Integer)
+        end
 
-        sig { params(key: T.untyped).returns(T.untyped) }
+        sig { params(key: Integer).returns(T.nilable(String)) }
         def [](key); end
 
-        sig { params(string: T.untyped).returns(T.untyped) }
+        sig { params(string: String).void }
         def add(string); end
       end
 
-      sig { params(data: T.untyped).returns(T.untyped) }
+      sig { params(data: String).returns(String) }
       def self.decode(data); end
 
-      sig { params(string_table: T.untyped, some_code: T.untyped, other_code: T.untyped).returns(T.untyped) }
+      sig { params(string_table: PDF::Reader::LZW::StringTable, some_code: T.nilable(Integer), other_code: T.nilable(Integer)).returns(String) }
       def self.create_new_string(string_table, some_code, other_code); end
     end
 
@@ -647,7 +663,7 @@ module PDF
       sig { params(key: T.untyped).returns(T.nilable(T::Array[Numeric])) }
       def deref_array_of_numbers(key); end
 
-      sig { params(key: T.untyped).returns(T.nilable(T:Hash[Symbol, T.untyped])) }
+      sig { params(key: T.untyped).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def deref_hash(key); end
 
       sig { params(key: T.untyped).returns(T.nilable(Symbol)) }
@@ -674,10 +690,10 @@ module PDF
       sig { params(key: T.untyped).returns(T.untyped) }
       def deref!(key); end
 
-      sig { params(key: T.untyped).returns(T::Array[T.untyped]) }
+      sig { params(key: T.untyped).returns(T.nilable(T::Array[T.untyped])) }
       def deref_array!(key); end
 
-      sig { params(key: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+      sig { params(key: T.untyped).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
       def deref_hash!(key); end
 
       sig { params(key: T.untyped, local_default: T.untyped).returns(T.untyped) }
@@ -763,22 +779,25 @@ module PDF
     end
 
     class ObjectStream
-      sig { params(stream: T.untyped).void }
-      def initialize(stream); end
+      sig { params(stream: PDF::Reader::Stream).void }
+      def initialize(stream)
+        @dict = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+        @data = T.let(T.unsafe(nil), String)
+      end
 
       sig { params(objid: T.untyped).returns(T.untyped) }
       def [](objid); end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def size; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Integer, Integer]) }
       def offsets; end
 
-      sig { returns(T.untyped) }
+      sig { returns(Integer) }
       def first; end
 
-      sig { returns(T.untyped) }
+      sig { returns(PDF::Reader::Buffer) }
       def buffer; end
     end
 
@@ -807,8 +826,6 @@ module PDF
     end
 
     class Page
-      include ResourceMethods
-
       sig { returns(PDF::Reader::ObjectHash) }
       attr_reader :objects
 
@@ -881,7 +898,7 @@ module PDF
       sig { params(origin: T.untyped).returns(T.untyped) }
       def ancestors(origin = @page_object[:Parent]); end
 
-      sig { params(obj: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+      sig { params(obj: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
       def select_inheritable(obj); end
     end
 
@@ -1386,31 +1403,36 @@ module PDF
       def series(*methods); end
     end
 
-    module ResourceMethods
-      extend T::Helpers
+    class Resources
 
-      sig { returns(T.untyped) }
+      sig { params(objects: PDF::Reader::ObjectHash, resources: T::Hash[T.untyped, T.untyped]).void }
+      def initialize(objects, resources)
+        @objects = T.let(T.unsafe(nil), PDF::Reader::ObjectHash)
+        @resources = T.let(T.unsafe(nil), T::Hash[Symbol, T.untyped])
+      end
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def color_spaces; end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def fonts; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def graphic_states; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def patterns; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Array[Symbol]) }
       def procedure_sets; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def properties; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, T.untyped]) }
       def shadings; end
 
-      sig { returns(T.untyped) }
+      sig { returns(T::Hash[Symbol, PDF::Reader::Stream]) }
       def xobjects; end
     end
 
@@ -1674,6 +1696,9 @@ module PDF
 
     class TypeCheck
 
+      sig { params(obj: T.untyped).returns(Integer) }
+      def self.cast_to_int!(obj); end
+
       sig { params(obj: T.untyped).returns(Numeric) }
       def self.cast_to_numeric!(obj); end
 
@@ -1682,6 +1707,15 @@ module PDF
 
       sig { params(obj: T.untyped).returns(T.nilable(Symbol)) }
       def self.cast_to_symbol(obj); end
+
+      sig { params(obj: T.untyped).returns(Symbol) }
+      def self.cast_to_symbol!(obj); end
+
+      sig { params(obj: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+      def self.cast_to_pdf_dict!(obj); end
+
+      sig { params(obj: T.untyped).returns(T::Hash[Symbol, PDF::Reader::Stream]) }
+      def self.cast_to_pdf_dict_with_stream_values!(obj); end
     end
 
     class ValidatingReceiver
@@ -1923,54 +1957,67 @@ module PDF
         :ZapfDingbats
       ]
 
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: Integer).returns(T::Boolean) }
         def control_character?(code_point); end
 
-        sig { params(font_name: T.untyped).returns(T.untyped) }
+        sig { params(font_name: T.nilable(Symbol)).returns(String) }
         def extract_basefont(font_name); end
       end
 
       class Composite
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+          @widths = T.let(T.unsafe(nil), PDF::Reader::CidWidths)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
       end
 
       class TrueType
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+          @missing_width = T.let(T.unsafe(nil), Numeric)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: Integer).returns(T.nilable(Numeric)) }
         def glyph_width_from_font(code_point); end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: Integer).returns(T.nilable(Numeric)) }
         def glyph_width_from_descriptor(code_point); end
       end
 
       class TypeOneOrThree
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+          @missing_width = T.let(T.unsafe(nil), Numeric)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
       end
 
       class TypeZero
-        sig { params(font: T.untyped).void }
-        def initialize(font); end
+        sig { params(font: PDF::Reader::Font).void }
+        def initialize(font)
+          @font = T.let(T.unsafe(nil), PDF::Reader::Font)
+        end
 
-        sig { params(code_point: T.untyped).returns(T.untyped) }
+        sig { params(code_point: T.nilable(Integer)).returns(Numeric) }
         def glyph_width(code_point); end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pdf-reader
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.0
 platform: ruby
 authors:
 - James Healy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-24 00:00:00.000000000 Z
+date: 2022-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -288,9 +288,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/yob/pdf-reader/issues
-  changelog_uri: https://github.com/yob/pdf-reader/blob/v2.9.0/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.9.0
-  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.9.0
+  changelog_uri: https://github.com/yob/pdf-reader/blob/v2.10.0/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.10.0
+  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.10.0
 post_install_message:
 rdoc_options:
 - "--title"
@@ -311,7 +311,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: A library for accessing the content of PDF files