pdfrb 0.7.14 → 0.7.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29668fa0363922e98c020c762e0de36fc221ed3667407d70ab68b02bc40bf90e
-  data.tar.gz: 10e2c7a8f2f9dd8e43b464cab777ef54e921004ae8a59b89c3c29dfd3c0823db
+  metadata.gz: c59e3261ad38e5013f1adae6c5a5f48197ddfdc6226acd96e7fe09e6d7d9b3a5
+  data.tar.gz: f39fadf09d0a6b8ad2a401111c12384ac3a2fab66f7bbf8c40dc55cc174f1775
 SHA512:
-  metadata.gz: 5b2e9643a1eb44228dccaf6882139060297ebb0bfec23ba33f5e10303d4c477dd562a94b98bc0027ed049f99aac94bf56eae0cf19160cd37ed78825e32422d41
-  data.tar.gz: c43041d9ca87df1184b44897a4f5456e3b252e1a3cd604d67d2b6d6d8a1e0c4d4327c6ee01a449f1f16f7b8527098f1b73b7f0132b8aa148393f484617d161e8
+  metadata.gz: 8cc9ef29aa8e9be785306010db555dc7bdac6ddd45c6de13107bb0cf194b5c28091d13b61a321252edc39ec41500b82eb478b338aae88480eae6c51e7861416b
+  data.tar.gz: 14ed721ff08a6a3fc8a6ce8cd3ced4aa09edec502c870d008aef7a9f7374cddcedf8ab4472e3d48773773e4b8530b059ed73fd42ec1ba5988af7ae2cc98cece6

