@cantoo/fontkit 2.0.5 → 2.0.7

package/src/opentype/ShapingPlan.js

@@ -7,24 +7,59 @@
  *
  * @private
  */
+
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').ScriptTag} ScriptTag */
+/** @typedef {import('../../types/fontkit').TextDirection} TextDirection */
+/** @typedef {import('../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../types/fontkit').FeatureInput} FeatureInput */
+/** @typedef {import('../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../types/fontkit').GlyphPositionLike} GlyphPositionLike */
+/** @typedef {import('../../types/fontkit').ShapingStage} ShapingStage */
+/** @typedef {import('../../types/fontkit').ShapingStageFn} ShapingStageFn */
+/** @typedef {import('./OTProcessor').default} OTProcessor */
+
+/**
+ * @typedef {{ global?: string[], local?: string[] }} FeatureStagesArg
+ */
+
 export default class ShapingPlan {
+  /**
+   * @param {LayoutFont} font
+   * @param {ScriptTag | string[] | null | undefined} script
+   * @param {TextDirection} direction
+   */
   constructor(font, script, direction) {
+    /** @type {LayoutFont} */
     this.font = font;
+    /** @type {ScriptTag | string[] | null | undefined} */
     this.script = script;
+    /** @type {TextDirection} */
     this.direction = direction;
+    /** @type {ShapingStage[]} */
     this.stages = [];
+    /** @type {FeatureMap} */
     this.globalFeatures = {};
+    /** @type {Record<string, number>} */
     this.allFeatures = {};
+    /** @type {FeatureMap | null} */
     this.userFeatures = null; // original user feature values (for Type 3 alternate index)
+    /** @type {ScriptTag | string[] | null | undefined} */
+    this.bufferScript = undefined;
   }
 
   /**
    * Adds the given features to the last stage.
    * Already-planned tags are not duplicated, but a global add still promotes them.
+   * @param {string[]} features
+   * @param {boolean} global
    */
   _addFeatures(features, global) {
     let stageIndex = this.stages.length - 1;
     let stage = this.stages[stageIndex];
+    if (!Array.isArray(stage)) {
+      return;
+    }
     for (let feature of features) {
       if (this.allFeatures[feature] == null) {
         stage.push(feature);
@@ -39,6 +74,8 @@ export default class ShapingPlan {
 
   /**
    * Add features to the last stage
+   * @param {string | string[] | FeatureStagesArg} arg
+   * @param {boolean} [global]
    */
   add(arg, global = true) {
     if (this.stages.length === 0) {
@@ -51,7 +88,7 @@ export default class ShapingPlan {
 
     if (Array.isArray(arg)) {
       this._addFeatures(arg, global);
-    } else if (typeof arg === 'object') {
+    } else if (typeof arg === 'object' && arg !== null) {
       this._addFeatures(arg.global || [], true);
       this._addFeatures(arg.local || [], false);
     } else {
@@ -61,6 +98,8 @@ export default class ShapingPlan {
 
   /**
    * Add a new stage
+   * @param {string | string[] | FeatureStagesArg | ShapingStageFn} arg
+   * @param {boolean} [global]
    */
   addStage(arg, global) {
     if (typeof arg === 'function') {
@@ -71,17 +110,22 @@ export default class ShapingPlan {
     }
   }
 
+  /**
+   * @param {FeatureInput | null | undefined} features
+   */
   setFeatureOverrides(features) {
     if (Array.isArray(features)) {
       this.add(features);
-    } else if (typeof features === 'object') {
+    } else if (typeof features === 'object' && features !== null) {
       this.userFeatures = features;
       for (let tag in features) {
         if (features[tag]) {
           this.add(tag);
         } else if (this.allFeatures[tag] != null) {
           let stage = this.stages[this.allFeatures[tag]];
-          stage.splice(stage.indexOf(tag), 1);
+          if (Array.isArray(stage)) {
+            stage.splice(stage.indexOf(tag), 1);
+          }
           delete this.allFeatures[tag];
           delete this.globalFeatures[tag];
         }
@@ -91,6 +135,7 @@ export default class ShapingPlan {
 
   /**
    * Assigns the global features to the given glyphs
+   * @param {GlyphInfoLike[]} glyphs
    */
   assignGlobalFeatures(glyphs) {
     for (let glyph of glyphs) {
@@ -102,6 +147,9 @@ export default class ShapingPlan {
 
   /**
    * Executes the planned stages using the given OTProcessor
+   * @param {OTProcessor} processor
+   * @param {GlyphInfoLike[]} glyphs
+   * @param {GlyphPositionLike[] | null | undefined} [positions]
    */
   process(processor, glyphs, positions) {
     // Preserve original user values (e.g. { aalt: 2 }) for GSUB Type 3.

package/src/opentype/shapers/ArabicShaper.js

@@ -4,6 +4,9 @@ import UnicodeTrie from '../../packages/unicode-trie/index.js';
 import { decodeBase64 } from '../../utils';
 import dataTrie from './data.trie';
 
+/** @typedef {import('../../../types/fontkit').ShapingPlanLike} ShapingPlanLike */
+/** @typedef {import('../../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+
 const trie = new UnicodeTrie(decodeBase64(dataTrie));
 const FEATURES = ['isol', 'fina', 'fin2', 'fin3', 'medi', 'med2', 'init'];
 
@@ -25,9 +28,13 @@ const FIN3 = 'fin3';
 const MEDI = 'medi';
 const MED2 = 'med2';
 const INIT = 'init';
+/** @type {null} */
 const NONE = null;
 
+/** @typedef {[string | null, string | null, number]} ArabicStateTransition */
+
 // Each entry is [prevAction, curAction, nextState]
+/** @type {ArabicStateTransition[][]} */
 const STATE_TABLE = [
   //   Non_Joining,        Left_Joining,       Right_Joining,     Dual_Joining,           ALAPH,            DALATH RISH
   // State 0: prev was U,  not willing to join.
@@ -61,6 +68,9 @@ const STATE_TABLE = [
  * https://github.com/behdad/harfbuzz/blob/master/src/hb-ot-shape-complex-arabic.cc
  */
 export default class ArabicShaper extends DefaultShaper {
+  /**
+   * @param {ShapingPlanLike} plan
+   */
   static planFeatures(plan) {
     plan.add(['ccmp', 'locl']);
     for (let i = 0; i < FEATURES.length; i++) {
@@ -71,11 +81,16 @@ export default class ArabicShaper extends DefaultShaper {
     plan.addStage('mset');
   }
 
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   */
   static assignFeatures(plan, glyphs) {
     super.assignFeatures(plan, glyphs);
 
     let prev = -1;
     let state = 0;
+    /** @type {Array<string | null | undefined>} */
     let actions = [];
 
     // Apply the state machine to map glyphs to features
@@ -109,6 +124,10 @@ export default class ArabicShaper extends DefaultShaper {
   }
 }
 
+/**
+ * @param {number} codePoint
+ * @returns {number}
+ */
 function getShapingClass(codePoint) {
   let res = trie.get(codePoint);
   if (res) {

package/src/opentype/shapers/DefaultShaper.js

@@ -1,11 +1,19 @@
 import { isDigit, isMark } from '../../packages/unicode-properties/index.js';
 import GlyphInfo from '../GlyphInfo';
 
+/** @typedef {import('../../../types/fontkit').ShapingPlanLike} ShapingPlanLike */
+/** @typedef {import('../../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../../types/fontkit').FeatureInput} FeatureInput */
+/** @typedef {import('../../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../../types/fontkit').TextDirection} TextDirection */
+
 const VARIATION_FEATURES = ['rvrn'];
 const COMMON_FEATURES = ['ccmp', 'locl', 'rlig', 'mark', 'mkmk'];
 const FRACTIONAL_FEATURES = ['frac', 'numr', 'dnom'];
 const HORIZONTAL_FEATURES = ['calt', 'clig', 'liga', 'rclt', 'curs', 'kern'];
 const _VERTICAL_FEATURES = ['vert'];
+/** @type {Record<TextDirection, string[]>} */
 const DIRECTIONAL_FEATURES = {
   ltr: ['ltra', 'ltrm'],
   rtl: ['rtla', 'rtlm']
@@ -13,6 +21,12 @@ const DIRECTIONAL_FEATURES = {
 
 export default class DefaultShaper {
   static zeroMarkWidths = 'AFTER_GPOS';
+
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   * @param {FeatureInput | null | undefined} features
+   */
   static plan(plan, glyphs, features) {
     // Plan the features we want to apply
     this.planPreprocessing(plan);
@@ -26,6 +40,9 @@ export default class DefaultShaper {
     this.assignFeatures(plan, glyphs);
   }
 
+  /**
+   * @param {ShapingPlanLike} plan
+   */
   static planPreprocessing(plan) {
     plan.add({
       global: [...VARIATION_FEATURES, ...DIRECTIONAL_FEATURES[plan.direction]],
@@ -33,15 +50,26 @@ export default class DefaultShaper {
     });
   }
 
+  /**
+   * @param {ShapingPlanLike} _plan
+   */
   static planFeatures(_plan) {
     // Do nothing by default. Let subclasses override this.
   }
 
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {FeatureInput | null | undefined} userFeatures
+   */
   static planPostprocessing(plan, userFeatures) {
     plan.add([...COMMON_FEATURES, ...HORIZONTAL_FEATURES]);
     plan.setFeatureOverrides(userFeatures);
   }
 
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   */
   static assignFeatures(plan, glyphs) {
     // Font-aware NFC before GSUB (HarfBuzz default-shaper behavior).
     composeGlyphs(plan.font, glyphs);
@@ -75,9 +103,17 @@ export default class DefaultShaper {
   }
 }
 
-// Compose base+mark clusters when the font has the precomposed glyph.
-// Skip pure mark reorders (same length) so Arabic calt etc. keep expected order.
+/**
+ * Compose base+mark clusters when the font has the precomposed glyph.
+ * Skip pure mark reorders (same length) so Arabic calt etc. keep expected order.
+ * @param {LayoutFont} font
+ * @param {GlyphInfoLike[]} glyphs
+ */
 function composeGlyphs(font, glyphs) {
+  /**
+   * @param {GlyphInfoLike} g
+   * @returns {boolean}
+   */
   let singleMark = g => g.codePoints.length === 1 && isMark(g.codePoints[0]);
 
   for (let i = 0; i < glyphs.length;) {
@@ -94,12 +130,15 @@ function composeGlyphs(font, glyphs) {
       continue;
     }
 
-    let input = glyphs.slice(i, end).map(g => g.codePoints[0]);
+    let input = glyphs.slice(i, end).map(/** @param {GlyphInfoLike} g */ g => g.codePoints[0]);
     let composed = Array.from(String.fromCodePoint(...input).normalize('NFC')).flatMap((char) => {
       let cp = char.codePointAt(0);
+      if (cp == null) {
+        return /** @type {number[]} */ ([]);
+      }
       return font.hasGlyphForCodePoint(cp)
         ? [cp]
-        : Array.from(char.normalize('NFD'), c => c.codePointAt(0));
+        : Array.from(char.normalize('NFD'), c => /** @type {number} */ (c.codePointAt(0)));
     });
 
     if (composed.length === input.length) {
@@ -107,9 +146,14 @@ function composeGlyphs(font, glyphs) {
       continue;
     }
 
-    let replacement = composed.map(
-      cp => new GlyphInfo(font, font.glyphForCodePoint(cp).id, [cp], base.features)
-    );
+    /** @type {GlyphInfo[]} */
+    let replacement = [];
+    for (let cp of composed) {
+      let g = font.glyphForCodePoint(cp);
+      if (g) {
+        replacement.push(new GlyphInfo(font, g.id, [cp], /** @type {FeatureMap} */ (base.features)));
+      }
+    }
     glyphs.splice(i, end - i, ...replacement);
     i += replacement.length;
   }

package/src/opentype/shapers/HangulShaper.js

@@ -1,6 +1,12 @@
 import DefaultShaper from './DefaultShaper';
 import GlyphInfo from '../GlyphInfo';
 
+/** @typedef {import('../../../types/fontkit').ShapingPlanLike} ShapingPlanLike */
+/** @typedef {import('../../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../../types/fontkit').FeatureInput} FeatureInput */
+
 /**
  * This is a shaper for the Hangul script, used by the Korean language.
  * It does the following:
@@ -25,10 +31,18 @@ import GlyphInfo from '../GlyphInfo';
  */
 export default class HangulShaper extends DefaultShaper {
   static zeroMarkWidths = 'NONE';
+
+  /**
+   * @param {ShapingPlanLike} plan
+   */
   static planFeatures(plan) {
     plan.add(['ljmo', 'vjmo', 'tjmo'], false);
   }
 
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   */
   static assignFeatures(plan, glyphs) {
     let state = 0;
     let i = 0;
@@ -83,15 +97,24 @@ const V_END = V_BASE + V_COUNT - 1;
 const T_END = T_BASE + T_COUNT - 1;
 const DOTTED_CIRCLE = 0x25cc;
 
+/** @param {number} code @returns {boolean} */
 const isL = code => 0x1100 <= code && code <= 0x115f || 0xa960 <= code && code <= 0xa97c;
+/** @param {number} code @returns {boolean} */
 const isV = code => 0x1160 <= code && code <= 0x11a7 || 0xd7b0 <= code && code <= 0xd7c6;
+/** @param {number} code @returns {boolean} */
 const isT = code => 0x11a8 <= code && code <= 0x11ff || 0xd7cb <= code && code <= 0xd7fb;
+/** @param {number} code @returns {boolean} */
 const isTone = code => 0x302e <= code && code <= 0x302f;
+/** @param {number} code @returns {boolean} */
 const isLVT = code => HANGUL_BASE <= code && code <= HANGUL_END;
+/** @param {number} code @returns {boolean} */
 const isLV = code => (code - HANGUL_BASE) < HANGUL_COUNT && (code - HANGUL_BASE) % T_COUNT === 0;
+/** @param {number} code @returns {boolean} */
 const isCombiningL = code => L_BASE <= code && code <= L_END;
+/** @param {number} code @returns {boolean} */
 const isCombiningV = code => V_BASE <= code && code <= V_END;
-const isCombiningT = code => T_BASE + 1 && 1 <= code && code <= T_END;
+/** @param {number} code @returns {boolean} */
+const isCombiningT = code => T_BASE + 1 <= code && code <= T_END;
 
 // Character categories
 const X = 0; // Other character
@@ -102,7 +125,11 @@ const LV = 4; // Composed <LV> syllable
 const LVT = 5; // Composed <LVT> syllable
 const M = 6; // Tone mark
 
-// This function classifies a character using the above categories.
+/**
+ * This function classifies a character using the above categories.
+ * @param {number} code
+ * @returns {number}
+ */
 function getType(code) {
   if (isL(code)) { return L; }
   if (isV(code)) { return V; }
@@ -120,8 +147,11 @@ const COMPOSE = 2;
 const TONE_MARK = 4;
 const INVALID = 5;
 
+/** @typedef {[number, number]} HangulTransition */
+
 // Build a state machine that accepts valid syllables, and applies actions along the way.
 // The logic this is implementing is documented at the top of the file.
+/** @type {HangulTransition[][]} */
 const STATE_TABLE = [
   //       X                 L                 V                T                  LV                LVT               M
   // State 0: start state
@@ -137,10 +167,24 @@ const STATE_TABLE = [
   [[NO_ACTION, 0], [NO_ACTION, 1], [NO_ACTION, 0], [NO_ACTION, 0], [DECOMPOSE, 2], [DECOMPOSE, 3], [TONE_MARK, 0]]
 ];
 
+/**
+ * @param {LayoutFont} font
+ * @param {number} code
+ * @param {FeatureMap | FeatureInput | null | undefined} features
+ * @returns {GlyphInfo}
+ */
 function getGlyph(font, code, features) {
-  return new GlyphInfo(font, font.glyphForCodePoint(code).id, [code], features);
+  let g = font.glyphForCodePoint(code);
+  // Callers typically check hasGlyphForCodePoint first; .notdef if somehow missing.
+  return new GlyphInfo(font, g ? g.id : 0, [code], features);
 }
 
+/**
+ * @param {GlyphInfoLike[]} glyphs
+ * @param {number} i
+ * @param {LayoutFont} font
+ * @returns {number}
+ */
 function decompose(glyphs, i, font) {
   let glyph = glyphs[i];
   let code = glyph.codePoints[0];
@@ -178,6 +222,12 @@ function decompose(glyphs, i, font) {
   return i + insert.length - 1;
 }
 
+/**
+ * @param {GlyphInfoLike[]} glyphs
+ * @param {number} i
+ * @param {LayoutFont} font
+ * @returns {number}
+ */
 function compose(glyphs, i, font) {
   let glyph = glyphs[i];
   let code = glyphs[i].codePoints[0];
@@ -187,7 +237,14 @@ function compose(glyphs, i, font) {
   let prevType = getType(prev);
 
   // Figure out what type of syllable we're dealing with
-  let lv, ljmo, vjmo, tjmo;
+  /** @type {number | undefined} */
+  let lv;
+  /** @type {GlyphInfoLike | undefined} */
+  let ljmo;
+  /** @type {GlyphInfoLike | undefined} */
+  let vjmo;
+  /** @type {GlyphInfoLike | undefined} */
+  let tjmo;
   if (prevType === LV && type === T) {
     // <LV,T>
     lv = prev;
@@ -242,6 +299,12 @@ function compose(glyphs, i, font) {
   return i;
 }
 
+/**
+ * Length of the Hangul syllable ending at `code` (for tone-mark reordering).
+ * Tone marks only attach to LV/LVT/V/T clusters from the state machine.
+ * @param {number} code
+ * @returns {number}
+ */
 function getLength(code) {
   switch (getType(code)) {
     case LV:
@@ -251,23 +314,37 @@ function getLength(code) {
       return 2;
     case T:
       return 3;
+    default:
+      return 1;
   }
 }
 
+/**
+ * @param {GlyphInfoLike[]} glyphs
+ * @param {number} i
+ * @param {LayoutFont} font
+ */
 function reorderToneMark(glyphs, i, font) {
   let glyph = glyphs[i];
   let code = glyphs[i].codePoints[0];
 
   // Move tone mark to the beginning of the previous syllable, unless it is zero width
-  if (font.glyphForCodePoint(code).advanceWidth === 0) { return; }
+  let toneGlyph = font.glyphForCodePoint(code);
+  if (!toneGlyph || toneGlyph.advanceWidth === 0) { return; }
 
   let prev = glyphs[i - 1].codePoints[0];
   let len = getLength(prev);
 
   glyphs.splice(i, 1);
-  return glyphs.splice(i - len, 0, glyph);
+  glyphs.splice(i - len, 0, glyph);
 }
 
+/**
+ * @param {GlyphInfoLike[]} glyphs
+ * @param {number} i
+ * @param {LayoutFont} font
+ * @returns {number}
+ */
 function insertDottedCircle(glyphs, i, font) {
   let glyph = glyphs[i];
   let code = glyphs[i].codePoints[0];
@@ -276,7 +353,8 @@ function insertDottedCircle(glyphs, i, font) {
     let dottedCircle = getGlyph(font, DOTTED_CIRCLE, glyph.features);
 
     // If the tone mark is zero width, insert the dotted circle before, otherwise after
-    let idx = font.glyphForCodePoint(code).advanceWidth === 0 ? i : i + 1;
+    let toneGlyph = font.glyphForCodePoint(code);
+    let idx = (!toneGlyph || toneGlyph.advanceWidth === 0) ? i : i + 1;
     glyphs.splice(idx, 0, dottedCircle);
     i++;
   }

package/src/opentype/shapers/HebrewShaper.js

@@ -2,12 +2,23 @@ import { getCombiningClass } from '../../packages/unicode-properties/index.js';
 import DefaultShaper from './DefaultShaper';
 import GlyphInfo from '../GlyphInfo';
 
+/** @typedef {import('../../../types/fontkit').ShapingPlanLike} ShapingPlanLike */
+/** @typedef {import('../../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../../types/fontkit').OTScriptRecord} OTScriptRecord */
+/** @typedef {import('../../../types/fontkit').OTLangSys} OTLangSys */
+/** @typedef {import('../../../types/fontkit').OTLangSysRecord} OTLangSysRecord */
+
 /**
  * Hebrew shaper (HarfBuzz hb-ot-shaper-hebrew.cc):
  *   - Compose presentation forms (FBxx) when the font lacks GPOS mark for `hebr`
  *   - Reorder patah/qamats + sheva/hiriq + meteg/below so meteg sits next to the base
  */
 export default class HebrewShaper extends DefaultShaper {
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   */
   static assignFeatures(plan, glyphs) {
     super.assignFeatures(plan, glyphs);
 
@@ -26,7 +37,12 @@ const DAGESH_FORMS = [
   0xFB48, 0xFB49, 0xFB4A
 ];
 
-// Precomposed Hebrew presentation form for `a + b`, or null (HB compose_hebrew).
+/**
+ * Precomposed Hebrew presentation form for `a + b`, or null (HB compose_hebrew).
+ * @param {number} a
+ * @param {number} b
+ * @returns {number | null}
+ */
 function composeHebrewPair(a, b) {
   switch (b) {
     case 0x05B4: // HIRIQ
@@ -53,8 +69,12 @@ function composeHebrewPair(a, b) {
   }
 }
 
-// Greedily compose adjacent pairs when the font has the glyph
-// (e.g. SHIN + SHIN_DOT → FB2A, then + DAGESH → FB2C).
+/**
+ * Greedily compose adjacent pairs when the font has the glyph
+ * (e.g. SHIN + SHIN_DOT → FB2A, then + DAGESH → FB2C).
+ * @param {GlyphInfoLike[]} glyphs
+ * @param {LayoutFont} font
+ */
 function composeHebrew(glyphs, font) {
   for (let i = 0; i + 1 < glyphs.length;) {
     let composed = glyphs[i].codePoints[0];
@@ -66,17 +86,26 @@ function composeHebrew(glyphs, font) {
       consumed++;
     }
     if (consumed > 1) {
+      let composedGlyph = font.glyphForCodePoint(composed);
+      if (!composedGlyph) {
+        i++;
+        continue;
+      }
+      /** @type {number[]} */
       let cps = [];
       for (let j = 0; j < consumed; j++) cps.push(...glyphs[i + j].codePoints);
-      glyphs[i] = new GlyphInfo(font, font.glyphForCodePoint(composed).id, cps, glyphs[i].features);
+      glyphs[i] = new GlyphInfo(font, composedGlyph.id, cps, glyphs[i].features);
       glyphs.splice(i + 1, consumed - 1);
     }
     i++;
   }
 }
 
-// HB reorder_marks_hebrew: [patah/qamats, sheva/hiriq, meteg/below] → swap last two.
-// unicode-properties already exposes Hebrew modified CCCs (CCC10/14/17/18/22).
+/**
+ * HB reorder_marks_hebrew: [patah/qamats, sheva/hiriq, meteg/below] → swap last two.
+ * unicode-properties already exposes Hebrew modified CCCs (CCC10/14/17/18/22).
+ * @param {GlyphInfoLike[]} glyphs
+ */
 function reorderMarksHebrew(glyphs) {
   for (let i = 2; i < glyphs.length; i++) {
     let c0 = getCombiningClass(glyphs[i - 2].codePoints[0]);
@@ -93,13 +122,18 @@ function reorderMarksHebrew(glyphs) {
   }
 }
 
-// Gate fallback composition on Hebrew-script GPOS `mark` (not the global featureList).
+/**
+ * Gate fallback composition on Hebrew-script GPOS `mark` (not the global featureList).
+ * @param {LayoutFont} font
+ * @returns {boolean}
+ */
 function hasGposMark(font) {
-  let hebr = font.GPOS?.scriptList?.find(e => e.tag === 'hebr')?.script;
+  let hebr = font.GPOS?.scriptList?.find(/** @param {OTScriptRecord} e */ e => e.tag === 'hebr')?.script;
   if (!hebr) return false;
 
-  let langs = [hebr.defaultLangSys, ...(hebr.langSysRecords || []).map(l => l.langSys)].filter(Boolean);
-  return langs.some(ls =>
-    (ls.featureIndexes || []).some(i => font.GPOS.featureList[i]?.tag === 'mark')
+  let langs = [hebr.defaultLangSys, ...(hebr.langSysRecords || []).map(/** @param {OTLangSysRecord} l */ l => l.langSys)]
+    .filter(/** @returns {value is OTLangSys} */ (/** @type {OTLangSys | null} */ value) => value != null);
+  return langs.some(/** @param {OTLangSys} ls */ ls =>
+    (ls.featureIndexes || []).some(/** @param {number} i */ i => font.GPOS?.featureList[i]?.tag === 'mark')
   );
 }