hexapdf 1.1.1 → 1.3.0

data/lib/hexapdf/document/annotations.rb

@@ -0,0 +1,173 @@
+# -*- 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-2025 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/dictionary'
+require 'hexapdf/error'
+
+module HexaPDF
+  class Document
+
+    # This class provides methods for creating and managing the annotations of a PDF file.
+    #
+    # An annotation is an object that can be added to a certain location on a page, provides a
+    # visual appearance and allows for interaction with the user via keyboard and mouse.
+    #
+    # == Usage
+    #
+    # To create an annotation either call the general #create method or a specific creation method
+    # for an annotation type. After the annotation has been created customize it using the
+    # convenience methods on the annotation object. The last step should be the call to
+    # +regenerate_appearance+ so that the appearance is generated.
+    #
+    # See: PDF2.0 s12.5
+    class Annotations
+
+      include Enumerable
+
+      # Creates a new Annotations object for the given PDF document.
+      def initialize(document)
+        @document = document
+      end
+
+      # :call-seq:
+      #   annotations.create(type, page, **options)      -> annotation
+      #
+      # Creates a new annotation object with the given +type+ and +page+ by calling the respective
+      # +create_type+ method.
+      #
+      # The +options+ are passed on the specific annotation creation method.
+      def create(type, page, *args, **options)
+        method_name = "create_#{type}"
+        unless respond_to?(method_name)
+          raise ArgumentError, "Invalid type specified"
+        end
+        send("create_#{type}", page, *args, **options)
+      end
+
+      # :call-seq:
+      #   annotations.create_line(page, start_point:, end_point:)  -> annotation
+      #
+      # Creates a line annotation from +start_point+ to +end_point+ on the given page and returns
+      # it.
+      #
+      # The line uses a black color and a width of 1pt. It can be further styled using the
+      # convenience methods on the returned annotation object.
+      #
+      # Example:
+      #
+      #   doc.annotations.create_line(doc.pages[0], start_point: [100, 100], end_point: [130, 180]).
+      #     border_style(color: "blue", width: 2).
+      #     leader_line_length(10).
+      #     regenerate_appearance
+      #
+      # See: Type::Annotations::Line
+      def create_line(page, start_point:, end_point:)
+        create_and_add_to_page(:Line, page).
+          line(*start_point, *end_point).
+          border_style(color: 0, width: 1)
+      end
+
+      # :call-seq:
+      #   annotations.create_rectangle(page, x, y, width, height)  -> annotation
+      #
+      # Creates a rectangle (called "square" in the PDF specification) annotation with the
+      # lower-left corner at (+x+, +y+) and the given +width+ and +height+.
+      #
+      # The rectangle uses a black stroke color, no interior color and a line width of 1pt by
+      # default. It can be further styled using the convenience methods on the returned annotation
+      # object.
+      #
+      # Example:
+      #
+      #   #>pdf-small
+      #   doc.annotations.create_rectangle(doc.pages[0], 20, 20, 20, 60).
+      #     regenerate_appearance
+      #
+      #   doc.annotations.create_rectangle(doc.pages[0], 60, 20, 20, 60).
+      #     border_style(color: "hp-blue", width: 2).
+      #     interior_color("hp-orange").
+      #     regenerate_appearance
+      #
+      # See: Type::Annotations::Square
+      def create_rectangle(page, x, y, w, h)
+        annot = create_and_add_to_page(:Square, page)
+        annot[:Rect] = [x, y, x + w, y + h]
+        annot.border_style(color: 0, width: 1)
+        annot
+      end
+
+      # :call-seq:
+      #   annotations.create_ellipse(page, cx, cy, a:, b:)  -> annotation
+      #
+      # Creates an ellipse (called "circle" in the PDF specification) annotation with the center
+      # point at (+cx+, +cy+), the semi-major axis +a+ and the semi-minor axis +b+.
+      #
+      # The ellipse uses a black stroke color, no interior color and a line width of 1pt by
+      # default. It can be further styled using the convenience methods on the returned annotation
+      # object.
+      #
+      # Example:
+      #
+      #   #>pdf-small
+      #   doc.annotations.create_ellipse(doc.pages[0], 30, 50, a: 15, b: 20).
+      #     regenerate_appearance
+      #
+      #   doc.annotations.create_ellipse(doc.pages[0], 70, 50, a: 15, b: 20).
+      #     border_style(color: "hp-blue", width: 2).
+      #     interior_color("hp-orange").
+      #     regenerate_appearance
+      #
+      # See: Type::Annotations::Circle
+      def create_ellipse(page, x, y, a:, b:)
+        annot = create_and_add_to_page(:Circle, page)
+        annot[:Rect] = [x - a, y - b, x + a, y + b]
+        annot.border_style(color: 0, width: 1)
+        annot
+      end
+
+      private
+
+      # Returns the root of the destinations name tree.
+      def create_and_add_to_page(subtype, page)
+        annot = @document.add({Type: :Annot, Subtype: subtype})
+        (page[:Annots] ||= []) << annot
+        annot
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/document/layout.rb

