@songtonyli/dsh-cli 0.1.12 → 0.1.14

package/node_modules/fontkit/src/opentype/shapers/UniversalShaper.js

@@ -0,0 +1,185 @@
+import DefaultShaper from './DefaultShaper';
+import StateMachine from 'dfa';
+import UnicodeTrie from 'unicode-trie';
+import GlyphInfo from '../GlyphInfo';
+import useData from './use.json';
+import { decodeBase64 } from '../../utils';
+
+const {categories, decompositions} = useData;
+const trie = new UnicodeTrie(decodeBase64(require('fs').readFileSync(__dirname + '/use.trie', 'base64')));
+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, 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/node_modules/fontkit/src/opentype/shapers/gen-indic.js

@@ -0,0 +1,208 @@
+import codepoints from 'codepoints';
+import fs from 'fs';
+import UnicodeTrieBuilder from '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));

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

@@ -0,0 +1,287 @@
+import codepoints from 'codepoints';
+import fs from 'fs';
+import UnicodeTrieBuilder from '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));