pdf-reader 2.15.1 → 2.16.0

data/lib/pdf/reader/rectangle.rb

@@ -70,10 +70,21 @@ module PDF
         bottom_right.x - bottom_left.x
       end
 
+      # Is the point inside this rectangle? Nicer to read and use than contains_xy?(), but
+      # allocates more objects so be careful using on hot code paths.
+      #
       #: (PDF::Reader::Point) -> bool
       def contains?(point)
-        point.x >= bottom_left.x && point.x <= top_right.x &&
-          point.y >= bottom_left.y && point.y <= top_right.y
+        contains_xy?(point.x, point.y)
+      end
+
+      # Is the point inside this rectangle? Worse to read and use than contains?(), but
+      # allocates fewer objects so may be preferrable on hot code paths.
+      #
+      #: (Numeric, Numeric) -> bool
+      def contains_xy?(x, y)
+        x >= bottom_left.x && x <= top_right.x &&
+          y >= bottom_left.y && y <= top_right.y
       end
 
       # A pdf-style 4-number array

data/lib/pdf/reader/reference.rb

@@ -71,7 +71,7 @@ class PDF::Reader
     # return an identical hash
     #: () -> Integer
     def hash
-      "#{self.id}:#{self.gen}".hash
+      (id << 16) ^ gen
     end
     ################################################################################
   end

data/lib/pdf/reader/standard_key_builder.rb

@@ -2,7 +2,7 @@
 # typed: strict
 
 require 'digest/md5'
-require 'rc4'
+require 'pdf/reader/rc4'
 
 class PDF::Reader
 
@@ -91,22 +91,21 @@ class PDF::Reader
     #
     #: (String) -> String?
     def auth_owner_pass(pass)
+      owner_key = @owner_key
+      raise MalformedPDFError, "encrypted PDF is missing an owner key" if owner_key.nil?
+
       md5 = Digest::MD5.digest(pad_pass(pass))
       if @revision > 2 then
         50.times { md5 = Digest::MD5.digest(md5) }
         keyBegins = md5[0, @key_length]
         #first iteration decrypt owner_key
-        out = @owner_key
+        out = owner_key
         #RC4 keyed with (keyBegins XOR with iteration #) to decrypt previous out
         19.downto(0).each { |i|
-          # The RC4 gem doen't have type annotations, so the type checker doesn't
-          # know decrypt() returns a string
-          out = TypeCheck.cast_to_string!(
-            RC4.new(xor_each_byte(keyBegins,i)).decrypt(out)
-          )
+          out = Rc4.new(xor_each_byte(keyBegins,i)).decrypt(out)
         }
       else
-        out = RC4.new( md5[0, 5] ).decrypt( @owner_key )
+        out = Rc4.new( md5[0, 5] ).decrypt( owner_key )
       end
       # c) check output as user password
       auth_user_pass( out )
@@ -129,10 +128,10 @@ class PDF::Reader
         #initialize out for first iteration
         out = Digest::MD5.digest(PassPadBytes.pack("C*") + @file_id)
         #zero doesn't matter -> so from 0-19
-        20.times{ |i| out=RC4.new(xor_each_byte(keyBegins, i)).encrypt(out) }
+        20.times{ |i| out=Rc4.new(xor_each_byte(keyBegins, i)).encrypt(out) }
         pass = @user_key.to_s[0, 16] == out
       else
-        pass = RC4.new(keyBegins).encrypt(PassPadBytes.pack("C*")) == @user_key
+        pass = Rc4.new(keyBegins).encrypt(PassPadBytes.pack("C*")) == @user_key
       end
       pass ? keyBegins : nil
     end

data/lib/pdf/reader/text_run.rb

@@ -7,9 +7,6 @@ class PDF::Reader
   class TextRun
     include Comparable
 
-    #: PDF::Reader::Point
-    attr_reader :origin
-
     #: Numeric
     attr_reader :width
 
