@cantoo/fontkit 2.0.4 → 2.0.6

package/src/TrueTypeCollection.js

@@ -2,49 +2,89 @@ import * as r from 'restructure';
 import TTFFont from './TTFFont';
 import { asciiDecoder } from './utils';
 
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('../types/fontkit').NameString} NameString */
+
+/**
+ * @param {NameString | null | undefined} a
+ * @param {string | Uint8Array} b
+ * @returns {boolean}
+ */
+function postscriptNamesEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a instanceof Uint8Array && b instanceof Uint8Array) {
+    return a.length === b.length && a.every((v, i) => b[i] === v);
+  }
+  return false;
+}
+
 let TTCHeader = new r.VersionedStruct(r.uint32, {
   0x00010000: {
-    numFonts:   r.uint32,
-    offsets:    new r.Array(r.uint32, 'numFonts')
+    numFonts: r.uint32,
+    offsets: new r.Array(r.uint32, 'numFonts')
   },
   0x00020000: {
-    numFonts:   r.uint32,
-    offsets:    new r.Array(r.uint32, 'numFonts'),
-    dsigTag:    r.uint32,
+    numFonts: r.uint32,
+    offsets: new r.Array(r.uint32, 'numFonts'),
+    dsigTag: r.uint32,
     dsigLength: r.uint32,
     dsigOffset: r.uint32
   }
 });
 
