@cantoo/fontkit 2.0.4 → 2.0.6

package/src/opentype/GSUBProcessor.js

@@ -1,28 +1,73 @@
 import OTProcessor from './OTProcessor';
 import GlyphInfo from './GlyphInfo';
 
+/** @typedef {import('../../types/fontkit').CoverageTable} CoverageTable */
+/** @typedef {import('../../types/fontkit').OTLookup} OTLookup */
+/** @typedef {import('../../types/fontkit').ExtensionSubtable} ExtensionSubtable */
+/** @typedef {import('restructure').StructValue} StructValue */
+
+/**
+ * @typedef {StructValue & {
+ *   coverage?: CoverageTable,
+ *   version?: number,
+ *   deltaGlyphID?: number,
+ *   substitute?: import('../../types/fontkit').LazyList<number>,
+ *   sequences?: import('../../types/fontkit').LazyList<number[]>,
+ *   alternateSet?: import('../../types/fontkit').LazyList<number[]>,
+ *   ligatureSets?: import('../../types/fontkit').LazyList<Array<{ glyph: number, components: number[] }>>,
+ *   lookupType?: number,
+ *   extension?: StructValue,
+ *   backtrackGlyphCount?: number,
+ *   backtrackCoverage?: CoverageTable[],
+ *   lookaheadCoverage?: CoverageTable[],
+ * }} GSUBSubtable
+ */
+
 export default class GSUBProcessor extends OTProcessor {
+  /**
+   * @param {OTLookup} lookup
+   * @returns {number}
+   */
   lookupDirection(lookup) {
-    let type = lookup.lookupType === 7 ? lookup.subTables[0]?.lookupType : lookup.lookupType;
+    let first = lookup.subTables[0];
+    let type = lookup.lookupType === 7
+      ? (first && typeof first === 'object' && 'lookupType' in first
+          ? /** @type {number} */ (/** @type {{ lookupType?: number }} */ (first).lookupType)
+          : undefined)
+      : lookup.lookupType;
     return type === 8 ? -1 : 1;
   }
 
+  /**
+   * @param {number} lookupType
+   * @param {StructValue} table
+   * @returns {boolean}
+   */
   applyLookup(lookupType, table) {
+    let t = /** @type {GSUBSubtable} */ (table);
+    let glyphIterator = this.glyphIterator;
+    if (!glyphIterator) {
+      return false;
+    }
+
     switch (lookupType) {
       case 1: { // Single Substitution
-        let index = this.coverageIndex(table.coverage);
+        if (!t.coverage) return false;
+        let index = this.coverageIndex(t.coverage);
         if (index === -1) {
           return false;
         }
 
-        let glyph = this.glyphIterator.cur;
-        switch (table.version) {
+        let glyph = glyphIterator.cur;
+        if (!glyph) return false;
+
+        switch (t.version) {
           case 1:
-            glyph.id = (glyph.id + table.deltaGlyphID) & 0xffff;
+            glyph.id = (glyph.id + (t.deltaGlyphID ?? 0)) & 0xffff;
             break;
 
           case 2:
-            glyph.id = table.substitute.get(index);
+            if (t.substitute) glyph.id = t.substitute.get(index);
             break;
         }
 
@@ -30,23 +75,26 @@ export default class GSUBProcessor extends OTProcessor {
       }
 
       case 2: { // Multiple Substitution
-        let index = this.coverageIndex(table.coverage);
+        if (!t.coverage || !t.sequences) return false;
+        let index = this.coverageIndex(t.coverage);
         if (index !== -1) {
-          let sequence = table.sequences.get(index);
+          let sequence = t.sequences.get(index);
 
           if (sequence.length === 0) {
             // If the sequence length is zero, delete the glyph.
             // The OpenType spec disallows this, but seems like Harfbuzz and Uniscribe allow it.
-            this.glyphs.splice(this.glyphIterator.index, 1);
+            this.glyphs.splice(glyphIterator.index, 1);
             return true;
           }
 
-          this.glyphIterator.cur.id = sequence[0];
-          this.glyphIterator.cur.ligatureComponent = 0;
+          let curGlyph = glyphIterator.cur;
+          if (!curGlyph) return false;
 
-          let features = this.glyphIterator.cur.features;
-          let curGlyph = this.glyphIterator.cur;
-          let replacement = sequence.slice(1).map((gid, i) => {
+          curGlyph.id = sequence[0];
+          curGlyph.ligatureComponent = 0;
+
+          let features = curGlyph.features;
+          let replacement = sequence.slice(1).map(/** @param {number} gid @param {number} i */ (gid, i) => {
             let glyph = new GlyphInfo(this.font, gid, undefined, features);
             glyph.shaperInfo = curGlyph.shaperInfo;
             glyph.isLigated = curGlyph.isLigated;
@@ -56,7 +104,7 @@ export default class GSUBProcessor extends OTProcessor {
             return glyph;
           });
 
-          this.glyphs.splice(this.glyphIterator.index + 1, 0, ...replacement);
+          this.glyphs.splice(glyphIterator.index + 1, 0, ...replacement);
           return true;
         }
 
@@ -64,31 +112,37 @@ export default class GSUBProcessor extends OTProcessor {
       }
 
       case 3: { // Alternate Substitution
-        let index = this.coverageIndex(table.coverage);
+        if (!t.coverage || !t.alternateSet) return false;
+        let index = this.coverageIndex(t.coverage);
         if (index === -1) return false;
 
         // 1-based index from user features (e.g. { aalt: 2 }); boolean / missing → first
-        let alternates = table.alternateSet.get(index);
-        let alt = this.userFeatures?.[this.currentFeature];
-        let i = Number.isInteger(alt) && alt > 0 ? alt - 1 : 0;
-        this.glyphIterator.cur.id = alternates[i < alternates.length ? i : 0];
+        let alternates = t.alternateSet.get(index);
+        let cur = glyphIterator.cur;
+        if (!cur) return false;
+
+        let alt = this.currentFeature && this.userFeatures ? this.userFeatures[this.currentFeature] : undefined;
+        let i = typeof alt === 'number' && Number.isInteger(alt) && alt > 0 ? alt - 1 : 0;
+        cur.id = alternates[i < alternates.length ? i : 0];
         return true;
       }
 
       case 4: { // Ligature Substitution
-        let index = this.coverageIndex(table.coverage);
+        if (!t.coverage || !t.ligatureSets) return false;
+        let index = this.coverageIndex(t.coverage);
         if (index === -1) return false;
 
-        for (let ligature of table.ligatureSets.get(index)) {
+        for (let ligature of t.ligatureSets.get(index)) {
           let matched = this.sequenceMatchIndices(1, ligature.components);
           if (!matched) continue;
 
-          let curGlyph = this.glyphIterator.cur;
+          let curGlyph = glyphIterator.cur;
+          if (!curGlyph) continue;
 
           // Concatenate all of the characters the new ligature will represent
           let characters = curGlyph.codePoints.slice();
-          for (let index of matched) {
-            characters.push(...this.glyphs[index].codePoints);
+          for (let matchIdx of matched) {
+            characters.push(...this.glyphs[matchIdx].codePoints);
           }
 
           // Create the replacement ligature glyph
@@ -131,7 +185,7 @@ export default class GSUBProcessor extends OTProcessor {
           let lastLigID = curGlyph.ligatureID;
           let lastNumComps = curGlyph.codePoints.length;
           let curComps = lastNumComps;
-          let idx = this.glyphIterator.index + 1;
+          let idx = glyphIterator.index + 1;
 
           // Set ligatureID and ligatureComponent on glyphs that were skipped in the matched sequence.
           // This allows GPOS to attach marks to the correct ligature components.
@@ -171,7 +225,7 @@ export default class GSUBProcessor extends OTProcessor {
             this.glyphs.splice(matched[i], 1);
           }
 
-          this.glyphs[this.glyphIterator.index] = ligatureGlyph;
+          this.glyphs[glyphIterator.index] = ligatureGlyph;
           return true;
         }
 
@@ -184,20 +238,25 @@ export default class GSUBProcessor extends OTProcessor {
       case 6: // Chaining Contextual Substitution
         return this.applyChainingContext(table);
 
-      case 7: // Extension Substitution
-        return this.applyLookup(table.lookupType, table.extension);
+      case 7: { // Extension Substitution
+        let ext = /** @type {ExtensionSubtable} */ (table);
+        return this.applyLookup(ext.lookupType, ext.extension);
+      }
 
       case 8: { // Reverse Chaining Contextual Single Substitution
-        let index = this.coverageIndex(table.coverage);
+        if (!t.coverage || !t.substitute || !t.backtrackCoverage || !t.lookaheadCoverage) return false;
+        let index = this.coverageIndex(t.coverage);
         if (index === -1) return false;
 
         // Backtrack is stored closest-first; coverageSequenceMatches walks furthest-first.
-        if (!this.coverageSequenceMatches(-table.backtrackGlyphCount, [...table.backtrackCoverage].reverse())
-          || !this.coverageSequenceMatches(1, table.lookaheadCoverage)) {
+        if (!this.coverageSequenceMatches(-(t.backtrackGlyphCount ?? t.backtrackCoverage.length), [...t.backtrackCoverage].reverse())
+          || !this.coverageSequenceMatches(1, t.lookaheadCoverage)) {
           return false;
         }
 
-        this.glyphIterator.cur.id = table.substitute.get(index);
+        let cur = glyphIterator.cur;
+        if (!cur) return false;
+        cur.id = t.substitute.get(index);
         return true;
       }
 

package/src/opentype/GlyphInfo.js

@@ -1,36 +1,79 @@
-import {isMark} from '../packages/unicode-properties/index.js';
+import { isMark } from '../packages/unicode-properties/index.js';
 import OTProcessor from './OTProcessor';
 
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../types/fontkit').FeatureInput} FeatureInput */
+/** @typedef {import('../../types/fontkit').ClassDefTable} ClassDefTable */
+
 export default class GlyphInfo {
+  /**
+   * @param {LayoutFont} font
+   * @param {number} id
+   * @param {number[]} [codePoints]
+   * @param {FeatureInput | null | undefined} [features]
+   */
   constructor(font, id, codePoints = [], features) {
+    /** @type {LayoutFont} */
     this._font = font;
+    /** @type {number[]} */
     this.codePoints = codePoints;
-    this.id = id;
+    /** @type {number} */
+    this._id = 0;
 
+    /** @type {FeatureMap} */
     this.features = {};
     if (Array.isArray(features)) {
       for (let i = 0; i < features.length; i++) {
         let feature = features[i];
         this.features[feature] = true;
       }
-    } else if (typeof features === 'object') {
+    } else if (typeof features === 'object' && features !== null) {
       Object.assign(this.features, features);
     }
 
+    /** @type {number | null} */
     this.ligatureID = null;
+    /** @type {number | null} */
     this.ligatureComponent = null;
+    /** @type {boolean} */
     this.isLigated = false;
+    /** @type {number | null} */
     this.cursiveAttachment = null;
+    /** @type {number | null} */
     this.markAttachment = null;
+    /** @type {import('../../types/fontkit').IndicShaperInfo | import('../../types/fontkit').USEShaperInfo | null} */
     this.shaperInfo = null;
+    /** @type {boolean} */
     this.substituted = false;
+    /** @type {boolean} */
     this.isMultiplied = false;
+
+    /** @type {boolean} */
+    this.isBase = false;
+    /** @type {boolean} */
+    this.isLigature = false;
+    /** @type {boolean} */
+    this.isMark = false;
+    /** @type {number} */
+    this.markAttachmentType = 0;
+
+    // Apply GDEF / mark classification via the id setter, then clear
+    // `substituted` — construction is not a GSUB substitution.
+    this.id = id;
+    this.substituted = false;
   }
 
+  /**
+   * @returns {number}
+   */
   get id() {
     return this._id;
   }
 
+  /**
+   * @param {number} id
+   */
   set id(id) {
     this._id = id;
     this.substituted = true;
@@ -38,11 +81,13 @@ export default class GlyphInfo {
     let GDEF = this._font.GDEF;
     if (GDEF && GDEF.glyphClassDef) {
       // TODO: clean this up
-      let classID = OTProcessor.prototype.getClassID(id, GDEF.glyphClassDef);
+      let classID = OTProcessor.prototype.getClassID(id, /** @type {ClassDefTable} */ (GDEF.glyphClassDef));
       this.isBase = classID === 1;
       this.isLigature = classID === 2;
       this.isMark = classID === 3;
-      this.markAttachmentType = GDEF.markAttachClassDef ? OTProcessor.prototype.getClassID(id, GDEF.markAttachClassDef) : 0;
+      this.markAttachmentType = GDEF.markAttachClassDef
+        ? OTProcessor.prototype.getClassID(id, /** @type {ClassDefTable} */ (GDEF.markAttachClassDef))
+        : 0;
     } else {
       this.isMark = this.codePoints.length > 0 && this.codePoints.every(isMark);
       this.isBase = !this.isMark;
@@ -51,6 +96,9 @@ export default class GlyphInfo {
     }
   }
 
+  /**
+   * @returns {GlyphInfo}
+   */
   copy() {
     return new GlyphInfo(this._font, this.id, this.codePoints, this.features);
   }

package/src/opentype/GlyphIterator.js

@@ -1,21 +1,48 @@
+/** @typedef {import('../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../types/fontkit').GlyphIteratorOptions} GlyphIteratorOptions */
+/** @typedef {import('../../types/fontkit').LookupFlags} LookupFlags */
+/** @typedef {import('../../types/fontkit').MarkFilteringSet} MarkFilteringSet */
+
 export default class GlyphIterator {
+  /**
+   * @param {GlyphInfoLike[]} glyphs
+   * @param {GlyphIteratorOptions} [options]
+   */
   constructor(glyphs, options) {
+    /** @type {GlyphInfoLike[]} */
     this.glyphs = glyphs;
     this.reset(options);
   }
 
+  /**
+   * @param {GlyphIteratorOptions} [options]
+   * @param {number} [index]
+   * @param {MarkFilteringSet | null} [markFilteringSet]
+   */
   reset(options = {}, index = 0, markFilteringSet = null) {
+    /** @type {GlyphIteratorOptions} */
     this.options = options;
+    /** @type {LookupFlags} */
     this.flags = options.flags || {};
+    /** @type {number} */
     this.markAttachmentType = options.markAttachmentType || 0;
+    /** @type {MarkFilteringSet | null} */
     this.markFilteringSet = markFilteringSet;
+    /** @type {number} */
     this.index = index;
   }
 
+  /**
+   * @returns {GlyphInfoLike | null}
+   */
   get cur() {
     return this.glyphs[this.index] || null;
   }
 
+  /**
+   * @param {GlyphInfoLike} glyph
+   * @returns {boolean}
+   */
   shouldIgnore(glyph) {
     // Mark skip hierarchy (OT chapter 2): ignoreMarks > mark filtering set > markAttachmentType.
     if (glyph.isMark) {
@@ -30,10 +57,14 @@ export default class GlyphIterator {
       }
     }
 
-    return (this.flags.ignoreBaseGlyphs && glyph.isBase) ||
-           (this.flags.ignoreLigatures && glyph.isLigature);
+    return !!(this.flags.ignoreBaseGlyphs && glyph.isBase)
+      || !!(this.flags.ignoreLigatures && glyph.isLigature);
   }
 
+  /**
+   * @param {number} dir
+   * @returns {GlyphInfoLike | null}
+   */
   move(dir) {
     this.index += dir;
     while (0 <= this.index && this.index < this.glyphs.length && this.shouldIgnore(this.glyphs[this.index])) {
@@ -47,14 +78,24 @@ export default class GlyphIterator {
     return this.glyphs[this.index];
   }
 
+  /**
+   * @returns {GlyphInfoLike | null}
+   */
   next() {
     return this.move(+1);
   }
 
+  /**
+   * @returns {GlyphInfoLike | null}
+   */
   prev() {
     return this.move(-1);
   }
 
+  /**
+   * @param {number} [count]
+   * @returns {GlyphInfoLike | undefined}
+   */
   peek(count = 1) {
     let idx = this.index;
     let res = this.increment(count);
@@ -62,6 +103,10 @@ export default class GlyphIterator {
     return res;
   }
 
+  /**
+   * @param {number} [count]
+   * @returns {number}
+   */
   peekIndex(count = 1) {
     let idx = this.index;
     this.increment(count);
@@ -70,6 +115,10 @@ export default class GlyphIterator {
     return res;
   }
 
+  /**
+   * @param {number} [count]
+   * @returns {GlyphInfoLike | undefined}
+   */
   increment(count = 1) {
     let dir = count < 0 ? -1 : 1;
     count = Math.abs(count);

package/src/opentype/OTLayoutEngine.js

@@ -4,14 +4,35 @@ import GlyphInfo from './GlyphInfo';
 import GSUBProcessor from './GSUBProcessor';
 import GPOSProcessor from './GPOSProcessor';
 
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').GlyphRunLike} GlyphRunLike */
+/** @typedef {import('../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../types/fontkit').GlyphPositionLike} GlyphPositionLike */
+/** @typedef {import('../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../types/fontkit').ScriptTag} ScriptTag */
+/** @typedef {import('../../types/fontkit').LanguageTag} LanguageTag */
+/** @typedef {import('../../types/fontkit').LayoutGlyph} LayoutGlyph */
+/** @typedef {import('../../types/fontkit').ShaperLike} ShaperLike */
+
 export default class OTLayoutEngine {
+  /**
+   * @param {LayoutFont} font
+   */
   constructor(font) {
+    /** @type {LayoutFont} */
     this.font = font;
+    /** @type {GlyphInfo[] | null} */
     this.glyphInfos = null;
+    /** @type {ShapingPlan | null} */
     this.plan = null;
+    /** @type {GSUBProcessor | null} */
     this.GSUBProcessor = null;
+    /** @type {GPOSProcessor | null} */
     this.GPOSProcessor = null;
+    /** @type {boolean} */
     this.fallbackPosition = true;
+    /** @type {ShaperLike | null} */
+    this.shaper = null;
 
     if (font.GSUB) {
       this.GSUBProcessor = new GSUBProcessor(font, font.GSUB);
@@ -22,12 +43,18 @@ export default class OTLayoutEngine {
     }
   }
 
+  /**
+   * @param {GlyphRunLike} glyphRun
+   */
   setup(glyphRun) {
     // Map glyphs to GlyphInfo objects so data can be passed between
     // GSUB and GPOS without mutating the real (shared) Glyph objects.
-    this.glyphInfos = glyphRun.glyphs.map(glyph => new GlyphInfo(this.font, glyph.id, [...glyph.codePoints]));
+    this.glyphInfos = /** @type {LayoutGlyph[]} */ (glyphRun.glyphs).map(
+      /** @param {LayoutGlyph} glyph */ glyph => new GlyphInfo(this.font, glyph.id, [...glyph.codePoints])
+    );
 
     // Select an OpenType script for GSUB/GPOS features.
+    /** @type {string | null} */
     let script = null;
     if (this.GPOSProcessor) {
       script = this.GPOSProcessor.selectScript(glyphRun.script, glyphRun.language, glyphRun.direction);
@@ -40,12 +67,13 @@ export default class OTLayoutEngine {
     // Choose the complex shaper from the buffer Unicode script (HB model). The OT
     // script may fall back to DFLT/latn even for Thai text; that must not select
     // DefaultShaper or Thai SARA AM / PUA preprocessing is skipped.
-    this.shaper = Shapers.choose(glyphRun.script || script);
+    this.shaper = /** @type {ShaperLike} */ (Shapers.choose(glyphRun.script || script));
     this.plan = new ShapingPlan(this.font, script || glyphRun.script, glyphRun.direction);
     this.plan.bufferScript = glyphRun.script;
     this.shaper.plan(this.plan, this.glyphInfos, glyphRun.features);
 
     // Enabled features as true, then overlay user values (e.g. aalt: 2) without mutating input.
+    /** @type {FeatureMap} */
     let features = {};
     for (let key in this.plan.allFeatures) {
       features[key] = true;
@@ -53,38 +81,62 @@ export default class OTLayoutEngine {
     glyphRun.features = Object.assign(features, glyphRun.features);
   }
 
+  /**
+   * @param {GlyphRunLike} glyphRun
+   */
   substitute(glyphRun) {
-    if (this.GSUBProcessor) {
+    if (this.GSUBProcessor && this.plan && this.glyphInfos) {
       this.plan.process(this.GSUBProcessor, this.glyphInfos);
 
       // Map glyph infos back to normal Glyph objects
-      glyphRun.glyphs = this.glyphInfos.map(glyphInfo => this.font.getGlyph(glyphInfo.id, glyphInfo.codePoints));
+      /** @type {LayoutGlyph[]} */
+      let glyphs = [];
+      for (let glyphInfo of this.glyphInfos) {
+        let g = this.font.getGlyph(glyphInfo.id, glyphInfo.codePoints);
+        if (g) {
+          glyphs.push(g);
+        }
+      }
+      glyphRun.glyphs = glyphs;
     }
   }
 
+  /**
+   * @param {GlyphRunLike} glyphRun
+   * @returns {FeatureMap | Record<string, import('../../types/fontkit').OTFeature> | null | undefined | false}
+   */
   position(glyphRun) {
-    if (this.shaper.zeroMarkWidths === 'BEFORE_GPOS') {
+    if (this.shaper && this.shaper.zeroMarkWidths === 'BEFORE_GPOS' && glyphRun.positions) {
       this.zeroMarkAdvances(glyphRun.positions);
     }
 
-    if (this.GPOSProcessor) {
+    if (this.GPOSProcessor && this.plan && this.glyphInfos && glyphRun.positions) {
       this.plan.process(this.GPOSProcessor, this.glyphInfos, glyphRun.positions);
     }
 
-    if (this.shaper.zeroMarkWidths === 'AFTER_GPOS') {
+    if (this.shaper && this.shaper.zeroMarkWidths === 'AFTER_GPOS' && glyphRun.positions) {
       this.zeroMarkAdvances(glyphRun.positions);
     }
 
     // Reverse the glyphs and positions if the script is right-to-left
     if (glyphRun.direction === 'rtl') {
       glyphRun.glyphs.reverse();
-      glyphRun.positions.reverse();
+      if (glyphRun.positions) {
+        glyphRun.positions.reverse();
+      }
     }
 
     return this.GPOSProcessor && this.GPOSProcessor.features;
   }
 
+  /**
+   * @param {GlyphPositionLike[]} positions
+   */
   zeroMarkAdvances(positions) {
+    if (!this.glyphInfos) {
+      return;
+    }
+
     for (let i = 0; i < this.glyphInfos.length; i++) {
       if (this.glyphInfos[i].isMark) {
         positions[i].xAdvance = 0;
@@ -99,7 +151,13 @@ export default class OTLayoutEngine {
     this.shaper = null;
   }
 
+  /**
+   * @param {ScriptTag | string[] | null | undefined} script
+   * @param {LanguageTag | null | undefined} language
+   * @returns {string[]}
+   */
   getAvailableFeatures(script, language) {
+    /** @type {string[]} */
     let features = [];
 
     if (this.GSUBProcessor) {