@cantoo/fontkit 2.0.4

package/src/opentype/shapers/DefaultShaper.js

@@ -0,0 +1,116 @@
+import {isDigit, isMark} from '../../packages/unicode-properties/index.js';
+import GlyphInfo from '../GlyphInfo';
+
+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'];
+const DIRECTIONAL_FEATURES = {
+  ltr: ['ltra', 'ltrm'],
+  rtl: ['rtla', 'rtlm']
+};
+
+export default class DefaultShaper {
+  static zeroMarkWidths = 'AFTER_GPOS';
+  static plan(plan, glyphs, features) {
+    // Plan the features we want to apply
+    this.planPreprocessing(plan);
+    this.planFeatures(plan);
+    this.planPostprocessing(plan, features);
+
+    // Assign the global features to all the glyphs
+    plan.assignGlobalFeatures(glyphs);
+
+    // Assign local features to glyphs
+    this.assignFeatures(plan, glyphs);
+  }
+
+  static planPreprocessing(plan) {
+    plan.add({
+      global: [...VARIATION_FEATURES, ...DIRECTIONAL_FEATURES[plan.direction]],
+      local: FRACTIONAL_FEATURES
+    });
+  }
+
+  static planFeatures(_plan) {
+    // Do nothing by default. Let subclasses override this.
+  }
+
+  static planPostprocessing(plan, userFeatures) {
+    plan.add([...COMMON_FEATURES, ...HORIZONTAL_FEATURES]);
+    plan.setFeatureOverrides(userFeatures);
+  }
+
+  static assignFeatures(plan, glyphs) {
+    // Font-aware NFC before GSUB (HarfBuzz default-shaper behavior).
+    composeGlyphs(plan.font, glyphs);
+
+    // Enable contextual fractions
+    for (let i = 0; i < glyphs.length; i++) {
+      let glyph = glyphs[i];
+      if (glyph.codePoints[0] === 0x2044) { // fraction slash
+        let start = i;
+        let end = i + 1;
+
+        // Apply numerator
+        while (start > 0 && isDigit(glyphs[start - 1].codePoints[0])) {
+          glyphs[start - 1].features.numr = true;
+          glyphs[start - 1].features.frac = true;
+          start--;
+        }
+
+        // Apply denominator
+        while (end < glyphs.length && isDigit(glyphs[end].codePoints[0])) {
+          glyphs[end].features.dnom = true;
+          glyphs[end].features.frac = true;
+          end++;
+        }
+
+        // Apply fraction slash
+        glyph.features.frac = true;
+        i = end - 1;
+      }
+    }
+  }
+}
+
+// Compose base+mark clusters when the font has the precomposed glyph.
+// Skip pure mark reorders (same length) so Arabic calt etc. keep expected order.
+function composeGlyphs(font, glyphs) {
+  let singleMark = g => g.codePoints.length === 1 && isMark(g.codePoints[0]);
+
+  for (let i = 0; i < glyphs.length; ) {
+    let base = glyphs[i];
+    if (base.codePoints.length !== 1 || isMark(base.codePoints[0])) {
+      i++;
+      continue;
+    }
+
+    let end = i + 1;
+    while (end < glyphs.length && singleMark(glyphs[end])) end++;
+    if (end === i + 1) {
+      i++;
+      continue;
+    }
+
+    let input = glyphs.slice(i, end).map(g => g.codePoints[0]);
+    let composed = Array.from(String.fromCodePoint(...input).normalize('NFC')).flatMap(char => {
+      let cp = char.codePointAt(0);
+      return font.hasGlyphForCodePoint(cp)
+        ? [cp]
+        : Array.from(char.normalize('NFD'), c => c.codePointAt(0));
+    });
+
+    if (composed.length === input.length) {
+      i = end;
+      continue;
+    }
+
+    let replacement = composed.map(
+      cp => new GlyphInfo(font, font.glyphForCodePoint(cp).id, [cp], base.features)
+    );
+    glyphs.splice(i, end - i, ...replacement);
+    i += replacement.length;
+  }
+}

package/src/opentype/shapers/HangulShaper.js