@@ -218,6 +218,19 @@ module HexaPDF
         style
       end
 
+      # Returns +true+ if a style with the given +name+ exists, else +false+.
+      #
+      # Example:
+      #
+      #   layout.style(:header, font: 'Helvetica')
+      #   layout.style?(:header)     # => true
+      #   layout.style?(:paragraph)  # => false
+      #
+      # See: #style
+      def style?(name)
+        @styles.key?(name)
+      end
+
       # :call-seq:
       #    layout.styles            -> styles
       #    layout.styles(**mapping)   -> styles
@@ -286,8 +299,9 @@ module HexaPDF
             box_options[:children] = ChildrenCollector.collect(self, &block)
           end
         end
+        style = retrieve_style(style)
         box_class_for_name(name).new(width: width, height: height,
-                                     style: retrieve_style(style), **box_options, &box_block)
+                                     style: style, **style.box_options, **box_options, &box_block)
       end
 
       # Creates an array of HexaPDF::Layout::TextFragment objects for the given +text+.
@@ -354,7 +368,7 @@ module HexaPDF
         box_style = (box_style ? retrieve_style(box_style) : style)
         box_class_for_name(:text).new(items: text_fragments(text, style: style),
                                       width: width, height: height, properties: properties,
-                                      style: box_style)
+                                      style: box_style, **box_style.box_options)
       end
       alias text text_box
 
@@ -457,7 +471,8 @@ module HexaPDF
           end
         end
         box_class_for_name(:text).new(items: data, width: width, height: height,
-                                      properties: properties, style: box_style)
+                                      properties: properties, style: box_style,
+                                      **box_style.box_options)
       end
       alias formatted_text formatted_text_box
 
@@ -479,7 +494,7 @@ module HexaPDF
         style = retrieve_style(style, style_properties)
         image = file.kind_of?(HexaPDF::Stream) ? file : @document.images.add(file)
         box_class_for_name(:image).new(image: image, width: width, height: height,
-                                       properties: properties, style: style)
+                                       properties: properties, style: style, **style.box_options)
       end
       alias image image_box
 
@@ -608,7 +623,8 @@ module HexaPDF
         end
         box_class_for_name(:table).new(cells: cells, column_widths: column_widths, header: header,
                                        footer: footer, cell_style: cell_style, width: width,
-                                       height: height, properties: properties, style: style)
+                                       height: height, properties: properties, style: style,
+                                       **style.box_options)
       end
       alias table table_box
 
@@ -666,6 +682,22 @@ module HexaPDF
         end
       end
 
+      FONT_BOLD_VARIANT_MAPPER = { #:nodoc:
+        nil => {true => :bold, false: :none},
+        none: {true => :bold, false: :none},
+        bold: {true => :bold, false: :none},
+        italic: {true => :bold_italic, false: :italic},
+        bold_italic: {true => :bold_italic, false: :italic},
+      }
+
+      FONT_ITALIC_VARIANT_MAPPER = { #:nodoc:
+        nil => {true => :italic, false: :none},
+        none: {true => :italic, false: :none},
+        italic: {true => :italic, false: :none},
+        bold: {true => :bold_italic, false: :bold},
+        bold_italic: {true => :bold_italic, false: :bold},
+      }
+
       # Retrieves the appropriate HexaPDF::Layout::Style object based on the +style+ and
       # +properties+ arguments.
       #
