hexapdf 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f05785a632fc75d280395078734af23925d219183182d8660bf08ba352cf74c
-  data.tar.gz: ee143096b0e71bbccfc0397e0cc1d01fac908f6fb4969e015b2b7c7952088af0
+  metadata.gz: 041330c9846091186ddeecd7900a7919bb96da26b3513b047f03c87888efedcd
+  data.tar.gz: ff89d47f1eeac1d2dda4982224403318528401918ccfe7f1bb775d05d8f0e6f3
 SHA512:
-  metadata.gz: e555fcfde66afe9cbff99c0643c53c79659b5a82f9abe15ac042b449b4a2258be0cea5b8f0cea28e11cd3c429211a6972e3bc45909e3cfd5f9effd8f15553c4f
-  data.tar.gz: ee7f9f8ffbf80f9171343edb49ced27ca6e89767c54cc23db7c26c51ccb34b17976005cded879132b319bea8b7e890b3840e2359c01eb12f32b69d61a65e24a1
+  metadata.gz: 508fa118a26d5825f9ae2a105cdf4717b02901fd3095c49cf5855caae7648bf60b9cea414bb6670dd3bd0c82f99b076a8df7ffb79efa60990003468d7f3a9db9
+  data.tar.gz: 613323b8b2a93a01e31ec9e35664e6dc2939b210bbe7d7c055cb861eac6cd530978b14256a55a8e51f2e3804be06808440d5816c73e808df4af3f111f325b9c9

data/CHANGELOG.md

