@pdfme/pdf-lib 0.0.0

package/__tests__/core/parser/PDFXRefStreamParser.spec.ts

@@ -0,0 +1,187 @@
+import fs from 'fs';
+import {
+  PDFContext,
+  PDFRawStream,
+  PDFXRefStreamParser,
+  ReparseError,
+} from '../../../src/index';
+
+const readData = (file: string) =>
+  new Uint8Array(fs.readFileSync(`${__dirname}/data/${file}`));
+
+describe(`PDFXRefStreamParser`, () => {
+  it(`can parse XRef streams (1)`, () => {
+    const context = PDFContext.create();
+    const dict = context.obj({
+      DecodeParms: { Columns: 4, Predictor: 12 },
+      Filter: 'FlateDecode',
+      Length: 373,
+      Size: 319,
+      W: [1, 2, 1],
+    });
+    const contents = readData('xref-stream1');
+    const stream = PDFRawStream.of(dict, contents);
+
+    const entries = PDFXRefStreamParser.forStream(stream).parseIntoContext();
+    const normal = entries.filter(
+      (entry) => !entry.deleted && !entry.inObjectStream,
+    );
+    const deleted = entries.filter((entry) => entry.deleted);
+    const inObjectStream = entries.filter((entry) => entry.inObjectStream);
+
+    expect(entries.length).toBe(319);
+    expect(normal.length).toBe(51);
+    expect(deleted.length).toBe(201);
+    expect(inObjectStream.length).toBe(67);
+  });
+
+  it(`can parse XRef streams (2)`, () => {
+    const context = PDFContext.create();
+    const dict = context.obj({
+      DecodeParms: { Columns: 4, Predictor: 12 },
+      Filter: 'FlateDecode',
+      // prettier-ignore
+      Index: [
+        1, 1,
+        16, 1,
+        18, 2,
+        25, 3,
+        30, 6,
+        50, 1,
+        78, 11,
+        90, 2,
+        95, 1,
+        119, 19,
+        139, 1,
+        141, 1,
+        143, 11,
+        156, 61,
+        219, 2,
+        223, 9,
+        243, 2,
+        246, 13,
+        282, 7,
+        290, 1,
+        308, 1,
+        319, 4,
+      ],
+      Length: 120,
+      Size: 323,
+      W: [1, 2, 1],
+    });
+    const contents = readData('xref-stream2');
+    const stream = PDFRawStream.of(dict, contents);
+
+    const entries = PDFXRefStreamParser.forStream(stream).parseIntoContext();
+    const normal = entries.filter(
+      (entry) => !entry.deleted && !entry.inObjectStream,
+    );
+    const deleted = entries.filter((entry) => entry.deleted);
+    const inObjectStream = entries.filter((entry) => entry.inObjectStream);
+
+    expect(entries.length).toBe(160);
+    expect(normal.length).toBe(32);
+    expect(deleted.length).toBe(95);
+    expect(inObjectStream.length).toBe(33);
+  });
+
+  it(`can parse XRef streams (3)`, () => {
+    const context = PDFContext.create();
+    const dict = context.obj({
+      DecodeParms: { Columns: 3, Predictor: 12 },
+      Filter: ['FlateDecode'],
+      Index: [32, 1, 291, 1, 308, 1, 323, 2],
+      Length: 31,
+      Size: 325,
+      W: [1, 2, 0],
+    });
+    const contents = readData('xref-stream3');
+    const stream = PDFRawStream.of(dict, contents);
+
+    const entries = PDFXRefStreamParser.forStream(stream).parseIntoContext();
+    const normal = entries.filter(
+      (entry) => !entry.deleted && !entry.inObjectStream,
+    );
+    const deleted = entries.filter((entry) => entry.deleted);
+    const inObjectStream = entries.filter((entry) => entry.inObjectStream);
+
+    expect(entries.length).toBe(5);
+    expect(normal.length).toBe(3);
+    expect(deleted.length).toBe(0);
+    expect(inObjectStream.length).toBe(2);
+  });
+
+  it(`can parse XRef streams (4)`, () => {
+    const context = PDFContext.create();
+    const dict = context.obj({
+      Filter: 'FlateDecode',
+      Index: [0, 146],
+      Length: 332,
+      Size: 146,
+      W: [1, 2, 2],
+    });
+    const contents = readData('xref-stream4');
+    const stream = PDFRawStream.of(dict, contents);
+
+    const entries = PDFXRefStreamParser.forStream(stream).parseIntoContext();
+    const normal = entries.filter(
+      (entry) => !entry.deleted && !entry.inObjectStream,
+    );
+    const deleted = entries.filter((entry) => entry.deleted);
+    const inObjectStream = entries.filter((entry) => entry.inObjectStream);
+
+    expect(entries.length).toBe(146);
+    expect(normal.length).toBe(30);
+    expect(deleted.length).toBe(1);
+    expect(inObjectStream.length).toBe(115);
+  });
+
+  // it(`removes objects from the PDFContext that are marked as deleted`, () => {
+  //   const context = PDFContext.create();
+  //   const dict = context.obj({
+  //     DecodeParms: { Columns: 4, Predictor: 12 },
+  //     Filter: 'FlateDecode',
+  //     Length: 373,
+  //     Size: 319,
+  //     W: [1, 2, 1],
+  //   });
+  //   const contents = readData('xref-stream1');
+  //   const stream = PDFRawStream.of(dict, contents);
+
+  //   const fooStr = PDFString.of('foo');
+  //   const fooRef = PDFRef.of(1, 1);
+  //   context.assign(fooRef, fooStr);
+
+  //   const barStr = PDFString.of('bar');
+  //   const barRef = PDFRef.of(2, 2);
+  //   context.assign(barRef, barStr);
+
+  //   expect(context.lookup(fooRef)).not.toBeUndefined();
+  //   expect(context.lookup(barRef)).not.toBeUndefined();
+
+  //   PDFXRefStreamParser.forStream(stream).parseIntoContext();
+
+  //   expect(context.lookup(fooRef)).toBeUndefined();
+  //   expect(context.lookup(barRef)).not.toBeUndefined();
+  // });
+
+  it(`prevents reparsing`, () => {
+    const context = PDFContext.create();
+    const dict = context.obj({
+      Filter: 'FlateDecode',
+      Index: [0, 146],
+      Length: 332,
+      Size: 146,
+      W: [1, 2, 2],
+    });
+    const contents = readData('xref-stream4');
+    const stream = PDFRawStream.of(dict, contents);
+
+    const parser = PDFXRefStreamParser.forStream(stream);
+
+    expect(() => parser.parseIntoContext()).not.toThrow();
+    expect(() => parser.parseIntoContext()).toThrow(
+      new ReparseError('PDFXRefStreamParser', 'parseIntoContext'),
+    );
+  });
+});