@@ -23,15 +20,23 @@ class PDF::Reader
 
     #: (Numeric, Numeric, Numeric, Numeric, String) -> void
     def initialize(x, y, width, font_size, text)
-      @origin = PDF::Reader::Point.new(x, y) #: PDF::Reader::Point
+      @x = x #: Numeric
+      @y = y #: Numeric
       @width = width
       @font_size = font_size
       @text = text
+      @origin = nil #: PDF::Reader::Point | nil
       @endx = nil #: Numeric | nil
       @endy = nil #: Numeric | nil
       @mergable_range = nil #: Range[Numeric] | nil
     end
 
+    # Lazily constructed to avoid allocating a Point on every TextRun
+    #: () -> PDF::Reader::Point
+    def origin
+      @origin ||= PDF::Reader::Point.new(@x, @y)
+    end
+
     # Allows collections of TextRun objects to be sorted. They will be sorted
     # in order of their position on a cartesian plain - Top Left to Bottom Right
     #: (PDF::Reader::Point) -> Numeric
@@ -53,22 +58,22 @@ class PDF::Reader
 
     #: () -> Numeric
     def x
-      @origin.x
+      @x
     end
 
     #: () -> Numeric
     def y
-      @origin.y
+      @y
     end
 
     #: () -> Numeric
     def endx
-      @endx ||= @origin.x + width
+      @endx ||= @x + width
     end
 
     #: () -> Numeric
     def endy
-      @endy ||= @origin.y + font_size
+      @endy ||= @y + font_size
     end
 
     #: () -> Numeric

data/lib/pdf/reader/transformation_matrix.rb

@@ -54,6 +54,17 @@ class PDF::Reader
        @e,@f,1]
     end
 
+    # Apply a left-multiplication by a translation matrix [1, 0, 0, 1, tx, ty]
+    # without allocating a new TransformationMatrix.
+    #
+    #: (Numeric, Numeric) -> void
+    def prepend_translation!(tx, ty)
+      new_e = (tx * @a) + (ty * @c) + @e
+      new_f = (tx * @b) + (ty * @d) + @f
+      @e = new_e
+      @f = new_f
+    end
+
     # multiply this matrix with another.
     #
     # the second matrix is represented by the 6 scalar values that are changeable

data/lib/pdf/reader/type_check.rb

@@ -50,7 +50,7 @@ module PDF
         end
       end
 
-      #: (untyped) -> Symbol | nil
+      #: (untyped) -> (Symbol | nil)
       def self.cast_to_symbol(obj)
         if obj.is_a?(Symbol)
           obj

data/lib/pdf/reader/xref.rb

@@ -151,14 +151,17 @@ class PDF::Reader
           end
 
           objid, count = params[0].to_i, params[1].to_i
-          count.times do
+          count.times do |entry_index|
             offset = buf.token.to_i
             generation = buf.token.to_i
             state = buf.token
 
             # Some PDF writers start numbering at 1 instead of 0. Fix up the number.
-            # TODO should this fix be logged?
-            objid = 0 if objid == 1 and offset == 0 and generation == 65535 and state == 'f'
+            # Only apply this on the first entry of the section - if entry_index > 0,
+            # objid has been incremented from 0 and object 1 is a legitimate free entry.
+            if entry_index == 0 and objid == 1 and offset == 0 and generation == 65535 and state == 'f'
+              objid = 0
+            end
             store(objid, generation, offset + @junk_offset) if state == "n" && offset > 0
             objid += 1
             params.clear

data/lib/pdf/reader.rb

@@ -130,7 +130,7 @@ module PDF
     #: () -> Hash[untyped, untyped]?
     def info
       dict = @objects.deref_hash(@objects.trailer[:Info]) || {}
-      doc_strings_to_utf8(dict)
+      EncodingUtils.obj_to_utf8(dict)
     end
 
     # Return a String with extra XML metadata provided by the author of the PDF file. Not
