@cantoo/fontkit 2.0.4 → 2.0.6

package/src/packages/unicode-trie/dist/index.cjs

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -45,6 +46,9 @@ var swap32LE = (array) => {
 };
 
 // index.js
+function isNodeBuffer(value) {
+  return typeof value === "object" && value !== null && "readUInt32BE" in value && "readUInt32LE" in value && "slice" in value && typeof value.readUInt32BE === "function" && typeof value.readUInt32LE === "function" && typeof value.slice === "function";
+}
 var SHIFT_1 = 6 + 5;
 var SHIFT_2 = 5;
 var SHIFT_1_2 = SHIFT_1 - SHIFT_2;
@@ -62,29 +66,38 @@ var UTF8_2B_INDEX_2_LENGTH = 2048 >> 6;
 var INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
 var DATA_GRANULARITY = 1 << INDEX_SHIFT;
 var UnicodeTrie = class {
+  /**
+   * @param {Uint8Array | Buffer | UnicodeTrieInit} data
+   */
   constructor(data) {
-    const isBuffer = typeof data.readUInt32BE === "function" && typeof data.slice === "function";
-    if (isBuffer || data instanceof Uint8Array) {
+    if (isNodeBuffer(data) || data instanceof Uint8Array) {
+      let bytes;
       let uncompressedLength;
-      if (isBuffer) {
+      if (isNodeBuffer(data)) {
         this.highStart = data.readUInt32LE(0);
         this.errorValue = data.readUInt32LE(4);
         uncompressedLength = data.readUInt32LE(8);
-        data = data.slice(12);
+        bytes = new Uint8Array(data.buffer, data.byteOffset + 12, data.byteLength - 12);
       } else {
         const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
         this.highStart = view.getUint32(0, true);
         this.errorValue = view.getUint32(4, true);
         uncompressedLength = view.getUint32(8, true);
-        data = data.subarray(12);
+        bytes = data.subarray(12);
       }
-      data = (0, import_fflate.inflateSync)(data, { out: new Uint8Array(uncompressedLength) });
-      swap32LE(data);
-      this.data = new Uint32Array(data.buffer, data.byteOffset, data.byteLength >> 2);
+      bytes = (0, import_fflate.inflateSync)(bytes, { out: new Uint8Array(uncompressedLength) });
+      swap32LE(bytes);
+      this.data = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);
     } else {
-      ({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);
+      this.data = data.data;
+      this.highStart = data.highStart;
+      this.errorValue = data.errorValue;
     }
   }
+  /**
+   * @param {number} codePoint
+   * @returns {number}
+   */
   get(codePoint) {
     let index;
     if (codePoint < 0 || codePoint > 1114111) {

package/src/packages/unicode-trie/dist/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../index.js", "../swap.js"],
-  "sourcesContent": ["import { inflateSync } from 'fflate';\nimport { swap32LE } from './swap.js';\n\n// Shift size for getting the index-1 table offset.\nconst SHIFT_1 = 6 + 5;\n\n// Shift size for getting the index-2 table offset.\nconst SHIFT_2 = 5;\n\n// Difference between the two shift sizes,\n// for getting an index-1 offset from an index-2 offset. 6=11-5\nconst SHIFT_1_2 = SHIFT_1 - SHIFT_2;\n\n// Number of index-1 entries for the BMP. 32=0x20\n// This part of the index-1 table is omitted from the serialized form.\nconst OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> SHIFT_1;\n\n// Number of entries in an index-2 block. 64=0x40\nconst INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;\n\n// Mask for getting the lower bits for the in-index-2-block offset. */\nconst INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;\n\n// Shift size for shifting left the index array values.\n// Increases possible data size with 16-bit index values at the cost\n// of compactability.\n// This requires data blocks to be aligned by DATA_GRANULARITY.\nconst INDEX_SHIFT = 2;\n\n// Number of entries in a data block. 32=0x20\nconst DATA_BLOCK_LENGTH = 1 << SHIFT_2;\n\n// Mask for getting the lower bits for the in-data-block offset.\nconst DATA_MASK = DATA_BLOCK_LENGTH - 1;\n\n// The part of the index-2 table for U+D800..U+DBFF stores values for\n// lead surrogate code _units_ not code _points_.\n// Values for lead surrogate code _points_ are indexed with this portion of the table.\n// Length=32=0x20=0x400>>SHIFT_2. (There are 1024=0x400 lead surrogates.)\nconst LSCP_INDEX_2_OFFSET = 0x10000 >> SHIFT_2;\nconst LSCP_INDEX_2_LENGTH = 0x400 >> SHIFT_2;\n\n// Count the lengths of both BMP pieces. 2080=0x820\nconst INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;\n\n// The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.\n// Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.\nconst UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;\nconst UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6;  // U+0800 is the first code point after 2-byte UTF-8\n\n// The index-1 table, only used for supplementary code points, at offset 2112=0x840.\n// Variable length, for code points up to highStart, where the last single-value range starts.\n// Maximum length 512=0x200=0x100000>>SHIFT_1.\n// (For 0x100000 supplementary code points U+10000..U+10ffff.)\n//\n// The part of the index-2 table for supplementary code points starts\n// after this index-1 table.\n//\n// Both the index-1 table and the following part of the index-2 table\n// are omitted completely if there is only BMP data.\nconst INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;\n\n// The alignment size of a data block. Also the granularity for compaction.\nconst DATA_GRANULARITY = 1 << INDEX_SHIFT;\n\nclass UnicodeTrie {\n  constructor(data) {\n    const isBuffer = (typeof data.readUInt32BE === 'function') && (typeof data.slice === 'function');\n\n    if (isBuffer || data instanceof Uint8Array) {\n      // read binary format\n      let uncompressedLength;\n      if (isBuffer) {\n        this.highStart = data.readUInt32LE(0);\n        this.errorValue = data.readUInt32LE(4);\n        uncompressedLength = data.readUInt32LE(8);\n        data = data.slice(12);\n      } else {\n        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n        this.highStart = view.getUint32(0, true);\n        this.errorValue = view.getUint32(4, true);\n        uncompressedLength = view.getUint32(8, true);\n        data = data.subarray(12);\n      }\n\n      // inflate the actual trie data (raw deflate, matching builder)\n      data = inflateSync(data, { out: new Uint8Array(uncompressedLength) });\n\n      // swap bytes from little-endian\n      swap32LE(data);\n\n      this.data = new Uint32Array(data.buffer, data.byteOffset, data.byteLength >> 2);\n\n    } else {\n      // pre-parsed data\n      ({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);\n    }\n  }\n\n  get(codePoint) {\n    let index;\n    if ((codePoint < 0) || (codePoint > 0x10ffff)) {\n      return this.errorValue;\n    }\n\n    if ((codePoint < 0xd800) || ((codePoint > 0xdbff) && (codePoint <= 0xffff))) {\n      // Ordinary BMP code point, excluding leading surrogates.\n      // BMP uses a single level lookup.  BMP index starts at offset 0 in the index.\n      // data is stored in the index array itself.\n      index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint <= 0xffff) {\n      // Lead Surrogate Code Point.  A Separate index section is stored for\n      // lead surrogate code units and code points.\n      //   The main index has the code unit data.\n      //   For this function, we need the code point data.\n      index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint < this.highStart) {\n      // Supplemental code point, use two-level lookup.\n      index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];\n      index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];\n      index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    return this.data[this.data.length - DATA_GRANULARITY];\n  }\n}\n\nexport default UnicodeTrie;\n", "const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);\n\nconst swap = (b, n, m) => {\n  let i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n};\n\nconst swap32 = array => {\n  const len = array.length;\n  for (let i = 0; i < len; i += 4) {\n    swap(array, i, i + 3);\n    swap(array, i + 1, i + 2);\n  }\n};\n\nexport const swap32LE = array => {\n  if (isBigEndian) {\n    swap32(array);\n  }\n};\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { inflateSync } from 'fflate';\nimport { swap32LE } from './swap.js';\n\n/**\n * Pre-parsed trie payload (e.g. from UnicodeTrieBuilder.freeze).\n * @typedef {object} UnicodeTrieInit\n * @property {Int32Array | Uint32Array} data\n * @property {number} highStart\n * @property {number} errorValue\n */\n\n/**\n * Duck-type Node Buffer (has LE/BE readers + slice), matching prior runtime checks.\n * @param {unknown} value\n * @returns {value is Buffer}\n */\nfunction isNodeBuffer(value) {\n  return (\n    typeof value === 'object'\n    && value !== null\n    && 'readUInt32BE' in value\n    && 'readUInt32LE' in value\n    && 'slice' in value\n    && typeof value.readUInt32BE === 'function'\n    && typeof value.readUInt32LE === 'function'\n    && typeof value.slice === 'function'\n  );\n}\n\n// Shift size for getting the index-1 table offset.\nconst SHIFT_1 = 6 + 5;\n\n// Shift size for getting the index-2 table offset.\nconst SHIFT_2 = 5;\n\n// Difference between the two shift sizes,\n// for getting an index-1 offset from an index-2 offset. 6=11-5\nconst SHIFT_1_2 = SHIFT_1 - SHIFT_2;\n\n// Number of index-1 entries for the BMP. 32=0x20\n// This part of the index-1 table is omitted from the serialized form.\nconst OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> SHIFT_1;\n\n// Number of entries in an index-2 block. 64=0x40\nconst INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;\n\n// Mask for getting the lower bits for the in-index-2-block offset. */\nconst INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;\n\n// Shift size for shifting left the index array values.\n// Increases possible data size with 16-bit index values at the cost\n// of compactability.\n// This requires data blocks to be aligned by DATA_GRANULARITY.\nconst INDEX_SHIFT = 2;\n\n// Number of entries in a data block. 32=0x20\nconst DATA_BLOCK_LENGTH = 1 << SHIFT_2;\n\n// Mask for getting the lower bits for the in-data-block offset.\nconst DATA_MASK = DATA_BLOCK_LENGTH - 1;\n\n// The part of the index-2 table for U+D800..U+DBFF stores values for\n// lead surrogate code _units_ not code _points_.\n// Values for lead surrogate code _points_ are indexed with this portion of the table.\n// Length=32=0x20=0x400>>SHIFT_2. (There are 1024=0x400 lead surrogates.)\nconst LSCP_INDEX_2_OFFSET = 0x10000 >> SHIFT_2;\nconst LSCP_INDEX_2_LENGTH = 0x400 >> SHIFT_2;\n\n// Count the lengths of both BMP pieces. 2080=0x820\nconst INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;\n\n// The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.\n// Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.\nconst UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;\nconst UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6; // U+0800 is the first code point after 2-byte UTF-8\n\n// The index-1 table, only used for supplementary code points, at offset 2112=0x840.\n// Variable length, for code points up to highStart, where the last single-value range starts.\n// Maximum length 512=0x200=0x100000>>SHIFT_1.\n// (For 0x100000 supplementary code points U+10000..U+10ffff.)\n//\n// The part of the index-2 table for supplementary code points starts\n// after this index-1 table.\n//\n// Both the index-1 table and the following part of the index-2 table\n// are omitted completely if there is only BMP data.\nconst INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;\n\n// The alignment size of a data block. Also the granularity for compaction.\nconst DATA_GRANULARITY = 1 << INDEX_SHIFT;\n\nclass UnicodeTrie {\n  /**\n   * @param {Uint8Array | Buffer | UnicodeTrieInit} data\n   */\n  constructor(data) {\n    if (isNodeBuffer(data) || data instanceof Uint8Array) {\n      // read binary format\n      /** @type {Uint8Array} */\n      let bytes;\n      let uncompressedLength;\n      if (isNodeBuffer(data)) {\n        this.highStart = data.readUInt32LE(0);\n        this.errorValue = data.readUInt32LE(4);\n        uncompressedLength = data.readUInt32LE(8);\n        // View past the 12-byte header (avoids Buffer.slice \u2192 Uint8Array assignability issues).\n        bytes = new Uint8Array(data.buffer, data.byteOffset + 12, data.byteLength - 12);\n      } else {\n        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n        this.highStart = view.getUint32(0, true);\n        this.errorValue = view.getUint32(4, true);\n        uncompressedLength = view.getUint32(8, true);\n        bytes = data.subarray(12);\n      }\n\n      // inflate the actual trie data (raw deflate, matching builder)\n      bytes = inflateSync(bytes, { out: new Uint8Array(uncompressedLength) });\n\n      // swap bytes from little-endian\n      swap32LE(bytes);\n\n      /**\n       * Compacted index + data table.\n       * @type {Uint32Array | Int32Array}\n       */\n      this.data = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);\n    } else {\n      // pre-parsed data\n      /**\n       * Compacted index + data table.\n       * @type {Uint32Array | Int32Array}\n       */\n      this.data = data.data;\n      /**\n       * First code point of the final single-value range.\n       * @type {number}\n       */\n      this.highStart = data.highStart;\n      /**\n       * Value returned for out-of-range code points.\n       * @type {number}\n       */\n      this.errorValue = data.errorValue;\n    }\n  }\n\n  /**\n   * @param {number} codePoint\n   * @returns {number}\n   */\n  get(codePoint) {\n    let index;\n    if ((codePoint < 0) || (codePoint > 0x10ffff)) {\n      return this.errorValue;\n    }\n\n    if ((codePoint < 0xd800) || ((codePoint > 0xdbff) && (codePoint <= 0xffff))) {\n      // Ordinary BMP code point, excluding leading surrogates.\n      // BMP uses a single level lookup.  BMP index starts at offset 0 in the index.\n      // data is stored in the index array itself.\n      index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint <= 0xffff) {\n      // Lead Surrogate Code Point.  A Separate index section is stored for\n      // lead surrogate code units and code points.\n      //   The main index has the code unit data.\n      //   For this function, we need the code point data.\n      index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint < this.highStart) {\n      // Supplemental code point, use two-level lookup.\n      index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];\n      index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];\n      index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    return this.data[this.data.length - DATA_GRANULARITY];\n  }\n}\n\nexport default UnicodeTrie;\n", "const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);\n\n/**\n * @param {Uint8Array} b\n * @param {number} n\n * @param {number} m\n */\nconst swap = (b, n, m) => {\n  let i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n};\n\n/**\n * @param {Uint8Array} array\n */\nconst swap32 = (array) => {\n  const len = array.length;\n  for (let i = 0; i < len; i += 4) {\n    swap(array, i, i + 3);\n    swap(array, i + 1, i + 2);\n  }\n};\n\n/**\n * Swap byte order of each 32-bit word in-place when running on a big-endian host,\n * so the trie data is little-endian as expected by the runtime.\n * @param {Uint8Array} array\n */\nexport const swap32LE = (array) => {\n  if (isBigEndian) {\n    swap32(array);\n  }\n};\n"],
+  "mappings": "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",
   "names": []
 }

package/src/packages/unicode-trie/dist/index.mjs

@@ -22,6 +22,9 @@ var swap32LE = (array) => {
 };
 
 // index.js
+function isNodeBuffer(value) {
+  return typeof value === "object" && value !== null && "readUInt32BE" in value && "readUInt32LE" in value && "slice" in value && typeof value.readUInt32BE === "function" && typeof value.readUInt32LE === "function" && typeof value.slice === "function";
+}
 var SHIFT_1 = 6 + 5;
 var SHIFT_2 = 5;
 var SHIFT_1_2 = SHIFT_1 - SHIFT_2;
@@ -39,29 +42,38 @@ var UTF8_2B_INDEX_2_LENGTH = 2048 >> 6;
 var INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
 var DATA_GRANULARITY = 1 << INDEX_SHIFT;
 var UnicodeTrie = class {
+  /**
+   * @param {Uint8Array | Buffer | UnicodeTrieInit} data
+   */
   constructor(data) {
-    const isBuffer = typeof data.readUInt32BE === "function" && typeof data.slice === "function";
-    if (isBuffer || data instanceof Uint8Array) {
+    if (isNodeBuffer(data) || data instanceof Uint8Array) {
+      let bytes;
       let uncompressedLength;
-      if (isBuffer) {
+      if (isNodeBuffer(data)) {
         this.highStart = data.readUInt32LE(0);
         this.errorValue = data.readUInt32LE(4);
         uncompressedLength = data.readUInt32LE(8);
-        data = data.slice(12);
+        bytes = new Uint8Array(data.buffer, data.byteOffset + 12, data.byteLength - 12);
       } else {
         const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
         this.highStart = view.getUint32(0, true);
         this.errorValue = view.getUint32(4, true);
         uncompressedLength = view.getUint32(8, true);
-        data = data.subarray(12);
+        bytes = data.subarray(12);
       }
-      data = inflateSync(data, { out: new Uint8Array(uncompressedLength) });
-      swap32LE(data);
-      this.data = new Uint32Array(data.buffer, data.byteOffset, data.byteLength >> 2);
+      bytes = inflateSync(bytes, { out: new Uint8Array(uncompressedLength) });
+      swap32LE(bytes);
+      this.data = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);
     } else {
-      ({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);
+      this.data = data.data;
+      this.highStart = data.highStart;
+      this.errorValue = data.errorValue;
     }
   }
+  /**
+   * @param {number} codePoint
+   * @returns {number}
+   */
   get(codePoint) {
     let index;
     if (codePoint < 0 || codePoint > 1114111) {

package/src/packages/unicode-trie/dist/index.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../index.js", "../swap.js"],
-  "sourcesContent": ["import { inflateSync } from 'fflate';\nimport { swap32LE } from './swap.js';\n\n// Shift size for getting the index-1 table offset.\nconst SHIFT_1 = 6 + 5;\n\n// Shift size for getting the index-2 table offset.\nconst SHIFT_2 = 5;\n\n// Difference between the two shift sizes,\n// for getting an index-1 offset from an index-2 offset. 6=11-5\nconst SHIFT_1_2 = SHIFT_1 - SHIFT_2;\n\n// Number of index-1 entries for the BMP. 32=0x20\n// This part of the index-1 table is omitted from the serialized form.\nconst OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> SHIFT_1;\n\n// Number of entries in an index-2 block. 64=0x40\nconst INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;\n\n// Mask for getting the lower bits for the in-index-2-block offset. */\nconst INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;\n\n// Shift size for shifting left the index array values.\n// Increases possible data size with 16-bit index values at the cost\n// of compactability.\n// This requires data blocks to be aligned by DATA_GRANULARITY.\nconst INDEX_SHIFT = 2;\n\n// Number of entries in a data block. 32=0x20\nconst DATA_BLOCK_LENGTH = 1 << SHIFT_2;\n\n// Mask for getting the lower bits for the in-data-block offset.\nconst DATA_MASK = DATA_BLOCK_LENGTH - 1;\n\n// The part of the index-2 table for U+D800..U+DBFF stores values for\n// lead surrogate code _units_ not code _points_.\n// Values for lead surrogate code _points_ are indexed with this portion of the table.\n// Length=32=0x20=0x400>>SHIFT_2. (There are 1024=0x400 lead surrogates.)\nconst LSCP_INDEX_2_OFFSET = 0x10000 >> SHIFT_2;\nconst LSCP_INDEX_2_LENGTH = 0x400 >> SHIFT_2;\n\n// Count the lengths of both BMP pieces. 2080=0x820\nconst INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;\n\n// The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.\n// Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.\nconst UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;\nconst UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6;  // U+0800 is the first code point after 2-byte UTF-8\n\n// The index-1 table, only used for supplementary code points, at offset 2112=0x840.\n// Variable length, for code points up to highStart, where the last single-value range starts.\n// Maximum length 512=0x200=0x100000>>SHIFT_1.\n// (For 0x100000 supplementary code points U+10000..U+10ffff.)\n//\n// The part of the index-2 table for supplementary code points starts\n// after this index-1 table.\n//\n// Both the index-1 table and the following part of the index-2 table\n// are omitted completely if there is only BMP data.\nconst INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;\n\n// The alignment size of a data block. Also the granularity for compaction.\nconst DATA_GRANULARITY = 1 << INDEX_SHIFT;\n\nclass UnicodeTrie {\n  constructor(data) {\n    const isBuffer = (typeof data.readUInt32BE === 'function') && (typeof data.slice === 'function');\n\n    if (isBuffer || data instanceof Uint8Array) {\n      // read binary format\n      let uncompressedLength;\n      if (isBuffer) {\n        this.highStart = data.readUInt32LE(0);\n        this.errorValue = data.readUInt32LE(4);\n        uncompressedLength = data.readUInt32LE(8);\n        data = data.slice(12);\n      } else {\n        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n        this.highStart = view.getUint32(0, true);\n        this.errorValue = view.getUint32(4, true);\n        uncompressedLength = view.getUint32(8, true);\n        data = data.subarray(12);\n      }\n\n      // inflate the actual trie data (raw deflate, matching builder)\n      data = inflateSync(data, { out: new Uint8Array(uncompressedLength) });\n\n      // swap bytes from little-endian\n      swap32LE(data);\n\n      this.data = new Uint32Array(data.buffer, data.byteOffset, data.byteLength >> 2);\n\n    } else {\n      // pre-parsed data\n      ({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);\n    }\n  }\n\n  get(codePoint) {\n    let index;\n    if ((codePoint < 0) || (codePoint > 0x10ffff)) {\n      return this.errorValue;\n    }\n\n    if ((codePoint < 0xd800) || ((codePoint > 0xdbff) && (codePoint <= 0xffff))) {\n      // Ordinary BMP code point, excluding leading surrogates.\n      // BMP uses a single level lookup.  BMP index starts at offset 0 in the index.\n      // data is stored in the index array itself.\n      index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint <= 0xffff) {\n      // Lead Surrogate Code Point.  A Separate index section is stored for\n      // lead surrogate code units and code points.\n      //   The main index has the code unit data.\n      //   For this function, we need the code point data.\n      index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint < this.highStart) {\n      // Supplemental code point, use two-level lookup.\n      index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];\n      index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];\n      index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    return this.data[this.data.length - DATA_GRANULARITY];\n  }\n}\n\nexport default UnicodeTrie;\n", "const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);\n\nconst swap = (b, n, m) => {\n  let i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n};\n\nconst swap32 = array => {\n  const len = array.length;\n  for (let i = 0; i < len; i += 4) {\n    swap(array, i, i + 3);\n    swap(array, i + 1, i + 2);\n  }\n};\n\nexport const swap32LE = array => {\n  if (isBigEndian) {\n    swap32(array);\n  }\n};\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { inflateSync } from 'fflate';\nimport { swap32LE } from './swap.js';\n\n/**\n * Pre-parsed trie payload (e.g. from UnicodeTrieBuilder.freeze).\n * @typedef {object} UnicodeTrieInit\n * @property {Int32Array | Uint32Array} data\n * @property {number} highStart\n * @property {number} errorValue\n */\n\n/**\n * Duck-type Node Buffer (has LE/BE readers + slice), matching prior runtime checks.\n * @param {unknown} value\n * @returns {value is Buffer}\n */\nfunction isNodeBuffer(value) {\n  return (\n    typeof value === 'object'\n    && value !== null\n    && 'readUInt32BE' in value\n    && 'readUInt32LE' in value\n    && 'slice' in value\n    && typeof value.readUInt32BE === 'function'\n    && typeof value.readUInt32LE === 'function'\n    && typeof value.slice === 'function'\n  );\n}\n\n// Shift size for getting the index-1 table offset.\nconst SHIFT_1 = 6 + 5;\n\n// Shift size for getting the index-2 table offset.\nconst SHIFT_2 = 5;\n\n// Difference between the two shift sizes,\n// for getting an index-1 offset from an index-2 offset. 6=11-5\nconst SHIFT_1_2 = SHIFT_1 - SHIFT_2;\n\n// Number of index-1 entries for the BMP. 32=0x20\n// This part of the index-1 table is omitted from the serialized form.\nconst OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> SHIFT_1;\n\n// Number of entries in an index-2 block. 64=0x40\nconst INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;\n\n// Mask for getting the lower bits for the in-index-2-block offset. */\nconst INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;\n\n// Shift size for shifting left the index array values.\n// Increases possible data size with 16-bit index values at the cost\n// of compactability.\n// This requires data blocks to be aligned by DATA_GRANULARITY.\nconst INDEX_SHIFT = 2;\n\n// Number of entries in a data block. 32=0x20\nconst DATA_BLOCK_LENGTH = 1 << SHIFT_2;\n\n// Mask for getting the lower bits for the in-data-block offset.\nconst DATA_MASK = DATA_BLOCK_LENGTH - 1;\n\n// The part of the index-2 table for U+D800..U+DBFF stores values for\n// lead surrogate code _units_ not code _points_.\n// Values for lead surrogate code _points_ are indexed with this portion of the table.\n// Length=32=0x20=0x400>>SHIFT_2. (There are 1024=0x400 lead surrogates.)\nconst LSCP_INDEX_2_OFFSET = 0x10000 >> SHIFT_2;\nconst LSCP_INDEX_2_LENGTH = 0x400 >> SHIFT_2;\n\n// Count the lengths of both BMP pieces. 2080=0x820\nconst INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;\n\n// The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.\n// Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.\nconst UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;\nconst UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6; // U+0800 is the first code point after 2-byte UTF-8\n\n// The index-1 table, only used for supplementary code points, at offset 2112=0x840.\n// Variable length, for code points up to highStart, where the last single-value range starts.\n// Maximum length 512=0x200=0x100000>>SHIFT_1.\n// (For 0x100000 supplementary code points U+10000..U+10ffff.)\n//\n// The part of the index-2 table for supplementary code points starts\n// after this index-1 table.\n//\n// Both the index-1 table and the following part of the index-2 table\n// are omitted completely if there is only BMP data.\nconst INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;\n\n// The alignment size of a data block. Also the granularity for compaction.\nconst DATA_GRANULARITY = 1 << INDEX_SHIFT;\n\nclass UnicodeTrie {\n  /**\n   * @param {Uint8Array | Buffer | UnicodeTrieInit} data\n   */\n  constructor(data) {\n    if (isNodeBuffer(data) || data instanceof Uint8Array) {\n      // read binary format\n      /** @type {Uint8Array} */\n      let bytes;\n      let uncompressedLength;\n      if (isNodeBuffer(data)) {\n        this.highStart = data.readUInt32LE(0);\n        this.errorValue = data.readUInt32LE(4);\n        uncompressedLength = data.readUInt32LE(8);\n        // View past the 12-byte header (avoids Buffer.slice \u2192 Uint8Array assignability issues).\n        bytes = new Uint8Array(data.buffer, data.byteOffset + 12, data.byteLength - 12);\n      } else {\n        const view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n        this.highStart = view.getUint32(0, true);\n        this.errorValue = view.getUint32(4, true);\n        uncompressedLength = view.getUint32(8, true);\n        bytes = data.subarray(12);\n      }\n\n      // inflate the actual trie data (raw deflate, matching builder)\n      bytes = inflateSync(bytes, { out: new Uint8Array(uncompressedLength) });\n\n      // swap bytes from little-endian\n      swap32LE(bytes);\n\n      /**\n       * Compacted index + data table.\n       * @type {Uint32Array | Int32Array}\n       */\n      this.data = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);\n    } else {\n      // pre-parsed data\n      /**\n       * Compacted index + data table.\n       * @type {Uint32Array | Int32Array}\n       */\n      this.data = data.data;\n      /**\n       * First code point of the final single-value range.\n       * @type {number}\n       */\n      this.highStart = data.highStart;\n      /**\n       * Value returned for out-of-range code points.\n       * @type {number}\n       */\n      this.errorValue = data.errorValue;\n    }\n  }\n\n  /**\n   * @param {number} codePoint\n   * @returns {number}\n   */\n  get(codePoint) {\n    let index;\n    if ((codePoint < 0) || (codePoint > 0x10ffff)) {\n      return this.errorValue;\n    }\n\n    if ((codePoint < 0xd800) || ((codePoint > 0xdbff) && (codePoint <= 0xffff))) {\n      // Ordinary BMP code point, excluding leading surrogates.\n      // BMP uses a single level lookup.  BMP index starts at offset 0 in the index.\n      // data is stored in the index array itself.\n      index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint <= 0xffff) {\n      // Lead Surrogate Code Point.  A Separate index section is stored for\n      // lead surrogate code units and code points.\n      //   The main index has the code unit data.\n      //   For this function, we need the code point data.\n      index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    if (codePoint < this.highStart) {\n      // Supplemental code point, use two-level lookup.\n      index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];\n      index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];\n      index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);\n      return this.data[index];\n    }\n\n    return this.data[this.data.length - DATA_GRANULARITY];\n  }\n}\n\nexport default UnicodeTrie;\n", "const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);\n\n/**\n * @param {Uint8Array} b\n * @param {number} n\n * @param {number} m\n */\nconst swap = (b, n, m) => {\n  let i = b[n];\n  b[n] = b[m];\n  b[m] = i;\n};\n\n/**\n * @param {Uint8Array} array\n */\nconst swap32 = (array) => {\n  const len = array.length;\n  for (let i = 0; i < len; i += 4) {\n    swap(array, i, i + 3);\n    swap(array, i + 1, i + 2);\n  }\n};\n\n/**\n * Swap byte order of each 32-bit word in-place when running on a big-endian host,\n * so the trie data is little-endian as expected by the runtime.\n * @param {Uint8Array} array\n */\nexport const swap32LE = (array) => {\n  if (isBigEndian) {\n    swap32(array);\n  }\n};\n"],
+  "mappings": "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",
   "names": []
 }

package/src/packages/unicode-trie/index.js

@@ -1,6 +1,32 @@
 import { inflateSync } from 'fflate';
 import { swap32LE } from './swap.js';
 
+/**
+ * Pre-parsed trie payload (e.g. from UnicodeTrieBuilder.freeze).
+ * @typedef {object} UnicodeTrieInit
+ * @property {Int32Array | Uint32Array} data
+ * @property {number} highStart
+ * @property {number} errorValue
+ */
+
+/**
+ * Duck-type Node Buffer (has LE/BE readers + slice), matching prior runtime checks.
+ * @param {unknown} value
+ * @returns {value is Buffer}
+ */
+function isNodeBuffer(value) {
+  return (
+    typeof value === 'object'
+    && value !== null
+    && 'readUInt32BE' in value
+    && 'readUInt32LE' in value
+    && 'slice' in value
+    && typeof value.readUInt32BE === 'function'
+    && typeof value.readUInt32LE === 'function'
+    && typeof value.slice === 'function'
+  );
+}
+
 // Shift size for getting the index-1 table offset.
 const SHIFT_1 = 6 + 5;
 
@@ -46,7 +72,7 @@ const INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
 // The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.
 // Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.
 const UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
-const UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6;  // U+0800 is the first code point after 2-byte UTF-8
+const UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6; // U+0800 is the first code point after 2-byte UTF-8
 
 // The index-1 table, only used for supplementary code points, at offset 2112=0x840.
 // Variable length, for code points up to highStart, where the last single-value range starts.
@@ -64,39 +90,64 @@ const INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
 const DATA_GRANULARITY = 1 << INDEX_SHIFT;
 
 class UnicodeTrie {
+  /**
+   * @param {Uint8Array | Buffer | UnicodeTrieInit} data
+   */
   constructor(data) {
-    const isBuffer = (typeof data.readUInt32BE === 'function') && (typeof data.slice === 'function');
-
-    if (isBuffer || data instanceof Uint8Array) {
+    if (isNodeBuffer(data) || data instanceof Uint8Array) {
       // read binary format
+      /** @type {Uint8Array} */
+      let bytes;
       let uncompressedLength;
-      if (isBuffer) {
+      if (isNodeBuffer(data)) {
         this.highStart = data.readUInt32LE(0);
         this.errorValue = data.readUInt32LE(4);
         uncompressedLength = data.readUInt32LE(8);
-        data = data.slice(12);
+        // View past the 12-byte header (avoids Buffer.slice → Uint8Array assignability issues).
+        bytes = new Uint8Array(data.buffer, data.byteOffset + 12, data.byteLength - 12);
       } else {
         const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
         this.highStart = view.getUint32(0, true);
         this.errorValue = view.getUint32(4, true);
         uncompressedLength = view.getUint32(8, true);
-        data = data.subarray(12);
+        bytes = data.subarray(12);
       }
 
       // inflate the actual trie data (raw deflate, matching builder)
-      data = inflateSync(data, { out: new Uint8Array(uncompressedLength) });
+      bytes = inflateSync(bytes, { out: new Uint8Array(uncompressedLength) });
 
       // swap bytes from little-endian
-      swap32LE(data);
-
-      this.data = new Uint32Array(data.buffer, data.byteOffset, data.byteLength >> 2);
+      swap32LE(bytes);
 
+      /**
+       * Compacted index + data table.
+       * @type {Uint32Array | Int32Array}
+       */
+      this.data = new Uint32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength >> 2);
     } else {
       // pre-parsed data
-      ({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);
+      /**
+       * Compacted index + data table.
+       * @type {Uint32Array | Int32Array}
+       */
+      this.data = data.data;
+      /**
+       * First code point of the final single-value range.
+       * @type {number}
+       */
+      this.highStart = data.highStart;
+      /**
+       * Value returned for out-of-range code points.
+       * @type {number}
+       */
+      this.errorValue = data.errorValue;
     }
   }
 
+  /**
+   * @param {number} codePoint
+   * @returns {number}
+   */
   get(codePoint) {
     let index;
     if ((codePoint < 0) || (codePoint > 0x10ffff)) {

package/src/packages/unicode-trie/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cantoo/unicode-trie",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Unicode Trie data structure for fast character metadata lookup, ported from ICU (fflate, no tiny-inflate/pako)",
   "type": "module",
   "main": "./dist/index.cjs",

package/src/packages/unicode-trie/swap.js

@@ -1,12 +1,20 @@
 const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);
 
+/**
+ * @param {Uint8Array} b
+ * @param {number} n
+ * @param {number} m
+ */
 const swap = (b, n, m) => {
   let i = b[n];
   b[n] = b[m];
   b[m] = i;
 };
 
-const swap32 = array => {
+/**
+ * @param {Uint8Array} array
+ */
+const swap32 = (array) => {
   const len = array.length;
   for (let i = 0; i < len; i += 4) {
     swap(array, i, i + 3);
@@ -14,7 +22,12 @@ const swap32 = array => {
   }
 };
 
-export const swap32LE = array => {
+/**
+ * Swap byte order of each 32-bit word in-place when running on a big-endian host,
+ * so the trie data is little-endian as expected by the runtime.
+ * @param {Uint8Array} array
+ */
+export const swap32LE = (array) => {
   if (isBigEndian) {
     swap32(array);
   }

package/src/subset/CFFSubset.js

@@ -2,39 +2,84 @@ import Subset from './Subset';
 import CFFTop from '../cff/CFFTop';
 import standardStrings from '../cff/CFFStandardStrings';
 
+/** @typedef {import('../../types/fontkit').SubsetFont} SubsetFont */
+/** @typedef {import('../../types/fontkit').CFFFontLike} CFFFontLike */
+/** @typedef {import('../../types/fontkit').CFFTopDict} CFFTopDict */
+/** @typedef {import('../../types/fontkit').CFFCharString} CFFCharString */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('restructure').StructValue} StructValue */
+
 export default class CFFSubset extends Subset {
+  /** @type {CFFFontLike} */
+  cff;
+  /** @type {BinaryBuffer[] | null} */
+  charstrings = null;
+  /** @type {BinaryBuffer[] | null} */
+  gsubrs = null;
+  /** @type {string[] | null} */
+  strings = null;
+
+  /**
+   * @param {SubsetFont} font
+   */
   constructor(font) {
     super(font);
 
-    this.cff = this.font['CFF '];
-    if (!this.cff) {
+    let cff = this.font['CFF '];
+    if (!cff) {
       throw new Error('Not a CFF Font');
     }
+    this.cff = cff;
   }
 
-  includeTable() {
+  /**
+   * @param {string} [_tag]
+   * @returns {never}
+   */
+  includeTable(_tag) {
     throw new Error('includeTable is only supported for TrueType (glyf) subsets, not CFF.');
   }
 
+  /**
+   * @returns {void}
+   */
   subsetCharstrings() {
     this.charstrings = [];
+    /** @type {Record<string, boolean>} */
     let gsubrs = {};
 
     for (let gid of this.glyphs) {
+      if (!this.cff.getCharString) {
+        throw new Error('CFF font missing getCharString()');
+      }
       this.charstrings.push(this.cff.getCharString(gid));
 
       let glyph = this.font.getGlyph(gid);
+      if (!glyph) {
+        continue;
+      }
       void glyph.path; // this causes the glyph to be parsed
 
-      for (let subr in glyph._usedGsubrs) {
-        gsubrs[subr] = true;
+      if (glyph._usedGsubrs) {
+        for (let subr in glyph._usedGsubrs) {
+          gsubrs[subr] = true;
+        }
       }
     }
 
-    this.gsubrs = this.subsetSubrs(this.cff.globalSubrIndex, gsubrs);
+    this.gsubrs = this.subsetSubrs(
+      /** @type {Array<{ offset: number, length: number }>} */ (this.cff.globalSubrIndex || []),
+      gsubrs
+    );
   }
 
+  /**
+   * @param {Array<{ offset: number, length: number }>} subrs
+   * @param {Record<string | number, boolean>} used
+   * @returns {BinaryBuffer[]}
+   */
   subsetSubrs(subrs, used) {
+    /** @type {BinaryBuffer[]} */
     let res = [];
     for (let i = 0; i < subrs.length; i++) {
       let subr = subrs[i];
@@ -49,6 +94,10 @@ export default class CFFSubset extends Subset {
     return res;
   }
 
+  /**
+   * @param {CFFTopDict} topDict
+   * @returns {void}
+   */
   subsetFontdict(topDict) {
     topDict.FDArray = [];
     topDict.FDSelect = {
@@ -56,28 +105,42 @@ export default class CFFSubset extends Subset {
       fds: []
     };
 
+    /** @type {Record<number, boolean>} */
     let used_fds = {};
+    /** @type {Array<Record<string, boolean>>} */
     let used_subrs = [];
+    /** @type {Record<number, number>} */
     let fd_select = {};
     for (let gid of this.glyphs) {
+      if (!this.cff.fdForGlyph) {
+        continue;
+      }
       let fd = this.cff.fdForGlyph(gid);
       if (fd == null) {
         continue;
       }
 
       if (!used_fds[fd]) {
-        topDict.FDArray.push(Object.assign({}, this.cff.topDict.FDArray[fd]));
+        let src = this.cff.topDict.FDArray && this.cff.topDict.FDArray[fd];
+        topDict.FDArray.push(Object.assign({}, src));
         used_subrs.push({});
         fd_select[fd] = topDict.FDArray.length - 1;
       }
 
       used_fds[fd] = true;
-      topDict.FDSelect.fds.push(fd_select[fd]);
+      if (topDict.FDSelect.fds) {
+        topDict.FDSelect.fds.push(fd_select[fd]);
+      }
 
       let glyph = this.font.getGlyph(gid);
+      if (!glyph) {
+        continue;
+      }
       void glyph.path; // this causes the glyph to be parsed
-      for (let subr in glyph._usedSubrs) {
-        used_subrs[fd_select[fd]][subr] = true;
+      if (glyph._usedSubrs) {
+        for (let subr in glyph._usedSubrs) {
+          used_subrs[fd_select[fd]][subr] = true;
+        }
       }
     }
 
@@ -86,38 +149,59 @@ export default class CFFSubset extends Subset {
       delete dict.FontName;
       if (dict.Private && dict.Private.Subrs) {
         dict.Private = Object.assign({}, dict.Private);
-        dict.Private.Subrs = this.subsetSubrs(dict.Private.Subrs, used_subrs[i]);
+        dict.Private.Subrs = this.subsetSubrs(
+          /** @type {Array<{ offset: number, length: number }>} */ (dict.Private.Subrs),
+          used_subrs[i]
+        );
       }
     }
 
     return;
   }
 
+  /**
+   * @param {CFFTopDict} topDict
+   * @returns {StructValue}
+   */
   createCIDFontdict(topDict) {
+    /** @type {Record<string, boolean>} */
     let used_subrs = {};
     for (let gid of this.glyphs) {
       let glyph = this.font.getGlyph(gid);
+      if (!glyph) {
+        continue;
+      }
       void glyph.path; // this causes the glyph to be parsed
 
-      for (let subr in glyph._usedSubrs) {
-        used_subrs[subr] = true;
+      if (glyph._usedSubrs) {
+        for (let subr in glyph._usedSubrs) {
+          used_subrs[subr] = true;
+        }
       }
     }
 
     let privateDict = Object.assign({}, this.cff.topDict.Private);
     if (this.cff.topDict.Private && this.cff.topDict.Private.Subrs) {
-      privateDict.Subrs = this.subsetSubrs(this.cff.topDict.Private.Subrs, used_subrs);
+      privateDict.Subrs = this.subsetSubrs(
+        /** @type {Array<{ offset: number, length: number }>} */ (this.cff.topDict.Private.Subrs),
+        used_subrs
+      );
     }
 
     topDict.FDArray = [{ Private: privateDict }];
+    let charstrings = this.charstrings || [];
     return topDict.FDSelect = {
       version: 3,
       nRanges: 1,
       ranges: [{ first: 0, fd: 0 }],
-      sentinel: this.charstrings.length
+      sentinel: charstrings.length
     };
   }
 
+  /**
+   * @param {string | null | undefined} string
+   * @returns {number | null}
+   */
   addString(string) {
     if (!string) {
       return null;
@@ -131,28 +215,34 @@ export default class CFFSubset extends Subset {
     return standardStrings.length + this.strings.length - 1;
   }
 
+  /**
+   * @returns {import('restructure').BinaryBuffer}
+   */
   encode() {
     this.subsetCharstrings();
 
+    let charstrings = this.charstrings || [];
+
     let charset = {
-      version: this.charstrings.length > 255 ? 2 : 1,
-      ranges: this.charstrings.length > 1
-        ? [{ first: 1, nLeft: this.charstrings.length - 2 }]
+      version: charstrings.length > 255 ? 2 : 1,
+      ranges: charstrings.length > 1
+        ? [{ first: 1, nLeft: charstrings.length - 2 }]
         : []
     };
 
-    let topDict = Object.assign({}, this.cff.topDict);
+    let topDict = /** @type {CFFTopDict} */ (Object.assign({}, this.cff.topDict));
     topDict.Private = null;
     topDict.charset = charset;
     topDict.Encoding = null;
-    topDict.CharStrings = this.charstrings;
+    topDict.CharStrings = charstrings;
 
     for (let key of ['version', 'Notice', 'Copyright', 'FullName', 'FamilyName', 'Weight', 'PostScript', 'BaseFontName', 'FontName']) {
-      topDict[key] = this.addString(this.cff.string(topDict[key]));
+      let sid = /** @type {number | null | undefined} */ (topDict[key]);
+      topDict[key] = this.cff.string ? this.addString(this.cff.string(sid)) : null;
     }
 
     topDict.ROS = [this.addString('Adobe'), this.addString('Identity'), 0];
-    topDict.CIDCount = this.charstrings.length;
+    topDict.CIDCount = charstrings.length;
 
     if (this.cff.isCIDFont) {
       this.subsetFontdict(topDict);