hexapdf 0.27.0 → 0.29.0

data/test/hexapdf/digital_signature/test_signatures.rb

@@ -0,0 +1,137 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'stringio'
+require 'tempfile'
+require 'hexapdf/document'
+require_relative 'common'
+
+describe HexaPDF::DigitalSignature::Signatures do
+  before do
+    @doc = HexaPDF::Document.new
+    @form = @doc.acro_form(create: true)
+    @sig1 = @form.create_signature_field("test1")
+    @sig2 = @form.create_signature_field("test2")
+  end
+
+  it "iterates over all signature dictionaries" do
+    assert_equal([], @doc.signatures.to_a)
+    @sig1.field_value = :sig1
+    @sig2.field_value = :sig2
+    assert_equal([:sig1, :sig2], @doc.signatures.to_a)
+  end
+
+  it "returns the number of signature dictionaries" do
+    @sig1.field_value = :sig1
+    assert_equal(1, @doc.signatures.count)
+  end
+
+  describe "signing_handler" do
+    it "return the initialized handler" do
+      handler = @doc.signatures.signing_handler(certificate: 'cert', reason: 'reason')
+      assert_equal('cert', handler.certificate)
+      assert_equal('reason', handler.reason)
+    end
+
+    it "fails if the given task is not available" do
+      assert_raises(HexaPDF::Error) { @doc.signatures.signing_handler(name: :unknown) }
+    end
+  end
+
+  describe "add" do
+    before do
+      @doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+      @io = StringIO.new(''.b)
+      @handler = @doc.signatures.signing_handler(
+        certificate: CERTIFICATES.signer_certificate,
+        key: CERTIFICATES.signer_key,
+        certificate_chain: [CERTIFICATES.ca_certificate]
+      )
+    end
+
+    it "uses the provided signature dictionary" do
+      sig = @doc.add({Type: :Sig, Key: :value})
+      @doc.signatures.add(@io, @handler, signature: sig)
+      assert_equal(1, @doc.signatures.to_a.compact.size)
+      assert_equal(:value, @doc.signatures.to_a[0][:Key])
+      refute_equal(:value, @doc.acro_form.each_field.first[:Key])
+    end
+
+    it "creates the signature dictionary if none is provided" do
+      @doc.signatures.add(@io, @handler)
+      assert_equal(1, @doc.signatures.to_a.compact.size)
+      refute(@doc.acro_form.each_field.first.key?(:Contents))
+    end
+
+    it "sets the needed information on the signature dictionary" do
+      def @handler.finalize_objects(sigfield, sig)
+        sig[:key] = :sig
+        sigfield[:key] = :sig_field
+      end
+      @doc.signatures.add(@io, @handler, write_options: {update_fields: false})
+      sig = @doc.signatures.first
+      assert_equal([0, 925, 925 + sig[:Contents].size * 2 + 2, 2501], sig[:ByteRange].value)
+      assert_equal(:sig, sig[:key])
+      assert_equal(:sig_field, @doc.acro_form.each_field.first[:key])
+      assert(sig.key?(:Contents))
+    end
+
+    it "creates the main form dictionary if necessary" do
+      @doc.signatures.add(@io, @handler)
+      assert(@doc.acro_form)
+      assert_equal([:signatures_exist, :append_only], @doc.acro_form.signature_flags)
+    end
+
+    it "uses the provided signature field" do
+      field = @doc.acro_form(create: true).create_signature_field('Signature2')
+      @doc.signatures.add(@io, @handler, signature: field)
+      assert_nil(@doc.acro_form.field_by_name("Signature3"))
+      refute_nil(field.field_value)
+      assert_nil(@doc.signatures.first[:T])
+    end
+
+    it "uses an existing signature field if possible" do
+      field = @doc.acro_form(create: true).create_signature_field('Signature2')
+      field.field_value = sig = @doc.add({Type: :Sig, key: :value})
+      @doc.signatures.add(@io, @handler, signature: sig)
+      assert_nil(@doc.acro_form.field_by_name("Signature3"))
+      assert_same(sig, @doc.signatures.first)
+    end
+
+    it "creates the signature field if necessary" do
+      @doc.acro_form(create: true).create_text_field('Signature2')
+      @doc.signatures.add(@io, @handler)
+      field = @doc.acro_form.field_by_name("Signature3")
+      assert_equal(:Sig, field.field_type)
+      refute_nil(field.field_value)
+      assert_equal(1, field.each_widget.count)
+    end
+
+    it "handles different xref section types correctly when determing the offsets" do
+      @doc.delete(7)
+      sig = @doc.signatures.add(@io, @handler, write_options: {update_fields: false})
+      assert_equal([0, 1036, 1036 + sig[:Contents].size * 2 + 2, 2483], sig[:ByteRange].value)
+    end
+
+    it "works if the signature object is the last object of the xref section" do
+      field = @doc.acro_form(create: true).create_signature_field('Signature2')
+      field.create_widget(@doc.pages[0], Rect: [0, 0, 0, 0])
+      sig = @doc.signatures.add(@io, @handler, signature: field, write_options: {update_fields: false})
+      assert_equal([0, 3143, 3143 + sig[:Contents].size * 2 + 2, 380], sig[:ByteRange].value)
+    end
+
+    it "allows writing to a file in addition to writing to an IO" do
+      tempfile = Tempfile.new('hexapdf-signature')
+      tempfile.close
+      @doc.signatures.add(tempfile.path, @handler)
+      doc = HexaPDF::Document.open(tempfile.path)
+      assert(doc.signatures.first.verify(allow_self_signed: true).success?)
+    end
+
+    it "adds a new revision with the signature" do
+      @doc.signatures.add(@io, @handler)
+      signed_doc = HexaPDF::Document.new(io: @io)
+      assert(signed_doc.signatures.first.verify)
+    end
+  end
+end

