@kittl/pdfkit 0.17.3 → 0.17.5

package/js/pdfkit.es.js

@@ -1,11 +1,13 @@
 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/sha256';
+import { cbc, ecb } from '@noble/ciphers/aes';
 import fs from 'fs';
 import * as fontkit from 'fontkit';
 import { EventEmitter } from 'events';
 import LineBreaker from 'linebreak';
-import exif from 'jpeg-exif';
 import PNG from 'png-js';
 
 class PDFAbstractReference {
@@ -363,6 +365,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];
@@ -378,7 +381,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 = [];
   }
@@ -434,6 +438,7 @@ class PDFPage {
     for (let color of Object.values(this.document.spotColors)) {
       this.resources.data.ColorSpace[color.id] = color;
     }
+    this.document._writeSpaceToResources(this.resources);
     this.resources.end();
     return this.content.end();
   }
@@ -451,6 +456,59 @@ 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) {
+  let padding = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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);
+  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;
@@ -551,10 +609,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) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -648,8 +706,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 +717,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,36 +735,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 = 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();
@@ -759,90 +818,98 @@ 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);
+  const out = new Uint8Array(32);
   const length = password.length;
   let index = 0;
   while (index < length && index < 32) {
@@ -857,27 +924,17 @@ 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] : '';
   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];
 
@@ -897,14 +954,18 @@ class PDFGradient$1 {
     }
     color = this.doc._normalizeColor(color);
     if (this.stops.length === 0) {
-      if (color.length === 3) {
-        this._colorSpace = 'DeviceRGB';
-      } else if (color.length === 4) {
-        this._colorSpace = 'DeviceCMYK';
-      } else if (color.length === 1) {
-        this._colorSpace = 'DeviceGray';
+      if (this._activeColorProfile) {
+        this._colorSpace = this._activeColorProfile.ref;
       } else {
-        throw new Error('Unknown color space');
+        if (color.length === 3) {
+          this._colorSpace = 'DeviceRGB';
+        } else if (color.length === 4) {
+          this._colorSpace = 'DeviceCMYK';
+        } else if (color.length === 1) {
+          this._colorSpace = 'DeviceGray';
+        } else {
+          throw new Error('Unknown color space');
+        }
       }
     } else if (this._colorSpace === 'DeviceRGB' && color.length !== 3 || this._colorSpace === 'DeviceCMYK' && color.length !== 4 || this._colorSpace === 'DeviceGray' && color.length !== 1) {
       throw new Error('All gradient stops must use the same color space');
@@ -1175,6 +1236,7 @@ var ColorMixin = {
     this._opacityCount = 0;
     this._patternCount = 0;
     this._gradCount = 0;
+    this._activeColorProfile = null;
   },
   _normalizeColor(color) {
     if (typeof color === 'string') {
@@ -1234,6 +1296,13 @@ var ColorMixin = {
     if (color instanceof SpotColor) {
       return color.id;
     }
+    if (this._activeColorProfile) {
+      const profile = this._activeColorProfile;
+      if (profile.channels !== color.length) {
+        throw Error("Profile channels don't match color channels");
+      }
+      return profile.label;
+    }
     return color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
   },
   fillColor(color, opacity) {
@@ -1263,6 +1332,18 @@ var ColorMixin = {
     this._doOpacity(null, opacity);
     return this;
   },
+  beginColorSpace(label) {
+    const profile = this._colorProfiles[label];
+    if (!profile) {
+      throw Error('Invalid color space label, the profile should be set first');
+    }
+    this._activeColorProfile = profile;
+    return this;
+  },
+  endColorSpace() {
+    this._activeColorProfile = null;
+    return this;
+  },
   _doOpacity(fillOpacity, strokeOpacity) {
     let dictionary, name;
     if (fillOpacity == null && strokeOpacity == null) {
@@ -1485,86 +1566,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 (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);
     }
   }
 };
@@ -2603,7 +2774,7 @@ begincmap
 1 begincodespacerange
 <0000><ffff>
 endcodespacerange
-1 beginbfrange
+${ranges.length} beginbfrange
 ${ranges.join('\n')}
 endbfrange
 endcmap
@@ -2788,6 +2959,7 @@ class LineWrapper extends 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;
@@ -3029,7 +3201,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);
       }
@@ -3439,7 +3617,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 +3750,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',
@@ -3582,9 +3805,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)) {
@@ -3736,12 +3961,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();
     });
@@ -3754,16 +3983,108 @@ class PNGImage {
   }
 }
 