package/__tests__/core/parser/data/object-stream-invalid

@@ -0,0 +1,2 @@
+1 0
+INVALID_OBJECT

package/__tests__/core/parser/data/object-stream1

@@ -0,0 +1,16 @@
+11 0 12 66 13 130
+<<
+  /Type /Font
+  /Subtype /TrueType
+  /FontDescriptor 12 0 R
+>>
+<<
+  /Type /FontDescriptor
+  /Ascent 891
+  /FontFile2 22 0 R
+>>
+<<
+  /Type /Font
+  /Subtype /Type0
+  /ToUnicode 10 0 R
+>>

package/__tests__/core/parser/data/object-stream2

@@ -0,0 +1,10 @@
+1 0 2 16 3 33 4 40 5 59 6 66 7 71 8 81 9 85
+<< /Foo /Bar >>
+[1 (two) /Three]
+/QuxBaz
+(Look, a string!)
+21 0 R
+-.123
+<ABC123>
+true
+null

package/__tests__/core/streams/Ascii85Stream.spec.ts

@@ -0,0 +1,20 @@
+import fs from 'fs';
+
+import Ascii85Stream from '../../../src/core/streams/Ascii85Stream';
+import Stream from '../../../src/core/streams/Stream';
+
+const DIR = `${__dirname}/data/ascii85`;
+const FILES = ['1'];
+
+describe(`Ascii85Stream`, () => {
+  FILES.forEach((file) => {
+    it(`can decode ascii 85 encoded data (${file})`, () => {
+      const encoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.encoded`));
+      const decoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.decoded`));
+
+      const stream = new Ascii85Stream(new Stream(encoded));
+
+      expect(stream.decode()).toEqual(decoded);
+    });
+  });
+});

