pdfkit 0.15.2 → 0.17.0

package/js/pdfkit.js

@@ -10,23 +10,15 @@ var LineBreaker = require('linebreak');
 var exif = require('jpeg-exif');
 var PNG = require('png-js');
 
-/*
-PDFAbstractReference - abstract class for PDF reference
-*/
-
 class PDFAbstractReference {
   toString() {
     throw new Error('Must be implemented by subclasses');
   }
 }
 
-/*
-PDFTree - abstract base class for name and number tree objects
-*/
 class PDFTree {
   constructor(options = {}) {
     this._items = {};
-    // disable /Limits output for this tree
     this.limits = typeof options.limits === 'boolean' ? options.limits : true;
   }
   add(key, val) {
@@ -36,7 +28,6 @@ class PDFTree {
     return this._items[key];
   }
   toString() {
-    // Needs to be sorted by key
     const sortedKeys = Object.keys(this._items).sort((a, b) => this._compareKeys(a, b));
     const out = ['<<'];
     if (this.limits && sortedKeys.length > 1) {
@@ -52,23 +43,37 @@ class PDFTree {
     out.push('>>');
     return out.join('\n');
   }
-  _compareKeys( /*a, b*/
-  ) {
+  _compareKeys() {
     throw new Error('Must be implemented by subclasses');
   }
   _keysName() {
     throw new Error('Must be implemented by subclasses');
   }
-  _dataForKey( /*k*/
-  ) {
+  _dataForKey() {
     throw new Error('Must be implemented by subclasses');
   }
 }
 
-/*
-PDFObject - converts JavaScript types into their corresponding PDF types.
-By Devon Govett
-*/
+class SpotColor {
+  constructor(doc, name, C, M, Y, K) {
+    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', {
+      Range: [0, 1, 0, 1, 0, 1, 0, 1],
+      C0: [0, 0, 0, 0],
+      C1: this.values.map(value => value / 100),
+      FunctionType: 2,
+      Domain: [0, 1],
+      N: 1
+    }]);
+    this.ref.end();
+  }
+  toString() {
+    return `${this.ref.id} 0 R`;
+  }
+}
+
 const pad = (str, length) => (Array(length + 1).join('0') + str).slice(-length);
 const escapableRe = /[\n\r\t\b\f()\\]/g;
 const escapable = {
@@ -81,8 +86,6 @@ const escapable = {
   '(': '\\(',
   ')': '\\)'
 };
-
-// Convert little endian UTF-16 to big endian
 const swapBytes = function (buff) {
   const l = buff.length;
   if (l & 0x01) {
@@ -98,14 +101,10 @@ const swapBytes = function (buff) {
 };
 class PDFObject {
   static convert(object, encryptFn = null) {
-    // String literals are converted to the PDF name type
     if (typeof object === 'string') {
       return `/${object}`;
-
-      // String objects are converted to PDF strings (UTF-16)
     } else if (object instanceof String) {
       let string = object;
-      // Detect if this is a unicode string
       let isUnicode = false;
       for (let i = 0, end = string.length; i < end; i++) {
         if (string.charCodeAt(i) > 0x7f) {
@@ -113,39 +112,27 @@ class PDFObject {
           break;
         }
       }
-
-      // If so, encode it as big endian UTF-16
       let stringBuffer;
       if (isUnicode) {
         stringBuffer = swapBytes(Buffer.from(`\ufeff${string}`, 'utf16le'));
       } else {
         stringBuffer = Buffer.from(string.valueOf(), 'ascii');
       }
-
-      // Encrypt the string when necessary
       if (encryptFn) {
         string = encryptFn(stringBuffer).toString('binary');
       } else {
         string = stringBuffer.toString('binary');
       }
-
-      // Escape characters as required by the spec
       string = string.replace(escapableRe, c => escapable[c]);
       return `(${string})`;
-
-      // Buffers are converted to PDF hex strings
     } else if (Buffer.isBuffer(object)) {
       return `<${object.toString('hex')}>`;
-    } else if (object instanceof PDFAbstractReference || object instanceof PDFTree) {
+    } else if (object instanceof PDFAbstractReference || object instanceof PDFTree || object instanceof SpotColor) {
       return object.toString();
     } else if (object instanceof Date) {
       let string = `D:${pad(object.getUTCFullYear(), 4)}` + pad(object.getUTCMonth() + 1, 2) + pad(object.getUTCDate(), 2) + pad(object.getUTCHours(), 2) + pad(object.getUTCMinutes(), 2) + pad(object.getUTCSeconds(), 2) + 'Z';
-
-      // Encrypt the string when necessary
       if (encryptFn) {
         string = encryptFn(Buffer.from(string, 'ascii')).toString('binary');
-
-        // Escape characters as required by the spec
         string = string.replace(escapableRe, c => escapable[c]);
       }
       return `(${string})`;
@@ -174,10 +161,6 @@ class PDFObject {
   }
 }
 
-/*
-PDFReference - represents a reference to another object in the PDF object heirarchy
-By Devon Govett
-*/
 class PDFReference extends PDFAbstractReference {
   constructor(document, id, data = {}) {
     super();
@@ -190,7 +173,7 @@ class PDFReference extends PDFAbstractReference {
     this.buffer = [];
   }
   write(chunk) {
-    if (!Buffer.isBuffer(chunk)) {
+    if (!(chunk instanceof Uint8Array)) {
       chunk = Buffer.from(chunk + '\n', 'binary');
     }
     this.uncompressedLength += chunk.length;
@@ -200,14 +183,14 @@ class PDFReference extends PDFAbstractReference {
     this.buffer.push(chunk);
     this.data.Length += chunk.length;
     if (this.compress) {
-      return this.data.Filter = 'FlateDecode';
+      this.data.Filter = 'FlateDecode';
     }
   }
   end(chunk) {
     if (chunk) {
       this.write(chunk);
     }
-    return this.finalize();
+    this.finalize();
   }
   finalize() {
     this.offset = this.document._offset;
@@ -227,7 +210,7 @@ class PDFReference extends PDFAbstractReference {
     if (this.buffer.length) {
       this.document._write('stream');
       this.document._write(this.buffer);
-      this.buffer = []; // free up memory
+      this.buffer = [];
       this.document._write('\nendstream');
     }
     this.document._write('endobj');
@@ -238,10 +221,69 @@ class PDFReference extends PDFAbstractReference {
   }
 }
 
-/*
-PDFPage - represents a single page in the PDF document
-By Devon Govett
-*/
+function PDFNumber(n) {
+  return Math.fround(n);
+}
+function normalizeSides(sides, defaultDefinition = undefined, transformer = v => v) {
+  if (sides == null || typeof sides === 'object' && Object.keys(sides).length === 0) {
+    sides = defaultDefinition;
+  }
+  if (sides == null || typeof sides !== 'object') {
+    sides = {
+      top: sides,
+      right: sides,
+      bottom: sides,
+      left: sides
+    };
+  } else if (Array.isArray(sides)) {
+    if (sides.length === 2) {
+      sides = {
+        vertical: sides[0],
+        horizontal: sides[1]
+      };
+    } else {
+      sides = {
+        top: sides[0],
+        right: sides[1],
+        bottom: sides[2],
+        left: sides[3]
+      };
+    }
+  }
+  if ('vertical' in sides || 'horizontal' in sides) {
+    sides = {
+      top: sides.vertical,
+      right: sides.horizontal,
+      bottom: sides.vertical,
+      left: sides.horizontal
+    };
+  }
+  return {
+    top: transformer(sides.top),
+    right: transformer(sides.right),
+    bottom: transformer(sides.bottom),
+    left: transformer(sides.left)
+  };
+}
+const MM_TO_CM = 1 / 10;
+const CM_TO_IN = 1 / 2.54;
+const PX_TO_IN = 1 / 96;
+const IN_TO_PT = 72;
+const PC_TO_PT = 12;
+function cosine(a) {
+  if (a === 0) return 1;
+  if (a === 90) return 0;
+  if (a === 180) return -1;
+  if (a === 270) return 0;
+  return Math.cos(a * Math.PI / 180);
+}
+function sine(a) {
+  if (a === 0) return 0;
+  if (a === 90) return 1;
+  if (a === 180) return 0;
+  if (a === 270) return -1;
+  return Math.sin(a * Math.PI / 180);
+}
 
 const DEFAULT_MARGINS = {
   top: 72,
@@ -304,35 +346,19 @@ const SIZES = {
 class PDFPage {
   constructor(document, options = {}) {
     this.document = document;
+    this._options = options;
     this.size = options.size || 'letter';
     this.layout = options.layout || 'portrait';
-
-    // process margins
-    if (typeof options.margin === 'number') {
-      this.margins = {
-        top: options.margin,
-        left: options.margin,
-        bottom: options.margin,
-        right: options.margin
-      };
-
-      // default to 1 inch margins
-    } else {
-      this.margins = options.margins || DEFAULT_MARGINS;
-    }
-
-    // calculate page dimensions
     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];
     this.content = this.document.ref();
-
-    // Initialize the Font, XObject, and ExtGState dictionaries
+    if (options.font) document.font(options.font, options.fontFamily);
+    if (options.fontSize) document.fontSize(options.fontSize);
+    this.margins = normalizeSides(options.margin ?? options.margins, DEFAULT_MARGINS, x => document.sizeToPoint(x, 0, this));
     this.resources = this.document.ref({
       ProcSet: ['PDF', 'Text', 'ImageB', 'ImageC', 'ImageI']
     });
-
-    // The page dictionary
     this.dictionary = this.document.ref({
       Type: 'Page',
       Parent: this.document._root.data.Pages,
@@ -342,8 +368,6 @@ class PDFPage {
     });
     this.markings = [];
   }
-
-  // Lazily create these objects
   get fonts() {
     const data = this.resources.data;
     return data.Font != null ? data.Font : data.Font = {};
@@ -372,204 +396,86 @@ class PDFPage {
     const data = this.dictionary.data;
     return data.StructParents != null ? data.StructParents : data.StructParents = this.document.createStructParentTreeNextKey();
   }
+  get contentWidth() {
+    return this.width - this.margins.left - this.margins.right;
+  }
+  get contentHeight() {
+    return this.height - this.margins.top - this.margins.bottom;
+  }
   maxY() {
     return this.height - this.margins.bottom;
   }
   write(chunk) {
     return this.content.write(chunk);
   }
+  _setTabOrder() {
+    if (!this.dictionary.Tabs && this.document.hasMarkInfoDictionary()) {
+      this.dictionary.data.Tabs = 'S';
+    }
+  }
   end() {
+    this._setTabOrder();
     this.dictionary.end();
+    this.resources.data.ColorSpace = this.resources.data.ColorSpace || {};
+    for (let color of Object.values(this.document.spotColors)) {
+      this.resources.data.ColorSpace[color.id] = color;
+    }
     this.resources.end();
     return this.content.end();
   }
 }
 
-/*
-PDFNameTree - represents a name tree object
-*/
 class PDFNameTree extends PDFTree {
   _compareKeys(a, b) {
     return a.localeCompare(b);
   }
   _keysName() {
-    return "Names";
+    return 'Names';
   }
   _dataForKey(k) {
     return new String(k);
   }
 }
 
-/**
- * Check if value is in a range group.
- * @param {number} value
- * @param {number[]} rangeGroup
- * @returns {boolean}
- */
 function inRange(value, rangeGroup) {
   if (value < rangeGroup[0]) return false;
   let startRange = 0;
   let endRange = rangeGroup.length / 2;
   while (startRange <= endRange) {
     const middleRange = Math.floor((startRange + endRange) / 2);
-
-    // actual array index
     const arrayIndex = middleRange * 2;
-
-    // Check if value is in range pointed by actual index
     if (value >= rangeGroup[arrayIndex] && value <= rangeGroup[arrayIndex + 1]) {
       return true;
     }
     if (value > rangeGroup[arrayIndex + 1]) {
-      // Search Right Side Of Array
       startRange = middleRange + 1;
     } else {
-      // Search Left Side Of Array
       endRange = middleRange - 1;
     }
   }
   return false;
 }
 
-// prettier-ignore-start
-/**
- * A.1 Unassigned code points in Unicode 3.2
- * @link https://tools.ietf.org/html/rfc3454#appendix-A.1
- */
 const unassigned_code_points = [0x0221, 0x0221, 0x0234, 0x024f, 0x02ae, 0x02af, 0x02ef, 0x02ff, 0x0350, 0x035f, 0x0370, 0x0373, 0x0376, 0x0379, 0x037b, 0x037d, 0x037f, 0x0383, 0x038b, 0x038b, 0x038d, 0x038d, 0x03a2, 0x03a2, 0x03cf, 0x03cf, 0x03f7, 0x03ff, 0x0487, 0x0487, 0x04cf, 0x04cf, 0x04f6, 0x04f7, 0x04fa, 0x04ff, 0x0510, 0x0530, 0x0557, 0x0558, 0x0560, 0x0560, 0x0588, 0x0588, 0x058b, 0x0590, 0x05a2, 0x05a2, 0x05ba, 0x05ba, 0x05c5, 0x05cf, 0x05eb, 0x05ef, 0x05f5, 0x060b, 0x060d, 0x061a, 0x061c, 0x061e, 0x0620, 0x0620, 0x063b, 0x063f, 0x0656, 0x065f, 0x06ee, 0x06ef, 0x06ff, 0x06ff, 0x070e, 0x070e, 0x072d, 0x072f, 0x074b, 0x077f, 0x07b2, 0x0900, 0x0904, 0x0904, 0x093a, 0x093b, 0x094e, 0x094f, 0x0955, 0x0957, 0x0971, 0x0980, 0x0984, 0x0984, 0x098d, 0x098e, 0x0991, 0x0992, 0x09a9, 0x09a9, 0x09b1, 0x09b1, 0x09b3, 0x09b5, 0x09ba, 0x09bb, 0x09bd, 0x09bd, 0x09c5, 0x09c6, 0x09c9, 0x09ca, 0x09ce, 0x09d6, 0x09d8, 0x09db, 0x09de, 0x09de, 0x09e4, 0x09e5, 0x09fb, 0x0a01, 0x0a03, 0x0a04, 0x0a0b, 0x0a0e, 0x0a11, 0x0a12, 0x0a29, 0x0a29, 0x0a31, 0x0a31, 0x0a34, 0x0a34, 0x0a37, 0x0a37, 0x0a3a, 0x0a3b, 0x0a3d, 0x0a3d, 0x0a43, 0x0a46, 0x0a49, 0x0a4a, 0x0a4e, 0x0a58, 0x0a5d, 0x0a5d, 0x0a5f, 0x0a65, 0x0a75, 0x0a80, 0x0a84, 0x0a84, 0x0a8c, 0x0a8c, 0x0a8e, 0x0a8e, 0x0a92, 0x0a92, 0x0aa9, 0x0aa9, 0x0ab1, 0x0ab1, 0x0ab4, 0x0ab4, 0x0aba, 0x0abb, 0x0ac6, 0x0ac6, 0x0aca, 0x0aca, 0x0ace, 0x0acf, 0x0ad1, 0x0adf, 0x0ae1, 0x0ae5, 0x0af0, 0x0b00, 0x0b04, 0x0b04, 0x0b0d, 0x0b0e, 0x0b11, 0x0b12, 0x0b29, 0x0b29, 0x0b31, 0x0b31, 0x0b34, 0x0b35, 0x0b3a, 0x0b3b, 0x0b44, 0x0b46, 0x0b49, 0x0b4a, 0x0b4e, 0x0b55, 0x0b58, 0x0b5b, 0x0b5e, 0x0b5e, 0x0b62, 0x0b65, 0x0b71, 0x0b81, 0x0b84, 0x0b84, 0x0b8b, 0x0b8d, 0x0b91, 0x0b91, 0x0b96, 0x0b98, 0x0b9b, 0x0b9b, 0x0b9d, 0x0b9d, 0x0ba0, 0x0ba2, 0x0ba5, 0x0ba7, 0x0bab, 0x0bad, 0x0bb6, 0x0bb6, 0x0bba, 0x0bbd, 0x0bc3, 0x0bc5, 0x0bc9, 0x0bc9, 0x0bce, 0x0bd6, 0x0bd8, 0x0be6, 0x0bf3, 0x0c00, 0x0c04, 0x0c04, 0x0c0d, 0x0c0d, 0x0c11, 0x0c11, 0x0c29, 0x0c29, 0x0c34, 0x0c34, 0x0c3a, 0x0c3d, 0x0c45, 0x0c45, 0x0c49, 0x0c49, 0x0c4e, 0x0c54, 0x0c57, 0x0c5f, 0x0c62, 0x0c65, 0x0c70, 0x0c81, 0x0c84, 0x0c84, 0x0c8d, 0x0c8d, 0x0c91, 0x0c91, 0x0ca9, 0x0ca9, 0x0cb4, 0x0cb4, 0x0cba, 0x0cbd, 0x0cc5, 0x0cc5, 0x0cc9, 0x0cc9, 0x0cce, 0x0cd4, 0x0cd7, 0x0cdd, 0x0cdf, 0x0cdf, 0x0ce2, 0x0ce5, 0x0cf0, 0x0d01, 0x0d04, 0x0d04, 0x0d0d, 0x0d0d, 0x0d11, 0x0d11, 0x0d29, 0x0d29, 0x0d3a, 0x0d3d, 0x0d44, 0x0d45, 0x0d49, 0x0d49, 0x0d4e, 0x0d56, 0x0d58, 0x0d5f, 0x0d62, 0x0d65, 0x0d70, 0x0d81, 0x0d84, 0x0d84, 0x0d97, 0x0d99, 0x0db2, 0x0db2, 0x0dbc, 0x0dbc, 0x0dbe, 0x0dbf, 0x0dc7, 0x0dc9, 0x0dcb, 0x0dce, 0x0dd5, 0x0dd5, 0x0dd7, 0x0dd7, 0x0de0, 0x0df1, 0x0df5, 0x0e00, 0x0e3b, 0x0e3e, 0x0e5c, 0x0e80, 0x0e83, 0x0e83, 0x0e85, 0x0e86, 0x0e89, 0x0e89, 0x0e8b, 0x0e8c, 0x0e8e, 0x0e93, 0x0e98, 0x0e98, 0x0ea0, 0x0ea0, 0x0ea4, 0x0ea4, 0x0ea6, 0x0ea6, 0x0ea8, 0x0ea9, 0x0eac, 0x0eac, 0x0eba, 0x0eba, 0x0ebe, 0x0ebf, 0x0ec5, 0x0ec5, 0x0ec7, 0x0ec7, 0x0ece, 0x0ecf, 0x0eda, 0x0edb, 0x0ede, 0x0eff, 0x0f48, 0x0f48, 0x0f6b, 0x0f70, 0x0f8c, 0x0f8f, 0x0f98, 0x0f98, 0x0fbd, 0x0fbd, 0x0fcd, 0x0fce, 0x0fd0, 0x0fff, 0x1022, 0x1022, 0x1028, 0x1028, 0x102b, 0x102b, 0x1033, 0x1035, 0x103a, 0x103f, 0x105a, 0x109f, 0x10c6, 0x10cf, 0x10f9, 0x10fa, 0x10fc, 0x10ff, 0x115a, 0x115e, 0x11a3, 0x11a7, 0x11fa, 0x11ff, 0x1207, 0x1207, 0x1247, 0x1247, 0x1249, 0x1249, 0x124e, 0x124f, 0x1257, 0x1257, 0x1259, 0x1259, 0x125e, 0x125f, 0x1287, 0x1287, 0x1289, 0x1289, 0x128e, 0x128f, 0x12af, 0x12af, 0x12b1, 0x12b1, 0x12b6, 0x12b7, 0x12bf, 0x12bf, 0x12c1, 0x12c1, 0x12c6, 0x12c7, 0x12cf, 0x12cf, 0x12d7, 0x12d7, 0x12ef, 0x12ef, 0x130f, 0x130f, 0x1311, 0x1311, 0x1316, 0x1317, 0x131f, 0x131f, 0x1347, 0x1347, 0x135b, 0x1360, 0x137d, 0x139f, 0x13f5, 0x1400, 0x1677, 0x167f, 0x169d, 0x169f, 0x16f1, 0x16ff, 0x170d, 0x170d, 0x1715, 0x171f, 0x1737, 0x173f, 0x1754, 0x175f, 0x176d, 0x176d, 0x1771, 0x1771, 0x1774, 0x177f, 0x17dd, 0x17df, 0x17ea, 0x17ff, 0x180f, 0x180f, 0x181a, 0x181f, 0x1878, 0x187f, 0x18aa, 0x1dff, 0x1e9c, 0x1e9f, 0x1efa, 0x1eff, 0x1f16, 0x1f17, 0x1f1e, 0x1f1f, 0x1f46, 0x1f47, 0x1f4e, 0x1f4f, 0x1f58, 0x1f58, 0x1f5a, 0x1f5a, 0x1f5c, 0x1f5c, 0x1f5e, 0x1f5e, 0x1f7e, 0x1f7f, 0x1fb5, 0x1fb5, 0x1fc5, 0x1fc5, 0x1fd4, 0x1fd5, 0x1fdc, 0x1fdc, 0x1ff0, 0x1ff1, 0x1ff5, 0x1ff5, 0x1fff, 0x1fff, 0x2053, 0x2056, 0x2058, 0x205e, 0x2064, 0x2069, 0x2072, 0x2073, 0x208f, 0x209f, 0x20b2, 0x20cf, 0x20eb, 0x20ff, 0x213b, 0x213c, 0x214c, 0x2152, 0x2184, 0x218f, 0x23cf, 0x23ff, 0x2427, 0x243f, 0x244b, 0x245f, 0x24ff, 0x24ff, 0x2614, 0x2615, 0x2618, 0x2618, 0x267e, 0x267f, 0x268a, 0x2700, 0x2705, 0x2705, 0x270a, 0x270b, 0x2728, 0x2728, 0x274c, 0x274c, 0x274e, 0x274e, 0x2753, 0x2755, 0x2757, 0x2757, 0x275f, 0x2760, 0x2795, 0x2797, 0x27b0, 0x27b0, 0x27bf, 0x27cf, 0x27ec, 0x27ef, 0x2b00, 0x2e7f, 0x2e9a, 0x2e9a, 0x2ef4, 0x2eff, 0x2fd6, 0x2fef, 0x2ffc, 0x2fff, 0x3040, 0x3040, 0x3097, 0x3098, 0x3100, 0x3104, 0x312d, 0x3130, 0x318f, 0x318f, 0x31b8, 0x31ef, 0x321d, 0x321f, 0x3244, 0x3250, 0x327c, 0x327e, 0x32cc, 0x32cf, 0x32ff, 0x32ff, 0x3377, 0x337a, 0x33de, 0x33df, 0x33ff, 0x33ff, 0x4db6, 0x4dff, 0x9fa6, 0x9fff, 0xa48d, 0xa48f, 0xa4c7, 0xabff, 0xd7a4, 0xd7ff, 0xfa2e, 0xfa2f, 0xfa6b, 0xfaff, 0xfb07, 0xfb12, 0xfb18, 0xfb1c, 0xfb37, 0xfb37, 0xfb3d, 0xfb3d, 0xfb3f, 0xfb3f, 0xfb42, 0xfb42, 0xfb45, 0xfb45, 0xfbb2, 0xfbd2, 0xfd40, 0xfd4f, 0xfd90, 0xfd91, 0xfdc8, 0xfdcf, 0xfdfd, 0xfdff, 0xfe10, 0xfe1f, 0xfe24, 0xfe2f, 0xfe47, 0xfe48, 0xfe53, 0xfe53, 0xfe67, 0xfe67, 0xfe6c, 0xfe6f, 0xfe75, 0xfe75, 0xfefd, 0xfefe, 0xff00, 0xff00, 0xffbf, 0xffc1, 0xffc8, 0xffc9, 0xffd0, 0xffd1, 0xffd8, 0xffd9, 0xffdd, 0xffdf, 0xffe7, 0xffe7, 0xffef, 0xfff8, 0x10000, 0x102ff, 0x1031f, 0x1031f, 0x10324, 0x1032f, 0x1034b, 0x103ff, 0x10426, 0x10427, 0x1044e, 0x1cfff, 0x1d0f6, 0x1d0ff, 0x1d127, 0x1d129, 0x1d1de, 0x1d3ff, 0x1d455, 0x1d455, 0x1d49d, 0x1d49d, 0x1d4a0, 0x1d4a1, 0x1d4a3, 0x1d4a4, 0x1d4a7, 0x1d4a8, 0x1d4ad, 0x1d4ad, 0x1d4ba, 0x1d4ba, 0x1d4bc, 0x1d4bc, 0x1d4c1, 0x1d4c1, 0x1d4c4, 0x1d4c4, 0x1d506, 0x1d506, 0x1d50b, 0x1d50c, 0x1d515, 0x1d515, 0x1d51d, 0x1d51d, 0x1d53a, 0x1d53a, 0x1d53f, 0x1d53f, 0x1d545, 0x1d545, 0x1d547, 0x1d549, 0x1d551, 0x1d551, 0x1d6a4, 0x1d6a7, 0x1d7ca, 0x1d7cd, 0x1d800, 0x1fffd, 0x2a6d7, 0x2f7ff, 0x2fa1e, 0x2fffd, 0x30000, 0x3fffd, 0x40000, 0x4fffd, 0x50000, 0x5fffd, 0x60000, 0x6fffd, 0x70000, 0x7fffd, 0x80000, 0x8fffd, 0x90000, 0x9fffd, 0xa0000, 0xafffd, 0xb0000, 0xbfffd, 0xc0000, 0xcfffd, 0xd0000, 0xdfffd, 0xe0000, 0xe0000, 0xe0002, 0xe001f, 0xe0080, 0xefffd];
-// prettier-ignore-end
-
 const isUnassignedCodePoint = character => inRange(character, unassigned_code_points);
-
-// prettier-ignore-start
-/**
- * B.1 Commonly mapped to nothing
- * @link https://tools.ietf.org/html/rfc3454#appendix-B.1
- */
 const commonly_mapped_to_nothing = [0x00ad, 0x00ad, 0x034f, 0x034f, 0x1806, 0x1806, 0x180b, 0x180b, 0x180c, 0x180c, 0x180d, 0x180d, 0x200b, 0x200b, 0x200c, 0x200c, 0x200d, 0x200d, 0x2060, 0x2060, 0xfe00, 0xfe00, 0xfe01, 0xfe01, 0xfe02, 0xfe02, 0xfe03, 0xfe03, 0xfe04, 0xfe04, 0xfe05, 0xfe05, 0xfe06, 0xfe06, 0xfe07, 0xfe07, 0xfe08, 0xfe08, 0xfe09, 0xfe09, 0xfe0a, 0xfe0a, 0xfe0b, 0xfe0b, 0xfe0c, 0xfe0c, 0xfe0d, 0xfe0d, 0xfe0e, 0xfe0e, 0xfe0f, 0xfe0f, 0xfeff, 0xfeff];
-// prettier-ignore-end
-
 const isCommonlyMappedToNothing = character => inRange(character, commonly_mapped_to_nothing);
-
-// prettier-ignore-start
-/**
- * C.1.2 Non-ASCII space characters
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.1.2
- */
-const non_ASCII_space_characters = [0x00a0, 0x00a0 /* NO-BREAK SPACE */, 0x1680, 0x1680 /* OGHAM SPACE MARK */, 0x2000, 0x2000 /* EN QUAD */, 0x2001, 0x2001 /* EM QUAD */, 0x2002, 0x2002 /* EN SPACE */, 0x2003, 0x2003 /* EM SPACE */, 0x2004, 0x2004 /* THREE-PER-EM SPACE */, 0x2005, 0x2005 /* FOUR-PER-EM SPACE */, 0x2006, 0x2006 /* SIX-PER-EM SPACE */, 0x2007, 0x2007 /* FIGURE SPACE */, 0x2008, 0x2008 /* PUNCTUATION SPACE */, 0x2009, 0x2009 /* THIN SPACE */, 0x200a, 0x200a /* HAIR SPACE */, 0x200b, 0x200b /* ZERO WIDTH SPACE */, 0x202f, 0x202f /* NARROW NO-BREAK SPACE */, 0x205f, 0x205f /* MEDIUM MATHEMATICAL SPACE */, 0x3000, 0x3000 /* IDEOGRAPHIC SPACE */];
-// prettier-ignore-end
-
+const non_ASCII_space_characters = [0x00a0, 0x00a0, 0x1680, 0x1680, 0x2000, 0x2000, 0x2001, 0x2001, 0x2002, 0x2002, 0x2003, 0x2003, 0x2004, 0x2004, 0x2005, 0x2005, 0x2006, 0x2006, 0x2007, 0x2007, 0x2008, 0x2008, 0x2009, 0x2009, 0x200a, 0x200a, 0x200b, 0x200b, 0x202f, 0x202f, 0x205f, 0x205f, 0x3000, 0x3000];
 const isNonASCIISpaceCharacter = character => inRange(character, non_ASCII_space_characters);
-
-// prettier-ignore-start
-const non_ASCII_controls_characters = [
-/**
- * C.2.2 Non-ASCII control characters
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.2.2
- */
-0x0080, 0x009f /* [CONTROL CHARACTERS] */, 0x06dd, 0x06dd /* ARABIC END OF AYAH */, 0x070f, 0x070f /* SYRIAC ABBREVIATION MARK */, 0x180e, 0x180e /* MONGOLIAN VOWEL SEPARATOR */, 0x200c, 0x200c /* ZERO WIDTH NON-JOINER */, 0x200d, 0x200d /* ZERO WIDTH JOINER */, 0x2028, 0x2028 /* LINE SEPARATOR */, 0x2029, 0x2029 /* PARAGRAPH SEPARATOR */, 0x2060, 0x2060 /* WORD JOINER */, 0x2061, 0x2061 /* FUNCTION APPLICATION */, 0x2062, 0x2062 /* INVISIBLE TIMES */, 0x2063, 0x2063 /* INVISIBLE SEPARATOR */, 0x206a, 0x206f /* [CONTROL CHARACTERS] */, 0xfeff, 0xfeff /* ZERO WIDTH NO-BREAK SPACE */, 0xfff9, 0xfffc /* [CONTROL CHARACTERS] */, 0x1d173, 0x1d17a /* [MUSICAL CONTROL CHARACTERS] */];
-const non_character_codepoints = [
-/**
- * C.4 Non-character code points
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.4
- */
-0xfdd0, 0xfdef /* [NONCHARACTER CODE POINTS] */, 0xfffe, 0xffff /* [NONCHARACTER CODE POINTS] */, 0x1fffe, 0x1ffff /* [NONCHARACTER CODE POINTS] */, 0x2fffe, 0x2ffff /* [NONCHARACTER CODE POINTS] */, 0x3fffe, 0x3ffff /* [NONCHARACTER CODE POINTS] */, 0x4fffe, 0x4ffff /* [NONCHARACTER CODE POINTS] */, 0x5fffe, 0x5ffff /* [NONCHARACTER CODE POINTS] */, 0x6fffe, 0x6ffff /* [NONCHARACTER CODE POINTS] */, 0x7fffe, 0x7ffff /* [NONCHARACTER CODE POINTS] */, 0x8fffe, 0x8ffff /* [NONCHARACTER CODE POINTS] */, 0x9fffe, 0x9ffff /* [NONCHARACTER CODE POINTS] */, 0xafffe, 0xaffff /* [NONCHARACTER CODE POINTS] */, 0xbfffe, 0xbffff /* [NONCHARACTER CODE POINTS] */, 0xcfffe, 0xcffff /* [NONCHARACTER CODE POINTS] */, 0xdfffe, 0xdffff /* [NONCHARACTER CODE POINTS] */, 0xefffe, 0xeffff /* [NONCHARACTER CODE POINTS] */, 0x10fffe, 0x10ffff /* [NONCHARACTER CODE POINTS] */];
-
-/**
- * 2.3.  Prohibited Output
- */
-const prohibited_characters = [
-/**
- * C.2.1 ASCII control characters
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.2.1
- */
-0, 0x001f /* [CONTROL CHARACTERS] */, 0x007f, 0x007f /* DELETE */,
-/**
- * C.8 Change display properties or are deprecated
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.8
- */
-0x0340, 0x0340 /* COMBINING GRAVE TONE MARK */, 0x0341, 0x0341 /* COMBINING ACUTE TONE MARK */, 0x200e, 0x200e /* LEFT-TO-RIGHT MARK */, 0x200f, 0x200f /* RIGHT-TO-LEFT MARK */, 0x202a, 0x202a /* LEFT-TO-RIGHT EMBEDDING */, 0x202b, 0x202b /* RIGHT-TO-LEFT EMBEDDING */, 0x202c, 0x202c /* POP DIRECTIONAL FORMATTING */, 0x202d, 0x202d /* LEFT-TO-RIGHT OVERRIDE */, 0x202e, 0x202e /* RIGHT-TO-LEFT OVERRIDE */, 0x206a, 0x206a /* INHIBIT SYMMETRIC SWAPPING */, 0x206b, 0x206b /* ACTIVATE SYMMETRIC SWAPPING */, 0x206c, 0x206c /* INHIBIT ARABIC FORM SHAPING */, 0x206d, 0x206d /* ACTIVATE ARABIC FORM SHAPING */, 0x206e, 0x206e /* NATIONAL DIGIT SHAPES */, 0x206f, 0x206f /* NOMINAL DIGIT SHAPES */,
-/**
- * C.7 Inappropriate for canonical representation
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.7
- */
-0x2ff0, 0x2ffb /* [IDEOGRAPHIC DESCRIPTION CHARACTERS] */,
-/**
- * C.5 Surrogate codes
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.5
- */
-0xd800, 0xdfff,
-/**
- * C.3 Private use
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.3
- */
-0xe000, 0xf8ff /* [PRIVATE USE, PLANE 0] */,
-/**
- * C.6 Inappropriate for plain text
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.6
- */
-0xfff9, 0xfff9 /* INTERLINEAR ANNOTATION ANCHOR */, 0xfffa, 0xfffa /* INTERLINEAR ANNOTATION SEPARATOR */, 0xfffb, 0xfffb /* INTERLINEAR ANNOTATION TERMINATOR */, 0xfffc, 0xfffc /* OBJECT REPLACEMENT CHARACTER */, 0xfffd, 0xfffd /* REPLACEMENT CHARACTER */,
-/**
- * C.9 Tagging characters
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.9
- */
-0xe0001, 0xe0001 /* LANGUAGE TAG */, 0xe0020, 0xe007f /* [TAGGING CHARACTERS] */,
-/**
- * C.3 Private use
- * @link https://tools.ietf.org/html/rfc3454#appendix-C.3
- */
-
-0xf0000, 0xffffd /* [PRIVATE USE, PLANE 15] */, 0x100000, 0x10fffd /* [PRIVATE USE, PLANE 16] */];
-// prettier-ignore-end
-
+const non_ASCII_controls_characters = [0x0080, 0x009f, 0x06dd, 0x06dd, 0x070f, 0x070f, 0x180e, 0x180e, 0x200c, 0x200c, 0x200d, 0x200d, 0x2028, 0x2028, 0x2029, 0x2029, 0x2060, 0x2060, 0x2061, 0x2061, 0x2062, 0x2062, 0x2063, 0x2063, 0x206a, 0x206f, 0xfeff, 0xfeff, 0xfff9, 0xfffc, 0x1d173, 0x1d17a];
+const non_character_codepoints = [0xfdd0, 0xfdef, 0xfffe, 0xffff, 0x1fffe, 0x1ffff, 0x2fffe, 0x2ffff, 0x3fffe, 0x3ffff, 0x4fffe, 0x4ffff, 0x5fffe, 0x5ffff, 0x6fffe, 0x6ffff, 0x7fffe, 0x7ffff, 0x8fffe, 0x8ffff, 0x9fffe, 0x9ffff, 0xafffe, 0xaffff, 0xbfffe, 0xbffff, 0xcfffe, 0xcffff, 0xdfffe, 0xdffff, 0xefffe, 0xeffff, 0x10fffe, 0x10ffff];
+const prohibited_characters = [0, 0x001f, 0x007f, 0x007f, 0x0340, 0x0340, 0x0341, 0x0341, 0x200e, 0x200e, 0x200f, 0x200f, 0x202a, 0x202a, 0x202b, 0x202b, 0x202c, 0x202c, 0x202d, 0x202d, 0x202e, 0x202e, 0x206a, 0x206a, 0x206b, 0x206b, 0x206c, 0x206c, 0x206d, 0x206d, 0x206e, 0x206e, 0x206f, 0x206f, 0x2ff0, 0x2ffb, 0xd800, 0xdfff, 0xe000, 0xf8ff, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb, 0xfffc, 0xfffc, 0xfffd, 0xfffd, 0xe0001, 0xe0001, 0xe0020, 0xe007f, 0xf0000, 0xffffd, 0x100000, 0x10fffd];
 const isProhibitedCharacter = character => inRange(character, non_ASCII_space_characters) || inRange(character, prohibited_characters) || inRange(character, non_ASCII_controls_characters) || inRange(character, non_character_codepoints);
-
-// prettier-ignore-start
-/**
- * D.1 Characters with bidirectional property "R" or "AL"
- * @link https://tools.ietf.org/html/rfc3454#appendix-D.1
- */
 const bidirectional_r_al = [0x05be, 0x05be, 0x05c0, 0x05c0, 0x05c3, 0x05c3, 0x05d0, 0x05ea, 0x05f0, 0x05f4, 0x061b, 0x061b, 0x061f, 0x061f, 0x0621, 0x063a, 0x0640, 0x064a, 0x066d, 0x066f, 0x0671, 0x06d5, 0x06dd, 0x06dd, 0x06e5, 0x06e6, 0x06fa, 0x06fe, 0x0700, 0x070d, 0x0710, 0x0710, 0x0712, 0x072c, 0x0780, 0x07a5, 0x07b1, 0x07b1, 0x200f, 0x200f, 0xfb1d, 0xfb1d, 0xfb1f, 0xfb28, 0xfb2a, 0xfb36, 0xfb38, 0xfb3c, 0xfb3e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfb46, 0xfbb1, 0xfbd3, 0xfd3d, 0xfd50, 0xfd8f, 0xfd92, 0xfdc7, 0xfdf0, 0xfdfc, 0xfe70, 0xfe74, 0xfe76, 0xfefc];
-// prettier-ignore-end
-
 const isBidirectionalRAL = character => inRange(character, bidirectional_r_al);
-
-// prettier-ignore-start
-/**
- * D.2 Characters with bidirectional property "L"
- * @link https://tools.ietf.org/html/rfc3454#appendix-D.2
- */
 const bidirectional_l = [0x0041, 0x005a, 0x0061, 0x007a, 0x00aa, 0x00aa, 0x00b5, 0x00b5, 0x00ba, 0x00ba, 0x00c0, 0x00d6, 0x00d8, 0x00f6, 0x00f8, 0x0220, 0x0222, 0x0233, 0x0250, 0x02ad, 0x02b0, 0x02b8, 0x02bb, 0x02c1, 0x02d0, 0x02d1, 0x02e0, 0x02e4, 0x02ee, 0x02ee, 0x037a, 0x037a, 0x0386, 0x0386, 0x0388, 0x038a, 0x038c, 0x038c, 0x038e, 0x03a1, 0x03a3, 0x03ce, 0x03d0, 0x03f5, 0x0400, 0x0482, 0x048a, 0x04ce, 0x04d0, 0x04f5, 0x04f8, 0x04f9, 0x0500, 0x050f, 0x0531, 0x0556, 0x0559, 0x055f, 0x0561, 0x0587, 0x0589, 0x0589, 0x0903, 0x0903, 0x0905, 0x0939, 0x093d, 0x0940, 0x0949, 0x094c, 0x0950, 0x0950, 0x0958, 0x0961, 0x0964, 0x0970, 0x0982, 0x0983, 0x0985, 0x098c, 0x098f, 0x0990, 0x0993, 0x09a8, 0x09aa, 0x09b0, 0x09b2, 0x09b2, 0x09b6, 0x09b9, 0x09be, 0x09c0, 0x09c7, 0x09c8, 0x09cb, 0x09cc, 0x09d7, 0x09d7, 0x09dc, 0x09dd, 0x09df, 0x09e1, 0x09e6, 0x09f1, 0x09f4, 0x09fa, 0x0a05, 0x0a0a, 0x0a0f, 0x0a10, 0x0a13, 0x0a28, 0x0a2a, 0x0a30, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 0x0a39, 0x0a3e, 0x0a40, 0x0a59, 0x0a5c, 0x0a5e, 0x0a5e, 0x0a66, 0x0a6f, 0x0a72, 0x0a74, 0x0a83, 0x0a83, 0x0a85, 0x0a8b, 0x0a8d, 0x0a8d, 0x0a8f, 0x0a91, 0x0a93, 0x0aa8, 0x0aaa, 0x0ab0, 0x0ab2, 0x0ab3, 0x0ab5, 0x0ab9, 0x0abd, 0x0ac0, 0x0ac9, 0x0ac9, 0x0acb, 0x0acc, 0x0ad0, 0x0ad0, 0x0ae0, 0x0ae0, 0x0ae6, 0x0aef, 0x0b02, 0x0b03, 0x0b05, 0x0b0c, 0x0b0f, 0x0b10, 0x0b13, 0x0b28, 0x0b2a, 0x0b30, 0x0b32, 0x0b33, 0x0b36, 0x0b39, 0x0b3d, 0x0b3e, 0x0b40, 0x0b40, 0x0b47, 0x0b48, 0x0b4b, 0x0b4c, 0x0b57, 0x0b57, 0x0b5c, 0x0b5d, 0x0b5f, 0x0b61, 0x0b66, 0x0b70, 0x0b83, 0x0b83, 0x0b85, 0x0b8a, 0x0b8e, 0x0b90, 0x0b92, 0x0b95, 0x0b99, 0x0b9a, 0x0b9c, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0ba8, 0x0baa, 0x0bae, 0x0bb5, 0x0bb7, 0x0bb9, 0x0bbe, 0x0bbf, 0x0bc1, 0x0bc2, 0x0bc6, 0x0bc8, 0x0bca, 0x0bcc, 0x0bd7, 0x0bd7, 0x0be7, 0x0bf2, 0x0c01, 0x0c03, 0x0c05, 0x0c0c, 0x0c0e, 0x0c10, 0x0c12, 0x0c28, 0x0c2a, 0x0c33, 0x0c35, 0x0c39, 0x0c41, 0x0c44, 0x0c60, 0x0c61, 0x0c66, 0x0c6f, 0x0c82, 0x0c83, 0x0c85, 0x0c8c, 0x0c8e, 0x0c90, 0x0c92, 0x0ca8, 0x0caa, 0x0cb3, 0x0cb5, 0x0cb9, 0x0cbe, 0x0cbe, 0x0cc0, 0x0cc4, 0x0cc7, 0x0cc8, 0x0cca, 0x0ccb, 0x0cd5, 0x0cd6, 0x0cde, 0x0cde, 0x0ce0, 0x0ce1, 0x0ce6, 0x0cef, 0x0d02, 0x0d03, 0x0d05, 0x0d0c, 0x0d0e, 0x0d10, 0x0d12, 0x0d28, 0x0d2a, 0x0d39, 0x0d3e, 0x0d40, 0x0d46, 0x0d48, 0x0d4a, 0x0d4c, 0x0d57, 0x0d57, 0x0d60, 0x0d61, 0x0d66, 0x0d6f, 0x0d82, 0x0d83, 0x0d85, 0x0d96, 0x0d9a, 0x0db1, 0x0db3, 0x0dbb, 0x0dbd, 0x0dbd, 0x0dc0, 0x0dc6, 0x0dcf, 0x0dd1, 0x0dd8, 0x0ddf, 0x0df2, 0x0df4, 0x0e01, 0x0e30, 0x0e32, 0x0e33, 0x0e40, 0x0e46, 0x0e4f, 0x0e5b, 0x0e81, 0x0e82, 0x0e84, 0x0e84, 0x0e87, 0x0e88, 0x0e8a, 0x0e8a, 0x0e8d, 0x0e8d, 0x0e94, 0x0e97, 0x0e99, 0x0e9f, 0x0ea1, 0x0ea3, 0x0ea5, 0x0ea5, 0x0ea7, 0x0ea7, 0x0eaa, 0x0eab, 0x0ead, 0x0eb0, 0x0eb2, 0x0eb3, 0x0ebd, 0x0ebd, 0x0ec0, 0x0ec4, 0x0ec6, 0x0ec6, 0x0ed0, 0x0ed9, 0x0edc, 0x0edd, 0x0f00, 0x0f17, 0x0f1a, 0x0f34, 0x0f36, 0x0f36, 0x0f38, 0x0f38, 0x0f3e, 0x0f47, 0x0f49, 0x0f6a, 0x0f7f, 0x0f7f, 0x0f85, 0x0f85, 0x0f88, 0x0f8b, 0x0fbe, 0x0fc5, 0x0fc7, 0x0fcc, 0x0fcf, 0x0fcf, 0x1000, 0x1021, 0x1023, 0x1027, 0x1029, 0x102a, 0x102c, 0x102c, 0x1031, 0x1031, 0x1038, 0x1038, 0x1040, 0x1057, 0x10a0, 0x10c5, 0x10d0, 0x10f8, 0x10fb, 0x10fb, 0x1100, 0x1159, 0x115f, 0x11a2, 0x11a8, 0x11f9, 0x1200, 0x1206, 0x1208, 0x1246, 0x1248, 0x1248, 0x124a, 0x124d, 0x1250, 0x1256, 0x1258, 0x1258, 0x125a, 0x125d, 0x1260, 0x1286, 0x1288, 0x1288, 0x128a, 0x128d, 0x1290, 0x12ae, 0x12b0, 0x12b0, 0x12b2, 0x12b5, 0x12b8, 0x12be, 0x12c0, 0x12c0, 0x12c2, 0x12c5, 0x12c8, 0x12ce, 0x12d0, 0x12d6, 0x12d8, 0x12ee, 0x12f0, 0x130e, 0x1310, 0x1310, 0x1312, 0x1315, 0x1318, 0x131e, 0x1320, 0x1346, 0x1348, 0x135a, 0x1361, 0x137c, 0x13a0, 0x13f4, 0x1401, 0x1676, 0x1681, 0x169a, 0x16a0, 0x16f0, 0x1700, 0x170c, 0x170e, 0x1711, 0x1720, 0x1731, 0x1735, 0x1736, 0x1740, 0x1751, 0x1760, 0x176c, 0x176e, 0x1770, 0x1780, 0x17b6, 0x17be, 0x17c5, 0x17c7, 0x17c8, 0x17d4, 0x17da, 0x17dc, 0x17dc, 0x17e0, 0x17e9, 0x1810, 0x1819, 0x1820, 0x1877, 0x1880, 0x18a8, 0x1e00, 0x1e9b, 0x1ea0, 0x1ef9, 0x1f00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fbc, 0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fcc, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fe0, 0x1fec, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ffc, 0x200e, 0x200e, 0x2071, 0x2071, 0x207f, 0x207f, 0x2102, 0x2102, 0x2107, 0x2107, 0x210a, 0x2113, 0x2115, 0x2115, 0x2119, 0x211d, 0x2124, 0x2124, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212d, 0x212f, 0x2131, 0x2133, 0x2139, 0x213d, 0x213f, 0x2145, 0x2149, 0x2160, 0x2183, 0x2336, 0x237a, 0x2395, 0x2395, 0x249c, 0x24e9, 0x3005, 0x3007, 0x3021, 0x3029, 0x3031, 0x3035, 0x3038, 0x303c, 0x3041, 0x3096, 0x309d, 0x309f, 0x30a1, 0x30fa, 0x30fc, 0x30ff, 0x3105, 0x312c, 0x3131, 0x318e, 0x3190, 0x31b7, 0x31f0, 0x321c, 0x3220, 0x3243, 0x3260, 0x327b, 0x327f, 0x32b0, 0x32c0, 0x32cb, 0x32d0, 0x32fe, 0x3300, 0x3376, 0x337b, 0x33dd, 0x33e0, 0x33fe, 0x3400, 0x4db5, 0x4e00, 0x9fa5, 0xa000, 0xa48c, 0xac00, 0xd7a3, 0xd800, 0xfa2d, 0xfa30, 0xfa6a, 0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xff21, 0xff3a, 0xff41, 0xff5a, 0xff66, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf, 0xffd2, 0xffd7, 0xffda, 0xffdc, 0x10300, 0x1031e, 0x10320, 0x10323, 0x10330, 0x1034a, 0x10400, 0x10425, 0x10428, 0x1044d, 0x1d000, 0x1d0f5, 0x1d100, 0x1d126, 0x1d12a, 0x1d166, 0x1d16a, 0x1d172, 0x1d183, 0x1d184, 0x1d18c, 0x1d1a9, 0x1d1ae, 0x1d1dd, 0x1d400, 0x1d454, 0x1d456, 0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4a9, 0x1d4ac, 0x1d4ae, 0x1d4b9, 0x1d4bb, 0x1d4bb, 0x1d4bd, 0x1d4c0, 0x1d4c2, 0x1d4c3, 0x1d4c5, 0x1d505, 0x1d507, 0x1d50a, 0x1d50d, 0x1d514, 0x1d516, 0x1d51c, 0x1d51e, 0x1d539, 0x1d53b, 0x1d53e, 0x1d540, 0x1d544, 0x1d546, 0x1d546, 0x1d54a, 0x1d550, 0x1d552, 0x1d6a3, 0x1d6a8, 0x1d7c9, 0x20000, 0x2a6d6, 0x2f800, 0x2fa1d, 0xf0000, 0xffffd, 0x100000, 0x10fffd];
-// prettier-ignore-end
-
 const isBidirectionalL = character => inRange(character, bidirectional_l);
 
-// 2.1.  Mapping
-
-/**
- * non-ASCII space characters [StringPrep, C.1.2] that can be
- * mapped to SPACE (U+0020)
- */
 const mapping2space = isNonASCIISpaceCharacter;
-
-/**
- * the "commonly mapped to nothing" characters [StringPrep, B.1]
- * that can be mapped to nothing.
- */
 const mapping2nothing = isCommonlyMappedToNothing;
-
-// utils
 const getCodePoint = character => character.codePointAt(0);
 const first = x => x[0];
 const last = x => x[x.length - 1];
-
-/**
- * Convert provided string into an array of Unicode Code Points.
- * Based on https://stackoverflow.com/a/21409165/1556249
- * and https://www.npmjs.com/package/code-point-at.
- * @param {string} input
- * @returns {number[]}
- */
 function toCodePoints(input) {
   const codepoints = [];
   const size = input.length;
@@ -587,14 +493,6 @@ function toCodePoints(input) {
   }
   return codepoints;
 }
-
-/**
- * SASLprep.
- * @param {string} input
- * @param {Object} opts
- * @param {boolean} opts.allowUnassigned
- * @returns {string}
- */
 function saslprep(input, opts = {}) {
   if (typeof input !== 'string') {
     throw new TypeError('Expected string.');
@@ -602,49 +500,24 @@ function saslprep(input, opts = {}) {
   if (input.length === 0) {
     return '';
   }
-
-  // 1. Map
-  const mapped_input = toCodePoints(input)
-  // 1.1 mapping to space
-  .map(character => mapping2space(character) ? 0x20 : character)
-  // 1.2 mapping to nothing
-  .filter(character => !mapping2nothing(character));
-
-  // 2. Normalize
+  const mapped_input = toCodePoints(input).map(character => mapping2space(character) ? 0x20 : character).filter(character => !mapping2nothing(character));
   const normalized_input = String.fromCodePoint.apply(null, mapped_input).normalize('NFKC');
   const normalized_map = toCodePoints(normalized_input);
-
-  // 3. Prohibit
   const hasProhibited = normalized_map.some(isProhibitedCharacter);
   if (hasProhibited) {
     throw new Error('Prohibited character, see https://tools.ietf.org/html/rfc4013#section-2.3');
   }
-
-  // Unassigned Code Points
   if (opts.allowUnassigned !== true) {
     const hasUnassigned = normalized_map.some(isUnassignedCodePoint);
     if (hasUnassigned) {
       throw new Error('Unassigned code point, see https://tools.ietf.org/html/rfc4013#section-2.5');
     }
   }
-
-  // 4. check bidi
-
   const hasBidiRAL = normalized_map.some(isBidirectionalRAL);
   const hasBidiL = normalized_map.some(isBidirectionalL);
-
-  // 4.1 If a string contains any RandALCat character, the string MUST NOT
-  // contain any LCat character.
   if (hasBidiRAL && hasBidiL) {
     throw new Error('String must not contain RandALCat and LCat at the same time,' + ' see https://tools.ietf.org/html/rfc3454#section-6');
   }
-
-  /**
-   * 4.2 If a string contains any RandALCat character, a RandALCat
-   * character MUST be the first character of the string, and a
-   * RandALCat character MUST be the last character of the string.
-   */
-
   const isFirstBidiRAL = isBidirectionalRAL(getCodePoint(first(normalized_input)));
   const isLastBidiRAL = isBidirectionalRAL(getCodePoint(last(normalized_input)));
   if (hasBidiRAL && !(isFirstBidiRAL && isLastBidiRAL)) {
@@ -653,15 +526,10 @@ function saslprep(input, opts = {}) {
   return normalized_input;
 }
 
-/*
-   PDFSecurity - represents PDF security settings
-   By Yang Liu <hi@zesik.com>
- */
 class PDFSecurity {
   static generateFileID(info = {}) {
     let infoStr = `${info.CreationDate.getTime()}\n`;
     for (let key in info) {
-      // eslint-disable-next-line no-prototype-builtins
       if (!info.hasOwnProperty(key)) {
         continue;
       }
@@ -992,9 +860,9 @@ function wordArrayToBuffer(wordArray) {
 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: number$2
 } = PDFObject;
-class PDFGradient {
+class PDFGradient$1 {
   constructor(doc) {
     this.doc = doc;
     this.stops = [];
@@ -1035,8 +903,6 @@ class PDFGradient {
     }
     this.embedded = true;
     this.matrix = m;
-
-    // if the last stop comes before 100%, add a copy at 100%
     const last = this.stops[stopsLength - 1];
     if (last[0] < 1) {
       this.stops.push([1, last[1], last[2]]);
@@ -1059,14 +925,11 @@ class PDFGradient {
       stops.push(fn);
       fn.end();
     }
-
-    // if there are only two stops, we don't need a stitching function
     if (stopsLength === 1) {
       fn = stops[0];
     } else {
       fn = this.doc.ref({
         FunctionType: 3,
-        // stitching function
         Domain: [0, 1],
         Functions: stops,
         Bounds: bounds,
@@ -1081,7 +944,7 @@ class PDFGradient {
       Type: 'Pattern',
       PatternType: 2,
       Shading: shader,
-      Matrix: this.matrix.map(number)
+      Matrix: this.matrix.map(number$2)
     });
     pattern.end();
     if (this.stops.some(stop => stop[2] < 1)) {
@@ -1147,7 +1010,6 @@ class PDFGradient {
     return pattern;
   }
   apply(stroke) {
-    // apply gradient transform to existing document ctm
     const [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
     const [m11, m12, m21, m22, dx, dy] = this.transform;
     const m = [m0 * m11 + m2 * m12, m1 * m11 + m3 * m12, m0 * m21 + m2 * m22, m1 * m21 + m3 * m22, m0 * dx + m2 * dy + m4, m1 * dx + m3 * dy + m5];
@@ -1159,7 +1021,7 @@ class PDFGradient {
     return this.doc.addContent(`/${this.id} ${op}`);
   }
 }
-class PDFLinearGradient extends PDFGradient {
+class PDFLinearGradient$1 extends PDFGradient$1 {
   constructor(doc, x1, y1, x2, y2) {
     super(doc);
     this.x1 = x1;
@@ -1177,10 +1039,10 @@ class PDFLinearGradient extends PDFGradient {
     });
   }
   opacityGradient() {
-    return new PDFLinearGradient(this.doc, this.x1, this.y1, this.x2, this.y2);
+    return new PDFLinearGradient$1(this.doc, this.x1, this.y1, this.x2, this.y2);
   }
 }
-class PDFRadialGradient extends PDFGradient {
+class PDFRadialGradient$1 extends PDFGradient$1 {
   constructor(doc, x1, y1, r1, x2, y2, r2) {
     super(doc);
     this.doc = doc;
@@ -1201,21 +1063,17 @@ class PDFRadialGradient extends PDFGradient {
     });
   }
   opacityGradient() {
-    return new PDFRadialGradient(this.doc, this.x1, this.y1, this.r1, this.x2, this.y2, this.r2);
+    return new PDFRadialGradient$1(this.doc, this.x1, this.y1, this.r1, this.x2, this.y2, this.r2);
   }
 }
 var Gradient = {
-  PDFGradient,
-  PDFLinearGradient,
-  PDFRadialGradient
+  PDFGradient: PDFGradient$1,
+  PDFLinearGradient: PDFLinearGradient$1,
+  PDFRadialGradient: PDFRadialGradient$1
 };
 
-/*
-PDF tiling pattern support. Uncolored only.
- */
-
 const underlyingColorSpaces = ['DeviceCMYK', 'DeviceRGB'];
-class PDFTilingPattern {
+class PDFTilingPattern$1 {
   constructor(doc, bBox, xStep, yStep, stream) {
     this.doc = doc;
     this.bBox = bBox;
@@ -1224,23 +1082,16 @@ class PDFTilingPattern {
     this.stream = stream;
   }
   createPattern() {
-    // no resources needed for our current usage
-    // required entry
     const resources = this.doc.ref();
     resources.end();
-    // apply default transform matrix (flipped in the default doc._ctm)
-    // see document.js & gradient.js
     const [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
     const [m11, m12, m21, m22, dx, dy] = [1, 0, 0, 1, 0, 0];
     const m = [m0 * m11 + m2 * m12, m1 * m11 + m3 * m12, m0 * m21 + m2 * m22, m1 * m21 + m3 * m22, m0 * dx + m2 * dy + m4, m1 * dx + m3 * dy + m5];
     const pattern = this.doc.ref({
       Type: 'Pattern',
       PatternType: 1,
-      // tiling
       PaintType: 2,
-      // 1-colored, 2-uncolored
       TilingType: 2,
-      // 2-no distortion
       BBox: this.bBox,
       XStep: this.xStep,
       YStep: this.yStep,
@@ -1251,8 +1102,6 @@ class PDFTilingPattern {
     return pattern;
   }
   embedPatternColorSpaces() {
-    // map each pattern to an underlying color space
-    // and embed on each page
     underlyingColorSpaces.forEach(csName => {
       const csId = this.getPatternColorSpaceId(csName);
       if (this.doc.page.colorSpaces[csId]) return;
@@ -1270,47 +1119,40 @@ class PDFTilingPattern {
       this.id = 'P' + this.doc._patternCount;
       this.pattern = this.createPattern();
     }
-
-    // patterns are embedded in each page
     if (!this.doc.page.patterns[this.id]) {
       this.doc.page.patterns[this.id] = this.pattern;
     }
   }
   apply(stroke, patternColor) {
-    // do any embedding/creating that might be needed
     this.embedPatternColorSpaces();
     this.embed();
     const normalizedColor = this.doc._normalizeColor(patternColor);
     if (!normalizedColor) throw Error(`invalid pattern color. (value: ${patternColor})`);
-
-    // select one of the pattern color spaces
     const csId = this.getPatternColorSpaceId(this.doc._getColorSpace(normalizedColor));
     this.doc._setColorSpace(csId, stroke);
-
-    // stroke/fill using the pattern and color (in the above underlying color space)
     const op = stroke ? 'SCN' : 'scn';
     return this.doc.addContent(`${normalizedColor.join(' ')} /${this.id} ${op}`);
   }
 }
 var pattern = {
-  PDFTilingPattern
+  PDFTilingPattern: PDFTilingPattern$1
 };
 
 const {
-  PDFGradient: PDFGradient$1,
-  PDFLinearGradient: PDFLinearGradient$1,
-  PDFRadialGradient: PDFRadialGradient$1
+  PDFGradient,
+  PDFLinearGradient,
+  PDFRadialGradient
 } = Gradient;
 const {
-  PDFTilingPattern: PDFTilingPattern$1
+  PDFTilingPattern
 } = pattern;
 var ColorMixin = {
   initColor() {
-    // The opacity dictionaries
+    this.spotColors = {};
     this._opacityRegistry = {};
     this._opacityCount = 0;
     this._patternCount = 0;
-    return this._gradCount = 0;
+    this._gradCount = 0;
   },
   _normalizeColor(color) {
     if (typeof color === 'string') {
@@ -1322,13 +1164,13 @@ var ColorMixin = {
         color = [hex >> 16, hex >> 8 & 0xff, hex & 0xff];
       } else if (namedColors[color]) {
         color = namedColors[color];
+      } else if (this.spotColors[color]) {
+        return this.spotColors[color];
       }
     }
     if (Array.isArray(color)) {
-      // RGB
       if (color.length === 3) {
         color = color.map(part => part / 255);
-        // CMYK
       } else if (color.length === 4) {
         color = color.map(part => part / 100);
       }
@@ -1337,15 +1179,13 @@ var ColorMixin = {
     return null;
   },
   _setColor(color, stroke) {
-    if (color instanceof PDFGradient$1) {
+    if (color instanceof PDFGradient) {
       color.apply(stroke);
       return true;
-      // see if tiling pattern, decode & apply it it
-    } else if (Array.isArray(color) && color[0] instanceof PDFTilingPattern$1) {
+    } else if (Array.isArray(color) && color[0] instanceof PDFTilingPattern) {
       color[0].apply(stroke, color[1]);
       return true;
     }
-    // any other case should be a normal color and not a pattern
     return this._setColorCore(color, stroke);
   },
   _setColorCore(color, stroke) {
@@ -1356,8 +1196,12 @@ var ColorMixin = {
     const op = stroke ? 'SCN' : 'scn';
     const space = this._getColorSpace(color);
     this._setColorSpace(space, stroke);
-    color = color.join(' ');
-    this.addContent(`${color} ${op}`);
+    if (color instanceof SpotColor) {
+      this.page.colorSpaces[color.id] = color.ref;
+      this.addContent(`1 ${op}`);
+    } else {
+      this.addContent(`${color.join(' ')} ${op}`);
+    }
     return true;
   },
   _setColorSpace(space, stroke) {
@@ -1365,6 +1209,9 @@ var ColorMixin = {
     return this.addContent(`/${space} ${op}`);
   },
   _getColorSpace(color) {
+    if (color instanceof SpotColor) {
+      return color.id;
+    }
     return color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
   },
   fillColor(color, opacity) {
@@ -1372,9 +1219,6 @@ var ColorMixin = {
     if (set) {
       this.fillOpacity(opacity);
     }
-
-    // save this for text wrapper, which needs to reset
-    // the fill color on new pages
     this._fillColor = [color, opacity];
     return this;
   },
@@ -1431,13 +1275,18 @@ var ColorMixin = {
     return this.addContent(`/${name} gs`);
   },
   linearGradient(x1, y1, x2, y2) {
-    return new PDFLinearGradient$1(this, x1, y1, x2, y2);
+    return new PDFLinearGradient(this, x1, y1, x2, y2);
   },
   radialGradient(x1, y1, r1, x2, y2, r2) {
-    return new PDFRadialGradient$1(this, x1, y1, r1, x2, y2, r2);
+    return new PDFRadialGradient(this, x1, y1, r1, x2, y2, r2);
   },
   pattern(bbox, xStep, yStep, stream) {
-    return new PDFTilingPattern$1(this, bbox, xStep, yStep, stream);
+    return new PDFTilingPattern(this, bbox, xStep, yStep, stream);
+  },
+  addSpotColor(name, C, M, Y, K) {
+    const color = new SpotColor(this, name, C, M, Y, K);
+    this.spotColors[name] = color;
+    return this;
   }
 };
 var namedColors = {
@@ -1625,7 +1474,6 @@ const parse = function (path) {
     if (parameters[c] != null) {
       params = parameters[c];
       if (cmd) {
-        // save existing command
         if (curArg.length > 0) {
           args[args.length] = +curArg;
         }
@@ -1643,14 +1491,11 @@ const parse = function (path) {
         continue;
       }
       if (args.length === params) {
-        // handle reused commands
         ret[ret.length] = {
           cmd,
           args
         };
         args = [+curArg];
-
-        // handle assumed commands
         if (cmd === 'M') {
           cmd = 'L';
         }
@@ -1661,8 +1506,6 @@ const parse = function (path) {
         args[args.length] = +curArg;
       }
       foundDecimal = c === '.';
-
-      // fix for negative numbers or repeated decimals with no delimeter between commands
       curArg = ['-', '.'].includes(c) ? c : '';
     } else {
       curArg += c;
@@ -1671,18 +1514,13 @@ const parse = function (path) {
       }
     }
   }
-
-  // add the last command
   if (curArg.length > 0) {
     if (args.length === params) {
-      // handle reused commands
       ret[ret.length] = {
         cmd,
         args
       };
       args = [+curArg];
-
-      // handle assumed commands
       if (cmd === 'M') {
         cmd = 'L';
       }
@@ -1700,10 +1538,7 @@ const parse = function (path) {
   return ret;
 };
 const apply = function (commands, doc) {
-  // current point, control point, and subpath starting point
   cx = cy = px = py = sx = sy = 0;
-
-  // run the commands
   for (let i = 0; i < commands.length; i++) {
     const c = commands[i];
     if (typeof runners[c.cmd] === 'function') {
@@ -1867,8 +1702,6 @@ const solveArc = function (doc, x, y, coords) {
     doc.bezierCurveTo(...bez);
   }
 };
-
-// from Inkscape svgtopdf, thanks!
 const arcToSegments = function (x, y, rx, ry, large, sweep, rotateX, ox, oy) {
   const th = rotateX * (Math.PI / 180);
   const sin_th = Math.sin(th);
@@ -1944,18 +1777,14 @@ class SVGPath {
 const {
   number: number$1
 } = PDFObject;
-
-// This constant is used to approximate a symmetrical arc using a cubic
-// Bezier curve.
 const KAPPA = 4.0 * ((Math.sqrt(2) - 1.0) / 3.0);
 var VectorMixin = {
   initVector() {
-    this._ctm = [1, 0, 0, 1, 0, 0]; // current transformation matrix
-    return this._ctmStack = [];
+    this._ctm = [1, 0, 0, 1, 0, 0];
+    this._ctmStack = [];
   },
   save() {
     this._ctmStack.push(this._ctm.slice());
-    // TODO: save/restore colorspace and styles so not setting it unnessesarily all the time?
     return this.addContent('q');
   },
   restore() {
@@ -2028,8 +1857,6 @@ var VectorMixin = {
       r = 0;
     }
     r = Math.min(r, 0.5 * w, 0.5 * h);
-
-    // amount to inset control points from corners (see `ellipse`)
     const c = r * (1.0 - KAPPA);
     this.moveTo(x + r, y);
     this.lineTo(x + w - r, y);
@@ -2043,7 +1870,6 @@ var VectorMixin = {
     return this.closePath();
   },
   ellipse(x, y, r1, r2) {
-    // based on http://stackoverflow.com/questions/2172798/how-to-draw-an-oval-in-html5-canvas/2173084#2173084
     if (r2 == null) {
       r2 = r1;
     }
@@ -2073,10 +1899,8 @@ var VectorMixin = {
     const HALF_PI = 0.5 * Math.PI;
     let deltaAng = endAngle - startAngle;
     if (Math.abs(deltaAng) > TWO_PI) {
-      // draw only full circle if more than that is specified
       deltaAng = TWO_PI;
     } else if (deltaAng !== 0 && anticlockwise !== deltaAng < 0) {
-      // necessary to flip direction of rendering
       const dir = anticlockwise ? -1 : 1;
       deltaAng = dir * TWO_PI + deltaAng;
     }
@@ -2084,38 +1908,21 @@ var VectorMixin = {
     const segAng = deltaAng / numSegs;
     const handleLen = segAng / HALF_PI * KAPPA * radius;
     let curAng = startAngle;
-
-    // component distances between anchor point and control point
     let deltaCx = -Math.sin(curAng) * handleLen;
     let deltaCy = Math.cos(curAng) * handleLen;
-
-    // anchor point
     let ax = x + Math.cos(curAng) * radius;
     let ay = y + Math.sin(curAng) * radius;
-
-    // calculate and render segments
     this.moveTo(ax, ay);
     for (let segIdx = 0; segIdx < numSegs; segIdx++) {
-      // starting control point
       const cp1x = ax + deltaCx;
       const cp1y = ay + deltaCy;
-
-      // step angle
       curAng += segAng;
-
-      // next anchor point
       ax = x + Math.cos(curAng) * radius;
       ay = y + Math.sin(curAng) * radius;
-
-      // next control point delta
       deltaCx = -Math.sin(curAng) * handleLen;
       deltaCy = Math.cos(curAng) * handleLen;
-
-      // ending control point
       const cp2x = ax - deltaCx;
       const cp2y = ay - deltaCy;
-
-      // render segment
       this.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, ax, ay);
     }
     return this;
@@ -2176,9 +1983,7 @@ var VectorMixin = {
     return this.addContent(`W${this._windingRule(rule)} n`);
   },
   transform(m11, m12, m21, m22, dx, dy) {
-    // keep track of the current transformation matrix
     if (m11 === 1 && m12 === 0 && m21 === 0 && m22 === 1 && dx === 0 && dy === 0) {
-      // Ignore identity transforms
       return this;
     }
     const m = this._ctm;
@@ -2342,7 +2147,6 @@ class AFMFont {
     this.boundingBoxes = {};
     this.kernPairs = {};
     this.parse();
-    // todo: remove charWidths since appears to not be used
     this.charWidths = new Array(256);
     for (let char = 0; char <= 255; char++) {
       this.charWidths[char] = this.glyphWidths[characters[char]];
@@ -2449,21 +2253,17 @@ class PDFFont {
       return;
     }
     this.embed();
-    return this.embedded = true;
+    this.embedded = true;
   }
   embed() {
     throw new Error('Must be implemented by subclasses');
   }
-  lineHeight(size, includeGap) {
-    if (includeGap == null) {
-      includeGap = false;
-    }
+  lineHeight(size, includeGap = false) {
     const gap = includeGap ? this.lineGap : 0;
     return (this.ascender + gap - this.descender) / 1000 * size;
   }
 }
 
-// This insanity is so bundlers can inline the font files
 const STANDARD_FONTS = {
   Courier() {
     return fs.readFileSync(__dirname + '/data/Courier.afm', 'utf8');
@@ -2591,8 +2391,6 @@ class EmbeddedFont extends PDFFont {
   }
   layoutRun(text, features) {
     const run = this.font.layout(text, features);
-
-    // Normalize position values
     for (let i = 0; i < run.positions.length; i++) {
       const position = run.positions[i];
       for (let key in position) {
@@ -2615,16 +2413,12 @@ class EmbeddedFont extends PDFFont {
     return run;
   }
   layout(text, features, onlyWidth) {
-    // Skip the cache if any user defined features are applied
     if (features) {
       return this.layoutRun(text, features);
     }
     let glyphs = onlyWidth ? null : [];
     let positions = onlyWidth ? null : [];
     let advanceWidth = 0;
-
-    // Split the string by words to increase cache efficiency.
-    // For this purpose, spaces and tabs are a good enough delimeter.
     let last = 0;
     let index = 0;
     while (index <= text.length) {
@@ -2677,7 +2471,7 @@ class EmbeddedFont extends PDFFont {
     if (isCFF) {
       fontFile.data.Subtype = 'CIDFontType0C';
     }
-    this.subset.encodeStream().on('data', data => fontFile.write(data)).on('end', () => fontFile.end());
+    fontFile.end(this.subset.encode());
     const familyClass = ((this.font['OS/2'] != null ? this.font['OS/2'].sFamilyClass : undefined) || 0) >> 8;
     let flags = 0;
     if (this.font.post.isFixedPitch) {
@@ -2686,17 +2480,15 @@ class EmbeddedFont extends PDFFont {
     if (1 <= familyClass && familyClass <= 7) {
       flags |= 1 << 1;
     }
-    flags |= 1 << 2; // assume the font uses non-latin characters
+    flags |= 1 << 2;
     if (familyClass === 10) {
       flags |= 1 << 3;
     }
     if (this.font.head.macStyle.italic) {
       flags |= 1 << 6;
     }
-
-    // generate a tag (6 uppercase letters. 17 is the char code offset from '0' to 'A'. 73 will map to 'Z')
     const tag = [1, 2, 3, 4, 5, 6].map(i => String.fromCharCode((this.id.charCodeAt(i) || 73) + 17)).join('');
-    const name = tag + '+' + this.font.postscriptName;
+    const name = tag + '+' + this.font.postscriptName?.replaceAll(' ', '_');
     const {
       bbox
     } = this.font;
@@ -2711,8 +2503,7 @@ class EmbeddedFont extends PDFFont {
       CapHeight: (this.font.capHeight || this.font.ascent) * this.scale,
       XHeight: (this.font.xHeight || 0) * this.scale,
       StemV: 0
-    }); // not sure how to calculate this
-
+    });
     if (isCFF) {
       descriptor.data.FontFile3 = fontFile;
     } else {
@@ -2754,17 +2545,11 @@ class EmbeddedFont extends PDFFont {
     };
     return this.dictionary.end();
   }
-
-  // Maps the glyph ids encoded in the PDF back to unicode strings
-  // Because of ligature substitutions and the like, there may be one or more
-  // unicode characters represented by each glyph.
   toUnicodeCmap() {
     const cmap = this.document.ref();
     const entries = [];
     for (let codePoints of this.unicode) {
       const encoded = [];
-
-      // encode codePoints to utf16
       for (let value of codePoints) {
         if (value > 0xffff) {
           value -= 0x10000;
@@ -2818,12 +2603,10 @@ class PDFFontFactory {
       }
       src = fs.readFileSync(src);
     }
-    if (Buffer.isBuffer(src)) {
+    if (src instanceof Uint8Array) {
       font = fontkit.create(src, family);
-    } else if (src instanceof Uint8Array) {
-      font = fontkit.create(Buffer.from(src), family);
     } else if (src instanceof ArrayBuffer) {
-      font = fontkit.create(Buffer.from(new Uint8Array(src)), family);
+      font = fontkit.create(new Uint8Array(src), family);
     }
     if (font == null) {
       throw new Error('Not a supported font format or standard PDF font.');
@@ -2832,20 +2615,27 @@ class PDFFontFactory {
   }
 }
 
+const isEqualFont = (font1, font2) => {
+  if (font1.font._tables?.head?.checkSumAdjustment !== font2.font._tables?.head?.checkSumAdjustment) {
+    return false;
+  }
+  if (JSON.stringify(font1.font._tables?.name?.records) !== JSON.stringify(font2.font._tables?.name?.records)) {
+    return false;
+  }
+  return true;
+};
 var FontsMixin = {
-  initFonts(defaultFont = 'Helvetica') {
-    // Lookup table for embedded fonts
+  initFonts(defaultFont = 'Helvetica', defaultFontFamily = null, defaultFontSize = 12) {
     this._fontFamilies = {};
     this._fontCount = 0;
-
-    // Font state
-    this._fontSize = 12;
+    this._fontSource = defaultFont;
+    this._fontFamily = defaultFontFamily;
+    this._fontSize = defaultFontSize;
     this._font = null;
+    this._remSize = defaultFontSize;
     this._registeredFonts = {};
-
-    // Set the default font
     if (defaultFont) {
-      this.font(defaultFont);
+      this.font(defaultFont, defaultFontFamily);
     }
   },
   font(src, family, size) {
@@ -2854,8 +2644,6 @@ var FontsMixin = {
       size = family;
       family = null;
     }
-
-    // check registered fonts if src is a string
     if (typeof src === 'string' && this._registeredFonts[src]) {
       cacheKey = src;
       ({
@@ -2868,28 +2656,21 @@ var FontsMixin = {
         cacheKey = null;
       }
     }
+    this._fontSource = src;
+    this._fontFamily = family;
     if (size != null) {
       this.fontSize(size);
     }
-
-    // fast path: check if the font is already in the PDF
     if (font = this._fontFamilies[cacheKey]) {
       this._font = font;
       return this;
     }
-
-    // load the font
     const id = `F${++this._fontCount}`;
     this._font = PDFFontFactory.open(this, src, family, id);
-
-    // check for existing font familes with the same name already in the PDF
-    // useful if the font was passed as a buffer
-    if (font = this._fontFamilies[this._font.name]) {
+    if ((font = this._fontFamilies[this._font.name]) && isEqualFont(this._font, font)) {
       this._font = font;
       return this;
     }
-
-    // save the font for reuse later
     if (cacheKey) {
       this._fontFamilies[cacheKey] = this._font;
     }
@@ -2899,13 +2680,10 @@ var FontsMixin = {
     return this;
   },
   fontSize(_fontSize) {
-    this._fontSize = _fontSize;
+    this._fontSize = this.sizeToPoint(_fontSize);
     return this;
   },
   currentLineHeight(includeGap) {
-    if (includeGap == null) {
-      includeGap = false;
-    }
     return this._font.lineHeight(this._fontSize, includeGap);
   },
   registerFont(name, src, family) {
@@ -2914,6 +2692,64 @@ var FontsMixin = {
       family
     };
     return this;
+  },
+  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;
+    if (typeof size === 'number') return size;
+    if (typeof size === 'boolean') return Number(size);
+    const match = String(size).match(/((\d+)?(\.\d+)?)(em|in|px|cm|mm|pc|ex|ch|rem|vw|vh|vmin|vmax|%|pt)?/);
+    if (!match) throw new Error(`Unsupported size '${size}'`);
+    let multiplier;
+    switch (match[4]) {
+      case 'em':
+        multiplier = this._fontSize;
+        break;
+      case 'in':
+        multiplier = IN_TO_PT;
+        break;
+      case 'px':
+        multiplier = PX_TO_IN * IN_TO_PT;
+        break;
+      case 'cm':
+        multiplier = CM_TO_IN * IN_TO_PT;
+        break;
+      case 'mm':
+        multiplier = MM_TO_CM * CM_TO_IN * IN_TO_PT;
+        break;
+      case 'pc':
+        multiplier = PC_TO_PT;
+        break;
+      case 'ex':
+        multiplier = this.currentLineHeight();
+        break;
+      case 'ch':
+        multiplier = this.widthOfString('0');
+        break;
+      case 'rem':
+        multiplier = this._remSize;
+        break;
+      case 'vw':
+        multiplier = page.width / 100;
+        break;
+      case 'vh':
+        multiplier = page.height / 100;
+        break;
+      case 'vmin':
+        multiplier = Math.min(page.width, page.height) / 100;
+        break;
+      case 'vmax':
+        multiplier = Math.max(page.width, page.height) / 100;
+        break;
+      case '%':
+        multiplier = percentageWidth / 100;
+        break;
+      case 'pt':
+      default:
+        multiplier = 1;
+    }
+    return multiplier * Number(match[1]);
   }
 };
 
@@ -2923,12 +2759,13 @@ class LineWrapper extends events.EventEmitter {
   constructor(document, options) {
     super();
     this.document = document;
-    this.indent = options.indent || 0;
-    this.characterSpacing = options.characterSpacing || 0;
-    this.wordSpacing = options.wordSpacing === 0;
+    this.horizontalScaling = options.horizontalScaling || 100;
+    this.indent = (options.indent || 0) * this.horizontalScaling / 100;
+    this.characterSpacing = (options.characterSpacing || 0) * this.horizontalScaling / 100;
+    this.wordSpacing = (options.wordSpacing === 0) * this.horizontalScaling / 100;
     this.columns = options.columns || 1;
-    this.columnGap = options.columnGap != null ? options.columnGap : 18; // 1/4 inch
-    this.lineWidth = (options.width - this.columnGap * (this.columns - 1)) / this.columns;
+    this.columnGap = (options.columnGap != null ? options.columnGap : 18) * this.horizontalScaling / 100;
+    this.lineWidth = (options.width * this.horizontalScaling / 100 - this.columnGap * (this.columns - 1)) / this.columns;
     this.spaceLeft = this.lineWidth;
     this.startX = this.document.x;
     this.startY = this.document.y;
@@ -2936,36 +2773,30 @@ class LineWrapper extends events.EventEmitter {
     this.ellipsis = options.ellipsis;
     this.continuedX = 0;
     this.features = options.features;
-
-    // calculate the maximum Y position the text can appear at
     if (options.height != null) {
       this.height = options.height;
-      this.maxY = this.startY + options.height;
+      this.maxY = PDFNumber(this.startY + options.height);
     } else {
-      this.maxY = this.document.page.maxY();
+      this.maxY = PDFNumber(this.document.page.maxY());
     }
-
-    // handle paragraph indents
     this.on('firstLine', options => {
-      // if this is the first line of the text segment, and
-      // we're continuing where we left off, indent that much
-      // otherwise use the user specified indent option
       const indent = this.continuedX || this.indent;
       this.document.x += indent;
       this.lineWidth -= indent;
-      return this.once('line', () => {
+      if (options.indentAllLines) {
+        return;
+      }
+      this.once('line', () => {
         this.document.x -= indent;
         this.lineWidth += indent;
         if (options.continued && !this.continuedX) {
           this.continuedX = this.indent;
         }
         if (!options.continued) {
-          return this.continuedX = 0;
+          this.continuedX = 0;
         }
       });
     });
-
-    // handle left aligning last lines of paragraphs
     this.on('lastLine', options => {
       const {
         align
@@ -2974,7 +2805,7 @@ class LineWrapper extends events.EventEmitter {
         options.align = 'left';
       }
       this.lastLine = true;
-      return this.once('line', () => {
+      this.once('line', () => {
         this.document.y += options.paragraphGap || 0;
         options.align = align;
         return this.lastLine = false;
@@ -2991,7 +2822,6 @@ class LineWrapper extends events.EventEmitter {
     return w + this.wordWidth(HYPHEN) <= this.spaceLeft;
   }
   eachWord(text, fn) {
-    // setup a unicode line breaker
     let bk;
     const breaker = new LineBreaker(text);
     let last = null;
@@ -3000,19 +2830,12 @@ class LineWrapper extends events.EventEmitter {
       var shouldContinue;
       let word = text.slice((last != null ? last.position : undefined) || 0, bk.position);
       let w = wordWidths[word] != null ? wordWidths[word] : wordWidths[word] = this.wordWidth(word);
-
-      // if the word is longer than the whole line, chop it up
-      // TODO: break by grapheme clusters, not JS string characters
       if (w > this.lineWidth + this.continuedX) {
-        // make some fake break objects
         let lbk = last;
         const fbk = {};
         while (word.length) {
-          // fit as much of the word as possible into the space we have
           var l, mightGrow;
           if (w > this.spaceLeft) {
-            // start our check at the end of our available space - this method is faster than a loop of each character and it resolves
-            // an issue with long loops when processing massive words, such as a huge number of spaces
             l = Math.ceil(this.spaceLeft / (w / word.length));
             w = this.wordWidth(word.slice(0, l));
             mightGrow = w <= this.spaceLeft && l < word.length;
@@ -3020,7 +2843,6 @@ class LineWrapper extends events.EventEmitter {
             l = word.length;
           }
           let mustShrink = w > this.spaceLeft && l > 0;
-          // shrink or grow word as necessary after our near-guess above
           while (mustShrink || mightGrow) {
             if (mustShrink) {
               w = this.wordWidth(word.slice(0, --l));
@@ -3031,20 +2853,14 @@ class LineWrapper extends events.EventEmitter {
               mightGrow = w <= this.spaceLeft && l < word.length;
             }
           }
-
-          // check for the edge case where a single character cannot fit into a line.
           if (l === 0 && this.spaceLeft === this.lineWidth) {
             l = 1;
           }
-
-          // send a required break unless this is the last piece and a linebreak is not specified
           fbk.required = bk.required || l < word.length;
           shouldContinue = fn(word.slice(0, l), w, fbk, lbk);
           lbk = {
             required: false
           };
-
-          // get the remaining piece of the word
           word = word.slice(l);
           w = this.wordWidth(word);
           if (shouldContinue === false) {
@@ -3052,7 +2868,6 @@ class LineWrapper extends events.EventEmitter {
           }
         }
       } else {
-        // otherwise just emit the break as it was given to us
         shouldContinue = fn(word, w, bk, last);
       }
       if (shouldContinue === false) {
@@ -3062,23 +2877,19 @@ class LineWrapper extends events.EventEmitter {
     }
   }
   wrap(text, options) {
-    // override options from previous continued fragments
+    this.horizontalScaling = options.horizontalScaling || 100;
     if (options.indent != null) {
-      this.indent = options.indent;
+      this.indent = options.indent * this.horizontalScaling / 100;
     }
     if (options.characterSpacing != null) {
-      this.characterSpacing = options.characterSpacing;
+      this.characterSpacing = options.characterSpacing * this.horizontalScaling / 100;
     }
     if (options.wordSpacing != null) {
-      this.wordSpacing = options.wordSpacing;
+      this.wordSpacing = options.wordSpacing * this.horizontalScaling / 100;
     }
     if (options.ellipsis != null) {
       this.ellipsis = options.ellipsis;
     }
-
-    // make sure we're actually on the page
-    // and that the first line of is never by
-    // itself at the bottom of a page (orphans)
     const nextY = this.document.y + this.document.currentLineHeight(true);
     if (this.document.y > this.maxY || nextY > this.maxY) {
       this.nextSection();
@@ -3089,7 +2900,7 @@ class LineWrapper extends events.EventEmitter {
     let lc = 0;
     let {
       y
-    } = this.document; // used to reset Y pos if options.continued (below)
+    } = this.document;
     const emitLine = () => {
       options.textWidth = textWidth + this.wordSpacing * (wc - 1);
       options.wordCount = wc;
@@ -3112,23 +2923,17 @@ class LineWrapper extends events.EventEmitter {
         wc++;
       }
       if (bk.required || !this.canFit(word, w)) {
-        // if the user specified a max height and an ellipsis, and is about to pass the
-        // max height and max columns after the next line, append the ellipsis
         const lh = this.document.currentLineHeight(true);
-        if (this.height != null && this.ellipsis && this.document.y + lh * 2 > this.maxY && this.column >= this.columns) {
+        if (this.height != null && this.ellipsis && PDFNumber(this.document.y + lh * 2) > this.maxY && this.column >= this.columns) {
           if (this.ellipsis === true) {
             this.ellipsis = '…';
-          } // map default ellipsis character
+          }
           buffer = buffer.replace(/\s+$/, '');
           textWidth = this.wordWidth(buffer + this.ellipsis);
-
-          // remove characters from the buffer until the ellipsis fits
-          // to avoid infinite loop need to stop while-loop if buffer is empty string
           while (buffer && textWidth > this.lineWidth) {
             buffer = buffer.slice(0, -1).replace(/\s+$/, '');
             textWidth = this.wordWidth(buffer + this.ellipsis);
           }
-          // need to add ellipsis only if there is enough space for it
           if (textWidth <= this.lineWidth) {
             buffer = buffer + this.ellipsis;
           }
@@ -3143,35 +2948,25 @@ class LineWrapper extends events.EventEmitter {
           }
           this.emit('lastLine', options, this);
         }
-
-        // Previous entry is a soft hyphen - add visible hyphen.
         if (buffer[buffer.length - 1] == SOFT_HYPHEN) {
           buffer = buffer.slice(0, -1) + HYPHEN;
           this.spaceLeft -= this.wordWidth(HYPHEN);
         }
         emitLine();
-
-        // if we've reached the edge of the page,
-        // continue on a new page or column
-        if (this.document.y + lh > this.maxY) {
+        if (PDFNumber(this.document.y + lh) > this.maxY) {
           const shouldContinue = this.nextSection();
-
-          // stop if we reached the maximum height
           if (!shouldContinue) {
             wc = 0;
             buffer = '';
             return false;
           }
         }
-
-        // reset the space left and buffer
         if (bk.required) {
           this.spaceLeft = this.lineWidth;
           buffer = '';
           textWidth = 0;
           return wc = 0;
         } else {
-          // reset the space left and buffer
           this.spaceLeft = this.lineWidth - w;
           buffer = word;
           textWidth = w;
@@ -3186,25 +2981,19 @@ class LineWrapper extends events.EventEmitter {
       emitLine();
     }
     this.emit('sectionEnd', options, this);
-
-    // if the wrap is set to be continued, save the X position
-    // to start the first line of the next segment at, and reset
-    // the y position
     if (options.continued === true) {
       if (lc > 1) {
         this.continuedX = 0;
       }
       this.continuedX += options.textWidth || 0;
-      return this.document.y = y;
+      this.document.y = y;
     } else {
-      return this.document.x = this.startX;
+      this.document.x = this.startX;
     }
   }
   nextSection(options) {
     this.emit('sectionEnd', options, this);
     if (++this.column > this.columns) {
-      // if a max height was specified by the user, we're done.
-      // otherwise, the default is to make a new page at the bottom.
       if (this.height != null) {
         return false;
       }
@@ -3228,15 +3017,14 @@ class LineWrapper extends events.EventEmitter {
 }
 
 const {
-  number: number$2
+  number
 } = PDFObject;
 var TextMixin = {
   initText() {
     this._line = this._line.bind(this);
-    // Current coordinates
     this.x = 0;
     this.y = 0;
-    return this._lineGap = 0;
+    this._lineGap = 0;
   },
   lineGap(_lineGap) {
     this._lineGap = _lineGap;
@@ -3258,11 +3046,7 @@ var TextMixin = {
   },
   _text(text, x, y, options, lineCallback) {
     options = this._initOptions(x, y, options);
-
-    // Convert text to a string
     text = text == null ? '' : `${text}`;
-
-    // if the wordSpacing option is specified, remove multiple consecutive spaces
     if (options.wordSpacing) {
       text = text.replace(/\s{2,}/g, ' ');
     }
@@ -3271,8 +3055,12 @@ var TextMixin = {
         options.structParent.add(this.struct(options.structType || 'P', [this.markStructureContent(options.structType || 'P')]));
       }
     };
-
-    // word wrapping
+    if (options.rotation !== 0) {
+      this.save();
+      this.rotate(-options.rotation, {
+        origin: [this.x, this.y]
+      });
+    }
     if (options.width) {
       let wrapper = this._wrapper;
       if (!wrapper) {
@@ -3283,21 +3071,113 @@ var TextMixin = {
       this._wrapper = options.continued ? wrapper : null;
       this._textOptions = options.continued ? options : null;
       wrapper.wrap(text, options);
-
-      // render paragraphs as single lines
     } else {
       for (let line of text.split('\n')) {
         addStructure();
         lineCallback(line, options);
       }
     }
+    if (options.rotation !== 0) this.restore();
     return this;
   },
   text(text, x, y, options) {
     return this._text(text, x, y, options, this._line);
   },
   widthOfString(string, options = {}) {
-    return this._font.widthOfString(string, this._fontSize, options.features) + (options.characterSpacing || 0) * (string.length - 1);
+    const horizontalScaling = options.horizontalScaling || 100;
+    return (this._font.widthOfString(string, this._fontSize, options.features) + (options.characterSpacing || 0) * (string.length - 1)) * horizontalScaling / 100;
+  },
+  boundsOfString(string, x, y, options) {
+    options = this._initOptions(x, y, options);
+    ({
+      x,
+      y
+    } = this);
+    const lineGap = options.lineGap ?? this._lineGap ?? 0;
+    const lineHeight = this.currentLineHeight(true) + lineGap;
+    let contentWidth = 0;
+    string = String(string ?? '');
+    if (options.wordSpacing) {
+      string = string.replace(/\s{2,}/g, ' ');
+    }
+    if (options.width) {
+      let wrapper = new LineWrapper(this, options);
+      wrapper.on('line', (text, options) => {
+        this.y += lineHeight;
+        text = text.replace(/\n/g, '');
+        if (text.length) {
+          let wordSpacing = options.wordSpacing ?? 0;
+          const characterSpacing = options.characterSpacing ?? 0;
+          if (options.width && options.align === 'justify') {
+            const words = text.trim().split(/\s+/);
+            const textWidth = this.widthOfString(text.replace(/\s+/g, ''), options);
+            const spaceWidth = this.widthOfString(' ') + characterSpacing;
+            wordSpacing = Math.max(0, (options.lineWidth - textWidth) / Math.max(1, words.length - 1) - spaceWidth);
+          }
+          contentWidth = Math.max(contentWidth, options.textWidth + wordSpacing * (options.wordCount - 1) + characterSpacing * (text.length - 1));
+        }
+      });
+      wrapper.wrap(string, options);
+    } else {
+      for (let line of string.split('\n')) {
+        const lineWidth = this.widthOfString(line, options);
+        this.y += lineHeight;
+        contentWidth = Math.max(contentWidth, lineWidth);
+      }
+    }
+    let contentHeight = this.y - y;
+    if (options.height) contentHeight = Math.min(contentHeight, options.height);
+    this.x = x;
+    this.y = y;
+    if (options.rotation === 0) {
+      return {
+        x,
+        y,
+        width: contentWidth,
+        height: contentHeight
+      };
+    } else if (options.rotation === 90) {
+      return {
+        x: x,
+        y: y - contentWidth,
+        width: contentHeight,
+        height: contentWidth
+      };
+    } else if (options.rotation === 180) {
+      return {
+        x: x - contentWidth,
+        y: y - contentHeight,
+        width: contentWidth,
+        height: contentHeight
+      };
+    } else if (options.rotation === 270) {
+      return {
+        x: x - contentHeight,
+        y: y,
+        width: contentHeight,
+        height: contentWidth
+      };
+    }
+    const cos = cosine(options.rotation);
+    const sin = sine(options.rotation);
+    const x1 = x;
+    const y1 = y;
+    const x2 = x + contentWidth * cos;
+    const y2 = y - contentWidth * sin;
+    const x3 = x + contentWidth * cos + contentHeight * sin;
+    const y3 = y - contentWidth * sin + contentHeight * cos;
+    const x4 = x + contentHeight * sin;
+    const y4 = y + contentHeight * cos;
+    const xMin = Math.min(x1, x2, x3, x4);
+    const xMax = Math.max(x1, x2, x3, x4);
+    const yMin = Math.min(y1, y2, y3, y4);
+    const yMax = Math.max(y1, y2, y3, y4);
+    return {
+      x: xMin,
+      y: yMin,
+      width: xMax - xMin,
+      height: yMax - yMin
+    };
   },
   heightOfString(text, options) {
     const {
@@ -3305,11 +3185,10 @@ var TextMixin = {
       y
     } = this;
     options = this._initOptions(options);
-    options.height = Infinity; // don't break pages
-
+    options.height = Infinity;
     const lineGap = options.lineGap || this._lineGap || 0;
     this._text(text, this.x, this.y, options, () => {
-      return this.y += this.currentLineHeight(true) + lineGap;
+      this.y += this.currentLineHeight(true) + lineGap;
     });
     const height = this.y - y;
     this.x = x;
@@ -3407,12 +3286,12 @@ var TextMixin = {
       wrapper.on('sectionStart', () => {
         const pos = indent + itemIndent * (level - 1);
         this.x += pos;
-        return wrapper.lineWidth -= pos;
+        wrapper.lineWidth -= pos;
       });
       wrapper.on('sectionEnd', () => {
         const pos = indent + itemIndent * (level - 1);
         this.x -= pos;
-        return wrapper.lineWidth += pos;
+        wrapper.lineWidth += pos;
       });
       wrapper.wrap(listItem, options);
     };
@@ -3426,11 +3305,7 @@ var TextMixin = {
       options = x;
       x = null;
     }
-
-    // clone options object
     const result = Object.assign({}, options);
-
-    // extend options with previous values for continued text
     if (this._textOptions) {
       for (let key in this._textOptions) {
         const val = this._textOptions[key];
@@ -3441,16 +3316,12 @@ var TextMixin = {
         }
       }
     }
-
-    // Update the current position
     if (x != null) {
       this.x = x;
     }
     if (y != null) {
       this.y = y;
     }
-
-    // wrap to margins if no x or y position passed
     if (result.lineBreak !== false) {
       if (result.width == null) {
         result.width = this.page.width - this.x - this.page.margins.right;
@@ -3462,17 +3333,18 @@ var TextMixin = {
     }
     if (result.columnGap == null) {
       result.columnGap = 18;
-    } // 1/4 inch
-
+    }
+    result.rotation = Number(options.rotation ?? 0) % 360;
+    if (result.rotation < 0) result.rotation += 360;
     return result;
   },
   _line(text, options = {}, wrapper) {
     this._fragment(text, this.x, this.y, options);
     const lineGap = options.lineGap || this._lineGap || 0;
     if (!wrapper) {
-      return this.x += this.widthOfString(text);
+      this.x += this.widthOfString(text, options);
     } else {
-      return this.y += this.currentLineHeight(true) + lineGap;
+      this.y += this.currentLineHeight(true) + lineGap;
     }
   },
   _fragment(text, x, y, options) {
@@ -3481,13 +3353,10 @@ var TextMixin = {
     if (text.length === 0) {
       return;
     }
-
-    // handle options
     const align = options.align || 'left';
     let wordSpacing = options.wordSpacing || 0;
     const characterSpacing = options.characterSpacing || 0;
-
-    // text alignments
+    const horizontalScaling = options.horizontalScaling || 100;
     if (options.width) {
       switch (align) {
         case 'right':
@@ -3498,7 +3367,6 @@ var TextMixin = {
           x += options.lineWidth / 2 - options.textWidth / 2;
           break;
         case 'justify':
-          // calculate the word spacing value
           words = text.trim().split(/\s+/);
           textWidth = this.widthOfString(text.replace(/\s+/g, ''), options);
           var spaceWidth = this.widthOfString(' ') + characterSpacing;
@@ -3506,8 +3374,6 @@ var TextMixin = {
           break;
       }
     }
-
-    // text baseline alignments based on http://wiki.apache.org/xmlgraphics-fop/LineLayout/AlignmentHandling
     if (typeof options.baseline === 'number') {
       dy = -options.baseline;
     } else {
@@ -3540,11 +3406,7 @@ var TextMixin = {
       }
       dy = dy / 1000 * this._fontSize;
     }
-
-    // calculate the actual rendered width of the string after word and character spacing
     const renderedWidth = options.textWidth + wordSpacing * (options.wordCount - 1) + characterSpacing * (text.length - 1);
-
-    // create link annotations if the link option is given
     if (options.link != null) {
       this.link(x, y, renderedWidth, this.currentLineHeight(), options.link);
     }
@@ -3554,8 +3416,6 @@ var TextMixin = {
     if (options.destination != null) {
       this.addNamedDestination(options.destination, 'XYZ', x, y, null);
     }
-
-    // create underline
     if (options.underline) {
       this.save();
       if (!options.stroke) {
@@ -3569,8 +3429,6 @@ var TextMixin = {
       this.stroke();
       this.restore();
     }
-
-    // create strikethrough line
     if (options.strike) {
       this.save();
       if (!options.stroke) {
@@ -3585,8 +3443,6 @@ var TextMixin = {
       this.restore();
     }
     this.save();
-
-    // oblique (angle in degrees or boolean)
     if (options.oblique) {
       let skew;
       if (typeof options.oblique === 'number') {
@@ -3598,40 +3454,24 @@ var TextMixin = {
       this.transform(1, 0, skew, 1, -skew * dy, 0);
       this.transform(1, 0, 0, 1, -x, -y);
     }
-
-    // flip coordinate system
     this.transform(1, 0, 0, -1, 0, this.page.height);
     y = this.page.height - y - dy;
-
-    // add current font to page if necessary
     if (this.page.fonts[this._font.id] == null) {
       this.page.fonts[this._font.id] = this._font.ref();
     }
-
-    // begin the text object
     this.addContent('BT');
-
-    // text position
-    this.addContent(`1 0 0 1 ${number$2(x)} ${number$2(y)} Tm`);
-
-    // font and font size
-    this.addContent(`/${this._font.id} ${number$2(this._fontSize)} Tf`);
-
-    // rendering mode
+    this.addContent(`1 0 0 1 ${number(x)} ${number(y)} Tm`);
+    this.addContent(`/${this._font.id} ${number(this._fontSize)} Tf`);
     const mode = options.fill && options.stroke ? 2 : options.stroke ? 1 : 0;
     if (mode) {
       this.addContent(`${mode} Tr`);
     }
-
-    // Character spacing
     if (characterSpacing) {
-      this.addContent(`${number$2(characterSpacing)} Tc`);
+      this.addContent(`${number(characterSpacing)} Tc`);
+    }
+    if (horizontalScaling !== 100) {
+      this.addContent(`${horizontalScaling} Tz`);
     }
-
-    // Add the actual text
-    // If we have a word spacing value, we need to encode each word separately
-    // since the normal Tw operator only works on character code 32, which isn't
-    // used for embedded fonts.
     if (wordSpacing) {
       words = text.trim().split(/\s+/);
       wordSpacing += this.widthOfString(' ') + characterSpacing;
@@ -3642,9 +3482,6 @@ var TextMixin = {
         const [encodedWord, positionsWord] = this._font.encode(word, options.features);
         encoded = encoded.concat(encodedWord);
         positions = positions.concat(positionsWord);
-
-        // add the word spacing to the end of the word
-        // clone object because of cache
         const space = {};
         const object = positions[positions.length - 1];
         for (let key in object) {
@@ -3661,60 +3498,42 @@ var TextMixin = {
     const commands = [];
     let last = 0;
     let hadOffset = false;
-
-    // Adds a segment of text to the TJ command buffer
     const addSegment = cur => {
       if (last < cur) {
         const hex = encoded.slice(last, cur).join('');
         const advance = positions[cur - 1].xAdvance - positions[cur - 1].advanceWidth;
-        commands.push(`<${hex}> ${number$2(-advance)}`);
+        commands.push(`<${hex}> ${number(-advance)}`);
       }
-      return last = cur;
+      last = cur;
     };
-
-    // Flushes the current TJ commands to the output stream
     const flush = i => {
       addSegment(i);
       if (commands.length > 0) {
         this.addContent(`[${commands.join(' ')}] TJ`);
-        return commands.length = 0;
+        commands.length = 0;
       }
     };
     for (i = 0; i < positions.length; i++) {
-      // If we have an x or y offset, we have to break out of the current TJ command
-      // so we can move the text position.
       const pos = positions[i];
       if (pos.xOffset || pos.yOffset) {
-        // Flush the current buffer
         flush(i);
-
-        // Move the text position and flush just the current character
-        this.addContent(`1 0 0 1 ${number$2(x + pos.xOffset * scale)} ${number$2(y + pos.yOffset * scale)} Tm`);
+        this.addContent(`1 0 0 1 ${number(x + pos.xOffset * scale)} ${number(y + pos.yOffset * scale)} Tm`);
         flush(i + 1);
         hadOffset = true;
       } else {
-        // If the last character had an offset, reset the text position
         if (hadOffset) {
-          this.addContent(`1 0 0 1 ${number$2(x)} ${number$2(y)} Tm`);
+          this.addContent(`1 0 0 1 ${number(x)} ${number(y)} Tm`);
           hadOffset = false;
         }
-
-        // Group segments that don't have any advance adjustments
         if (pos.xAdvance - pos.advanceWidth !== 0) {
           addSegment(i + 1);
         }
       }
       x += pos.xAdvance * scale;
     }
-
-    // Flush any remaining commands
     flush(i);
-
-    // end the text object
     this.addContent('ET');
-
-    // restore flipped coordinate system
-    return this.restore();
+    this.restore();
   }
 };
 
@@ -3732,8 +3551,6 @@ class JPEG {
     if (this.data.readUInt16BE(0) !== 0xffd8) {
       throw 'SOI not found in JPEG';
     }
-
-    // Parse the EXIF orientation
     this.orientation = exif.fromBuffer(this.data).Orientation || 1;
     let pos = 2;
     while (pos < this.data.length) {
@@ -3770,16 +3587,10 @@ class JPEG {
       ColorSpace: this.colorSpace,
       Filter: 'DCTDecode'
     });
-
-    // add extra decode params for CMYK images. By swapping the
-    // min and max values from the default, we invert the colors. See
-    // section 4.8.4 of the spec.
     if (this.colorSpace === 'DeviceCMYK') {
       this.obj.data['Decode'] = [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0];
     }
     this.obj.end(this.data);
-
-    // free memory
     return this.data = null;
   }
 }
@@ -3822,24 +3633,14 @@ class PNGImage {
     if (this.image.palette.length === 0) {
       this.obj.data['ColorSpace'] = this.image.colorSpace;
     } else {
-      // embed the color palette in the PDF as an object stream
       const palette = this.document.ref();
       palette.end(Buffer.from(this.image.palette));
-
-      // build the color space array for the image
       this.obj.data['ColorSpace'] = ['Indexed', 'DeviceRGB', this.image.palette.length / 3 - 1, palette];
     }
-
-    // For PNG color types 0, 2 and 3, the transparency data is stored in
-    // a dedicated PNG chunk.
     if (this.image.transparency.grayscale != null) {
-      // Use Color Key Masking (spec section 4.8.5)
-      // An array with N elements, where N is two times the number of color components.
       const val = this.image.transparency.grayscale;
       this.obj.data['Mask'] = [val, val];
     } else if (this.image.transparency.rgb) {
-      // Use Color Key Masking (spec section 4.8.5)
-      // An array with N elements, where N is two times the number of color components.
       const {
         rgb
       } = this.image.transparency;
@@ -3849,14 +3650,9 @@ class PNGImage {
       }
       this.obj.data['Mask'] = mask;
     } else if (this.image.transparency.indexed) {
-      // Create a transparency SMask for the image based on the data
-      // in the PLTE and tRNS sections. See below for details on SMasks.
       dataDecoded = true;
       return this.loadIndexedAlphaChannel();
     } else if (hasAlphaChannel) {
-      // For PNG color types 4 and 6, the transparency data is stored as a alpha
-      // channel mixed in with the main image data. Separate this data out into an
-      // SMask object and store it separately in the PDF.
       dataDecoded = true;
       return this.splitAlphaChannel();
     }
@@ -3880,11 +3676,7 @@ class PNGImage {
       sMask.end(this.alphaChannel);
       this.obj.data['SMask'] = sMask;
     }
-
-    // add the actual image data
     this.obj.end(this.imgData);
-
-    // free memory
     this.image = null;
     return this.imgData = null;
   }
@@ -3897,7 +3689,6 @@ class PNGImage {
       const alphaChannel = Buffer.alloc(pixelCount);
       let i = p = a = 0;
       const len = pixels.length;
-      // For 16bit images copy only most significant byte (MSB) - PNG data is always stored in network byte order (MSB first)
       const skipByteCount = this.image.bits === 16 ? 1 : 0;
       while (i < len) {
         for (let colorIndex = 0; colorIndex < colorCount; colorIndex++) {
@@ -3932,10 +3723,6 @@ class PNGImage {
   }
 }
 
-/*
-PDFImage - embeds images in PDF documents
-By Devon Govett
-*/
 class PDFImage {
   static open(src, label) {
     let data;
@@ -3967,17 +3754,16 @@ class PDFImage {
 var ImagesMixin = {
   initImages() {
     this._imageRegistry = {};
-    return this._imageCount = 0;
+    this._imageCount = 0;
   },
   image(src, x, y, options = {}) {
-    let bh, bp, bw, image, ip, left, left1, rotateAngle, originX, originY;
+    let bh, bp, bw, image, ip, left, left1, originX, originY;
     if (typeof x === 'object') {
       options = x;
       x = null;
     }
-
-    // Ignore orientation based on document options or image options
     const ignoreOrientation = options.ignoreOrientation || options.ignoreOrientation !== false && this.options.ignoreOrientation;
+    const inDocumentFlow = typeof y !== 'number';
     x = (left = x != null ? x : options.x) != null ? left : this.x;
     y = (left1 = y != null ? y : options.y) != null ? left1 : this.y;
     if (typeof src === 'string') {
@@ -4000,8 +3786,6 @@ var ImagesMixin = {
       width,
       height
     } = image;
-
-    // If EXIF orientation calls for it, swap width and height
     if (!ignoreOrientation && image.orientation > 4) {
       [width, height] = [height, width];
     }
@@ -4053,80 +3837,70 @@ var ImagesMixin = {
         y = y + bh - h;
       }
     }
+    let rotateAngle = 0;
+    let xTransform = x;
+    let yTransform = y;
+    let hTransform = h;
+    let wTransform = w;
     if (!ignoreOrientation) {
       switch (image.orientation) {
-        // No orientation (need to flip image, though, because of the default transform matrix on the document)
         default:
         case 1:
-          h = -h;
-          y -= h;
-          rotateAngle = 0;
+          hTransform = -h;
+          yTransform += h;
           break;
-        // Flip Horizontal
         case 2:
-          w = -w;
-          h = -h;
-          x -= w;
-          y -= h;
-          rotateAngle = 0;
+          wTransform = -w;
+          hTransform = -h;
+          xTransform += w;
+          yTransform += h;
           break;
-        // Rotate 180 degrees
         case 3:
           originX = x;
           originY = y;
-          h = -h;
-          x -= w;
+          hTransform = -h;
+          xTransform -= w;
           rotateAngle = 180;
           break;
-        // Flip vertical
         case 4:
-          // Do nothing, image will be flipped
-
           break;
-        // Flip horizontally and rotate 270 degrees CW
         case 5:
           originX = x;
           originY = y;
-          [w, h] = [h, w];
-          y -= h;
+          wTransform = h;
+          hTransform = w;
+          yTransform -= hTransform;
           rotateAngle = 90;
           break;
-        // Rotate 90 degrees CW
         case 6:
           originX = x;
           originY = y;
-          [w, h] = [h, w];
-          h = -h;
+          wTransform = h;
+          hTransform = -w;
           rotateAngle = 90;
           break;
-        // Flip horizontally and rotate 90 degrees CW
         case 7:
           originX = x;
           originY = y;
-          [w, h] = [h, w];
-          h = -h;
-          w = -w;
-          x -= w;
+          hTransform = -w;
+          wTransform = -h;
+          xTransform += h;
           rotateAngle = 90;
           break;
-        // Rotate 270 degrees CW
         case 8:
           originX = x;
           originY = y;
-          [w, h] = [h, w];
-          h = -h;
-          x -= w;
-          y -= h;
+          wTransform = h;
+          hTransform = -w;
+          xTransform -= h;
+          yTransform += w;
           rotateAngle = -90;
           break;
       }
     } else {
-      h = -h;
-      y -= h;
-      rotateAngle = 0;
+      hTransform = -h;
+      yTransform += h;
     }
-
-    // create link annotations if the link option is given
     if (options.link != null) {
       this.link(x, y, w, h, options.link);
     }
@@ -4136,9 +3910,7 @@ var ImagesMixin = {
     if (options.destination != null) {
       this.addNamedDestination(options.destination, 'XYZ', x, y, null);
     }
-
-    // Set the current y position to below the image if it is in the document flow
-    if (this.y === y) {
+    if (inDocumentFlow) {
       this.y += h;
     }
     this.save();
@@ -4147,7 +3919,7 @@ var ImagesMixin = {
         origin: [originX, originY]
       });
     }
-    this.transform(w, 0, 0, h, x, y);
+    this.transform(wTransform, 0, 0, hTransform, xTransform, yTransform);
     this.addContent(`/${image.label} Do`);
     this.restore();
     return this;
@@ -4173,19 +3945,17 @@ var AnnotationsMixin = {
     options.Rect = this._convertRect(x, y, w, h);
     options.Border = [0, 0, 0];
     if (options.Subtype === 'Link' && typeof options.F === 'undefined') {
-      options.F = 1 << 2; // Print Annotation Flag
+      options.F = 1 << 2;
     }
     if (options.Subtype !== 'Link') {
       if (options.C == null) {
         options.C = this._normalizeColor(options.color || [0, 0, 0]);
       }
-    } // convert colors
+    }
     delete options.color;
     if (typeof options.Dest === 'string') {
       options.Dest = new String(options.Dest);
     }
-
-    // Capitalize keys
     for (let key in options) {
       const val = options[key];
       options[key[0].toUpperCase() + key.slice(1)] = val;
@@ -4198,7 +3968,9 @@ var AnnotationsMixin = {
   note(x, y, w, h, contents, options = {}) {
     options.Subtype = 'Text';
     options.Contents = new String(contents);
-    options.Name = 'Comment';
+    if (options.Name == null) {
+      options.Name = 'Comment';
+    }
     if (options.color == null) {
       options.color = [243, 223, 92];
     }
@@ -4216,7 +3988,6 @@ var AnnotationsMixin = {
   link(x, y, w, h, url, options = {}) {
     options.Subtype = 'Link';
     if (typeof url === 'number') {
-      // Link to a page in the document (the page must already exist)
       const pages = this._root.data.Pages.data;
       if (url >= 0 && url < pages.Kids.length) {
         options.A = this.ref({
@@ -4228,7 +3999,6 @@ var AnnotationsMixin = {
         throw new Error(`The document has no page ${url}`);
       }
     } else {
-      // Link to an external url
       options.A = this.ref({
         S: 'URI',
         URI: new String(url)
@@ -4281,14 +4051,11 @@ var AnnotationsMixin = {
     return this.annotate(x, y, w, h, options);
   },
   fileAnnotation(x, y, w, h, file = {}, options = {}) {
-    // create hidden file
     const filespec = this.file(file.src, Object.assign({
       hidden: true
     }, file));
     options.Subtype = 'FileAttachment';
     options.FS = filespec;
-
-    // add description from filespec unless description (Contents) has already been set
     if (options.Contents) {
       options.Contents = new String(options.Contents);
     } else if (filespec.data.Desc) {
@@ -4297,14 +4064,9 @@ var AnnotationsMixin = {
     return this.annotate(x, y, w, h, options);
   },
   _convertRect(x1, y1, w, h) {
-    // flip y1 and y2
     let y2 = y1;
     y1 += h;
-
-    // make x2
     let x2 = x1 + w;
-
-    // apply current transformation matrix to points
     const [m0, m1, m2, m3, m4, m5] = this._ctm;
     x1 = m0 * x1 + m2 * y1 + m4;
     y1 = m1 * x1 + m3 * y1 + m5;
@@ -4366,7 +4128,7 @@ class PDFOutline {
 
 var OutlineMixin = {
   initOutline() {
-    return this.outline = new PDFOutline(this, null, null, null);
+    this.outline = new PDFOutline(this, null, null, null);
   },
   endOutline() {
     this.outline.endOutline();
@@ -4377,11 +4139,6 @@ var OutlineMixin = {
   }
 };
 
-/*
-PDFStructureContent - a reference to a marked structure content
-By Ben Schmidt
-*/
-
 class PDFStructureContent {
   constructor(pageRef, mcid) {
     this.refs = [{
@@ -4394,10 +4151,6 @@ class PDFStructureContent {
   }
 }
 
-/*
-PDFStructureElement - represents an element in the PDF logical structure tree
-By Ben Schmidt
-*/
 class PDFStructureElement {
   constructor(document, type, options = {}, children = null) {
     this.document = document;
@@ -4405,7 +4158,6 @@ class PDFStructureElement {
     this._ended = false;
     this._flushed = false;
     this.dictionary = document.ref({
-      // Type: "StructElem",
       S: type
     });
     const data = this.dictionary.data;
@@ -4454,7 +4206,6 @@ class PDFStructureElement {
       this._addContentToParentTree(child);
     }
     if (typeof child === 'function' && this._attached) {
-      // _contentForClosure() adds the content to the parent tree
       child = this._contentForClosure(child);
     }
     this._children.push(child);
@@ -4530,10 +4281,6 @@ class PDFStructureElement {
     this.dictionary.data.K = [];
     this._children.forEach(child => this._flushChild(child));
     this.dictionary.end();
-
-    // free memory used by children; the dictionary itself may still be
-    // referenced by a parent structure element or root, but we can
-    // at least trim the tree here
     this._children = [];
     this.dictionary.data.K = null;
     this._flushed = true;
@@ -4554,7 +4301,7 @@ class PDFStructureElement {
           this.dictionary.data.K.push(mcid);
         } else {
           this.dictionary.data.K.push({
-            Type: "MCR",
+            Type: 'MCR',
             Pg: pageRef,
             MCID: mcid
           });
@@ -4564,25 +4311,18 @@ class PDFStructureElement {
   }
 }
 
-/*
-PDFNumberTree - represents a number tree object
-*/
 class PDFNumberTree extends PDFTree {
   _compareKeys(a, b) {
     return parseInt(a) - parseInt(b);
   }
   _keysName() {
-    return "Nums";
+    return 'Nums';
   }
   _dataForKey(k) {
     return parseInt(k);
   }
 }
 
-/*
-Markings mixin - support marked content sequences in content streams
-By Ben Schmidt
-*/
 var MarkingsMixin = {
   initMarkings(options) {
     this.structChildren = [];
@@ -4701,6 +4441,9 @@ var MarkingsMixin = {
     }
     return this._root.data.MarkInfo;
   },
+  hasMarkInfoDictionary() {
+    return !!this._root.data.MarkInfo;
+  },
   getStructTreeRoot() {
     if (!this._root.data.StructTreeRoot) {
       this._root.data.StructTreeRoot = this.ref({
@@ -4715,7 +4458,6 @@ var MarkingsMixin = {
     return this.getStructTreeRoot().data.ParentTree;
   },
   createStructParentTreeNextKey() {
-    // initialise the MarkInfo dictionary
     this.getMarkInfoDictionary();
     const structTreeRoot = this.getStructTreeRoot();
     const key = structTreeRoot.data.ParentTreeNextKey++;
@@ -4779,10 +4521,6 @@ const FORMAT_DEFAULT = {
   }
 };
 var AcroFormMixin = {
-  /**
-   * Must call if adding AcroForms to a document. Must also call font() before
-   * this method to set the default font.
-   */
   initForm() {
     if (!this._font) {
       throw new Error('Must set a font before calling initForm method');
@@ -4805,9 +4543,6 @@ var AcroFormMixin = {
     this._root.data.AcroForm = AcroForm;
     return this;
   },
-  /**
-   * Called automatically by document.js
-   */
   endAcroForm() {
     if (this._root.data.AcroForm) {
       if (!Object.keys(this._acroform.fonts).length && !this._acroform.defaultFont) {
@@ -4833,38 +4568,18 @@ var AcroFormMixin = {
     }
     return this;
   },
-  /**
-   * Creates and adds a form field to the document. Form fields are intermediate
-   * nodes in a PDF form that are used to specify form name heirarchy and form
-   * value defaults.
-   * @param {string} name - field name (T attribute in field dictionary)
-   * @param {object} options  - other attributes to include in field dictionary
-   */
   formField(name, options = {}) {
     let fieldDict = this._fieldDict(name, null, options);
     let fieldRef = this.ref(fieldDict);
     this._addToParent(fieldRef);
     return fieldRef;
   },
-  /**
-   * Creates and adds a Form Annotation to the document. Form annotations are
-   * called Widget annotations internally within a PDF file.
-   * @param {string} name - form field name (T attribute of widget annotation
-   * dictionary)
-   * @param {number} x
-   * @param {number} y
-   * @param {number} w
-   * @param {number} h
-   * @param {object} options
-   */
   formAnnotation(name, type, x, y, w, h, options = {}) {
     let fieldDict = this._fieldDict(name, type, options);
     fieldDict.Subtype = 'Widget';
     if (fieldDict.F === undefined) {
-      fieldDict.F = 4; // print the annotation
+      fieldDict.F = 4;
     }
-
-    // Add Field annot to page, and get it's ref
     this.annotate(x, y, w, h, fieldDict);
     let annotRef = this.page.annotations[this.page.annotations.length - 1];
     return this._addToParent(annotRef);
@@ -5025,23 +4740,18 @@ var AcroFormMixin = {
       delete options.align;
     }
     if (result !== 0) {
-      options.Q = result; // default
+      options.Q = result;
     }
     return options;
   },
   _resolveFont(options) {
-    // add current font to document-level AcroForm dict if necessary
     if (this._acroform.fonts[this._font.id] == null) {
       this._acroform.fonts[this._font.id] = this._font.ref();
     }
-
-    // add current font to field's resource dict (RD) if not the default acroform font
     if (this._acroform.defaultFont !== this._font.name) {
       options.DR = {
         Font: {}
       };
-
-      // Get the fontSize option. If not set use auto sizing
       const fontSize = options.fontSize || 0;
       options.DR.Font[this._font.id] = this._font.ref();
       options.DA = new String(`/${this._font.id} ${fontSize} Tf 0 g`);
@@ -5093,19 +4803,6 @@ var AcroFormMixin = {
 };
 
 var AttachmentsMixin = {
-  /**
-   * Embed contents of `src` in PDF
-   * @param {Buffer | ArrayBuffer | string} src input Buffer, ArrayBuffer, base64 encoded string or path to file
-   * @param {object} options
-   *  * options.name: filename to be shown in PDF, will use `src` if none set
-   *  * options.type: filetype to be shown in PDF
-   *  * options.description: description to be shown in PDF
-   *  * options.hidden: if true, do not add attachment to EmbeddedFiles dictionary. Useful for file attachment annotations
-   *  * options.creationDate: override creation date
-   *  * options.modifiedDate: override modified date
-   *  * options.relationship: Relationship between the PDF document and its attached file. Can be 'Alternative', 'Data', 'Source', 'Supplement' or 'Unspecified'.
-   * @returns filespec reference
-   */
   file(src, options = {}) {
     options.name = options.name || src;
     options.relationship = options.relationship || 'Unspecified';
@@ -5133,8 +4830,6 @@ var AttachmentsMixin = {
         if (!data) {
           throw new Error(`Could not read contents of file at filepath ${src}`);
         }
-
-        // update CreationDate and ModDate
         const {
           birthtime,
           ctime
@@ -5143,26 +4838,18 @@ var AttachmentsMixin = {
         refBody.Params.ModDate = ctime;
       }
     }
-
-    // override creation date and modified date
     if (options.creationDate instanceof Date) {
       refBody.Params.CreationDate = options.creationDate;
     }
     if (options.modifiedDate instanceof Date) {
       refBody.Params.ModDate = options.modifiedDate;
     }
-    // add optional subtype
     if (options.type) {
       refBody.Subtype = options.type.replace('/', '#2F');
     }
-
-    // add checksum and size information
     const checksum = CryptoJS.MD5(CryptoJS.lib.WordArray.create(new Uint8Array(data)));
     refBody.Params.CheckSum = new String(checksum);
     refBody.Params.Size = data.byteLength;
-
-    // save some space when embedding the same file again
-    // if a file with the same name and metadata exists, reuse its reference
     let ref;
     if (!this._fileRegistry) this._fileRegistry = {};
     let file = this._fileRegistry[options.name];
@@ -5176,7 +4863,6 @@ var AttachmentsMixin = {
         ref
       };
     }
-    // add filespec for embedded file
     const fileSpecBody = {
       Type: 'Filespec',
       AFRelationship: options.relationship,
@@ -5194,8 +4880,6 @@ var AttachmentsMixin = {
     if (!options.hidden) {
       this.addNamedEmbeddedFile(options.name, filespec);
     }
-
-    // Add file to the catalogue to be PDF/A3 compliant
     if (this._root.data.AF) {
       this._root.data.AF.push(filespec);
     } else {
@@ -5204,8 +4888,6 @@ var AttachmentsMixin = {
     return filespec;
   }
 };
-
-/** check two embedded file metadata objects for equality */
 function isEqual(a, b) {
   return a.Subtype === b.Subtype && a.Params.CheckSum.toString() === b.Params.CheckSum.toString() && a.Params.Size === b.Params.Size && a.Params.CreationDate.getTime() === b.Params.CreationDate.getTime() && (a.Params.ModDate === undefined && b.Params.ModDate === undefined || a.Params.ModDate.getTime() === b.Params.ModDate.getTime());
 }
@@ -5216,7 +4898,6 @@ var PDFA = {
       this.subset_conformance = pSubset.charAt(pSubset.length - 1).toUpperCase();
       this.subset = parseInt(pSubset.charAt(pSubset.length - 2));
     } else {
-      // Default to Basic conformance when user doesn't specify
       this.subset_conformance = 'B';
       this.subset = parseInt(pSubset.charAt(pSubset.length - 1));
     }
@@ -5301,6 +4982,642 @@ var SubsetMixin = {
   }
 };
 
+const ROW_FIELDS = ['height', 'minHeight', 'maxHeight'];
+const COLUMN_FIELDS = ['width', 'minWidth', 'maxWidth'];
+function memoize(fn, maxSize) {
+  const cache = new Map();
+  return function (...args) {
+    const key = args[0];
+    if (!cache.has(key)) {
+      cache.set(key, fn(...args));
+      if (cache.size > maxSize) cache.delete(cache.keys().next());
+    }
+    return cache.get(key);
+  };
+}
+function isObject(item) {
+  return item && typeof item === 'object' && !Array.isArray(item);
+}
+function deepMerge(target, ...sources) {
+  if (!isObject(target)) return target;
+  target = deepClone(target);
+  for (const source of sources) {
+    if (isObject(source)) {
+      for (const key in source) {
+        if (isObject(source[key])) {
+          if (!(key in target)) target[key] = {};
+          target[key] = deepMerge(target[key], source[key]);
+        } else if (source[key] !== undefined) {
+          target[key] = deepClone(source[key]);
+        }
+      }
+    }
+  }
+  return target;
+}
+function deepClone(obj) {
+  let result = obj;
+  if (typeof obj == 'object') {
+    result = Array.isArray(obj) ? [] : {};
+    for (const key in obj) result[key] = deepClone(obj[key]);
+  }
+  return result;
+}
+
+function normalizedDefaultStyle(defaultStyleInternal) {
+  let defaultStyle = defaultStyleInternal;
+  if (typeof defaultStyle !== 'object') defaultStyle = {
+    text: defaultStyle
+  };
+  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);
+  defaultStyle.align = normalizeAlignment(defaultStyle.align);
+  return {
+    defaultStyle,
+    defaultRowStyle,
+    defaultColStyle
+  };
+}
+function normalizedRowStyle(defaultRowStyle, rowStyleInternal, i) {
+  let rowStyle = rowStyleInternal(i);
+  if (rowStyle == null || typeof rowStyle !== 'object') {
+    rowStyle = {
+      height: rowStyle
+    };
+  }
+  rowStyle.padding = normalizeSides(rowStyle.padding);
+  rowStyle.border = normalizeSides(rowStyle.border);
+  rowStyle.borderColor = normalizeSides(rowStyle.borderColor);
+  rowStyle.align = normalizeAlignment(rowStyle.align);
+  rowStyle = deepMerge(defaultRowStyle, rowStyle);
+  const document = this.document;
+  const page = document.page;
+  const contentHeight = page.contentHeight;
+  if (rowStyle.height == null || rowStyle.height === 'auto') {
+    rowStyle.height = 'auto';
+  } else {
+    rowStyle.height = document.sizeToPoint(rowStyle.height, 0, page, contentHeight);
+  }
+  rowStyle.minHeight = document.sizeToPoint(rowStyle.minHeight, 0, page, contentHeight);
+  rowStyle.maxHeight = document.sizeToPoint(rowStyle.maxHeight, 0, page, contentHeight);
+  return rowStyle;
+}
+function normalizedColumnStyle(defaultColStyle, colStyleInternal, i) {
+  let colStyle = colStyleInternal(i);
+  if (colStyle == null || typeof colStyle !== 'object') {
+    colStyle = {
+      width: colStyle
+    };
+  }
+  colStyle.padding = normalizeSides(colStyle.padding);
+  colStyle.border = normalizeSides(colStyle.border);
+  colStyle.borderColor = normalizeSides(colStyle.borderColor);
+  colStyle.align = normalizeAlignment(colStyle.align);
+  colStyle = deepMerge(defaultColStyle, colStyle);
+  if (colStyle.width == null || colStyle.width === '*') {
+    colStyle.width = '*';
+  } else {
+    colStyle.width = this.document.sizeToPoint(colStyle.width, 0, this.document.page, this._maxWidth);
+  }
+  colStyle.minWidth = this.document.sizeToPoint(colStyle.minWidth, 0, this.document.page, this._maxWidth);
+  colStyle.maxWidth = this.document.sizeToPoint(colStyle.maxWidth, 0, this.document.page, this._maxWidth);
+  return colStyle;
+}
+function normalizeAlignment(align) {
+  return align == null || typeof align === 'string' ? {
+    x: align,
+    y: align
+  } : align;
+}
+
+function normalizeTable() {
+  const doc = this.document;
+  const opts = this.opts;
+  let index = doc._tableIndex++;
+  this._id = new String(opts.id ?? `table-${index}`);
+  this._position = {
+    x: doc.sizeToPoint(opts.position?.x, doc.x),
+    y: doc.sizeToPoint(opts.position?.y, doc.y)
+  };
+  this._maxWidth = doc.sizeToPoint(opts.maxWidth, doc.page.width - doc.page.margins.right - this._position.x);
+  const {
+    defaultStyle,
+    defaultColStyle,
+    defaultRowStyle
+  } = normalizedDefaultStyle(opts.defaultStyle);
+  this._defaultStyle = defaultStyle;
+  let colStyle;
+  if (opts.columnStyles) {
+    if (Array.isArray(opts.columnStyles)) {
+      colStyle = i => opts.columnStyles[i];
+    } else if (typeof opts.columnStyles === 'function') {
+      colStyle = memoize(i => opts.columnStyles(i), Infinity);
+    } else if (typeof opts.columnStyles === 'object') {
+      colStyle = () => opts.columnStyles;
+    }
+  }
+  if (!colStyle) colStyle = () => ({});
+  this._colStyle = normalizedColumnStyle.bind(this, defaultColStyle, colStyle);
+  let rowStyle;
+  if (opts.rowStyles) {
+    if (Array.isArray(opts.rowStyles)) {
+      rowStyle = i => opts.rowStyles[i];
+    } else if (typeof opts.rowStyles === 'function') {
+      rowStyle = memoize(i => opts.rowStyles(i), 10);
+    } else if (typeof opts.rowStyles === 'object') {
+      rowStyle = () => opts.rowStyles;
+    }
+  }
+  if (!rowStyle) rowStyle = () => ({});
+  this._rowStyle = normalizedRowStyle.bind(this, defaultRowStyle, rowStyle);
+}
+function normalizeText(text) {
+  if (text != null) text = `${text}`;
+  return text;
+}
+function normalizeCell(cell, rowIndex, colIndex) {
+  const colStyle = this._colStyle(colIndex);
+  let rowStyle = this._rowStyle(rowIndex);
+  const font = deepMerge({}, colStyle.font, rowStyle.font, cell.font);
+  const customFont = Object.values(font).filter(v => v != null).length > 0;
+  const doc = this.document;
+  const rollbackFont = doc._fontSource;
+  const rollbackFontSize = doc._fontSize;
+  const rollbackFontFamily = doc._fontFamily;
+  if (customFont) {
+    if (font.src) doc.font(font.src, font.family);
+    if (font.size) doc.fontSize(font.size);
+    rowStyle = this._rowStyle(rowIndex);
+  }
+  cell.padding = normalizeSides(cell.padding);
+  cell.border = normalizeSides(cell.border);
+  cell.borderColor = normalizeSides(cell.borderColor);
+  const config = deepMerge(this._defaultStyle, colStyle, rowStyle, cell);
+  config.rowIndex = rowIndex;
+  config.colIndex = colIndex;
+  config.font = font ?? {};
+  config.customFont = customFont;
+  config.text = normalizeText(config.text);
+  config.rowSpan = config.rowSpan ?? 1;
+  config.colSpan = config.colSpan ?? 1;
+  config.padding = normalizeSides(config.padding, '0.25em', x => doc.sizeToPoint(x, '0.25em'));
+  config.border = normalizeSides(config.border, 1, x => doc.sizeToPoint(x, 1));
+  config.borderColor = normalizeSides(config.borderColor, 'black', x => x ?? 'black');
+  config.align = normalizeAlignment(config.align);
+  config.align.x = config.align.x ?? 'left';
+  config.align.y = config.align.y ?? 'top';
+  config.textStroke = doc.sizeToPoint(config.textStroke, 0);
+  config.textStrokeColor = config.textStrokeColor ?? 'black';
+  config.textColor = config.textColor ?? 'black';
+  config.textOptions = config.textOptions ?? {};
+  config.id = new String(config.id ?? `${this._id}-${rowIndex}-${colIndex}`);
+  config.type = config.type?.toUpperCase() === 'TH' ? 'TH' : 'TD';
+  if (config.scope) {
+    config.scope = config.scope.toLowerCase();
+    if (config.scope === 'row') config.scope = 'Row';else if (config.scope === 'both') config.scope = 'Both';else if (config.scope === 'column') config.scope = 'Column';
+  }
+  if (typeof this.opts.debug === 'boolean') config.debug = this.opts.debug;
+  if (customFont) doc.font(rollbackFont, rollbackFontFamily, rollbackFontSize);
+  return config;
+}
+function normalizeRow(row, rowIndex) {
+  if (!this._cellClaim) this._cellClaim = new Set();
+  let colIndex = 0;
+  return row.map(cell => {
+    if (cell == null || typeof cell !== 'object') cell = {
+      text: cell
+    };
+    while (this._cellClaim.has(`${rowIndex},${colIndex}`)) {
+      colIndex++;
+    }
+    cell = normalizeCell.call(this, cell, rowIndex, colIndex);
+    for (let i = 0; i < cell.rowSpan; i++) {
+      for (let j = 0; j < cell.colSpan; j++) {
+        this._cellClaim.add(`${rowIndex + i},${colIndex + j}`);
+      }
+    }
+    colIndex += cell.colSpan;
+    return cell;
+  });
+}
+
+function ensure(row) {
+  this._columnWidths = [];
+  ensureColumnWidths.call(this, row.reduce((a, cell) => a + cell.colSpan, 0));
+  this._rowHeights = [];
+  this._rowYPos = [this._position.y];
+  this._rowBuffer = new Set();
+}
+function ensureColumnWidths(numCols) {
+  let starColumnIndexes = [];
+  let starMinAcc = 0;
+  let unclaimedWidth = this._maxWidth;
+  for (let i = 0; i < numCols; i++) {
+    let col = this._colStyle(i);
+    if (col.width === '*') {
+      starColumnIndexes[i] = col;
+      starMinAcc += col.minWidth;
+    } else {
+      unclaimedWidth -= col.width;
+      this._columnWidths[i] = col.width;
+    }
+  }
+  let starColCount = starColumnIndexes.reduce(x => x + 1, 0);
+  if (starMinAcc >= unclaimedWidth) {
+    starColumnIndexes.forEach((cell, i) => {
+      this._columnWidths[i] = cell.minWidth;
+    });
+  } else if (starColCount > 0) {
+    starColumnIndexes.forEach((col, i) => {
+      let starSize = unclaimedWidth / starColCount;
+      this._columnWidths[i] = Math.max(starSize, col.minWidth);
+      if (col.maxWidth > 0) {
+        this._columnWidths[i] = Math.min(this._columnWidths[i], col.maxWidth);
+      }
+      unclaimedWidth -= this._columnWidths[i];
+      starColCount--;
+    });
+  }
+  let tempX = this._position.x;
+  this._columnXPos = Array.from(this._columnWidths, v => {
+    const t = tempX;
+    tempX += v;
+    return t;
+  });
+}
+function measure(row, rowIndex) {
+  row.forEach(cell => this._rowBuffer.add(cell));
+  if (rowIndex > 0) {
+    this._rowYPos[rowIndex] = this._rowYPos[rowIndex - 1] + this._rowHeights[rowIndex - 1];
+  }
+  const rowStyle = this._rowStyle(rowIndex);
+  let toRender = [];
+  this._rowBuffer.forEach(cell => {
+    if (cell.rowIndex + cell.rowSpan - 1 === rowIndex) {
+      toRender.push(measureCell.call(this, cell, rowStyle.height));
+      this._rowBuffer.delete(cell);
+    }
+  });
+  let rowHeight = rowStyle.height;
+  if (rowHeight === 'auto') {
+    rowHeight = toRender.reduce((acc, cell) => {
+      let minHeight = cell.textBounds.height + cell.padding.top + cell.padding.bottom;
+      for (let i = 0; i < cell.rowSpan - 1; i++) {
+        minHeight -= this._rowHeights[cell.rowIndex + i];
+      }
+      return Math.max(acc, minHeight);
+    }, 0);
+  }
+  rowHeight = Math.max(rowHeight, rowStyle.minHeight);
+  if (rowStyle.maxHeight > 0) {
+    rowHeight = Math.min(rowHeight, rowStyle.maxHeight);
+  }
+  this._rowHeights[rowIndex] = rowHeight;
+  let newPage = false;
+  if (rowHeight > this.document.page.contentHeight) {
+    console.warn(new Error(`Row ${rowIndex} requested more than the safe page height, row has been clamped`).stack.slice(7));
+    this._rowHeights[rowIndex] = this.document.page.maxY() - this._rowYPos[rowIndex];
+  } else if (this._rowYPos[rowIndex] + rowHeight >= this.document.page.maxY()) {
+    this._rowYPos[rowIndex] = this.document.page.margins.top;
+    newPage = true;
+  }
+  return {
+    newPage,
+    toRender: toRender.map(cell => measureCell.call(this, cell, rowHeight))
+  };
+}
+function measureCell(cell, rowHeight) {
+  let cellWidth = 0;
+  for (let i = 0; i < cell.colSpan; i++) {
+    cellWidth += this._columnWidths[cell.colIndex + i];
+  }
+  let cellHeight = rowHeight;
+  if (cellHeight === 'auto') {
+    cellHeight = this.document.page.contentHeight;
+  } else {
+    for (let i = 0; i < cell.rowSpan - 1; i++) {
+      cellHeight += this._rowHeights[cell.rowIndex + i];
+    }
+  }
+  const textAllocatedWidth = cellWidth - cell.padding.left - cell.padding.right;
+  const textAllocatedHeight = cellHeight - cell.padding.top - cell.padding.bottom;
+  const rotation = cell.textOptions.rotation ?? 0;
+  const {
+    width: textMaxWidth,
+    height: textMaxHeight
+  } = computeBounds(rotation, textAllocatedWidth, textAllocatedHeight);
+  const textOptions = {
+    align: cell.align.x,
+    ellipsis: true,
+    stroke: cell.textStroke > 0,
+    fill: true,
+    width: textMaxWidth,
+    height: textMaxHeight,
+    rotation,
+    ...cell.textOptions
+  };
+  let textBounds = {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  };
+  if (cell.text) {
+    const rollbackFont = this.document._fontSource;
+    const rollbackFontSize = this.document._fontSize;
+    const rollbackFontFamily = this.document._fontFamily;
+    if (cell.font?.src) this.document.font(cell.font.src, cell.font?.family);
+    if (cell.font?.size) this.document.fontSize(cell.font.size);
+    const unRotatedTextBounds = this.document.boundsOfString(cell.text, 0, 0, {
+      ...textOptions,
+      rotation: 0
+    });
+    textOptions.width = unRotatedTextBounds.width;
+    textOptions.height = unRotatedTextBounds.height;
+    textBounds = this.document.boundsOfString(cell.text, 0, 0, textOptions);
+    this.document.font(rollbackFont, rollbackFontFamily, rollbackFontSize);
+  }
+  return {
+    ...cell,
+    textOptions,
+    x: this._columnXPos[cell.colIndex],
+    y: this._rowYPos[cell.rowIndex],
+    textX: this._columnXPos[cell.colIndex] + cell.padding.left,
+    textY: this._rowYPos[cell.rowIndex] + cell.padding.top,
+    width: cellWidth,
+    height: cellHeight,
+    textAllocatedHeight,
+    textAllocatedWidth,
+    textBounds
+  };
+}
+function computeBounds(rotation, allocWidth, allocHeight) {
+  let textMaxWidth, textMaxHeight;
+  const cos = cosine(rotation);
+  const sin = sine(rotation);
+  if (rotation === 0 || rotation === 180) {
+    textMaxWidth = allocWidth;
+    textMaxHeight = allocHeight;
+  } else if (rotation === 90 || rotation === 270) {
+    textMaxWidth = allocHeight;
+    textMaxHeight = allocWidth;
+  } else if (rotation < 90 || rotation > 180 && rotation < 270) {
+    textMaxWidth = allocWidth / (2 * cos);
+    textMaxHeight = allocWidth / (2 * sin);
+  } else {
+    textMaxHeight = allocWidth / (2 * cos);
+    textMaxWidth = allocWidth / (2 * sin);
+  }
+  const EF = sin * textMaxWidth;
+  const FG = cos * textMaxHeight;
+  if (EF + FG > allocHeight) {
+    const denominator = cos * cos - sin * sin;
+    if (rotation === 0 || rotation === 180) {
+      textMaxWidth = allocWidth;
+      textMaxHeight = allocHeight;
+    } else if (rotation === 90 || rotation === 270) {
+      textMaxWidth = allocHeight;
+      textMaxHeight = allocWidth;
+    } else if (rotation < 90 || rotation > 180 && rotation < 270) {
+      textMaxWidth = (allocWidth * cos - allocHeight * sin) / denominator;
+      textMaxHeight = (allocHeight * cos - allocWidth * sin) / denominator;
+    } else {
+      textMaxHeight = (allocWidth * cos - allocHeight * sin) / denominator;
+      textMaxWidth = (allocHeight * cos - allocWidth * sin) / denominator;
+    }
+  }
+  return {
+    width: Math.abs(textMaxWidth),
+    height: Math.abs(textMaxHeight)
+  };
+}
+
+function accommodateTable() {
+  const structParent = this.opts.structParent;
+  if (structParent) {
+    this._tableStruct = this.document.struct('Table');
+    this._tableStruct.dictionary.data.ID = this._id;
+    if (structParent instanceof PDFStructureElement) {
+      structParent.add(this._tableStruct);
+    } else if (structParent instanceof PDFDocument) {
+      structParent.addStructure(this._tableStruct);
+    }
+    this._headerRowLookup = {};
+    this._headerColumnLookup = {};
+  }
+}
+function accommodateCleanup() {
+  if (this._tableStruct) this._tableStruct.end();
+}
+function accessibleRow(row, rowIndex, renderCell) {
+  const rowStruct = this.document.struct('TR');
+  rowStruct.dictionary.data.ID = new String(`${this._id}-${rowIndex}`);
+  this._tableStruct.add(rowStruct);
+  row.forEach(cell => renderCell(cell, rowStruct));
+  rowStruct.end();
+}
+function accessibleCell(cell, rowStruct, callback) {
+  const doc = this.document;
+  const cellStruct = doc.struct(cell.type, {
+    title: cell.title
+  });
+  cellStruct.dictionary.data.ID = cell.id;
+  rowStruct.add(cellStruct);
+  const padding = cell.padding;
+  const border = cell.border;
+  const attributes = {
+    O: 'Table',
+    Width: cell.width,
+    Height: cell.height,
+    Padding: [padding.top, padding.bottom, padding.left, padding.right],
+    RowSpan: cell.rowSpan > 1 ? cell.rowSpan : undefined,
+    ColSpan: cell.colSpan > 1 ? cell.colSpan : undefined,
+    BorderThickness: [border.top, border.bottom, border.left, border.right]
+  };
+  if (cell.type === 'TH') {
+    if (cell.scope === 'Row' || cell.scope === 'Both') {
+      for (let i = 0; i < cell.rowSpan; i++) {
+        if (!this._headerRowLookup[cell.rowIndex + i]) {
+          this._headerRowLookup[cell.rowIndex + i] = [];
+        }
+        this._headerRowLookup[cell.rowIndex + i].push(cell.id);
+      }
+      attributes.Scope = cell.scope;
+    }
+    if (cell.scope === 'Column' || cell.scope === 'Both') {
+      for (let i = 0; i < cell.colSpan; i++) {
+        if (!this._headerColumnLookup[cell.colIndex + i]) {
+          this._headerColumnLookup[cell.colIndex + i] = [];
+        }
+        this._headerColumnLookup[cell.colIndex + i].push(cell.id);
+      }
+      attributes.Scope = cell.scope;
+    }
+  }
+  const Headers = new Set([...Array.from({
+    length: cell.colSpan
+  }, (_, i) => this._headerColumnLookup[cell.colIndex + i]).flat(), ...Array.from({
+    length: cell.rowSpan
+  }, (_, i) => this._headerRowLookup[cell.rowIndex + i]).flat()].filter(Boolean));
+  if (Headers.size) attributes.Headers = Array.from(Headers);
+  const normalizeColor = doc._normalizeColor;
+  if (cell.backgroundColor != null) {
+    attributes.BackgroundColor = normalizeColor(cell.backgroundColor);
+  }
+  const hasBorder = [border.top, border.bottom, border.left, border.right];
+  if (hasBorder.some(x => x)) {
+    const borderColor = cell.borderColor;
+    attributes.BorderColor = [hasBorder[0] ? normalizeColor(borderColor.top) : null, hasBorder[1] ? normalizeColor(borderColor.bottom) : null, hasBorder[2] ? normalizeColor(borderColor.left) : null, hasBorder[3] ? normalizeColor(borderColor.right) : null];
+  }
+  Object.keys(attributes).forEach(key => attributes[key] === undefined && delete attributes[key]);
+  cellStruct.dictionary.data.A = doc.ref(attributes);
+  cellStruct.add(callback);
+  cellStruct.end();
+  cellStruct.dictionary.data.A.end();
+}
+
+function renderRow(row, rowIndex) {
+  if (this._tableStruct) {
+    accessibleRow.call(this, row, rowIndex, renderCell.bind(this));
+  } else {
+    row.forEach(cell => renderCell.call(this, cell));
+  }
+  return this._rowYPos[rowIndex] + this._rowHeights[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();
+    }
+    renderBorder.call(this, cell.border, cell.borderColor, cell.x, cell.y, cell.width, cell.height);
+    if (cell.debug) {
+      this.document.save();
+      this.document.dash(1, {
+        space: 1
+      }).lineWidth(1).strokeOpacity(0.3);
+      this.document.rect(cell.x, cell.y, cell.width, cell.height).stroke('green');
+      this.document.restore();
+    }
+    if (cell.text) renderCellText.call(this, cell);
+  };
+  if (rowStruct) accessibleCell.call(this, cell, rowStruct, cellRenderer);else cellRenderer();
+}
+function renderCellText(cell) {
+  const doc = this.document;
+  const rollbackFont = doc._fontSource;
+  const rollbackFontSize = doc._fontSize;
+  const rollbackFontFamily = doc._fontFamily;
+  if (cell.customFont) {
+    if (cell.font.src) doc.font(cell.font.src, cell.font.family);
+    if (cell.font.size) doc.fontSize(cell.font.size);
+  }
+  const x = cell.textX;
+  const y = cell.textY;
+  const Ah = cell.textAllocatedHeight;
+  const Aw = cell.textAllocatedWidth;
+  const Cw = cell.textBounds.width;
+  const Ch = cell.textBounds.height;
+  const Ox = -cell.textBounds.x;
+  const Oy = -cell.textBounds.y;
+  const PxScale = cell.align.x === 'right' ? 1 : cell.align.x === 'center' ? 0.5 : 0;
+  const Px = (Aw - Cw) * PxScale;
+  const PyScale = cell.align.y === 'bottom' ? 1 : cell.align.y === 'center' ? 0.5 : 0;
+  const Py = (Ah - Ch) * PyScale;
+  const dx = Px + Ox;
+  const dy = Py + Oy;
+  if (cell.debug) {
+    doc.save();
+    doc.dash(1, {
+      space: 1
+    }).lineWidth(1).strokeOpacity(0.3);
+    if (cell.text) {
+      doc.moveTo(x + Px, y).lineTo(x + Px, y + Ah).moveTo(x + Px + Cw, y).lineTo(x + Px + Cw, y + Ah).stroke('blue').moveTo(x, y + Py).lineTo(x + Aw, y + Py).moveTo(x, y + Py + Ch).lineTo(x + Aw, y + Py + Ch).stroke('green');
+    }
+    doc.rect(x, y, Aw, Ah).stroke('orange');
+    doc.restore();
+  }
+  doc.save().rect(x, y, Aw, Ah).clip();
+  doc.fillColor(cell.textColor).strokeColor(cell.textStrokeColor);
+  if (cell.textStroke > 0) doc.lineWidth(cell.textStroke);
+  doc.text(cell.text, x + dx, y + dy, cell.textOptions);
+  doc.restore();
+  if (cell.font) doc.font(rollbackFont, rollbackFontFamily, rollbackFontSize);
+}
+function renderBorder(border, borderColor, x, y, width, height, mask) {
+  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();
+    }
+  } else {
+    if (border.top > 0) {
+      doc.save().lineWidth(border.top).moveTo(x, y).lineTo(x + width, y).stroke(borderColor.top).restore();
+    }
+    if (border.right > 0) {
+      doc.save().lineWidth(border.right).moveTo(x + width, y).lineTo(x + width, y + height).stroke(borderColor.right).restore();
+    }
+    if (border.bottom > 0) {
+      doc.save().lineWidth(border.bottom).moveTo(x + width, y + height).lineTo(x, y + height).stroke(borderColor.bottom).restore();
+    }
+    if (border.left > 0) {
+      doc.save().lineWidth(border.left).moveTo(x, y + height).lineTo(x, y).stroke(borderColor.left).restore();
+    }
+  }
+}
+
+class PDFTable {
+  constructor(document, opts = {}) {
+    this.document = document;
+    this.opts = Object.freeze(opts);
+    normalizeTable.call(this);
+    accommodateTable.call(this);
+    this._currRowIndex = 0;
+    this._ended = false;
+    if (opts.data) {
+      for (const row of opts.data) this.row(row);
+      return this.end();
+    }
+  }
+  row(row, lastRow = false) {
+    if (this._ended) {
+      throw new Error(`Table was marked as ended on row ${this._currRowIndex}`);
+    }
+    row = Array.from(row);
+    row = normalizeRow.call(this, row, this._currRowIndex);
+    if (this._currRowIndex === 0) ensure.call(this, row);
+    const {
+      newPage,
+      toRender
+    } = measure.call(this, row, this._currRowIndex);
+    if (newPage) this.document.continueOnNewPage();
+    const yPos = renderRow.call(this, toRender, this._currRowIndex);
+    this.document.x = this._position.x;
+    this.document.y = yPos;
+    if (lastRow) return this.end();
+    this._currRowIndex++;
+    return this;
+  }
+  end() {
+    while (this._rowBuffer?.size) this.row([]);
+    this._ended = true;
+    accommodateCleanup.call(this);
+    return this.document;
+  }
+}
+
+var TableMixin = {
+  initTables() {
+    this._tableIndex = 0;
+  },
+  table(opts) {
+    return new PDFTable(this, opts);
+  }
+};
+
 class PDFMetadata {
   constructor() {
     this._metadata = `
@@ -5342,7 +5659,7 @@ var MetadataMixin = {
   _addInfo() {
     this.appendXML(`
         <rdf:Description rdf:about="" xmlns:xmp="http://ns.adobe.com/xap/1.0/">
-            <xmp:CreateDate>${this.info.CreationDate.toISOString().split('.')[0] + "Z"}</xmp:CreateDate>
+            <xmp:CreateDate>${this.info.CreationDate.toISOString().split('.')[0] + 'Z'}</xmp:CreateDate>
             <xmp:CreatorTool>${this.info.Creator}</xmp:CreatorTool>
         </rdf:Description>
         `);
@@ -5395,11 +5712,6 @@ var MetadataMixin = {
   endMetadata() {
     this._addInfo();
     this.metadata.end();
-
-    /*
-    Metadata was introduced in PDF 1.4, so adding it to 1.3 
-    will likely only take up more space.
-    */
     if (this.version != 1.3) {
       this.metadataRef = this.ref({
         length: this.metadata.getLength(),
@@ -5414,16 +5726,10 @@ var MetadataMixin = {
   }
 };
 
-/*
-PDFDocument - represents an entire PDF document
-By Devon Govett
-*/
 class PDFDocument extends stream.Readable {
   constructor(options = {}) {
     super(options);
     this.options = options;
-
-    // PDF version
     switch (options.pdfVersion) {
       case '1.4':
         this.version = 1.4;
@@ -5442,13 +5748,9 @@ class PDFDocument extends stream.Readable {
         this.version = 1.3;
         break;
     }
-
-    // Whether streams should be compressed
     this.compress = this.options.compress != null ? this.options.compress : true;
     this._pageBuffer = [];
     this._pageBufferStart = 0;
-
-    // The PDF object store
     this._offsets = [];
     this._waiting = 0;
     this._ended = false;
@@ -5469,11 +5771,7 @@ class PDFDocument extends stream.Readable {
     if (this.options.lang) {
       this._root.data.Lang = new String(this.options.lang);
     }
-
-    // The current page
     this.page = null;
-
-    // Initialize mixins
     this.initMetadata();
     this.initColor();
     this.initVector();
@@ -5482,9 +5780,8 @@ class PDFDocument extends stream.Readable {
     this.initImages();
     this.initOutline();
     this.initMarkings(options);
+    this.initTables();
     this.initSubset(options);
-
-    // Initialize the metadata
     this.info = {
       Producer: 'PDFKit',
       Creator: 'PDFKit',
@@ -5501,21 +5798,10 @@ class PDFDocument extends stream.Readable {
         DisplayDocTitle: true
       });
     }
-
-    // Generate file ID
     this._id = PDFSecurity.generateFileID(this.info);
-
-    // Initialize security settings
     this._security = PDFSecurity.create(this, options);
-
-    // Write the header
-    // PDF version
     this._write(`%PDF-${this.version}`);
-
-    // 4 binary chars, as recommended by the spec
     this._write('%\xFF\xFF\xFF\xFF');
-
-    // Add the first page
     if (this.options.autoFirstPage !== false) {
       this.addPage();
     }
@@ -5526,27 +5812,16 @@ class PDFDocument extends stream.Readable {
         options
       } = this);
     }
-
-    // end the current page if needed
     if (!this.options.bufferPages) {
       this.flushPages();
     }
-
-    // create a page object
     this.page = new PDFPage(this, options);
     this._pageBuffer.push(this.page);
-
-    // add the page to the object store
     const pages = this._root.data.Pages.data;
     pages.Kids.push(this.page.dictionary);
     pages.Count++;
-
-    // reset x and y coordinates
     this.x = this.page.margins.left;
     this.y = this.page.margins.top;
-
-    // flip PDF coordinate system so that the origin is in
-    // the top left rather than the bottom left
     this._ctm = [1, 0, 0, 1, 0, 0];
     this.transform(1, 0, 0, -1, 0, this.page.height);
     this.emit('pageAdded');
@@ -5554,7 +5829,7 @@ class PDFDocument extends stream.Readable {
   }
   continueOnNewPage(options) {
     const pageMarkings = this.endPageMarkings(this.page);
-    this.addPage(options);
+    this.addPage(options ?? this.page._options);
     this.initPageMarkings(pageMarkings);
     return this;
   }
@@ -5572,8 +5847,6 @@ class PDFDocument extends stream.Readable {
     return this.page = page;
   }
   flushPages() {
-    // this local variable exists so we're future-proof against
-    // reentrant calls to flushPages.
     const pages = this._pageBuffer;
     this._pageBuffer = [];
     this._pageBufferStart += pages.length;
@@ -5594,13 +5867,10 @@ class PDFDocument extends stream.Readable {
   }
   addNamedEmbeddedFile(name, ref) {
     if (!this._root.data.Names.data.EmbeddedFiles) {
-      // disabling /Limits for this tree fixes attachments not showing in Adobe Reader
       this._root.data.Names.data.EmbeddedFiles = new PDFNameTree({
         limits: false
       });
     }
-
-    // add filespec to EmbeddedFiles
     this._root.data.Names.data.EmbeddedFiles.add(name, ref);
   }
   addNamedJavaScript(name, js) {
@@ -5615,19 +5885,17 @@ class PDFDocument extends stream.Readable {
   }
   ref(data) {
     const ref = new PDFReference(this, this._offsets.length + 1, data);
-    this._offsets.push(null); // placeholder for this object's offset once it is finalized
+    this._offsets.push(null);
     this._waiting++;
     return ref;
   }
   _read() {}
-  // do nothing, but this method is required by node
-
   _write(data) {
     if (!Buffer.isBuffer(data)) {
       data = Buffer.from(data + '\n', 'binary');
     }
     this.push(data);
-    return this._offset += data.length;
+    this._offset += data.length;
   }
   addContent(data) {
     this.page.write(data);
@@ -5637,7 +5905,7 @@ class PDFDocument extends stream.Readable {
     this._offsets[ref.id - 1] = ref.offset;
     if (--this._waiting === 0 && this._ended) {
       this._finalize();
-      return this._ended = false;
+      this._ended = false;
     }
   }
   end() {
@@ -5674,13 +5942,12 @@ class PDFDocument extends stream.Readable {
       this._security.end();
     }
     if (this._waiting === 0) {
-      return this._finalize();
+      this._finalize();
     } else {
-      return this._ended = true;
+      this._ended = true;
     }
   }
   _finalize() {
-    // generate xref
     const xRefOffset = this._offset;
     this._write('xref');
     this._write(`0 ${this._offsets.length + 1}`);
@@ -5689,8 +5956,6 @@ class PDFDocument extends stream.Readable {
       offset = `0000000000${offset}`.slice(-10);
       this._write(offset + ' 00000 n ');
     }
-
-    // trailer
     const trailer = {
       Size: this._offsets.length + 1,
       Root: this._root,
@@ -5705,9 +5970,7 @@ class PDFDocument extends stream.Readable {
     this._write('startxref');
     this._write(`${xRefOffset}`);
     this._write('%%EOF');
-
-    // end the stream
-    return this.push(null);
+    this.push(null);
   }
   toString() {
     return '[object PDFDocument]';
@@ -5728,6 +5991,7 @@ mixin(MarkingsMixin);
 mixin(AcroFormMixin);
 mixin(AttachmentsMixin);
 mixin(SubsetMixin);
+mixin(TableMixin);
 PDFDocument.LineWrapper = LineWrapper;
 
 module.exports = PDFDocument;