+class BitmapImage {
+  constructor(data, label, properties) {
+    this.label = label;
+    this.data = data;
+    this.width = properties.width;
+    this.height = properties.height;
+    this.channels = properties.channels;
+    this.colorSpace = properties.colorSpace;
+    this.hasAlphaChannel = properties.hasAlphaChannel;
+    this.obj = null;
+  }
+  embed(document) {
+    if (this.obj) {
+      return;
+    }
+    this.document = document;
+    if (!(this.data instanceof Uint8Array && this.data.length === this.channels * this.width * this.height)) {
+      throw Error("Invalid bitmap, data doesn't match the given properties.");
+    }
+    if (this.colorSpace) {
+      const profile = this.document._colorProfiles[this.colorSpace];
+      if (!profile) {
+        throw Error("PDFDocument doesn't support bitmap color space.");
+      }
+      const channels = this.hasAlphaChannel ? this.channels - 1 : this.channels;
+      if (profile.channels !== channels) {
+        throw Error("Color profile doesn't support image channels");
+      }
+      this.colorSpace = profile.ref;
+    } else {
+      if (!this.hasAlphaChannel) {
+        this.colorSpace = this.channels === 4 ? 'DeviceCMYK' : 'DeviceRGB';
+      } else {
+        this.colorSpace = this.channels === 5 ? 'DeviceCMYK' : 'DeviceRGB';
+      }
+    }
+    let pixelData = this.data;
+    let alphaData = undefined;
+    if (this.hasAlphaChannel) {
+      const pixelChannels = this.channels - 1;
+      pixelData = new Uint8Array(pixelChannels * this.width * this.height);
+      alphaData = new Uint8Array(this.width * this.height);
+      if (this.channels === 4) {
+        for (let src = 0, dst = 0, a = 0; a < this.data.length; src += 4, dst += 3, a++) {
+          pixelData[dst] = this.data[src];
+          pixelData[dst + 1] = this.data[src + 1];
+          pixelData[dst + 2] = this.data[src + 2];
+          alphaData[a] = this.data[src + 3];
+        }
+      } else if (this.channels === 5) {
+        for (let src = 0, dst = 0, a = 0; a < this.data.length; src += 5, dst += 4, a++) {
+          pixelData[dst] = this.data[src];
+          pixelData[dst + 1] = this.data[src + 1];
+          pixelData[dst + 2] = this.data[src + 2];
+          pixelData[dst + 3] = this.data[src + 3];
+          alphaData[a] = this.data[src + 4];
+        }
+      } else {
+        for (let src = 0, dst = 0, a = 0; a < this.data.length; src += this.channels, dst += pixelChannels, a++) {
+          for (let j = 0; j < pixelChannels; j++) {
+            pixelData[dst + j] = this.data[src + j];
+          }
+          alphaData[a] = this.data[src + pixelChannels];
+        }
+      }
+    }
+    this.obj = this.document.ref({
+      Type: 'XObject',
+      Subtype: 'Image',
+      BitsPerComponent: 8,
+      Width: this.width,
+      Height: this.height,
+      ColorSpace: this.colorSpace
+    });
+    if (alphaData) {
+      const sMask = this.document.ref({
+        Type: 'XObject',
+        Subtype: 'Image',
+        Height: this.height,
+        Width: this.width,
+        BitsPerComponent: 8,
+        ColorSpace: 'DeviceGray',
+        Decode: [0, 1]
+      });
+      sMask.end(alphaData);
+      this.obj.data['SMask'] = sMask;
+    }
+    this.obj.end(pixelData);
+    this.data = null;
+  }
+}
+
 class PDFImage {
-  static open(src, label) {
+  static open(src, label, properties) {
     let data;
-    if (Buffer.isBuffer(src)) {
+    if (src instanceof Uint8Array || Buffer.isBuffer(src)) {
       data = src;
     } else if (src instanceof ArrayBuffer) {
       data = Buffer.from(new Uint8Array(src));
     } else {
       const split = src.split(',');
-      if (split[0].startsWith('data:') && split[0].endsWith(';base64,')) {
+      if (split[0].startsWith('data:') && split[0].endsWith(';base64')) {
         if (split.length === 1) {
           throw Error('Empty base64');
         }
@@ -3775,6 +4096,9 @@ class PDFImage {
         }
       }
     }
+    if (properties?.isBitmap) {
+      return new BitmapImage(data, label, properties);
+    }
     if (data[0] === 0xff && data[1] === 0xd8) {
       return new JPEG(data, label);
     } else if (data[0] === 0x89 && data.toString('ascii', 1, 4) === 'PNG') {
@@ -3959,13 +4283,13 @@ var ImagesMixin = {
     this.restore();
     return this;
   },
-  openImage(src) {
+  openImage(src, properties) {
     let image;
     if (typeof src === 'string') {
       image = this._imageRegistry[src];
     }
     if (!image) {
-      image = PDFImage.open(src, `I${++this._imageCount}`);
+      image = PDFImage.open(src, `I${++this._imageCount}`, properties);
       if (typeof src === 'string') {
         this._imageRegistry[src] = image;
       }
@@ -3974,6 +4298,12 @@ var ImagesMixin = {
   }
 };
 
+class PDFAnnotationReference {
+  constructor(annotationRef) {
+    this.annotationRef = annotationRef;
+  }
+}
+
 var AnnotationsMixin = {
   annotate(x, y, w, h, options) {
     options.Type = 'Annot';
@@ -3991,12 +4321,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;
   },
@@ -4043,6 +4379,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) {
@@ -4124,16 +4463,27 @@ 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
-    };
+    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 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;
@@ -4145,10 +4495,10 @@ class PDFOutline {
     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);
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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;
   }
@@ -4184,7 +4534,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';
     }
   }
 };
@@ -4257,6 +4607,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);
     }
@@ -4273,6 +4626,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`);
@@ -4304,11 +4663,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;
@@ -4362,6 +4727,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);
+    }
   }
 }
 
@@ -4457,6 +4831,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) {
@@ -4915,7 +5296,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;
@@ -4975,6 +5356,9 @@ var PDFA = {
     this._addColorOutputIntent();
   },
   _addColorOutputIntent() {
+    if (this._root.data.OutputIntents && this._root.data.OutputIntents.length !== 0) {
+      return;
+    }
     const iccProfile = fs.readFileSync(`${__dirname}/data/sRGB_IEC61966_2_1.icc`);
     const colorProfileRef = this.ref({
       Length: iccProfile.length,
@@ -5567,7 +5951,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) {
@@ -5631,20 +6015,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();
     }
   }
 }
@@ -5810,6 +6194,73 @@ var MetadataMixin = {
   }
 };
 
+class ICCProfile {
+  constructor(label, data, channels, alternate) {
+    this.label = label;
+    this.data = data;
+    this.channels = channels;
+    this.alternate = alternate;
+    this.ref = null;
+    this.streamRef = null;
+  }
+  embed(document) {
+    if (this.ref) {
+      return;
+    }
+    this.document = document;
+    this.streamRef = this.document.ref({
+      Alternate: this.alternate,
+      N: this.channels,
+      Length: this.data.length
+    });
+    this.streamRef.end(this.data);
+    this.ref = this.document.ref([`ICCBased ${this.streamRef}`]);
+    this.ref.end();
+    this.data = null;
+  }
+}
+
+var ColorSpaceMixin = {
+  initColorSpace() {
+    this._colorProfiles = {};
+  },
+  iccProfile(label, data, channels, alternate) {
+    const profile = new ICCProfile(label, data, channels, alternate);
+    profile.embed(this);
+    this._colorProfiles[label] = profile;
+    return this;
+  },
+  _writeSpaceToResources(resources) {
+    resources.data.ColorSpace = resources.data.ColorSpace || {};
+    Object.entries(this._colorProfiles).forEach(_ref => {
+      let [k, v] = _ref;
+      resources.data.ColorSpace[k] = v.ref;
+    });
+  }
+};
+
+var OutputIntent = {
+  initOutputIntent() {
+    this._root.data.OutputIntents = this._root.data.OutputIntents || [];
+  },
+  outputIntent(type, s, info, outputConditionIdentifier, destOutputProfileLabel) {
+    const profile = this._colorProfiles[destOutputProfileLabel];
+    if (profile) {
+      throw Error('Invalid color profile label, the profile should be set first');
+    }
+    const intentRef = this.ref({
+      Type: type,
+      S: s,
+      Info: info,
+      OutputConditionIdentifier: outputConditionIdentifier,
+      DestOutputProfile: profile.ref
+    });
+    intentRef.end();
+    this._root.data.OutputIntents.push(intentRef);
+    return this;
+  }
+};
+
 class PDFDocument extends stream.Readable {
   constructor() {
     let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -5856,8 +6307,13 @@ 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.initColorSpace();
     this.initColor();
     this.initVector();
     this.initFonts(options.font);
@@ -5867,6 +6323,7 @@ class PDFDocument extends stream.Readable {
     this.initMarkings(options);
     this.initTables();
     this.initSubset(options);
+    this.initOutputIntent();
     this.info = {
       Producer: 'PDFKit',
       Creator: 'PDFKit',
@@ -6068,6 +6525,7 @@ const mixin = methods => {
   Object.assign(PDFDocument.prototype, methods);
 };
 mixin(MetadataMixin);
+mixin(ColorSpaceMixin);
 mixin(ColorMixin);
 mixin(VectorMixin);
 mixin(FontsMixin);
@@ -6080,6 +6538,7 @@ mixin(AcroFormMixin);
 mixin(AttachmentsMixin);
 mixin(SubsetMixin);
 mixin(TableMixin);
+mixin(OutputIntent);
 PDFDocument.LineWrapper = LineWrapper;
 
 export { PDFDocument as default };