@pdfme/pdf-lib 6.0.3 → 6.0.5-dev.1

package/__tests__/core/objects/PDFNull.spec.ts

@@ -1,30 +0,0 @@
-import { PDFNull } from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFNull`, () => {
-  it(`cannot be publicly constructed`, () => {
-    expect(() => new (PDFNull as any)()).toThrow();
-  });
-
-  it(`can be converted to null`, () => {
-    expect(PDFNull.asNull()).toBe(null);
-  });
-
-  it(`can be cloned`, () => {
-    expect(PDFNull.clone()).toBe(PDFNull);
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(PDFNull)).toBe('null');
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFNull.sizeInBytes()).toBe(4);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer = new Uint8Array(8).fill(toCharCode(' '));
-    expect(PDFNull.copyBytesInto(buffer, 3)).toBe(4);
-    expect(buffer).toEqual(typedArrayFor('   null '));
-  });
-});

package/__tests__/core/objects/PDFNumber.spec.ts

@@ -1,50 +0,0 @@
-import { PDFNumber } from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFNumber`, () => {
-  it(`can be constructed from PDFNumber.of(...)`, () => {
-    expect(PDFNumber.of(21)).toBeInstanceOf(PDFNumber);
-    expect(PDFNumber.of(-43)).toBeInstanceOf(PDFNumber);
-    expect(PDFNumber.of(-0.1e7)).toBeInstanceOf(PDFNumber);
-  });
-
-  it(`can be cloned`, () => {
-    const original = PDFNumber.of(-21.42);
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(clone.toString()).toBe(original.toString());
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(PDFNumber.of(21))).toEqual('21');
-    expect(String(PDFNumber.of(-43))).toEqual('-43');
-    expect(String(PDFNumber.of(3.403e38))).toEqual(
-      '340300000000000000000000000000000000000',
-    );
-    expect(String(PDFNumber.of(-3.403e38))).toEqual(
-      '-340300000000000000000000000000000000000',
-    );
-    expect(String(PDFNumber.of(-3.403e-38))).toContain(
-      '-0.00000000000000000000000000000000000003403',
-    );
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFNumber.of(21).sizeInBytes()).toBe(2);
-    expect(PDFNumber.of(-43).sizeInBytes()).toBe(3);
-    expect(PDFNumber.of(3.403e38).sizeInBytes()).toBe(39);
-    expect(PDFNumber.of(-3.403e38).sizeInBytes()).toBe(40);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer1 = new Uint8Array(8).fill(toCharCode(' '));
-    expect(PDFNumber.of(21).copyBytesInto(buffer1, 3)).toBe(2);
-    expect(buffer1).toEqual(typedArrayFor('   21   '));
-
-    const buffer2 = new Uint8Array(40).fill(toCharCode(' '));
-    expect(PDFNumber.of(-3.403e38).copyBytesInto(buffer2, 0)).toBe(40);
-    expect(buffer2).toEqual(
-      typedArrayFor('-340300000000000000000000000000000000000'),
-    );
-  });
-});

package/__tests__/core/objects/PDFObject.spec.ts

@@ -1,29 +0,0 @@
-import { MethodNotImplementedError, PDFObject } from '../../../src/core';
-
-describe(`PDFObject`, () => {
-  const pdfObject = new PDFObject();
-
-  it(`does not implement clone()`, () => {
-    expect(() => pdfObject.clone()).toThrow(
-      new MethodNotImplementedError(PDFObject.name, 'clone'),
-    );
-  });
-
-  it(`does not implement toString()`, () => {
-    expect(() => pdfObject.toString()).toThrow(
-      new MethodNotImplementedError(PDFObject.name, 'toString'),
-    );
-  });
-
-  it(`does not implement sizeInBytes()`, () => {
-    expect(() => pdfObject.sizeInBytes()).toThrow(
-      new MethodNotImplementedError(PDFObject.name, 'sizeInBytes'),
-    );
-  });
-
-  it(`does not implement copyBytesInto()`, () => {
-    expect(() => pdfObject.copyBytesInto(new Uint8Array(), 0)).toThrow(
-      new MethodNotImplementedError(PDFObject.name, 'copyBytesInto'),
-    );
-  });
-});

