pdf-reader 2.5.0 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 652d05cf6a22fad5ecb4b92de1e27ba60cafc6525c5ca524e24c7f9796fe1b83
-  data.tar.gz: 2c7448e97890a9fcbd10ec2cd5bafb9025db2fb75dabaf71a4074c542b1065a1
+  metadata.gz: 2b4616131d0ad73c4ef2c4992ae79d4fde420d6857aba60e8dfac9b088a0b915
+  data.tar.gz: f93f481d7f76af426420dbf507a88e8ecead8ec84690781f42de3b7b5ffbd1bd
 SHA512:
-  metadata.gz: ac82452924cf46af98ee15f2a20642b1d06d5b9c22104fe171b5b4612665e482f341e12473805016ccb9d921fc15324ba51675170b369adeace8b278cd1279fb
-  data.tar.gz: b1dc1c4422b0e6bf01092cf724630ba7424fdef1fdaf34f33aaa3a31397caf6ef5a73185a98e6e2828a9e082d87cbca311565397cb064cac20d86e72be27626f
+  metadata.gz: 86dbe3450a11e0deb3f5db98625375b252cc25f289d76c98b5de48342d1b4957de81c1c2b6cce53d7d09738e9576bd48213c92166d48911c1f45ad6a77f195a5
+  data.tar.gz: ee852ff644a095bae93eb7cc30c6d070c8c6adda4f9bfadecf938bf3ba2723fed08c75a3bf15ba30fcf8fded7ad6a5b74dad8a3f512823798686350f24b912eb

data/CHANGELOG