data/test/hexapdf/digital_signature/test_signing.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/digital_signature'
+require_relative 'common'
+
+describe HexaPDF::DigitalSignature::Signing do
+  before do
+    @handler = HexaPDF::DigitalSignature::Signing::DefaultHandler.new(
+      certificate: CERTIFICATES.signer_certificate,
+      key: CERTIFICATES.signer_key,
+      certificate_chain: [CERTIFICATES.ca_certificate]
+    )
+  end
+
+  it "allows embedding an external signature value" do
+    # Create first signature normally for testing the signature-finding code later
+    doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+    io = StringIO.new(''.b)
+    doc.signatures.add(io, @handler)
+    doc = HexaPDF::Document.new(io: io)
+    io = StringIO.new(''.b)
+
+    byte_range = nil
+    @handler.signature_size = 5000
+    @handler.certificate = nil
+    @handler.external_signing = proc {|_, br| byte_range = br; "" }
+    doc.signatures.add(io, @handler)
+
+    io.pos = byte_range[0]
+    data = io.read(byte_range[1])
+    io.pos = byte_range[2]
+    data << io.read(byte_range[3])
+    contents = OpenSSL::PKCS7.sign(CERTIFICATES.signer_certificate, @handler.key, data,
+                                   @handler.certificate_chain,
+                                   OpenSSL::PKCS7::DETACHED | OpenSSL::PKCS7::BINARY).to_der
+    HexaPDF::DigitalSignature::Signing.embed_signature(io, contents)
+    doc = HexaPDF::Document.new(io: io)
+    assert_equal(2, doc.signatures.each.count)
+    doc.signatures.each do |signature|
+      assert(signature.verify(allow_self_signed: true).messages.find {|m| m.content == 'Signature valid' })
+    end
+  end
+
+  it "fails if the reserved signature space is too small" do
+    doc = HexaPDF::Document.new(io: StringIO.new(MINIMAL_PDF))
+    io = StringIO.new(''.b)
+    def @handler.signature_size; 200; end
+    msg = assert_raises(HexaPDF::Error) { doc.signatures.add(io, @handler) }
+    assert_match(/space.*too small.*200 vs/, msg.message)
+  end
+end

data/test/hexapdf/{type/signature → digital_signature}/test_verification_result.rb

@@ -1,26 +1,26 @@
 # -*- encoding: utf-8 -*-
 
 require 'test_helper'
-require 'hexapdf/type/signature'
+require 'hexapdf/digital_signature'
 
