@cantoo/fontkit 2.0.4

package/src/opentype/shapers/ThaiShaper.js

@@ -0,0 +1,238 @@
+import DefaultShaper from './DefaultShaper';
+import GlyphInfo from '../GlyphInfo';
+
+/**
+ * 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 {
+  static assignFeatures(plan, glyphs) {
+    super.assignFeatures(plan, glyphs);
+    preprocessThai(glyphs, plan.font);
+    // HB: PUA only when buffer script is Thai and the font has no Thai GSUB.
+    if (isThaiBufferScript(plan.bufferScript || plan.script) && !hasThaiGsub(plan.font)) {
+      applyThaiPuaShaping(glyphs, plan.font);
+    }
+  }
+}
+
+// Thai/Lao SARA AM differ only by the 0x80 bit (U+0E33 / U+0EB3).
+function isSaraAm(u) {
+  return (u & ~0x0080) === 0x0E33;
+}
+
+function nikhahitFromSaraAm(u) {
+  return u - 0x0E33 + 0x0E4D;
+}
+
+function saraAaFromSaraAm(u) {
+  return u - 1;
+}
+
+// Above-base marks (Thai; Lao is the same set with +0x80).
+function isAboveBaseMark(u) {
+  const c = u & ~0x0080;
+  return c === 0x0E31
+    || (c >= 0x0E34 && c <= 0x0E37)
+    || (c >= 0x0E47 && c <= 0x0E4E)
+    || c === 0x0E3B;
+}
+
+function preprocessThai(glyphs, font) {
+  let i = 0;
+  while (i < glyphs.length) {
+    const u = glyphs[i].codePoints[0];
+    if (!isSaraAm(u)) {
+      i++;
+      continue;
+    }
+
+    const features = glyphs[i].features;
+    const nikhahit = makeGlyph(font, nikhahitFromSaraAm(u), features);
+    const saraAa = makeGlyph(font, saraAaFromSaraAm(u), features);
+    glyphs.splice(i, 1, nikhahit, saraAa);
+
+    // Walk NIKHAHIT backward over above-base marks toward the base.
+    let nikhahitIndex = i;
+    let target = nikhahitIndex;
+    while (target > 0 && isAboveBaseMark(glyphs[target - 1].codePoints[0])) {
+      target--;
+    }
+    if (target !== nikhahitIndex) {
+      const moved = glyphs.splice(nikhahitIndex, 1)[0];
+      glyphs.splice(target, 0, moved);
+    }
+
+    i += 2;
+  }
+}
+
+function makeGlyph(font, codePoint, features) {
+  const id = font.glyphForCodePoint(codePoint).id;
+  return new GlyphInfo(font, id, [codePoint], features);
+}
+
+// PUA fallback: above/below state machines remap marks (and some bases) to
+// Windows/Mac private-use codepoints when the font ships those glyphs.
+const NOP = 0;
+const SD = 1;
+const SL = 2;
+const SDL = 3;
+const RD = 4;
+
+const NC = 0; // normal consonant
+const AC = 1; // ascender (1B/1D/1F)
+const RC = 2; // removable descender (0D/10)
+const DC = 3; // strict descender (0E/0F)
+const NOT_CONSONANT = 4;
+
+const AV = 0; // above-base vowel/mark
+const BV = 1; // below-base vowel/mark
+const T = 2;  // tone mark
+const NOT_MARK = 3;
+
+function getConsonantType(u) {
+  if (u === 0x0E1B || u === 0x0E1D || u === 0x0E1F) return AC;
+  if (u === 0x0E0D || u === 0x0E10) return RC;
+  if (u === 0x0E0E || u === 0x0E0F) return DC;
+  if (u >= 0x0E01 && u <= 0x0E2E) return NC;
+  return NOT_CONSONANT;
+}
+
+function getMarkType(u) {
+  if (
+    u === 0x0E31 ||
+    (u >= 0x0E34 && u <= 0x0E37) ||
+    u === 0x0E47 ||
+    (u >= 0x0E4D && u <= 0x0E4E)
+  ) {
+    return AV;
+  }
+  if (u >= 0x0E38 && u <= 0x0E3A) return BV;
+  if (u >= 0x0E48 && u <= 0x0E4C) return T;
+  return NOT_MARK;
+}
+
+const T0 = 0, T1 = 1, T2 = 2, T3 = 3;
+const ABOVE_START_STATE = [T0, T1, T0, T0, T3]; // NC AC RC DC NOT_CONSONANT
+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
+];
+
+const B0 = 0, B1 = 1, B2 = 2;
+const BELOW_START_STATE = [B0, B0, B1, B2, B2];
+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
+];
+
+// [original, Windows PUA, Mac PUA] per action
+const PUA_MAPPINGS = {
+  [SD]: [
+    [0x0E48, 0xF70A, 0xF88B], // MAI EK
+    [0x0E49, 0xF70B, 0xF88E], // MAI THO
+    [0x0E4A, 0xF70C, 0xF891], // MAI TRI
+    [0x0E4B, 0xF70D, 0xF894], // MAI CHATTAWA
+    [0x0E4C, 0xF70E, 0xF897], // THANTHAKHAT
+    [0x0E38, 0xF718, 0xF89B], // SARA U
+    [0x0E39, 0xF719, 0xF89C], // SARA UU
+    [0x0E3A, 0xF71A, 0xF89D]  // PHINTHU
+  ],
+  [SDL]: [
+    [0x0E48, 0xF705, 0xF88C],
+    [0x0E49, 0xF706, 0xF88F],
+    [0x0E4A, 0xF707, 0xF892],
+    [0x0E4B, 0xF708, 0xF895],
+    [0x0E4C, 0xF709, 0xF898]
+  ],
+  [SL]: [
+    [0x0E48, 0xF713, 0xF88A],
+    [0x0E49, 0xF714, 0xF88D],
+    [0x0E4A, 0xF715, 0xF890],
+    [0x0E4B, 0xF716, 0xF893],
+    [0x0E4C, 0xF717, 0xF896],
+    [0x0E31, 0xF710, 0xF884], // MAI HAN-AKAT
+    [0x0E34, 0xF701, 0xF885], // SARA I
+    [0x0E35, 0xF702, 0xF886], // SARA II
+    [0x0E36, 0xF703, 0xF887], // SARA UE
+    [0x0E37, 0xF704, 0xF888], // SARA UEE
+    [0x0E47, 0xF712, 0xF889], // MAITAIKHU
+    [0x0E4D, 0xF711, 0xF899]  // NIKHAHIT
+  ],
+  [RD]: [
+    [0x0E0D, 0xF70F, 0xF89A], // YO YING
+    [0x0E10, 0xF700, 0xF89E]  // THO THAN
+  ]
+};
+
+function thaiPuaShape(u, action, font) {
+  if (action === NOP) return u;
+  const mappings = PUA_MAPPINGS[action];
+  if (!mappings) return u;
+  for (const [orig, winPua, macPua] of mappings) {
+    if (orig !== u) continue;
+    if (font.hasGlyphForCodePoint(winPua)) return winPua;
+    if (font.hasGlyphForCodePoint(macPua)) return macPua;
+    break;
+  }
+  return u;
+}
+
+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);
+}
+
+function applyThaiPuaShaping(glyphs, font) {
+  let aboveState = ABOVE_START_STATE[NOT_CONSONANT];
+  let belowState = BELOW_START_STATE[NOT_CONSONANT];
+  let baseIndex = 0;
+
+  for (let i = 0; i < glyphs.length; i++) {
+    const u = glyphs[i].codePoints[0];
+    const mt = getMarkType(u);
+
+    if (mt === NOT_MARK) {
+      const ct = getConsonantType(u);
+      aboveState = ABOVE_START_STATE[ct];
+      belowState = BELOW_START_STATE[ct];
+      baseIndex = i;
+      continue;
+    }
+
+    const [aboveAction, aboveNext] = ABOVE_STATE_MACHINE[aboveState][mt];
+    const [belowAction, belowNext] = BELOW_STATE_MACHINE[belowState][mt];
+    aboveState = aboveNext;
+    belowState = belowNext;
+
+    // At most one action is non-NOP.
+    const action = aboveAction !== NOP ? aboveAction : belowAction;
+    if (action === NOP) continue;
+
+    if (action === RD) {
+      replaceGlyphCodePoint(glyphs, baseIndex, thaiPuaShape(glyphs[baseIndex].codePoints[0], action, font), font);
+    } else {
+      replaceGlyphCodePoint(glyphs, i, thaiPuaShape(u, action, font), font);
+    }
+  }
+}
+
+// Gate PUA shaping on absence of Thai GSUB (HB plan->map.found_script[0]).
+function hasThaiGsub(font) {
+  const gsub = font.GSUB;
+  if (!gsub || !gsub.scriptList) return false;
+  return gsub.scriptList.some(entry => entry.tag === 'thai' || entry.tag === 'tha2');
+}
+
+function isThaiBufferScript(script) {
+  if (Array.isArray(script)) return script.includes('thai');
+  return script === 'thai';
+}

package/src/opentype/shapers/UniversalShaper.js

@@ -0,0 +1,186 @@
+import DefaultShaper from './DefaultShaper';
+import StateMachine from 'dfa';
+import UnicodeTrie from '../../packages/unicode-trie/index.js';
+import GlyphInfo from '../GlyphInfo';
+import useData from './use.json';
+import { decodeBase64 } from '../../utils';
+import useTrie from './use.trie';
+
+const {categories, decompositions} = useData;
+const trie = new UnicodeTrie(decodeBase64(useTrie));
+const stateMachine = new StateMachine(useData);
+
+/**
+ * This shaper is an implementation of the Universal Shaping Engine, which
+ * uses Unicode data to shape a number of scripts without a dedicated shaping engine.
+ * See https://www.microsoft.com/typography/OpenTypeDev/USE/intro.htm.
+ */
+export default class UniversalShaper extends DefaultShaper {
+  static zeroMarkWidths = 'BEFORE_GPOS';
+  static planFeatures(plan) {
+    plan.addStage(setupSyllables);
+
+    // Default glyph pre-processing group
+    plan.addStage(['locl', 'ccmp', 'nukt', 'akhn']);
+
+    // Reordering group
+    plan.addStage(clearSubstitutionFlags);
+    plan.addStage(['rphf'], false);
+    plan.addStage(recordRphf);
+    plan.addStage(clearSubstitutionFlags);
+    plan.addStage(['pref']);
+    plan.addStage(recordPref);
+
+    // Orthographic unit shaping group
+    plan.addStage(['rkrf', 'abvf', 'blwf', 'half', 'pstf', 'vatu', 'cjct']);
+    plan.addStage(reorder);
+
+    // Topographical features
+    // Scripts that need this are handled by the Arabic shaper, not implemented here for now.
+    // plan.addStage(['isol', 'init', 'medi', 'fina', 'med2', 'fin2', 'fin3'], false);
+
+    // Standard topographic presentation and positional feature application
+    plan.addStage(['abvs', 'blws', 'pres', 'psts', 'dist', 'abvm', 'blwm']);
+  }
+
+  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 g = plan.font.glyphForCodePoint(c);
+          return new GlyphInfo(plan.font, g.id, [c], glyphs[i].features);
+        });
+
+        glyphs.splice(i, 1, ...decomposed);
+      }
+    }
+  }
+}
+
+function useCategory(glyph) {
+  return trie.get(glyph.codePoints[0]);
+}
+
+class USEInfo {
+  constructor(category, syllableType, syllable) {
+    this.category = category;
+    this.syllableType = syllableType;
+    this.syllable = syllable;
+  }
+}
+
+function setupSyllables(font, glyphs) {
+  let syllable = 0;
+  for (let [start, end, tags] of stateMachine.match(glyphs.map(useCategory))) {
+    ++syllable;
+
+    // Create shaper info
+    for (let i = start; i <= end; i++) {
+      glyphs[i].shaperInfo = new USEInfo(categories[useCategory(glyphs[i])], tags[0], syllable);
+    }
+
+    // Assign rphf feature
+    let limit = glyphs[start].shaperInfo.category === 'R' ? 1 : Math.min(3, end - start);
+    for (let i = start; i < start + limit; i++) {
+      glyphs[i].features.rphf = true;
+    }
+  }
+}
+
+function clearSubstitutionFlags(font, glyphs) {
+  for (let glyph of glyphs) {
+    glyph.substituted = false;
+  }
+}
+
+function recordRphf(font, glyphs) {
+  for (let glyph of glyphs) {
+    if (glyph.substituted && glyph.features.rphf) {
+      // Mark a substituted repha.
+      glyph.shaperInfo.category = 'R';
+    }
+  }
+}
+
+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';
+    }
+  }
+}
+
+function reorder(font, glyphs) {
+  let dottedCircle = font.glyphForCodePoint(0x25cc).id;
+
+  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 type = info.syllableType;
+
+    // Only a few syllable types need reordering.
+    if (type !== 'virama_terminated_cluster' && type !== 'standard_cluster' && type !== 'broken_cluster') {
+      continue;
+    }
+
+    // Insert a dotted circle glyph in broken clusters.
+    if (type === 'broken_cluster' && dottedCircle) {
+      let g = new GlyphInfo(font, dottedCircle, [0x25cc]);
+      g.shaperInfo = info;
+
+      // Insert after possible Repha.
+      for (i = start; i < end && glyphs[i].shaperInfo.category === 'R'; i++);
+      glyphs.splice(i + 1, 0, g);
+      end++;
+    }
+
+    // Move things forward.
+    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;
+        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.
+          if (isHalant(glyphs[i])) {
+            i--;
+          }
+
+          glyphs.splice(start, 0, ...glyphs.splice(start + 1, i - start), glyphs[i]);
+          break;
+        }
+      }
+    }
+
+    // Move things back.
+    for (i = start, j = end; i < end; i++) {
+      info = glyphs[i].shaperInfo;
+      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.
+        j = isHalant(glyphs[i]) ? i + 1 : i;
+      } else if ((info.category === 'VPre' || info.category === 'VMPre') && j < i) {
+        glyphs.splice(j, 1, glyphs[i], ...glyphs.splice(j, i - j));
+      }
+    }
+  }
+}
+
+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);
+  return start;
+}
+
+function isHalant(glyph) {
+  return glyph.shaperInfo.category === 'H' && !glyph.isLigated;
+}
+
+function isBase(info) {
+  return info.category === 'B' || info.category === 'GB';
+}