data/lib/pdfrb/document/encryption.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+require "securerandom"
+
+module Pdfrb
+  class Document
+    # Encryption facade. Exposes a clean API for encrypting a
+    # document (builds the /Encrypt dict, wires the security handler
+    # into the writer config) and for checking encryption status.
+    #
+    # Usage:
+    #   doc.encryption.encrypt!(
+    #     user_password: "reader",
+    #     owner_password: "owner",
+    #     bits: 128,
+    #     permissions: %i[print copy]
+    #   )
+    #   doc.write("encrypted.pdf")
+    class Encryption
+      PERMISSION_FLAGS = {
+        print: 1 << 2,
+        modify: 1 << 3,
+        copy: 1 << 4,
+        annotate: 1 << 5,
+        fill: 1 << 8,
+        extract: 1 << 9,
+        assemble: 1 << 10,
+        print_hq: 1 << 11,
+      }.freeze
+
+      attr_reader :document
+
+      def initialize(document)
+        @document = document
+      end
+
+      # Encrypt this document with a user + owner password.
+      #
+      # @param user_password [String] the password readers need to open.
+      # @param owner_password [String] the password that grants full
+      #   permissions (defaults to user_password).
+      # @param bits [Integer] key length: 40, 128 (AES-128), or
+      #   256 (AES-256 R6).
+      # @param permissions [Array<Symbol>] granted permissions from
+      #   PERMISSION_FLAGS keys; any not listed are denied.
+      # @return [Pdfrb::Model::Cos::Dictionary] the /Encrypt dict.
+      def encrypt!(user_password:, owner_password: nil, bits: 128,
+                   permissions: PERMISSION_FLAGS.keys)
+        case bits
+        when 256 then encrypt_v5(user_password, owner_password || user_password, permissions)
+        when 128 then encrypt_rc4(user_password, owner_password || user_password,
+                                  permissions, v: 4, r: 4, length: 128)
+        when 40 then encrypt_rc4(user_password, owner_password || user_password,
+                                 permissions, v: 2, r: 3, length: 40)
+        else
+          raise Pdfrb::EncryptionError,
+                "unsupported key length: #{bits} (use 40, 128, or 256)"
+        end
+      end
+
+      # Whether the document has an /Encrypt dict in the trailer.
+      def encrypted?
+        trailer = document.trailer
+        !trailer.nil? && !trailer[:Encrypt].nil?
+      end
+
+      # Remove /Encrypt from the trailer (decrypt use case). Returns
+      # self for chaining; use encrypted? to check the result.
+      def decrypt!
+        trailer = document.trailer
+        if trailer && trailer[:Encrypt]
+          if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+            trailer.value.delete(:Encrypt)
+          else
+            trailer.delete(:Encrypt)
+          end
+          document.config["encryption.handler"] = nil
+          document.config["encryption.password"] = nil
+        end
+        self
+      end
+
+      # Compute the /P integer: all bits set minus the denied ones.
+      def self.permission_bits(granted)
+        base = -1
+        PERMISSION_FLAGS.each do |name, bit|
+          base &= ~bit unless granted.include?(name)
+        end
+        base
+      end
+
+      private
+
+      def ensure_id!
+        id0 = Digest::MD5.hexdigest(Time.now.to_s + rand.to_s)[0, 16]
+        trailer = document.trailer
+        if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+          trailer.value[:ID] = [id0.b, id0.b]
+        else
+          trailer[:ID] = [id0.b, id0.b]
+        end
+        id0.b
+      end
+
+      # RC4-based encryption for V2/V4 (40-bit or 128-bit).
+      def encrypt_rc4(user_pw, owner_pw, permissions, v:, r:, length:)
+        p_bits = self.class.permission_bits(permissions)
+        id0 = ensure_id!
+
+        o_entry = compute_o_entry(user_pw, owner_pw, r, length)
+        key = Pdfrb::Encryption::PasswordVerification.derive_key_rc4(
+          password: user_pw, o_entry: o_entry.b, p_flags: p_bits,
+          id0: id0, revision: r, key_length_bits: length,
+          encrypt_metadata: true
+        )
+        u_entry =
+          if r == 2
+            Pdfrb::Encryption::PasswordVerification.build_u_r2(key)
+          else
+            Pdfrb::Encryption::PasswordVerification.build_u_r3plus(
+              file_key: key, id0: id0, revision: r
+            )
+          end
+
+        register({ Filter: :Standard, V: v, R: r, Length: length,
+                   P: p_bits, O: o_entry, U: u_entry },
+                 user_password: user_pw)
+      end
+
+      # AES-256 R6 encryption for V5.
+      def encrypt_v5(user_pw, owner_pw, permissions)
+        p_bits = self.class.permission_bits(permissions)
+        id0 = ensure_id!
+
+        handler = Pdfrb::Encryption::StandardSecurityHandler.for_v5(
+          user_password: user_pw, owner_password: owner_pw,
+          permissions: p_bits, id: id0
+        )
+        dict = handler.encrypt_dict
+        register({ Filter: :Standard, V: dict[:V], R: dict[:R],
+                   Length: dict[:Length], P: p_bits,
+                   O: dict[:O], U: dict[:U], UE: dict[:UE],
+                   OE: dict[:OE], Perms: dict[:Perms] },
+                 user_password: user_pw,
+                 prebuilt_handler: handler)
+      end
+
+      # Compute the /O entry per Algorithm 3 (owner password hash).
+      def compute_o_entry(user_pw, owner_pw, revision, length_bits)
+        require "digest/md5"
+        pv = Pdfrb::Encryption::PasswordVerification
+        padded = pv.pad_password(owner_pw)
+        digest = Digest::MD5.digest(padded)
+        if revision >= 3
+          50.times do
+            digest = if length_bits >= 128
+                       Digest::MD5.digest(digest[0, length_bits / 8])
+                     else
+                       Digest::MD5.digest(digest[0, 5])
+                     end
+          end
+        end
+        rc4 = Pdfrb::Encryption::RC4Impl.new(digest[0, length_bits / 8])
+        o = rc4.process(pv.pad_password(user_pw))
+        if revision >= 3
+          19.downto(1) do |i|
+            key = digest[0, length_bits / 8].bytes.map { |b| b ^ i }.pack("C*")
+            o = Pdfrb::Encryption::RC4Impl.new(key).process(o)
+          end
+        end
+        o
+      end
+
+      # Register the encrypt dict in the trailer + wire the handler.
+      def register(encrypt_hash, user_password:, prebuilt_handler: nil)
+        dict = document.add(encrypt_hash,
+                            type: Pdfrb::Model::Type::EncryptionStandard)
+        ref = Pdfrb::Model::Reference.new(dict.oid, dict.gen)
+        trailer = document.trailer
+        if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+          trailer.value[:Encrypt] = ref
+        else
+          trailer[:Encrypt] = ref
+        end
+
+        handler = prebuilt_handler || begin
+          h = Pdfrb::Encryption::StandardSecurityHandler.new(
+            { Encrypt: encrypt_hash,
+              ID: if trailer.is_a?(Pdfrb::Model::Cos::Dictionary)
+                    trailer.value[:ID]
+                  else
+                    trailer[:ID]
+                  end }
+          )
+          h.verify_user_password?(user_password)
+          h
+        end
+        document.config["encryption.handler"] = handler
+        document.config["encryption.password"] = user_password
+        dict
+      end
+    end
+  end
+end

data/lib/pdfrb/document.rb