@@ -0,0 +1,285 @@
+import DefaultShaper from './DefaultShaper';
+import GlyphInfo from '../GlyphInfo';
+
+/**
+ * This is a shaper for the Hangul script, used by the Korean language.
+ * It does the following:
+ *   - decompose if unsupported by the font:
+ *     <LV>   -> <L,V>
+ *     <LVT>  -> <L,V,T>
+ *     <LV,T> -> <L,V,T>
+ *
+ *   - compose if supported by the font:
+ *     <L,V>   -> <LV>
+ *     <L,V,T> -> <LVT>
+ *     <LV,T>  -> <LVT>
+ *
+ *   - reorder tone marks (S is any valid syllable):
+ *     <S, M> -> <M, S>
+ *
+ *   - apply ljmo, vjmo, and tjmo OpenType features to decomposed Jamo sequences.
+ *
+ * This logic is based on the following documents:
+ *   - http://www.microsoft.com/typography/OpenTypeDev/hangul/intro.htm
+ *   - http://ktug.org/~nomos/harfbuzz-hangul/hangulshaper.pdf
+ */
+export default class HangulShaper extends DefaultShaper {
+  static zeroMarkWidths = 'NONE';
+  static planFeatures(plan) {
+    plan.add(['ljmo', 'vjmo', 'tjmo'], false);
+  }
+
+  static assignFeatures(plan, glyphs) {
+    let state = 0;
+    let i = 0;
+    while (i < glyphs.length) {
+      let action;
+      let glyph = glyphs[i];
+      let code = glyph.codePoints[0];
+      let type = getType(code);
+
+      [ action, state ] = STATE_TABLE[state][type];
+
+      switch (action) {
+        case DECOMPOSE:
+          // Decompose the composed syllable if it is not supported by the font.
+          if (!plan.font.hasGlyphForCodePoint(code)) {
+            i = decompose(glyphs, i, plan.font);
+          }
+          break;
+
+        case COMPOSE:
+          // Found a decomposed syllable. Try to compose if supported by the font.
+          i = compose(glyphs, i, plan.font);
+          break;
+
+        case TONE_MARK:
+          // Got a valid syllable, followed by a tone mark. Move the tone mark to the beginning of the syllable.
+          reorderToneMark(glyphs, i, plan.font);
+          break;
+
+        case INVALID:
+          // Tone mark has no valid syllable to attach to, so insert a dotted circle
+          i = insertDottedCircle(glyphs, i, plan.font);
+          break;
+      }
+
+      i++;
+    }
+  }
+}
+
+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_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 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;
+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;
+const isCombiningL = code => L_BASE <= code && code <= L_END;
+const isCombiningV = code => V_BASE <= code && code <= V_END;
+const isCombiningT = code => T_BASE + 1 && 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 LVT = 5; // Composed <LVT> syllable
+const M   = 6; // Tone mark
+
+// This function classifies a character using the above categories.
+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 (isTone(code)) { return M; }
+  return X;
+}
+
+// State machine actions
+const NO_ACTION = 0;
+const DECOMPOSE = 1;
+const COMPOSE   = 2;
+const TONE_MARK = 4;
+const INVALID   = 5;
+
+// 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.
+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  ] ],
+
+  // State 1: <L>
+  [ [ 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 ] ],
+
+  // 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 ] ]
+];
+
+function getGlyph(font, code, features) {
+  return new GlyphInfo(font, font.glyphForCodePoint(code).id, [code], features);
+}
+
+function decompose(glyphs, i, font) {
+  let glyph = glyphs[i];
+  let code = glyph.codePoints[0];
+
+  let s = code - HANGUL_BASE;
+  let t = T_BASE + s % T_COUNT;
+  s = s / T_COUNT | 0;
+  let l = L_BASE + s / V_COUNT | 0;
+  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))) {
+    return i;
+  }
+
+  // Replace the current glyph with decomposed L, V, and T glyphs,
+  // and apply the proper OpenType features to each component.
+  let ljmo = getGlyph(font, l, glyph.features);
+  ljmo.features.ljmo = true;
+
+  let vjmo = getGlyph(font, v, glyph.features);
+  vjmo.features.vjmo = true;
+
+  let insert = [ ljmo, vjmo ];
+
+  if (t > T_BASE) {
+    let tjmo = getGlyph(font, t, glyph.features);
+    tjmo.features.tjmo = true;
+    insert.push(tjmo);
+  }
+
+  glyphs.splice(i, 1, ...insert);
+  return i + insert.length - 1;
+}
+
+function compose(glyphs, i, font) {
+  let glyph = glyphs[i];
+  let code = glyphs[i].codePoints[0];
+  let type = getType(code);
+
+  let prev = glyphs[i - 1].codePoints[0];
+  let prevType = getType(prev);
+
+  // Figure out what type of syllable we're dealing with
+  let lv, ljmo, vjmo, tjmo;
+  if (prevType === LV && type === T) {
+    // <LV,T>
+    lv = prev;
+    tjmo = glyph;
+  } else {
+    if (type === V) {
+      // <L,V>
+      ljmo = glyphs[i - 1];
+      vjmo = glyph;
+    } else {
+      // <L,V,T>
+      ljmo = glyphs[i - 2];
+      vjmo = glyphs[i - 1];
+      tjmo = glyph;
+    }
+
+    let l = ljmo.codePoints[0];
+    let v = vjmo.codePoints[0];
+
+    // Make sure L and V are combining characters
+    if (isCombiningL(l) && isCombiningV(v)) {
+      lv = HANGUL_BASE + ((l - L_BASE) * V_COUNT + (v - V_BASE)) * T_COUNT;
+    }
+  }
+
+  let t = (tjmo && tjmo.codePoints[0]) || T_BASE;
+  if ((lv != null) && (t === T_BASE || isCombiningT(t))) {
+    let s = lv + (t - T_BASE);
+
+    // Replace with a composed glyph if supported by the font,
+    // otherwise apply the proper OpenType features to each component.
+    if (font.hasGlyphForCodePoint(s)) {
+      let del = prevType === V ? 3 : 2;
+      glyphs.splice(i - del + 1, del, getGlyph(font, s, glyph.features));
+      return i - del + 1;
+    }
+  }
+
+  // Didn't compose (either a non-combining component or unsupported by font).
+  if (ljmo) { ljmo.features.ljmo = true; }
+  if (vjmo) { vjmo.features.vjmo = true; }
+  if (tjmo) { tjmo.features.tjmo = true; }
+
+  if (prevType === LV) {
+    // Sequence was originally <L,V>, which got combined earlier.
+    // Either the T was non-combining, or the LVT glyph wasn't supported.
+    // Decompose the glyph again and apply OT features.
+    decompose(glyphs, i - 1, font);
+    return i + 1;
+  }
+
+  return i;
+}
+
+function getLength(code) {
+  switch (getType(code)) {
+    case LV:
+    case LVT:
+      return 1;
+    case V:
+      return 2;
+    case T:
+      return 3;
+  }
+}
+
+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 prev = glyphs[i - 1].codePoints[0];
+  let len = getLength(prev);
+
+  glyphs.splice(i, 1);
+  return glyphs.splice(i - len, 0, glyph);
+}
+
+function insertDottedCircle(glyphs, i, font) {
+  let glyph = glyphs[i];
+  let code = glyphs[i].codePoints[0];
+
+  if (font.hasGlyphForCodePoint(DOTTED_CIRCLE)) {
+    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;
+    glyphs.splice(idx, 0, dottedCircle);
+    i++;
+  }
+
+  return i;
+}