-describe HexaPDF::Type::Signature::VerificationResult do
+describe HexaPDF::DigitalSignature::VerificationResult do
   describe "Message" do
     it "accepts a type and a content argument on creation" do
-      m = HexaPDF::Type::Signature::VerificationResult::Message.new(:type, 'content')
+      m = HexaPDF::DigitalSignature::VerificationResult::Message.new(:type, 'content')
       assert_equal(:type, m.type)
       assert_equal('content', m.content)
     end
 
     it "allows sorting by type" do
-      info =  HexaPDF::Type::Signature::VerificationResult::Message.new(:info, 'c')
-      warning = HexaPDF::Type::Signature::VerificationResult::Message.new(:warning, 'c')
-      error = HexaPDF::Type::Signature::VerificationResult::Message.new(:error, 'c')
+      info =  HexaPDF::DigitalSignature::VerificationResult::Message.new(:info, 'c')
+      warning = HexaPDF::DigitalSignature::VerificationResult::Message.new(:warning, 'c')
+      error = HexaPDF::DigitalSignature::VerificationResult::Message.new(:error, 'c')
       assert_equal([error, warning, info], [info, error, warning].sort)
     end
   end
 
   before do
-    @result = HexaPDF::Type::Signature::VerificationResult.new
+    @result = HexaPDF::DigitalSignature::VerificationResult.new
   end
 
   it "can add new messages" do

data/test/hexapdf/document/test_pages.rb

@@ -166,7 +166,7 @@ describe HexaPDF::Document::Pages do
     it "works for a single page label entry" do
       @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}]}
       result = @doc.pages.each_labelling_range.to_a
-      assert_equal([[0, 10, {S: :r}]], result.map {|s, c, l| [s, c, l.value]})
+      assert_equal([[0, 10, {S: :r}]], result.map {|s, c, l| [s, c, l.value] })
       assert_equal(:lowercase_roman, result[0].last.numbering_style)
     end
 
@@ -174,7 +174,7 @@ describe HexaPDF::Document::Pages do
       @doc.catalog[:PageLabels] = {Nums: [0, {S: :r}, 2, {S: :d}, 7, {S: :A}]}
       result = @doc.pages.each_labelling_range.to_a
       assert_equal([[0, 2, {S: :r}], [2, 5, {S: :d}], [7, 3, {S: :A}]],
-                   result.map {|s, c, l| [s, c, l.value]})
+                   result.map {|s, c, l| [s, c, l.value] })
     end
 
     it "returns a zero or negative count for the last range if there aren't enough pages" do

data/test/hexapdf/encryption/test_aes.rb

@@ -122,7 +122,7 @@ describe HexaPDF::Encryption::AES do
       [4, 20, 40].each do |length|
         assert_raises(HexaPDF::EncryptionError) do
           collector(@algorithm_class.decryption_fiber('some' * 4,
-                                                                 Fiber.new { 'a' * length }))
+                                                      Fiber.new { 'a' * length }))
         end
       end
     end

data/test/hexapdf/filter/test_predictor.rb

@@ -4,7 +4,6 @@ require_relative 'common'
 require 'hexapdf/filter/predictor'
 
 describe HexaPDF::Filter::Predictor do
-
   module CommonPredictorTests
     def test_decoding_through_decoder_method
       @testcases.each do |name, data|

data/test/hexapdf/layout/test_box.rb

@@ -131,7 +131,8 @@ describe HexaPDF::Layout::Box do
       assert_equal([nil, box], box.split(150, 150, nil))
     end
 
-    it "can't be split if it doesn't (completely) fit as the default implementation knows nothing about the content" do
+    it "can't be split if it doesn't (completely) fit as the default implementation " \
+      "knows nothing about the content" do
       @box.style.position = :flow # make sure we would generally be splitable
       @box.fit(90, 100, nil)
       assert_equal([nil, @box], @box.split(150, 150, nil))

data/test/hexapdf/layout/test_column_box.rb

@@ -11,7 +11,7 @@ describe HexaPDF::Layout::ColumnBox do
     @text_boxes = 5.times.map do
       HexaPDF::Layout::TextBox.new(items: [inline_box] * 15, style: {position: :default})
     end
