@pdfme/pdf-lib 1.18.4 → 5.4.0-dev.42

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

@@ -0,0 +1,14 @@
+/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CMapType 2 def
+/CMapName/R99 def
+1 begincodespacerange
+<00><ff>
+endcodespacerange
+1 beginbfrange
+<20><20><0020>
+endbfrange
+endcmap
+CMapName currentdict /CMap defineresource pop
+end end

package/__tests__/core/streams/data/lzw/3.encoded

@@ -0,0 +1,2 @@
+��d�!$�i:����S2�LƓq��e9�Χ#�@b2�‡��@d4��2	�,�ͦ�*M�'���e3M�s��8�m2��C�̞�$��f&����a���&�9�<��1�|
+2�LuH�^�[��&���\�V+���{��L�[��2��sJ5 @c����ID��8S�f�,^3����A�@@

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

@@ -0,0 +1,14 @@
+/CIDInit /ProcSet findresource begin
+12 dict begin
+begincmap
+/CMapType 2 def
+/CMapName/R99 def
+1 begincodespacerange
+<00><ff>
+endcodespacerange
+1 beginbfrange
+<20><20><0020>
+endbfrange
+endcmap
+CMapName currentdict /CMap defineresource pop
+end end

package/__tests__/core/streams/data/lzw/4.encoded

@@ -0,0 +1,2 @@
+��d�!$�i:����S2�LƓq��e9�Χ#�@b2�‡��@d4��2	�,�ͦ�*M�'���e3M�s��8�m2��C�̞�$��f&����a���&�9�<��1�|
+2�LuH�^�[��&���\�V+���{��L�[��2��sJ5 @c����ID��8S�f�,^3����A�@@

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

@@ -0,0 +1 @@
+wwwwwwwwwwwwwwwwwwwwwwwwwqqqqqrstv

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

@@ -0,0 +1 @@
+�w�qrstv�

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

@@ -0,0 +1 @@
+wwwwwwwwwwwwwwwwwwwwwwwwwqqqqqrstvxxxxxxxxxxxxxxxxxxxxxxx

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

@@ -0,0 +1 @@
+�w�qrstv�x�

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

@@ -0,0 +1 @@
+wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwabababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab

package/__tests__/core/streams/data/runlength/4.encoded

@@ -0,0 +1 @@
+�wabababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab�

package/__tests__/core/streams/data/runlength/5.decoded

@@ -0,0 +1 @@
+ababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababbbbbb

package/__tests__/core/streams/data/runlength/5.encoded

@@ -0,0 +1 @@
+~abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababa�b�

package/__tests__/core/streams/data/runlength/empty.encoded

@@ -0,0 +1 @@
+�

package/__tests__/core/structures/PDFCatalog.spec.ts

@@ -0,0 +1,108 @@
+import {
+  PDFCatalog,
+  PDFContext,
+  PDFDict,
+  PDFName,
+  PDFPageLeaf,
+  PDFPageTree,
+  PDFRef,
+} from '../../../src/index';
+
+describe(`PDFCatalog`, () => {
+  it(`can be constructed directly from a Map and PDFContext`, () => {
+    const context = PDFContext.create();
+    const dict = new Map();
+    const catalog = PDFCatalog.fromMapWithContext(dict, context);
+
+    expect(catalog).toBeInstanceOf(PDFCatalog);
+    expect(catalog.get(PDFName.of('Type'))).toBeUndefined();
+    expect(catalog.get(PDFName.of('Pages'))).toBeUndefined();
+  });
+
+  it(`is constructed with the correct Type and entries`, () => {
+    const context = PDFContext.create();
+    const pagesRef = PDFRef.of(21);
+    const catalog = PDFCatalog.withContextAndPages(context, pagesRef);
+
+    expect(catalog).toBeInstanceOf(PDFCatalog);
+    expect(catalog.get(PDFName.of('Type'))).toBe(PDFName.of('Catalog'));
+    expect(catalog.get(PDFName.of('Pages'))).toBe(pagesRef);
+  });
+
+  it(`returns its Pages entry value when it's a reference`, () => {
+    const context = PDFContext.create();
+    const pages = PDFDict.withContext(context);
+    const pagesRef = context.register(pages);
+    const catalog = PDFCatalog.withContextAndPages(context, pagesRef);
+
+    expect(catalog.Pages()).toBe(pages);
+  });
+
+  it(`returns its Pages entry value when it's a direct object`, () => {
+    const context = PDFContext.create();
+    const pages = PDFPageTree.withContext(context);
+    const catalog = PDFCatalog.withContextAndPages(context, pages);
+
+    expect(catalog.Pages()).toBe(pages);
+  });
+
+  it(`can insert leaf nodes`, () => {
+    const context = PDFContext.create();
+
+    const pageTree1 = PDFPageTree.withContext(context);
+    const pageTreeRef1 = context.register(pageTree1);
+
+    const catalog = PDFCatalog.withContextAndPages(context, pageTreeRef1);
+
+    const leaf1 = PDFPageLeaf.withContextAndParent(context, pageTreeRef1);
+    const leafRef1 = context.register(leaf1);
+
+    const leaf2 = PDFPageLeaf.withContextAndParent(context, pageTreeRef1);
+    const leafRef2 = context.register(leaf2);
+
+    pageTree1.pushLeafNode(leafRef1);
+    pageTree1.pushLeafNode(leafRef2);
+
+    expect(pageTree1.Count().asNumber()).toBe(2);
+    expect(pageTree1.Kids().get(1)).toBe(leafRef2);
+    expect(pageTree1.Kids().get(2)).toBe(undefined);
+
+    const newLeaf = PDFPageLeaf.withContextAndParent(context, pageTreeRef1);
+    const newLeafRef = context.register(newLeaf);
+    const insertionRef = catalog.insertLeafNode(newLeafRef, 2);
+
+    expect(pageTree1.Count().asNumber()).toBe(3);
+
+    expect(insertionRef).toBe(pageTreeRef1);
+    expect(pageTree1.Kids().get(1)).toBe(leafRef2);
+    expect(pageTree1.Kids().get(2)).toBe(newLeafRef);
+  });
+
+  it(`can remove leaf nodes`, () => {
+    const context = PDFContext.create();
+
+    const pageTree1 = PDFPageTree.withContext(context);
+    const pageTreeRef1 = context.register(pageTree1);
+
+    const catalog = PDFCatalog.withContextAndPages(context, pageTreeRef1);
+
+    const leaf1 = PDFPageLeaf.withContextAndParent(context, pageTreeRef1);
+    const leafRef1 = context.register(leaf1);
+
+    const leaf2 = PDFPageLeaf.withContextAndParent(context, pageTreeRef1);
+    const leafRef2 = context.register(leaf2);
+
+    pageTree1.pushLeafNode(leafRef1);
+    pageTree1.pushLeafNode(leafRef2);
+
+    expect(pageTree1.Count().asNumber()).toBe(2);
+    expect(pageTree1.Kids().get(0)).toBe(leafRef1);
+    expect(pageTree1.Kids().get(1)).toBe(leafRef2);
+
+    catalog.removeLeafNode(1);
+
+    expect(pageTree1.Count().asNumber()).toBe(1);
+    expect(pageTree1.Kids().get(0)).toBe(leafRef1);
+    expect(pageTree1.Kids().get(1)).toBe(undefined);
+  });
+});

package/__tests__/core/structures/PDFContentStream.spec.ts

@@ -0,0 +1,117 @@
+import pako from 'pako';
+
+import {
+  mergeIntoTypedArray,
+  moveText,
+  PDFContentStream,
+  PDFContext,
+  PDFDict,
+  PDFName,
+  PDFNumber,
+  PDFOperator,
+  PDFOperatorNames as Ops,
+  PDFString,
+  popGraphicsState,
+  pushGraphicsState,
+  toCharCode,
+  typedArrayFor,
+} from '../../../src/index';
+
+describe(`PDFContentStream`, () => {
+  const context = PDFContext.create();
+  const dict = PDFDict.withContext(context);
+  const operators = [
+    PDFOperator.of(Ops.BeginText),
+    PDFOperator.of(Ops.SetFontAndSize, [PDFName.of('F1'), PDFNumber.of(24)]),
+    PDFOperator.of(Ops.MoveText, [PDFNumber.of(100), PDFNumber.of(100)]),
+    PDFOperator.of(Ops.ShowText, [PDFString.of('Hello World and stuff!')]),
+    PDFOperator.of(Ops.EndText),
+  ];
+
+  it(`can be constructed from PDFContentStream.of(...)`, () => {
+    expect(PDFContentStream.of(dict, operators, false)).toBeInstanceOf(
+      PDFContentStream,
+    );
+  });
+
+  it(`allows operators to be pushed to the end of the stream`, () => {
+    const stream = PDFContentStream.of(dict, [pushGraphicsState()], false);
+    stream.push(moveText(21, 99), popGraphicsState());
+    expect(String(stream)).toEqual(
+      '<<\n/Length 13\n>>\n' +
+        'stream\n' +
+        'q\n' +
+        '21 99 Td\n' +
+        'Q\n' +
+        '\nendstream',
+    );
+  });
+
+  it(`can be cloned`, () => {
+    const original = PDFContentStream.of(dict, operators, false);
+    const clone = original.clone();
+    expect(clone).not.toBe(original);
+    expect(String(clone)).toBe(String(original));
+  });
+
+  it(`can be converted to a string`, () => {
+    expect(String(PDFContentStream.of(dict, operators, false))).toEqual(
+      '<<\n/Length 55\n>>\n' +
+        'stream\n' +
+        'BT\n' +
+        '/F1 24 Tf\n' +
+        '100 100 Td\n' +
+        '(Hello World and stuff!) Tj\n' +
+        'ET\n' +
+        '\nendstream',
+    );
+  });
+
+  it(`can provide its size in bytes`, () => {
+    expect(PDFContentStream.of(dict, operators, false).sizeInBytes()).toBe(89);
+  });
+
+  it(`can be serialized`, () => {
+    const stream = PDFContentStream.of(dict, operators, false);
+    const buffer = new Uint8Array(stream.sizeInBytes() + 3).fill(
+      toCharCode(' '),
+    );
+    expect(stream.copyBytesInto(buffer, 2)).toBe(89);
+    expect(buffer).toEqual(
+      typedArrayFor(
+        '  <<\n/Length 55\n>>\n' +
+          'stream\n' +
+          'BT\n' +
+          '/F1 24 Tf\n' +
+          '100 100 Td\n' +
+          '(Hello World and stuff!) Tj\n' +
+          'ET\n' +
+          '\nendstream ',
+      ),
+    );
+  });
+
+  it(`can be serialized when encoded`, () => {
+    const contents =
+      'BT\n' +
+      '/F1 24 Tf\n' +
+      '100 100 Td\n' +
+      '(Hello World and stuff!) Tj\n' +
+      'ET\n';
+    const encodedContents = pako.deflate(contents);
+
+    const stream = PDFContentStream.of(dict, operators, true);
+    const buffer = new Uint8Array(stream.sizeInBytes() + 3).fill(
+      toCharCode(' '),
+    );
+    expect(stream.copyBytesInto(buffer, 2)).toBe(115);
+    expect(buffer).toEqual(
+      mergeIntoTypedArray(
+        '  <<\n/Length 60\n/Filter /FlateDecode\n>>\n',
+        'stream\n',
+        encodedContents,
+        '\nendstream ',
+      ),
+    );
+  });
+});

package/__tests__/core/structures/PDFCrossRefStream.spec.ts

@@ -0,0 +1,145 @@
+import pako from 'pako';
+
+import {
+  mergeIntoTypedArray,
+  PDFContext,
+  PDFCrossRefStream,
+  PDFRef,
+  toCharCode,
+} from '../../../src/index';
+
+describe(`PDFCrossRefStream`, () => {
+  const context = PDFContext.create();
+  const dict = context.obj({});
+
+  it(`can be constructed from PDFCrossRefStream.create(...)`, () => {
+    expect(PDFCrossRefStream.create(dict, false)).toBeInstanceOf(
+      PDFCrossRefStream,
+    );
+  });
+
+  const stream1 = PDFCrossRefStream.create(dict, false);
+  stream1.addDeletedEntry(PDFRef.of(1, 2), 11);
+  stream1.addUncompressedEntry(PDFRef.of(2, 40), 30);
+  stream1.addCompressedEntry(PDFRef.of(21), PDFRef.of(5), 691);
+
+  const stream2 = PDFCrossRefStream.create(dict, false);
+  stream2.addUncompressedEntry(PDFRef.of(2), 300);
+  stream2.addCompressedEntry(PDFRef.of(3), PDFRef.of(10), 0);
+  stream2.addUncompressedEntry(PDFRef.of(9000), 600);
+  stream2.addCompressedEntry(PDFRef.of(9001), PDFRef.of(10), 1);
+
+  it(`can be cloned`, () => {
+    const original = stream1;
+    const clone = original.clone();
+    expect(clone).not.toBe(original);
+    expect(String(clone)).toBe(String(original));
+  });
+
+  it(`can be converted to a string`, () => {
+    expect(String(stream1)).toEqual(
+      '<<\n/Type /XRef\n/Length 16\n/W [ 1 1 2 ]\n/Index [ 0 3 21 1 ]\n>>\n' +
+        'stream\n' +
+        '001111111111111111010110101111100101000101011010110011' +
+        '\nendstream',
+    );
+  });
+
+  it(`can be converted to a string without object number 1`, () => {
+    expect(String(stream2)).toEqual(
+      '<<\n/Type /XRef\n/Length 25\n/W [ 1 2 2 ]\n/Index [ 0 1 2 2 9000 2 ]\n>>\n' +
+        'stream\n' +
+        '00011111111111111111110110000100101000110101100000100101001' +
+        '\nendstream',
+    );
+  });
+
+  it(`can provide its size in bytes`, () => {
+    expect(stream1.sizeInBytes()).toBe(95);
+  });
+
+  it(`can provide its size in bytes without object number 1`, () => {
+    expect(stream2.sizeInBytes()).toBe(110);
+  });
+
+  it(`can be serialized`, () => {
+    const buffer = new Uint8Array(stream1.sizeInBytes() + 3).fill(
+      toCharCode(' '),
+    );
+
+    // prettier-ignore
+    const expectedEntries = new Uint8Array([
+      0,  0, 255, 255,
+      0, 11,   0,   2,
+      1, 30,   0,  40,
+      2,  5,   2, 179,
+    ]);
+
+    expect(stream1.copyBytesInto(buffer, 2)).toBe(95);
+    expect(buffer).toEqual(
+      mergeIntoTypedArray(
+        '  <<\n/Type /XRef\n/Length 16\n/W [ 1 1 2 ]\n/Index [ 0 3 21 1 ]\n>>\n',
+        'stream\n',
+        expectedEntries,
+        '\nendstream ',
+      ),
+    );
+  });
+
+  it(`can be serialized without object number 1`, () => {
+    const buffer = new Uint8Array(stream2.sizeInBytes() + 3).fill(
+      toCharCode(' '),
+    );
+
+    // prettier-ignore
+    const expectedEntries = new Uint8Array([
+      0,  0,   0,  255,  255,
+      1,  1,  44,    0,    0,
+      2,  0,  10,    0,    0,
+      1,  2,  88,    0,    0,
+      2,  0,  10,    0,    1,
+    ]);
+
+    expect(stream2.copyBytesInto(buffer, 2)).toBe(110);
+    expect(buffer).toEqual(
+      mergeIntoTypedArray(
+        '  <<\n/Type /XRef\n/Length 25\n/W [ 1 2 2 ]\n/Index [ 0 1 2 2 9000 2 ]\n>>\n',
+        'stream\n',
+        expectedEntries,
+        '\nendstream ',
+      ),
+    );
+  });
+
+  it(`can be serialized when encoded`, () => {
+    const stream = PDFCrossRefStream.create(dict, true);
+    stream.addUncompressedEntry(PDFRef.of(2), 300);
+    stream.addCompressedEntry(PDFRef.of(3), PDFRef.of(10), 0);
+    stream.addUncompressedEntry(PDFRef.of(9000), 600);
+    stream.addCompressedEntry(PDFRef.of(9001), PDFRef.of(10), 1);
+
+    const buffer = new Uint8Array(stream.sizeInBytes() + 3).fill(
+      toCharCode(' '),
+    );
+
+    // prettier-ignore
+    const expectedEntries = new Uint8Array([
+      0,  0,   0,  255,  255,
+      1,  1,  44,    0,    0,
+      2,  0,  10,    0,    0,
+      1,  2,  88,    0,    0,
+      2,  0,  10,    0,    1,
+    ]);
+    const encodedEntries = pako.deflate(expectedEntries);
+
+    expect(stream.copyBytesInto(buffer, 2)).toBe(135);
+    expect(buffer).toEqual(
+      mergeIntoTypedArray(
+        '  <<\n/Type /XRef\n/Length 29\n/W [ 1 2 2 ]\n/Index [ 0 1 2 2 9000 2 ]\n/Filter /FlateDecode\n>>\n',
+        'stream\n',
+        encodedEntries,
+        '\nendstream ',
+      ),
+    );
+  });
+});

package/__tests__/core/structures/PDFObjectStream.spec.ts

@@ -0,0 +1,138 @@
+import pako from 'pako';
+
+import {
+  mergeIntoTypedArray,
+  PDFContext,
+  PDFHexString,
+  PDFObject,
+  PDFObjectStream,
+  PDFRef,
+  PDFString,
+  toCharCode,
+  typedArrayFor,
+} from '../../../src/index';
+
+describe(`PDFObjectStream`, () => {
+  const context = PDFContext.create();
+
+  const objects: [PDFRef, PDFObject][] = [
+    [context.nextRef(), context.obj([])],
+    [context.nextRef(), context.obj(true)],
+    [context.nextRef(), context.obj({})],
+    [context.nextRef(), PDFHexString.of('ABC123')],
+    [context.nextRef(), PDFRef.of(21)],
+    [context.nextRef(), context.obj('QuxBaz')],
+    [context.nextRef(), context.obj(null)],
+    [context.nextRef(), context.obj(21)],
+    [context.nextRef(), PDFString.of('Stuff and thingz')],
+  ];
+
+  it(`can be constructed from PDFObjectStream.of(...)`, () => {
+    expect(
+      PDFObjectStream.withContextAndObjects(context, objects, false),
+    ).toBeInstanceOf(PDFObjectStream);
+  });
+
+  it(`can be cloned`, () => {
+    const original = PDFObjectStream.withContextAndObjects(
+      context,
+      objects,
+      false,
+    );
+    const clone = original.clone();
+    expect(clone).not.toBe(original);
+    expect(String(clone)).toBe(String(original));
+  });
+
+  it(`can be converted to a string`, () => {
+    expect(
+      String(PDFObjectStream.withContextAndObjects(context, objects, false)),
+    ).toEqual(
+      '<<\n/Type /ObjStm\n/N 9\n/First 42\n/Length 108\n>>\n' +
+        'stream\n' +
+        '1 0 2 4 3 9 4 15 5 24 6 31 7 39 8 44 9 47 ' +
+        '[ ]\n' +
+        'true\n' +
+        '<<\n>>\n' +
+        '<ABC123>\n' +
+        '21 0 R\n' +
+        '/QuxBaz\n' +
+        'null\n' +
+        '21\n' +
+        '(Stuff and thingz)\n' +
+        '\nendstream',
+    );
+  });
+
+  it(`can provide its size in bytes`, () => {
+    expect(
+      PDFObjectStream.withContextAndObjects(
+        context,
+        objects,
+        false,
+      ).sizeInBytes(),
+    ).toBe(172);
+  });
+
+  it(`can be serialized`, () => {
+    const stream = PDFObjectStream.withContextAndObjects(
+      context,
+      objects,
+      false,
+    );
+    const buffer = new Uint8Array(stream.sizeInBytes() + 3).fill(
+      toCharCode(' '),
+    );
+    expect(stream.copyBytesInto(buffer, 2)).toBe(172);
+    expect(buffer).toEqual(
+      typedArrayFor(
+        '  <<\n/Type /ObjStm\n/N 9\n/First 42\n/Length 108\n>>\n' +
+          'stream\n' +
+          '1 0 2 4 3 9 4 15 5 24 6 31 7 39 8 44 9 47 ' +
+          '[ ]\n' +
+          'true\n' +
+          '<<\n>>\n' +
+          '<ABC123>\n' +
+          '21 0 R\n' +
+          '/QuxBaz\n' +
+          'null\n' +
+          '21\n' +
+          '(Stuff and thingz)\n' +
+          '\nendstream ',
+      ),
+    );
+  });
+
+  it(`can be serialized when encoded`, () => {
+    const contents =
+      '1 0 2 4 3 9 4 15 5 24 6 31 7 39 8 44 9 47 ' +
+      '[ ]\n' +
+      'true\n' +
+      '<<\n>>\n' +
+      '<ABC123>\n' +
+      '21 0 R\n' +
+      '/QuxBaz\n' +
+      'null\n' +
+      '21\n' +
+      '(Stuff and thingz)\n';
+    const encodedContents = pako.deflate(contents);
+
+    const stream = PDFObjectStream.withContextAndObjects(
+      context,
+      objects,
+      true,
+    );
+    const buffer = new Uint8Array(stream.sizeInBytes() + 3).fill(
+      toCharCode(' '),
+    );
+    expect(stream.copyBytesInto(buffer, 2)).toBe(195);
+    expect(buffer).toEqual(
+      mergeIntoTypedArray(
+        '  <<\n/Filter /FlateDecode\n/Type /ObjStm\n/N 9\n/First 42\n/Length 110\n>>\n',
+        'stream\n',
+        encodedContents,
+        '\nendstream ',
+      ),
+    );
+  });
+});