package/__tests__/core/streams/AsciiHexStream.spec.ts

@@ -0,0 +1,20 @@
+import fs from 'fs';
+
+import AsciiHexStream from '../../../src/core/streams/AsciiHexStream';
+import Stream from '../../../src/core/streams/Stream';
+
+const DIR = `${__dirname}/data/asciihex`;
+const FILES = ['1', '2'];
+
+describe(`AsciiHexStream`, () => {
+  FILES.forEach((file) => {
+    it(`can decode ascii hex encoded data (${file})`, () => {
+      const encoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.encoded`));
+      const decoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.decoded`));
+
+      const stream = new AsciiHexStream(new Stream(encoded));
+
+      expect(stream.decode()).toEqual(decoded);
+    });
+  });
+});

package/__tests__/core/streams/FlateStream.spec.ts

@@ -0,0 +1,20 @@
+import fs from 'fs';
+
+import FlateStream from '../../../src/core/streams/FlateStream';
+import Stream from '../../../src/core/streams/Stream';
+
+const DIR = `${__dirname}/data/flate`;
+const FILES = ['1', '2', '3', '4', '5', '6', '7'];
+
+describe(`FlateStream`, () => {
+  FILES.forEach((file) => {
+    it(`can decode flate encoded data (${file})`, () => {
+      const encoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.encoded`));
+      const decoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.decoded`));
+
+      const stream = new FlateStream(new Stream(encoded));
+
+      expect(stream.decode()).toEqual(decoded);
+    });
+  });
+});

package/__tests__/core/streams/LZWStream.spec.ts

@@ -0,0 +1,20 @@
+import fs from 'fs';
+
+import LZWStream from '../../../src/core/streams/LZWStream';
+import Stream from '../../../src/core/streams/Stream';
+
+const DIR = `${__dirname}/data/lzw`;
+const FILES = ['1', '2', '3', '4'];
+
+describe(`LZWStream`, () => {
+  FILES.forEach((file) => {
+    it(`can decode LZW encoded data (${file})`, () => {
+      const encoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.encoded`));
+      const decoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.decoded`));
+
+      const stream = new LZWStream(new Stream(encoded), undefined, 0);
+
+      expect(stream.decode()).toEqual(decoded);
+    });
+  });
+});

package/__tests__/core/streams/RunLengthStream.spec.ts

