@cantoo/fontkit 2.0.4

package/src/opentype/OTProcessor.js

@@ -0,0 +1,472 @@
+import GlyphIterator from './GlyphIterator';
+import * as Script from '../layout/Script';
+
+const DEFAULT_SCRIPTS = ['DFLT', 'dflt', 'latn'];
+
+export default class OTProcessor {
+  constructor(font, table) {
+    this.font = font;
+    this.table = table;
+
+    this.script = null;
+    this.scriptTag = null;
+
+    this.language = null;
+    this.languageTag = null;
+
+    this.features = {};
+    this.lookups = {};
+
+    // FeatureVariations apply at the current location; default to normalized
+    // origin when no variation is set (HarfBuzz behavior). Without this,
+    // variable fonts skip FeatureVariations until getVariation() is called.
+    let coords = font._variationProcessor?.normalizedCoords
+      ?? (font.fvar ? new Array(font.fvar.axis.length).fill(0) : null);
+    this.variationsIndex = coords ? this.findVariationsIndex(coords) : -1;
+
+    // initialize to default script + language
+    this.selectScript();
+
+    // current context (set by applyFeatures)
+    this.glyphs = [];
+    this.positions = []; // only used by GPOS
+    this.ligatureID = 1;
+    this.currentFeature = null;
+  }
+
+  findScript(script) {
+    if (this.table.scriptList == null) {
+      return null;
+    }
+
+    if (!Array.isArray(script)) {
+      script = [script];
+    }
+
+    for (let s of script) {
+      for (let entry of this.table.scriptList) {
+        if (entry.tag === s) {
+          return entry;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  selectScript(script, language, direction) {
+    let changed = false;
+    let entry;
+    if (!this.script || script !== this.scriptTag) {
+      entry = this.findScript(script);
+      if (!entry) {
+        entry = this.findScript(DEFAULT_SCRIPTS);
+      }
+
+      if (!entry) {
+        return this.scriptTag;
+      }
+
+      this.scriptTag = entry.tag;
+      this.script = entry.script;
+      this.language = null;
+      this.languageTag = null;
+      changed = true;
+    }
+
+    if (!direction || direction !== this.direction) {
+      this.direction = direction || Script.direction(script);
+    }
+
+    if (language && language.length < 4) {
+      language += ' '.repeat(4 - language.length);
+    }
+
+    if (!language || language !== this.languageTag) {
+      this.language = null;
+
+      for (let lang of this.script.langSysRecords) {
+        if (lang.tag === language) {
+          this.language = lang.langSys;
+          this.languageTag = lang.tag;
+          break;
+        }
+      }
+
+      if (!this.language) {
+        this.language = this.script.defaultLangSys;
+        this.languageTag = null;
+      }
+
+      changed = true;
+    }
+
+    // Build a feature lookup table
+    if (changed) {
+      this.features = {};
+      if (this.language) {
+        for (let featureIndex of this.language.featureIndexes) {
+          let record = this.table.featureList[featureIndex];
+          let substituteFeature = this.substituteFeatureForVariations(featureIndex);
+          this.features[record.tag] = substituteFeature || record.feature;
+        }
+      }
+    }
+
+    return this.scriptTag;
+  }
+
+  lookupsForFeatures(userFeatures = [], exclude) {
+    let lookups = [];
+    for (let tag of userFeatures) {
+      let feature = this.features[tag];
+      if (!feature) {
+        continue;
+      }
+
+      for (let lookupIndex of feature.lookupListIndexes) {
+        if (exclude && exclude.indexOf(lookupIndex) !== -1) {
+          continue;
+        }
+
+        lookups.push({
+          feature: tag,
+          index: lookupIndex,
+          lookup: this.table.lookupList.get(lookupIndex)
+        });
+      }
+    }
+
+    lookups.sort((a, b) => a.index - b.index);
+    return lookups;
+  }
+
+  substituteFeatureForVariations(featureIndex) {
+    if (this.variationsIndex === -1) {
+      return null;
+    }
+
+    let record = this.table.featureVariations.featureVariationRecords[this.variationsIndex];
+    let substitutions = record.featureTableSubstitution.substitutions;
+    for (let substitution of substitutions) {
+      if (substitution.featureIndex === featureIndex) {
+        return substitution.alternateFeatureTable;
+      }
+    }
+
+    return null;
+  }
+
+  findVariationsIndex(coords) {
+    let variations = this.table.featureVariations;
+    if (!variations) {
+      return -1;
+    }
+
+    let records = variations.featureVariationRecords;
+    for (let i = 0; i < records.length; i++) {
+      let conditions = records[i].conditionSet.conditionTable;
+      if (this.variationConditionsMatch(conditions, coords)) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  variationConditionsMatch(conditions, coords) {
+    return conditions.every(condition => {
+      let coord = condition.axisIndex < coords.length ? coords[condition.axisIndex] : 0;
+      return condition.filterRangeMinValue <= coord && coord <= condition.filterRangeMaxValue;
+    });
+  }
+
+  applyFeatures(userFeatures, glyphs, advances) {
+    let lookups = this.lookupsForFeatures(userFeatures);
+    this.applyLookups(lookups, glyphs, advances);
+  }
+
+  applyLookups(lookups, glyphs, positions) {
+    this.glyphs = glyphs;
+    this.positions = positions;
+    this.glyphIterator = new GlyphIterator(glyphs);
+
+    for (let { feature, lookup } of lookups) {
+      this.currentFeature = feature;
+
+      // Direction may be RTL for some lookups (see lookupDirection).
+      let direction = this.lookupDirection(lookup);
+      this.glyphIterator.reset(
+        lookup.flags,
+        direction < 0 ? glyphs.length - 1 : 0,
+        this.getMarkFilteringSet(lookup)
+      );
+
+      while (this.glyphIterator.index >= 0 && this.glyphIterator.index < glyphs.length) {
+        if (feature in this.glyphIterator.cur.features) {
+          for (let table of lookup.subTables) {
+            if (this.applyLookup(lookup.lookupType, table)) {
+              break;
+            }
+          }
+        }
+        this.glyphIterator.move(direction);
+      }
+    }
+  }
+
+  // Subclasses may reverse iteration for specific lookup types (e.g. GSUB Type 8).
+  lookupDirection(_lookup) {
+    return 1;
+  }
+
+  applyLookup(_lookup, _table) {
+    throw new Error("applyLookup must be implemented by subclasses");
+  }
+
+  applyLookupList(lookupRecords) {
+    let options = this.glyphIterator.options;
+    let markFilteringSet = this.glyphIterator.markFilteringSet;
+    let glyphIndex = this.glyphIterator.index;
+
+    for (let lookupRecord of lookupRecords) {
+      // Reset flags and find glyph index for this lookup record
+      this.glyphIterator.reset(options, glyphIndex, markFilteringSet);
+      this.glyphIterator.increment(lookupRecord.sequenceIndex);
+
+      // Get the lookup and setup flags for subtables
+      let lookup = this.table.lookupList.get(lookupRecord.lookupListIndex);
+      this.glyphIterator.reset(lookup.flags, this.glyphIterator.index, this.getMarkFilteringSet(lookup));
+
+      // Apply lookup subtables until one matches
+      for (let table of lookup.subTables) {
+        if (this.applyLookup(lookup.lookupType, table)) {
+          break;
+        }
+      }
+    }
+
+    this.glyphIterator.reset(options, glyphIndex, markFilteringSet);
+    return true;
+  }
+
+  getMarkFilteringSet(lookup) {
+    if (!lookup.flags.flags.useMarkFilteringSet) {
+      return null;
+    }
+
+    let coverage = this.font.GDEF?.markGlyphSetsDef?.coverage?.[lookup.markFilteringSet];
+    if (!coverage) {
+      return null;
+    }
+
+    // Cache a Set-like {has} that reuses coverageIndex (avoids expanding large ranges).
+    let cache = (this._markFilteringCache ??= new Map());
+    let filter = cache.get(coverage);
+    if (!filter) {
+      filter = { has: id => this.coverageIndex(coverage, id) >= 0 };
+      cache.set(coverage, filter);
+    }
+    return filter;
+  }
+
+  coverageIndex(coverage, glyph) {
+    if (glyph == null) {
+      glyph = this.glyphIterator.cur.id;
+    }
+
+    switch (coverage.version) {
+      case 1:
+        return coverage.glyphs.indexOf(glyph);
+
+      case 2:
+        for (let range of coverage.rangeRecords) {
+          if (range.start <= glyph && glyph <= range.end) {
+            return range.startCoverageIndex + glyph - range.start;
+          }
+        }
+
+        break;
+    }
+
+    return -1;
+  }
+
+  match(sequenceIndex, sequence, fn, matched) {
+    let pos = this.glyphIterator.index;
+    let glyph = this.glyphIterator.increment(sequenceIndex);
+    let idx = 0;
+
+    while (idx < sequence.length && glyph && fn(sequence[idx], glyph)) {
+      if (matched) {
+        matched.push(this.glyphIterator.index);
+      }
+
+      idx++;
+      glyph = this.glyphIterator.next();
+    }
+
+    this.glyphIterator.index = pos;
+    if (idx < sequence.length) {
+      return false;
+    }
+
+    return matched || true;
+  }
+
+  sequenceMatches(sequenceIndex, sequence) {
+    return this.match(sequenceIndex, sequence, (component, glyph) => component === glyph.id);
+  }
+
+  sequenceMatchIndices(sequenceIndex, sequence) {
+    return this.match(sequenceIndex, sequence, (component, glyph) => {
+      // If the current feature doesn't apply to this glyph,
+      if (!(this.currentFeature in glyph.features)) {
+        return false;
+      }
+
+      return component === glyph.id;
+    }, []);
+  }
+
+  coverageSequenceMatches(sequenceIndex, sequence) {
+    return this.match(sequenceIndex, sequence, (coverage, glyph) =>
+      this.coverageIndex(coverage, glyph.id) >= 0
+    );
+  }
+
+  getClassID(glyph, classDef) {
+    switch (classDef.version) {
+      case 1: { // Class array
+        let i = glyph - classDef.startGlyph;
+        if (i >= 0 && i < classDef.classValueArray.length) {
+          return classDef.classValueArray[i];
+        }
+
+        break;
+      }
+
+      case 2:
+        for (let range of classDef.classRangeRecord) {
+          if (range.start <= glyph && glyph <= range.end) {
+            return range.class;
+          }
+        }
+
+        break;
+    }
+
+    return 0;
+  }
+
+  classSequenceMatches(sequenceIndex, sequence, classDef) {
+    return this.match(sequenceIndex, sequence, (classID, glyph) =>
+      classID === this.getClassID(glyph.id, classDef)
+    );
+  }
+
+  applyContext(table) {
+    let index, set;
+    switch (table.version) {
+      case 1:
+        index = this.coverageIndex(table.coverage);
+        if (index === -1) {
+          return false;
+        }
+
+        set = table.ruleSets[index];
+        for (let rule of set) {
+          if (this.sequenceMatches(1, rule.input)) {
+            return this.applyLookupList(rule.lookupRecords);
+          }
+        }
+
+        break;
+
+      case 2:
+        if (this.coverageIndex(table.coverage) === -1) {
+          return false;
+        }
+
+        index = this.getClassID(this.glyphIterator.cur.id, table.classDef);
+        if (index === -1) {
+          return false;
+        }
+
+        set = table.classSet[index];
+        for (let rule of set) {
+          if (this.classSequenceMatches(1, rule.classes, table.classDef)) {
+            return this.applyLookupList(rule.lookupRecords);
+          }
+        }
+
+        break;
+
+      case 3:
+        if (this.coverageSequenceMatches(0, table.coverages)) {
+          return this.applyLookupList(table.lookupRecords);
+        }
+
+        break;
+    }
+
+    return false;
+  }
+
+  applyChainingContext(table) {
+    let index;
+    switch (table.version) {
+      case 1: {
+        index = this.coverageIndex(table.coverage);
+        if (index === -1) {
+          return false;
+        }
+
+        let set = table.chainRuleSets[index];
+        for (let rule of set) {
+          // Backtrack is stored closest-first; sequenceMatches walks furthest-first.
+          if (this.sequenceMatches(-rule.backtrack.length, [...rule.backtrack].reverse())
+            && this.sequenceMatches(1, rule.input)
+            && this.sequenceMatches(1 + rule.input.length, rule.lookahead)) {
+            return this.applyLookupList(rule.lookupRecords);
+          }
+        }
+
+        break;
+      }
+
+      case 2: {
+        if (this.coverageIndex(table.coverage) === -1) {
+          return false;
+        }
+
+        index = this.getClassID(this.glyphIterator.cur.id, table.inputClassDef);
+        let rules = table.chainClassSet[index];
+        if (!rules) {
+          return false;
+        }
+
+        for (let rule of rules) {
+          if (this.classSequenceMatches(-rule.backtrack.length, [...rule.backtrack].reverse(), table.backtrackClassDef) &&
+            this.classSequenceMatches(1, rule.input, table.inputClassDef) &&
+            this.classSequenceMatches(1 + rule.input.length, rule.lookahead, table.lookaheadClassDef)) {
+            return this.applyLookupList(rule.lookupRecords);
+          }
+        }
+
+        break;
+      }
+
+      case 3:
+        if (this.coverageSequenceMatches(-table.backtrackGlyphCount, [...table.backtrackCoverage].reverse()) &&
+          this.coverageSequenceMatches(0, table.inputCoverage) &&
+          this.coverageSequenceMatches(table.inputGlyphCount, table.lookaheadCoverage)) {
+          return this.applyLookupList(table.lookupRecords);
+        }
+
+        break;
+    }
+
+    return false;
+  }
+}

package/src/opentype/ShapingPlan.js

@@ -0,0 +1,121 @@
+/**
+ * ShapingPlans are used by the OpenType shapers to store which
+ * features should by applied, and in what order to apply them.
+ * The features are applied in groups called stages. A feature
+ * can be applied globally to all glyphs, or locally to only
+ * specific glyphs.
+ *
+ * @private
+ */
+export default class ShapingPlan {
+  constructor(font, script, direction) {
+    this.font = font;
+    this.script = script;
+    this.direction = direction;
+    this.stages = [];
+    this.globalFeatures = {};
+    this.allFeatures = {};
+    this.userFeatures = null; // original user feature values (for Type 3 alternate index)
+  }
+
+  /**
+   * Adds the given features to the last stage.
+   * Already-planned tags are not duplicated, but a global add still promotes them.
+   */
+  _addFeatures(features, global) {
+    let stageIndex = this.stages.length - 1;
+    let stage = this.stages[stageIndex];
+    for (let feature of features) {
+      if (this.allFeatures[feature] == null) {
+        stage.push(feature);
+        this.allFeatures[feature] = stageIndex;
+      }
+
+      if (global) {
+        this.globalFeatures[feature] = true;
+      }
+    }
+  }
+
+  /**
+   * Add features to the last stage
+   */
+  add(arg, global = true) {
+    if (this.stages.length === 0) {
+      this.stages.push([]);
+    }
+
+    if (typeof arg === 'string') {
+      arg = [arg];
+    }
+
+    if (Array.isArray(arg)) {
+      this._addFeatures(arg, global);
+    } else if (typeof arg === 'object') {
+      this._addFeatures(arg.global || [], true);
+      this._addFeatures(arg.local || [], false);
+    } else {
+      throw new Error("Unsupported argument to ShapingPlan#add");
+    }
+  }
+
+  /**
+   * Add a new stage
+   */
+  addStage(arg, global) {
+    if (typeof arg === 'function') {
+      this.stages.push(arg, []);
+    } else {
+      this.stages.push([]);
+      this.add(arg, global);
+    }
+  }
+
+  setFeatureOverrides(features) {
+    if (Array.isArray(features)) {
+      this.add(features);
+    } else if (typeof features === 'object') {
+      this.userFeatures = features;
+      for (let tag in features) {
+        if (features[tag]) {
+          this.add(tag);
+        } else if (this.allFeatures[tag] != null) {
+          let stage = this.stages[this.allFeatures[tag]];
+          stage.splice(stage.indexOf(tag), 1);
+          delete this.allFeatures[tag];
+          delete this.globalFeatures[tag];
+        }
+      }
+    }
+  }
+
+  /**
+   * Assigns the global features to the given glyphs
+   */
+  assignGlobalFeatures(glyphs) {
+    for (let glyph of glyphs) {
+      for (let feature in this.globalFeatures) {
+        glyph.features[feature] = true;
+      }
+    }
+  }
+
+  /**
+   * Executes the planned stages using the given OTProcessor
+   */
+  process(processor, glyphs, positions) {
+    // Preserve original user values (e.g. { aalt: 2 }) for GSUB Type 3.
+    processor.userFeatures = this.userFeatures;
+
+    for (let stage of this.stages) {
+      if (typeof stage === 'function') {
+        if (!positions) {
+          stage(this.font, glyphs, this);
+        }
+
+      } else if (stage.length > 0) {
+        processor.applyFeatures(stage, glyphs, positions);
+      }
+    }
+  }
+}

package/src/opentype/shapers/ArabicShaper.js

@@ -0,0 +1,124 @@
+import DefaultShaper from './DefaultShaper';
+import {getCategory} from '../../packages/unicode-properties/index.js';
+import UnicodeTrie from '../../packages/unicode-trie/index.js';
+import { decodeBase64 } from '../../utils';
+import dataTrie from './data.trie';
+
+const trie = new UnicodeTrie(decodeBase64(dataTrie));
+const FEATURES = ['isol', 'fina', 'fin2', 'fin3', 'medi', 'med2', 'init'];
+
+const ShapingClasses = {
+  Non_Joining: 0,
+  Left_Joining: 1,
+  Right_Joining: 2,
+  Dual_Joining: 3,
+  Join_Causing: 3,
+  ALAPH: 4,
+  'DALATH RISH': 5,
+  Transparent: 6
+};
+
+const ISOL = 'isol';
+const FINA = 'fina';
+const FIN2 = 'fin2';
+const FIN3 = 'fin3';
+const MEDI = 'medi';
+const MED2 = 'med2';
+const INIT = 'init';
+const NONE = null;
+
+// Each entry is [prevAction, curAction, nextState]
+const STATE_TABLE = [
+  //   Non_Joining,        Left_Joining,       Right_Joining,     Dual_Joining,           ALAPH,            DALATH RISH
+  // State 0: prev was U,  not willing to join.
+  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 6 ] ],
+
+  // State 1: prev was R or ISOL/ALAPH,  not willing to join.
+  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 2 ],  [ NONE, FIN2, 5 ],  [ NONE, ISOL, 6 ] ],
+
+  // State 2: prev was D/L in ISOL form,  willing to join.
+  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ INIT, FINA, 1 ],  [ INIT, FINA, 3 ],  [ INIT, FINA, 4 ],  [ INIT, FINA, 6 ] ],
+
+  // State 3: prev was D in FINA form,  willing to join.
+  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ MEDI, FINA, 1 ],  [ MEDI, FINA, 3 ],  [ MEDI, FINA, 4 ],  [ MEDI, FINA, 6 ] ],
+
+  // State 4: prev was FINA ALAPH,  not willing to join.
+  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ MED2, ISOL, 1 ],  [ MED2, ISOL, 2 ],  [ MED2, FIN2, 5 ],  [ MED2, ISOL, 6 ] ],
+
+  // State 5: prev was FIN2/FIN3 ALAPH,  not willing to join.
+  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ ISOL, ISOL, 1 ],  [ ISOL, ISOL, 2 ],  [ ISOL, FIN2, 5 ],  [ ISOL, ISOL, 6 ] ],
+
+  // State 6: prev was DALATH/RISH,  not willing to join.
+  [ [ NONE, NONE, 0 ],  [ NONE, ISOL, 2 ],  [ NONE, ISOL, 1 ],  [ NONE, ISOL, 2 ],  [ NONE, FIN3, 5 ],  [ NONE, ISOL, 6 ] ]
+];
+
+/**
+ * This is a shaper for Arabic, and other cursive scripts.
+ * It uses data from ArabicShaping.txt in the Unicode database,
+ * compiled to a UnicodeTrie by generate-data.coffee.
+ *
+ * The shaping state machine was ported from Harfbuzz.
+ * https://github.com/behdad/harfbuzz/blob/master/src/hb-ot-shape-complex-arabic.cc
+ */
+export default class ArabicShaper extends DefaultShaper {
+  static planFeatures(plan) {
+    plan.add(['ccmp', 'locl']);
+    for (let i = 0; i < FEATURES.length; i++) {
+      let feature = FEATURES[i];
+      plan.addStage(feature, false);
+    }
+
+    plan.addStage('mset');
+  }
+
+  static assignFeatures(plan, glyphs) {
+    super.assignFeatures(plan, glyphs);
+
+    let prev = -1;
+    let state = 0;
+    let actions = [];
+
+    // Apply the state machine to map glyphs to features
+    for (let i = 0; i < glyphs.length; i++) {
+      let curAction, prevAction;
+      let glyph = glyphs[i];
+      let type = getShapingClass(glyph.codePoints[0]);
+      if (type === ShapingClasses.Transparent) {
+        actions[i] = NONE;
+        continue;
+      }
+
+      [prevAction, curAction, state] = STATE_TABLE[state][type];
+
+      if (prevAction !== NONE && prev !== -1) {
+        actions[prev] = prevAction;
+      }
+
+      actions[i] = curAction;
+      prev = i;
+    }
+
+    // Apply the chosen features to their respective glyphs
+    for (let index = 0; index < glyphs.length; index++) {
+      let feature;
+      let glyph = glyphs[index];
+      if ((feature = actions[index])) {
+        glyph.features[feature] = true;
+      }
+    }
+  }
+}
+
+function getShapingClass(codePoint) {
+  let res = trie.get(codePoint);
+  if (res) {
+    return res - 1;
+  }
+
+  let category = getCategory(codePoint);
+  if (category === 'Mn' || category === 'Me' || category === 'Cf') {
+    return ShapingClasses.Transparent;
+  }
+
+  return ShapingClasses.Non_Joining;
+}