@@ -1,3 +1,44 @@
+## 1.2.0 - 2025-02-10
+
+### Added
+
+* **Breaking change**: Argument `compact` to [HexaPDF::Document#write] to
+  automatically run the 'compact' optimization task
+* [HexaPDF::Document::Annotations], accessible via
+  [HexaPDF::Document#annotations], as convenience interface for working with
+  annotations
+* [HexaPDF::Type::Annotations::AppearanceGenerator] as central class for
+  generating appearance streams
+* [HexaPDF::Type::Annotations::Line] for line annotations
+* [HexaPDF::Type::Annotation#opacity] for setting the opacity values when
+  regenerating the appearance stream
+* [HexaPDF::Type::Annotation#contents] for setting the text of the annotation
+* Configuration option 'acro_form.text_field.on_max_len_exceeded' to allow
+  custom handling of too long values
+
+### Changed
+
+* **Breaking change**: Extracted `#border_style` and associated data class from
+  [HexaPDF::Type::Annotations::Widget] into
+  [HexaPDF::Type::Annotations::BorderStyling]
+* [HexaPDF::Type::Form#canvas] to allow getting the canvas without the initial
+  translation
+
+### Fixed
+
+* AcroForm Javascript actions to gracefully handle the special values infinity
+  and NaN
+* Type1 and TrueType font wrappers to handle the case where fonts are first
+  added and later deleted
+
+
+## 1.1.1 - 2025-01-08
+
+### Fixed
+
+* Missing require statements leading to problems loading type classes
+
+
 ## 1.1.0 - 2025-01-08
 
 ### Added

data/lib/hexapdf/cli/command.rb

@@ -35,7 +35,6 @@
 #++
 
 require 'io/console'
-require 'ostruct'
 require 'cmdparse'
 require 'hexapdf/document'
 require 'hexapdf/font/true_type'
@@ -68,21 +67,22 @@ module HexaPDF
 
       def initialize(*args, **kwargs, &block) #:nodoc:
         super
-        @out_options = OpenStruct.new
-        @out_options.compact = true
-        @out_options.compress_pages = false
-        @out_options.object_streams = :preserve
-        @out_options.xref_streams = :preserve
-        @out_options.streams = :preserve
-        @out_options.optimize_fonts = false
-        @out_options.prune_page_resources = false
-
-        @out_options.encryption = :preserve
-        @out_options.enc_user_pwd = @out_options.enc_owner_pwd = nil
-        @out_options.enc_key_length = 128
-        @out_options.enc_algorithm = :aes
-        @out_options.enc_force_v4 = false
-        @out_options.enc_permissions = []
+        @out_options = {
+          compact: true,
+          compress_pages: false,
+          object_streams: :preserve,
+          xref_streams: :preserve,
+          streams: :preserve,
+          optimize_fonts: false,
+          prune_page_resources: false,
+          encryption: :preserve,
+          enc_user_pwd: nil,
+          enc_owner_pwd: nil,
+          enc_key_length: 128,
+          enc_algorithm: :aes,
+          enc_force_v4: false,
+          enc_permissions: [],
+        }
       end
 
       protected
@@ -163,7 +163,7 @@ module HexaPDF
           if command_parser.verbosity_info?
             puts "Creating output document #{out_file}"
           end
-          doc.write(out_file, validate: false, incremental: incremental)
+          doc.write(out_file, validate: false, compact: false, incremental: incremental)
         end
       end
 
@@ -183,35 +183,35 @@ module HexaPDF
         options.separator("")
         options.separator("Optimization options:")
         options.on("--[no-]compact", "Delete unnecessary PDF objects (default: " \
-                   "#{@out_options.compact})") do |c|
-          @out_options.compact = c
+                   "#{@out_options[:compact]})") do |c|
+          @out_options[:compact] = c
         end
         options.on("--object-streams MODE", [:generate, :preserve, :delete],
                    "Handling of object streams (either generate, preserve or delete; " \
-                     "default: #{@out_options.object_streams})") do |os|
-          @out_options.object_streams = os
+                     "default: #{@out_options[:object_streams]})") do |os|
+          @out_options[:object_streams] = os
         end
         options.on("--xref-streams MODE", [:generate, :preserve, :delete],
                    "Handling of cross-reference streams (either generate, preserve or delete; " \
-                     "default: #{@out_options.xref_streams})") do |x|
-          @out_options.xref_streams = x
+                     "default: #{@out_options[:xref_streams]})") do |x|
+          @out_options[:xref_streams] = x
         end
         options.on("--streams MODE", [:compress, :preserve, :uncompress],
                    "Handling of stream data (either compress, preserve or uncompress; default: " \
-                     "#{@out_options.streams})") do |streams|
-          @out_options.streams = streams
+                     "#{@out_options[:streams]})") do |streams|
+          @out_options[:streams] = streams
         end
         options.on("--[no-]compress-pages", "Recompress page content streams (may take a long " \
-                   "time; default: #{@out_options.compress_pages})") do |c|
-          @out_options.compress_pages = c
+                   "time; default: #{@out_options[:compress_pages]})") do |c|
+          @out_options[:compress_pages] = c
         end
         options.on("--[no-]prune-page-resources", "Prunes unused objects from the page resources " \
-                   "(may take a long time; default: #{@out_options.prune_page_resources})") do |c|
-          @out_options.prune_page_resources = c
+                   "(may take a long time; default: #{@out_options[:prune_page_resources]})") do |c|
+          @out_options[:prune_page_resources] = c
         end
         options.on("--[no-]optimize-fonts", "Optimize embedded font files; " \
-                   "default: #{@out_options.optimize_fonts})") do |o|
-          @out_options.optimize_fonts = o
+                   "default: #{@out_options[:optimize_fonts]})") do |o|
+          @out_options[:optimize_fonts] = o
         end
       end
 
@@ -222,37 +222,37 @@ module HexaPDF
         options.separator("")
         options.separator("Encryption options:")
         options.on("--decrypt", "Remove any encryption") do
-          @out_options.encryption = :remove
+          @out_options[:encryption] = :remove
         end
         options.on("--encrypt", "Encrypt the output file") do
-          @out_options.encryption = :add
+          @out_options[:encryption] = :add
         end
         options.on("--owner-password PASSWORD", String, "The owner password to be set on the " \
                    "output file (use - for reading from standard input)") do |pwd|
-          @out_options.encryption = :add
-          @out_options.enc_owner_pwd = (pwd == '-' ? read_password("Owner password") : pwd)
+          @out_options[:encryption] = :add
+          @out_options[:enc_owner_pwd] = (pwd == '-' ? read_password("Owner password") : pwd)
         end
         options.on("--user-password PASSWORD", String, "The user password to be set on the " \
                    "output file (use - for reading from standard input)") do |pwd|