@@ -1,3 +1,45 @@
+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)
+- For sorbet users, additional type annotations are included in the gem
+
+v2.8.0 (28th Decemeber 2021)
+- Add PDF::Reader::Page#runs for extracting text from a page with positioning metadata (http://github.com/yob/pdf-reader/pull/411)
+- Add options to PDF::Reader::Page#text to make some behaviour configurable (http://github.com/yob/pdf-reader/pull/411)
+    - including extracting the text for only part of the page
+- Improve text positioning and extraction for Type3 fonts (http://github.com/yob/pdf-reader/pull/412)
+- Skip extracting text that is positioned outside the page (http://github.com/yob/pdf-reader/pull/413)
+- Fix occasional crash when reading some streams (http://github.com/yob/pdf-reader/pull/405)
+
+v2.7.0 (13th December 2021)
+- Include RBI type files in the gem
+  - Downstream users of pdf-reader who also use sorbet *should* find many parts of the API will
+    now be typed checked by sorbet
+- Fix glyph positioning in some rotation scenarios (http://github.com/yob/pdf-reader/pull/403)
+  - Improved text extraction on some rotated pages, and rotated text on normal pages
+- Add PDF::Reader::Page#rectangles (http://github.com/yob/pdf-reader/pull/402)
+  - Returns page boxes (MediaBox, etc) with rotation applied, and as PORO rather than arrays of numbers
+- Add PDF::Reader::Page#origin (http://github.com/yob/pdf-reader/pull/400)
+- Add PDF::Reader::Page#{height,width} (http://github.com/yob/pdf-reader/pull/399)
+- Overlap filter should only drop characters that overlap *and* match (http://github.com/yob/pdf-reader/pull/401)
+
+v2.6.0 (12th November 2021)
+- Text extraction improvements
+  - Improved text layout on pages with a variety of font sizes (http://github.com/yob/pdf-reader/pull/355)
+  - Fixed text positioning for some rotated pages (http://github.com/yob/pdf-reader/pull/356)
+  - Improved character width calculation for PDFs using built-in (non-embedded) ZapfDingbats (http://github.com/yob/pdf-reader/pull/373)
+  - Skip zero-width characters (http://github.com/yob/pdf-reader/pull/372)
+- Performance improvements
+  - Reduced memory pressure when decoding TIFF images (http://github.com/yob/pdf-reader/pull/360)
+  - Optional dependency on ascii81_native gem for faster processing of files using the ascii85 filter (http://github.com/yob/pdf-reader/pull/359)
+- Successfully parse more files
+  - Gracefully handle some non-spec compliant CR/LF issues (http://github.com/yob/pdf-reader/pull/364)
+  - Fix parsing of some escape sequences in content streams (http://github.com/yob/pdf-reader/pull/368)
+  - Increase the amount of junk bytes we detect and skip at the end of a file (382)
+  - Ignore "/Prev 0" in trailers (http://github.com/yob/pdf-reader/pull/383)
+  - Fix parsing of some inline images (BI ID EI tokens) (http://github.com/yob/pdf-reader/pull/389)
+  - Gracefully handle some xref tables that incorrectly start with 1 (http://github.com/yob/pdf-reader/pull/384)
+
 v2.5.0 (6th June 2021)
 - bump minimum ruby version to 2.0
 - Correctly handle trascoding to UTF-8 from some fonts that use a difference table [#344](https://github.com/yob/pdf-reader/pull/344/) 

data/README.md

@@ -166,6 +166,19 @@ http://groups.google.com/group/pdf-reader
 The easiest way to explain how this works in practice is to show some examples.
 Check out the examples/ directory for a few files.
 
+# Alternate Decoder
+
+For PDF files containing Ascii85 streams, the [ascii85_native](https://github.com/AnomalousBit/ascii85_native) gem can be used for increased performance. If the ascii85_native gem is detected, pdf-reader will automatically use the gem.
+
+First, run `gem install ascii85_native` and then require the gem alongside pdf-reader:
+
+```ruby
+require "pdf-reader"
+require "ascii85_native"
+```
+
+Another way of enabling native Ascii85 decoding is to place `gem 'ascii85_native'` in your project's `Gemfile`.
+
 # Known Limitations
 
 Occasionally some text cannot be extracted properly due to the way it has been
@@ -176,7 +189,9 @@ little UTF-8 friendly box to indicate an unrecognisable character.
 
 * PDF::Reader Code Repository: http://github.com/yob/pdf-reader
 
-* PDF Specification: http://www.adobe.com/devnet/pdf/pdf_reference.html
+* PDF Specification: https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/PDF32000_2008.pdf
+
+* Adobe PDF Developer Resources: http://www.adobe.com/devnet/pdf/pdf_reference.html
 
 * PDF Tutorial Slide Presentations: https://web.archive.org/web/20150110042057/http://home.comcast.net/~jk05/presentations/PDFTutorials.html
 

data/Rakefile

@@ -14,7 +14,7 @@ desc "Run cane to check quality metrics"
 Cane::RakeTask.new(:quality) do |cane|
   cane.abc_max = 20
   cane.style_measure = 100
-  cane.max_violations = 31
+  cane.max_violations = 28
 
   cane.use Morecane::EncodingCheck, :encoding_glob => "{app,lib,spec}/**/*.rb"
 end

data/examples/extract_fonts.rb

@@ -17,8 +17,8 @@ module ExtractFonts
       return count if page.fonts.nil? || page.fonts.empty?
 
       page.fonts.each do |label, font|
-        next if complete_refs[font]
-        complete_refs[font] = true
+        next if complete_refs[label]
+        complete_refs[label] = true
 
         process_font(page, font)
 
@@ -39,7 +39,7 @@ module ExtractFonts
       when :TrueType, :CIDFontType2 then
         ExtractFonts::TTF.new(page.objects, font).save("#{font[:BaseFont]}.ttf")
       else
-        $stderr.puts "unsupported font type #{font[:Subtype]}"
+        $stderr.puts "unsupported font type #{font[:Subtype]} for #{font[:BaseFont]}"
       end
     end
 
@@ -68,10 +68,15 @@ module ExtractFonts
   end
 end
 
-filename = File.expand_path(File.dirname(__FILE__)) + "/../spec/data/cairo-unicode.pdf"
+if ARGV.size == 0 # default file name
+  ARGV << File.expand_path(File.join(File.dirname(__dir__), "spec", "data", "cairo-unicode.pdf")) 
+end
+
 extractor = ExtractFonts::Extractor.new
 
-PDF::Reader.open(filename) do |reader|
-  page = reader.page(1)
-  extractor.page(page)
+ARGV.each do |arg|
+  PDF::Reader.open(arg) do |reader|
+    page = reader.page(1)
+    extractor.page(page)
+  end
 end

data/examples/rspec.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # coding: utf-8
+# typed: ignore
 
 #  Basic RSpec of a generated PDF
 #

data/lib/pdf/reader/aes_v2_security_handler.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+require 'digest/md5'
+
+class PDF::Reader
+
+  # Decrypts data using the AESV2 algorithim defined in the PDF spec. Requires
+  # a decryption key, which is usually generated by PDF::Reader::StandardKeyBuilder
+  #
+  class AesV2SecurityHandler
+
+    def initialize(key)
+      @encrypt_key = key
+    end
+
+    ##7.6.2 General Encryption Algorithm
+    #
+    # Algorithm 1: Encryption of data using the AES-128-CBC algorithm
+    #
+    # version == 4 and CFM == AESV2
+    #
+    # buf - a string to decrypt
+    # ref - a PDF::Reader::Reference for the object to decrypt
+    #
+    def decrypt( buf, ref )
+      objKey = @encrypt_key.dup
+      (0..2).each { |e| objKey << (ref.id >> e*8 & 0xFF ) }
+      (0..1).each { |e| objKey << (ref.gen >> e*8 & 0xFF ) }
+      objKey << 'sAlT'  # Algorithm 1, b)
+      length = objKey.length < 16 ? objKey.length : 16
+      cipher = OpenSSL::Cipher.new("AES-#{length << 3}-CBC")
+      cipher.decrypt
+      cipher.key = Digest::MD5.digest(objKey)[0,length]
+      cipher.iv = buf[0..15]
+      cipher.update(buf[16..-1]) + cipher.final
+    end
+
+  end
+end

data/lib/pdf/reader/aes_v3_security_handler.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+require 'digest'
+require 'openssl'
+
+class PDF::Reader
+
+  # Decrypts data using the AESV3 algorithim defined in the PDF 1.7, Extension Level 3 spec.
+  # Requires a decryption key, which is usually generated by PDF::Reader::KeyBuilderV5
+  #
+  class AesV3SecurityHandler
+
+    def initialize(key)
+      @encrypt_key = key
+      @cipher = "AES-256-CBC"
+    end
+
+    ##7.6.2 General Encryption Algorithm
+    #
+    # Algorithm 1: Encryption of data using the RC4 or AES algorithms
+    #
+    # used to decrypt RC4/AES encrypted PDF streams (buf)
+    #
+    # buf - a string to decrypt
+    # ref - a PDF::Reader::Reference for the object to decrypt
+    #
+    def decrypt( buf, ref )
+      cipher = OpenSSL::Cipher.new(@cipher)
+      cipher.decrypt
+      cipher.key = @encrypt_key.dup
+      cipher.iv = buf[0..15]
+      cipher.update(buf[16..-1]) + cipher.final
+    end
+
+  end
+end

data/lib/pdf/reader/bounding_rectangle_runs_filter.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+# typed: strict
+# frozen_string_literal: true
+
+class PDF::Reader
+
+  # Filter our text/characters that are positioned outside a rectangle. Usually the page
+  # MediaBox or CropBox, but could be a user specified rectangle too
+  class BoundingRectangleRunsFilter
+
+    def self.runs_within_rect(runs, rect)
+      runs.select { |run| rect.contains?(run.origin) }
+    end
+  end
+end
+

data/lib/pdf/reader/buffer.rb

@@ -1,4 +1,5 @@
 # coding: ASCII-8BIT
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -48,6 +49,18 @@ class PDF::Reader
     ID = "ID"
     FWD_SLASH = "/"
     NULL_BYTE = "\x00"
+    CR = "\r"
+    LF = "\n"
+    CRLF = "\r\n"
+    WHITE_SPACE = [LF, CR, ' ']
+
+    # Quite a few PDFs have trailing junk.
+    # This can be several k of nuls in some cases
+    # Allow for this here
+    TRAILING_BYTECOUNT = 5000
+
+    # must match whole tokens
+    DIGITS_ONLY = %r{\A\d+\z}
 
     attr_reader :pos
 
@@ -86,9 +99,12 @@ class PDF::Reader
     #
     # options:
     #
-    #   :skip_eol - if true, the IO stream is advanced past a CRLF or LF that
-    #               is sitting under the io cursor.
-    #
+    #   :skip_eol - if true, the IO stream is advanced past a CRLF, CR or LF
+    #               that is sitting under the io cursor.
+    #   Note:
+    #   Skipping a bare CR is not spec-compliant.
+    #   This is because the data may start with LF.
+    #   However we check for CRLF first, so the ambiguity is avoided.
     def read(bytes, opts = {})
       reset_pos
 
@@ -97,9 +113,9 @@ class PDF::Reader
         str = @io.read(2)
         if str.nil?
           return nil
-        elsif str == "\r\n"
+        elsif str == CRLF # This MUST be done before checking for CR alone
           # do nothing
-        elsif str[0,1] == "\n"
+        elsif str[0, 1] == LF || str[0, 1] == CR # LF or CR alone
           @io.seek(-1, IO::SEEK_CUR)
         else
           @io.seek(-2, IO::SEEK_CUR)
@@ -127,8 +143,10 @@ class PDF::Reader
     #
     def find_first_xref_offset
       check_size_is_non_zero
-      @io.seek(-1024, IO::SEEK_END) rescue @io.seek(0)
-      data = @io.read(1024)
+      @io.seek(-TRAILING_BYTECOUNT, IO::SEEK_END) rescue @io.seek(0)
+      data = @io.read(TRAILING_BYTECOUNT)
+
+      raise MalformedPDFError, "PDF does not contain EOF marker" if data.nil?
 
       # the PDF 1.7 spec (section #3.4) says that EOL markers can be either \r, \n, or both.
       lines = data.split(/[\n\r]+/).reverse
@@ -136,7 +154,12 @@ class PDF::Reader
 
       raise MalformedPDFError, "PDF does not contain EOF marker" if eof_index.nil?
       raise MalformedPDFError, "PDF EOF marker does not follow offset" if eof_index >= lines.size-1
-      lines[eof_index+1].to_i
+      offset = lines[eof_index+1].to_i
+
+      # a byte offset < 0 doesn't make much sense. This is unlikely to happen, but in theory some
+      # corrupted PDFs might have a line that looks like a negative int preceding the `%%EOF`
+      raise MalformedPDFError, "invalid xref offset" if offset < 0
+      offset
     end
 
     private
@@ -217,45 +240,73 @@ class PDF::Reader
       return if @tokens.size < 3
       return if @tokens[2] != "R"
 
-      if @tokens[0].match(/\d+/) && @tokens[1].match(/\d+/)
-        @tokens[0] = PDF::Reader::Reference.new(@tokens[0].to_i, @tokens[1].to_i)
-        @tokens[1] = nil
-        @tokens[2] = nil
-        @tokens.compact!
+      token_one = @tokens[0]
+      token_two = @tokens[1]
+      if token_one.is_a?(String) && token_two.is_a?(String) && token_one.match(DIGITS_ONLY) && token_two.match(DIGITS_ONLY)
+        @tokens[0] = PDF::Reader::Reference.new(token_one.to_i, token_two.to_i)
+        @tokens.delete_at(2)
+        @tokens.delete_at(1)
       end
     end
 
+    # Extract data between ID and EI
+    # If the EI follows white-space the space is dropped from the data
+    # The EI must followed by white-space or end of buffer
+    # This is to reduce the chance of accidentally matching an embedded EI
     def prepare_inline_token
-      str = "".dup
-
-      buffer = []
-
-      until buffer[0] =~ /\s|\0/ && buffer[1, 2] == ["E", "I"]
+      idstart = @io.pos
+      prevchr = ''
+      eisize = 0 # how many chars in the end marker
+      seeking = 'E' # what are we looking for now?
+      loop do
         chr = @io.read(1)
-        buffer << chr
-
-        if buffer.length > 3
-          str << buffer.shift
+        break if chr.nil?
+        case seeking
+        when 'E'
+          if chr == 'E'
+            seeking = 'I'
+            if WHITE_SPACE.include? prevchr
+              eisize = 3 # include whitespace in delimiter, i.e. drop from data
+            else # assume the EI immediately follows the data
+              eisize = 2 # leave prevchr in data
+            end
+          end
+        when 'I'
+          if chr == 'I'
+            seeking = ''
+          else
+            seeking = 'E'
+          end
+        when ''
+          if WHITE_SPACE.include? chr
+            eisize += 1 # Drop trailer
+            break
+          else
+            seeking = 'E'
+          end
         end
+        prevchr = chr.is_a?(String) ? chr : ''
       end
-
-      str << NULL_BYTE if buffer.first == NULL_BYTE
-
-      @tokens << string_token(str)
-      @io.seek(-3, IO::SEEK_CUR) unless chr.nil?
+      unless seeking == ''
+        raise MalformedPDFError, "EI terminator not found"
+      end
+      eiend = @io.pos
+      @io.seek(idstart, IO::SEEK_SET)
+      str = @io.read(eiend - eisize - idstart) # get the ID content
+      @tokens << str.freeze if str
     end
 
     # if we're currently inside a hex string, read hex nibbles until
     # we find a closing >
     #
     def prepare_hex_token
+      finished = :false
       str = "".dup
-      finished = false
 
-      while !finished
+      until finished == :true
         byte = @io.getbyte
         if byte.nil?
-          finished = true # unbalanced params
+          finished = :true # unbalanced params
         elsif (48..57).include?(byte) || (65..90).include?(byte) || (97..122).include?(byte)
           str << byte
         elsif byte <= 32
@@ -264,7 +315,7 @@ class PDF::Reader
           @tokens << str if str.size > 0
           @tokens << ">" if byte != 0x3E # '>'
           @tokens << byte.chr
-          finished = true
+          finished = :true
         end
       end
     end
@@ -311,14 +362,17 @@ class PDF::Reader
     def prepare_regular_token
       tok = "".dup
 
-      while byte = @io.getbyte
+      loop do
+        byte = @io.getbyte
+
         case byte
+        when nil
+          break
         when 0x25
           # comment, ignore everything until the next EOL char
-          done = false
-          while !done
-            byte = @io.getbyte
-            done = true if byte.nil? || byte == 0x0A || byte == 0x0D
+          loop do
+            commentbyte = @io.getbyte
+            break if commentbyte.nil? || commentbyte == 0x0A || commentbyte == 0x0D
           end
         when *TOKEN_WHITESPACE
           # white space, token finished
@@ -388,15 +442,5 @@ class PDF::Reader
       byte
     end
 
-    # for a handful of tokens we want to tell the parser how to convert them
-    # into higher level tokens. This methods adds a to_token() method
-    # to tokens that should remain as strings.
-    #
-    def string_token(token)
-      def token.to_token
-        to_s
-      end
-      token
-    end
   end
 end

data/lib/pdf/reader/cid_widths.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 #

data/lib/pdf/reader/cmap.rb

@@ -1,4 +1,5 @@
 # coding: utf-8
+# typed: true
 # frozen_string_literal: true
 
 ################################################################################
@@ -32,16 +33,17 @@ class PDF::Reader
   # extracting various useful information.
   #
   class CMap # :nodoc:
+
     CMAP_KEYWORDS = {
-      "begincodespacerange" => 1,
-      "endcodespacerange" => 1,
-      "beginbfchar" => 1,
-      "endbfchar" => 1,
-      "beginbfrange" => 1,
-      "endbfrange" => 1,
-      "begin" => 1,
-      "begincmap" => 1,
-      "def" => 1
+      "begincodespacerange" => :noop,
+      "endcodespacerange" => :noop,
+      "beginbfchar" => :noop,
+      "endbfchar" => :noop,
+      "beginbfrange" => :noop,
+      "endbfrange" => :noop,
+      "begin" => :noop,
+      "begincmap" => :noop,
+      "def" => :noop
     }
 
     attr_reader :map
@@ -51,30 +53,6 @@ class PDF::Reader
       process_data(data)
     end
 
-    def process_data(data)
-      parser = build_parser(data)
-      mode = nil
-      instructions = []
-
-      while token = parser.parse_token(CMAP_KEYWORDS)
-        if token == "beginbfchar"
-          mode = :char
-        elsif token == "endbfchar"
-          process_bfchar_instructions(instructions)
-          instructions = []
-          mode = nil
-        elsif token == "beginbfrange"
-          mode = :range
-        elsif token == "endbfrange"
-          process_bfrange_instructions(instructions)
-          instructions = []
-          mode = nil
-        elsif mode == :char || mode == :range
-          instructions << token
-        end
-      end
-    end
-
     def size
       @map.size
     end
@@ -84,13 +62,40 @@ class PDF::Reader
     # Returns an array of Integers.
     #
     def decode(c)
-      # TODO: implement the conversion
-      return c unless Integer === c
-      @map[c]
+      @map.fetch(c, [])
     end
 
     private
 
+    def process_data(data, initial_mode = :none)
+      parser = build_parser(data)
+      mode = initial_mode
+      instructions = []
+
+      while token = parser.parse_token(CMAP_KEYWORDS)
+        if token.is_a?(String) || token.is_a?(Array)
+          if token == "beginbfchar"
+            mode = :char
+          elsif token == "endbfchar"
+            process_bfchar_instructions(instructions)
+            instructions = []
+            mode = :none
+          elsif token == "beginbfrange"
+            mode = :range
+          elsif token == "endbfrange"
+            process_bfrange_instructions(instructions)
+            instructions = []
+            mode = :none
+          elsif mode == :char
+            instructions << token.to_s
+          elsif mode == :range
+            instructions << token
+          end
+        end
+      end
+    end
+
+
     def build_parser(instructions)
       buffer = Buffer.new(StringIO.new(instructions))
       Parser.new(buffer)
@@ -105,7 +110,6 @@ class PDF::Reader
     # exception when we try converting broken UTF-16 to UTF-8
     #
     def str_to_int(str)
-      return nil if str.nil? || str.size == 0
       unpacked_string = if str.bytesize == 1 # UTF-8
         str.unpack("C*")
       else # UTF-16
@@ -113,12 +117,15 @@ class PDF::Reader
       end
       result = []
       while unpacked_string.any? do
-        if unpacked_string.size >= 2 && unpacked_string[0] > 0xD800 && unpacked_string[0] < 0xDBFF
+        if unpacked_string.size >= 2 &&
+            unpacked_string.first.to_i > 0xD800 &&
+            unpacked_string.first.to_i < 0xDBFF
           # this is a Unicode UTF-16 "Surrogate Pair" see Unicode Spec. Chapter 3.7
           # lets convert to a UTF-32. (the high bit is between 0xD800-0xDBFF, the
           # low bit is between 0xDC00-0xDFFF) for example: U+1D44E (U+D835 U+DC4E)
-          points = [unpacked_string.shift, unpacked_string.shift]
-          result << (points[0] - 0xD800) * 0x400 + (points[1] - 0xDC00) + 0x10000
+          point_one = unpacked_string.shift.to_i
+          point_two = unpacked_string.shift.to_i
+          result << (point_one - 0xD800) * 0x400 + (point_two - 0xDC00) + 0x10000
         else
           result << unpacked_string.shift
         end
@@ -128,9 +135,11 @@ class PDF::Reader
 
     def process_bfchar_instructions(instructions)
       instructions.each_slice(2) do |one, two|
-        find    = str_to_int(one)
-        replace = str_to_int(two)
-        @map[find.first] = replace
+        find    = str_to_int(one.to_s)
+        replace = str_to_int(two.to_s)
+        if find.any? && replace.any?
+          @map[find.first.to_i] = replace
+        end
       end
     end
 
@@ -141,30 +150,36 @@ class PDF::Reader
         elsif start.kind_of?(String) && finish.kind_of?(String) && to.kind_of?(Array)
           bfrange_type_two(start, finish, to)
         else
-          raise "invalid bfrange section"
+          raise MalformedPDFError, "invalid bfrange section"
         end
       end
     end
 
     def bfrange_type_one(start_code, end_code, dst)
-      start_code = str_to_int(start_code)[0]
-      end_code   = str_to_int(end_code)[0]
+      start_code = str_to_int(start_code).first
+      end_code   = str_to_int(end_code).first
       dst        = str_to_int(dst)
 
+      return if start_code.nil? || end_code.nil?
+
       # add all values in the range to our mapping
       (start_code..end_code).each_with_index do |val, idx|
-        @map[val] = dst.length == 1 ? [dst[0] + idx] : [dst[0], dst[1] + 1]
+        @map[val] = dst.length == 1 ? [dst[0].to_i + idx] : [dst[0].to_i, dst[1].to_i + 1]
       end
     end
 
     def bfrange_type_two(start_code, end_code, dst)
-      start_code = str_to_int(start_code)[0]
-      end_code   = str_to_int(end_code)[0]
+      start_code = str_to_int(start_code).first
+      end_code   = str_to_int(end_code).first
+
+      return if start_code.nil? || end_code.nil?
+
       from_range = (start_code..end_code)
 
       # add all values in the range to our mapping
       from_range.each_with_index do |val, idx|
-        @map[val] = str_to_int(dst[idx])
+        dst_char = dst[idx]
+        @map[val.to_i] = str_to_int(dst_char) if dst_char
       end
     end
   end