@@ -690,7 +722,14 @@ module HexaPDF
         end
         unless style.font.respond_to?(:pdf_object)
           name, options = *style.font
-          style.font(@document.fonts.add(name, **(options || {})))
+          options ||= {}
+          if style.font_bold?
+            options[:variant] = FONT_BOLD_VARIANT_MAPPER.dig(options[:variant], style.font_bold)
+          end
+          if style.font_italic?
+            options[:variant] = FONT_ITALIC_VARIANT_MAPPER.dig(options[:variant], style.font_italic)
+          end
+          style.font(@document.fonts.add(name, **options))
         end
         style
       end

data/lib/hexapdf/document.rb

@@ -123,6 +123,7 @@ module HexaPDF
     autoload(:Destinations, 'hexapdf/document/destinations')
     autoload(:Layout, 'hexapdf/document/layout')
     autoload(:Metadata, 'hexapdf/document/metadata')
+    autoload(:Annotations, 'hexapdf/document/annotations')
 
     # :call-seq:
     #   Document.open(filename, **docargs)                   -> doc
@@ -539,6 +540,12 @@ module HexaPDF
       @destinations ||= Destinations.new(self)
     end
 
+    # Returns the Annotations object that provides convenience methods for working with annotation
+    # objects.
+    def annotations
+      @annotations ||= Annotations.new(self)
+    end
+
     # Returns the Layout object that provides convenience methods for working with the
     # HexaPDF::Layout classes for document layout.
     def layout
@@ -726,8 +733,8 @@ module HexaPDF
     end
 
     # :call-seq:
-    #   doc.write(filename, incremental: false, validate: true, update_fields: true, optimize: false) -> [start_xref, section]
-    #   doc.write(io, incremental: false, validate: true, update_fields: true, optimize: false) -> [start_xref, section]
+    #   doc.write(filename, incremental: false, validate: true, update_fields: true, optimize: false, compact: true) -> [start_xref, section]
+    #   doc.write(io, incremental: false, validate: true, update_fields: true, optimize: false, compact: true) -> [start_xref, section]
     #
     # Writes the document to the given file (in case +io+ is a String) or IO stream. Returns the
     # file position of the start of the last cross-reference section and the last XRefSection object
@@ -755,7 +762,20 @@ module HexaPDF
     # optimize::
     #   Optimize the file size by using object and cross-reference streams. This will raise the PDF
     #   version to at least 1.5.
-    def write(file_or_io, incremental: false, validate: true, update_fields: true, optimize: false)
+    #
+    # compact::
+    #   Compact the document by reducing it to a single revision and removing null and unused
+    #   objects.
+    #
+    #   The initial revision of a document has to contain objects with continuous numbering. If some
+    #   object numbers refer to free entries, other PDF libraries/viewers might not work
+    #   correctly. So continuous object numbers are assigned to stay compliant with the
+    #   specification.
+    #
+    #   Only change this argument to +false+ if you run the optimization task with 'compact: true'
+    #   beforehand or if you know exactly what you do and what not compacting implies.
+    def write(file_or_io, incremental: false, validate: true, update_fields: true, optimize: false,
+              compact: true)
       if update_fields
         trailer.update_id
         if @metadata
@@ -774,10 +794,11 @@ module HexaPDF
         end
       end
 
-      if optimize
-        task(:optimize, object_streams: :generate)
-        self.version = '1.5' if version < '1.5'
-      end
+      optimize_opts = {}
+      optimize_opts[:object_streams] = :generate if optimize
+      optimize_opts[:compact] = true if compact && !incremental
+      task(:optimize, **optimize_opts) unless optimize_opts.empty?
+      self.version = '1.5' if version < '1.5' if optimize
 
       dispatch_message(:before_write)
 