package/__tests__/core/objects/PDFRawStream.spec.ts

@@ -1,45 +0,0 @@
-import { PDFContext, PDFDict, PDFRawStream } from '../../../src/core';
-import { mergeIntoTypedArray, toCharCode } from '../../../src/utils';
-
-describe(`PDFRawStream`, () => {
-  const context = PDFContext.create();
-  const dict = PDFDict.withContext(context);
-  const data = new Uint8Array([12, 39, 92, 38, 38, 28, 49]);
-
-  it(`can be constructed from PDFRawStream.of(...)`, () => {
-    expect(PDFRawStream.of(dict, data)).toBeInstanceOf(PDFRawStream);
-  });
-
-  it(`can be converted to a Uint8Array`, () => {
-    expect(PDFRawStream.of(dict, data).asUint8Array()).toEqual(data);
-  });
-
-  it(`can be cloned`, () => {
-    const original = PDFRawStream.of(dict, data);
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(clone.toString()).toEqual(original.toString());
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(PDFRawStream.of(dict, data))).toEqual(
-      `<<\n/Length 7\n>>\nstream\n\f'\\&&\u001c1\nendstream`,
-    );
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFRawStream.of(dict, data).sizeInBytes()).toBe(40);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer = new Uint8Array(44).fill(toCharCode(' '));
-    expect(PDFRawStream.of(dict, data).copyBytesInto(buffer, 3));
-    expect(buffer).toEqual(
-      mergeIntoTypedArray(
-        '   <<\n/Length 7\n>>\nstream\n',
-        data,
-        '\nendstream ',
-      ),
-    );
-  });
-});

package/__tests__/core/objects/PDFRef.spec.ts