package/src/opentype/shapers/HebrewShaper.js

@@ -0,0 +1,105 @@
+import {getCombiningClass} from '../../packages/unicode-properties/index.js';
+import DefaultShaper from './DefaultShaper';
+import GlyphInfo from '../GlyphInfo';
+
+/**
+ * Hebrew shaper (HarfBuzz hb-ot-shaper-hebrew.cc):
+ *   - Compose presentation forms (FBxx) when the font lacks GPOS mark for `hebr`
+ *   - Reorder patah/qamats + sheva/hiriq + meteg/below so meteg sits next to the base
+ */
+export default class HebrewShaper extends DefaultShaper {
+  static assignFeatures(plan, glyphs) {
+    super.assignFeatures(plan, glyphs);
+
+    if (!hasGposMark(plan.font)) {
+      composeHebrew(glyphs, plan.font);
+    }
+    reorderMarksHebrew(glyphs);
+  }
+}
+
+// Dagesh forms for U+05D0..U+05EA (0 = no precomposed form).
+const DAGESH_FORMS = [
+  0xFB30, 0xFB31, 0xFB32, 0xFB33, 0xFB34, 0xFB35, 0xFB36, 0,
+  0xFB38, 0xFB39, 0xFB3A, 0xFB3B, 0xFB3C, 0, 0xFB3E, 0,
+  0xFB40, 0xFB41, 0, 0xFB43, 0xFB44, 0, 0xFB46, 0xFB47,
+  0xFB48, 0xFB49, 0xFB4A
+];
+
+// Precomposed Hebrew presentation form for `a + b`, or null (HB compose_hebrew).
+function composeHebrewPair(a, b) {
+  switch (b) {
+    case 0x05B4: // HIRIQ
+      return a === 0x05D9 ? 0xFB1D : null;
+    case 0x05B7: // PATAH
+      return a === 0x05F2 ? 0xFB1F : a === 0x05D0 ? 0xFB2E : null;
+    case 0x05B8: // QAMATS
+      return a === 0x05D0 ? 0xFB2F : null;
+    case 0x05B9: // HOLAM
+      return a === 0x05D5 ? 0xFB4B : null;
+    case 0x05BC: // DAGESH
+      if (a >= 0x05D0 && a <= 0x05EA) return DAGESH_FORMS[a - 0x05D0] || null;
+      if (a === 0xFB2A) return 0xFB2C;
+      if (a === 0xFB2B) return 0xFB2D;
+      return null;
+    case 0x05BF: // RAFE
+      return a === 0x05D1 ? 0xFB4C : a === 0x05DB ? 0xFB4D : a === 0x05E4 ? 0xFB4E : null;
+    case 0x05C1: // SHIN DOT
+      return a === 0x05E9 ? 0xFB2A : a === 0xFB49 ? 0xFB2C : null;
+    case 0x05C2: // SIN DOT
+      return a === 0x05E9 ? 0xFB2B : a === 0xFB49 ? 0xFB2D : null;
+    default:
+      return null;
+  }
+}
+
+// Greedily compose adjacent pairs when the font has the glyph
+// (e.g. SHIN + SHIN_DOT → FB2A, then + DAGESH → FB2C).
+function composeHebrew(glyphs, font) {
+  for (let i = 0; i + 1 < glyphs.length; ) {
+    let composed = glyphs[i].codePoints[0];
+    let consumed = 1;
+    while (i + consumed < glyphs.length) {
+      let ab = composeHebrewPair(composed, glyphs[i + consumed].codePoints[0]);
+      if (ab == null || !font.hasGlyphForCodePoint(ab)) break;
+      composed = ab;
+      consumed++;
+    }
+    if (consumed > 1) {
+      let cps = [];
+      for (let j = 0; j < consumed; j++) cps.push(...glyphs[i + j].codePoints);
+      glyphs[i] = new GlyphInfo(font, font.glyphForCodePoint(composed).id, cps, glyphs[i].features);
+      glyphs.splice(i + 1, consumed - 1);
+    }
+    i++;
+  }
+}
+
+// HB reorder_marks_hebrew: [patah/qamats, sheva/hiriq, meteg/below] → swap last two.
+// unicode-properties already exposes Hebrew modified CCCs (CCC10/14/17/18/22).
+function reorderMarksHebrew(glyphs) {
+  for (let i = 2; i < glyphs.length; i++) {
+    let c0 = getCombiningClass(glyphs[i - 2].codePoints[0]);
+    let c1 = getCombiningClass(glyphs[i - 1].codePoints[0]);
+    let c2 = getCombiningClass(glyphs[i].codePoints[0]);
+    if (
+      (c0 === 'CCC17' || c0 === 'CCC18') &&
+      (c1 === 'CCC10' || c1 === 'CCC14') &&
+      (c2 === 'CCC22' || c2 === 'Below')
+    ) {
+      [glyphs[i - 1], glyphs[i]] = [glyphs[i], glyphs[i - 1]];
+      break;
+    }
+  }
+}
+
+// Gate fallback composition on Hebrew-script GPOS `mark` (not the global featureList).
+function hasGposMark(font) {
+  let hebr = font.GPOS?.scriptList?.find(e => e.tag === 'hebr')?.script;
+  if (!hebr) return false;
+
+  let langs = [hebr.defaultLangSys, ...(hebr.langSysRecords || []).map(l => l.langSys)].filter(Boolean);
+  return langs.some(ls =>
+    (ls.featureIndexes || []).some(i => font.GPOS.featureList[i]?.tag === 'mark')
+  );
+}