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

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

@@ -1,134 +0,0 @@
-import {
-  PDFArray,
-  PDFBool,
-  PDFContext,
-  PDFDict,
-  PDFHexString,
-  PDFName,
-  PDFNull,
-  PDFNumber,
-  PDFRef,
-  PDFString,
-} from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFArray`, () => {
-  const context = PDFContext.create();
-
-  it(`can be constructed with PDFArray.withContext(...)`, () => {
-    expect(PDFArray.withContext(context)).toBeInstanceOf(PDFArray);
-  });
-
-  const pdfArray = PDFArray.withContext(context);
-
-  const pdfBool = PDFBool.True;
-  const pdfHexString = PDFHexString.of('ABC123');
-  const pdfName = PDFName.of('Foo#Bar!');
-  const pdfNull = PDFNull;
-  const pdfNumber = PDFNumber.of(-24.179);
-  const pdfString = PDFString.of('foobar');
-
-  const pdfSubDict = PDFDict.withContext(context);
-  pdfSubDict.set(PDFName.of('Foo'), PDFName.of('Bar'));
-
-  const pdfSubArray = PDFArray.withContext(context);
-  pdfSubArray.push(PDFBool.True);
-  pdfSubArray.push(pdfSubDict);
-
-  const pdfRef = PDFRef.of(21, 92);
-
-  pdfArray.push(pdfBool);
-  pdfArray.push(pdfHexString);
-  pdfArray.push(pdfName);
-  pdfArray.push(pdfNull);
-  pdfArray.push(pdfNumber);
-  pdfArray.push(pdfString);
-  pdfArray.push(pdfSubArray);
-  pdfArray.push(pdfRef);
-
-  it(`retains pushed objects`, () => {
-    expect(pdfArray.size()).toBe(8);
-
-    expect(pdfArray.get(0)).toBe(pdfBool);
-    expect(pdfArray.get(1)).toBe(pdfHexString);
-    expect(pdfArray.get(2)).toBe(pdfName);
-    expect(pdfArray.get(3)).toBe(pdfNull);
-    expect(pdfArray.get(4)).toBe(pdfNumber);
-    expect(pdfArray.get(5)).toBe(pdfString);
-    expect(pdfArray.get(6)).toBe(pdfSubArray);
-    expect(pdfArray.get(7)).toBe(pdfRef);
-  });
-
-  it(`allows objects to be assigned to specific indices`, () => {
-    const array = PDFArray.withContext(PDFContext.create());
-    array.push(PDFName.of('a'));
-    array.push(PDFName.of('b'));
-    array.push(PDFName.of('c'));
-    array.set(1, PDFName.of('z'));
-    expect(array.get(1)).toBe(PDFName.of('z'));
-    expect(array.size()).toBe(3);
-  });
-
-  it(`allows objects to be inserted at specific indices`, () => {
-    const array = PDFArray.withContext(PDFContext.create());
-    array.push(PDFName.of('a'));
-    array.push(PDFName.of('b'));
-    array.push(PDFName.of('c'));
-    array.insert(1, PDFName.of('z'));
-    expect(array.get(0)).toBe(PDFName.of('a'));
-    expect(array.get(1)).toBe(PDFName.of('z'));
-    expect(array.get(2)).toBe(PDFName.of('b'));
-    expect(array.size()).toBe(4);
-  });
-
-  it(`allows objects to be removed from specific indices`, () => {
-    const array = PDFArray.withContext(PDFContext.create());
-    array.push(PDFName.of('a'));
-    array.push(PDFName.of('b'));
-    array.push(PDFName.of('c'));
-    array.remove(1);
-    expect(array.get(0)).toBe(PDFName.of('a'));
-    expect(array.get(1)).toBe(PDFName.of('c'));
-    expect(array.size()).toBe(2);
-  });
-
-  it(`can be converted to an Array`, () => {
-    expect(pdfArray.asArray()).toEqual([
-      pdfBool,
-      pdfHexString,
-      pdfName,
-      pdfNull,
-      pdfNumber,
-      pdfString,
-      pdfSubArray,
-      pdfRef,
-    ]);
-  });
-
-  it(`can be cloned`, () => {
-    const original = pdfArray;
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(clone.toString()).toBe(original.toString());
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(pdfArray)).toBe(
-      '[ true <ABC123> /Foo#23Bar! null -24.179 (foobar) [ true <<\n/Foo /Bar\n>> ] 21 92 R ]',
-    );
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(pdfArray.sizeInBytes()).toBe(84);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer = new Uint8Array(88).fill(toCharCode(' '));
-    expect(pdfArray.copyBytesInto(buffer, 3)).toBe(84);
-    expect(buffer).toEqual(
-      typedArrayFor(
-        '   [ true <ABC123> /Foo#23Bar! null -24.179 (foobar) [ true <<\n/Foo /Bar\n>> ] 21 92 R ] ',
-      ),
-    );
-  });
-});

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

@@ -1,42 +0,0 @@
-import { PDFBool, PrivateConstructorError } from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFBool`, () => {
-  it(`cannot be publicly constructed`, () => {
-    expect(() => new (PDFBool as any)({}, true)).toThrow(
-      new PrivateConstructorError(PDFBool.name),
-    );
-  });
-
-  it(`can be converted to a boolean`, () => {
-    expect(PDFBool.True.asBoolean()).toBe(true);
-    expect(PDFBool.False.asBoolean()).toBe(false);
-  });
-
-  it(`can be cloned`, () => {
-    expect(PDFBool.True.clone()).toBe(PDFBool.True);
-    expect(PDFBool.False.clone()).toBe(PDFBool.False);
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(PDFBool.True)).toBe('true');
-    expect(String(PDFBool.False)).toBe('false');
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFBool.True.sizeInBytes()).toBe(4);
-    expect(PDFBool.False.sizeInBytes()).toBe(5);
-  });
-
-  it(`can be serialized when true`, () => {
-    const buffer = new Uint8Array(8).fill(toCharCode(' '));
-    expect(PDFBool.True.copyBytesInto(buffer, 3)).toBe(4);
-    expect(buffer).toEqual(typedArrayFor('   true '));
-  });
-
-  it(`can be serialized when false`, () => {
-    const buffer = new Uint8Array(9).fill(toCharCode(' '));
-    expect(PDFBool.False.copyBytesInto(buffer, 1)).toBe(5);
-    expect(buffer).toEqual(typedArrayFor(' false   '));
-  });
-});

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

