pdfkit 0.17.2 → 0.19.0

package/js/pdfkit.es.js

@@ -1,11 +1,12 @@
 import stream from 'stream';
 import zlib from 'zlib';
-import CryptoJS from 'crypto-js';
+import { concatBytes } from '@noble/hashes/utils';
+import md5 from 'js-md5';
+import { sha256 } from '@noble/hashes/sha2';
+import { cbc, ecb } from '@noble/ciphers/aes';
 import fs from 'fs';
-import * as fontkit from 'fontkit';
-import { EventEmitter } from 'events';
+import { create } from 'fontkit';
 import LineBreaker from 'linebreak';
-import exif from 'jpeg-exif';
 import PNG from 'png-js';
 
 class PDFAbstractReference {
@@ -15,8 +16,7 @@ class PDFAbstractReference {
 }
 
 class PDFTree {
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(options = {}) {
     this._items = {};
     this.limits = typeof options.limits === 'boolean' ? options.limits : true;
   }
@@ -58,7 +58,7 @@ class SpotColor {
     this.id = 'CS' + Object.keys(doc.spotColors).length;
     this.name = name;
     this.values = [C, M, Y, K];
-    this.ref = doc.ref(['Separation', this.name, 'DeviceCMYK', {
+    this.ref = doc.ref(['Separation', escapeName(this.name), 'DeviceCMYK', {
       Range: [0, 1, 0, 1, 0, 1, 0, 1],
       C0: [0, 0, 0, 0],
       C1: this.values.map(value => value / 100),
@@ -74,6 +74,10 @@ class SpotColor {
 }
 
 const pad = (str, length) => (Array(length + 1).join('0') + str).slice(-length);
+const isSafeCharCode = code => {
+  if (code > 0x7f) return true;
+  return code > 0x20 && code !== 0x7f && code !== 0x23 && code !== 0x25 && code !== 0x28 && code !== 0x29 && code !== 0x2f && code !== 0x3c && code !== 0x3e && code !== 0x5b && code !== 0x5d && code !== 0x7b && code !== 0x7d;
+};
 const escapableRe = /[\n\r\t\b\f()\\]/g;
 const escapable = {
   '\n': '\\n',
@@ -85,6 +89,18 @@ const escapable = {
   '(': '\\(',
   ')': '\\)'
 };
+const escapeName = function (name) {
+  let escapedName = '';
+  for (const char of name) {
+    const code = char.charCodeAt(0);
+    if (isSafeCharCode(code)) {
+      escapedName += char;
+    } else {
+      escapedName += `#${code.toString(16).toUpperCase().padStart(2, '0')}`;
+    }
+  }
+  return escapedName;
+};
 const swapBytes = function (buff) {
   const l = buff.length;
   if (l & 0x01) {
@@ -99,8 +115,7 @@ const swapBytes = function (buff) {
   return buff;
 };
 class PDFObject {
-  static convert(object) {
-    let encryptFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  static convert(object, encryptFn = null) {
     if (typeof object === 'string') {
       return `/${object}`;
     } else if (object instanceof String) {
@@ -162,8 +177,7 @@ class PDFObject {
 }
 
 class PDFReference extends PDFAbstractReference {
-  constructor(document, id) {
-    let data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  constructor(document, id, data = {}) {
     super();
     this.document = document;
     this.id = id;
@@ -235,9 +249,7 @@ function PDFNumber(n) {
   }
   return fArray[0];
 }
-function normalizeSides(sides) {
-  let defaultDefinition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
-  let transformer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : v => v;
+function normalizeSides(sides, defaultDefinition = undefined, transformer = v => v) {
   if (sides == null || typeof sides === 'object' && Object.keys(sides).length === 0) {
     sides = defaultDefinition;
   }
@@ -357,12 +369,12 @@ const SIZES = {
   TABLOID: [792.0, 1224.0]
 };
 class PDFPage {
-  constructor(document) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  constructor(document, options = {}) {
     this.document = document;
     this._options = options;
     this.size = options.size || 'letter';
     this.layout = options.layout || 'portrait';
+    this.userUnit = options.userUnit || 1.0;
     const dimensions = Array.isArray(this.size) ? this.size : SIZES[this.size.toUpperCase()];
     this.width = dimensions[this.layout === 'portrait' ? 0 : 1];
     this.height = dimensions[this.layout === 'portrait' ? 1 : 0];
@@ -378,7 +390,8 @@ class PDFPage {
       Parent: this.document._root.data.Pages,
       MediaBox: [0, 0, this.width, this.height],
       Contents: this.content,
-      Resources: this.resources
+      Resources: this.resources,
+      UserUnit: this.userUnit
     });
     this.markings = [];
   }
@@ -451,6 +464,54 @@ class PDFNameTree extends PDFTree {
   }
 }
 
+function md5Hash(data) {
+  return new Uint8Array(md5.arrayBuffer(data));
+}
+function md5Hex(data) {
+  return md5(data);
+}
+
+function sha256Hash(data) {
+  return sha256(data);
+}
+
+function aesCbcEncrypt(data, key, iv, padding = true) {
+  return cbc(key, iv, {
+    disablePadding: !padding
+  }).encrypt(data);
+}
+function aesEcbEncrypt(data, key) {
+  return ecb(key, {
+    disablePadding: true
+  }).encrypt(data);
+}
+
+function rc4(data, key) {
+  const s = new Uint8Array(256);
+  for (let i = 0; i < 256; i++) {
+    s[i] = i;
+  }
+  let j = 0;
+  for (let i = 0; i < 256; i++) {
+    j = j + s[i] + key[i % key.length] & 0xff;
+    [s[i], s[j]] = [s[j], s[i]];
+  }
+  const output = new Uint8Array(data.length);
+  for (let i = 0, j = 0, k = 0; k < data.length; k++) {
+    i = i + 1 & 0xff;
+    j = j + s[i] & 0xff;
+    [s[i], s[j]] = [s[j], s[i]];
+    output[k] = data[k] ^ s[s[i] + s[j] & 0xff];
+  }
+  return output;
+}
+
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  globalThis.crypto.getRandomValues(bytes);
+  return bytes;
+}
+
 function inRange(value, rangeGroup) {
   if (value < rangeGroup[0]) return false;
   let startRange = 0;
@@ -507,8 +568,7 @@ function toCodePoints(input) {
   }
   return codepoints;
 }
-function saslprep(input) {
-  let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function saslprep(input, opts = {}) {
   if (typeof input !== 'string') {
     throw new TypeError('Expected string.');
   }
@@ -542,8 +602,7 @@ function saslprep(input) {
 }
 
 class PDFSecurity {
-  static generateFileID() {
-    let info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  static generateFileID(info = {}) {
     let infoStr = `${info.CreationDate.getTime()}\n`;
     for (let key in info) {
       if (!info.hasOwnProperty(key)) {
@@ -551,20 +610,18 @@ class PDFSecurity {
       }
       infoStr += `${key}: ${info[key].valueOf()}\n`;
     }
-    return wordArrayToBuffer(CryptoJS.MD5(infoStr));
+    return Buffer.from(md5Hash(infoStr));
   }
   static generateRandomWordArray(bytes) {
-    return CryptoJS.lib.WordArray.random(bytes);
+    return randomBytes(bytes);
   }
-  static create(document) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  static create(document, options = {}) {
     if (!options.ownerPassword && !options.userPassword) {
       return null;
     }
     return new PDFSecurity(document, options);
   }
-  constructor(document) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  constructor(document, options = {}) {
     if (!options.ownerPassword && !options.userPassword) {
       throw new Error('None of owner password and user password is defined.');
     }
@@ -648,8 +705,8 @@ class PDFSecurity {
       encDict.StrF = 'StdCF';
     }
     encDict.R = r;
-    encDict.O = wordArrayToBuffer(ownerPasswordEntry);
-    encDict.U = wordArrayToBuffer(userPasswordEntry);
+    encDict.O = Buffer.from(ownerPasswordEntry);
+    encDict.U = Buffer.from(userPasswordEntry);
     encDict.P = permissions;
   }
   _setupEncryptionV5(encDict, options) {
@@ -659,10 +716,10 @@ class PDFSecurity {
     const processedOwnerPassword = options.ownerPassword ? processPasswordR5(options.ownerPassword) : processedUserPassword;
     this.encryptionKey = getEncryptionKeyR5(PDFSecurity.generateRandomWordArray);
     const userPasswordEntry = getUserPasswordR5(processedUserPassword, PDFSecurity.generateRandomWordArray);
-    const userKeySalt = CryptoJS.lib.WordArray.create(userPasswordEntry.words.slice(10, 12), 8);
+    const userKeySalt = userPasswordEntry.slice(40, 48);
     const userEncryptionKeyEntry = getUserEncryptionKeyR5(processedUserPassword, userKeySalt, this.encryptionKey);
     const ownerPasswordEntry = getOwnerPasswordR5(processedOwnerPassword, userPasswordEntry, PDFSecurity.generateRandomWordArray);
-    const ownerKeySalt = CryptoJS.lib.WordArray.create(ownerPasswordEntry.words.slice(10, 12), 8);
+    const ownerKeySalt = ownerPasswordEntry.slice(40, 48);
     const ownerEncryptionKeyEntry = getOwnerEncryptionKeyR5(processedOwnerPassword, ownerKeySalt, userPasswordEntry, this.encryptionKey);
     const permsEntry = getEncryptedPermissionsR5(permissions, this.encryptionKey, PDFSecurity.generateRandomWordArray);
     encDict.V = 5;
@@ -677,43 +734,43 @@ class PDFSecurity {
     encDict.StmF = 'StdCF';
     encDict.StrF = 'StdCF';
     encDict.R = 5;
-    encDict.O = wordArrayToBuffer(ownerPasswordEntry);
-    encDict.OE = wordArrayToBuffer(ownerEncryptionKeyEntry);
-    encDict.U = wordArrayToBuffer(userPasswordEntry);
-    encDict.UE = wordArrayToBuffer(userEncryptionKeyEntry);
+    encDict.O = Buffer.from(ownerPasswordEntry);
+    encDict.OE = Buffer.from(ownerEncryptionKeyEntry);
+    encDict.U = Buffer.from(userPasswordEntry);
+    encDict.UE = Buffer.from(userEncryptionKeyEntry);
     encDict.P = permissions;
-    encDict.Perms = wordArrayToBuffer(permsEntry);
+    encDict.Perms = Buffer.from(permsEntry);
   }
   getEncryptFn(obj, gen) {
     let digest;
     if (this.version < 5) {
-      digest = this.encryptionKey.clone().concat(CryptoJS.lib.WordArray.create([(obj & 0xff) << 24 | (obj & 0xff00) << 8 | obj >> 8 & 0xff00 | gen & 0xff, (gen & 0xff00) << 16], 5));
+      const suffix = new Uint8Array([obj & 0xff, obj >> 8 & 0xff, obj >> 16 & 0xff, gen & 0xff, gen >> 8 & 0xff]);
+      digest = concatBytes(this.encryptionKey, suffix);
     }
     if (this.version === 1 || this.version === 2) {
-      let key = CryptoJS.MD5(digest);
-      key.sigBytes = Math.min(16, this.keyBits / 8 + 5);
-      return buffer => wordArrayToBuffer(CryptoJS.RC4.encrypt(CryptoJS.lib.WordArray.create(buffer), key).ciphertext);
+      let key = md5Hash(digest);
+      const keyLen = Math.min(16, this.keyBits / 8 + 5);
+      key = key.slice(0, keyLen);
+      return buffer => Buffer.from(rc4(new Uint8Array(buffer), key));
     }
     let key;
     if (this.version === 4) {
-      key = CryptoJS.MD5(digest.concat(CryptoJS.lib.WordArray.create([0x73416c54], 4)));
+      const saltMarker = new Uint8Array([0x73, 0x41, 0x6c, 0x54]);
+      key = md5Hash(concatBytes(digest, saltMarker));
     } else {
       key = this.encryptionKey;
     }
     const iv = PDFSecurity.generateRandomWordArray(16);
-    const options = {
-      mode: CryptoJS.mode.CBC,
-      padding: CryptoJS.pad.Pkcs7,
-      iv
+    return buffer => {
+      const encrypted = aesCbcEncrypt(new Uint8Array(buffer), key, iv, true);
+      return Buffer.from(concatBytes(iv, encrypted));
     };
-    return buffer => wordArrayToBuffer(iv.clone().concat(CryptoJS.AES.encrypt(CryptoJS.lib.WordArray.create(buffer), key, options).ciphertext));
   }
   end() {
     this.dictionary.end();
   }
 }
-function getPermissionsR2() {
-  let permissionObject = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function getPermissionsR2(permissionObject = {}) {
   let permissions = 0xffffffc0 >> 0;
   if (permissionObject.printing) {
     permissions |= 0b000000000100;
@@ -729,8 +786,7 @@ function getPermissionsR2() {
   }
   return permissions;
 }
-function getPermissionsR3() {
-  let permissionObject = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function getPermissionsR3(permissionObject = {}) {
   let permissions = 0xfffff0c0 >> 0;
   if (permissionObject.printing === 'lowResolution') {
     permissions |= 0b000000000100;
@@ -759,90 +815,97 @@ function getPermissionsR3() {
   return permissions;
 }
 function getUserPasswordR2(encryptionKey) {
-  return CryptoJS.RC4.encrypt(processPasswordR2R3R4(), encryptionKey).ciphertext;
+  return rc4(processPasswordR2R3R4(), encryptionKey);
 }
 function getUserPasswordR3R4(documentId, encryptionKey) {
-  const key = encryptionKey.clone();
-  let cipher = CryptoJS.MD5(processPasswordR2R3R4().concat(CryptoJS.lib.WordArray.create(documentId)));
+  const key = encryptionKey.slice();
+  let cipher = md5Hash(concatBytes(processPasswordR2R3R4(), new Uint8Array(documentId)));
   for (let i = 0; i < 20; i++) {
-    const xorRound = Math.ceil(key.sigBytes / 4);
-    for (let j = 0; j < xorRound; j++) {
-      key.words[j] = encryptionKey.words[j] ^ (i | i << 8 | i << 16 | i << 24);
+    const xorKey = new Uint8Array(key.length);
+    for (let j = 0; j < key.length; j++) {
+      xorKey[j] = encryptionKey[j] ^ i;
     }
-    cipher = CryptoJS.RC4.encrypt(cipher, key).ciphertext;
+    cipher = rc4(cipher, xorKey);
   }
-  return cipher.concat(CryptoJS.lib.WordArray.create(null, 16));
+  const result = new Uint8Array(32);
+  result.set(cipher);
+  return result;
 }
 function getOwnerPasswordR2R3R4(r, keyBits, paddedUserPassword, paddedOwnerPassword) {
   let digest = paddedOwnerPassword;
   let round = r >= 3 ? 51 : 1;
   for (let i = 0; i < round; i++) {
-    digest = CryptoJS.MD5(digest);
+    digest = md5Hash(digest);
   }
-  const key = digest.clone();
-  key.sigBytes = keyBits / 8;
+  const keyLen = keyBits / 8;
+  let key = digest.slice(0, keyLen);
   let cipher = paddedUserPassword;
   round = r >= 3 ? 20 : 1;
   for (let i = 0; i < round; i++) {
-    const xorRound = Math.ceil(key.sigBytes / 4);
-    for (let j = 0; j < xorRound; j++) {
-      key.words[j] = digest.words[j] ^ (i | i << 8 | i << 16 | i << 24);
+    const xorKey = new Uint8Array(keyLen);
+    for (let j = 0; j < keyLen; j++) {
+      xorKey[j] = key[j] ^ i;
     }
-    cipher = CryptoJS.RC4.encrypt(cipher, key).ciphertext;
+    cipher = rc4(cipher, xorKey);
   }
   return cipher;
 }
 function getEncryptionKeyR2R3R4(r, keyBits, documentId, paddedUserPassword, ownerPasswordEntry, permissions) {
-  let key = paddedUserPassword.clone().concat(ownerPasswordEntry).concat(CryptoJS.lib.WordArray.create([lsbFirstWord(permissions)], 4)).concat(CryptoJS.lib.WordArray.create(documentId));
+  const permBytes = new Uint8Array([permissions & 0xff, permissions >> 8 & 0xff, permissions >> 16 & 0xff, permissions >> 24 & 0xff]);
+  let key = concatBytes(paddedUserPassword, ownerPasswordEntry, permBytes, new Uint8Array(documentId));
   const round = r >= 3 ? 51 : 1;
+  const keyLen = keyBits / 8;
   for (let i = 0; i < round; i++) {
-    key = CryptoJS.MD5(key);
-    key.sigBytes = keyBits / 8;
+    key = md5Hash(key);
+    key = key.slice(0, keyLen);
   }
   return key;
 }
 function getUserPasswordR5(processedUserPassword, generateRandomWordArray) {
   const validationSalt = generateRandomWordArray(8);
   const keySalt = generateRandomWordArray(8);
-  return CryptoJS.SHA256(processedUserPassword.clone().concat(validationSalt)).concat(validationSalt).concat(keySalt);
+  const hash = sha256Hash(concatBytes(processedUserPassword, validationSalt));
+  return concatBytes(hash, validationSalt, keySalt);
 }
 function getUserEncryptionKeyR5(processedUserPassword, userKeySalt, encryptionKey) {
-  const key = CryptoJS.SHA256(processedUserPassword.clone().concat(userKeySalt));
-  const options = {
-    mode: CryptoJS.mode.CBC,
-    padding: CryptoJS.pad.NoPadding,
-    iv: CryptoJS.lib.WordArray.create(null, 16)
-  };
-  return CryptoJS.AES.encrypt(encryptionKey, key, options).ciphertext;
+  const key = sha256Hash(concatBytes(processedUserPassword, userKeySalt));
+  const iv = new Uint8Array(16);
+  return aesCbcEncrypt(encryptionKey, key, iv, false);
 }
 function getOwnerPasswordR5(processedOwnerPassword, userPasswordEntry, generateRandomWordArray) {
   const validationSalt = generateRandomWordArray(8);
   const keySalt = generateRandomWordArray(8);
-  return CryptoJS.SHA256(processedOwnerPassword.clone().concat(validationSalt).concat(userPasswordEntry)).concat(validationSalt).concat(keySalt);
+  const hash = sha256Hash(concatBytes(processedOwnerPassword, validationSalt, userPasswordEntry));
+  return concatBytes(hash, validationSalt, keySalt);
 }
 function getOwnerEncryptionKeyR5(processedOwnerPassword, ownerKeySalt, userPasswordEntry, encryptionKey) {
-  const key = CryptoJS.SHA256(processedOwnerPassword.clone().concat(ownerKeySalt).concat(userPasswordEntry));
-  const options = {
-    mode: CryptoJS.mode.CBC,
-    padding: CryptoJS.pad.NoPadding,
-    iv: CryptoJS.lib.WordArray.create(null, 16)
-  };
-  return CryptoJS.AES.encrypt(encryptionKey, key, options).ciphertext;
+  const key = sha256Hash(concatBytes(processedOwnerPassword, ownerKeySalt, userPasswordEntry));
+  const iv = new Uint8Array(16);
+  return aesCbcEncrypt(encryptionKey, key, iv, false);
 }
 function getEncryptionKeyR5(generateRandomWordArray) {
   return generateRandomWordArray(32);
 }
 function getEncryptedPermissionsR5(permissions, encryptionKey, generateRandomWordArray) {
-  const cipher = CryptoJS.lib.WordArray.create([lsbFirstWord(permissions), 0xffffffff, 0x54616462], 12).concat(generateRandomWordArray(4));
-  const options = {
-    mode: CryptoJS.mode.ECB,
-    padding: CryptoJS.pad.NoPadding
-  };
-  return CryptoJS.AES.encrypt(cipher, encryptionKey, options).ciphertext;
+  const data = new Uint8Array(16);
+  data[0] = permissions & 0xff;
+  data[1] = permissions >> 8 & 0xff;
+  data[2] = permissions >> 16 & 0xff;
+  data[3] = permissions >> 24 & 0xff;
+  data[4] = 0xff;
+  data[5] = 0xff;
+  data[6] = 0xff;
+  data[7] = 0xff;
+  data[8] = 0x54;
+  data[9] = 0x61;
+  data[10] = 0x64;
+  data[11] = 0x62;
+  const randomPart = generateRandomWordArray(4);
+  data.set(randomPart, 12);
+  return aesEcbEncrypt(data, encryptionKey);
 }
-function processPasswordR2R3R4() {
-  let password = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
-  const out = Buffer.alloc(32);
+function processPasswordR2R3R4(password = '') {
+  const out = new Uint8Array(32);
   const length = password.length;
   let index = 0;
   while (index < length && index < 32) {
@@ -857,34 +920,23 @@ function processPasswordR2R3R4() {
     out[index] = PASSWORD_PADDING[index - length];
     index++;
   }
-  return CryptoJS.lib.WordArray.create(out);
+  return out;
 }
-function processPasswordR5() {
-  let password = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+function processPasswordR5(password = '') {
   password = unescape(encodeURIComponent(saslprep(password)));
   const length = Math.min(127, password.length);
-  const out = Buffer.alloc(length);
+  const out = new Uint8Array(length);
   for (let i = 0; i < length; i++) {
     out[i] = password.charCodeAt(i);
   }
-  return CryptoJS.lib.WordArray.create(out);
-}
-function lsbFirstWord(data) {
-  return (data & 0xff) << 24 | (data & 0xff00) << 8 | data >> 8 & 0xff00 | data >> 24 & 0xff;
-}
-function wordArrayToBuffer(wordArray) {
-  const byteArray = [];
-  for (let i = 0; i < wordArray.sigBytes; i++) {
-    byteArray.push(wordArray.words[Math.floor(i / 4)] >> 8 * (3 - i % 4) & 0xff);
-  }
-  return Buffer.from(byteArray);
+  return out;
 }
 const PASSWORD_PADDING = [0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41, 0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08, 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80, 0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a];
 
 const {
   number: number$2
 } = PDFObject;
-class PDFGradient$1 {
+let PDFGradient$1 = class PDFGradient {
   constructor(doc) {
     this.doc = doc;
     this.stops = [];
@@ -1042,8 +1094,8 @@ class PDFGradient$1 {
     const op = stroke ? 'SCN' : 'scn';
     return this.doc.addContent(`/${this.id} ${op}`);
   }
-}
-class PDFLinearGradient$1 extends PDFGradient$1 {
+};
+let PDFLinearGradient$1 = class PDFLinearGradient extends PDFGradient$1 {
   constructor(doc, x1, y1, x2, y2) {
     super(doc);
     this.x1 = x1;
@@ -1061,10 +1113,10 @@ class PDFLinearGradient$1 extends PDFGradient$1 {
     });
   }
   opacityGradient() {
-    return new PDFLinearGradient$1(this.doc, this.x1, this.y1, this.x2, this.y2);
+    return new PDFLinearGradient(this.doc, this.x1, this.y1, this.x2, this.y2);
   }
-}
-class PDFRadialGradient$1 extends PDFGradient$1 {
+};
+let PDFRadialGradient$1 = class PDFRadialGradient extends PDFGradient$1 {
   constructor(doc, x1, y1, r1, x2, y2, r2) {
     super(doc);
     this.doc = doc;
@@ -1085,9 +1137,9 @@ class PDFRadialGradient$1 extends PDFGradient$1 {
     });
   }
   opacityGradient() {
-    return new PDFRadialGradient$1(this.doc, this.x1, this.y1, this.r1, this.x2, this.y2, this.r2);
+    return new PDFRadialGradient(this.doc, this.x1, this.y1, this.r1, this.x2, this.y2, this.r2);
   }
-}
+};
 var Gradient = {
   PDFGradient: PDFGradient$1,
   PDFLinearGradient: PDFLinearGradient$1,
@@ -1095,7 +1147,7 @@ var Gradient = {
 };
 
 const underlyingColorSpaces = ['DeviceCMYK', 'DeviceRGB'];
-class PDFTilingPattern$1 {
+let PDFTilingPattern$1 = class PDFTilingPattern {
   constructor(doc, bBox, xStep, yStep, stream) {
     this.doc = doc;
     this.bBox = bBox;
@@ -1155,7 +1207,7 @@ class PDFTilingPattern$1 {
     const op = stroke ? 'SCN' : 'scn';
     return this.doc.addContent(`${normalizedColor.join(' ')} /${this.id} ${op}`);
   }
-}
+};
 var pattern = {
   PDFTilingPattern: PDFTilingPattern$1
 };
@@ -1485,86 +1537,176 @@ const parameters = {
   Z: 0,
   z: 0
 };
+const isCommand = function (c) {
+  return c in parameters;
+};
+const isWsp = function (c) {
+  const codePoint = c.codePointAt(0);
+  return codePoint === 0x20 || codePoint === 0x9 || codePoint === 0xd || codePoint === 0xa;
+};
+const isDigit = function (c) {
+  const codePoint = c.codePointAt(0);
+  if (codePoint == null) {
+    return false;
+  }
+  return 48 <= codePoint && codePoint <= 57;
+};
+const readNumber = function (string, cursor) {
+  let i = cursor;
+  let value = '';
+  let state = 'none';
+  for (; i < string.length; i += 1) {
+    const c = string[i];
+    if (c === '+' || c === '-') {
+      if (state === 'none') {
+        state = 'sign';
+        value += c;
+        continue;
+      }
+      if (state === 'e') {
+        state = 'exponent_sign';
+        value += c;
+        continue;
+      }
+    }
+    if (isDigit(c)) {
+      if (state === 'none' || state === 'sign' || state === 'whole') {
+        state = 'whole';
+        value += c;
+        continue;
+      }
+      if (state === 'decimal_point' || state === 'decimal') {
+        state = 'decimal';
+        value += c;
+        continue;
+      }
+      if (state === 'e' || state === 'exponent_sign' || state === 'exponent') {
+        state = 'exponent';
+        value += c;
+        continue;
+      }
+    }
+    if (c === '.') {
+      if (state === 'none' || state === 'sign' || state === 'whole') {
+        state = 'decimal_point';
+        value += c;
+        continue;
+      }
+    }
+    if (c === 'E' || c === 'e') {
+      if (state === 'whole' || state === 'decimal_point' || state === 'decimal') {
+        state = 'e';
+        value += c;
+        continue;
+      }
+    }
+    break;
+  }
+  const number = Number.parseFloat(value);
+  if (Number.isNaN(number)) {
+    return [cursor, null];
+  }
+  return [i - 1, number];
+};
 const parse = function (path) {
-  let cmd;
-  const ret = [];
+  const pathData = [];
+  let command = null;
   let args = [];
-  let curArg = '';
-  let foundDecimal = false;
-  let params = 0;
-  for (let c of path) {
-    if (parameters[c] != null) {
-      params = parameters[c];
-      if (cmd) {
-        if (curArg.length > 0) {
-          args[args.length] = +curArg;
+  let argsCount = 0;
+  let canHaveComma = false;
+  let hadComma = false;
+  for (let i = 0; i < path.length; i += 1) {
+    const c = path.charAt(i);
+    if (isWsp(c)) {
+      continue;
+    }
+    if (canHaveComma && c === ',') {
+      if (hadComma) {
+        break;
+      }
+      hadComma = true;
+      continue;
+    }
+    if (isCommand(c)) {
+      if (hadComma) {
+        return pathData;
+      }
+      if (command == null) {
+        if (c !== 'M' && c !== 'm') {
+          return pathData;
+        }
+      } else {
+        if (args.length !== 0) {
+          return pathData;
         }
-        ret[ret.length] = {
-          cmd,
-          args
-        };
-        args = [];
-        curArg = '';
-        foundDecimal = false;
-      }
-      cmd = c;
-    } else if ([' ', ','].includes(c) || c === '-' && curArg.length > 0 && curArg[curArg.length - 1] !== 'e' || c === '.' && foundDecimal) {
-      if (curArg.length === 0) {
-        continue;
       }
-      if (args.length === params) {
-        ret[ret.length] = {
-          cmd,
+      command = c;
+      args = [];
+      argsCount = parameters[command];
+      canHaveComma = false;
+      if (argsCount === 0) {
+        pathData.push({
+          command,
           args
-        };
-        args = [+curArg];
-        if (cmd === 'M') {
-          cmd = 'L';
+        });
+      }
+      continue;
+    }
+    if (command == null) {
+      return pathData;
+    }
+    let newCursor = i;
+    let number = null;
+    if (command === 'A' || command === 'a') {
+      const position = args.length;
+      if (position === 0 || position === 1) {
+        if (c !== '+' && c !== '-') {
+          [newCursor, number] = readNumber(path, i);
         }
-        if (cmd === 'm') {
-          cmd = 'l';
+      }
+      if (position === 2 || position === 5 || position === 6) {
+        [newCursor, number] = readNumber(path, i);
+      }
+      if (position === 3 || position === 4) {
+        if (c === '0') {
+          number = 0;
+        }
+        if (c === '1') {
+          number = 1;
         }
-      } else {
-        args[args.length] = +curArg;
       }
-      foundDecimal = c === '.';
-      curArg = ['-', '.'].includes(c) ? c : '';
     } else {
-      curArg += c;
-      if (c === '.') {
-        foundDecimal = true;
-      }
-    }
-  }
-  if (curArg.length > 0) {
-    if (args.length === params) {
-      ret[ret.length] = {
-        cmd,
+      [newCursor, number] = readNumber(path, i);
+    }
+    if (number == null) {
+      return pathData;
+    }
+    args.push(number);
+    canHaveComma = true;
+    hadComma = false;
+    i = newCursor;
+    if (args.length === argsCount) {
+      pathData.push({
+        command,
         args
-      };
-      args = [+curArg];
-      if (cmd === 'M') {
-        cmd = 'L';
+      });
+      if (command === 'M') {
+        command = 'L';
       }
-      if (cmd === 'm') {
-        cmd = 'l';
+      if (command === 'm') {
+        command = 'l';
       }
-    } else {
-      args[args.length] = +curArg;
+      args = [];
     }
   }
-  ret[ret.length] = {
-    cmd,
-    args
-  };
-  return ret;
+  return pathData;
 };
 const apply = function (commands, doc) {
   cx = cy = px = py = sx = sy = 0;
   for (let i = 0; i < commands.length; i++) {
     const c = commands[i];
-    if (typeof runners[c.cmd] === 'function') {
-      runners[c.cmd](doc, c.args);
+    if (typeof runners[c.command] === 'function') {
+      runners[c.command](doc, c.args);
     }
   }
 };
@@ -1844,8 +1986,7 @@ var VectorMixin = {
   miterLimit(m) {
     return this.addContent(`${number$1(m)} M`);
   },
-  dash(length) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  dash(length, options = {}) {
     const originalLength = length;
     if (!Array.isArray(length)) {
       length = [length, options.space || length];
@@ -1875,21 +2016,42 @@ var VectorMixin = {
   rect(x, y, w, h) {
     return this.addContent(`${number$1(x)} ${number$1(y)} ${number$1(w)} ${number$1(h)} re`);
   },
-  roundedRect(x, y, w, h, r) {
-    if (r == null) {
-      r = 0;
-    }
-    r = Math.min(r, 0.5 * w, 0.5 * h);
-    const c = r * (1.0 - KAPPA);
-    this.moveTo(x + r, y);
-    this.lineTo(x + w - r, y);
-    this.bezierCurveTo(x + w - c, y, x + w, y + c, x + w, y + r);
-    this.lineTo(x + w, y + h - r);
-    this.bezierCurveTo(x + w, y + h - c, x + w - c, y + h, x + w - r, y + h);
-    this.lineTo(x + r, y + h);
-    this.bezierCurveTo(x + c, y + h, x, y + h - c, x, y + h - r);
-    this.lineTo(x, y + r);
-    this.bezierCurveTo(x, y + c, x + c, y, x + r, y);
+  roundedRect(x, y, w, h, borderRadius) {
+    if (borderRadius == null) {
+      borderRadius = 0;
+    }
+    let radii;
+    if (Array.isArray(borderRadius)) {
+      radii = borderRadius.slice(0, 4);
+    } else {
+      radii = [borderRadius, borderRadius, borderRadius, borderRadius];
+    }
+    const limit = Math.min(0.5 * w, 0.5 * h);
+    const rTL = Math.max(0, Math.min(radii[0] || 0, limit));
+    const rTR = Math.max(0, Math.min(radii[1] || 0, limit));
+    const rBR = Math.max(0, Math.min(radii[2] || 0, limit));
+    const rBL = Math.max(0, Math.min(radii[3] || 0, limit));
+    const cpTR = rTR * (1.0 - KAPPA);
+    const cpBR = rBR * (1.0 - KAPPA);
+    const cpBL = rBL * (1.0 - KAPPA);
+    const cpTL = rTL * (1.0 - KAPPA);
+    this.moveTo(x + rTL, y);
+    this.lineTo(x + w - rTR, y);
+    if (rTR > 0) {
+      this.bezierCurveTo(x + w - cpTR, y, x + w, y + cpTR, x + w, y + rTR);
+    }
+    this.lineTo(x + w, y + h - rBR);
+    if (rBR > 0) {
+      this.bezierCurveTo(x + w, y + h - cpBR, x + w - cpBR, y + h, x + w - rBR, y + h);
+    }
+    this.lineTo(x + rBL, y + h);
+    if (rBL > 0) {
+      this.bezierCurveTo(x + cpBL, y + h, x, y + h - cpBL, x, y + h - rBL);
+    }
+    this.lineTo(x, y + rTL);
+    if (rTL > 0) {
+      this.bezierCurveTo(x, y + cpTL, x + cpTL, y, x + rTL, y);
+    }
     return this.closePath();
   },
   ellipse(x, y, r1, r2) {
@@ -1950,10 +2112,7 @@ var VectorMixin = {
     }
     return this;
   },
-  polygon() {
-    for (var _len = arguments.length, points = new Array(_len), _key = 0; _key < _len; _key++) {
-      points[_key] = arguments[_key];
-    }
+  polygon(...points) {
     this.moveTo(...(points.shift() || []));
     for (let point of points) {
       this.lineTo(...(point || []));
@@ -2026,8 +2185,7 @@ var VectorMixin = {
   translate(x, y) {
     return this.transform(1, 0, 0, 1, x, y);
   },
-  rotate(angle) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  rotate(angle, options = {}) {
     let y;
     const rad = angle * Math.PI / 180;
     const cos = Math.cos(rad);
@@ -2042,8 +2200,7 @@ var VectorMixin = {
     }
     return this.transform(cos, sin, -sin, cos, x, y);
   },
-  scale(xFactor, yFactor) {
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  scale(xFactor, yFactor, options = {}) {
     let y;
     if (yFactor == null) {
       yFactor = xFactor;
@@ -2186,7 +2343,7 @@ class AFMFont {
       if (match = line.match(/^Start(\w+)/)) {
         section = match[1];
         continue;
-      } else if (match = line.match(/^End(\w+)/)) {
+      } else if (line.match(/^End(\w+)/)) {
         section = '';
         continue;
       }
@@ -2278,8 +2435,7 @@ class PDFFont {
   embed() {
     throw new Error('Must be implemented by subclasses');
   }
-  lineHeight(size) {
-    let includeGap = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  lineHeight(size, includeGap = false) {
     const gap = includeGap ? this.lineGap : 0;
     return (this.ascender + gap - this.descender) / 1000 * size;
   }
@@ -2531,9 +2687,15 @@ class EmbeddedFont extends PDFFont {
       descriptor.data.FontFile2 = fontFile;
     }
     if (this.document.subset && this.document.subset === 1) {
-      const CIDSet = Buffer.from('FFFFFFFFC0', 'hex');
+      const maxCID = this.widths.length - 1;
+      const cidSetBuffer = Buffer.alloc(Math.ceil((maxCID + 1) / 8), 0);
+      for (let cid = 0; cid <= maxCID; cid++) {
+        if (this.widths[cid] != null) {
+          cidSetBuffer[Math.floor(cid / 8)] |= 0x80 >> cid % 8;
+        }
+      }
       const CIDSetRef = this.document.ref();
-      CIDSetRef.write(CIDSet);
+      CIDSetRef.write(cidSetBuffer);
       CIDSetRef.end();
       descriptor.data.CIDSet = CIDSetRef;
     }
@@ -2603,7 +2765,7 @@ begincmap
 1 begincodespacerange
 <0000><ffff>
 endcodespacerange
-1 beginbfrange
+${ranges.length} beginbfrange
 ${ranges.join('\n')}
 endbfrange
 endcmap
@@ -2625,9 +2787,9 @@ class PDFFontFactory {
       src = fs.readFileSync(src);
     }
     if (src instanceof Uint8Array) {
-      font = fontkit.create(src, family);
+      font = create(src, family);
     } else if (src instanceof ArrayBuffer) {
-      font = fontkit.create(new Uint8Array(src), family);
+      font = create(new Uint8Array(src), family);
     }
     if (font == null) {
       throw new Error('Not a supported font format or standard PDF font.');
@@ -2646,10 +2808,7 @@ const isEqualFont = (font1, font2) => {
   return true;
 };
 var FontsMixin = {
-  initFonts() {
-    let defaultFont = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Helvetica';
-    let defaultFontFamily = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-    let defaultFontSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 12;
+  initFonts(defaultFont = 'Helvetica', defaultFontFamily = null, defaultFontSize = 12) {
     this._fontFamilies = {};
     this._fontCount = 0;
     this._fontSource = defaultFont;
@@ -2698,9 +2857,12 @@ var FontsMixin = {
     if (cacheKey) {
       this._fontFamilies[cacheKey] = this._font;
     }
-    if (this._font.name) {
+    if (this._font.name && !this._fontFamilies[this._font.name]) {
       this._fontFamilies[this._font.name] = this._font;
     }
+    if (!cacheKey && (!this._font.name || this._fontFamilies[this._font.name] !== this._font)) {
+      this._fontFamilies[this._font.id] = this._font;
+    }
     return this;
   },
   fontSize(_fontSize) {
@@ -2717,10 +2879,7 @@ var FontsMixin = {
     };
     return this;
   },
-  sizeToPoint(size) {
-    let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let page = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.page;
-    let percentageWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+  sizeToPoint(size, defaultValue = 0, page = this.page, percentageWidth = undefined) {
     if (!percentageWidth) percentageWidth = this._fontSize;
     if (typeof defaultValue !== 'number') defaultValue = this.sizeToPoint(defaultValue);
     if (size === undefined) return defaultValue;
@@ -2782,12 +2941,13 @@ var FontsMixin = {
 
 const SOFT_HYPHEN = '\u00AD';
 const HYPHEN = '-';
-class LineWrapper extends EventEmitter {
+class LineWrapper {
   constructor(document, options) {
-    super();
+    this._listeners = Object.create(null);
     this.document = document;
     this.horizontalScaling = options.horizontalScaling || 100;
     this.indent = (options.indent || 0) * this.horizontalScaling / 100;
+    this.indentAllLines = options.indentAllLines || false;
     this.characterSpacing = (options.characterSpacing || 0) * this.horizontalScaling / 100;
     this.wordSpacing = (options.wordSpacing === 0) * this.horizontalScaling / 100;
     this.columns = options.columns || 1;
@@ -2839,6 +2999,22 @@ class LineWrapper extends EventEmitter {
       });
     });
   }
+  on(event, listener) {
+    (this._listeners[event] || (this._listeners[event] = [])).push(listener);
+  }
+  once(event, listener) {
+    const wrapper = (...args) => {
+      const listeners = this._listeners[event];
+      listeners.splice(listeners.indexOf(wrapper), 1);
+      listener(...args);
+    };
+    this.on(event, wrapper);
+  }
+  emit(event, ...args) {
+    const listeners = this._listeners[event];
+    if (!listeners) return;
+    for (const listener of listeners.slice()) listener(...args);
+  }
   wordWidth(word) {
     return PDFNumber(this.document.widthOfString(word, this) + this.characterSpacing + this.wordSpacing);
   }
@@ -2904,6 +3080,9 @@ class LineWrapper extends EventEmitter {
     }
   }
   wrap(text, options) {
+    const {
+      document
+    } = this;
     this.horizontalScaling = options.horizontalScaling || 100;
     if (options.indent != null) {
       this.indent = options.indent * this.horizontalScaling / 100;
@@ -2917,24 +3096,20 @@ class LineWrapper extends EventEmitter {
     if (options.ellipsis != null) {
       this.ellipsis = options.ellipsis;
     }
-    const nextY = this.document.y + this.document.currentLineHeight(true);
-    if (this.document.y > this.maxY || nextY > this.maxY) {
+    const nextY = document.y + document.currentLineHeight(true);
+    if (document.y > this.maxY || nextY > this.maxY) {
       this.nextSection();
     }
     let buffer = '';
     let textWidth = 0;
     let wc = 0;
     let lc = 0;
-    let {
-      y
-    } = this.document;
+    let continueY = document.y;
     const emitLine = () => {
       options.textWidth = textWidth + this.wordSpacing * (wc - 1);
       options.wordCount = wc;
       options.lineWidth = this.lineWidth;
-      ({
-        y
-      } = this.document);
+      continueY = document.y;
       this.emit('line', buffer, options, this);
       return lc++;
     };
@@ -2950,8 +3125,8 @@ class LineWrapper extends EventEmitter {
         wc++;
       }
       if (bk.required || !this.canFit(word, w)) {
-        const lh = this.document.currentLineHeight(true);
-        if (this.height != null && this.ellipsis && PDFNumber(this.document.y + lh * 2) > this.maxY && this.column >= this.columns) {
+        const lh = document.currentLineHeight(true);
+        if (this.height != null && this.ellipsis && PDFNumber(document.y + lh * 2) > this.maxY && this.column >= this.columns) {
           if (this.ellipsis === true) {
             this.ellipsis = '…';
           }
@@ -2980,7 +3155,7 @@ class LineWrapper extends EventEmitter {
           this.spaceLeft -= this.wordWidth(HYPHEN);
         }
         emitLine();
-        if (PDFNumber(this.document.y + lh) > this.maxY) {
+        if (PDFNumber(document.y + lh) > this.maxY) {
           this.emit('sectionEnd', options, this);
           const shouldContinue = this.nextSection();
           if (!shouldContinue) {
@@ -3015,9 +3190,9 @@ class LineWrapper extends EventEmitter {
         this.continuedX = 0;
       }
       this.continuedX += options.textWidth || 0;
-      this.document.y = y;
+      document.y = continueY;
     } else {
-      this.document.x = this.startX;
+      document.x = this.startX;
     }
   }
   nextSection(options) {
@@ -3029,7 +3204,13 @@ class LineWrapper extends EventEmitter {
       this.column = 1;
       this.startY = this.document.page.margins.top;
       this.maxY = this.document.page.maxY();
-      this.document.x = this.startX;
+      if (this.indentAllLines) {
+        const indent = this.continuedX || this.indent;
+        this.document.x += indent;
+        this.lineWidth -= indent;
+      } else {
+        this.document.x = this.startX;
+      }
       if (this.document._fillColor) {
         this.document.fillColor(...this.document._fillColor);
       }
@@ -3119,8 +3300,7 @@ var TextMixin = {
   text(text, x, y, options) {
     return this._text(text, x, y, options, this._line);
   },
-  widthOfString(string) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  widthOfString(string, options = {}) {
     const horizontalScaling = options.horizontalScaling || 100;
     return (this._font.widthOfString(string, this._fontSize, options.features) + (options.characterSpacing || 0) * (string.length - 1)) * horizontalScaling / 100;
   },
@@ -3326,11 +3506,8 @@ var TextMixin = {
     }
     return this;
   },
-  _initOptions() {
-    let x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let y = arguments.length > 1 ? arguments[1] : undefined;
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    if (typeof x === 'object') {
+  _initOptions(x = {}, y, options = {}) {
+    if (x && typeof x === 'object') {
       options = x;
       x = null;
     }
@@ -3363,13 +3540,11 @@ var TextMixin = {
     if (result.columnGap == null) {
       result.columnGap = 18;
     }
-    result.rotation = Number(options.rotation ?? 0) % 360;
+    result.rotation = Number(result.rotation ?? 0) % 360;
     if (result.rotation < 0) result.rotation += 360;
     return result;
   },
-  _line(text) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    let wrapper = arguments.length > 2 ? arguments[2] : undefined;
+  _line(text, options = {}, wrapper) {
     this._fragment(text, this.x, this.y, options);
     if (wrapper) {
       const lineGap = options.lineGap || this._lineGap || 0;
@@ -3439,7 +3614,11 @@ var TextMixin = {
     }
     const renderedWidth = options.textWidth + wordSpacing * (options.wordCount - 1) + characterSpacing * (text.length - 1);
     if (options.link != null) {
-      this.link(x, y, renderedWidth, this.currentLineHeight(), options.link);
+      const linkOptions = {};
+      if (this._currentStructureElement && this._currentStructureElement.dictionary.data.S === 'Link') {
+        linkOptions.structParent = this._currentStructureElement;
+      }
+      this.link(x, y, renderedWidth, this.currentLineHeight(), options.link, linkOptions);
     }
     if (options.goTo != null) {
       this.goTo(x, y, renderedWidth, this.currentLineHeight(), options.goTo);
@@ -3568,6 +3747,61 @@ var TextMixin = {
   }
 };
 
+const toBinaryString = bytes => {
+  const chunkSize = 0x8000;
+  let out = '';
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const end = Math.min(i + chunkSize, bytes.length);
+    out += String.fromCharCode.apply(null, bytes.subarray(i, end));
+  }
+  return out;
+};
+const readUInt16BE = (bytes, offset = 0) => (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
+const readUInt16LE = (bytes, offset = 0) => (bytes[offset + 1] << 8 | bytes[offset]) >>> 0;
+const readUInt32BE = (bytes, offset = 0) => bytes[offset] * 0x1000000 + (bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+const readUInt32LE = (bytes, offset = 0) => (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16) + bytes[offset + 3] * 0x1000000 >>> 0;
+
+const parseExifOrientation = data => {
+  if (!data || data.length < 20) return null;
+  let pos = 2;
+  while (pos < data.length - 4) {
+    while (pos < data.length && data[pos] !== 0xff) pos++;
+    if (pos >= data.length - 4) return null;
+    const marker = readUInt16BE(data, pos);
+    pos += 2;
+    if (marker === 0xffda) return null;
+    if (marker >= 0xffd0 && marker <= 0xffd9 || marker === 0xff01) continue;
+    if (pos + 2 > data.length) return null;
+    const segmentLength = readUInt16BE(data, pos);
+    if (marker === 0xffe1 && pos + 8 <= data.length) {
+      const exifHeader = toBinaryString(data.subarray(pos + 2, pos + 8));
+      if (exifHeader === 'Exif\x00\x00') {
+        const tiffStart = pos + 8;
+        if (tiffStart + 8 > data.length) return null;
+        const byteOrder = toBinaryString(data.subarray(tiffStart, tiffStart + 2));
+        const isLittleEndian = byteOrder === 'II';
+        if (!isLittleEndian && byteOrder !== 'MM') return null;
+        const read16 = isLittleEndian ? o => readUInt16LE(data, o) : o => readUInt16BE(data, o);
+        const read32 = isLittleEndian ? o => readUInt32LE(data, o) : o => readUInt32BE(data, o);
+        if (read16(tiffStart + 2) !== 42) return null;
+        const ifdPos = tiffStart + read32(tiffStart + 4);
+        if (ifdPos + 2 > data.length) return null;
+        const entryCount = read16(ifdPos);
+        for (let i = 0; i < entryCount; i++) {
+          const entryPos = ifdPos + 2 + i * 12;
+          if (entryPos + 12 > data.length) return null;
+          if (read16(entryPos) === 0x0112) {
+            const value = read16(entryPos + 8);
+            return value >= 1 && value <= 8 ? value : null;
+          }
+        }
+        return null;
+      }
+    }
+    pos += segmentLength;
+  }
+  return null;
+};
 const MARKERS = [0xffc0, 0xffc1, 0xffc2, 0xffc3, 0xffc5, 0xffc6, 0xffc7, 0xffc8, 0xffc9, 0xffca, 0xffcb, 0xffcc, 0xffcd, 0xffce, 0xffcf];
 const COLOR_SPACE_MAP = {
   1: 'DeviceGray',
@@ -3582,9 +3816,11 @@ class JPEG {
     if (this.data.readUInt16BE(0) !== 0xffd8) {
       throw 'SOI not found in JPEG';
     }
-    this.orientation = exif.fromBuffer(this.data).Orientation || 1;
+    this.orientation = parseExifOrientation(this.data) || 1;
     let pos = 2;
     while (pos < this.data.length) {
+      while (pos < this.data.length && this.data[pos] !== 0xff) pos++;
+      if (pos >= this.data.length) break;
       marker = this.data.readUInt16BE(pos);
       pos += 2;
       if (MARKERS.includes(marker)) {
@@ -3601,7 +3837,7 @@ class JPEG {
     pos += 2;
     this.width = this.data.readUInt16BE(pos);
     pos += 2;
-    const channels = this.data[pos++];
+    const channels = this.data[pos + 1];
     this.colorSpace = COLOR_SPACE_MAP[channels];
     this.obj = null;
   }
@@ -3636,58 +3872,60 @@ class PNGImage {
     this.obj = null;
   }
   embed(document) {
-    let dataDecoded = false;
     this.document = document;
     if (this.obj) {
       return;
     }
-    const hasAlphaChannel = this.image.hasAlphaChannel;
-    const isInterlaced = this.image.interlaceMethod === 1;
-    this.obj = this.document.ref({
+    const {
+      image,
+      height,
+      width
+    } = this;
+    const hasAlphaChannel = image.hasAlphaChannel;
+    const isInterlaced = image.interlaceMethod === 1;
+    const obj = this.obj = document.ref({
       Type: 'XObject',
       Subtype: 'Image',
-      BitsPerComponent: hasAlphaChannel ? 8 : this.image.bits,
-      Width: this.width,
-      Height: this.height,
+      BitsPerComponent: hasAlphaChannel ? 8 : image.bits,
+      Width: width,
+      Height: height,
       Filter: 'FlateDecode'
     });
     if (!hasAlphaChannel) {
-      const params = this.document.ref({
+      const params = document.ref({
         Predictor: isInterlaced ? 1 : 15,
-        Colors: this.image.colors,
-        BitsPerComponent: this.image.bits,
-        Columns: this.width
+        Colors: image.colors,
+        BitsPerComponent: image.bits,
+        Columns: width
       });
-      this.obj.data['DecodeParms'] = params;
+      obj.data['DecodeParms'] = params;
       params.end();
     }
-    if (this.image.palette.length === 0) {
-      this.obj.data['ColorSpace'] = this.image.colorSpace;
+    if (image.palette.length === 0) {
+      obj.data['ColorSpace'] = image.colorSpace;
     } else {
-      const palette = this.document.ref();
-      palette.end(Buffer.from(this.image.palette));
-      this.obj.data['ColorSpace'] = ['Indexed', 'DeviceRGB', this.image.palette.length / 3 - 1, palette];
-    }
-    if (this.image.transparency.grayscale != null) {
-      const val = this.image.transparency.grayscale;
-      this.obj.data['Mask'] = [val, val];
-    } else if (this.image.transparency.rgb) {
+      const palette = document.ref();
+      palette.end(Buffer.from(image.palette));
+      obj.data['ColorSpace'] = ['Indexed', 'DeviceRGB', image.palette.length / 3 - 1, palette];
+    }
+    if (image.transparency.grayscale != null) {
+      const val = image.transparency.grayscale;
+      obj.data['Mask'] = [val, val];
+    } else if (image.transparency.rgb) {
       const {
         rgb
-      } = this.image.transparency;
+      } = image.transparency;
       const mask = [];
       for (let x of rgb) {
         mask.push(x, x);
       }
-      this.obj.data['Mask'] = mask;
-    } else if (this.image.transparency.indexed) {
-      dataDecoded = true;
+      obj.data['Mask'] = mask;
+    } else if (image.transparency.indexed) {
       return this.loadIndexedAlphaChannel();
     } else if (hasAlphaChannel) {
-      dataDecoded = true;
       return this.splitAlphaChannel();
     }
-    if (isInterlaced && !dataDecoded) {
+    if (isInterlaced && true) {
       return this.decodeData();
     }
     this.finalize();
@@ -3736,12 +3974,16 @@ class PNGImage {
   }
   loadIndexedAlphaChannel() {
     const transparency = this.image.transparency.indexed;
+    const isInterlaced = this.image.interlaceMethod === 1;
     return this.image.decodePixels(pixels => {
       const alphaChannel = Buffer.alloc(this.width * this.height);
       let i = 0;
       for (let j = 0, end = pixels.length; j < end; j++) {
         alphaChannel[i++] = transparency[pixels[j]];
       }
+      if (isInterlaced) {
+        this.imgData = zlib.deflateSync(Buffer.from(pixels));
+      }
       this.alphaChannel = zlib.deflateSync(alphaChannel);
       return this.finalize();
     });
@@ -3774,7 +4016,7 @@ class PDFImage {
     }
     if (data[0] === 0xff && data[1] === 0xd8) {
       return new JPEG(data, label);
-    } else if (data[0] === 0x89 && data.toString('ascii', 1, 4) === 'PNG') {
+    } else if (data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47) {
       return new PNGImage(data, label);
     } else {
       throw new Error('Unknown image format.');
@@ -3787,8 +4029,7 @@ var ImagesMixin = {
     this._imageRegistry = {};
     this._imageCount = 0;
   },
-  image(src, x, y) {
-    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  image(src, x, y, options = {}) {
     let bh, bp, bw, image, ip, left, left1, originX, originY;
     if (typeof x === 'object') {
       options = x;
@@ -3946,6 +4187,9 @@ var ImagesMixin = {
       this.y += h;
     }
     this.save();
+    if (options.opacity != null) {
+      this._doOpacity(options.opacity, null);
+    }
     if (rotateAngle) {
       this.rotate(rotateAngle, {
         origin: [originX, originY]
@@ -3971,6 +4215,12 @@ var ImagesMixin = {
   }
 };
 
+class PDFAnnotationReference {
+  constructor(annotationRef) {
+    this.annotationRef = annotationRef;
+  }
+}
+
 var AnnotationsMixin = {
   annotate(x, y, w, h, options) {
     options.Type = 'Annot';
@@ -3988,17 +4238,22 @@ var AnnotationsMixin = {
     if (typeof options.Dest === 'string') {
       options.Dest = new String(options.Dest);
     }
+    const structParent = options.structParent;
+    delete options.structParent;
     for (let key in options) {
       const val = options[key];
       options[key[0].toUpperCase() + key.slice(1)] = val;
     }
     const ref = this.ref(options);
     this.page.annotations.push(ref);
+    if (structParent && typeof structParent.add === 'function') {
+      const annotRef = new PDFAnnotationReference(ref);
+      structParent.add(annotRef);
+    }
     ref.end();
     return this;
   },
-  note(x, y, w, h, contents) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  note(x, y, w, h, contents, options = {}) {
     options.Subtype = 'Text';
     options.Contents = new String(contents);
     if (options.Name == null) {
@@ -4009,8 +4264,7 @@ var AnnotationsMixin = {
     }
     return this.annotate(x, y, w, h, options);
   },
-  goTo(x, y, w, h, name) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  goTo(x, y, w, h, name, options = {}) {
     options.Subtype = 'Link';
     options.A = this.ref({
       S: 'GoTo',
@@ -4019,8 +4273,7 @@ var AnnotationsMixin = {
     options.A.end();
     return this.annotate(x, y, w, h, options);
   },
-  link(x, y, w, h, url) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  link(x, y, w, h, url, options = {}) {
     options.Subtype = 'Link';
     if (typeof url === 'number') {
       const pages = this._root.data.Pages.data;
@@ -4040,62 +4293,55 @@ var AnnotationsMixin = {
       });
       options.A.end();
     }
+    if (options.structParent && !options.Contents) {
+      options.Contents = new String('');
+    }
     return this.annotate(x, y, w, h, options);
   },
-  _markup(x, y, w, h) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  _markup(x, y, w, h, options = {}) {
     const [x1, y1, x2, y2] = this._convertRect(x, y, w, h);
     options.QuadPoints = [x1, y2, x2, y2, x1, y1, x2, y1];
     options.Contents = new String();
     return this.annotate(x, y, w, h, options);
   },
-  highlight(x, y, w, h) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  highlight(x, y, w, h, options = {}) {
     options.Subtype = 'Highlight';
     if (options.color == null) {
       options.color = [241, 238, 148];
     }
     return this._markup(x, y, w, h, options);
   },
-  underline(x, y, w, h) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  underline(x, y, w, h, options = {}) {
     options.Subtype = 'Underline';
     return this._markup(x, y, w, h, options);
   },
-  strike(x, y, w, h) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  strike(x, y, w, h, options = {}) {
     options.Subtype = 'StrikeOut';
     return this._markup(x, y, w, h, options);
   },
-  lineAnnotation(x1, y1, x2, y2) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  lineAnnotation(x1, y1, x2, y2, options = {}) {
     options.Subtype = 'Line';
     options.Contents = new String();
     options.L = [x1, this.page.height - y1, x2, this.page.height - y2];
     return this.annotate(x1, y1, x2, y2, options);
   },
-  rectAnnotation(x, y, w, h) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  rectAnnotation(x, y, w, h, options = {}) {
     options.Subtype = 'Square';
     options.Contents = new String();
     return this.annotate(x, y, w, h, options);
   },
-  ellipseAnnotation(x, y, w, h) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  ellipseAnnotation(x, y, w, h, options = {}) {
     options.Subtype = 'Circle';
     options.Contents = new String();
     return this.annotate(x, y, w, h, options);
   },
-  textAnnotation(x, y, w, h, text) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  textAnnotation(x, y, w, h, text, options = {}) {
     options.Subtype = 'FreeText';
     options.Contents = new String(text);
     options.DA = new String();
     return this.annotate(x, y, w, h, options);
   },
-  fileAnnotation(x, y, w, h) {
-    let file = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  fileAnnotation(x, y, w, h, file = {}, options = {}) {
     const filespec = this.file(file.src, Object.assign({
       hidden: true
     }, file));
@@ -4121,16 +4367,26 @@ var AnnotationsMixin = {
   }
 };
 
+const DEFAULT_OPTIONS = {
+  top: 0,
+  left: 0,
+  zoom: 0,
+  fit: true,
+  pageNumber: null,
+  expanded: false
+};
 class PDFOutline {
-  constructor(document, parent, title, dest) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
-      expanded: false
-    };
+  constructor(document, parent, title, dest, options = DEFAULT_OPTIONS) {
     this.document = document;
     this.options = options;
     this.outlineData = {};
     if (dest !== null) {
-      this.outlineData['Dest'] = [dest.dictionary, 'Fit'];
+      const destWidth = dest.data.MediaBox[2];
+      const destHeight = dest.data.MediaBox[3];
+      const top = destHeight - (options.top || 0);
+      const left = destWidth - (options.left || 0);
+      const zoom = options.zoom || 0;
+      this.outlineData['Dest'] = options.fit ? [dest, 'Fit'] : [dest, 'XYZ', left, top, zoom];
     }
     if (parent !== null) {
       this.outlineData['Parent'] = parent;
@@ -4141,11 +4397,10 @@ class PDFOutline {
     this.dictionary = this.document.ref(this.outlineData);
     this.children = [];
   }
-  addItem(title) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
-      expanded: false
-    };
-    const result = new PDFOutline(this.document, this.dictionary, title, this.document.page, options);
+  addItem(title, options = DEFAULT_OPTIONS) {
+    const pages = this.document._root.data.Pages.data.Kids;
+    const dest = options.pageNumber != null ? pages[options.pageNumber] : this.document.page.dictionary;
+    const result = new PDFOutline(this.document, this.dictionary, title, dest, options);
     this.children.push(result);
     return result;
   }
@@ -4181,7 +4436,7 @@ var OutlineMixin = {
     this.outline.endOutline();
     if (this.outline.children.length > 0) {
       this._root.data.Outlines = this.outline.dictionary;
-      return this._root.data.PageMode = 'UseOutlines';
+      return this._root.data.PageMode = this._root.data.PageMode || 'UseOutlines';
     }
   }
 };
@@ -4199,9 +4454,7 @@ class PDFStructureContent {
 }
 
 class PDFStructureElement {
-  constructor(document, type) {
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    let children = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  constructor(document, type, options = {}, children = null) {
     this.document = document;
     this._attached = false;
     this._ended = false;
@@ -4214,21 +4467,41 @@ class PDFStructureElement {
       children = options;
       options = {};
     }
-    if (typeof options.title !== 'undefined') {
+    if (options.title) {
       data.T = new String(options.title);
     }
-    if (typeof options.lang !== 'undefined') {
+    if (options.lang) {
       data.Lang = new String(options.lang);
     }
-    if (typeof options.alt !== 'undefined') {
+    if (options.alt) {
       data.Alt = new String(options.alt);
     }
-    if (typeof options.expanded !== 'undefined') {
+    if (options.expanded) {
       data.E = new String(options.expanded);
     }
-    if (typeof options.actual !== 'undefined') {
+    if (options.actual) {
       data.ActualText = new String(options.actual);
     }
+    const hasBbox = Array.isArray(options.bbox) && options.bbox.length === 4;
+    const hasPlacement = typeof options.placement === 'string';
+    if (hasBbox || hasPlacement) {
+      const attrs = {
+        O: 'Layout'
+      };
+      attrs.Placement = hasPlacement ? options.placement : 'Block';
+      if (hasBbox) {
+        const height = document.page.height;
+        attrs.BBox = [options.bbox[0], height - options.bbox[3], options.bbox[2], height - options.bbox[1]];
+      }
+      data.A = attrs;
+    }
+    if (options.scope) {
+      data.A = {
+        ...(data.A || {}),
+        O: 'Table',
+        Scope: options.scope
+      };
+    }
     this._children = [];
     if (children) {
       if (!Array.isArray(children)) {
@@ -4254,6 +4527,9 @@ class PDFStructureElement {
     if (child instanceof PDFStructureContent) {
       this._addContentToParentTree(child);
     }
+    if (child instanceof PDFAnnotationReference) {
+      this._addAnnotationToParentTree(child.annotationRef);
+    }
     if (typeof child === 'function' && this._attached) {
       child = this._contentForClosure(child);
     }
@@ -4261,15 +4537,20 @@ class PDFStructureElement {
     return this;
   }
   _addContentToParentTree(content) {
-    content.refs.forEach(_ref => {
-      let {
-        pageRef,
-        mcid
-      } = _ref;
+    content.refs.forEach(({
+      pageRef,
+      mcid
+    }) => {
       const pageStructParents = this.document.getStructParentTree().get(pageRef.data.StructParents);
       pageStructParents[mcid] = this.dictionary;
     });
   }
+  _addAnnotationToParentTree(annotRef) {
+    const parentTreeKey = this.document.createStructParentTreeNextKey();
+    annotRef.data.StructParent = parentTreeKey;
+    const parentTree = this.document.getStructParentTree();
+    parentTree.add(parentTreeKey, this.dictionary);
+  }
   setParent(parentRef) {
     if (this.dictionary.data.P) {
       throw new Error(`Structure element added to more than one parent`);
@@ -4301,11 +4582,17 @@ class PDFStructureElement {
     this._flush();
   }
   _isValidChild(child) {
-    return child instanceof PDFStructureElement || child instanceof PDFStructureContent || typeof child === 'function';
+    return child instanceof PDFStructureElement || child instanceof PDFStructureContent || child instanceof PDFAnnotationReference || typeof child === 'function';
   }
   _contentForClosure(closure) {
     const content = this.document.markStructureContent(this.dictionary.data.S);
+    const prevStructElement = this.document._currentStructureElement;
+    this.document._currentStructureElement = this;
+    const wasEnded = this._ended;
+    this._ended = false;
     closure();
+    this._ended = wasEnded;
+    this.document._currentStructureElement = prevStructElement;
     this.document.endMarkedContent();
     this._addContentToParentTree(content);
     return content;
@@ -4340,11 +4627,10 @@ class PDFStructureElement {
       this.dictionary.data.K.push(child.dictionary);
     }
     if (child instanceof PDFStructureContent) {
-      child.refs.forEach(_ref2 => {
-        let {
-          pageRef,
-          mcid
-        } = _ref2;
+      child.refs.forEach(({
+        pageRef,
+        mcid
+      }) => {
         if (!this.dictionary.data.Pg) {
           this.dictionary.data.Pg = pageRef;
         }
@@ -4359,6 +4645,15 @@ class PDFStructureElement {
         }
       });
     }
+    if (child instanceof PDFAnnotationReference) {
+      const pageRef = this.document.page.dictionary;
+      const objr = {
+        Type: 'OBJR',
+        Obj: child.annotationRef,
+        Pg: pageRef
+      };
+      this.dictionary.data.K.push(objr);
+    }
   }
 }
 
@@ -4382,8 +4677,7 @@ var MarkingsMixin = {
       this.getStructTreeRoot();
     }
   },
-  markContent(tag) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  markContent(tag, options = null) {
     if (tag === 'Artifact' || options && options.mcid) {
       let toClose = 0;
       this.page.markings.forEach(marking => {
@@ -4438,8 +4732,7 @@ var MarkingsMixin = {
     this.addContent(`/${tag} ${PDFObject.convert(dictionary)} BDC`);
     return this;
   },
-  markStructureContent(tag) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  markStructureContent(tag, options = {}) {
     const pageStructParents = this.getStructParentTree().get(this.page.structParentTreeKey);
     const mcid = pageStructParents.length;
     pageStructParents.push(null);
@@ -4454,11 +4747,16 @@ var MarkingsMixin = {
   endMarkedContent() {
     this.page.markings.pop();
     this.addContent('EMC');
+    if (this._textOptions) {
+      delete this._textOptions.link;
+      delete this._textOptions.goTo;
+      delete this._textOptions.destination;
+      delete this._textOptions.underline;
+      delete this._textOptions.strike;
+    }
     return this;
   },
-  struct(type) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    let children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  struct(type, options = {}, children = null) {
     return new PDFStructureElement(this, type, options, children);
   },
   addStructure(structElem) {
@@ -4623,15 +4921,13 @@ var AcroFormMixin = {
     }
     return this;
   },
-  formField(name) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  formField(name, options = {}) {
     let fieldDict = this._fieldDict(name, null, options);
     let fieldRef = this.ref(fieldDict);
     this._addToParent(fieldRef);
     return fieldRef;
   },
-  formAnnotation(name, type, x, y, w, h) {
-    let options = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {};
+  formAnnotation(name, type, x, y, w, h, options = {}) {
     let fieldDict = this._fieldDict(name, type, options);
     fieldDict.Subtype = 'Widget';
     if (fieldDict.F === undefined) {
@@ -4641,28 +4937,22 @@ var AcroFormMixin = {
     let annotRef = this.page.annotations[this.page.annotations.length - 1];
     return this._addToParent(annotRef);
   },
-  formText(name, x, y, w, h) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  formText(name, x, y, w, h, options = {}) {
     return this.formAnnotation(name, 'text', x, y, w, h, options);
   },
-  formPushButton(name, x, y, w, h) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  formPushButton(name, x, y, w, h, options = {}) {
     return this.formAnnotation(name, 'pushButton', x, y, w, h, options);
   },
-  formCombo(name, x, y, w, h) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  formCombo(name, x, y, w, h, options = {}) {
     return this.formAnnotation(name, 'combo', x, y, w, h, options);
   },
-  formList(name, x, y, w, h) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  formList(name, x, y, w, h, options = {}) {
     return this.formAnnotation(name, 'list', x, y, w, h, options);
   },
-  formRadioButton(name, x, y, w, h) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  formRadioButton(name, x, y, w, h, options = {}) {
     return this.formAnnotation(name, 'radioButton', x, y, w, h, options);
   },
-  formCheckbox(name, x, y, w, h) {
-    let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {};
+  formCheckbox(name, x, y, w, h, options = {}) {
     return this.formAnnotation(name, 'checkbox', x, y, w, h, options);
   },
   _addToParent(fieldRef) {
@@ -4677,8 +4967,7 @@ var AcroFormMixin = {
     }
     return this;
   },
-  _fieldDict(name, type) {
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  _fieldDict(name, type, options = {}) {
     if (!this._acroform) {
       throw new Error('Call document.initForm() method before adding form elements to document');
     }
@@ -4867,8 +5156,7 @@ var AcroFormMixin = {
 };
 
 var AttachmentsMixin = {
-  file(src) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  file(src, options = {}) {
     options.name = options.name || src;
     options.relationship = options.relationship || 'Unspecified';
     const refBody = {
@@ -4887,7 +5175,7 @@ var AttachmentsMixin = {
       const match = /^data:(.*?);base64,(.*)$/.exec(src);
       if (match) {
         if (match[1]) {
-          refBody.Subtype = match[1].replace('/', '#2F');
+          refBody.Subtype = escapeName(match[1]);
         }
         data = Buffer.from(match[2], 'base64');
       } else {
@@ -4910,9 +5198,9 @@ var AttachmentsMixin = {
       refBody.Params.ModDate = options.modifiedDate;
     }
     if (options.type) {
-      refBody.Subtype = options.type.replace('/', '#2F');
+      refBody.Subtype = escapeName(options.type);
     }
-    const checksum = CryptoJS.MD5(CryptoJS.lib.WordArray.create(new Uint8Array(data)));
+    const checksum = md5Hex(new Uint8Array(data));
     refBody.Params.CheckSum = new String(checksum);
     refBody.Params.Size = data.byteLength;
     let ref;
@@ -5051,10 +5339,10 @@ const ROW_FIELDS = ['height', 'minHeight', 'maxHeight'];
 const COLUMN_FIELDS = ['width', 'minWidth', 'maxWidth'];
 function memoize(fn, maxSize) {
   const cache = new Map();
-  return function () {
-    const key = arguments.length <= 0 ? undefined : arguments[0];
+  return function (...args) {
+    const key = args[0];
     if (!cache.has(key)) {
-      cache.set(key, fn(...arguments));
+      cache.set(key, fn(...args));
       if (cache.size > maxSize) cache.delete(cache.keys().next());
     }
     return cache.get(key);
@@ -5063,12 +5351,9 @@ function memoize(fn, maxSize) {
 function isObject(item) {
   return item && typeof item === 'object' && !Array.isArray(item);
 }
-function deepMerge(target) {
+function deepMerge(target, ...sources) {
   if (!isObject(target)) return target;
   target = deepClone(target);
-  for (var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-    sources[_key - 1] = arguments[_key];
-  }
   for (const source of sources) {
     if (isObject(source)) {
       for (const key in source) {
@@ -5097,14 +5382,8 @@ function normalizedDefaultStyle(defaultStyleInternal) {
   if (typeof defaultStyle !== 'object') defaultStyle = {
     text: defaultStyle
   };
-  const defaultRowStyle = Object.fromEntries(Object.entries(defaultStyle).filter(_ref => {
-    let [k] = _ref;
-    return ROW_FIELDS.includes(k);
-  }));
-  const defaultColStyle = Object.fromEntries(Object.entries(defaultStyle).filter(_ref2 => {
-    let [k] = _ref2;
-    return COLUMN_FIELDS.includes(k);
-  }));
+  const defaultRowStyle = Object.fromEntries(Object.entries(defaultStyle).filter(([k]) => ROW_FIELDS.includes(k)));
+  const defaultColStyle = Object.fromEntries(Object.entries(defaultStyle).filter(([k]) => COLUMN_FIELDS.includes(k)));
   defaultStyle.padding = normalizeSides(defaultStyle.padding);
   defaultStyle.border = normalizeSides(defaultStyle.border);
   defaultStyle.borderColor = normalizeSides(defaultStyle.borderColor);
@@ -5564,7 +5843,7 @@ function renderRow(row, rowIndex) {
 function renderCell(cell, rowStruct) {
   const cellRenderer = () => {
     if (cell.backgroundColor != null) {
-      this.document.save().rect(cell.x, cell.y, cell.width, cell.height).fill(cell.backgroundColor).restore();
+      this.document.save().fillColor(cell.backgroundColor).rect(cell.x, cell.y, cell.width, cell.height).fill().restore();
     }
     renderBorder.call(this, cell.border, cell.borderColor, cell.x, cell.y, cell.width, cell.height);
     if (cell.debug) {
@@ -5621,34 +5900,30 @@ function renderCellText(cell) {
   if (cell.font) doc.font(rollbackFont, rollbackFontFamily, rollbackFontSize);
 }
 function renderBorder(border, borderColor, x, y, width, height, mask) {
-  border = Object.fromEntries(Object.entries(border).map(_ref => {
-    let [k, v] = _ref;
-    return [k, mask && !mask[k] ? 0 : v];
-  }));
+  border = Object.fromEntries(Object.entries(border).map(([k, v]) => [k, mask && !mask[k] ? 0 : v]));
   const doc = this.document;
   if ([border.right, border.bottom, border.left].every(val => val === border.top)) {
     if (border.top > 0) {
-      doc.save().lineWidth(border.top).rect(x, y, width, height).stroke(borderColor.top).restore();
+      doc.save().lineWidth(border.top).strokeColor(borderColor.top).rect(x, y, width, height).stroke().restore();
     }
   } else {
     if (border.top > 0) {
-      doc.save().lineWidth(border.top).moveTo(x, y).lineTo(x + width, y).stroke(borderColor.top).restore();
+      doc.save().lineWidth(border.top).moveTo(x, y).strokeColor(borderColor.top).lineTo(x + width, y).stroke().restore();
     }
     if (border.right > 0) {
-      doc.save().lineWidth(border.right).moveTo(x + width, y).lineTo(x + width, y + height).stroke(borderColor.right).restore();
+      doc.save().lineWidth(border.right).moveTo(x + width, y).strokeColor(borderColor.right).lineTo(x + width, y + height).stroke().restore();
     }
     if (border.bottom > 0) {
-      doc.save().lineWidth(border.bottom).moveTo(x + width, y + height).lineTo(x, y + height).stroke(borderColor.bottom).restore();
+      doc.save().lineWidth(border.bottom).moveTo(x + width, y + height).strokeColor(borderColor.bottom).lineTo(x, y + height).stroke().restore();
     }
     if (border.left > 0) {
-      doc.save().lineWidth(border.left).moveTo(x, y + height).lineTo(x, y).stroke(borderColor.left).restore();
+      doc.save().lineWidth(border.left).moveTo(x, y + height).strokeColor(borderColor.left).lineTo(x, y).stroke().restore();
     }
   }
 }
 
 class PDFTable {
-  constructor(document) {
-    let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  constructor(document, opts = {}) {
     this.document = document;
     this.opts = Object.freeze(opts);
     normalizeTable.call(this);
@@ -5660,8 +5935,7 @@ class PDFTable {
       return this.end();
     }
   }
-  row(row) {
-    let lastRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  row(row, lastRow = false) {
     if (this._ended) {
       throw new Error(`Table was marked as ended on row ${this._currRowIndex}`);
     }
@@ -5712,8 +5986,7 @@ class PDFMetadata {
         <?xpacket end="w"?>
         `);
   }
-  append(xml) {
-    let newline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  append(xml, newline = true) {
     this._metadata = this._metadata.concat(xml);
     if (newline) this._metadata = this._metadata.concat('\n');
   }
@@ -5733,8 +6006,7 @@ var MetadataMixin = {
   initMetadata() {
     this.metadata = new PDFMetadata();
   },
-  appendXML(xml) {
-    let newline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  appendXML(xml, newline = true) {
     this.metadata.append(xml, newline);
   },
   _addInfo() {
@@ -5781,7 +6053,7 @@ var MetadataMixin = {
     }
     this.appendXML(`
         <rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
-            <pdf:Producer>${this.info.Creator}</pdf:Producer>`, false);
+            <pdf:Producer>${this.info.Producer}</pdf:Producer>`, false);
     if (this.info.Keywords) {
       this.appendXML(`
             <pdf:Keywords>${this.info.Keywords}</pdf:Keywords>`, false);
@@ -5808,8 +6080,7 @@ var MetadataMixin = {
 };
 
 class PDFDocument extends stream.Readable {
-  constructor() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(options = {}) {
     super(options);
     this.options = options;
     switch (options.pdfVersion) {
@@ -5853,6 +6124,10 @@ class PDFDocument extends stream.Readable {
     if (this.options.lang) {
       this._root.data.Lang = new String(this.options.lang);
     }
+    if (this.options.pageLayout) {
+      const layout = this.options.pageLayout;
+      this._root.data.PageLayout = layout.charAt(0).toUpperCase() + layout.slice(1);
+    }
     this.page = null;
     this.initMetadata();
     this.initColor();
@@ -5937,10 +6212,7 @@ class PDFDocument extends stream.Readable {
       page.end();
     }
   }
-  addNamedDestination(name) {
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
+  addNamedDestination(name, ...args) {
     if (args.length === 0) {
       args = ['XYZ', null, null, null];
     }