data/lib/hexapdf/error.rb

@@ -94,9 +94,17 @@ module HexaPDF
     end
 
     def message # :nodoc:
-      "No glyph for #{glyph.str.inspect} in font '#{glyph.font_wrapper.wrapped_font.full_name}' " \
-        "found. \n\n" \
-        "Use the configuration option 'font.on_missing_glyph' to customize missing glyph handling."
+      str = "No glyph for #{glyph.str.inspect} in font '#{glyph.font_wrapper.wrapped_font.full_name}' " \
+            "found. \n\n"
+      str << if glyph.font_wrapper.font_type == :Type1
+               "The used Type1 font only contains a very limited number of glyphs. TrueType " \
+               "fonts usually provide a much wider array of glyphs. Use the configuration option " \
+               "'font.map' to register appropriate font files. Also have a look at the " \
+               "'font.default' and 'font.fallback' options. "
+             else
+               "Maybe register another #{glyph.font_wrapper.font_type} font that contains the " \
+               "needed glyph and use it as fallback via the configuration option 'font.fallback'."
+             end
     end
 
   end

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

@@ -63,6 +63,16 @@ 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
 
@@ -107,7 +117,7 @@ module HexaPDF
           locations = []
 
           @glyph_map.each_key do |old_gid|
-            glyph = orig_glyf[old_gid]
+            glyph = orig_glyf[old_gid.kind_of?(Symbol) ? 0 : old_gid]
             locations << table.size
             data = glyph.raw_data
             if glyph.compound?
@@ -166,7 +176,10 @@ module HexaPDF
         # Adds the components of compound glyphs to the subset.
         def add_glyph_components
           glyf = @font[:glyf]
-          @glyph_map.keys.each {|gid| glyf[gid].components&.each {|cgid| use_glyph(cgid) } }
+          @glyph_map.keys.each do |gid|
+            next if gid.kind_of?(Symbol)
+            glyf[gid].components&.each {|cgid| use_glyph(cgid) }
+          end
         end
 
       end

data/lib/hexapdf/font/true_type_wrapper.rb

@@ -299,6 +299,7 @@ module HexaPDF
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do
+          next if dict.null?
           update_font_name(dict)
           embed_font(dict, document)
           complete_width_information(dict)

data/lib/hexapdf/font/type1_wrapper.rb

@@ -270,6 +270,7 @@ module HexaPDF
         dict.font_wrapper = self
 
         document.register_listener(:complete_objects) do
+          next if dict.null?
           min, max = @encoding.code_to_name.keys.minmax
           dict[:FirstChar] = min
           dict[:LastChar] = max

data/lib/hexapdf/layout/style.rb

@@ -603,11 +603,36 @@ module HexaPDF
       #   style.update(**properties)    -> style
       #
       # Updates the style's properties using the key-value pairs specified by the +properties+ hash.
+      #
+      # Also see: #merge
       def update(**properties)
         properties.each {|key, value| send(key, value) }
         self
       end
 
+      # Yields all set properties.
+      def each_property # :yield: property, value
+        return to_enum(__method__) unless block_given?
+        instance_variables.each do |iv|
+          (val = PROPERTIES[iv]) && yield(val, instance_variable_get(iv))
+        end
+      end
+
+      # :call-seq:
+      #   style.merge(other_style)   -> style
+      #
+      # Merges the set properties of the +other_style+ object into this one.
+      #
+      # Note that merging is done on a per-property basis. So if a complex property is set on
+      # +other_style+ and also on +self+, the +other_style+ value completely overwrites the one from
+      # +self+.
+      #
+      # Also see: #update
+      def merge(other)
+        other.each_property {|property, value| send(property, value) }
+        self
+      end
+
       ##
       # :method: font
       # :call-seq:
@@ -615,8 +640,9 @@ module HexaPDF
       #
       # The font to be used, must be set to a valid font wrapper object before it can be used.
       #