@@ -1,195 +0,0 @@
-import {
-  PDFArray,
-  PDFBool,
-  PDFContext,
-  PDFDict,
-  PDFHexString,
-  PDFName,
-  PDFNull,
-  PDFNumber,
-  PDFRef,
-  PDFString,
-  PDFObject,
-} from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFDict`, () => {
-  const context = PDFContext.create();
-
-  it(`can be constructed from PDFDict.withContext(...)`, () => {
-    expect(PDFDict.withContext(context)).toBeInstanceOf(PDFDict);
-  });
-
-  const pdfDict = PDFDict.withContext(context);
-
-  const pdfBool = PDFBool.True;
-  const pdfHexString = PDFHexString.of('ABC123');
-  const pdfName = PDFName.of('Foo#Bar!');
-  const pdfNull = PDFNull;
-  const pdfNumber = PDFNumber.of(-24.179);
-  const pdfString = PDFString.of('foobar');
-  const pdfRef = PDFRef.of(21, 92);
-
-  pdfDict.set(PDFName.of('Boolean'), pdfBool);
-  pdfDict.set(PDFName.of('HexString'), pdfHexString);
-  pdfDict.set(PDFName.of('Name'), pdfName);
-  pdfDict.set(PDFName.of('Null'), pdfNull);
-  pdfDict.set(PDFName.of('Number'), pdfNumber);
-  pdfDict.set(PDFName.of('String'), pdfString);
-  pdfDict.set(PDFName.of('Ref'), pdfRef);
-
-  const pdfArray = PDFArray.withContext(context);
-  pdfArray.push(PDFBool.True);
-  pdfArray.push(PDFNull);
-
-  const pdfSubDict = PDFDict.withContext(context);
-  pdfSubDict.set(PDFName.of('Array'), pdfArray);
-
-  pdfDict.set(PDFName.of('Dictionary'), pdfSubDict);
-
-  it(`can detect if a value is present`, () => {
-    expect(pdfDict.has(PDFName.of('Boolean'))).toBe(true);
-    expect(pdfDict.has(PDFName.of('HexString'))).toBe(true);
-    expect(pdfDict.has(PDFName.of('Name'))).toBe(true);
-    expect(pdfDict.has(PDFName.of('Null'))).toBe(false);
-    expect(pdfDict.has(PDFName.of('Number'))).toBe(true);
-    expect(pdfDict.has(PDFName.of('String'))).toBe(true);
-    expect(pdfDict.has(PDFName.of('Ref'))).toBe(true);
-    expect(pdfDict.has(PDFName.of('Dictionary'))).toBe(true);
-    expect(pdfSubDict.has(PDFName.of('Array'))).toBe(true);
-    expect(pdfDict.has(PDFName.of('foo'))).toBe(false);
-  });
-
-  it(`retains entered objects`, () => {
-    expect(pdfDict.entries().length).toBe(8);
-
-    expect(pdfDict.get(PDFName.of('Boolean'))).toBe(pdfBool);
-    expect(pdfDict.get(PDFName.of('HexString'))).toBe(pdfHexString);
-    expect(pdfDict.get(PDFName.of('Name'))).toBe(pdfName);
-    expect(pdfDict.get(PDFName.of('Null'))).toBe(undefined);
-    expect(pdfDict.get(PDFName.of('Number'))).toBe(pdfNumber);
-    expect(pdfDict.get(PDFName.of('String'))).toBe(pdfString);
-    expect(pdfDict.get(PDFName.of('Ref'))).toBe(pdfRef);
-    expect(pdfDict.get(PDFName.of('Dictionary'))).toBe(pdfSubDict);
-    expect(pdfSubDict.get(PDFName.of('Array'))).toBe(pdfArray);
-  });
-
-  it(`can be converted to a Map`, () => {
-    expect(pdfDict.asMap()).toEqual(
-      new Map<PDFName, PDFObject>([
-        [PDFName.of('Boolean'), pdfBool],
-        [PDFName.of('HexString'), pdfHexString],
-        [PDFName.of('Name'), pdfName],
-        [PDFName.of('Null'), pdfNull],
-        [PDFName.of('Number'), pdfNumber],
-        [PDFName.of('String'), pdfString],
-        [PDFName.of('Ref'), pdfRef],
-        [PDFName.of('Dictionary'), pdfSubDict],
-      ]),
-    );
-  });
-
-  it(`can be cloned`, () => {
-    const original = pdfDict;
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(clone.toString()).toBe(original.toString());
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(pdfDict)).toBe(
-      `<<
-/Boolean true
-/HexString <ABC123>
-/Name /Foo#23Bar!
-/Null null
-/Number -24.179
-/String (foobar)
-/Ref 21 92 R
-/Dictionary <<
-/Array [ true null ]
->>
->>`,
-    );
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(pdfDict.sizeInBytes()).toBe(153);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer = new Uint8Array(157).fill(toCharCode(' '));
-    expect(pdfDict.copyBytesInto(buffer, 3)).toBe(153);
-    expect(buffer).toEqual(
-      typedArrayFor(
-        `   <<
-/Boolean true
-/HexString <ABC123>
-/Name /Foo#23Bar!
-/Null null
-/Number -24.179
-/String (foobar)
-/Ref 21 92 R
-/Dictionary <<
-/Array [ true null ]
->>
->> `,
-      ),
-    );
-  });
-
-  it(`returns "undefined" if the underlying value is "PDFNull"`, () => {
-    const dict = context.obj({ foo: null });
-    dict.set(PDFName.of('Bar'), PDFNull);
-    context.assign(PDFRef.of(21), PDFNull);
-    dict.set(PDFName.of('qux'), PDFRef.of(21));
-
-    expect(dict.get(PDFName.of('foo'))).toBe(undefined);
-    expect(dict.get(PDFName.of('Bar'))).toBe(undefined);
-    expect(dict.get(PDFName.of('qux'))).toBe(PDFRef.of(21));
-
-    expect(dict.lookup(PDFName.of('foo'))).toBe(undefined);
-    expect(dict.lookup(PDFName.of('Bar'))).toBe(undefined);
-    expect(dict.lookup(PDFName.of('qux'))).toBe(undefined);
-
-    expect(dict.lookup(PDFName.of('foo'), PDFNull)).toBe(PDFNull);
-    expect(dict.lookup(PDFName.of('Bar'), PDFNull)).toBe(PDFNull);
-    expect(dict.lookup(PDFName.of('qux'), PDFNull)).toBe(PDFNull);
-
-    expect(dict.lookupMaybe(PDFName.of('foo'), PDFNull)).toBe(PDFNull);
-    expect(dict.lookupMaybe(PDFName.of('Bar'), PDFNull)).toBe(PDFNull);
-    expect(dict.lookupMaybe(PDFName.of('qux'), PDFNull)).toBe(PDFNull);
-
-    expect(dict.lookupMaybe(PDFName.of('foo'), PDFDict)).toBe(undefined);
-    expect(dict.lookupMaybe(PDFName.of('Bar'), PDFDict)).toBe(undefined);
-    expect(dict.lookupMaybe(PDFName.of('qux'), PDFDict)).toBe(undefined);
-  });
-
-  // https://github.com/Hopding/pdf-lib/issues/1075
-  it(`can generate new keys that don't conflict with existing ones`, () => {
-    const anotherContext = PDFContext.create();
-    const anotherDict = anotherContext.obj({});
-    const anotherKey = anotherDict.uniqueKey();
-
-    const dict = context.obj({});
-    expect(dict.keys().length).toBe(0);
-
-    dict.set(anotherKey, context.obj('boing'));
-    expect(dict.keys().length).toBe(1);
-
-    const key1 = dict.uniqueKey();
-    dict.set(key1, context.obj('beep'));
-    expect(dict.keys().length).toBe(2);
-
-    const key2 = dict.uniqueKey();
-    dict.set(key2, context.obj('boop'));
-    expect(dict.keys().length).toBe(3);
-
-    const key3 = dict.uniqueKey();
-    dict.set(key3, context.obj('baap'));
-    expect(dict.keys().length).toBe(4);
-
-    expect(new Set(dict.keys()).size).toBe(4);
-    expect(dict.keys()).toEqual([anotherKey, key1, key2, key3]);
-  });
-});

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