@@ -234,58 +234,6 @@ module PDF
 
     private
 
-    # recursively convert strings from outside a content stream into UTF-8
-    #
-    #: (untyped) -> untyped
-    def doc_strings_to_utf8(obj)
-      case obj
-      when ::Hash then
-        {}.tap { |new_hash|
-          obj.each do |key, value|
-            new_hash[key] = doc_strings_to_utf8(value)
-          end
-        }
-      when Array then
-        obj.map { |item| doc_strings_to_utf8(item) }
-      when String then
-        if has_utf16_bom?(obj)
-          utf16_to_utf8(obj)
-        else
-          pdfdoc_to_utf8(obj)
-        end
-      else
-        obj
-      end
-    end
-
-    #: (String) -> bool
-    def has_utf16_bom?(str)
-      first_bytes = str[0,2]
-
-      return false if first_bytes.nil?
-
-      first_bytes.unpack("C*") == [254, 255]
-    end
-
-    # TODO find a PDF I can use to spec this behaviour
-    #
-    #: (String) -> String
-    def pdfdoc_to_utf8(obj)
-      obj.force_encoding("utf-8")
-      obj
-    end
-
-    # one day we'll all run on a 1.9 compatible VM and I can just do this with
-    # String#encode
-    #
-    #: (String) -> String
-    def utf16_to_utf8(obj)
-      str = obj[2, obj.size].to_s
-      str = str.unpack("n*").pack("U*")
-      str.force_encoding("utf-8")
-      str
-    end
-
     #: () -> Hash[Symbol, untyped]
     def root
       @root ||= @objects.deref_hash(@objects.trailer[:Root]) || {}
@@ -302,6 +250,7 @@ require 'pdf/reader/bounding_rectangle_runs_filter'
 require 'pdf/reader/cid_widths'
 require 'pdf/reader/cmap'
 require 'pdf/reader/encoding'
+require 'pdf/reader/encoding_utils'
 require 'pdf/reader/error'
 require 'pdf/reader/filter'
 require 'pdf/reader/filter/ascii85'
@@ -333,6 +282,7 @@ require 'pdf/reader/standard_key_builder'
 require 'pdf/reader/key_builder_v5'
 require 'pdf/reader/aes_v2_security_handler'
 require 'pdf/reader/aes_v3_security_handler'
+require 'pdf/reader/rc4'
 require 'pdf/reader/rc4_security_handler'
 require 'pdf/reader/unimplemented_security_handler'
 require 'pdf/reader/stream'

data/rbi/pdf-reader.rbi

@@ -33,21 +33,9 @@ class PDF::Reader
 
   private
 
-  sig { params(obj: T.untyped).returns(T.untyped) }
-  def doc_strings_to_utf8(obj); end
-
-  sig { params(str: ::String).returns(T::Boolean) }
-  def has_utf16_bom?(str); end
-
-  sig { params(obj: ::String).returns(::String) }
-  def pdfdoc_to_utf8(obj); end
-
   sig { returns(T::Hash[::Symbol, T.untyped]) }
   def root; end
 
