pdfkit 0.17.2 → 0.18.0

package/js/pdfkit.js

@@ -2,12 +2,14 @@
 
 var stream = require('stream');
 var zlib = require('zlib');
-var CryptoJS = require('crypto-js');
+var utils = require('@noble/hashes/utils');
+var md5 = require('js-md5');
+var sha256 = require('@noble/hashes/sha256');
+var aes = require('@noble/ciphers/aes');
 var fs = require('fs');
 var fontkit = require('fontkit');
 var events = require('events');
 var LineBreaker = require('linebreak');
-var exif = require('jpeg-exif');
 var PNG = require('png-js');
 
 class PDFAbstractReference {
@@ -359,6 +361,7 @@ class PDFPage {
     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];
@@ -374,7 +377,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 = [];
   }
@@ -447,6 +451,58 @@ class PDFNameTree extends PDFTree {
   }
 }
 
+function md5Hash(data) {
+  return new Uint8Array(md5.arrayBuffer(data));
+}
+function md5Hex(data) {
+  return md5(data);
+}
+
+function sha256Hash(data) {
+  return sha256.sha256(data);
+}
+
+function aesCbcEncrypt(data, key, iv, padding = true) {
+  return aes.cbc(key, iv, {
+    disablePadding: !padding
+  }).encrypt(data);
+}
+function aesEcbEncrypt(data, key) {
+  return aes.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);
+  if (globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    require('crypto').randomFillSync(bytes);
+  }
+  return bytes;
+}
+
 function inRange(value, rangeGroup) {
   if (value < rangeGroup[0]) return false;
   let startRange = 0;
@@ -545,10 +601,10 @@ 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, options = {}) {
     if (!options.ownerPassword && !options.userPassword) {
@@ -640,8 +696,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) {
@@ -651,10 +707,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;
@@ -669,36 +725,37 @@ 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 = utils.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(utils.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(utils.concatBytes(iv, encrypted));
     };
-    return buffer => wordArrayToBuffer(iv.clone().concat(CryptoJS.AES.encrypt(CryptoJS.lib.WordArray.create(buffer), key, options).ciphertext));
   }
   end() {
     this.dictionary.end();
@@ -749,89 +806,97 @@ function getPermissionsR3(permissionObject = {}) {
   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(utils.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 = utils.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(utils.concatBytes(processedUserPassword, validationSalt));
+  return utils.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(utils.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(utils.concatBytes(processedOwnerPassword, validationSalt, userPasswordEntry));
+  return utils.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(utils.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(password = '') {
-  const out = Buffer.alloc(32);
+  const out = new Uint8Array(32);
   const length = password.length;
   let index = 0;
   while (index < length && index < 32) {
@@ -846,26 +911,16 @@ function processPasswordR2R3R4(password = '') {
     out[index] = PASSWORD_PADDING[index - length];
     index++;
   }
-  return CryptoJS.lib.WordArray.create(out);
+  return out;
 }
 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];
 
@@ -1473,86 +1528,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;
         }
-        ret[ret.length] = {
-          cmd,
+      } else {
+        if (args.length !== 0) {
+          return pathData;
+        }
+      }
+      command = c;
+      args = [];
+      argsCount = parameters[command];
+      canHaveComma = false;
+      if (argsCount === 0) {
+        pathData.push({
+          command,
           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;
+      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 (args.length === params) {
-        ret[ret.length] = {
-          cmd,
-          args
-        };
-        args = [+curArg];
-        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 (cmd === 'm') {
-          cmd = 'l';
+        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);
     }
   }
 };
@@ -2584,7 +2729,7 @@ begincmap
 1 begincodespacerange
 <0000><ffff>
 endcodespacerange
-1 beginbfrange
+${ranges.length} beginbfrange
 ${ranges.join('\n')}
 endbfrange
 endcmap
@@ -2763,6 +2908,7 @@ class LineWrapper extends events.EventEmitter {
     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;
@@ -3004,7 +3150,13 @@ class LineWrapper extends events.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);
       }
@@ -3408,7 +3560,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);
@@ -3537,6 +3693,47 @@ var TextMixin = {
   }
 };
 
+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 = data.readUInt16BE(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 = data.readUInt16BE(pos);
+    if (marker === 0xffe1 && pos + 8 <= data.length) {
+      const exifHeader = data.subarray(pos + 2, pos + 8).toString('binary');
+      if (exifHeader === 'Exif\x00\x00') {
+        const tiffStart = pos + 8;
+        if (tiffStart + 8 > data.length) return null;
+        const byteOrder = data.subarray(tiffStart, tiffStart + 2).toString('ascii');
+        const isLittleEndian = byteOrder === 'II';
+        if (!isLittleEndian && byteOrder !== 'MM') return null;
+        const read16 = isLittleEndian ? o => data.readUInt16LE(o) : o => data.readUInt16BE(o);
+        const read32 = isLittleEndian ? o => data.readUInt32LE(o) : o => data.readUInt32BE(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',
@@ -3551,9 +3748,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)) {
@@ -3705,12 +3904,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();
     });
@@ -3939,6 +4142,12 @@ var ImagesMixin = {
   }
 };
 
+class PDFAnnotationReference {
+  constructor(annotationRef) {
+    this.annotationRef = annotationRef;
+  }
+}
+
 var AnnotationsMixin = {
   annotate(x, y, w, h, options) {
     options.Type = 'Annot';
@@ -3956,12 +4165,18 @@ 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;
   },
@@ -4005,6 +4220,9 @@ 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, options = {}) {
@@ -4076,15 +4294,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, options = {
-    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;
@@ -4095,10 +4324,10 @@ class PDFOutline {
     this.dictionary = this.document.ref(this.outlineData);
     this.children = [];
   }
-  addItem(title, options = {
-    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;
   }
@@ -4134,7 +4363,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';
     }
   }
 };
@@ -4205,6 +4434,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);
     }
@@ -4220,6 +4452,12 @@ class PDFStructureElement {
       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`);
@@ -4251,11 +4489,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;
@@ -4308,6 +4552,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);
+    }
   }
 }
 
@@ -4401,6 +4654,13 @@ 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, options = {}, children = null) {
@@ -4847,7 +5107,7 @@ var AttachmentsMixin = {
     if (options.type) {
       refBody.Subtype = options.type.replace('/', '#2F');
     }
-    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;
@@ -5490,7 +5750,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) {
@@ -5551,20 +5811,20 @@ function renderBorder(border, borderColor, x, y, width, height, mask) {
   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();
     }
   }
 }
@@ -5771,6 +6031,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();