-          @out_options.encryption = :add
-          @out_options.enc_user_pwd = (pwd == '-' ? read_password("User password") : pwd)
+          @out_options[:encryption] = :add
+          @out_options[:enc_user_pwd] = (pwd == '-' ? read_password("User password") : pwd)
         end
         options.on("--algorithm ALGORITHM", [:aes, :arc4],
                    "The encryption algorithm: aes or arc4 (default: " \
-                     "#{@out_options.enc_algorithm})") do |a|
-          @out_options.encryption = :add
-          @out_options.enc_algorithm = a
+                     "#{@out_options[:enc_algorithm]})") do |a|
+          @out_options[:encryption] = :add
+          @out_options[:enc_algorithm] = a
         end
         options.on("--key-length BITS", Integer,
                    "The encryption key length in bits (default: " \
-                     "#{@out_options.enc_key_length})") do |i|
-          @out_options.encryption = :add
-          @out_options.enc_key_length = i
+                     "#{@out_options[:enc_key_length]})") do |i|
+          @out_options[:encryption] = :add
+          @out_options[:enc_key_length] = i
         end
         options.on("--force-V4",
                    "Force use of encryption version 4 if key length=128 and algorithm=arc4") do
-          @out_options.encryption = :add
-          @out_options.enc_force_v4 = true
+          @out_options[:encryption] = :add
+          @out_options[:enc_force_v4] = true
         end
         syms = HexaPDF::Encryption::StandardSecurityHandler::Permissions::SYMBOL_TO_PERMISSION.keys
         options.on("--permissions PERMS", Array,
@@ -264,8 +264,8 @@ module HexaPDF
             end
             perm.to_sym
           end
-          @out_options.encryption = :add
-          @out_options.enc_permissions = perms
+          @out_options[:encryption] = :add
+          @out_options[:enc_permissions] = perms
         end
       end
 
@@ -273,12 +273,12 @@ module HexaPDF
       #
       # See: #define_optimization_options
       def apply_optimization_options(doc)
-        doc.task(:optimize, compact: @out_options.compact,
-                 object_streams: @out_options.object_streams,
-                 xref_streams: @out_options.xref_streams,
-                 compress_pages: @out_options.compress_pages,
-                 prune_page_resources: @out_options.prune_page_resources)
-        if @out_options.streams != :preserve || @out_options.optimize_fonts
+        doc.task(:optimize, compact: @out_options[:compact],
+                 object_streams: @out_options[:object_streams],
+                 xref_streams: @out_options[:xref_streams],
+                 compress_pages: @out_options[:compress_pages],
+                 prune_page_resources: @out_options[:prune_page_resources])
+        if @out_options[:streams] != :preserve || @out_options[:optimize_fonts]
           doc.each do |obj|
             optimize_stream(obj)
             optimize_font(obj)
@@ -292,15 +292,15 @@ module HexaPDF
 
       # Applies the chosen stream mode to the given object.
       def optimize_stream(obj)
-        return if @out_options.streams == :preserve || !obj.respond_to?(:set_filter) ||
+        return if @out_options[:streams] == :preserve || !obj.respond_to?(:set_filter) ||
           Array(obj[:Filter]).any? {|f| IGNORED_FILTERS[f] }
 
-        obj.set_filter(@out_options.streams == :compress ? :FlateDecode : nil)
+        obj.set_filter(@out_options[:streams] == :compress ? :FlateDecode : nil)
       end
 
       # Optimize the object if it is a font object.
       def optimize_font(obj)
-        return unless @out_options.optimize_fonts && obj.kind_of?(HexaPDF::Type::Font) &&
+        return unless @out_options[:optimize_fonts] && obj.kind_of?(HexaPDF::Type::Font) &&
           (obj[:Subtype] == :TrueType ||
            (obj[:Subtype] == :Type0 && obj.descendant_font[:Subtype] == :CIDFontType2)) &&
           obj.embedded?
@@ -319,14 +319,14 @@ module HexaPDF
       #
       # See: #define_encryption_options
       def apply_encryption_options(doc)
-        case @out_options.encryption
+        case @out_options[:encryption]
         when :add
-          doc.encrypt(algorithm: @out_options.enc_algorithm,
-                      key_length: @out_options.enc_key_length,
-                      force_v4: @out_options.enc_force_v4,
-                      permissions: @out_options.enc_permissions,
-                      owner_password: @out_options.enc_owner_pwd,
-                      user_password: @out_options.enc_user_pwd)
+          doc.encrypt(algorithm: @out_options[:enc_algorithm],
+                      key_length: @out_options[:enc_key_length],
+                      force_v4: @out_options[:enc_force_v4],
+                      permissions: @out_options[:enc_permissions],
+                      owner_password: @out_options[:enc_owner_pwd],
+                      user_password: @out_options[:enc_user_pwd])
         when :remove
           doc.encrypt(name: nil)
         end

data/lib/hexapdf/cli/inspect.rb

@@ -396,7 +396,7 @@ module HexaPDF
         io = @doc.revisions.parser.io
 
         io.seek(0, IO::SEEK_END)
-        startxrefs = @doc.revisions.map {|rev| rev.trailer[:Prev] } <<
+        startxrefs = @doc.revisions.map {|rev| rev.trailer[:Prev].to_i } <<
                      @doc.revisions.parser.startxref_offset <<
                      io.pos
         startxrefs.sort!

data/lib/hexapdf/cli/modify.rb

@@ -34,7 +34,6 @@
 # commercial licenses are available at <https://gettalong.at/hexapdf/>.
 #++
 
-require 'ostruct'
 require 'hexapdf/cli/command'
 
 module HexaPDF

data/lib/hexapdf/cli/optimize.rb

@@ -53,11 +53,11 @@ module HexaPDF
         EOF
 
         @password = nil
-        @out_options.compact = true
-        @out_options.xref_streams = :generate
-        @out_options.object_streams = :generate
-        @out_options.streams = :compress
-        @out_options.optimize_fonts = true
+        @out_options[:compact] = true
+        @out_options[:xref_streams] = :generate
+        @out_options[:object_streams] = :generate
+        @out_options[:streams] = :compress
+        @out_options[:optimize_fonts] = true
 
         options.on("--password PASSWORD", "-p", String,
                    "The password for decryption. Use - for reading from standard input.") do |pwd|

data/lib/hexapdf/configuration.rb

@@ -224,6 +224,21 @@ module HexaPDF
   # acro_form.text_field.default_width::
   #    A number specifying the default width of AcroForm text fields which should be auto-sized.
   #
+  # acro_form.text_field.on_max_len_exceeded::
+  #    Callback hook when the value of a text field exceeds the set maximum length.
+  #
+  #    The value needs to be an object that responds to \#call(field, value) where +field+ is the
+  #    AcroForm text field on which the value is set and +value+ is the invalid value. The returned
+  #    value is used instead of the invalid value.
+  #
+  #    The default implementation raises an error.
+  #
+  # annotation.appearance_generator::
+  #    The class that should be used for generating appearances for annotations. If the value is a
+  #    String, it should contain the name of a constant to such a class.
+  #
+  #    See HexaPDF::Type::Annotations::AppearanceGenerator
+  #
   # debug::
   #    If set to +true+, enables debug output.
   #
@@ -502,6 +517,10 @@ module HexaPDF
                           "#{field.concrete_field_type} field named '#{field.full_field_name}'"
                       end,
                       'acro_form.text_field.default_width' => 100,
+                      'acro_form.text_field.on_max_len_exceeded' => proc do |field, value|
+                        raise HexaPDF::Error, "Value exceeds maximum allowed length of #{field[:MaxLen]}"
+                      end,
+                      'annotation.appearance_generator' => 'HexaPDF::Type::Annotations::AppearanceGenerator',
                       'debug' => false,
                       'document.auto_decrypt' => true,
                       'document.on_invalid_string' => proc do |str|
@@ -746,6 +765,7 @@ module HexaPDF
                           Text: 'HexaPDF::Type::Annotations::Text',
                           Link: 'HexaPDF::Type::Annotations::Link',
                           Widget: 'HexaPDF::Type::Annotations::Widget',
+                          Line: 'HexaPDF::Type::Annotations::Line',
                           XML: 'HexaPDF::Type::Metadata',
                           GTS_PDFX: 'HexaPDF::Type::OutputIntent',
                           GTS_PDFA1: 'HexaPDF::Type::OutputIntent',
@@ -774,6 +794,7 @@ module HexaPDF
                           Text: 'HexaPDF::Type::Annotations::Text',
                           Link: 'HexaPDF::Type::Annotations::Link',
                           Widget: 'HexaPDF::Type::Annotations::Widget',
+                          Line: 'HexaPDF::Type::Annotations::Line',
                         },
                         XXAcroFormField: {
                           Tx: 'HexaPDF::Type::AcroForm::TextField',

data/lib/hexapdf/content/graphics_state.rb

@@ -255,7 +255,7 @@ module HexaPDF
           array.inject(0) {|m, n| m < 0 ? m : (n < 0 ? -1 : m + n) } <= 0)
           raise ArgumentError, "Invalid line dash pattern: #{array.inspect} #{phase.inspect}"
         end