@@ -0,0 +1,20 @@
+import fs from 'fs';
+
+import RunLengthStream from '../../../src/core/streams/RunLengthStream';
+import Stream from '../../../src/core/streams/Stream';
+
+const DIR = `${__dirname}/data/runlength`;
+const FILES = ['1', '2', '3', '4', '5'];
+
+describe(`RunLengthStream`, () => {
+  FILES.forEach((file) => {
+    it(`can decode run length encoded data (${file})`, () => {
+      const encoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.encoded`));
+      const decoded = new Uint8Array(fs.readFileSync(`${DIR}/${file}.decoded`));
+
+      const stream = new RunLengthStream(new Stream(encoded));
+
+      expect(stream.decode()).toEqual(decoded);
+    });
+  });
+});

package/__tests__/core/streams/Stream.spec.ts

@@ -0,0 +1,128 @@
+import Stream from '../../../src/core/streams/Stream';
+
+describe(`Stream`, () => {
+  it('can get the stream length', () => {
+    const bytes = Uint8Array.from([1, 1, 2]);
+    const stream = new Stream(bytes, 0, bytes.length);
+    expect(stream.length).toEqual(3);
+  });
+
+  it('can detect when the stream is empty', () => {
+    const stream = new Stream(Uint8Array.from([]), 0, 0);
+    expect(stream.isEmpty).toEqual(true);
+  });
+
+  describe('can get the bytes from a stream', () => {
+    const bytes = Uint8Array.from([1, 1, 2]);
+
+    it('when the current position is at or after the end', () => {
+      const stream = new Stream(bytes, 5);
+      expect(stream.getByte()).toEqual(-1);
+    });
+
+    it('when the current position is before the end', () => {
+      const stream = new Stream(bytes, 0);
+      for (let pos = 0; pos < bytes.length; pos++) {
+        expect(stream.getByte()).toEqual(bytes[pos]);
+      }
+    });
+  });
+
+  it('can get unsigned sixteen bit integers', () => {
+    const stream = new Stream(Uint8Array.from([1, 1, 2, 2]));
+    expect(stream.getUint16()).toEqual(257);
+    expect(stream.getUint16()).toEqual(514);
+  });
+
+  it('can get thirty-two bit integers', () => {
+    const bytes = Uint8Array.from([1, 1, 1, 1, 255, 255, 255, 255, 2, 2, 2, 2]);
+    const stream = new Stream(bytes);
+    expect(stream.getInt32()).toEqual(16843009);
+    expect(stream.getInt32()).toEqual(-1);
+    expect(stream.getInt32()).toEqual(33686018);
+  });
+
+  describe('can get the next n bytes', () => {
+    let stream: Stream;
+    const bytes = Uint8Array.from([1, 2, 258]);
+
+    beforeEach(() => {
+      stream = new Stream(bytes);
+    });
+
+    describe('when zero length is specified', () => {
+      it('and the values are not clamped', () => {
+        expect(stream.getBytes(0, false)).toEqual(bytes);
+      });
+
+      it('and the values are clamped', () => {
+        const gottenBytes = stream.getBytes(0, true);
+        expect(gottenBytes instanceof Uint8ClampedArray).toEqual(true);
+        expect(gottenBytes.length).toEqual(stream.length);
+        expect(gottenBytes[0]).toEqual(1);
+        expect(gottenBytes[1]).toEqual(2);
+        expect(gottenBytes[2]).toEqual(2);
+      });
+    });
+
+    it('when a non-zero length is specified', () => {
+      expect(stream.getBytes(2, false)).toEqual(bytes.subarray(0, 2));
+    });
+  });
+
+  it('can peek at the next byte', () => {
+    const stream = new Stream(Uint8Array.from([1, 2]));
+    expect(stream.peekByte()).toEqual(1);
+    expect(stream.peekByte()).toEqual(1);
+  });
+
+  describe('can peek at the next n bytes', () => {
+    let stream: Stream;
+    const bytes = Uint8Array.from([1, 2, 258]);
+
+    beforeEach(() => {
+      stream = new Stream(bytes);
+    });
+
+    it('when the values are not clamped', () => {
+      expect(stream.peekBytes(3, false)).toEqual(bytes);
+    });
+
+    it('when the values are clamped', () => {
+      const peekedBytes = stream.peekBytes(3, true);
+      expect(peekedBytes instanceof Uint8ClampedArray).toEqual(true);
+      expect(peekedBytes.length).toEqual(3);
+      expect(peekedBytes[0]).toEqual(1);
+      expect(peekedBytes[1]).toEqual(2);
+      expect(peekedBytes[2]).toEqual(2);
+    });
+  });
+
+  it('can skip bytes', () => {
+    const stream = new Stream(Uint8Array.from([1, 2]));
+    stream.skip(1);
+    expect(stream.peekByte()).toEqual(2);
+    stream.skip(1);
+    expect(stream.peekByte()).toEqual(-1);
+  });
+
+  it('can reset the position pointer', () => {
+    const stream = new Stream(Uint8Array.from([1, 2]));
+    stream.skip(1);
+    stream.reset();
+    expect(stream.peekByte()).toEqual(1);
+  });
+
+  it('can create a substream', () => {
+    const stream = new Stream(Uint8Array.from([1, 2, 3]));
+    const substream = stream.makeSubStream(1, 4);
+    expect(substream.length).toEqual(4);
+    expect(substream.peekByte()).toEqual(2);
+  });
+
+  it('can decode to bytes', () => {
+    const bytes = Uint8Array.from([1, 2, 3]);
+    const stream = new Stream(bytes);
+    expect(stream.decode()).toEqual(bytes);
+  });
+});

package/__tests__/core/streams/data/ascii85/1.encoded

@@ -0,0 +1,43 @@
+70!<9iWTSm7K<E>iWTSm7fWNCiWTSm8,rWHiWTSm8H8`MiWTSm8cSiRiWTSm
+9)nrWiWTSm9E5&\iWTSm9`P/aiWTSm:&k8fiWTSm:B1AkiWTSm:]LJpiWTSm
+;#gSuiWTSm;?-]%iWTSm;ZHf*iWTSm;uco/iWTSm<<*#4iWTSm<WE,9iWTSm
+<r`5>iWTSm=9&>CiWTSm=TAGHiWTSm=o\P&M<.ZglicMP!!!"'J]"ig!<A%A
+q#CBoL!k&HkhZ:>!9c9E!!)4J#6=g,>KOe_2$i.E#lc1Zi<9Je!!!$!,nT#=
+#\X2<!!)9As8W-!,o#;A#\XJD!!)91s8W-!,oGSE#\XbL!!)9!s8W-!,okkI
+#\Y%T!!)8fs8W-!,p;.M#\Y=\!!)8Vs8W-!,p_FQ#\YUd!!)8Fs8W-!,q.^U
+#\Yml!!)86s8W-!,qS!Y#\Z0t!!)8&s8W-!,r"9]#\ZI'!!)7ks8W-!,rFQa
+#\Za/!!)7[s8W-!,rjie#\[$7!!)7Ks8W-!,s:,i#\[<?!!)7;s8W-!,s^Dm
+#\[TG!!)7+s8W-!,t-\q#\[lO!!)6ps8W-!,tQtu#\\/W!!)6`s8W-!,u!8$
+#\\G_!!)9Qrr<#u,uEP(#\\_g!!)9Arr<#u,uih,#\]"o!!)91rr<#u-!9+0
+#\];"!!)9!rr<#u-!]C4#\]S*!!)8frr<#u-",[8#\]k2!!)8Vrr<#u-"Ps<
+#\^.:!!)8Frr<#u-"u6@#\^FB!!)86rr<#u-#DND#\^^J!!)8&rr<#u-#hfH
+#\_!R!!)7krr<#u-$8)L#\_9Z!!)7[rr<#u-$\AP#\_Qb!!)7Krr<#u-%+YT
+#\_ij!!)7;rr<#u-%OqX#\`,r!!)7+rr<#u-%t4\#\`E%!!)6prr<#u-&CL`
+#\`]-!!)6`rr<#u-&gdd#\`u5!!)9QrVuot-'7'h#\X2=!!)9ArVuot-'[?l
+#\XJE!!)91rVuot-(*Wp#\XbM!!)9!rVuot-(Not#\Y%U!!)8frVuot-(s3#
+#\Y=]!!)8VrVuot-)BK'#\YUe!!)8FrVuot-)fc+#\Ymm!!)86rVuot-*6&/
+#\Z0u!!)8&rVuot-*Z>3#\ZI(!!)7krVuot-+)V7#\Za0!!)7[rVuot-+Mn;
+#\[$8!!)7KrVuot-+r1?#\[<@!!)7;rVuot-,AIC#\[TH!!)7+rVuot-,eaG
+#\[lP!!)6prVuot--5$K#\\/X!!)6`rVuot--Y<O#\\G`!!)9Qr;Zfs-.(TS
+#\\_h!!)9Ar;Zfs-.LlW#\]"p!!)91r;Zfs-.q/[#\];#!!)9!r;Zfs-/@G_
+#\]S+!!)8fr;Zfs-/d_c#\]k3!!)8Vr;Zfs-04"g#\^.;!!)8Fr;Zfs-0X:k
+#\^FC!!)86r;Zfs-1'Ro#\^^K!!)8&r;Zfs-1Kjs#\_!S!!)7kr;Zfs-1p."
+#\_9[!!)7[r;Zfs-2?F&#\_Qc!!)7Kr;Zfs-2c^*#\_ik!!)7;r;Zfs,llp.
+#\`,s!!)7+r;Zfs,m<32#\`E&!!)6pr;Zfs,m`K6#\`].!!)6`r;Zfs,n/c:
+#\`u6!!)9Qqu?]r,nT&>#\X2>!!)9Aqu?]r,o#>B#\XJF!!)91qu?]r,oGVF
+#\XbN!!)9!qu?]r,oknJ#\Y%V!!)8fqu?]r,p;1N#\Y=^!!)8Vqu?]r,p_IR
+#\YUf!!)8Fqu?]r,q.aV#\Ymn!!)86qu?]r,qS$Z#\Z1!!!)8&qu?]r,r"<^
+#\ZI)!!)7kqu?]r,rFTb#\Za1!!)7[qu?]r,rjlf#\[$9!!)7Kqu?]r,s:/j
+#\[<A!!)7;qu?]r,s^Gn#\[TI!!)7+qu?]r,t-_r#\[lQ!!)6pqu?]r,tR#!
+#\\/Y!!)6`qu?]r,u!;%#\\Ga!!)9QqZ$Tq,uES)#\\_i!!)9AqZ$Tq,uik-
+#\]"q!!)91qZ$Tq-!9.1#\];$!!)9!qZ$Tq-!]F5#\]S,!!)8fqZ$Tq-",^9
+#\]k4!!)8VqZ$Tq-"Q!=#\^.<!!)8FqZ$Tq-"u9A#\^FD!!)86qZ$Tq-#DQE
+#\^^L!!)8&qZ$Tq-#hiI#\_!T!!)7kqZ$Tq-$8,M#\_9\!!)7[qZ$Tq-$\DQ
+#\_Qd!!)7KqZ$Qqzz!!!!Rm9YY.KB2Mu<)RB0Rfs(2&=Wh/;-%B"jobtRPPb
+C[oT5/rOH>QcOH>QcOH>Q(M<0BV#_5(Ziro\gF:@ITK>7VbLuJRDs3dTsiWT
+UG&;APTlc'+Liro\hahs3?M<0BV#b_gf"UKgtF:u(`!!!"Q^iTn'"=+Q:"UP
+.Tahs4%OH>QcOH>QcOH>Q(M<0BV(lLfgMbOV<:]u[VM+f0#a$_0]zM,Y`'M$
+,*fQi6sbahs4"F=$ufM<0BV#`0NHMd6aJF<h!IFU3mu"H-:`MZts>1!q`($,
+La&Mb=>67L4oV%#\-p0uu*'$.'3I^kop\iW4rW,`0m+F<h!Gls7MgF=%!]+Q
+Wb4<Jfgk^i]p@70oY2jTPoq_i8g>NP$V=!!!"m+QWb4<Jfgk^i^*[,io18K>
+7M_,io18?,Mb`F=$ufKYWH+F:?1n~>trailing garbage

package/__tests__/core/streams/data/asciihex/1.decoded

@@ -0,0 +1 @@
+BT/F1 12 Tf 20 20 Td (ASCIIHexDecode filter, small Length, size diff is more than 135 bytes) Tj ET

package/__tests__/core/streams/data/asciihex/1.encoded

@@ -0,0 +1 @@
+42542F4631203132205466203230203230205464202841534349494865784465636F64652066696C7465722C20736D616C6C204C656E6774682C2073697A652064696666206973206D6F7265207468616E203133352062797465732920546A204554>

package/__tests__/core/streams/data/asciihex/2.decoded

@@ -0,0 +1,7 @@
+BT
+/F1 30 Tf
+350 750 Td
+20 TL
+1 Tr
+(Hello world) Tj
+ET

package/__tests__/core/streams/data/asciihex/2.encoded

@@ -0,0 +1 @@
+42540A2F46312033302054660A333530203735302054640A323020544C0A312054720A2848656C6C6F20776F726C642920546A0A45540A>

package/__tests__/core/streams/data/flate/1.corrupt.encoded

@@ -0,0 +1 @@
+H���Lcr���q�[�n3�}Qes��w,%��ҩ�ɝxm���B3}�N��#h�Rg��

package/__tests__/core/streams/data/flate/1.encoded

@@ -0,0 +1,2 @@
+x��S]O�0�|o��?�E�xm�?�FE+h�B��">��b�S�rGP�X��gf��ԀJC듅����-Ԡ�֘|$��5o��-XO����jVM��EE��0�;�ac�z(j?5^��q�{	�kp���c&��&Ӣq>fL!�e
+>�Y�ZV�B�oy&��/y"Dz���X�������R��QN�H!�;m5������&?�vuŽ����z��G��I�F�fݚ�����[���D�����G|��H�]q �qxC�w�H��-Ʒ�����~=K�bDz��4��H|�<�`�]�ߨ��2���o9��\g;�m�l0cC+Kk�q�=���s.(ȃ��{�s�rF��Y�K���%k

package/__tests__/core/streams/data/flate/2.decoded

@@ -0,0 +1,33 @@
+0.75293 g
+0 0 8.8018 7.3892 re
+f
+0 g
+1 1 m
+1 6.3892 l
+7.8018 6.3892 l
+6.8018 5.3892 l
+2 5.3892 l
+2 2 l
+f
+1 g
+7.8018 6.3892 m
+7.8018 1 l
+1 1 l
+2 2 l
+6.8018 2 l
+6.8018 5.3892 l
+f
+0.5 0.5 7.8018 6.3892 re
+s
+q
+2 2 4.8018 3.3892 re
+W
+n
+0 g
+BT
+/ZaDb 4 Tf
+2.8789 2.9514 Td
+3.852 TL
+(n) Tj
+ET
+Q

package/__tests__/core/streams/data/flate/3.decoded

@@ -0,0 +1,15 @@
+0.749023 g
+0 0 8.52 8.64 re
+f
+q
+1 1 6.52 6.64 re
+W
+n
+0 g
+BT
+/ZaDb 4.7865 Tf
+2.4388 2.6998 Td
+4.6094 TL
+(n) Tj
+ET
+Q

package/__tests__/core/streams/data/flate/4.decoded

@@ -0,0 +1,16 @@
+0.749023 g
+0 0 8.52 8.4 re
+f
+q
+1 1 6.52 6.4 re
+W
+n
+0 g
+BT
+/ZaDb 4.5471 Tf
+2.5299 2.6608 Td
+4.3789 TL
+0 0 Td
+(n) Tj
+ET
+Q

package/__tests__/core/streams/data/flate/6.decoded

@@ -0,0 +1,17 @@
+1 g
+0 0 26.2211 12.5861 re
+f
+/Tx BMC 
+q
+2 1 22.2211 10.5861 re
+W
+n
+0 g
+BT
+/Helv 12 Tf
+0 g
+2 1.8409 Td
+(PRE) Tj
+ET
+Q
+EMC

package/__tests__/core/streams/data/flate/7.decoded

@@ -0,0 +1,20 @@
+/CIDInit /ProcSet findresource begin
+10 dict begin
+begincmap
+/CIDSystemInfo
+<< /Registry (Adobe)
+/Ordering (UCS)
+/Supplement 0
+>> def
+/CMapName /Adobe-Identity-UCS def
+/CMapType 2 def
+1 begincodespacerange
+<0000> <FFFF>
+endcodespacerange
+1 beginbfchar
+<00B2> <2014>
+endbfchar
+endcmap
+CMapName currentdict /CMap defineresource pop
+end
+end

package/__tests__/core/streams/data/flate/7.encoded

@@ -0,0 +1 @@
+x�]�Mj�0��>�����$t��,�C�������Fq�}e7L���>�,}�=����0���1�ac�0��I�8o�ѕ�.&*-�	��������k�N.�x��+;dO3�>/����7.H	*�u�p�A�&��A��;�}����9>��Д��