@@ -1,168 +0,0 @@
-import { PDFHexString } from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFHexString`, () => {
-  it(`can be constructed from PDFHexString.of(...)`, () => {
-    expect(PDFHexString.of('4E6F762073686D6F7A2')).toBeInstanceOf(PDFHexString);
-    expect(PDFHexString.of('901FA3')).toBeInstanceOf(PDFHexString);
-    expect(PDFHexString.of('901FA')).toBeInstanceOf(PDFHexString);
-  });
-
-  it(`can be constructed from a string of text (using UTF-16BE encoding)`, () => {
-    expect(String(PDFHexString.fromText(''))).toBe('<FEFF>');
-    expect(String(PDFHexString.fromText('ä☺𠜎️☁️💩'))).toBe(
-      '<FEFF00E4263AD841DF0EFE0F2601FE0FD83DDCA9>',
-    );
-    expect(String(PDFHexString.fromText('stuff 💩 and 🎂things'))).toBe(
-      '<FEFF007300740075006600660020D83DDCA900200061006E00640020D83CDF82007400680069006E00670073>',
-    );
-  });
-
-  describe(`converting to bytes`, () => {
-    it(`can handle an even number of hex digits`, () => {
-      const hex = 'FEFF0045006700670020D83CDF73';
-
-      // prettier-ignore
-      expect(PDFHexString.of(hex).asBytes()).toEqual(Uint8Array.of(
-        0xFE, 0xFF, 
-        0x00, 0x45, 
-        0x00, 0x67, 
-        0x00, 0x67, 
-        0x00, 0x20, 
-        0xD8, 0x3C, 
-        0xDF, 0x73,
-      ));
-    });
-
-    it(`can handle an odd number of hex digits`, () => {
-      const hex = '6145627300623';
-
-      // prettier-ignore
-      expect(PDFHexString.of(hex).asBytes()).toEqual(Uint8Array.of(
-        0x61, 0x45, 
-        0x62, 0x73, 
-        0x00, 0x62, 
-        0x30,
-      ));
-    });
-  });
-
-  describe(`decoding to string`, () => {
-    it(`can interpret UTF-16BE strings`, () => {
-      const hex = 'FEFF0045006700670020D83CDF73';
-      expect(PDFHexString.of(hex).decodeText()).toBe('Egg 🍳');
-    });
-
-    it(`can interpret UTF-16LE strings`, () => {
-      const hex = 'FFFE45006700670020003CD873DF';
-      expect(PDFHexString.of(hex).decodeText()).toBe('Egg 🍳');
-    });
-
-    it(`can interpret PDFDocEncoded strings`, () => {
-      const hex = '61456273006236';
-      expect(PDFHexString.of(hex).decodeText()).toBe('aEbs\0b6');
-    });
-  });
-
-  describe(`decoding to date`, () => {
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSSOHH'mm`, () => {
-      expect(
-        PDFHexString.fromText(`D:20200321165011+01'01`).decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T15:49:11Z'));
-      expect(
-        PDFHexString.fromText(`D:20200321165011-01'01`).decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T17:51:11Z'));
-      expect(
-        PDFHexString.fromText(`D:20200321165011Z00'00`).decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T16:50:11Z'));
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSSOHH`, () => {
-      expect(
-        PDFHexString.fromText('D:20200321165011+01').decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T15:50:11Z'));
-      expect(
-        PDFHexString.fromText('D:20200321165011-01').decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T17:50:11Z'));
-      expect(
-        PDFHexString.fromText('D:20200321165011Z00').decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T16:50:11Z'));
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSSO`, () => {
-      expect(
-        PDFHexString.fromText('D:20200321165011Z').decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T16:50:11Z'));
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmmSS`, () => {
-      expect(
-        PDFHexString.fromText('D:20200321165011').decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T16:50:11Z'));
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHHmm`, () => {
-      expect(
-        PDFHexString.fromText('D:202003211650').decodeDate(),
-      ).toStrictEqual(new Date('2020-03-21T16:50:00Z'));
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDDHH`, () => {
-      expect(PDFHexString.fromText('D:2020032116').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T16:00:00Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMMDD`, () => {
-      expect(PDFHexString.fromText('D:20200321').decodeDate()).toStrictEqual(
-        new Date('2020-03-21T00:00:00Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYYMM`, () => {
-      expect(PDFHexString.fromText('D:202003').decodeDate()).toStrictEqual(
-        new Date('2020-03-01T00:00:00Z'),
-      );
-    });
-
-    it(`can interpret date strings of the form D:YYYY`, () => {
-      expect(PDFHexString.fromText('D:2020').decodeDate()).toStrictEqual(
-        new Date('2020-01-01T00:00:00Z'),
-      );
-    });
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(PDFHexString.of('901FA').asString()).toBe('901FA');
-    expect(PDFHexString.fromText('stuff 💩 and 🎂things').asString()).toBe(
-      'FEFF007300740075006600660020D83DDCA900200061006E00640020D83CDF82007400680069006E00670073',
-    );
-  });
-
-  it(`can be cloned`, () => {
-    const original = PDFHexString.of('901FA');
-    const clone = original.clone();
-    expect(clone).not.toBe(original);
-    expect(clone.toString()).toBe(original.toString());
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(PDFHexString.of('4E6F762073686D6F7A2'))).toBe(
-      '<4E6F762073686D6F7A2>',
-    );
-    expect(String(PDFHexString.of('901FA3'))).toBe('<901FA3>');
-    expect(String(PDFHexString.of('901FA'))).toBe('<901FA>');
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFHexString.of('4E6F762073686D6F7A2').sizeInBytes()).toBe(21);
-    expect(PDFHexString.of('901FA3').sizeInBytes()).toBe(8);
-    expect(PDFHexString.of('901FA').sizeInBytes()).toBe(7);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer = new Uint8Array(11).fill(toCharCode(' '));
-    expect(PDFHexString.of('901FA').copyBytesInto(buffer, 3)).toBe(7);
-    expect(buffer).toEqual(typedArrayFor('   <901FA> '));
-  });
-});

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

@@ -1,32 +0,0 @@
-import { PDFInvalidObject } from '../../../src/core';
-
-describe(`PDFInvalidObject`, () => {
-  const data = new Uint8Array([12, 39, 92, 38, 38, 28, 49]);
-
-  it(`can be constructed from PDFInvalidObject.of(...)`, () => {
-    expect(PDFInvalidObject.of(data)).toBeInstanceOf(PDFInvalidObject);
-  });
-
-  it(`can be cloned`, () => {
-    const original = PDFInvalidObject.of(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(PDFInvalidObject.of(data))).toBe('PDFInvalidObject(7 bytes)');
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFInvalidObject.of(data).sizeInBytes()).toBe(7);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer = new Uint8Array(11).fill(0);
-    expect(PDFInvalidObject.of(data).copyBytesInto(buffer, 3)).toBe(7);
-    expect(buffer).toEqual(
-      new Uint8Array([0, 0, 0, 12, 39, 92, 38, 38, 28, 49, 0]),
-    );
-  });
-});

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

@@ -1,122 +0,0 @@
-import { PDFName, PrivateConstructorError } from '../../../src/core';
-import { toCharCode, typedArrayFor } from '../../../src/utils';
-
-describe(`PDFName`, () => {
-  it(`can be constructed from PDFName.of(...)`, () => {
-    expect(PDFName.of('foobar')).toBeInstanceOf(PDFName);
-    expect(PDFName.of('A;Name_With-***Characters?')).toBeInstanceOf(PDFName);
-    expect(PDFName.of('paired#28#29parentheses')).toBeInstanceOf(PDFName);
-  });
-
-  it(`cannot be publicly constructed`, () => {
-    expect(() => new (PDFName as any)({}, 'stuff')).toThrow(
-      new PrivateConstructorError(PDFName.name),
-    );
-  });
-
-  it(`returns the same instance when given the same value`, () => {
-    expect(PDFName.of('foobar')).toBe(PDFName.of('foobar'));
-    expect(PDFName.of('A;Name_With-***Characters?')).toBe(
-      PDFName.of('A;Name_With-***Characters?'),
-    );
-    expect(PDFName.of('paired#28#29parentheses')).toBe(
-      PDFName.of('paired#28#29parentheses'),
-    );
-  });
-
-  it(`decodes hex codes in the values`, () => {
-    expect(PDFName.of('Lime#20Green')).toBe(PDFName.of('Lime Green'));
-    expect(PDFName.of('paired#28#29parentheses')).toBe(
-      PDFName.of('paired()parentheses'),
-    );
-    expect(PDFName.of('The_Key_of_F#23_Minor')).toBe(
-      PDFName.of('The_Key_of_F#_Minor'),
-    );
-    expect(PDFName.of('A#42')).toBe(PDFName.of('AB'));
-    expect(PDFName.of('Identity#2DH')).toBe(PDFName.of('Identity-H'));
-
-    expect(PDFName.of('#40')).toBe(PDFName.of('@'));
-    expect(PDFName.of('#41')).toBe(PDFName.of('A'));
-    expect(PDFName.of('#42')).toBe(PDFName.of('B'));
-    expect(PDFName.of('#43')).toBe(PDFName.of('C'));
-    expect(PDFName.of('#44')).toBe(PDFName.of('D'));
-    expect(PDFName.of('#45')).toBe(PDFName.of('E'));
-    expect(PDFName.of('#46')).toBe(PDFName.of('F'));
-    expect(PDFName.of('#47')).toBe(PDFName.of('G'));
-    expect(PDFName.of('#48')).toBe(PDFName.of('H'));
-    expect(PDFName.of('#49')).toBe(PDFName.of('I'));
-    expect(PDFName.of('#4A')).toBe(PDFName.of('J'));
-    expect(PDFName.of('#4B')).toBe(PDFName.of('K'));
-    expect(PDFName.of('#4C')).toBe(PDFName.of('L'));
-    expect(PDFName.of('#4D')).toBe(PDFName.of('M'));
-    expect(PDFName.of('#4E')).toBe(PDFName.of('N'));
-    expect(PDFName.of('#4F')).toBe(PDFName.of('O'));
-  });
-
-  it(`encodes hashes, whitespace, and delimiters when serialized`, () => {
-    expect(PDFName.of('Foo#').toString()).toBe('/Foo#23');
-
-    // Note that the \0 shouldn't ever be written into a name,
-    // but we'll support it for parsing flexibility sake
-    expect(PDFName.of('Foo\0').toString()).toBe('/Foo#00');
-    expect(PDFName.of('Foo\t').toString()).toBe('/Foo#09');
-    expect(PDFName.of('Foo\n').toString()).toBe('/Foo#0A');
-    expect(PDFName.of('Foo\f').toString()).toBe('/Foo#0C');
-    expect(PDFName.of('Foo\r').toString()).toBe('/Foo#0D');
-    expect(PDFName.of('Foo ').toString()).toBe('/Foo#20');
-
-    expect(PDFName.of('Foo(').toString()).toBe('/Foo#28');
-    expect(PDFName.of('Foo)').toString()).toBe('/Foo#29');
-    expect(PDFName.of('Foo<').toString()).toBe('/Foo#3C');
-    expect(PDFName.of('Foo>').toString()).toBe('/Foo#3E');
-    expect(PDFName.of('Foo[').toString()).toBe('/Foo#5B');
-    expect(PDFName.of('Foo]').toString()).toBe('/Foo#5D');
-    expect(PDFName.of('Foo{').toString()).toBe('/Foo#7B');
-    expect(PDFName.of('Foo}').toString()).toBe('/Foo#7D');
-    expect(PDFName.of('Foo/').toString()).toBe('/Foo#2F');
-    expect(PDFName.of('Foo%').toString()).toBe('/Foo#25');
-  });
-
-  it(`can be cloned`, () => {
-    expect(PDFName.of('foobar').clone()).toBe(PDFName.of('foobar'));
-    expect(PDFName.of('Lime#20Green').clone()).toBe(PDFName.of('Lime Green'));
-  });
-
-  it(`can be converted to a string`, () => {
-    expect(String(PDFName.of('foobar'))).toBe('/foobar');
-    expect(String(PDFName.of('Lime Green'))).toBe('/Lime#20Green');
-    expect(String(PDFName.of('\0\t\n\f\r '))).toBe('/#00#09#0A#0C#0D#20');
-    expect(String(PDFName.of('Foo#Bar'))).toBe('/Foo#23Bar');
-    expect(String(PDFName.of('paired()parentheses'))).toBe(
-      '/paired#28#29parentheses',
-    );
-    expect(String(PDFName.of('The_Key_of_F#23_Minor'))).toBe(
-      '/The_Key_of_F#23_Minor',
-    );
-    expect(String(PDFName.of('A#42'))).toBe('/AB');
-  });
-
-  it(`can provide its size in bytes`, () => {
-    expect(PDFName.of('foobar').sizeInBytes()).toBe(7);
-    expect(PDFName.of('Lime Green').sizeInBytes()).toBe(13);
-    expect(PDFName.of('\0\t\n\f\r ').sizeInBytes()).toBe(19);
-    expect(PDFName.of('Foo#Bar').sizeInBytes()).toBe(10);
-    expect(PDFName.of('paired()parentheses').sizeInBytes()).toBe(24);
-    expect(PDFName.of('The_Key_of_F#23_Minor').sizeInBytes()).toBe(22);
-    expect(PDFName.of('A#42').sizeInBytes()).toBe(3);
-  });
-
-  it(`can be serialized`, () => {
-    const buffer1 = new Uint8Array(23).fill(toCharCode(' '));
-    expect(PDFName.of('\0\t\n\f\r ').copyBytesInto(buffer1, 3)).toBe(19);
-    expect(buffer1).toEqual(typedArrayFor('   /#00#09#0A#0C#0D#20 '));
-
-    const buffer2 = new Uint8Array(17).fill(toCharCode(' '));
-    expect(PDFName.of('Lime Green').copyBytesInto(buffer2, 1)).toBe(13);
-    expect(buffer2).toEqual(typedArrayFor(' /Lime#20Green   '));
-
-    const buffer3 = new Uint8Array(7).fill(toCharCode(' '));
-    expect(PDFName.of('A#42').copyBytesInto(buffer3, 4)).toBe(3);
-    expect(buffer3).toEqual(typedArrayFor('    /AB'));
-  });
-});