@cantoo/fontkit 2.0.4 → 2.0.6

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,16 +88,18 @@ 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 {
-      throw new Error("Unsupported argument to ShapingPlan#add");
+      throw new Error('Unsupported argument to ShapingPlan#add');
     }
   }
 
   /**
    * 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.
@@ -112,7 +160,6 @@ export default class ShapingPlan {
         if (!positions) {
           stage(this.font, glyphs, this);
         }
-
       } else if (stage.length > 0) {
         processor.applyFeatures(stage, glyphs, positions);
       }

package/src/opentype/shapers/ArabicShaper.js

@@ -1,9 +1,12 @@
 import DefaultShaper from './DefaultShaper';
-import {getCategory} from '../../packages/unicode-properties/index.js';
+import { getCategory } from '../../packages/unicode-properties/index.js';
 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,31 +28,35 @@ 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.
-  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 6 ] ],
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 6]],
 
   // State 1: prev was R or ISOL/ALAPH,  not willing to join.
-  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 2 ],  [ NONE, FIN2, 5 ],  [ NONE, ISOL, 6 ] ],
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 2], [NONE, FIN2, 5], [NONE, ISOL, 6]],
 
   // State 2: prev was D/L in ISOL form,  willing to join.
-  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ INIT, FINA, 1 ],  [ INIT, FINA, 3 ],  [ INIT, FINA, 4 ],  [ INIT, FINA, 6 ] ],
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [INIT, FINA, 1], [INIT, FINA, 3], [INIT, FINA, 4], [INIT, FINA, 6]],
 
   // State 3: prev was D in FINA form,  willing to join.
-  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ MEDI, FINA, 1 ],  [ MEDI, FINA, 3 ],  [ MEDI, FINA, 4 ],  [ MEDI, FINA, 6 ] ],
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [MEDI, FINA, 1], [MEDI, FINA, 3], [MEDI, FINA, 4], [MEDI, FINA, 6]],
 
   // State 4: prev was FINA ALAPH,  not willing to join.
-  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ MED2, ISOL, 1 ],  [ MED2, ISOL, 2 ],  [ MED2, FIN2, 5 ],  [ MED2, ISOL, 6 ] ],
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [MED2, ISOL, 1], [MED2, ISOL, 2], [MED2, FIN2, 5], [MED2, ISOL, 6]],
 
   // State 5: prev was FIN2/FIN3 ALAPH,  not willing to join.
-  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ ISOL, ISOL, 1 ],  [ ISOL, ISOL, 2 ],  [ ISOL, FIN2, 5 ],  [ ISOL, ISOL, 6 ] ],
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [ISOL, ISOL, 1], [ISOL, ISOL, 2], [ISOL, FIN2, 5], [ISOL, ISOL, 6]],
 
   // State 6: prev was DALATH/RISH,  not willing to join.
-  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 2 ],  [ NONE, FIN3, 5 ],  [ NONE, ISOL, 6 ] ]
+  [[NONE, NONE, 0], [NONE, ISOL, 2], [NONE, ISOL, 1], [NONE, ISOL, 2], [NONE, FIN3, 5], [NONE, ISOL, 6]]
 ];
 
 /**
@@ -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 { 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,12 +103,20 @@ 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; ) {
+  for (let i = 0; i < glyphs.length;) {
     let base = glyphs[i];
     if (base.codePoints.length !== 1 || isMark(base.codePoints[0])) {
       i++;
@@ -94,12 +130,15 @@ function composeGlyphs(font, glyphs) {
       continue;
     }
 
-    let input = glyphs.slice(i, end).map(g => g.codePoints[0]);
-    let composed = Array.from(String.fromCodePoint(...input).normalize('NFC')).flatMap(char => {
+    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;
@@ -38,7 +52,7 @@ export default class HangulShaper extends DefaultShaper {
       let code = glyph.codePoints[0];
       let type = getType(code);
 
-      [ action, state ] = STATE_TABLE[state][type];
+      [action, state] = STATE_TABLE[state][type];
 
       switch (action) {
         case DECOMPOSE:
@@ -69,46 +83,59 @@ export default class HangulShaper extends DefaultShaper {
   }
 }
 
-const HANGUL_BASE  = 0xac00;
-const HANGUL_END   = 0xd7a4;
+const HANGUL_BASE = 0xac00;
+const HANGUL_END = 0xd7a4;
 const HANGUL_COUNT = HANGUL_END - HANGUL_BASE + 1;
-const L_BASE  = 0x1100; // lead
-const V_BASE  = 0x1161; // vowel
-const T_BASE  = 0x11a7; // trail
+const L_BASE = 0x1100; // lead
+const V_BASE = 0x1161; // vowel
+const T_BASE = 0x11a7; // trail
 const L_COUNT = 19;
 const V_COUNT = 21;
 const T_COUNT = 28;
-const L_END   = L_BASE + L_COUNT - 1;
-const V_END   = V_BASE + V_COUNT - 1;
-const T_END   = T_BASE + T_COUNT - 1;
+const L_END = L_BASE + L_COUNT - 1;
+const V_END = V_BASE + V_COUNT - 1;
+const T_END = T_BASE + T_COUNT - 1;
 const DOTTED_CIRCLE = 0x25cc;
 
-const isL    = code => 0x1100 <= code && code <= 0x115f || 0xa960 <= code && code <= 0xa97c;
-const isV    = code => 0x1160 <= code && code <= 0x11a7 || 0xd7b0 <= code && code <= 0xd7c6;
-const isT    = code => 0x11a8 <= code && code <= 0x11ff || 0xd7cb <= code && code <= 0xd7fb;
+/** @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;
-const isLVT  = code => HANGUL_BASE <= code && code <= HANGUL_END;
-const isLV   = code => (code - HANGUL_BASE) < HANGUL_COUNT && (code - HANGUL_BASE) % T_COUNT === 0;
+/** @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
-const L   = 1; // Leading consonant
-const V   = 2; // Medial vowel
-const T   = 3; // Trailing consonant
-const LV  = 4; // Composed <LV> syllable
+const X = 0; // Other character
+const L = 1; // Leading consonant
+const V = 2; // Medial vowel
+const T = 3; // Trailing consonant
+const LV = 4; // Composed <LV> syllable
 const LVT = 5; // Composed <LVT> syllable
-const M   = 6; // Tone mark
+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; }
-  if (isT(code))    { return T; }
-  if (isLV(code))   { return LV; }
-  if (isLVT(code))  { return LVT; }
+  if (isL(code)) { return L; }
+  if (isV(code)) { return V; }
+  if (isT(code)) { return T; }
+  if (isLV(code)) { return LV; }
+  if (isLVT(code)) { return LVT; }
   if (isTone(code)) { return M; }
   return X;
 }
@@ -116,31 +143,48 @@ function getType(code) {
 // State machine actions
 const NO_ACTION = 0;
 const DECOMPOSE = 1;
-const COMPOSE   = 2;
+const COMPOSE = 2;
 const TONE_MARK = 4;
-const INVALID   = 5;
+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
-  [ [ NO_ACTION, 0 ], [ NO_ACTION, 1 ], [ NO_ACTION, 0 ], [ NO_ACTION, 0 ], [ DECOMPOSE, 2 ], [ DECOMPOSE, 3 ], [  INVALID, 0  ] ],
+  [[NO_ACTION, 0], [NO_ACTION, 1], [NO_ACTION, 0], [NO_ACTION, 0], [DECOMPOSE, 2], [DECOMPOSE, 3], [INVALID, 0]],
 
   // State 1: <L>
-  [ [ NO_ACTION, 0 ], [ NO_ACTION, 1 ], [  COMPOSE, 2  ], [ NO_ACTION, 0 ], [ DECOMPOSE, 2 ], [ DECOMPOSE, 3 ], [  INVALID, 0  ] ],
+  [[NO_ACTION, 0], [NO_ACTION, 1], [COMPOSE, 2], [NO_ACTION, 0], [DECOMPOSE, 2], [DECOMPOSE, 3], [INVALID, 0]],
 
   // State 2: <L,V> or <LV>
-  [ [ NO_ACTION, 0 ], [ NO_ACTION, 1 ], [ NO_ACTION, 0 ], [  COMPOSE, 3  ], [ DECOMPOSE, 2 ], [ DECOMPOSE, 3 ], [ TONE_MARK, 0 ] ],
+  [[NO_ACTION, 0], [NO_ACTION, 1], [NO_ACTION, 0], [COMPOSE, 3], [DECOMPOSE, 2], [DECOMPOSE, 3], [TONE_MARK, 0]],
 
   // State 3: <L,V,T> or <LVT>
-  [ [ NO_ACTION, 0 ], [ NO_ACTION, 1 ], [ NO_ACTION, 0 ], [ NO_ACTION, 0 ], [ DECOMPOSE, 2 ], [ DECOMPOSE, 3 ], [ TONE_MARK, 0 ] ]
+  [[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];
@@ -152,9 +196,9 @@ function decompose(glyphs, i, font) {
   let v = V_BASE + s % V_COUNT;
 
   // Don't decompose if all of the components are not available
-  if (!font.hasGlyphForCodePoint(l) ||
-      !font.hasGlyphForCodePoint(v) ||
-      (t !== T_BASE && !font.hasGlyphForCodePoint(t))) {
+  if (!font.hasGlyphForCodePoint(l)
+    || !font.hasGlyphForCodePoint(v)
+    || (t !== T_BASE && !font.hasGlyphForCodePoint(t))) {
     return i;
   }
 
@@ -166,7 +210,7 @@ function decompose(glyphs, i, font) {
   let vjmo = getGlyph(font, v, glyph.features);
   vjmo.features.vjmo = true;
 
-  let insert = [ ljmo, vjmo ];
+  let insert = [ljmo, vjmo];
 
   if (t > T_BASE) {
     let tjmo = getGlyph(font, t, glyph.features);
@@ -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++;
   }