-  sig { params(obj: ::String).returns(::String) }
-  def utf16_to_utf8(obj); end
-
   class << self
     sig do
       params(
@@ -198,6 +186,9 @@ class PDF::Reader::Buffer
   sig { returns(T::Boolean) }
   def in_content_stream?; end
 
+  sig { params(str: ::String, regexp: ::Regexp).returns(T::Boolean) }
+  def match?(str, regexp); end
+
   sig { void }
   def merge_indirect_reference; end
 
@@ -237,6 +228,7 @@ PDF::Reader::Buffer::ID = T.let(T.unsafe(nil), String)
 PDF::Reader::Buffer::LEFT_PAREN = T.let(T.unsafe(nil), String)
 PDF::Reader::Buffer::LESS_THAN = T.let(T.unsafe(nil), String)
 PDF::Reader::Buffer::LF = T.let(T.unsafe(nil), String)
+PDF::Reader::Buffer::NAME_TERMINATOR_BYTES = T.let(T.unsafe(nil), Array)
 PDF::Reader::Buffer::NULL_BYTE = T.let(T.unsafe(nil), String)
 PDF::Reader::Buffer::STREAM = T.let(T.unsafe(nil), String)
 PDF::Reader::Buffer::TOKEN_DELIMITER = T.let(T.unsafe(nil), Array)
@@ -282,6 +274,7 @@ class PDF::Reader::CMap
 end
 
 PDF::Reader::CMap::CMAP_KEYWORDS = T.let(T.unsafe(nil), Hash)
+PDF::Reader::CMap::EMPTY_CODEPOINTS = T.let(T.unsafe(nil), Array)
 PDF::Reader::CMap::HIGH_SURROGATE_RANGE = T.let(T.unsafe(nil), Range)
 
 class PDF::Reader::CidWidths
@@ -329,12 +322,12 @@ class PDF::Reader::Encoding
 
   private
 
+  sig { params(file: ::String).returns(T::Hash[::Integer, ::Integer]) }
+  def build_file_mapping(file); end
+
   sig { params(str: ::String).returns(::String) }
   def convert_to_utf8(str); end
 
-  sig { returns(T::Hash[::Integer, ::Integer]) }
-  def default_mapping; end
-
   sig { params(enc: ::Symbol).returns(T.nilable(::String)) }
   def get_mapping_file(enc); end
 
@@ -350,15 +343,47 @@ class PDF::Reader::Encoding
   sig { params(times: ::Integer).returns(::String) }
   def little_boxes(times); end
 
-  sig { params(file: ::String).void }
-  def load_mapping(file); end
-
   sig { returns(T::Boolean) }
   def utf8_conversion_impossible?; end
+
+  sig { params(codepoint: ::Integer).returns(T::Boolean) }
+  def valid_unicode_scalar?(codepoint); end
 end
 
 PDF::Reader::Encoding::CONTROL_CHARS = T.let(T.unsafe(nil), Array)
+PDF::Reader::Encoding::DEFAULT_MAPPING = T.let(T.unsafe(nil), Hash)
+PDF::Reader::Encoding::FILE_MAPPINGS = T.let(T.unsafe(nil), Hash)
 PDF::Reader::Encoding::UNKNOWN_CHAR = T.let(T.unsafe(nil), Integer)
+
+class PDF::Reader::EncodingUtils
+  sig { params(obj: T.untyped).returns(T.untyped) }
+  def obj_to_utf8(obj); end
+
+  sig { params(str: ::String).returns(::String) }
+  def string_to_utf8(str); end
+
+  private
+
+  sig { params(str: ::String).returns(T::Boolean) }
+  def has_utf16_bom?(str); end
+
+  sig { params(str: ::String).returns(::String) }
+  def pdfdoc_to_utf8(str); end
+
+  sig { params(obj: ::String).returns(::String) }
+  def utf16_to_utf8(obj); end
+
+  class << self
+    sig { params(obj: T.untyped).returns(T.untyped) }
+    def obj_to_utf8(obj); end
+
+    sig { params(str: ::String).returns(::String) }
+    def string_to_utf8(str); end
+  end
+end
+
+PDF::Reader::EncodingUtils::PDFDOC_CODEPOINTS = T.let(T.unsafe(nil), Hash)
+PDF::Reader::EncodingUtils::UTF16_BOM = T.let(T.unsafe(nil), Array)
 class PDF::Reader::EncryptedPDFError < ::PDF::Reader::UnsupportedFeatureError; end
 
 class PDF::Reader::Error
@@ -375,10 +400,10 @@ class PDF::Reader::Error
     sig { params(object: ::Object, name: ::String).void }
     def validate_not_nil(object, name); end
 
-    sig { params(object: ::Object, name: ::String, klass: ::Module).void }
+    sig { params(object: ::Object, name: ::String, klass: T::Module[T.untyped]).void }
     def validate_type(object, name, klass); end
 
-    sig { params(object: ::Object, name: ::String, klass: ::Module).void }
+    sig { params(object: ::Object, name: ::String, klass: T::Module[T.untyped]).void }
     def validate_type_as_malformed(object, name, klass); end
   end
 end
@@ -558,8 +583,8 @@ class PDF::Reader::Font
   sig { params(obj: T::Hash[::Symbol, T.untyped]).void }
   def extract_type3_info(obj); end
 
-  sig { params(x: ::Numeric, y: ::Numeric).returns([::Numeric, ::Numeric]) }
-  def font_matrix_transform(x, y); end
+  sig { params(pt: ::PDF::Reader::Point).returns(::PDF::Reader::Point) }
+  def font_matrix_transform(pt); end
 
   sig do
     params(
@@ -825,25 +850,34 @@ class PDF::Reader::ObjectCache
   def has_key?(key); end
   def has_value?(value); end
 
-  sig { returns(T.untyped) }
+  sig { returns(::Integer) }
   def hits; end
 
   def include?(key); end
   def key?(key); end
+
+  sig { returns(T::Array[T.untyped]) }
   def keys; end
+
   def length; end
   def member?(key); end
 
-  sig { returns(T.untyped) }
+  sig { returns(::Integer) }
   def misses; end
 
   def size; end
+
+  sig { returns(::String) }
   def to_s; end
+
+  sig { returns(T::Array[T.untyped]) }
   def values; end
 
   private
 
+  sig { params(obj: T.untyped).returns(T.nilable(T::Boolean)) }
   def cacheable?(obj); end
+
   def update_stats(key); end
 end
 
@@ -852,7 +886,7 @@ PDF::Reader::ObjectCache::CACHEABLE_TYPES = T.let(T.unsafe(nil), Array)
 class PDF::Reader::ObjectHash
   include ::Enumerable
 
-  sig { params(input: T.any(::IO, ::String, ::StringIO, ::Tempfile), opts: T::Hash[::Symbol, T.untyped]).void }
+  sig { params(input: T.untyped, opts: T::Hash[::Symbol, T.untyped]).void }
   def initialize(input, opts = T.unsafe(nil)); end
 
   sig { params(key: T.any(::Integer, ::PDF::Reader::Reference)).returns(T.untyped) }
@@ -1004,7 +1038,7 @@ class PDF::Reader::ObjectHash
   end
   def deref_internal!(key, seen); end
 
-  sig { params(input: T.any(::IO, ::String, ::StringIO, ::Tempfile)).returns(T.any(::IO, ::StringIO, ::Tempfile)) }
+  sig { params(input: T.untyped).returns(T.untyped) }
   def extract_io_from(input); end
 
   sig do
@@ -1241,7 +1275,13 @@ class PDF::Reader::PageState
   def begin_text_object; end
   def clone_state; end
   def concatenate_matrix(a, b, c, d, e, f); end
+
+  sig { params(x: ::Numeric, y: ::Numeric).returns([::Numeric]) }
   def ctm_transform(x, y); end
+
+  sig { params(pt: T.any(::Numeric, ::PDF::Reader::Point), opt_y: ::Numeric).returns(::PDF::Reader::Point) }
+  def ctm_transform_point(pt, opt_y = T.unsafe(nil)); end
+
   def current_font; end
   def end_text_object; end
   def find_color_space(label); end
@@ -1272,8 +1312,13 @@ class PDF::Reader::PageState
   def set_word_spacing(word_spacing); end
   def show_text_with_positioning(params); end
   def stack_depth; end
+
+  sig { params(x: ::Numeric, y: ::Numeric).returns(T::Array[::Numeric]) }
   def trm_transform(x, y); end
 
+  sig { params(pt: T.any(::Numeric, ::PDF::Reader::Point), opt_y: ::Numeric).returns(::PDF::Reader::Point) }
+  def trm_transform_point(pt, opt_y = T.unsafe(nil)); end
+
   private
 
   def build_fonts(raw_fonts); end
@@ -1288,9 +1333,14 @@ PDF::Reader::PageState::DEFAULT_GRAPHICS_STATE = T.let(T.unsafe(nil), Hash)
 class PDF::Reader::PageTextReceiver
   extend ::Forwardable
 
+  def begin_marked_content_with_pl(tag, properties); end
   def begin_text_object(*args, **_arg1, &block); end
   def concatenate_matrix(*args, **_arg1, &block); end
+
+  sig { returns(::String) }
   def content; end
+
+  def end_marked_content; end
   def end_text_object(*args, **_arg1, &block); end
   def font_size(*args, **_arg1, &block); end
   def invoke_xobject(label); end
@@ -1323,9 +1373,15 @@ class PDF::Reader::PageTextReceiver
 
   private
 
-  def apply_rotation(x, y); end
+  sig { params(pt: ::PDF::Reader::Point).returns(::PDF::Reader::Point) }
+  def apply_rotation(pt); end
+
   def group_chars_into_runs(chars); end
+
+  sig { params(string: ::String).void }
   def internal_show_text(string); end
+
+  sig { params(runs: T::Array[::PDF::Reader::TextRun]).returns(T::Array[::PDF::Reader::TextRun]) }
   def merge_runs(runs); end
 end
 
@@ -1334,8 +1390,15 @@ class PDF::Reader::PagesStrategy; end
 PDF::Reader::PagesStrategy::OPERATORS = T.let(T.unsafe(nil), Hash)
 
 class PDF::Reader::Parser
-  sig { params(buffer: ::PDF::Reader::Buffer, objects: T.nilable(::PDF::Reader::ObjectHash)).void }
-  def initialize(buffer, objects = T.unsafe(nil)); end
+  sig do
+    params(
+      buffer: ::PDF::Reader::Buffer,
+      operators: T::Hash[T.any(::PDF::Reader::Token, ::String), ::Symbol],
+      objects: T.nilable(::PDF::Reader::ObjectHash),
+      relaxed_dictionaries: T::Boolean
+    ).void
+  end
+  def initialize(buffer, operators: T.unsafe(nil), objects: T.unsafe(nil), relaxed_dictionaries: T.unsafe(nil)); end
 
   sig do
     params(
@@ -1346,11 +1409,9 @@ class PDF::Reader::Parser
   def object(id, gen); end
 
   sig do
-    params(
-      operators: T::Hash[T.any(::PDF::Reader::Token, ::String), ::Symbol]
-    ).returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
+    returns(T.nilable(T.any(::Numeric, ::PDF::Reader::Reference, ::PDF::Reader::Token, ::String, ::Symbol, T::Array[T.untyped], T::Hash[T.untyped, T.untyped])))
   end
-  def parse_token(operators = T.unsafe(nil)); end
+  def parse_token; end
 
   private
 
@@ -1363,6 +1424,9 @@ class PDF::Reader::Parser
   sig { returns(::String) }
   def hex_string; end
 
+  sig { params(str: ::String, regexp: ::Regexp).returns(T::Boolean) }
+  def match?(str, regexp); end
+
   sig { returns(::Symbol) }
   def pdf_name; end
 
@@ -1373,6 +1437,7 @@ class PDF::Reader::Parser
   def string; end
 end
 
+PDF::Reader::Parser::INTERNED_TOKENS = T.let(T.unsafe(nil), Hash)
 PDF::Reader::Parser::MAPPING = T.let(T.unsafe(nil), Hash)
 PDF::Reader::Parser::STRATEGIES = T.let(T.unsafe(nil), Hash)
 PDF::Reader::Parser::TOKEN_STRATEGY = T.let(T.unsafe(nil), Proc)
@@ -1391,6 +1456,9 @@ class PDF::Reader::Point
   def y; end
 end
 
+PDF::Reader::Point::ONE_ONE = T.let(T.unsafe(nil), PDF::Reader::Point)
+PDF::Reader::Point::ZERO_ZERO = T.let(T.unsafe(nil), PDF::Reader::Point)
+
 class PDF::Reader::PrintReceiver
   sig { params(methodname: ::Symbol, args: T.untyped).void }
   def method_missing(methodname, *args); end
@@ -1399,6 +1467,16 @@ class PDF::Reader::PrintReceiver
   def respond_to?(meth); end
 end
 
+class PDF::Reader::Rc4
+  sig { params(key: ::String).void }
+  def initialize(key); end
+
+  sig { params(data: ::String).returns(::String) }
+  def decrypt(data); end
+
+  def encrypt(*args, **_arg1, &blk); end
+end
+
 class PDF::Reader::Rc4SecurityHandler
   sig { params(key: ::String).void }
   def initialize(key); end
@@ -1426,6 +1504,9 @@ class PDF::Reader::Rectangle
   sig { params(point: ::PDF::Reader::Point).returns(T::Boolean) }
   def contains?(point); end
 
+  sig { params(x: ::Numeric, y: ::Numeric).returns(T::Boolean) }
+  def contains_xy?(x, y); end
+
   sig { returns(::Numeric) }
   def height; end
 
@@ -1743,6 +1824,9 @@ class PDF::Reader::TransformationMatrix
   end
   def multiply!(a, b, c, d, e, f); end
 
+  sig { params(tx: ::Numeric, ty: ::Numeric).void }
+  def prepend_translation!(tx, ty); end
+
   sig { returns([::Numeric]) }
   def to_a; end
 
@@ -1781,7 +1865,7 @@ class PDF::Reader::TypeCheck
     sig { params(string: T.untyped).returns(::String) }
     def cast_to_string!(string); end
 
-    sig { params(obj: T.untyped).returns(::Symbol) }
+    sig { params(obj: T.untyped).returns(T.nilable(::Symbol)) }
     def cast_to_symbol(obj); end
 
     sig { params(obj: T.untyped).returns(::Symbol) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdf-reader
 version: !ruby/object:Gem::Version
-  version: 2.15.1
+  version: 2.16.0
 platform: ruby
 authors:
 - James Healy
@@ -119,20 +119,6 @@ dependencies:
     - - "!="
       - !ruby/object:Gem::Version
         version: 2.0.0
-- !ruby/object:Gem::Dependency
-  name: ruby-rc4
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: hashery
   requirement: !ruby/object:Gem::Requirement
@@ -240,6 +226,7 @@ files:
 - lib/pdf/reader/cid_widths.rb
 - lib/pdf/reader/cmap.rb
 - lib/pdf/reader/encoding.rb
+- lib/pdf/reader/encoding_utils.rb
 - lib/pdf/reader/encodings/mac_expert.txt
 - lib/pdf/reader/encodings/mac_roman.txt
 - lib/pdf/reader/encodings/pdf_doc.txt
@@ -278,6 +265,7 @@ files:
 - lib/pdf/reader/parser.rb
 - lib/pdf/reader/point.rb
 - lib/pdf/reader/print_receiver.rb
+- lib/pdf/reader/rc4.rb
 - lib/pdf/reader/rc4_security_handler.rb
 - lib/pdf/reader/rectangle.rb
 - lib/pdf/reader/reference.rb
@@ -307,9 +295,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/yob/pdf-reader/issues
-  changelog_uri: https://github.com/yob/pdf-reader/blob/v2.15.1/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.15.1
-  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.15.1
+  changelog_uri: https://github.com/yob/pdf-reader/blob/v2.16.0/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/pdf-reader/2.16.0
+  source_code_uri: https://github.com/yob/pdf-reader/tree/v2.16.0
 rdoc_options:
 - "--title"
 - PDF::Reader Documentation