package/src/opentype/shapers/gen-indic.js

@@ -0,0 +1,208 @@
+import codepoints from 'codepoints';
+import fs from 'fs';
+import UnicodeTrieBuilder from '../../packages/unicode-trie/builder.js';
+import dfa from 'dfa/compile.js';
+import { CATEGORIES, POSITIONS, CONSONANT_FLAGS } from './indic-data.js';
+
+const compile = dfa.default;
+
+const CATEGORY_MAP = {
+  Avagraha: 'Symbol',
+  Bindu: 'SM',
+  Brahmi_Joining_Number: 'Placeholder',
+  Cantillation_Mark: 'A',
+  Consonant: 'C',
+  Consonant_Dead: 'C',
+  Consonant_Final: 'CM',
+  Consonant_Head_Letter: 'C',
+  Consonant_Killer: 'M',
+  Consonant_Medial: 'CM',
+  Consonant_Placeholder: 'Placeholder',
+  Consonant_Preceding_Repha: 'Repha',
+  Consonant_Prefixed: 'X',
+  Consonant_Subjoined: 'CM',
+  Consonant_Succeeding_Repha: 'N',
+  Consonant_With_Stacker: 'Repha',
+  Gemination_Mark: 'SM',
+  Invisible_Stacker: 'Coeng',
+  Joiner: 'ZWJ',
+  Modifying_Letter: 'X',
+  Non_Joiner: 'ZWNJ',
+  Nukta: 'N',
+  Number: 'Placeholder',
+  Number_Joiner: 'Placeholder',
+  Pure_Killer: 'M',
+  Register_Shifter: 'RS',
+  Syllable_Modifier: 'M',
+  Tone_Letter: 'X',
+  Tone_Mark: 'N',
+  Virama: 'H',
+  Visarga: 'SM',
+  Vowel: 'V',
+  Vowel_Dependent: 'M',
+  Vowel_Independent: 'V'
+};
+
+const OVERRIDES = {
+  0x0953: 'SM',
+  0x0954: 'SM',
+  0x0A72: 'C',
+  0x0A73: 'C',
+  0x1CF5: 'C',
+  0x1CF6: 'C',
+  0x1CE2: 'A',
+  0x1CE3: 'A',
+  0x1CE4: 'A',
+  0x1CE5: 'A',
+  0x1CE6: 'A',
+  0x1CE7: 'A',
+  0x1CE8: 'A',
+  0x1CED: 'A',
+  0xA8F2: 'Symbol',
+  0xA8F3: 'Symbol',
+  0xA8F4: 'Symbol',
+  0xA8F5: 'Symbol',
+  0xA8F6: 'Symbol',
+  0xA8F7: 'Symbol',
+  0x1CE9: 'Symbol',
+  0x1CEA: 'Symbol',
+  0x1CEB: 'Symbol',
+  0x1CEC: 'Symbol',
+  0x1CEE: 'Symbol',
+  0x1CEF: 'Symbol',
+  0x1CF0: 'Symbol',
+  0x1CF1: 'Symbol',
+  0x17C6: 'N',
+  0x2010: 'Placeholder',
+  0x2011: 'Placeholder',
+  0x25CC: 'Dotted_Circle',
+
+  // Ra
+  0x0930: 'Ra', // Devanagari
+  0x09B0: 'Ra', // Bengali
+  0x09F0: 'Ra', // Bengali
+  0x0A30: 'Ra', // Gurmukhi - No Reph
+  0x0AB0: 'Ra', // Gujarati
+  0x0B30: 'Ra', // Oriya
+  0x0BB0: 'Ra', // Tamil - No Reph
+  0x0C30: 'Ra', // Telugu - Reph formed only with ZWJ
+  0x0CB0: 'Ra', // Kannada
+  0x0D30: 'Ra', // Malayalam - No Reph, Logical Repha
+  0x0DBB: 'Ra', // Sinhala - Reph formed only with ZWJ
+  0x179A: 'Ra', // Khmer - No Reph, Visual Repha
+};
+
+const POSITION_MAP = {
+  Left: 'Pre_C',
+  Top: 'Above_C',
+  Bottom: 'Below_C',
+  Right: 'Post_C',
+
+  // These should resolve to the position of the last part of the split sequence.
+  Bottom_And_Right: 'Post_C',
+  Left_And_Right: 'Post_C',
+  Top_And_Bottom: 'Below_C',
+  Top_And_Bottom_And_Right: 'Post_C',
+  Top_And_Left: 'Above_C',
+  Top_And_Left_And_Right: 'Post_C',
+  Top_And_Right: 'Post_C',
+
+  Overstruck: 'After_Main',
+  Visual_Order_Left: 'Pre_M'
+};
+
+function matraPosition(c, pos) {
+  switch (pos) {
+    case 'Pre_C':
+      return 'Pre_M';
+
+    case 'Post_C':
+      switch (c.block) {
+        case 'Devanagari': return 'After_Sub';
+        case 'Bengali':    return 'After_Post';
+        case 'Gurmukhi':   return 'After_Post';
+        case 'Gujarati':   return 'After_Post';
+        case 'Oriya':      return 'After_Post';
+        case 'Tamil':      return 'After_Post';
+        case 'Telugu':     return c.code <= 0x0C42 ? 'Before_Sub' : 'After_Sub';
+        case 'Kannada':    return c.code < 0x0CC3 || c.code > 0xCD6 ? 'Before_Sub' : 'After_Sub';
+        case 'Malayalam':  return 'After_Post';
+        case 'Sinhala':    return 'After_Sub';
+        case 'Khmer':      return 'After_Post';
+        default:           return 'After_Sub';
+      }
+
+    case 'Above_C':
+      switch (c.block) {
+        case 'Devanagari': return 'After_Sub';
+        case 'Gurmukhi':   return 'After_Post'; // Deviate from spec
+        case 'Gujarati':   return 'After_Sub';
+        case 'Oriya':      return 'After_Main';
+        case 'Tamil':      return 'After_Sub';
+        case 'Telugu':     return 'Before_Sub';
+        case 'Kannada':    return 'Before_Sub';
+        case 'Sinhala':    return 'After_Sub';
+        case 'Khmer':      return 'After_Post';
+        default:           return 'After_Sub';
+      }
+
+    case 'Below_C':
+      switch (c.block) {
+        case 'Devanagari': return 'After_Sub';
+        case 'Bengali':    return 'After_Sub';
+        case 'Gurmukhi':   return 'After_Post';
+        case 'Gujarati':   return 'After_Post';
+        case 'Oriya':      return 'After_Sub';
+        case 'Tamil':      return 'After_Post';
+        case 'Telugu':     return 'Before_Sub';
+        case 'Kannada':    return 'Before_Sub';
+        case 'Malayalam':  return 'After_Post';
+        case 'Sinhala':    return 'After_Sub';
+        case 'Khmer':      return 'After_Post';
+        default:           return 'After_Sub';
+      }
+
+    default:
+      return pos;
+  }
+}
+
+function getPosition(codepoint, category) {
+  let position = POSITION_MAP[codepoint.indicPositionalCategory] || 'End';
+
+  if (CATEGORIES[category] & CONSONANT_FLAGS) {
+    position = 'Base_C';
+  } else if (category === 'M') {
+    position = matraPosition(codepoint, position);
+  } else if (category === 'SM' || category === 'VD' || category === 'A' || category === 'Symbol') {
+    position = 'SMVD';
+  }
+
+  // Oriya Bindu is Before_Sub in the spec.
+  if (codepoint.code === 0x0B01) {
+    position = 'Before_Sub';
+  }
+
+  return Math.log2(POSITIONS[position]);
+}
+
+let symbols = {};
+for (let c in CATEGORIES) {
+  symbols[c] = Math.log2(CATEGORIES[c]);
+}
+
+let trie = new UnicodeTrieBuilder;
+for (let i = 0; i < codepoints.length; i++) {
+  let codepoint = codepoints[i];
+  if (codepoint) {
+    let category = OVERRIDES[codepoint.code] || CATEGORY_MAP[codepoint.indicSyllabicCategory] || 'X';
+    let position = getPosition(codepoint, category);
+
+    trie.set(codepoint.code, (symbols[category] << 8) | position);
+  }
+}
+
+fs.writeFileSync(new URL('indic.trie', import.meta.url), trie.toBuffer());
+
+let stateMachine = compile(fs.readFileSync(new URL('indic.machine', import.meta.url), 'utf8'), symbols);
+fs.writeFileSync(new URL('indic.json', import.meta.url), JSON.stringify(stateMachine));