@cantoo/fontkit 2.0.5 → 2.0.6

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;
 
@@ -64,38 +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);
+      swap32LE(bytes);
 
-      this.data = new Uint32Array(data.buffer, data.byteOffset, data.byteLength >> 2);
+      /**
+       * 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.1",
+  "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,11 +1,19 @@
 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;
 };
 
+/**
+ * @param {Uint8Array} array
+ */
 const swap32 = (array) => {
   const len = array.length;
   for (let i = 0; i < len; i += 4) {
@@ -14,6 +22,11 @@ const swap32 = (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);

package/src/subset/Subset.js

@@ -1,22 +1,37 @@
 import Tables from '../tables';
 
+/** @typedef {import('../../types/fontkit').SubsetFont} SubsetFont */
+/** @typedef {import('../../types/fontkit').SubsetGlyph} SubsetGlyph */
+/** @typedef {import('../../types/fontkit').TableCodec} TableCodec */
+
 // Tables written by TTFSubset.encode; must not be overwritten via includeTable.
 const MANAGED_TTF_TABLES = [
   'head', 'hhea', 'loca', 'maxp', 'cvt ', 'prep', 'glyf', 'hmtx', 'fpgm'
 ];
 
 export default class Subset {
+  /**
+   * @param {SubsetFont} font
+   */
   constructor(font) {
+    /** @type {SubsetFont} */
     this.font = font;
+    /** @type {number[]} */
     this.glyphs = [];
+    /** @type {Record<number, number>} */
     this.mapping = {};
     // Extra OT table tags to copy into a TTF subset (e.g. 'OS/2', 'name', 'post').
+    /** @type {string[]} */
     this.includedTables = [];
 
     // always include the missing glyph
     this.includeGlyph(0);
   }
 
+  /**
+   * @param {number | SubsetGlyph} glyph
+   * @returns {number}
+   */
   includeGlyph(glyph) {
     if (typeof glyph === 'object') {
       glyph = glyph.id;
@@ -32,6 +47,10 @@ export default class Subset {
 
   // Copy an OT table into the TTF subset (tag is a 4-byte string, e.g. 'OS/2').
   // Only honored by TTFSubset.encode; CFFSubset overrides this to throw.
+  /**
+   * @param {string} [tag]
+   * @returns {this}
+   */
   includeTable(tag) {
     if (typeof tag !== 'string' || tag.length !== 4) {
       throw new Error(
@@ -50,7 +69,8 @@ export default class Subset {
       throw new Error(`Table "${tag}" is not present in this font.`);
     }
 
-    if (!Tables[tag]) {
+    let encoders = /** @type {Record<string, TableCodec | undefined>} */ (/** @type {unknown} */ (Tables));
+    if (!encoders[tag]) {
       throw new Error(`Table "${tag}" cannot be encoded (no encoder registered in fontkit).`);
     }
 

package/src/subset/TTFSubset.js

@@ -3,36 +3,88 @@ import Subset from './Subset';
 import Directory from '../tables/directory';
 import TTFGlyphEncoder from '../glyph/TTFGlyphEncoder';
 
+/** @typedef {import('../../types/fontkit').SubsetFont} SubsetFont */
+/** @typedef {import('../../types/fontkit').DecodedGlyf} DecodedGlyf */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @typedef {{ advance: number, bearing: number }} HmtxMetric
+ */
+
 export default class TTFSubset extends Subset {
+  /** @type {TTFGlyphEncoder} */
+  glyphEncoder;
+  /** @type {Uint8Array[] | null} */
+  glyf = null;
+  /** @type {number} */
+  offset = 0;
+  /** @type {{ offsets: number[], version: number } | null} */
+  loca = null;
+  /** @type {{ metrics: HmtxMetric[], bearings: number[] } | null} */
+  hmtx = null;
+
+  /**
+   * @param {SubsetFont} font
+   */
   constructor(font) {
     super(font);
     this.glyphEncoder = new TTFGlyphEncoder();
   }
 
+  /**
+   * @param {number} gid
+   * @returns {number}
+   */
   _addGlyph(gid) {
     let glyph = this.font.getGlyph(gid);
+    if (!glyph || !glyph._decode) {
+      throw new Error(`Cannot decode glyph ${gid}`);
+    }
     let glyf = glyph._decode();
 
+    if (!this.font.loca) {
+      throw new Error('Font missing loca table');
+    }
+
     // get the offset to the glyph from the loca table
     let curOffset = this.font.loca.offsets[gid];
     let nextOffset = this.font.loca.offsets[gid + 1];
 
     let stream = this.font._getTableStream('glyf');
+    if (!stream) {
+      throw new Error('Font missing glyf table');
+    }
     stream.pos += curOffset;
 
-    let buffer = stream.readBuffer(nextOffset - curOffset);
+    let raw = stream.readBuffer(nextOffset - curOffset);
+    /** @type {Uint8Array} */
+    let buffer = raw instanceof Uint8Array
+      ? raw
+      : Uint8Array.from(/** @type {Iterable<number>} */ (/** @type {unknown} */ (raw)));
 
     // if it is a compound glyph, include its components
     if (glyf && glyf.numberOfContours < 0) {
       buffer = new Uint8Array(buffer);
-      let view = new DataView(buffer.buffer);
-      for (let component of glyf.components) {
+      let ab = buffer.buffer instanceof ArrayBuffer ? buffer.buffer : new Uint8Array(buffer).buffer;
+      let view = new DataView(ab, buffer.byteOffset, buffer.byteLength);
+      for (let component of glyf.components || []) {
         gid = this.includeGlyph(component.glyphID);
         view.setUint16(component.pos, gid);
       }
     } else if (glyf && this.font._variationProcessor) {
       // If this is a TrueType variation glyph, re-encode the path
-      buffer = this.glyphEncoder.encodeSimple(glyph.path, glyf.instructions);
+      let encoded = this.glyphEncoder.encodeSimple(
+        /** @type {import('../glyph/Path').default} */ (/** @type {unknown} */ (glyph.path)),
+        glyf.instructions
+      );
+      buffer = encoded instanceof Uint8Array
+        ? encoded
+        : Uint8Array.from(/** @type {Iterable<number>} */ (/** @type {unknown} */ (encoded)));
+    }
+
+    if (!this.glyf || !this.loca || !this.hmtx) {
+      throw new Error('TTFSubset.encode must initialize glyf/loca/hmtx before _addGlyph');
     }
 
     this.glyf.push(buffer);
@@ -43,10 +95,13 @@ export default class TTFSubset extends Subset {
       bearing: glyph._getMetrics().leftBearing
     });
 
-    this.offset += buffer.length;
+    this.offset += buffer.byteLength;
     return this.glyf.length - 1;
   }
 
+  /**
+   * @returns {BinaryBuffer}
+   */
   encode() {
     // tables required by PDF spec:
     //   head, hhea, loca, maxp, cvt , prep, glyf, hmtx, fpgm
@@ -54,16 +109,17 @@ export default class TTFSubset extends Subset {
     // additional tables required for standalone fonts:
     //   name, cmap, OS/2, post
 
+    /** @type {Uint8Array[]} */
     this.glyf = [];
     this.offset = 0;
     this.loca = {
-      offsets: [],
-      version: this.font.loca.version
+      offsets: /** @type {number[]} */ ([]),
+      version: this.font.loca ? (this.font.loca.version ?? 0) : 0
     };
 
     this.hmtx = {
-      metrics: [],
-      bearings: []
+      metrics: /** @type {HmtxMetric[]} */ ([]),
+      bearings: /** @type {number[]} */ ([])
     };
 
     // include all the glyphs
@@ -75,40 +131,26 @@ export default class TTFSubset extends Subset {
     }
 
     let maxp = cloneDeep(this.font.maxp);
-    maxp.numGlyphs = this.glyf.length;
+    if (maxp && typeof maxp === 'object') {
+      /** @type {StructValue} */ (maxp).numGlyphs = this.glyf.length;
+    }
 
-    this.loca.offsets.push(this.offset);
+    let loca = this.loca;
+    loca.offsets.push(this.offset);
 
     let head = cloneDeep(this.font.head);
-    head.indexToLocFormat = this.loca.version;
+    if (head && typeof head === 'object') {
+      /** @type {StructValue} */ (head).indexToLocFormat = loca.version;
+    }
 
     let hhea = cloneDeep(this.font.hhea);
-    hhea.numberOfMetrics = this.hmtx.metrics.length;
-
-    // map = []
-    // for index in [0...256]
-    //     if index < @numGlyphs
-    //         map[index] = index
-    //     else
-    //         map[index] = 0
-    //
-    // cmapTable =
-    //     version: 0
-    //     length: 262
-    //     language: 0
-    //     codeMap: map
-    //
-    // cmap =
-    //     version: 0
-    //     numSubtables: 1
-    //     tables: [
-    //         platformID: 1
-    //         encodingID: 0
-    //         table: cmapTable
-    //     ]
+    if (hhea && typeof hhea === 'object') {
+      /** @type {StructValue} */ (hhea).numberOfMetrics = this.hmtx.metrics.length;
+    }
 
     // TODO: subset prep, cvt, fpgm?
     // The following is the minimum set of tables.
+    /** @type {Record<string, unknown>} */
     let t = {
       head,
       hhea,
@@ -121,8 +163,9 @@ export default class TTFSubset extends Subset {
       fpgm: this.font.fpgm
     };
 
+    let fontTables = /** @type {Record<string, unknown>} */ (/** @type {unknown} */ (this.font));
     for (const tag of this.includedTables) {
-      t[tag] = cloneDeep(this.font[tag]);
+      t[tag] = cloneDeep(fontTables[tag]);
     }
 
     return Directory.toBuffer({ tables: t });

package/src/tables/BASE.js

@@ -65,6 +65,7 @@ let Axis = new r.Struct({
   baseScriptList: new r.Pointer(r.uint16, BaseScriptList)
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint32, {
   header: {
     horizAxis: new r.Pointer(r.uint16, Axis), // May be NULL

package/src/tables/COLR.js

@@ -16,6 +16,7 @@ let BaseGlyphRecord = new r.Struct({
   numLayers: r.uint16
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   version: r.uint16,
   numBaseGlyphRecords: r.uint16,

package/src/tables/CPAL.js

@@ -7,6 +7,7 @@ let ColorRecord = new r.Struct({
   alpha: r.uint8
 });
 
+/** @type {import('restructure').VersionedStruct} */
 export default new r.VersionedStruct(r.uint16, {
   header: {
     numPaletteEntries: r.uint16,

package/src/tables/DSIG.js

@@ -12,6 +12,7 @@ let SignatureBlock = new r.Struct({
   signature: new r.Buffer('cbSignature')
 });
 
+/** @type {import('restructure').Struct} */
 export default new r.Struct({
   ulVersion: r.uint32, // Version number of the DSIG table (0x00000001)
   usNumSigs: r.uint16, // Number of signatures in the table