@cantoo/fontkit 2.0.4 → 2.0.6

package/src/opentype/shapers/HebrewShaper.js

@@ -1,13 +1,24 @@
-import {getCombiningClass} from '../../packages/unicode-properties/index.js';
+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,10 +69,14 @@ 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; ) {
+  for (let i = 0; i + 1 < glyphs.length;) {
     let composed = glyphs[i].codePoints[0];
     let consumed = 1;
     while (i + consumed < glyphs.length) {
@@ -66,26 +86,35 @@ 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]);
     let c1 = getCombiningClass(glyphs[i - 1].codePoints[0]);
     let c2 = getCombiningClass(glyphs[i].codePoints[0]);
     if (
-      (c0 === 'CCC17' || c0 === 'CCC18') &&
-      (c1 === 'CCC10' || c1 === 'CCC14') &&
-      (c2 === 'CCC22' || c2 === 'Below')
+      (c0 === 'CCC17' || c0 === 'CCC18')
+      && (c1 === 'CCC10' || c1 === 'CCC14')
+      && (c2 === 'CCC22' || c2 === 'Below')
     ) {
       [glyphs[i - 1], glyphs[i]] = [glyphs[i], glyphs[i - 1]];
       break;
@@ -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')
   );
 }

package/src/opentype/shapers/IndicShaper.js

@@ -1,7 +1,7 @@
 import DefaultShaper from './DefaultShaper';
 import StateMachine from 'dfa';
 import UnicodeTrie from '../../packages/unicode-trie/index.js';
-import {getCategory} from '../../packages/unicode-properties/index.js';
+import { getCategory } from '../../packages/unicode-properties/index.js';
 import * as Script from '../../layout/Script';
 import GlyphInfo from '../GlyphInfo';
 import indicMachine from './indic.json';