-    draw_block = lambda do |canvas, box|
+    draw_block = lambda do |canvas, _box|
       canvas.move_to(0, 0).end_path
     end
     @fixed_size_boxes = 15.times.map { HexaPDF::Layout::Box.new(width: 20, height: 10, &draw_block) }

data/test/hexapdf/layout/test_list_box.rb

@@ -222,7 +222,7 @@ describe HexaPDF::Layout::ListBox do
     end
 
     it "allows drawing custom markers" do
-      marker = lambda do |doc, list_box, index|
+      marker = lambda do |_doc, _list_box, _index|
         HexaPDF::Layout::Box.create(width: 10, height: 10) {}
       end
       box = create_box(children: @fixed_size_boxes[0, 1], item_type: marker)

data/test/hexapdf/test_dictionary_fields.rb

@@ -175,7 +175,6 @@ describe HexaPDF::DictionaryFields do
 
     it "allows conversion to a Time object from a binary string" do
       refute(@field.convert('test'.b, self))
-      refute(@field.convert('D:01211016165909+00\'64'.b, self))
 
       [
         ["D:1998", [1998, 01, 01, 00, 00, 00, "-00:00"]],
@@ -191,6 +190,8 @@ describe HexaPDF::DictionaryFields do
         ["D:1998-08'00'", [1998, 01, 01, 00, 00, 00, "-08:00"]],
         ["D:19981223195210-08", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
         ["D:19981223195210-08'00", [1998, 12, 23, 19, 52, 10, "-08:00"]], # non-standard, missing '
+        ["D:19981223195210-54'00", [1998, 12, 23, 19, 52, 10, "-23:59:59"]], # non-standard, TZ hour to large
+        ["D:19981223195210+10'65", [1998, 12, 23, 19, 52, 10, "+11:05"]], # non-standard, TZ min to large
       ].each do |str, data|
         obj = @field.convert(str, self)
         assert_equal(Time.new(*data), obj, "date str used: #{str}")

data/test/hexapdf/test_document.rb

@@ -163,14 +163,8 @@ describe HexaPDF::Document do
       refute_equal(0, obj.oid)
     end
 
-    it "fails if the given object is not a PDF object" do
-      assert_raises(ArgumentError) { @doc.import(5) }
-    end
-
-    it "fails if the given object is associated with no or the destination document" do
-      assert_raises(ArgumentError) { @doc.import(HexaPDF::Object.new(5)) }
-      obj = @doc.add(5)
-      assert_raises(ArgumentError) { @doc.import(obj) }
+    it "works if the given object is not a PDF object" do
+      assert_equal(5, @doc.import(5))
     end
   end
 
@@ -510,7 +504,7 @@ describe HexaPDF::Document do
 
     it "allows to conveniently sign a document" do
       mock = Minitest::Mock.new
-      mock.expect(:handler, :handler, name: :handler, opt: :key)
+      mock.expect(:signing_handler, :handler, name: :handler, opt: :key)
       mock.expect(:add, :added, [:io, :handler], signature: :sig, write_options: :write_options)
       @doc.instance_variable_set(:@signatures, mock)
       result = @doc.sign(:io, handler: :handler, write_options: :write_options, signature: :sig, opt: :key)

data/test/hexapdf/test_importer.rb

@@ -31,12 +31,12 @@ describe HexaPDF::Importer do
     @source.pages.add
     @source.pages.root[:Rotate] = 90
     @dest = HexaPDF::Document.new
-    @importer = HexaPDF::Importer.for(source: @source, destination: @dest)
+    @importer = HexaPDF::Importer.for(@dest)
   end
 
   describe "::for" do
     it "caches the importer" do
-      assert_same(@importer, HexaPDF::Importer.for(source: @source, destination: @dest))
+      assert_same(@importer, HexaPDF::Importer.for(@dest))
     end
   end
 
@@ -61,8 +61,14 @@ describe HexaPDF::Importer do
     end
 
     it "can import a direct object" do
-      obj = @importer.import(key: @obj)
-      assert(@dest.object?(obj[:key]))
+      assert_nil(@importer.import(nil))
+      assert_equal(5, @importer.import(5))
+      assert(@dest.object?(@importer.import({key: @obj})[:key]))
+    end
+
+    it "determines the source document dynamically" do
+      obj = @importer.import(@obj.value)
+      assert_equal("test", obj[:ref].value)
     end
 
     it "copies the data of the imported objects" do
@@ -120,10 +126,11 @@ describe HexaPDF::Importer do
       assert_equal(90, page[:Rotate])
     end
 
-    it "raise an error if the given object doesn't belong to the source document" do
+    it "works for importing objects from different documents" do
       other_doc = HexaPDF::Document.new
       other_obj = other_doc.add("test")
-      assert_raises(HexaPDF::Error) { @importer.import(other_obj) }
+      imported = @importer.import(other_obj)
+      assert_equal("test", imported.value)
     end
   end
 end

data/test/hexapdf/test_parser.rb

@@ -54,6 +54,23 @@ describe HexaPDF::Parser do
     @parser = HexaPDF::Parser.new(@parse_io, @document)
   end
 
+  describe "linearized?" do
+    it "can determine whether a document is linearized" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 0 obj\n<</Linearized 1/H [2 4]/O 1/E 1/N 1/T 1>>\nendobj")
+      assert(@parser.linearized?)
+    end
+
+    it "returns false if the first object is not a linearization dictionary" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 0 obj\n<</Length 2 0 R>>\nstream\nhallo\nendstream\nendobj")
+      refute(@parser.linearized?)
+    end
+
+    it "returns false if there is a parse error" do
+      create_parser("%PDF-1.7\n%abcdefgh\n1 a obj thing")
+      refute(@parser.linearized?)
+    end
+  end
+
   describe "parse_indirect_object" do
     it "reads indirect objects sequentially" do
       object, oid, gen, stream = @parser.parse_indirect_object

data/test/hexapdf/test_revision.rb

@@ -199,6 +199,14 @@ describe HexaPDF::Revision do
       deleted = @rev.object(6)
       @rev.delete(6)
       assert_equal([obj, @obj, deleted], @rev.each_modified_object.to_a)
+      assert_same(obj, @rev.object(3))
+    end
+
+    it "optionally deletes the modified objects from the revision" do
+      obj = @rev.object(3)
+      obj.value = :other
+      assert_equal([obj], @rev.each_modified_object(delete: true).to_a)
+      refute_same(obj, @rev.object(3))
     end
 
     it "ignores object and xref streams that were deleted" do
@@ -207,6 +215,13 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
 
+    it "handles object and xref streams that were added appropriately depending on the 'all' arg" do
+      xref = @rev.add(HexaPDF::Dictionary.new({Type: :XRef}, oid: 8))
+      objstm = @rev.add(HexaPDF::Dictionary.new({Type: :ObjStm}, oid: 9))
+      assert_equal([], @rev.each_modified_object.to_a)
+      assert_equal([xref, objstm], @rev.each_modified_object(all: true).to_a)
+    end
+
     it "doesn't return non-modified objects" do
       @rev.object(2)
       assert_equal([], @rev.each_modified_object.to_a)
@@ -230,18 +245,4 @@ describe HexaPDF::Revision do
       assert_equal([], @rev.each_modified_object.to_a)
     end
   end
-
-  describe "reset_objects" do
-    it "deletes loaded objects" do
-      @rev.object(2)
-      @rev.reset_objects
-      assert(@rev.instance_variable_get(:@objects).oids.empty?)
-    end
-
-    it "deletes added objects" do
-      @rev.add(@obj)
-      @rev.reset_objects
-      assert(@rev.instance_variable_get(:@objects).oids.empty?)
-    end
-  end
 end

data/test/hexapdf/test_revisions.rb

@@ -356,4 +356,47 @@ describe HexaPDF::Revisions do
       HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
     end
   end
+
+  it "merges the two revisions of a linearized PDF into one" do
+    io = StringIO.new(<<~EOF)
+      %PDF-1.2
+      5 0 obj
+      <</Linearized 1>>
+      endobj
+      xref
+      5 1
+      0000000009 00000 n
+      trailer
+      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 6/Prev 394>>
+      %
+      1 0 obj
+      <</ModDate(D:20221205233910+01'00')/Producer(HexaPDF version 0.27.0)>>
+      endobj
+      2 0 obj
+      <</Type/Catalog/Pages 3 0 R>>
+      endobj
+      3 0 obj
+      <</Type/Pages/Kids[4 0 R]/Count 1>>
+      endobj
+      4 0 obj
+      <</Type/Page/MediaBox[0 0 595 842]/Parent 3 0 R/Resources<<>>>>
+      endobj
+      xref
+      0 5
+      0000000000 65535 f 
+      0000000133 00000 n 
+      0000000219 00000 n 
+      0000000264 00000 n 
+      0000000315 00000 n 
+      trailer
+      <</ID[(a)(b)]/Info 1 0 R/Root 2 0 R/Size 5>>
+      startxref
+      41
+      %%EOF
+    EOF
+    doc = HexaPDF::Document.new(io: io, config: {'parser.try_xref_reconstruction' => false})
+    assert(doc.revisions.parser.linearized?)
+    assert_equal(1, doc.revisions.count)
+    assert_same(5, doc.revisions.current.xref_section.max_oid)
+  end
 end

data/test/hexapdf/test_stream.rb

@@ -142,7 +142,7 @@ describe HexaPDF::Stream do
   def encoded_data(str, encoders = [])
     map = @document.config['filter.map']
     tmp = feeder(str)
-    encoders.each {|e| tmp = ::Object.const_get(map[e]).encoder(tmp) }
+    encoders.each {|e| tmp = Object.const_get(map[e]).encoder(tmp) }
     collector(tmp)
   end
 

data/test/hexapdf/test_tokenizer.rb

@@ -14,15 +14,14 @@ describe HexaPDF::Tokenizer do
 
   it "handles object references" do
     #HexaPDF::Reference.new(1, 0), HexaPDF::Reference.new(1, 2), 2, -1, 'R', 0, 0, 'R', -1, 0, 'R',
-    create_tokenizer("1 0 R +2 +15 R 2 -1 R 0 0 R -1 0 R")
+    create_tokenizer("1 0 R +2 +15 R 2 -1 R 0 0 R 0 10 R -1 0 R")
     assert_equal(HexaPDF::Reference.new(1, 0), @tokenizer.next_token)
     assert_equal(HexaPDF::Reference.new(2, 15), @tokenizer.next_token)
     assert_equal(2, @tokenizer.next_token)
     assert_equal(-1, @tokenizer.next_token)
     assert_equal('R', @tokenizer.next_token)
-    assert_equal(0, @tokenizer.next_token)
-    assert_equal(0, @tokenizer.next_token)
-    assert_equal('R', @tokenizer.next_token)
+    assert_nil(@tokenizer.next_token)
+    assert_nil(@tokenizer.next_token)
     assert_equal(-1, @tokenizer.next_token)
     assert_equal(0, @tokenizer.next_token)
     assert_equal('R', @tokenizer.next_token)

data/test/hexapdf/test_writer.rb

@@ -40,7 +40,7 @@ describe HexaPDF::Writer do
       219
       %%EOF
       3 0 obj
-      <</Producer(HexaPDF version 0.27.0)>>
+      <</Producer(HexaPDF version 0.29.0)>>
       endobj
       xref
       3 1
@@ -72,7 +72,7 @@ describe HexaPDF::Writer do
       141
       %%EOF
       6 0 obj
-      <</Producer(HexaPDF version 0.27.0)>>
+      <</Producer(HexaPDF version 0.29.0)>>
       endobj
       2 0 obj
       <</Length 10>>stream
@@ -214,7 +214,7 @@ describe HexaPDF::Writer do
       <</Type/Page/MediaBox[0 0 595 842]/Parent 2 0 R/Resources<<>>>>
       endobj
       5 0 obj
-      <</Producer(HexaPDF version 0.27.0)>>
+      <</Producer(HexaPDF version 0.29.0)>>
       endobj
       4 0 obj
       <</Root 1 0 R/Info 5 0 R/Size 6/Type/XRef/W[1 1 2]/Index[0 6]/Filter/FlateDecode/DecodeParms<</Columns 4/Predictor 12>>/Length 33>>stream