@@ -31,6 +31,7 @@ module Pdfrb
     autoload :Info, "pdfrb/document/info"
     autoload :PageLabels, "pdfrb/document/page_labels"
     autoload :Stamps, "pdfrb/document/stamps"
+    autoload :Encryption, "pdfrb/document/encryption"
 
     def initialize(io: nil, config: {})
       Pdfrb::Model::Type.eager_load!
@@ -163,6 +164,8 @@ module Pdfrb
 
     def stamps; @stamps ||= Document::Stamps.new(self); end
 
+    def encryption; @encryption ||= Document::Encryption.new(self); end
+
     def info; @info ||= Document::Info.new(self); end
 
     def display; @display ||= Document::Display.new(self); end

data/lib/pdfrb/encryption/standard_security_handler.rb

@@ -219,7 +219,11 @@ module Pdfrb
         hash = md5.digest
 
         rc4 = RC4Impl.new(key)
-        20.times { |i| hash = rc4.process(hash, key ^ i) }
+        19.downto(1) do |i|
+          xored_key = key.bytes.map { |b| b ^ i }.pack("C*")
+          rc4 = RC4Impl.new(xored_key)
+          hash = rc4.process(hash)
+        end
 
         hash[0, 16]
       end

data/lib/pdfrb/model/type/bead.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Bead (ISO 32000-2 §12.4.3, PDF 1.1+). A single rectangular
+      # portion of a page that is part of a Thread (article). Beads
+      # form a doubly-linked list via /N (next) and /V (previous).
+      class Bead < Pdfrb::Model::Cos::Dictionary
+        arlington_object "Bead"
+
+        # /Type — optional, fixed "Bead".
+        def type
+          value[:Type]&.to_sym
+        end
+
+        # /T — optional indirect Thread this bead belongs to.
+        def thread(document = nil)
+          ref = value[:T]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+
+        # /N — required indirect next Bead.
+        def next_bead(document = nil)
+          ref = value[:N]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+
+        # /V — required indirect previous Bead.
+        def previous_bead(document = nil)
+          ref = value[:V]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+
+        # /P — required indirect Page the bead sits on.
+        def page(document = nil)
+          ref = value[:P]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+
+        # /R — required rectangle on the page.
+        def rect
+          value[:R]
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/thread.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # Thread (ISO 32000-2 §12.4.2, PDF 1.1+). Represents an
+      # article — a sequence of text blocks that flows across pages
+      # (e.g. a newspaper column that continues on a later page).
+      # Threads are listed in the Catalog's /Threads array.
+      class Thread < Pdfrb::Model::Cos::Dictionary
+        arlington_object "Thread"
+
+        # /Type — optional, fixed "Thread".
+        def type
+          value[:Type]&.to_sym
+        end
+
+        # /F — required indirect reference to the first Bead in
+        # the thread.
+        def first_bead(document = nil)
+          ref = value[:F]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+
+        # /I — optional DocInfo dict with article metadata.
+        def info(document = nil)
+          ref = value[:I]
+          return nil unless ref && document
+
+          resolved = ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+          return nil unless resolved
+
+          Pdfrb::Model::Type::Info.new(resolved.value) if resolved.value.is_a?(::Hash)
+        end
+
+        # /Metadata — optional indirect stream (PDF 2.0).
+        def metadata(document = nil)
+          ref = value[:Metadata]
+          return nil unless ref && document
+
+          ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/trap_region.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # TrapRegion (Adobe TechNote 5620 §5.34, PDF 1.3, deprecated
+      # PDF 2.0). A trapping (prepress) region on a page. Referenced
+      # from /Annots as /Subtype /Traps or from separation profiles.
+      class TrapRegion < Pdfrb::Model::Cos::Dictionary
+        arlington_object "TrapRegion"
+
+        # /TP — required name: trapping parameters version.
+        def trap_parameters
+          value[:TP]
+        end
+
+        # /TZ — optional array-of-arrays of numbers defining trap
+        # zones.
+        def trap_zones
+          value[:TZ]
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/web_capture_command.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # WebCaptureCommand (ISO 32000-1 §14.10.4, PDF 1.3, deprecated
+      # PDF 2.0). Describes a URL retrieval for the Web Capture
+      # (spider) system: what to fetch, how to fetch it, and what
+      # form data to post.
+      class WebCaptureCommand < Pdfrb::Model::Cos::Dictionary
+        arlington_object "WebCaptureCommand"
+
+        # /URL — required ASCII string to retrieve.
+        def url
+          value[:URL]
+        end
+
+        # /L — optional integer, delay before retrieval in seconds
+        # (default 1). Must be >= 1.
+        def delay_seconds
+          value[:L] || 1
+        end
+
+        # /F — optional bitmask of flags.
+        def flags
+          value[:F] || 0
+        end
+
+        # /CT — optional content type of posted data (RFC 2045).
+        def content_type
+          value[:CT] || "application/x-www-form-urlencoded"
+        end
+
+        # /S — optional WebCaptureCommandSettings dict.
+        def settings(document = nil)
+          ref = value[:S]
+          return nil unless ref && document
+
+          resolved = ref.is_a?(Pdfrb::Model::Reference) ? document.object(ref) : ref
+          return nil unless resolved
+
+          Pdfrb::Model::Type::WebCaptureCommandSettings.new(resolved.value)
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/web_capture_command_settings.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # WebCaptureCommandSettings (ISO 32000-1 §14.10.4, PDF 1.3,
+      # deprecated PDF 2.0). Browser-like settings (get/post data,
+      # cookies) for a WebCaptureCommand.
+      class WebCaptureCommandSettings < Pdfrb::Model::Cos::Dictionary
+        arlington_object "WebCaptureCommandSettings"
+
+        # /G — optional GET parameters dictionary.
+        def get_params
+          value[:G]
+        end
+
+        # /C — optional cookie parameters dictionary.
+        def cookie_params
+          value[:C]
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/web_capture_image_set.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # WebCaptureImageSet (ISO 32000-1 §14.10.3, PDF 1.3, deprecated
+      # PDF 2.0). A spider content set holding captured images. The
+      # /O array lists image XObjects; /R gives the crawl depth for
+      # each image.
+      class WebCaptureImageSet < Pdfrb::Model::Cos::Stream
+        arlington_object "WebCaptureImageSet"
+
+        # /Type — optional, fixed "SpiderContentSet".
+        def type
+          value[:Type]&.to_sym
+        end
+
+        # /S — required, fixed "SIS" (Spider Image Set).
+        def set_type
+          value[:S]&.to_sym
+        end
+
+        # /ID — required unique identifier.
+        def set_id
+          value[:ID]
+        end
+
+        # /O — required array of indirect references to images.
+        def images(document = nil)
+          refs = value[:O]
+          return [] unless refs && document
+
+          arr = refs.is_a?(Pdfrb::Model::PdfArray) ? refs.value : refs
+          arr = [arr] unless arr.is_a?(::Array)
+          arr.filter_map { |r| r.is_a?(Pdfrb::Model::Reference) ? document.object(r) : r }
+        end
+
+        # /CT — optional content type (RFC 2045).
+        def content_type
+          value[:CT]
+        end
+
+        # /TS — optional date of capture.
+        def timestamp
+          value[:TS]
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type/web_capture_page_set.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Pdfrb
+  module Model
+    module Type
+      # WebCapturePageSet (ISO 32000-1 §14.10.3, PDF 1.3, deprecated
+      # PDF 2.0). A spider content set holding captured pages. The
+      # /O array lists page objects converted from HTML.
+      class WebCapturePageSet < Pdfrb::Model::Cos::Stream
+        arlington_object "WebCapturePageSet"
+
+        # /Type — optional, fixed "SpiderContentSet".
+        def type
+          value[:Type]&.to_sym
+        end
+
+        # /S — required, fixed "SPS" (Spider Page Set).
+        def set_type
+          value[:S]&.to_sym
+        end
+
+        # /ID — required unique identifier.
+        def set_id
+          value[:ID]
+        end
+
+        # /O — required array of indirect references to pages.
+        def pages(document = nil)
+          refs = value[:O]
+          return [] unless refs && document
+
+          arr = refs.is_a?(Pdfrb::Model::PdfArray) ? refs.value : refs
+          arr = [arr] unless arr.is_a?(::Array)
+          arr.filter_map { |r| r.is_a?(Pdfrb::Model::Reference) ? document.object(r) : r }
+        end
+
+        # /CT — optional content type.
+        def content_type
+          value[:CT]
+        end
+
+        # /TS — optional date of capture.
+        def timestamp
+          value[:TS]
+        end
+      end
+
+      # WebCaptureInfo (ISO 32000-1 §14.10.2, PDF 1.3, deprecated
+      # PDF 2.0). Root dictionary for the Web Capture system, listed
+      # in the Catalog's /SpiderInfo key.
+      class WebCaptureInfo < Pdfrb::Model::Cos::Dictionary
+        arlington_object "WebCaptureInfo"
+
+        # /V — required version number (fixed 1).
+        def version
+          value[:V]
+        end
+
+        # /C — optional array of WebCaptureCommands.
+        def commands(document = nil)
+          refs = value[:C]
+          return [] unless refs && document
+
+          arr = refs.is_a?(Pdfrb::Model::PdfArray) ? refs.value : refs
+          arr = [arr] unless arr.is_a?(::Array)
+          arr.filter_map do |r|
+            resolved = r.is_a?(Pdfrb::Model::Reference) ? document.object(r) : r
+            next nil unless resolved && resolved.value.is_a?(::Hash)
+
+            Pdfrb::Model::Type::WebCaptureCommand.new(resolved.value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pdfrb/model/type.rb

@@ -371,6 +371,20 @@ module Pdfrb
 
       # User property (s14.7.5).
       autoload :UserProperty, "pdfrb/model/type/user_property"
+
+      # Threads/articles (s12.4).
+      autoload :Thread, "pdfrb/model/type/thread"
+      autoload :Bead, "pdfrb/model/type/bead"
+
+      # Web Capture / spider (s14.10, PDF 1.3, deprecated 2.0).
+      autoload :WebCaptureInfo, "pdfrb/model/type/web_capture_page_set"
+      autoload :WebCaptureCommand, "pdfrb/model/type/web_capture_command"
+      autoload :WebCaptureCommandSettings, "pdfrb/model/type/web_capture_command_settings"
+      autoload :WebCaptureImageSet, "pdfrb/model/type/web_capture_image_set"
+      autoload :WebCapturePageSet, "pdfrb/model/type/web_capture_page_set"
+
+      # Trapping (Adobe TechNote 5620).
+      autoload :TrapRegion, "pdfrb/model/type/trap_region"
     end
   end
 end

data/lib/pdfrb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pdfrb
-  VERSION = "0.7.14"
+  VERSION = "0.7.16"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pdfrb
 version: !ruby/object:Gem::Version
-  version: 0.7.14
+  version: 0.7.16
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-14 00:00:00.000000000 Z
+date: 2026-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -817,6 +817,7 @@ files:
 - lib/pdfrb/document/colors.rb
 - lib/pdfrb/document/destinations.rb
 - lib/pdfrb/document/display.rb
+- lib/pdfrb/document/encryption.rb
 - lib/pdfrb/document/files.rb
 - lib/pdfrb/document/fonts.rb
 - lib/pdfrb/document/form.rb
@@ -979,6 +980,7 @@ files:
 - lib/pdfrb/model/type/appearance_characteristics.rb
 - lib/pdfrb/model/type/appearance_generator.rb
 - lib/pdfrb/model/type/appearance_trap_net.rb
+- lib/pdfrb/model/type/bead.rb
 - lib/pdfrb/model/type/border_effect.rb
 - lib/pdfrb/model/type/border_styling.rb
 - lib/pdfrb/model/type/box_color_info.rb
@@ -1132,6 +1134,7 @@ files:
 - lib/pdfrb/model/type/text_appearance.rb
 - lib/pdfrb/model/type/text_field.rb
 - lib/pdfrb/model/type/text_markup_annotation.rb
+- lib/pdfrb/model/type/thread.rb
 - lib/pdfrb/model/type/three_d_activation.rb
 - lib/pdfrb/model/type/three_d_animation_style.rb
 - lib/pdfrb/model/type/three_d_background.rb
@@ -1153,6 +1156,7 @@ files:
 - lib/pdfrb/model/type/timespan.rb
 - lib/pdfrb/model/type/to_unicode_cmap_stream.rb
 - lib/pdfrb/model/type/transition.rb
+- lib/pdfrb/model/type/trap_region.rb
 - lib/pdfrb/model/type/underline_annotation.rb
 - lib/pdfrb/model/type/ur_transform_parameters.rb
 - lib/pdfrb/model/type/uri_dict.rb
@@ -1163,6 +1167,10 @@ files:
 - lib/pdfrb/model/type/viewport.rb
 - lib/pdfrb/model/type/vri.rb
 - lib/pdfrb/model/type/watermark_annotation.rb
+- lib/pdfrb/model/type/web_capture_command.rb
+- lib/pdfrb/model/type/web_capture_command_settings.rb
+- lib/pdfrb/model/type/web_capture_image_set.rb
+- lib/pdfrb/model/type/web_capture_page_set.rb
 - lib/pdfrb/model/type/widget_annotation.rb
 - lib/pdfrb/model/type/widget_appearance.rb
 - lib/pdfrb/model/type/xobject_form.rb