-        @array = array.freeze
+        @array = array
         @phase = phase
       end
 

data/lib/hexapdf/digital_signature/signing/signed_data_creator.rb

@@ -108,7 +108,7 @@ module HexaPDF
         # +type+::
         #     The type can either be :cms when creating standard PDF CMS signatures or :pades when
         #     creating PAdES compatible signatures. PAdES signatures are part of PDF 2.0.
-        def create(data, type: :cms, &block) # :yield: digested_data
+        def create(data, type: :cms, &block) # :yield: digest_algorithm, hashed_data
           signed_attrs = create_signed_attrs(data, signing_time: (type == :cms))
           signature = digest_and_sign_data(set(*signed_attrs.value).to_der, &block)
           unsigned_attrs = create_unsigned_attrs(signature)

data/lib/hexapdf/document/annotations.rb

@@ -0,0 +1,115 @@
+# -*- 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, **options)
+        method_name = "create_#{type}"
+        unless respond_to?(method_name)
+          raise ArgumentError, "Invalid type specified"
+        end
+        send("create_#{type}", page, **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
+
+      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.rb

@@ -43,6 +43,8 @@ require 'hexapdf/reference'
 require 'hexapdf/object'
 require 'hexapdf/pdf_array'
 require 'hexapdf/stream'
+require 'hexapdf/name_tree_node'
+require 'hexapdf/number_tree_node'
 require 'hexapdf/revisions'
 require 'hexapdf/type'
 require 'hexapdf/task'
@@ -121,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
@@ -537,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
@@ -724,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
@@ -753,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
@@ -772,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/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/type/acro_form/java_script_actions.rb

@@ -496,7 +496,7 @@ module HexaPDF
                    else
                      nil
                    end
-          result && (result == result.truncate ? result.to_i.to_s : result.to_s)
+          result && (result.finite? && result == result.truncate ? result.to_i.to_s : result.to_s)
         end
 
         AF_SIMPLE_CALCULATE_MAPPING = { #:nodoc:
@@ -613,7 +613,14 @@ module HexaPDF
 
         # Returns the numeric value of the string, interpreting comma as point.
         def af_make_number(value)
-          value.to_s.tr(',', '.').to_f
+          value = value.to_s
+          if value.match?(/(?:[+-])?Inf(?:inity)?/i)
+            value.start_with?('-') ? -Float::INFINITY : Float::INFINITY
+          elsif value.match?(/NaN/i)
+            Float::NAN
+          else
+            value.tr(',', '.').to_f
+          end
         end
 
         # Formats the numeric value according to the format string and separator style.

data/lib/hexapdf/type/acro_form/text_field.rb

@@ -176,7 +176,7 @@ module HexaPDF
           end
           str = str.gsub(/[[:space:]]/, ' ') if str && concrete_field_type == :single_line_text_field
           if key?(:MaxLen) && str && str.length > self[:MaxLen]
-            raise HexaPDF::Error, "Value exceeds maximum allowed length of #{self[:MaxLen]}"
+            str = @document.config['acro_form.text_field.on_max_len_exceeded'].call(self, str)
           end
           self[:V] = str
           update_widgets
@@ -348,7 +348,14 @@ module HexaPDF
             return
           end
           if (max_len = self[:MaxLen]) && field_value && field_value.length > max_len
-            yield("Text contents of field '#{full_field_name}' is too long")
+            correctable = true
+            begin
+              str = @document.config['acro_form.text_field.on_max_len_exceeded'].call(self, field_value)
+            rescue HexaPDF::Error
+              correctable = false
+            end
+            yield("Text contents of field '#{full_field_name}' is too long", correctable)
+            self.field_value = str if correctable
           end
           if comb_text_field? && !max_len
             yield("Comb text field needs a value for /MaxLen")