-      # HexaPDF::Composer handles this property specially in that it resolves a set string or array
-      # to a font wrapper object before doing anything else with the style object.
+      # HexaPDF::Document::Layout handles this property - together with #font_bold and #font_italic
+      # - specially in that it resolves a set string or array to a font wrapper object before doing
+      # anything else with the style object.
       #
       # This is the only style property without a default value!
       #
@@ -633,6 +659,48 @@ module HexaPDF
       #   composer.text("Courier Bold", font: "Courier bold")
       #   composer.text("Courier Bold also", font: ["Courier", variant: :bold])
 
+      ##
+      # :method: font_bold
+      # :call-seq:
+      #   font_bold(bold = false)
+      #
+      # Specifies whether the bold variant of the font is used.
+      #
+      # Note that this property only has affect if #font is not already set to a font wrapper
+      # object and if it is set explicitly (i.e. #font_bold? returns +true+).
+      #
+      # See #font, #font_italic
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.text("Helvetica bold", font: "Helvetica", font_bold: true)
+      #
+      #   helvetica_bold = composer.document.fonts.add("Helvetica", variant: :bold)
+      #   composer.text("Helvetica bold", font: helvetica_bold, font_bold: false)
+      #   composer.text("Helvetica", font: ["Helvetica", {variant: :bold}], font_bold: false)
+
+      ##
+      # :method: font_italic
+      # :call-seq:
+      #   font_italic(bold = false)
+      #
+      # Specifies whether the italic variant of the font is used.
+      #
+      # Note that this property only has affect if #font is not already set to a font wrapper
+      # object and if it is set explicitly (i.e. #font_italic? returns +true+).
+      #
+      # See #font, #font_bold.
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.text("Helvetica italic", font: "Helvetica", font_italic: true)
+      #
+      #   helvetica_bold = composer.document.fonts.add("Helvetica", variant: :italic)
+      #   composer.text("Helvetica italic", font: helvetica_bold, font_italic: false)
+      #   composer.text("Helvetica", font: ["Helvetica", {variant: :italic}], font_italic: false)
+
       ##
       # :method: font_size
       # :call-seq:
@@ -1021,7 +1089,7 @@ module HexaPDF
       #
       # This method can set the line spacing in two ways:
       #
-      # * Using two positional arguments +type+ and +value+.
+      # * Using the positional, mandatory argument +type+ and the optional +value+.
       # * Or a hash with the keys +type+ and +value+.
       #
       # Note that the last line has no additional spacing after it by default. Set #last_line_gap
@@ -1422,8 +1490,33 @@ module HexaPDF
       #   composer.text("This is some longer text that does not appear in two lines.",
       #                 height: 15, overflow: :truncate)
 
-      [
+      ##
+      # :method: box_options
+      # :call-seq:
+      #   box_options(**options)
+      #
+      # Contains initialization arguments for the box instance that is created with this
+      # style. Together with the other style properties this allows the complete specification of a
+      # box instance just via a Style instance.
+      #
+      # Note that this property is only used by the HexaPDF::Document::Layout methods when a box
+      # instance is created. If a box instance is created directly, this property has no effect.
+      #
+      # Examples:
+      #
+      #   #>pdf-composer100
+      #   composer.style(:my_list, box_options: {marker_type: :decimal, item_spacing: 15})
+      #   composer.list(style: :my_list) do |list|
+      #     list.text("This is some text.")
+      #     list.text("This is some other text.")
+      #   end
+
+
+      # :nodoc:
+      PROPERTIES = [
         [:font, "raise HexaPDF::Error, 'No font set'"],
+        [:font_bold, false],
+        [:font_italic, false],
         [:font_size, 10],
         [:line_height, nil],
         [:character_spacing, 0],
@@ -1457,8 +1550,8 @@ module HexaPDF
         [:text_valign, :top, {valid_values: [:top, :center, :bottom]}],
         [:text_indent, 0],
         [:line_spacing, "LineSpacing.new(type: :single)",
-         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) || value.kind_of?(Numeric) ? " \
-           "{type: value, value: extra_arg} : value))",
+         {setter: "LineSpacing.new(**(value.kind_of?(Symbol) || value.kind_of?(Numeric) || " \
+           "value.kind_of?(LineSpacing) ? {type: value, value: extra_arg} : value))",
           extra_args: ", extra_arg = nil"}],
         [:last_line_gap, false, {valid_values: [true, false]}],
         [:fill_horizontal, nil],
