@cantoo/fontkit 2.0.5 → 2.0.7

package/src/opentype/shapers/IndicShaper.js

@@ -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 };
   }
 
-  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++) {
@@ -190,7 +296,7 @@ function initialReordering(font, glyphs, plan) {
     }
 
     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),
@@ -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;
@@ -719,7 +829,7 @@ function finalReordering(font, glyphs, plan) {
       && 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;
 
@@ -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
@@ -92,6 +111,7 @@ const BV = 1; // below-base vowel/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,6 +120,7 @@ function getConsonantType(u) {
   return NOT_CONSONANT;
 }
 
+/** @param {number} u @returns {number} */
 function getMarkType(u) {
   if (
     u === 0x0E31
@@ -116,6 +137,7 @@ 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
@@ -126,6 +148,7 @@ const ABOVE_STATE_MACHINE = [
 
 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
@@ -134,6 +157,7 @@ const BELOW_STATE_MACHINE = [
 ];
 
 // [original, Windows PUA, Mac PUA] per action
+/** @type {Record<number, number[][]>} */
 const PUA_MAPPINGS = {
   [SD]: [
     [0x0E48, 0xF70A, 0xF88B], // MAI EK
@@ -172,6 +196,7 @@ const PUA_MAPPINGS = {
   ]
 };
 
+/** @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';

package/src/opentype/shapers/UniversalShaper.js

@@ -6,9 +6,28 @@ import useData from './use.json';
 import { decodeBase64 } from '../../utils';
 import useTrie from './use.trie';
 
-const { categories, decompositions } = useData;
+/** @typedef {import('../../../types/fontkit').ShapingPlanLike} ShapingPlanLike */
+/** @typedef {import('../../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../../types/fontkit').USEShaperInfo} USEShaperInfo */
+/** @typedef {import('dfa').StateMachineDefinition} StateMachineDefinition */
+
+/**
+ * Generated USE payload: category tables plus a compiled `dfa` machine
+ * (`stateTable` / `accepting` / `tags`). Extra keys are fine — StateMachine
+ * only reads the three DFA fields.
+ *
+ * @typedef {StateMachineDefinition & {
+ *   categories: string[],
+ *   decompositions: Record<string, number[]>
+ * }} UseData
+ */
+
+/** @type {UseData} */
+const useDataTyped = /** @type {UseData} */ (useData);
+const { categories, decompositions } = useDataTyped;
 const trie = new UnicodeTrie(decodeBase64(useTrie));
-const stateMachine = new StateMachine(useData);
+const stateMachine = new StateMachine(useDataTyped);
 
 /**
  * This shaper is an implementation of the Universal Shaping Engine, which
@@ -17,6 +36,9 @@ const stateMachine = new StateMachine(useData);
  */
 export default class UniversalShaper extends DefaultShaper {
   static zeroMarkWidths = 'BEFORE_GPOS';
+  /**
+   * @param {ShapingPlanLike} plan
+   */
   static planFeatures(plan) {
     plan.addStage(setupSyllables);
 
@@ -43,16 +65,25 @@ export default class UniversalShaper extends DefaultShaper {
     plan.addStage(['abvs', 'blws', 'pres', 'psts', 'dist', 'abvm', 'blwm']);
   }
 
+  /**
+   * @param {ShapingPlanLike} plan
+   * @param {GlyphInfoLike[]} glyphs
+   */
   static assignFeatures(plan, glyphs) {
     // Decompose split vowels
     // TODO: do this in a more general unicode normalizer
     for (let i = glyphs.length - 1; i >= 0; i--) {
       let codepoint = glyphs[i].codePoints[0];
-      if (decompositions[codepoint]) {
-        let decomposed = decompositions[codepoint].map((c) => {
+      let decomp = decompositions[String(codepoint)] || decompositions[/** @type {keyof typeof decompositions} */ (/** @type {unknown} */ (codepoint))];
+      if (decomp) {
+        /** @type {GlyphInfo[]} */
+        let decomposed = [];
+        for (let c of decomp) {
           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);
       }
@@ -60,11 +91,17 @@ export default class UniversalShaper extends DefaultShaper {
   }
 }
 
+/** @param {GlyphInfoLike} glyph @returns {number} */
 function useCategory(glyph) {
   return trie.get(glyph.codePoints[0]);
 }
 
 class USEInfo {
+  /**
+   * @param {string} category
+   * @param {string} syllableType
+   * @param {number} syllable
+   */
   constructor(category, syllableType, syllable) {
     this.category = category;
     this.syllableType = syllableType;
@@ -72,6 +109,27 @@ class USEInfo {
   }
 }
 
+/**
+ * @param {import('../../../types/fontkit').IndicShaperInfo | import('../../../types/fontkit').USEShaperInfo | null} info
+ * @returns {info is USEShaperInfo}
+ */
+function isUSEShaperInfo(info) {
+  return info != null && typeof info.category === 'string';
+}
+
+/**
+ * @param {GlyphInfoLike} glyph
+ * @returns {USEShaperInfo}
+ */
+function useInfo(glyph) {
+  let info = glyph.shaperInfo;
+  if (!isUSEShaperInfo(info)) {
+    throw new Error('Expected USE shaperInfo');
+  }
+  return info;
+}
+
+/** @type {import('../../../types/fontkit').ShapingStageFn} */
 function setupSyllables(font, glyphs) {
   let syllable = 0;
   for (let [start, end, tags] of stateMachine.match(glyphs.map(useCategory))) {
@@ -83,43 +141,48 @@ function setupSyllables(font, glyphs) {
     }
 
     // Assign rphf feature
-    let limit = glyphs[start].shaperInfo.category === 'R' ? 1 : Math.min(3, end - start);
+    let limit = useInfo(glyphs[start]).category === 'R' ? 1 : Math.min(3, end - start);
     for (let i = start; i < start + limit; i++) {
       glyphs[i].features.rphf = true;
     }
   }
 }
 
+/** @type {import('../../../types/fontkit').ShapingStageFn} */
 function clearSubstitutionFlags(font, glyphs) {
   for (let glyph of glyphs) {
     glyph.substituted = false;
   }
 }
 
+/** @type {import('../../../types/fontkit').ShapingStageFn} */
 function recordRphf(font, glyphs) {
   for (let glyph of glyphs) {
     if (glyph.substituted && glyph.features.rphf) {
       // Mark a substituted repha.
-      glyph.shaperInfo.category = 'R';
+      useInfo(glyph).category = 'R';
     }
   }
 }
 
+/** @type {import('../../../types/fontkit').ShapingStageFn} */
 function recordPref(font, glyphs) {
   for (let glyph of glyphs) {
     if (glyph.substituted) {
       // Mark a substituted pref as VPre, as they behave the same way.
-      glyph.shaperInfo.category = 'VPre';
+      useInfo(glyph).category = 'VPre';
     }
   }
 }
 
+/** @type {import('../../../types/fontkit').ShapingStageFn} */
 function reorder(font, glyphs) {
-  let dottedCircle = font.glyphForCodePoint(0x25cc).id;
+  let dottedCircleGlyph = font.glyphForCodePoint(0x25cc);
+  let dottedCircle = dottedCircleGlyph ? dottedCircleGlyph.id : 0;
 
   for (let start = 0, end = nextSyllable(glyphs, 0); start < glyphs.length; start = end, end = nextSyllable(glyphs, start)) {
     let i, j;
-    let info = glyphs[start].shaperInfo;
+    let info = useInfo(glyphs[start]);
     let type = info.syllableType;
 
     // Only a few syllable types need reordering.
@@ -133,7 +196,7 @@ function reorder(font, glyphs) {
       g.shaperInfo = info;
 
       // Insert after possible Repha.
-      for (i = start; i < end && glyphs[i].shaperInfo.category === 'R'; i++);
+      for (i = start; i < end && useInfo(glyphs[i]).category === 'R'; i++);
       glyphs.splice(i + 1, 0, g);
       end++;
     }
@@ -142,7 +205,7 @@ function reorder(font, glyphs) {
     if (info.category === 'R' && end - start > 1) {
       // Got a repha. Reorder it to after first base, before first halant.
       for (i = start + 1; i < end; i++) {
-        info = glyphs[i].shaperInfo;
+        info = useInfo(glyphs[i]);
         if (isBase(info) || isHalant(glyphs[i])) {
           // If we hit a halant, move before it; otherwise it's a base: move to it's
           // place, and shift things in between backward.
@@ -158,7 +221,7 @@ function reorder(font, glyphs) {
 
     // Move things back.
     for (i = start, j = end; i < end; i++) {
-      info = glyphs[i].shaperInfo;
+      info = useInfo(glyphs[i]);
       if (isBase(info) || isHalant(glyphs[i])) {
         // If we hit a halant, move after it; otherwise it's a base: move to it's
         // place, and shift things in between backward.
@@ -170,17 +233,20 @@ function reorder(font, glyphs) {
   }
 }
 
+/** @param {GlyphInfoLike[]} glyphs @param {number} start @returns {number} */
 function nextSyllable(glyphs, start) {
   if (start >= glyphs.length) return start;
-  let syllable = glyphs[start].shaperInfo.syllable;
-  while (++start < glyphs.length && glyphs[start].shaperInfo.syllable === syllable);
+  let syllable = useInfo(glyphs[start]).syllable;
+  while (++start < glyphs.length && useInfo(glyphs[start]).syllable === syllable);
   return start;
 }
 
+/** @param {GlyphInfoLike} glyph @returns {boolean} */
 function isHalant(glyph) {
-  return glyph.shaperInfo.category === 'H' && !glyph.isLigated;
+  return useInfo(glyph).category === 'H' && !glyph.isLigated;
 }
 
+/** @param {USEShaperInfo} info @returns {boolean} */
 function isBase(info) {
   return info.category === 'B' || info.category === 'GB';
 }