@@ -1,60 +0,0 @@
-import { PDFRef, PrivateConstructorError } from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFRef`, () => {
-  it(`can be constructed from PDFRef.of(...)`, () => {
-    expect(PDFRef.of(0)).toBeInstanceOf(PDFRef);
-    expect(PDFRef.of(0, 21)).toBeInstanceOf(PDFRef);
-    expect(PDFRef.of(94, 0)).toBeInstanceOf(PDFRef);
-    expect(PDFRef.of(4678, 9120)).toBeInstanceOf(PDFRef);
-  });
-
-  it(`cannot be publicly constructed`, () => {
-    expect(() => new (PDFRef as any)({}, 'stuff')).toThrow(
-      new PrivateConstructorError(PDFRef.name),
-    );
-  });
-
-  it(`returns the same instance when given the same object and generation numbers`, () => {
-    expect(PDFRef.of(0)).toBe(PDFRef.of(0));
-    expect(PDFRef.of(0, 21)).toBe(PDFRef.of(0, 21));
-    expect(PDFRef.of(94, 0)).toBe(PDFRef.of(94, 0));
-    expect(PDFRef.of(4678, 9120)).toBe(PDFRef.of(4678, 9120));
-  });
-
-  it(`can be cloned`, () => {
-    expect(PDFRef.of(4678, 9120).clone()).toBe(PDFRef.of(4678, 9120));
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(PDFRef.of(0))).toBe(`0 0 R`);
-    expect(String(PDFRef.of(0, 21))).toBe(`0 21 R`);
-    expect(String(PDFRef.of(94, 0))).toBe(`94 0 R`);
-    expect(String(PDFRef.of(4678, 9120))).toBe(`4678 9120 R`);
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFRef.of(0).sizeInBytes()).toBe(5);
-    expect(PDFRef.of(0, 21).sizeInBytes()).toBe(6);
-    expect(PDFRef.of(94, 0).sizeInBytes()).toBe(6);
-    expect(PDFRef.of(4678, 9120).sizeInBytes()).toBe(11);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer1 = new Uint8Array(9).fill(toCharCode(' '));
-    expect(PDFRef.of(0).copyBytesInto(buffer1, 3)).toBe(5);
-    expect(buffer1).toEqual(typedArrayFor('   0 0 R '));
-
-    const buffer2 = new Uint8Array(9).fill(toCharCode(' '));
-    expect(PDFRef.of(0, 21).copyBytesInto(buffer2, 1)).toBe(6);
-    expect(buffer2).toEqual(typedArrayFor(' 0 21 R  '));
-
-    const buffer3 = new Uint8Array(9).fill(toCharCode(' '));
-    expect(PDFRef.of(94, 0).copyBytesInto(buffer3, 2)).toBe(6);
-    expect(buffer3).toEqual(typedArrayFor('  94 0 R '));
-
-    const buffer4 = new Uint8Array(13).fill(toCharCode(' '));
-    expect(PDFRef.of(4678, 9120).copyBytesInto(buffer4, 0)).toBe(11);
-    expect(buffer4).toEqual(typedArrayFor('4678 9120 R  '));
-  });
-});

package/__tests__/core/objects/PDFString.spec.ts

@@ -1,237 +0,0 @@
-import { PDFString } from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFString`, () => {
-  it(`can be constructed from PDFString.of(...)`, () => {
-    expect(PDFString.of('foobar')).toBeInstanceOf(PDFString);
-    expect(PDFString.of(' (foo(bar))')).toBeInstanceOf(PDFString);
-    expect(PDFString.of(')b\\a/z(')).toBeInstanceOf(PDFString);
-  });
-
-  it(`can be constructed from a Date object`, () => {
-    const date1 = new Date('2018-06-24T01:58:37.228Z');
-    expect(String(PDFString.fromDate(date1))).toBe('(D:20180624015837Z)');
-
-    const date2 = new Date('2019-12-21T07:00:11.000Z');
-    expect(String(PDFString.fromDate(date2))).toBe('(D:20191221070011Z)');
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(PDFString.of('foobar').asString()).toBe('foobar');
-
-    const date = new Date('2018-06-24T01:58:37.228Z');
-    expect(PDFString.fromDate(date).asString()).toBe('D:20180624015837Z');
-  });
-
-  it(`can be cloned`, () => {
-    const original = PDFString.of(')b\\a/z(');
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(clone.toString()).toBe(original.toString());
-  });
-
-  describe(`conversion to string`, () => {
-    it(`can be converted to a string`, () => {
-      expect(String(PDFString.of('foobar'))).toBe('(foobar)');
-    });
-
-    it(`does not escape backslashes`, () => {
-      expect(String(PDFString.of('Foo\\Bar\\Qux'))).toBe('(Foo\\Bar\\Qux)');
-    });
-
-    it(`does not escape nested parenthesis`, () => {
-      expect(String(PDFString.of('(Foo((Bar))Qux)'))).toBe('((Foo((Bar))Qux))');
-    });
-  });
-
-  describe(`converting to bytes`, () => {
-    it(`can interpret escaped octal codes`, () => {
-      const literal =
-        '\\376\\377\\000\\105\\000\\147\\000\\147\\000\\040\\330\\074\\337\\163';
-
-      // prettier-ignore
-      expect(PDFString.of(literal).asBytes()).toEqual(Uint8Array.of(
-        0o376, 0o377,
-        0o000, 0o105,
-        0o000, 0o147,
-        0o000, 0o147,
-        0o000, 0o040,
-        0o330, 0o074,
-        0o337, 0o163,
-      ));
-    });
-
-    it(`can interpret ASCII symbols`, () => {
-      const literal = '\\376\\377\0E\0g\0g\0 \\330<\\337s';
-
-      // prettier-ignore
-      expect(PDFString.of(literal).asBytes()).toEqual(Uint8Array.of(
-        0o376, 0o377,
-        toCharCode('\0'), toCharCode('E'),
-        toCharCode('\0'), toCharCode('g'),
-        toCharCode('\0'), toCharCode('g'),
-        toCharCode('\0'), toCharCode(' '),
-        0o330, toCharCode('<'),  
-        0o337, toCharCode('s'),
-      ));
-    });
-
-    it(`can ignore line breaks`, () => {
-      const literal = '\\376\\377\0E\\\n\\0g\0g\0 \\330<\\337s';
-
-      // prettier-ignore
-      expect(PDFString.of(literal).asBytes()).toEqual(Uint8Array.of(
-        0o376, 0o377,
-        toCharCode('\0'), toCharCode('E'),
-        toCharCode('\0'), toCharCode('g'),
-        toCharCode('\0'), toCharCode('g'),
-        toCharCode('\0'), toCharCode(' '),
-        0o330, toCharCode('<'),  
-        0o337, toCharCode('s'),
-      ));
-    });
-
-    it(`can interpret EOLs and line breaks`, () => {
-      const literal = 'a\nb\rc\\\nd\\\re';
-
-      // prettier-ignore
-      expect(PDFString.of(literal).asBytes()).toEqual(Uint8Array.of(
-        toCharCode('a'), toCharCode('\n'),
-        toCharCode('b'), toCharCode('\r'),
-        toCharCode('c'), toCharCode('d'), 
-        toCharCode('e'),
-      ));
-    });
-
-    it(`can interpret invalid escapes`, () => {
-      const literal = 'a\nb\rc\\xd\\;';
-
-      // prettier-ignore
-      expect(PDFString.of(literal).asBytes()).toEqual(Uint8Array.of(
-        toCharCode('a'), toCharCode('\n'),
-        toCharCode('b'), toCharCode('\r'),
-        toCharCode('c'), toCharCode('x'),
-        toCharCode('d'), toCharCode(';'),
-      ));
-    });
-  });
-
-  describe(`decoding to string`, () => {
-    it(`can interpret UTF-16BE strings with escaped octal codes`, () => {
-      const literal =
-        '\\376\\377\\000\\105\\000\\147\\000\\147\\000\\040\\330\\074\\337\\163';
-      expect(PDFString.of(literal).decodeText()).toBe('Egg 🍳');
-    });
-
-    it(`can interpret UTF-16BE strings with ASCII symbols`, () => {
-      const literal = '\\376\\377\0E\0g\0g\0 \\330<\\337s';
-      expect(PDFString.of(literal).decodeText()).toBe('Egg 🍳');
-    });
-
-    it(`can interpret UTF-16BE strings with line breaks`, () => {
-      const literal = '\\376\\377\0E\\\n\\0g\0g\0 \\330<\\337s';
-      expect(PDFString.of(literal).decodeText()).toBe('Egg 🍳');
-    });
-
-    it(`can interpret UTF-16LE strings with escaped octal codes`, () => {
-      const literal =
-        '\\377\\376\\105\\000\\147\\000\\147\\000\\040\\000\\074\\330\\163\\337';
-      expect(PDFString.of(literal).decodeText()).toBe('Egg 🍳');
-    });
-
-    it(`can interpret PDFDocEncoded strings`, () => {
-      const literal = 'a\\105b\\163\\0b6';
-      expect(PDFString.of(literal).decodeText()).toBe('aEbs\0b6');
-    });
-
-    it(`can interpret PDFDocEncoded strings with EOLs and line breaks`, () => {
-      const literal = 'a\nb\rc\\\nd\\\re';
-      expect(PDFString.of(literal).decodeText()).toBe('a\nb\rcde');
-    });
-
-    it(`can interpret PDFDocEncoded strings with ignored escapes`, () => {
-      const literal = 'a\nb\rc\\xd\\;';
-      expect(PDFString.of(literal).decodeText()).toBe('a\nb\rcxd;');
-    });
-  });
-
-  describe(`decoding to date`, () => {
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSSOHH'mm`, () => {
-      expect(PDFString.of(`D:20200321165011+01'01`).decodeDate()).toStrictEqual(
-        new Date('2020-03-21T15:49:11Z'),
-      );
-      expect(PDFString.of(`D:20200321165011-01'01`).decodeDate()).toStrictEqual(
-        new Date('2020-03-21T17:51:11Z'),
-      );
-      expect(PDFString.of(`D:20200321165011Z00'00`).decodeDate()).toStrictEqual(
-        new Date('2020-03-21T16:50:11Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSSOHH`, () => {
-      expect(PDFString.of('D:20200321165011+01').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T15:50:11Z'),
-      );
-      expect(PDFString.of('D:20200321165011-01').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T17:50:11Z'),
-      );
-      expect(PDFString.of('D:20200321165011Z00').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T16:50:11Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSSO`, () => {
-      expect(PDFString.of('D:20200321165011Z').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T16:50:11Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSS`, () => {
-      expect(PDFString.of('D:20200321165011').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T16:50:11Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmm`, () => {
-      expect(PDFString.of('D:202003211650').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T16:50:00Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHH`, () => {
-      expect(PDFString.of('D:2020032116').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T16:00:00Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDD`, () => {
-      expect(PDFString.of('D:20200321').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T00:00:00Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMM`, () => {
-      expect(PDFString.of('D:202003').decodeDate()).toStrictEqual(
-        new Date('2020-03-01T00:00:00Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYY`, () => {
-      expect(PDFString.of('D:2020').decodeDate()).toStrictEqual(
-        new Date('2020-01-01T00:00:00Z'),
-      );
-    });
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFString.of('foobar').sizeInBytes()).toBe(8);
-    expect(PDFString.of(' (foo(bar))').sizeInBytes()).toBe(13);
-    expect(PDFString.of(')b\\a/z(').sizeInBytes()).toBe(9);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer = new Uint8Array(20).fill(toCharCode(' '));
-    expect(PDFString.of(')(b\\a/))z(').copyBytesInto(buffer, 3)).toBe(12);
-    expect(buffer).toEqual(typedArrayFor('   ()(b\\a/))z()     '));
-  });
-});

package/__tests__/core/operators/PDFOperator.spec.ts

@@ -1,77 +0,0 @@
-import {
-  PDFNumber,
-  PDFOperator,
-  PDFOperatorNames as Ops,
-  PDFString,
-  toCharCode,
-  typedArrayFor,
-} from '../../../src/index';
-
-describe(`PDFOperator`, () => {
-  it(`can be constructed with args`, () => {
-    const str = PDFString.of('FooBar');
-    expect(PDFOperator.of(Ops.ShowText, [str])).toBeInstanceOf(PDFOperator);
-  });
-
-  it(`can be constructed without args`, () => {
-    expect(PDFOperator.of(Ops.BeginText)).toBeInstanceOf(PDFOperator);
-  });
-
-  it(`can be cloned without args`, () => {
-    const original = PDFOperator.of(Ops.ClipNonZero);
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(String(clone)).toBe(String(original));
-  });
-
-  it(`can be cloned with args`, () => {
-    const original = PDFOperator.of(Ops.MoveText, [
-      PDFNumber.of(25),
-      PDFNumber.of(50),
-    ]);
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(String(clone)).toBe(String(original));
-  });
-
-  it(`can be converted to a string without args`, () => {
-    expect(String(PDFOperator.of(Ops.ClosePath))).toBe('h');
-  });
-
-  it(`can be converted to a string with args`, () => {
-    const op = PDFOperator.of(Ops.MoveText, [
-      PDFNumber.of(25.43),
-      PDFNumber.of(-50),
-    ]);
-    expect(String(op)).toBe('25.43 -50 Td');
-  });
-
-  it(`can provide its size in bytes without args`, () => {
-    expect(PDFOperator.of(Ops.ClosePath).sizeInBytes()).toBe(1);
-  });
-
-  it(`can provide its size in bytes with args`, () => {
-    const op = PDFOperator.of(Ops.MoveText, [
-      PDFNumber.of(25.43),
-      PDFNumber.of(-50),
-    ]);
-    expect(op.sizeInBytes()).toBe(12);
-  });
-
-  it(`can be serialized without args`, () => {
-    const op = PDFOperator.of(Ops.ClosePath);
-    const buffer = new Uint8Array(op.sizeInBytes() + 3).fill(toCharCode(' '));
-    expect(op.copyBytesInto(buffer, 2)).toBe(1);
-    expect(buffer).toEqual(typedArrayFor('  h '));
-  });
-
-  it(`can be serialized with args`, () => {
-    const op = PDFOperator.of(Ops.MoveText, [
-      PDFNumber.of(25.43),
-      PDFNumber.of(-50),
-    ]);
-    const buffer = new Uint8Array(op.sizeInBytes() + 3).fill(toCharCode(' '));
-    expect(op.copyBytesInto(buffer, 2)).toBe(12);
-    expect(buffer).toEqual(typedArrayFor('  25.43 -50 Td '));
-  });
-});