@@ -1475,6 +1568,7 @@ module HexaPDF
         [:mask_mode, :default, {valid_values: [:default, :none, :box, :fill_horizontal,
                                                :fill_frame_horizontal, :fill_vertical, :fill]}],
         [:overflow, :error],
+        [:box_options, {}],
       ].each do |name, default, options = {}|
         default = default.inspect unless default.kind_of?(String)
         setter = options.delete(:setter) || "value"
@@ -1500,7 +1594,7 @@ module HexaPDF
           end
         EOF
         alias_method("#{name}=", name)
-      end
+      end.each_with_object({}) {|arr, hash| hash[:"@#{arr.first}"] = arr.first }
 
       ##
       # :method: text_segmentation_algorithm

data/lib/hexapdf/object.rb

@@ -305,8 +305,8 @@ module HexaPDF
       result
     rescue HexaPDF::Error
       raise
-    rescue StandardError
-      yield("Error: Unexpected value encountered", false, self) if block_given?
+    rescue StandardError => e
+      yield("Unexpected error encountered: #{e.message}", false, self) if block_given?
       false
     end
 

data/lib/hexapdf/pdf_array.rb

@@ -143,10 +143,32 @@ module HexaPDF
     #   array.reject! {|item| block }   -> array or nil
     #   array.reject!                   -> Enumerator
     #
-    # Deletes all elements from the array for which the block returns +true+. If no changes were
-    # done, returns +nil+.
+    # Deletes all elements from the array for which the block returns +true+ and returns +self+. If
+    # no changes were done, returns +nil+.
     def reject!
-      value.reject! {|item| yield(process_entry(item)) }
+      return to_enum(__method__) unless block_given?
+      value.reject! {|item| yield(process_entry(item)) } && self
+    end
+
+    # :call-seq:
+    #   array.map! {|item| block }   -> array
+    #   array.map!                   -> Enumerator
+    #
+    # Maps all elements from the array in-place to the respective return value of the block+ and
+    # returns +self+.
+    def map!
+      return to_enum(__method__) unless block_given?
+      value.map! {|item| yield(process_entry(item)) }
+      self
+    end
+
+    # :call-seq:
+    #   array.compact!   -> array or nil
+    #
+    # Removes all +nil+ elements from the array. Returns +self+ if any elements were removed, +nil+
+    # otherwise.
+    def compact!
+      value.compact! && self
     end
 
     # :call-seq:

data/lib/hexapdf/tokenizer.rb

@@ -278,6 +278,9 @@ module HexaPDF
 
     REFERENCE_RE = /[#{WHITESPACE}]+([+]?\d+)[#{WHITESPACE}]+R#{WHITESPACE_OR_DELIMITER_RE}/ # :nodoc:
 
+    WHITESPACE_OR_DELIMITER_LUT = [] # :nodoc:
+    (WHITESPACE + DELIMITER).each_byte {|x| WHITESPACE_OR_DELIMITER_LUT[x] = true }
+
     # Parses the number (integer or real) at the current position.
     #
     # See: PDF2.0 s7.3.3
@@ -285,7 +288,7 @@ module HexaPDF
       prepare_string_scanner(40)
       pos = self.pos
       if (tmp = @ss.scan_integer)
-        if @ss.eos? || @ss.match?(WHITESPACE_OR_DELIMITER_RE)
+        if @ss.eos? || WHITESPACE_OR_DELIMITER_LUT[@ss.peek_byte]
           # Handle object references, see PDF2.0 s7.3.10
           prepare_string_scanner(10)
           if @ss.scan(REFERENCE_RE)