+/**
+ * @typedef {StructValue & { offsets: number[] }} TTCHeaderValue
+ */
+
 export default class TrueTypeCollection {
+  /** @type {string} */
   type = 'TTC';
 
+  /** @type {DecodeStream} */
+  stream;
+  /** @type {TTCHeaderValue} */
+  header;
+
+  /**
+   * @param {ArrayBufferView} buffer
+   * @returns {boolean}
+   */
   static probe(buffer) {
-    return asciiDecoder.decode(buffer.slice(0, 4)) === 'ttcf';
+    let bytes
+      = buffer instanceof Uint8Array
+        ? buffer
+        : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return asciiDecoder.decode(bytes.subarray(0, 4)) === 'ttcf';
   }
 
+  /**
+   * @param {DecodeStream} stream
+   */
   constructor(stream) {
     this.stream = stream;
     if (stream.readString(4) !== 'ttcf') {
       throw new Error('Not a TrueType collection');
     }
 
-    this.header = TTCHeader.decode(stream);
+    this.header = /** @type {TTCHeaderValue} */ (
+      /** @type {unknown} */ (TTCHeader.decode(stream))
+    );
   }
 
+  /**
+   * @param {string | Uint8Array} name
+   * @returns {TTFFont | null}
+   */
   getFont(name) {
     for (let offset of this.header.offsets) {
       let stream = new r.DecodeStream(this.stream.buffer);
       stream.pos = offset;
       let font = new TTFFont(stream);
-      if (
-        font.postscriptName === name ||
-        (
-          font.postscriptName instanceof Uint8Array && 
-          name instanceof Uint8Array && 
-          font.postscriptName.every((v, i) => name[i] === v)
-        )
-      ) {
+      if (postscriptNamesEqual(font.postscriptName, name)) {
         return font;
       }
     }
@@ -52,7 +92,11 @@ export default class TrueTypeCollection {
     return null;
   }
 
+  /**
+   * @type {TTFFont[]}
+   */
   get fonts() {
+    /** @type {TTFFont[]} */
     let fonts = [];
     for (let offset of this.header.offsets) {
       let stream = new r.DecodeStream(this.stream.buffer);

package/src/WOFF2Font.js

@@ -6,45 +6,98 @@ import WOFF2Glyph from './glyph/WOFF2Glyph';
 import WOFF2Directory from './tables/WOFF2Directory';
 import { asciiDecoder } from './utils';
 
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('restructure').BaseType} BaseType */
+/** @typedef {import('../types/fontkit').FontDirectory} FontDirectory */
+/** @typedef {import('../types/fontkit').TableEntry} TableEntry */
+/** @typedef {import('../types/fontkit').TransformedGlyf} TransformedGlyf */
+/** @typedef {import('../types/fontkit').DecodedGlyf} DecodedGlyf */
+/** @typedef {import('./glyph/Glyph').default} Glyph */
+
 /**
  * Subclass of TTFFont that represents a TTF/OTF font compressed by WOFF2
  * See spec here: http://www.w3.org/TR/WOFF2/
+ *
+ * @property {number} [_dataPos] Byte offset of the compressed table data (set in `_decodeDirectory`).
  */
 export default class WOFF2Font extends TTFFont {
+  /** @type {string} */
   type = 'WOFF2';
 
+  // NOTE: Do not declare `_dataPos` as a class field. It is assigned in
+  // `_decodeDirectory()` during `super()`, and subclass field initializers
+  // run *after* `super()` returns — which would wipe the real offset.
+
+  /** @type {boolean | undefined} */
+  _decompressed;
+  /** @type {(TransformedGlyf | undefined)[] | undefined} */
+  _transformedGlyphs;
+
+  /**
+   * @param {ArrayBufferView} buffer
+   * @returns {boolean}
+   */
   static probe(buffer) {
-    return asciiDecoder.decode(buffer.slice(0, 4)) === 'wOF2';
+    let bytes
+      = buffer instanceof Uint8Array
+        ? buffer
+        : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return asciiDecoder.decode(bytes.subarray(0, 4)) === 'wOF2';
   }
 
+  /** @returns {void} */
   _decodeDirectory() {
-    this.directory = WOFF2Directory.decode(this.stream);
+    this.directory = /** @type {FontDirectory} */ (
+      /** @type {unknown} */ (WOFF2Directory.decode(this.stream))
+    );
     this._dataPos = this.stream.pos;
   }
 
+  /** @returns {void} */
   _decompress() {
     // decompress data and setup table offsets if we haven't already
     if (!this._decompressed) {
-      this.stream.pos = this._dataPos;
-      let buffer = this.stream.readBuffer(this.directory.totalCompressedSize);
+      let dataPos = this._dataPos;
+      if (dataPos == null) {
+        throw new Error('Missing WOFF2 data offset; directory was not decoded');
+      }
+      this.stream.pos = dataPos;
+      let totalCompressedSize = this.directory.totalCompressedSize;
+      if (totalCompressedSize == null) {
+        throw new Error('Missing totalCompressedSize in WOFF2 directory');
+      }
+      let buffer = this.stream.readBuffer(totalCompressedSize);
 
       let decompressedSize = 0;
-      for (let tag in this.directory.tables) {
-        let entry = this.directory.tables[tag];
+      let tableMap = this.directory.tables;
+      for (let tag in tableMap) {
+        let entry = tableMap[tag];
+        if (!entry) {
+          continue;
+        }
         entry.offset = decompressedSize;
         decompressedSize += (entry.transformLength != null) ? entry.transformLength : entry.length;
       }
 
-      let decompressed = brotli(buffer, decompressedSize);
+      let decompressed = brotli(
+        buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength),
+        decompressedSize
+      );
       if (!decompressed) {
         throw new Error('Error decoding compressed data in WOFF2');
       }
 
-      this.stream = new r.DecodeStream(decompressed);
+      this._setStream(new r.DecodeStream(decompressed));
       this._decompressed = true;
     }
   }
 
+  /**
+   * @param {TableEntry} table
+   * @returns {unknown}
+   */
   _decodeTable(table) {
     this._decompress();
     return super._decodeTable(table);
@@ -52,13 +105,19 @@ export default class WOFF2Font extends TTFFont {
 
   // Override this method to get a glyph and return our
   // custom subclass if there is a glyf table.
+  /**
+   * @param {number} glyph
+   * @param {number[]} [characters]
+   * @returns {Glyph | null | undefined}
+   */
   _getBaseGlyph(glyph, characters = []) {
     let cached = this._glyphs[glyph];
-    if (cached?._getContours) {
+    if (cached && typeof (/** @type {{ _getContours?: unknown }} */ (cached))._getContours === 'function') {
       return cached;
     }
 
-    if (this.directory.tables.glyf && this.directory.tables.glyf.transformed) {
+    let glyfEntry = this.directory.tables.glyf;
+    if (glyfEntry && glyfEntry.transformed) {
       if (!this._transformedGlyphs) { this._transformGlyfTable(); }
       let outline = new WOFF2Glyph(glyph, characters, this);
       if (!cached) {
@@ -70,18 +129,27 @@ export default class WOFF2Font extends TTFFont {
     return super._getBaseGlyph(glyph, characters);
   }
 
+  /** @returns {void} */
   _transformGlyfTable() {
     this._decompress();
-    this.stream.pos = this.directory.tables.glyf.offset;
-    let table = GlyfTable.decode(this.stream);
+    let glyfEntry = this.directory.tables.glyf;
+    if (!glyfEntry) {
+      this._transformedGlyphs = [];
+      return;
+    }
+    this.stream.pos = glyfEntry.offset;
+    let table = /** @type {GlyfTableDecoded} */ (GlyfTable.decode(this.stream));
+    /** @type {TransformedGlyf[]} */
     let glyphs = [];
 
     for (let index = 0; index < table.numGlyphs; index++) {
-      let glyph = {};
+      /** @type {TransformedGlyf} */
+      let glyph = { numberOfContours: 0 };
       let nContours = table.nContours.readInt16BE();
       glyph.numberOfContours = nContours;
 
       if (nContours > 0) { // simple glyph
+        /** @type {number[]} */
         let nPoints = [];
         let totalPoints = 0;
 
@@ -93,13 +161,19 @@ export default class WOFF2Font extends TTFFont {
 
         glyph.points = decodeTriplet(table.flags, table.glyphs, totalPoints);
         for (let i = 0; i < nContours; i++) {
-          glyph.points[nPoints[i] - 1].endContour = true;
+          let pts = glyph.points;
+          if (pts) {
+            pts[nPoints[i] - 1].endContour = true;
+          }
         }
 
         read255UInt16(table.glyphs);
-
       } else if (nContours < 0) { // composite glyph
-        let haveInstructions = TTFGlyph.prototype._decodeComposite.call({ _font: this }, glyph, table.composites);
+        let haveInstructions = TTFGlyph.prototype._decodeComposite.call(
+          /** @type {TTFGlyph} */ (/** @type {unknown} */ ({ _font: this })),
+          /** @type {DecodedGlyf} */ (glyph),
+          table.composites
+        );
         if (haveInstructions) {
           read255UInt16(table.glyphs);
         }
@@ -112,13 +186,33 @@ export default class WOFF2Font extends TTFFont {
   }
 }
 
+/**
+ * @typedef {{
+ *   version: number,
+ *   numGlyphs: number,
+ *   nContours: DecodeStream,
+ *   nPoints: DecodeStream,
+ *   flags: DecodeStream,
+ *   glyphs: DecodeStream,
+ *   composites: DecodeStream
+ * }} GlyfTableDecoded
+ */
+
 // Special class that accepts a length and returns a sub-stream for that data
 class Substream {
+  /**
+   * @param {number | string} length
+   */
   constructor(length) {
     this.length = length;
     this._buf = new r.Buffer(length);
   }
 
+  /**
+   * @param {DecodeStream} stream
+   * @param {StructValue} parent
+   * @returns {DecodeStream}
+   */
   decode(stream, parent) {
     return new r.DecodeStream(this._buf.decode(stream, parent));
   }
@@ -150,6 +244,10 @@ const ONE_MORE_BYTE_CODE2 = 254;
 const ONE_MORE_BYTE_CODE1 = 255;
 const LOWEST_U_CODE = 253;
 
+/**
+ * @param {DecodeStream} stream
+ * @returns {number}
+ */
 function read255UInt16(stream) {
   let code = stream.readUInt8();
 
@@ -168,17 +266,30 @@ function read255UInt16(stream) {
   return code;
 }
 
+/**
+ * @param {number} flag
+ * @param {number} baseval
+ * @returns {number}
+ */
 function withSign(flag, baseval) {
   return flag & 1 ? baseval : -baseval;
 }
 
+/**
+ * @param {DecodeStream} flags
+ * @param {DecodeStream} glyphs
+ * @param {number} nPoints
+ * @returns {Point[]}
+ */
 function decodeTriplet(flags, glyphs, nPoints) {
   let y;
   let x = y = 0;
+  /** @type {Point[]} */
   let res = [];
 
   for (let i = 0; i < nPoints; i++) {
-    let dx, dy;
+    let dx = 0;
+    let dy = 0;
     let flag = flags.readUInt8();
     let onCurve = !(flag >> 7);
     flag &= 0x7f;
@@ -186,28 +297,23 @@ function decodeTriplet(flags, glyphs, nPoints) {
     if (flag < 10) {
       dx = 0;
       dy = withSign(flag, ((flag & 14) << 7) + glyphs.readUInt8());
-
     } else if (flag < 20) {
       dx = withSign(flag, (((flag - 10) & 14) << 7) + glyphs.readUInt8());
       dy = 0;
-
     } else if (flag < 84) {
       let b0 = flag - 20;
       let b1 = glyphs.readUInt8();
       dx = withSign(flag, 1 + (b0 & 0x30) + (b1 >> 4));
       dy = withSign(flag >> 1, 1 + ((b0 & 0x0c) << 2) + (b1 & 0x0f));
-
     } else if (flag < 120) {
       let b0 = flag - 84;
       dx = withSign(flag, 1 + ((b0 / 12) << 8) + glyphs.readUInt8());
       dy = withSign(flag >> 1, 1 + (((b0 % 12) >> 2) << 8) + glyphs.readUInt8());
-
     } else if (flag < 124) {
       let b1 = glyphs.readUInt8();
       let b2 = glyphs.readUInt8();
       dx = withSign(flag, (b1 << 4) + (b2 >> 4));
       dy = withSign(flag >> 1, ((b2 & 0x0f) << 8) + glyphs.readUInt8());
-
     } else {
       dx = withSign(flag, glyphs.readUInt16BE());
       dy = withSign(flag >> 1, glyphs.readUInt16BE());

package/src/WOFFFont.js

@@ -4,17 +4,41 @@ import { unzlibSync } from 'fflate';
 import * as r from 'restructure';
 import { asciiDecoder } from './utils';
 
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').BinaryBuffer} BinaryBuffer */
+/** @typedef {import('../types/fontkit').FontDirectory} FontDirectory */
+/** @typedef {import('../types/fontkit').TableEntry} TableEntry */
+
 export default class WOFFFont extends TTFFont {
+  /** @type {string} */
   type = 'WOFF';
 
+  /** @type {boolean | undefined} */
+  _decompressed;
+
+  /**
+   * @param {ArrayBufferView} buffer
+   * @returns {boolean}
+   */
   static probe(buffer) {
-    return asciiDecoder.decode(buffer.slice(0, 4)) === 'wOFF';
+    let bytes
+      = buffer instanceof Uint8Array
+        ? buffer
+        : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    return asciiDecoder.decode(bytes.subarray(0, 4)) === 'wOFF';
   }
 
+  /** @returns {void} */
   _decodeDirectory() {
-    this.directory = WOFFDirectory.decode(this.stream, { _startOffset: 0 });
+    this.directory = /** @type {FontDirectory} */ (
+      /** @type {unknown} */ (WOFFDirectory.decode(this.stream, { _startOffset: 0 }))
+    );
   }
 
+  /**
+   * @param {TableEntry} table
+   * @returns {unknown}
+   */
   _decodeTable(table) {
     this._decompress();
     return super._decodeTable(table);
@@ -22,15 +46,21 @@ export default class WOFFFont extends TTFFont {
 
   // Inflate all tables into one stream so internal offsets (e.g. gvar) stay
   // valid against this.stream — same reason WOFF2Font decompresses up front.
+  /** @returns {void} */
   _decompress() {
     if (this._decompressed) {
       return;
     }
 
     let totalSize = 0;
+    /** @type {Array<{ entry: TableEntry, newOffset: number }>} */
     let layout = [];
-    for (let tag in this.directory.tables) {
-      let entry = this.directory.tables[tag];
+    let tableMap = this.directory.tables;
+    for (let tag in tableMap) {
+      let entry = tableMap[tag];
+      if (!entry) {
+        continue;
+      }
       layout.push({ entry, newOffset: totalSize });
       totalSize = (totalSize + entry.length + 3) & ~3;
     }
@@ -38,19 +68,26 @@ export default class WOFFFont extends TTFFont {
     let buffer = new Uint8Array(totalSize);
     for (let { entry, newOffset } of layout) {
       this.stream.pos = entry.offset;
+      /** @type {BinaryBuffer | Uint8Array} */
       let data;
-      if (entry.compLength < entry.length) {
-        data = unzlibSync(this.stream.readBuffer(entry.compLength), {
+      let compLength = entry.compLength != null ? entry.compLength : entry.length;
+      if (compLength < entry.length) {
+        let compressed = this.stream.readBuffer(compLength);
+        let compressedBytes
+          = compressed instanceof Uint8Array
+            ? compressed
+            : new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+        data = unzlibSync(compressedBytes, {
           out: new Uint8Array(entry.length)
         });
       } else {
         data = this.stream.readBuffer(entry.length);
       }
-      buffer.set(data, newOffset);
+      buffer.set(data instanceof Uint8Array ? data : new Uint8Array(data.buffer, data.byteOffset, data.byteLength), newOffset);
       entry.offset = newOffset;
     }
 
-    this.stream = new r.DecodeStream(buffer);
+    this._setStream(new r.DecodeStream(buffer));
     this._decompressed = true;
   }
 }