@cantoo/fontkit 2.0.4

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

@@ -0,0 +1,287 @@
+import codepoints from 'codepoints';
+import fs from 'fs';
+import UnicodeTrieBuilder from '../../packages/unicode-trie/builder.js';
+import dfa from 'dfa/compile.js';
+
+const compile = dfa.default;
+
+const CATEGORIES = {
+  B: [
+    {UISC: 'Number'},
+    {UISC: 'Avagraha', UGC: 'Lo'},
+    {UISC: 'Bindu', UGC: 'Lo'},
+    {UISC: 'Consonant'},
+    {UISC: 'Consonant_Final', UGC: 'Lo'},
+    {UISC: 'Consonant_Head_Letter'},
+    {UISC: 'Consonant_Medial', UGC: 'Lo'},
+    {UISC: 'Consonant_Subjoined', UGC: 'Lo'},
+    {UISC: 'Tone_Letter'},
+    {UISC: 'Vowel', UGC: 'Lo'},
+    {UISC: 'Vowel_Independent'},
+    {UISC: 'Vowel_Dependent', UGC: 'Lo'}
+  ],
+  CGJ: [0x034f],
+  CM: [
+    'Nukta',
+    'Gemination_Mark',
+    'Consonant_Killer'
+  ],
+  CS: [
+    'Consonant_With_Stacker'
+  ],
+  F: [
+    {UISC: 'Consonant_Final', UGC: {not: 'Lo'}},
+    {UISC: 'Consonant_Succeeding_Repha'}
+  ],
+  FM: [
+    'Syllable_Modifier'
+  ],
+  GB: [
+    'Consonant_Placeholder',
+    0x2015,
+    0x2022,
+    0x25fb,
+    0x25fc,
+    0x25fd,
+    0x25fe
+  ],
+  H: [
+    'Virama',
+    'Invisible_Stacker'
+  ],
+  HN: [
+    'Number_Joiner'
+  ],
+  IND: [
+    'Consonant_Dead',
+    'Modifying_Letter',
+    {UGC: 'Po', U: {not: [0x104e, 0x2022]}}
+  ],
+  M: [
+    {UISC: 'Consonant_Medial', UGC: {not: 'Lo'}}
+  ],
+  N: [
+    'Brahmi_Joining_Number'
+  ],
+  R: [
+    'Consonant_Preceding_Repha',
+    'Consonant_Prefixed'
+  ],
+  Rsv: [
+    {UGC: 'Cn'} // TODO
+  ],
+  S: [
+    {UGC: 'So', U: {not: 0x25cc}},
+    {UGC: 'Sc'}
+  ],
+  SM: [
+    0x1b6b,
+    0x1b6c,
+    0x1b6d,
+    0x1b6e,
+    0x1b6f,
+    0x1b70,
+    0x1b71,
+    0x1b72,
+    0x1b73
+  ],
+  SUB: [
+    {UISC: 'Consonant_Subjoined', UGC: {not: 'Lo'}}
+  ],
+  V: [
+    {UISC: 'Vowel', UGC: {not: 'Lo'}},
+    {UISC: 'Vowel_Dependent', UGC: {not: 'Lo'}},
+    {UISC: 'Pure_Killer'}
+  ],
+  VM: [
+    {UISC: 'Bindu', UGC: {not: 'Lo'}},
+    'Tone_Mark',
+    'Cantillation_Mark',
+    'Register_Shifter',
+    'Visarga'
+  ],
+  VS: [
+    0xfe00, 0xfe01, 0xfe02, 0xfe03, 0xfe04, 0xfe05, 0xfe06, 0xfe07,
+    0xfe08, 0xfe09, 0xfe0a, 0xfe0b, 0xfe0c, 0xfe0d, 0xfe0e, 0xfe0f
+  ],
+  WJ: [0x2060],
+  ZWJ: [
+    'Joiner'
+  ],
+  ZWNJ: [
+    'Non_Joiner'
+  ],
+  O: [
+    'Other'
+  ]
+};
+
+const USE_POSITIONS = {
+  F: {
+    Abv: ['Top'],
+    Blw: ['Bottom'],
+    Pst: ['Right'],
+  },
+  M: {
+    Abv: ['Top'],
+    Blw: ['Bottom'],
+    Pst: ['Right'],
+    Pre: ['Left'],
+  },
+  CM: {
+    Abv: ['Top'],
+    Blw: ['Bottom'],
+  },
+  V: {
+    Abv: ['Top', 'Top_And_Bottom', 'Top_And_Bottom_And_Right', 'Top_And_Right'],
+    Blw: ['Bottom', 'Overstruck', 'Bottom_And_Right'],
+    Pst: ['Right'],
+    Pre: ['Left', 'Top_And_Left', 'Top_And_Left_And_Right', 'Left_And_Right'],
+  },
+  VM: {
+    Abv: ['Top'],
+    Blw: ['Bottom', 'Overstruck'],
+    Pst: ['Right'],
+    Pre: ['Left'],
+  },
+  SM: {
+    Abv: ['Top'],
+    Blw: ['Bottom'],
+  }
+};
+
+const UISC_OVERRIDE = {
+  0x17dd: 'Vowel_Dependent',
+  0x1ce2: 'Cantillation_Mark',
+  0x1ce3: 'Cantillation_Mark',
+  0x1ce4: 'Cantillation_Mark',
+  0x1ce5: 'Cantillation_Mark',
+  0x1ce6: 'Cantillation_Mark',
+  0x1ce7: 'Cantillation_Mark',
+  0x1ce8: 'Cantillation_Mark',
+  0x1ced: 'Tone_Mark'
+};
+
+const UIPC_OVERRIDE = {
+  0x1b6c: 'Bottom',
+  0x953: 'Not_Applicable',
+  0x954: 'Not_Applicable',
+  0x103c: 'Left',
+  0xa926: 'Top',
+  0xa927: 'Top',
+  0xa928: 'Top',
+  0xa929: 'Top',
+  0xa92a: 'Top',
+  0x111ca: 'Bottom',
+  0x11300: 'Top',
+  0x1133c: 'Bottom',
+  0x1171e: 'Left',
+  0x1cf2: 'Right',
+  0x1cf3: 'Right',
+  0x1cf8: 'Top',
+  0x1cf9: 'Top'
+};
+
+function check(pattern, value) {
+  if (typeof pattern === 'object' && pattern.not) {
+    if (Array.isArray(pattern.not)) {
+      return pattern.not.indexOf(value) === -1;
+    } else {
+      return value !== pattern.not;
+    }
+  }
+
+  return value === pattern;
+}
+
+function matches(pattern, code) {
+  if (typeof pattern === 'number') {
+    pattern = {U: pattern};
+  } else if (typeof pattern === 'string') {
+    pattern = {UISC: pattern};
+  }
+
+  for (let key in pattern) {
+    if (!check(pattern[key], code[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function getUISC(code) {
+  return UISC_OVERRIDE[code.code] || code.indicSyllabicCategory || 'Other';
+}
+
+function getUIPC(code) {
+  return UIPC_OVERRIDE[code.code] || code.indicPositionalCategory;
+}
+
+function getPositionalCategory(code, USE) {
+  let UIPC = getUIPC(code);
+  let pos = USE_POSITIONS[USE];
+  if (pos) {
+    for (let key in pos) {
+      if (pos[key].indexOf(UIPC) !== -1) {
+        return USE + key;
+      }
+    }
+  }
+
+  return USE;
+}
+
+function getCategory(code) {
+  for (let category in CATEGORIES) {
+    for (let pattern of CATEGORIES[category]) {
+      if (matches(pattern, {UISC: getUISC(code), UGC: code.category, U: code.code})) {
+        return getPositionalCategory(code, category);
+      }
+    }
+  }
+
+  return null;
+}
+
+let trie = new UnicodeTrieBuilder;
+let symbols = {};
+let numSymbols = 0;
+let decompositions = {};
+for (let i = 0; i < codepoints.length; i++) {
+  let codepoint = codepoints[i];
+  if (codepoint) {
+    let category = getCategory(codepoint);
+    if (!(category in symbols)) {
+      symbols[category] = numSymbols++;
+    }
+
+    trie.set(codepoint.code, symbols[category]);
+
+    if (codepoint.indicSyllabicCategory === 'Vowel_Dependent' && codepoint.decomposition.length > 0) {
+      decompositions[codepoint.code] = decompose(codepoint.code);
+    }
+  }
+}
+
+function decompose(code) {
+  let decomposition = [];
+  let codepoint = codepoints[code];
+  for (let c of codepoint.decomposition) {
+    let codes = decompose(c);
+    codes = codes.length > 0 ? codes : [c];
+    decomposition.push(...codes);
+  }
+
+  return decomposition;
+}
+
+fs.writeFileSync(new URL('use.trie', import.meta.url), trie.toBuffer());
+
+let stateMachine = compile(fs.readFileSync(new URL('use.machine', import.meta.url), 'utf8'), symbols);
+let json = Object.assign({
+  categories: Object.keys(symbols),
+  decompositions: decompositions
+}, stateMachine);
+
+fs.writeFileSync(new URL('use.json', import.meta.url), JSON.stringify(json));

package/src/opentype/shapers/generate-data.js

@@ -0,0 +1,33 @@
+//
+// This script generates a UnicodeTrie containing shaping data derived
+// from Unicode properties (currently just for the Arabic shaper).
+//
+import codepoints from 'codepoints';
+import fs from 'fs';
+import UnicodeTrieBuilder from '../../packages/unicode-trie/builder.js';
+
+let ShapingClasses = {
+  Non_Joining: 0,
+  Left_Joining: 1,
+  Right_Joining: 2,
+  Dual_Joining: 3,
+  Join_Causing: 3,
+  ALAPH: 4,
+  'DALATH RISH': 5,
+  Transparent: 6
+};
+
+let trie = new UnicodeTrieBuilder;
+for (let i = 0; i < codepoints.length; i++) {
+  let codepoint = codepoints[i];
+  if (codepoint) {
+    if (codepoint.joiningGroup === 'ALAPH' || codepoint.joiningGroup === 'DALATH RISH') {
+      trie.set(codepoint.code, ShapingClasses[codepoint.joiningGroup] + 1);
+
+    } else if (codepoint.joiningType) {
+      trie.set(codepoint.code, ShapingClasses[codepoint.joiningType] + 1);
+    }
+  }
+}
+
+fs.writeFileSync(new URL('data.trie', import.meta.url), trie.toBuffer());

package/src/opentype/shapers/index.js

@@ -0,0 +1,109 @@
+import DefaultShaper from './DefaultShaper';
+import ArabicShaper from './ArabicShaper';
+import HangulShaper from './HangulShaper';
+import HebrewShaper from './HebrewShaper';
+import IndicShaper from './IndicShaper';
+import ThaiShaper from './ThaiShaper';
+import UniversalShaper from './UniversalShaper';
+
+const SHAPERS = {
+  arab: ArabicShaper,    // Arabic
+  mong: ArabicShaper,    // Mongolian
+  syrc: ArabicShaper,    // Syriac
+  'nko ': ArabicShaper,  // N'Ko
+  phag: ArabicShaper,    // Phags Pa
+  mand: ArabicShaper,    // Mandaic
+  mani: ArabicShaper,    // Manichaean
+  phlp: ArabicShaper,    // Psalter Pahlavi
+
+  hang: HangulShaper,    // Hangul
+
+  hebr: HebrewShaper,    // Hebrew
+
+  bng2: IndicShaper,     // Bengali
+  beng: IndicShaper,     // Bengali
+  dev2: IndicShaper,     // Devanagari
+  deva: IndicShaper,     // Devanagari
+  gjr2: IndicShaper,     // Gujarati
+  gujr: IndicShaper,     // Gujarati
+  guru: IndicShaper,     // Gurmukhi
+  gur2: IndicShaper,     // Gurmukhi
+  knda: IndicShaper,     // Kannada
+  knd2: IndicShaper,     // Kannada
+  mlm2: IndicShaper,     // Malayalam
+  mlym: IndicShaper,     // Malayalam
+  ory2: IndicShaper,     // Oriya
+  orya: IndicShaper,     // Oriya
+  taml: IndicShaper,     // Tamil
+  tml2: IndicShaper,     // Tamil
+  telu: IndicShaper,     // Telugu
+  tel2: IndicShaper,     // Telugu
+  khmr: IndicShaper,     // Khmer
+
+  thai: ThaiShaper,      // Thai
+  'lao ': ThaiShaper,    // Lao (4-char OT tag with trailing space)
+
+  bali: UniversalShaper, // Balinese
+  batk: UniversalShaper, // Batak
+  brah: UniversalShaper, // Brahmi
+  bugi: UniversalShaper, // Buginese
+  buhd: UniversalShaper, // Buhid
+  cakm: UniversalShaper, // Chakma
+  cham: UniversalShaper, // Cham
+  dupl: UniversalShaper, // Duployan
+  egyp: UniversalShaper, // Egyptian Hieroglyphs
+  gran: UniversalShaper, // Grantha
+  hano: UniversalShaper, // Hanunoo
+  java: UniversalShaper, // Javanese
+  kthi: UniversalShaper, // Kaithi
+  kali: UniversalShaper, // Kayah Li
+  khar: UniversalShaper, // Kharoshthi
+  khoj: UniversalShaper, // Khojki
+  sind: UniversalShaper, // Khudawadi
+  lepc: UniversalShaper, // Lepcha
+  limb: UniversalShaper, // Limbu
+  mahj: UniversalShaper, // Mahajani
+  // mand: UniversalShaper, // Mandaic
+  // mani: UniversalShaper, // Manichaean
+  mtei: UniversalShaper, // Meitei Mayek
+  modi: UniversalShaper, // Modi
+  // mong: UniversalShaper, // Mongolian
+  // 'nko ': UniversalShaper, // N’Ko
+  hmng: UniversalShaper, // Pahawh Hmong
+  // phag: UniversalShaper, // Phags-pa
+  // phlp: UniversalShaper, // Psalter Pahlavi
+  rjng: UniversalShaper, // Rejang
+  saur: UniversalShaper, // Saurashtra
+  shrd: UniversalShaper, // Sharada
+  sidd: UniversalShaper, // Siddham
+  sinh: IndicShaper, // Sinhala
+  sund: UniversalShaper, // Sundanese
+  sylo: UniversalShaper, // Syloti Nagri
+  tglg: UniversalShaper, // Tagalog
+  tagb: UniversalShaper, // Tagbanwa
+  tale: UniversalShaper, // Tai Le
+  lana: UniversalShaper, // Tai Tham
+  tavt: UniversalShaper, // Tai Viet
+  takr: UniversalShaper, // Takri
+  tibt: UniversalShaper, // Tibetan
+  tfng: UniversalShaper, // Tifinagh
+  tirh: UniversalShaper, // Tirhuta
+
+  latn: DefaultShaper,   // Latin
+  DFLT: DefaultShaper    // Default
+};
+
+export function choose(script) {
+  if (!Array.isArray(script)) {
+    script = [script];
+  }
+
+  for (let s of script) {
+    let shaper = SHAPERS[s];
+    if (shaper) {
+      return shaper;
+    }
+  }
+
+  return DefaultShaper;
+}

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

@@ -0,0 +1,175 @@
+// Cateories used in the OpenType spec:
+// https://www.microsoft.com/typography/otfntdev/devanot/shaping.aspx
+export const CATEGORIES = {
+  X: 1 << 0,
+  C: 1 << 1,
+  V: 1 << 2,
+  N: 1 << 3,
+  H: 1 << 4,
+  ZWNJ: 1 << 5,
+  ZWJ: 1 << 6,
+  M: 1 << 7,
+  SM: 1 << 8,
+  VD: 1 << 9,
+  A: 1 << 10,
+  Placeholder: 1 << 11,
+  Dotted_Circle: 1 << 12,
+  RS: 1 << 13,    // Register Shifter, used in Khmer OT spec.
+  Coeng: 1 << 14, // Khmer-style Virama.
+  Repha: 1 << 15, // Atomically-encoded logical or visual repha.
+  Ra: 1 << 16,
+  CM: 1 << 17,    // Consonant-Medial.
+  Symbol: 1 << 18 // Avagraha, etc that take marks (SM,A,VD).
+};
+
+// Visual positions in a syllable from left to right.
+export const POSITIONS = {
+  Start: 1 << 0,
+
+  Ra_To_Become_Reph: 1 << 1,
+  Pre_M: 1 << 2,
+  Pre_C: 1 << 3,
+
+  Base_C: 1 << 4,
+  After_Main: 1 << 5,
+
+  Above_C: 1 << 6,
+
+  Before_Sub: 1 << 7,
+  Below_C: 1 << 8,
+  After_Sub: 1 << 9,
+
+  Before_Post: 1 << 10,
+  Post_C: 1 << 11,
+  After_Post: 1 << 12,
+
+  Final_C: 1 << 13,
+  SMVD: 1 << 14,
+
+  End: 1 << 15
+};
+
+export const CONSONANT_FLAGS = CATEGORIES.C | CATEGORIES.Ra | CATEGORIES.CM | CATEGORIES.V | CATEGORIES.Placeholder | CATEGORIES.Dotted_Circle;
+export const JOINER_FLAGS = CATEGORIES.ZWJ | CATEGORIES.ZWNJ;
+export const HALANT_OR_COENG_FLAGS = CATEGORIES.H | CATEGORIES.Coeng;
+
+export const INDIC_CONFIGS = {
+  Default: {
+    hasOldSpec: false,
+    virama: 0,
+    basePos: 'Last',
+    rephPos: POSITIONS.Before_Post,
+    rephMode: 'Implicit',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  Devanagari: {
+    hasOldSpec: true,
+    virama: 0x094D,
+    basePos: 'Last',
+    rephPos: POSITIONS.Before_Post,
+    rephMode: 'Implicit',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  Bengali: {
+    hasOldSpec: true,
+    virama: 0x09CD,
+    basePos: 'Last',
+    rephPos: POSITIONS.After_Sub,
+    rephMode: 'Implicit',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  Gurmukhi: {
+    hasOldSpec: true,
+    virama: 0x0A4D,
+    basePos: 'Last',
+    rephPos: POSITIONS.Before_Sub,
+    rephMode: 'Implicit',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  Gujarati: {
+    hasOldSpec: true,
+    virama: 0x0ACD,
+    basePos: 'Last',
+    rephPos: POSITIONS.Before_Post,
+    rephMode: 'Implicit',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  Oriya: {
+    hasOldSpec: true,
+    virama: 0x0B4D,
+    basePos: 'Last',
+    rephPos: POSITIONS.After_Main,
+    rephMode: 'Implicit',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  Tamil: {
+    hasOldSpec: true,
+    virama: 0x0BCD,
+    basePos: 'Last',
+    rephPos: POSITIONS.After_Post,
+    rephMode: 'Implicit',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  Telugu: {
+    hasOldSpec: true,
+    virama: 0x0C4D,
+    basePos: 'Last',
+    rephPos: POSITIONS.After_Post,
+    rephMode: 'Explicit',
+    blwfMode: 'Post_Only'
+  },
+
+  Kannada: {
+    hasOldSpec: true,
+    virama: 0x0CCD,
+    basePos: 'Last',
+    rephPos: POSITIONS.After_Post,
+    rephMode: 'Implicit',
+    blwfMode: 'Post_Only'
+  },
+
+  Malayalam: {
+    hasOldSpec: true,
+    virama: 0x0D4D,
+    basePos: 'Last',
+    rephPos: POSITIONS.After_Main,
+    rephMode: 'Log_Repha',
+    blwfMode: 'Pre_And_Post'
+  },
+
+  // Handled by UniversalShaper
+  // Sinhala: {
+  //   hasOldSpec: false,
+  //   virama: 0x0DCA,
+  //   basePos: 'Last_Sinhala',
+  //   rephPos: POSITIONS.After_Main,
+  //   rephMode: 'Explicit',
+  //   blwfMode: 'Pre_And_Post'
+  // },
+
+  Khmer: {
+    hasOldSpec: false,
+    virama: 0x17D2,
+    basePos: 'First',
+    rephPos: POSITIONS.Ra_To_Become_Reph,
+    rephMode: 'Vis_Repha',
+    blwfMode: 'Pre_And_Post'
+  }
+};
+
+// Additional decompositions that aren't in Unicode
+export const INDIC_DECOMPOSITIONS = {
+  // Khmer
+  0x17BE: [0x17C1, 0x17BE],
+  0x17BF: [0x17C1, 0x17BF],
+  0x17C0: [0x17C1, 0x17C0],
+  0x17C4: [0x17C1, 0x17C4],
+  0x17C5: [0x17C1, 0x17C5]
+};