@@ -17,9 +17,24 @@ import {
 import { decodeBase64 } from '../../utils';
 import indicTrie from './indic.trie';
 
-const {decompositions} = useData;
+/** @typedef {import('../../../types/fontkit').ShapingPlanLike} ShapingPlanLike */
+/** @typedef {import('../../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../../types/fontkit').IndicGlyphInfo} IndicGlyphInfo */
+/** @typedef {import('../../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../../types/fontkit').IndicConfig} IndicConfig */
+/** @typedef {import('../../../types/fontkit').IndicShaperInfo} IndicShaperInfo */
+/** @typedef {import('../../../types/fontkit').ShapingStageFn} ShapingStageFn */
+/** @typedef {import('dfa').StateMachineDefinition} StateMachineDefinition */
+
+/**
+ * @typedef {{ decompositions: Record<string, number[]> }} UseDataPartial
+ */
+
+/** @type {UseDataPartial} */
+const useDataTyped = /** @type {UseDataPartial} */ (useData);
+const { decompositions } = useDataTyped;
 const trie = new UnicodeTrie(decodeBase64(indicTrie));
-const stateMachine = new StateMachine(indicMachine);
+const stateMachine = new StateMachine(/** @type {StateMachineDefinition} */ (indicMachine));
 
 /**
  * The IndicShaper supports indic scripts e.g. Devanagari, Kannada, etc.
@@ -27,6 +42,10 @@ const stateMachine = new StateMachine(indicMachine);
  */
 export default class IndicShaper extends DefaultShaper {
   static zeroMarkWidths = 'NONE';
+
+  /**
+   * @param {ShapingPlanLike} plan
+   */
   static planFeatures(plan) {
     plan.addStage(setupSyllables);
 
@@ -55,24 +74,39 @@ export default class IndicShaper extends DefaultShaper {
     });
 
     // Setup the indic config for the selected script
-    plan.unicodeScript = Script.fromOpenType(plan.script);
-    plan.indicConfig = INDIC_CONFIGS[plan.unicodeScript] || INDIC_CONFIGS.Default;
-    plan.isOldSpec = plan.indicConfig.hasOldSpec && plan.script[plan.script.length - 1] !== '2';
+    let scriptTag = Array.isArray(plan.script) ? plan.script[0] : plan.script;
+    plan.unicodeScript = scriptTag != null ? Script.fromOpenType(scriptTag) : undefined;
+    /** @type {Record<string, IndicConfig>} */
+    let configs = INDIC_CONFIGS;
+    plan.indicConfig = (plan.unicodeScript && configs[plan.unicodeScript]) || configs.Default;
+    let scriptKey = Array.isArray(plan.script)
+      ? plan.script[plan.script.length - 1]
+      : plan.script;
+    plan.isOldSpec = !!(plan.indicConfig.hasOldSpec && scriptKey != null && scriptKey[scriptKey.length - 1] !== '2');
 
     // TODO: turn off kern (Khmer) and liga features.
   }
 
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   */
   static assignFeatures(plan, glyphs) {
     // Decompose split matras
     // TODO: do this in a more general unicode normalizer
     for (let i = glyphs.length - 1; i >= 0; i--) {
       let codepoint = glyphs[i].codePoints[0];
-      let d = INDIC_DECOMPOSITIONS[codepoint] || decompositions[codepoint];
+      let d = /** @type {Record<number, number[]>} */ (INDIC_DECOMPOSITIONS)[codepoint]
+        || decompositions[String(codepoint)];
       if (d) {
-        let decomposed = d.map(c => {
+        /** @type {GlyphInfo[]} */
+        let decomposed = [];
+        for (let c of d) {
           let g = plan.font.glyphForCodePoint(c);
-          return new GlyphInfo(plan.font, g.id, [c], glyphs[i].features);
-        });
+          if (g) {
+            decomposed.push(new GlyphInfo(plan.font, g.id, [c], glyphs[i].features));
+          }
+        }
 
         glyphs.splice(i, 1, ...decomposed);
       }
@@ -80,23 +114,63 @@ export default class IndicShaper extends DefaultShaper {
   }
 }
 
+/**
+ * @param {GlyphInfoLike} glyph
+ * @returns {number}
+ */
 function indicCategory(glyph) {
   return trie.get(glyph.codePoints[0]) >> 8;
 }
 
+/**
+ * @param {GlyphInfoLike} glyph
+ * @returns {number}
+ */
 function indicPosition(glyph) {
   return 1 << (trie.get(glyph.codePoints[0]) & 0xff);
 }
 
 class IndicInfo {
+  /**
+   * @param {number} category
+   * @param {number} position
+   * @param {string} syllableType
+   * @param {number} syllable
+   */
   constructor(category, position, syllableType, syllable) {
+    /** @type {number} */
     this.category = category;
+    /** @type {number} */
     this.position = position;
+    /** @type {string} */
     this.syllableType = syllableType;
+    /** @type {number} */
     this.syllable = syllable;
   }
 }
 
+/**
+ * @param {import('../../../types/fontkit').IndicShaperInfo | import('../../../types/fontkit').USEShaperInfo | null} info
+ * @returns {info is IndicShaperInfo}
+ */
+function isIndicShaperInfo(info) {
+  // Discriminate on category kind: Indic uses numeric bitflags, USE uses strings.
+  return info != null && typeof info.category === 'number';
+}
+
+/**
+ * @param {GlyphInfoLike} glyph
+ * @returns {IndicShaperInfo}
+ */
+function indicInfo(glyph) {
+  let info = glyph.shaperInfo;
+  if (!isIndicShaperInfo(info)) {
+    throw new Error('Expected Indic shaperInfo');
+  }
+  return info;
+}
+
+/** @type {ShapingStageFn} */
 function setupSyllables(font, glyphs) {
   let syllable = 0;
   let last = 0;
@@ -131,29 +205,55 @@ function setupSyllables(font, glyphs) {
   }
 }
 
+/**
+ * @param {GlyphInfoLike} glyph
+ * @returns {number}
+ */
 function isConsonant(glyph) {
-  return glyph.shaperInfo.category & CONSONANT_FLAGS;
+  return indicInfo(glyph).category & CONSONANT_FLAGS;
 }
 
+/**
+ * @param {GlyphInfoLike} glyph
+ * @returns {number}
+ */
 function isJoiner(glyph) {
-  return glyph.shaperInfo.category & JOINER_FLAGS;
+  return indicInfo(glyph).category & JOINER_FLAGS;
 }
 
+/**
+ * @param {GlyphInfoLike} glyph
+ * @returns {number}
+ */
 function isHalantOrCoeng(glyph) {
-  return glyph.shaperInfo.category & HALANT_OR_COENG_FLAGS;
+  return indicInfo(glyph).category & HALANT_OR_COENG_FLAGS;
 }
 
+/**
+ * @param {GlyphInfoLike[]} glyphs
+ * @param {string} feature
+ * @returns {boolean}
+ */
 function wouldSubstitute(glyphs, feature) {
   for (let glyph of glyphs) {
-    glyph.features = {[feature]: true};
+    glyph.features = { [feature]: true };
   }
 
-  let GSUB = glyphs[0]._font._layoutEngine.engine.GSUBProcessor;
-  GSUB.applyFeatures([feature], glyphs);
+  let engine = glyphs[0]._font._layoutEngine.engine;
+  if (!engine?.GSUBProcessor) {
+    return false;
+  }
+  engine.GSUBProcessor.applyFeatures([feature], glyphs);
 
   return glyphs.length === 1;
 }
 
+/**
+ * @param {LayoutFont} font
+ * @param {GlyphInfoLike} consonant
+ * @param {GlyphInfoLike} virama
+ * @returns {number}
+ */
 function consonantPosition(font, consonant, virama) {
   let glyphs = [virama, consonant, virama];
   if (wouldSubstitute(glyphs.slice(0, 2), 'blwf') || wouldSubstitute(glyphs.slice(1, 3), 'blwf')) {
@@ -167,12 +267,18 @@ function consonantPosition(font, consonant, virama) {
   return POSITIONS.Base_C;
 }
 
-function initialReordering(font, glyphs, plan) {
-  let indicConfig = plan.indicConfig;
-  let features = font._layoutEngine.engine.GSUBProcessor.features;
-
-  let dottedCircle = font.glyphForCodePoint(0x25cc).id;
-  let virama = font.glyphForCodePoint(indicConfig.virama).id;
+/** @type {ShapingStageFn} */
+function initialReordering(font, glyphsArg, plan) {
+  // setupSyllables always attaches IndicShaperInfo before this stage.
+  const glyphs = /** @type {IndicGlyphInfo[]} */ (glyphsArg);
+  let indicConfig = /** @type {IndicConfig} */ (plan.indicConfig);
+  let engine = font._layoutEngine.engine;
+  let features = engine?.GSUBProcessor ? engine.GSUBProcessor.features : {};
+
+  let dottedCircleGlyph = font.glyphForCodePoint(0x25cc);
+  let dottedCircle = dottedCircleGlyph ? dottedCircleGlyph.id : 0;
+  let viramaGlyph = font.glyphForCodePoint(indicConfig.virama);
+  let virama = viramaGlyph ? viramaGlyph.id : 0;
   if (virama) {
     let info = new GlyphInfo(font, virama, [indicConfig.virama]);
     for (let i = 0; i < glyphs.length; i++) {
@@ -183,14 +289,14 @@ function initialReordering(font, glyphs, plan) {
   }
 
   for (let start = 0, end = nextSyllable(glyphs, 0); start < glyphs.length; start = end, end = nextSyllable(glyphs, start)) {
-    let {syllableType} = glyphs[start].shaperInfo;
+    let { syllableType } = glyphs[start].shaperInfo;
 
     if (syllableType === 'symbol_cluster' || syllableType === 'non_indic_cluster') {
       continue;
     }
 
     if (syllableType === 'broken_cluster' && dottedCircle) {
-      let g = new GlyphInfo(font, dottedCircle, [0x25cc]);
+      let g = /** @type {IndicGlyphInfo} */ (new GlyphInfo(font, dottedCircle, [0x25cc]));
       g.shaperInfo = new IndicInfo(
         1 << indicCategory(g),
         indicPosition(g),
@@ -224,12 +330,12 @@ function initialReordering(font, glyphs, plan) {
     // If the syllable starts with Ra + Halant (in a script that has Reph)
     // and has more than one consonant, Ra is excluded from candidates for
     // base consonants.
-    if (indicConfig.rephPos !== POSITIONS.Ra_To_Become_Reph &&
-      features.rphf &&
-      start + 3 <= end && (
-        (indicConfig.rephMode === 'Implicit' && !isJoiner(glyphs[start + 2])) ||
-        (indicConfig.rephMode === 'Explicit' && glyphs[start + 2].shaperInfo.category === CATEGORIES.ZWJ)
-      )
+    if (indicConfig.rephPos !== POSITIONS.Ra_To_Become_Reph
+      && features.rphf
+      && start + 3 <= end && (
+      (indicConfig.rephMode === 'Implicit' && !isJoiner(glyphs[start + 2]))
+      || (indicConfig.rephMode === 'Explicit' && glyphs[start + 2].shaperInfo.category === CATEGORIES.ZWJ)
+    )
     ) {
       // See if it matches the 'rphf' feature.
       let g = [glyphs[start].copy(), glyphs[start + 1].copy(), glyphs[start + 2].copy()];
@@ -510,9 +616,9 @@ function initialReordering(font, glyphs, plan) {
       //
       // Test case: U+0924,U+094D,U+0930,U+094d,U+200D,U+0915
       for (let i = start; i + 1 < base; i++) {
-        if (glyphs[i].shaperInfo.category === CATEGORIES.Ra &&
-          glyphs[i + 1].shaperInfo.category === CATEGORIES.H &&
-          (i + 1 === base || glyphs[i + 2].shaperInfo.category === CATEGORIES.ZWJ)
+        if (glyphs[i].shaperInfo.category === CATEGORIES.Ra
+          && glyphs[i + 1].shaperInfo.category === CATEGORIES.H
+          && (i + 1 === base || glyphs[i + 2].shaperInfo.category === CATEGORIES.ZWJ)
         ) {
           glyphs[i].features.blwf = true;
           glyphs[i + 1].features.blwf = true;
@@ -569,9 +675,13 @@ function initialReordering(font, glyphs, plan) {
   }
 }
 
-function finalReordering(font, glyphs, plan) {
-  let indicConfig = plan.indicConfig;
-  let features = font._layoutEngine.engine.GSUBProcessor.features;
+/** @type {ShapingStageFn} */
+function finalReordering(font, glyphsArg, plan) {
+  // setupSyllables / initialReordering always attach IndicShaperInfo before this stage.
+  const glyphs = /** @type {IndicGlyphInfo[]} */ (glyphsArg);
+  let indicConfig = /** @type {IndicConfig} */ (plan.indicConfig);
+  let engine = font._layoutEngine.engine;
+  let features = engine?.GSUBProcessor ? engine.GSUBProcessor.features : {};
 
   for (let start = 0, end = nextSyllable(glyphs, 0); start < glyphs.length; start = end, end = nextSyllable(glyphs, start)) {
     // 4. Final reordering:
@@ -597,7 +707,7 @@ function finalReordering(font, glyphs, plan) {
                 while (base < end && isHalantOrCoeng(glyphs[base])) {
                   base++;
                 }
-                glyphs[base].shaperInfo.position = POSITIONS.BASE_C;
+                glyphs[base].shaperInfo.position = POSITIONS.Base_C;
                 tryPref = false;
               }
               break;
@@ -715,11 +825,11 @@ function finalReordering(font, glyphs, plan) {
     // - If repha is encoded separately and in the logical position, we should only
     //   move it if it did NOT ligate.  If it ligated, it's probably the font trying
     //   to make it work without the reordering.
-    if (start + 1 < end &&
-      glyphs[start].shaperInfo.position === POSITIONS.Ra_To_Become_Reph &&
-      (glyphs[start].shaperInfo.category === CATEGORIES.Repha) !== (glyphs[start].isLigated && !glyphs[start].isMultiplied)
+    if (start + 1 < end
+      && glyphs[start].shaperInfo.position === POSITIONS.Ra_To_Become_Reph
+      && (glyphs[start].shaperInfo.category === CATEGORIES.Repha) !== (glyphs[start].isLigated && !glyphs[start].isMultiplied)
     ) {
-      let newRephPos;
+      let newRephPos = end - 1;
       let rephPos = indicConfig.rephPos;
       let found = false;
 
@@ -838,9 +948,9 @@ function finalReordering(font, glyphs, plan) {
     if (tryPref && base + 1 < end) {
       for (let i = base + 1; i < end; i++) {
         if (glyphs[i].features.pref) {
-           // 1. Only reorder a glyph produced by substitution during application
-           //    of the <pref> feature. (Note that a font may shape a Ra consonant with
-           //    the feature generally but block it in certain contexts.)
+          // 1. Only reorder a glyph produced by substitution during application
+          //    of the <pref> feature. (Note that a font may shape a Ra consonant with
+          //    the feature generally but block it in certain contexts.)
 
           // Note: We just check that something got substituted.  We don't check that
           // the <pref> feature actually did it...
@@ -906,6 +1016,11 @@ function finalReordering(font, glyphs, plan) {
   }
 }
 
+/**
+ * @param {IndicGlyphInfo[]} glyphs
+ * @param {number} start
+ * @returns {number}
+ */
 function nextSyllable(glyphs, start) {
   if (start >= glyphs.length) return start;
   let syllable = glyphs[start].shaperInfo.syllable;

package/src/opentype/shapers/ThaiShaper.js

@@ -1,12 +1,24 @@
 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 */
+/** @typedef {import('../../../types/fontkit').ScriptTag} ScriptTag */
+/** @typedef {import('../../../types/fontkit').OTScriptRecord} OTScriptRecord */
+
 /**
  * Thai / Lao shaper (HarfBuzz hb-ot-shaper-thai.cc):
  *   1. Decompose SARA AM → NIKHAHIT + SARA AA and reorder NIKHAHIT past above marks
  *   2. PUA tone/vowel shift fallback for legacy fonts without Thai GSUB
  */
 export default class ThaiShaper extends DefaultShaper {
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   */
   static assignFeatures(plan, glyphs) {
     super.assignFeatures(plan, glyphs);
     preprocessThai(glyphs, plan.font);
@@ -18,19 +30,23 @@ export default class ThaiShaper extends DefaultShaper {
 }
 
 // Thai/Lao SARA AM differ only by the 0x80 bit (U+0E33 / U+0EB3).
+/** @param {number} u @returns {boolean} */
 function isSaraAm(u) {
   return (u & ~0x0080) === 0x0E33;
 }
 
+/** @param {number} u @returns {number} */
 function nikhahitFromSaraAm(u) {
   return u - 0x0E33 + 0x0E4D;
 }
 
+/** @param {number} u @returns {number} */
 function saraAaFromSaraAm(u) {
   return u - 1;
 }
 
 // Above-base marks (Thai; Lao is the same set with +0x80).
+/** @param {number} u @returns {boolean} */
 function isAboveBaseMark(u) {
   const c = u & ~0x0080;
   return c === 0x0E31
@@ -39,6 +55,7 @@ function isAboveBaseMark(u) {
     || c === 0x0E3B;
 }
 
+/** @param {GlyphInfoLike[]} glyphs @param {LayoutFont} font */
 function preprocessThai(glyphs, font) {
   let i = 0;
   while (i < glyphs.length) {
@@ -68,9 +85,11 @@ function preprocessThai(glyphs, font) {
   }
 }
 
+/** @param {LayoutFont} font @param {number} codePoint @param {FeatureMap | FeatureInput | null | undefined} features @returns {GlyphInfo} */
 function makeGlyph(font, codePoint, features) {
-  const id = font.glyphForCodePoint(codePoint).id;
-  return new GlyphInfo(font, id, [codePoint], features);
+  const g = font.glyphForCodePoint(codePoint);
+  // .notdef when the mapped code point is somehow missing from the font.
+  return new GlyphInfo(font, g ? g.id : 0, [codePoint], features);
 }
 
 // PUA fallback: above/below state machines remap marks (and some bases) to
@@ -89,9 +108,10 @@ const NOT_CONSONANT = 4;
 
 const AV = 0; // above-base vowel/mark
 const BV = 1; // below-base vowel/mark
-const T = 2;  // tone mark
+const T = 2; // tone mark
 const NOT_MARK = 3;
 
+/** @param {number} u @returns {number} */
 function getConsonantType(u) {
   if (u === 0x0E1B || u === 0x0E1D || u === 0x0E1F) return AC;
   if (u === 0x0E0D || u === 0x0E10) return RC;
@@ -100,12 +120,13 @@ function getConsonantType(u) {
   return NOT_CONSONANT;
 }
 
+/** @param {number} u @returns {number} */
 function getMarkType(u) {
   if (
-    u === 0x0E31 ||
-    (u >= 0x0E34 && u <= 0x0E37) ||
-    u === 0x0E47 ||
-    (u >= 0x0E4D && u <= 0x0E4E)
+    u === 0x0E31
+    || (u >= 0x0E34 && u <= 0x0E37)
+    || u === 0x0E47
+    || (u >= 0x0E4D && u <= 0x0E4E)
   ) {
     return AV;
   }
@@ -116,24 +137,27 @@ function getMarkType(u) {
 
 const T0 = 0, T1 = 1, T2 = 2, T3 = 3;
 const ABOVE_START_STATE = [T0, T1, T0, T0, T3]; // NC AC RC DC NOT_CONSONANT
+/** @type {[number, number][][]} */
 const ABOVE_STATE_MACHINE = [
   // AV          BV          T
-  [[NOP, T3], [NOP, T0], [SD, T3]],   // T0
-  [[SL, T2],  [NOP, T1], [SDL, T2]],  // T1
-  [[NOP, T3], [NOP, T2], [SL, T3]],   // T2
-  [[NOP, T3], [NOP, T3], [NOP, T3]]   // T3
+  [[NOP, T3], [NOP, T0], [SD, T3]], // T0
+  [[SL, T2], [NOP, T1], [SDL, T2]], // T1
+  [[NOP, T3], [NOP, T2], [SL, T3]], // T2
+  [[NOP, T3], [NOP, T3], [NOP, T3]] // T3
 ];
 
 const B0 = 0, B1 = 1, B2 = 2;
 const BELOW_START_STATE = [B0, B0, B1, B2, B2];
+/** @type {[number, number][][]} */
 const BELOW_STATE_MACHINE = [
   // AV          BV          T
-  [[NOP, B0], [NOP, B2], [NOP, B0]],  // B0
-  [[NOP, B1], [RD, B2],  [NOP, B1]],  // B1
-  [[NOP, B2], [SD, B2],  [NOP, B2]]   // B2
+  [[NOP, B0], [NOP, B2], [NOP, B0]], // B0
+  [[NOP, B1], [RD, B2], [NOP, B1]], // B1
+  [[NOP, B2], [SD, B2], [NOP, B2]] // B2
 ];
 
 // [original, Windows PUA, Mac PUA] per action
+/** @type {Record<number, number[][]>} */
 const PUA_MAPPINGS = {
   [SD]: [
     [0x0E48, 0xF70A, 0xF88B], // MAI EK
@@ -143,7 +167,7 @@ const PUA_MAPPINGS = {
     [0x0E4C, 0xF70E, 0xF897], // THANTHAKHAT
     [0x0E38, 0xF718, 0xF89B], // SARA U
     [0x0E39, 0xF719, 0xF89C], // SARA UU
-    [0x0E3A, 0xF71A, 0xF89D]  // PHINTHU
+    [0x0E3A, 0xF71A, 0xF89D] // PHINTHU
   ],
   [SDL]: [
     [0x0E48, 0xF705, 0xF88C],
@@ -164,14 +188,15 @@ const PUA_MAPPINGS = {
     [0x0E36, 0xF703, 0xF887], // SARA UE
     [0x0E37, 0xF704, 0xF888], // SARA UEE
     [0x0E47, 0xF712, 0xF889], // MAITAIKHU
-    [0x0E4D, 0xF711, 0xF899]  // NIKHAHIT
+    [0x0E4D, 0xF711, 0xF899] // NIKHAHIT
   ],
   [RD]: [
     [0x0E0D, 0xF70F, 0xF89A], // YO YING
-    [0x0E10, 0xF700, 0xF89E]  // THO THAN
+    [0x0E10, 0xF700, 0xF89E] // THO THAN
   ]
 };
 
+/** @param {number} u @param {number} action @param {LayoutFont} font @returns {number} */
 function thaiPuaShape(u, action, font) {
   if (action === NOP) return u;
   const mappings = PUA_MAPPINGS[action];
@@ -185,12 +210,16 @@ function thaiPuaShape(u, action, font) {
   return u;
 }
 
+/** @param {GlyphInfoLike[]} glyphs @param {number} index @param {number} newCp @param {LayoutFont} font */
 function replaceGlyphCodePoint(glyphs, index, newCp, font) {
   const prev = glyphs[index];
   if (prev.codePoints[0] === newCp) return;
-  glyphs[index] = new GlyphInfo(font, font.glyphForCodePoint(newCp).id, [newCp], prev.features);
+  const g = font.glyphForCodePoint(newCp);
+  if (!g) return;
+  glyphs[index] = new GlyphInfo(font, g.id, [newCp], prev.features);
 }
 
+/** @param {GlyphInfoLike[]} glyphs @param {LayoutFont} font */
 function applyThaiPuaShaping(glyphs, font) {
   let aboveState = ABOVE_START_STATE[NOT_CONSONANT];
   let belowState = BELOW_START_STATE[NOT_CONSONANT];
@@ -226,12 +255,14 @@ function applyThaiPuaShaping(glyphs, font) {
 }
 
 // Gate PUA shaping on absence of Thai GSUB (HB plan->map.found_script[0]).
+/** @param {LayoutFont} font @returns {boolean} */
 function hasThaiGsub(font) {
   const gsub = font.GSUB;
   if (!gsub || !gsub.scriptList) return false;
-  return gsub.scriptList.some(entry => entry.tag === 'thai' || entry.tag === 'tha2');
+  return gsub.scriptList.some(/** @param {OTScriptRecord} entry */ entry => entry.tag === 'thai' || entry.tag === 'tha2');
 }
 
+/** @param {ScriptTag | string[] | null | undefined} script @returns {boolean} */
 function isThaiBufferScript(script) {
   if (Array.isArray(script)) return script.includes('thai');
   return script === 'thai';