@cantoo/fontkit 2.0.4

package/src/opentype/GSUBProcessor.js

@@ -0,0 +1,208 @@
+import OTProcessor from './OTProcessor';
+import GlyphInfo from './GlyphInfo';
+
+export default class GSUBProcessor extends OTProcessor {
+  lookupDirection(lookup) {
+    let type = lookup.lookupType === 7 ? lookup.subTables[0]?.lookupType : lookup.lookupType;
+    return type === 8 ? -1 : 1;
+  }
+
+  applyLookup(lookupType, table) {
+    switch (lookupType) {
+      case 1: { // Single Substitution
+        let index = this.coverageIndex(table.coverage);
+        if (index === -1) {
+          return false;
+        }
+
+        let glyph = this.glyphIterator.cur;
+        switch (table.version) {
+          case 1:
+            glyph.id = (glyph.id + table.deltaGlyphID) & 0xffff;
+            break;
+
+          case 2:
+            glyph.id = table.substitute.get(index);
+            break;
+        }
+
+        return true;
+      }
+
+      case 2: { // Multiple Substitution
+        let index = this.coverageIndex(table.coverage);
+        if (index !== -1) {
+          let sequence = table.sequences.get(index);
+
+          if (sequence.length === 0) {
+            // If the sequence length is zero, delete the glyph.
+            // The OpenType spec disallows this, but seems like Harfbuzz and Uniscribe allow it.
+            this.glyphs.splice(this.glyphIterator.index, 1);
+            return true;
+          }
+
+          this.glyphIterator.cur.id = sequence[0];
+          this.glyphIterator.cur.ligatureComponent = 0;
+
+          let features = this.glyphIterator.cur.features;
+          let curGlyph = this.glyphIterator.cur;
+          let replacement = sequence.slice(1).map((gid, i) => {
+            let glyph = new GlyphInfo(this.font, gid, undefined, features);
+            glyph.shaperInfo = curGlyph.shaperInfo;
+            glyph.isLigated = curGlyph.isLigated;
+            glyph.ligatureComponent = i + 1;
+            glyph.substituted = true;
+            glyph.isMultiplied = true;
+            return glyph;
+          });
+
+          this.glyphs.splice(this.glyphIterator.index + 1, 0, ...replacement);
+          return true;
+        }
+
+        return false;
+      }
+
+      case 3: { // Alternate Substitution
+        let index = this.coverageIndex(table.coverage);
+        if (index === -1) return false;
+
+        // 1-based index from user features (e.g. { aalt: 2 }); boolean / missing → first
+        let alternates = table.alternateSet.get(index);
+        let alt = this.userFeatures?.[this.currentFeature];
+        let i = Number.isInteger(alt) && alt > 0 ? alt - 1 : 0;
+        this.glyphIterator.cur.id = alternates[i < alternates.length ? i : 0];
+        return true;
+      }
+
+      case 4: { // Ligature Substitution
+        let index = this.coverageIndex(table.coverage);
+        if (index === -1) return false;
+
+        for (let ligature of table.ligatureSets.get(index)) {
+          let matched = this.sequenceMatchIndices(1, ligature.components);
+          if (!matched) continue;
+
+          let curGlyph = this.glyphIterator.cur;
+
+          // Concatenate all of the characters the new ligature will represent
+          let characters = curGlyph.codePoints.slice();
+          for (let index of matched) {
+            characters.push(...this.glyphs[index].codePoints);
+          }
+
+          // Create the replacement ligature glyph
+          let ligatureGlyph = new GlyphInfo(this.font, ligature.glyph, characters, curGlyph.features);
+          ligatureGlyph.shaperInfo = curGlyph.shaperInfo;
+          ligatureGlyph.isLigated = true;
+          ligatureGlyph.substituted = true;
+
+          // From Harfbuzz:
+          // - If it *is* a mark ligature, we don't allocate a new ligature id, and leave
+          //   the ligature to keep its old ligature id.  This will allow it to attach to
+          //   a base ligature in GPOS.  Eg. if the sequence is: LAM,LAM,SHADDA,FATHA,HEH,
+          //   and LAM,LAM,HEH for a ligature, they will leave SHADDA and FATHA with a
+          //   ligature id and component value of 2.  Then if SHADDA,FATHA form a ligature
+          //   later, we don't want them to lose their ligature id/component, otherwise
+          //   GPOS will fail to correctly position the mark ligature on top of the
+          //   LAM,LAM,HEH ligature. See https://bugzilla.gnome.org/show_bug.cgi?id=676343
+          //
+          // - If a ligature is formed of components that some of which are also ligatures
+          //   themselves, and those ligature components had marks attached to *their*
+          //   components, we have to attach the marks to the new ligature component
+          //   positions!  Now *that*'s tricky!  And these marks may be following the
+          //   last component of the whole sequence, so we should loop forward looking
+          //   for them and update them.
+          //
+          //   Eg. the sequence is LAM,LAM,SHADDA,FATHA,HEH, and the font first forms a
+          //   'calt' ligature of LAM,HEH, leaving the SHADDA and FATHA with a ligature
+          //   id and component == 1.  Now, during 'liga', the LAM and the LAM-HEH ligature
+          //   form a LAM-LAM-HEH ligature.  We need to reassign the SHADDA and FATHA to
+          //   the new ligature with a component value of 2.
+          //
+          //   This in fact happened to a font...  See https://bugzilla.gnome.org/show_bug.cgi?id=437633
+          let isMarkLigature = curGlyph.isMark;
+          for (let i = 0; i < matched.length && isMarkLigature; i++) {
+            isMarkLigature = this.glyphs[matched[i]].isMark;
+          }
+
+          ligatureGlyph.ligatureID = isMarkLigature ? null : this.ligatureID++;
+
+          let lastLigID = curGlyph.ligatureID;
+          let lastNumComps = curGlyph.codePoints.length;
+          let curComps = lastNumComps;
+          let idx = this.glyphIterator.index + 1;
+
+          // Set ligatureID and ligatureComponent on glyphs that were skipped in the matched sequence.
+          // This allows GPOS to attach marks to the correct ligature components.
+          for (let matchIndex of matched) {
+            // Don't assign new ligature components for mark ligatures (see above)
+            if (isMarkLigature) {
+              idx = matchIndex;
+            } else {
+              while (idx < matchIndex) {
+                let ligatureComponent = curComps - lastNumComps + Math.min(this.glyphs[idx].ligatureComponent || 1, lastNumComps);
+                this.glyphs[idx].ligatureID = ligatureGlyph.ligatureID;
+                this.glyphs[idx].ligatureComponent = ligatureComponent;
+                idx++;
+              }
+            }
+
+            lastLigID = this.glyphs[idx].ligatureID;
+            lastNumComps = this.glyphs[idx].codePoints.length;
+            curComps += lastNumComps;
+            idx++; // skip base glyph
+          }
+
+          // Adjust ligature components for any marks following
+          if (lastLigID && !isMarkLigature) {
+            for (let i = idx; i < this.glyphs.length; i++) {
+              if (this.glyphs[i].ligatureID === lastLigID) {
+                let ligatureComponent = curComps - lastNumComps + Math.min(this.glyphs[i].ligatureComponent || 1, lastNumComps);
+                this.glyphs[i].ligatureComponent = ligatureComponent;
+              } else {
+                break;
+              }
+            }
+          }
+
+          // Delete the matched glyphs, and replace the current glyph with the ligature glyph
+          for (let i = matched.length - 1; i >= 0; i--) {
+            this.glyphs.splice(matched[i], 1);
+          }
+
+          this.glyphs[this.glyphIterator.index] = ligatureGlyph;
+          return true;
+        }
+
+        return false;
+      }
+
+      case 5: // Contextual Substitution
+        return this.applyContext(table);
+
+      case 6: // Chaining Contextual Substitution
+        return this.applyChainingContext(table);
+
+      case 7: // Extension Substitution
+        return this.applyLookup(table.lookupType, table.extension);
+
+      case 8: { // Reverse Chaining Contextual Single Substitution
+        let index = this.coverageIndex(table.coverage);
+        if (index === -1) return false;
+
+        // Backtrack is stored closest-first; coverageSequenceMatches walks furthest-first.
+        if (!this.coverageSequenceMatches(-table.backtrackGlyphCount, [...table.backtrackCoverage].reverse())
+          || !this.coverageSequenceMatches(1, table.lookaheadCoverage)) {
+          return false;
+        }
+
+        this.glyphIterator.cur.id = table.substitute.get(index);
+        return true;
+      }
+
+      default:
+        throw new Error(`GSUB lookupType ${lookupType} is not supported`);
+    }
+  }
+}

package/src/opentype/GlyphInfo.js

@@ -0,0 +1,57 @@
+import {isMark} from '../packages/unicode-properties/index.js';
+import OTProcessor from './OTProcessor';
+
+export default class GlyphInfo {
+  constructor(font, id, codePoints = [], features) {
+    this._font = font;
+    this.codePoints = codePoints;
+    this.id = id;
+
+    this.features = {};
+    if (Array.isArray(features)) {
+      for (let i = 0; i < features.length; i++) {
+        let feature = features[i];
+        this.features[feature] = true;
+      }
+    } else if (typeof features === 'object') {
+      Object.assign(this.features, features);
+    }
+
+    this.ligatureID = null;
+    this.ligatureComponent = null;
+    this.isLigated = false;
+    this.cursiveAttachment = null;
+    this.markAttachment = null;
+    this.shaperInfo = null;
+    this.substituted = false;
+    this.isMultiplied = false;
+  }
+
+  get id() {
+    return this._id;
+  }
+
+  set id(id) {
+    this._id = id;
+    this.substituted = true;
+
+    let GDEF = this._font.GDEF;
+    if (GDEF && GDEF.glyphClassDef) {
+      // TODO: clean this up
+      let classID = OTProcessor.prototype.getClassID(id, GDEF.glyphClassDef);
+      this.isBase = classID === 1;
+      this.isLigature = classID === 2;
+      this.isMark = classID === 3;
+      this.markAttachmentType = GDEF.markAttachClassDef ? OTProcessor.prototype.getClassID(id, GDEF.markAttachClassDef) : 0;
+    } else {
+      this.isMark = this.codePoints.length > 0 && this.codePoints.every(isMark);
+      this.isBase = !this.isMark;
+      this.isLigature = this.codePoints.length > 1;
+      this.markAttachmentType = 0;
+    }
+  }
+
+  copy() {
+    return new GlyphInfo(this._font, this.id, this.codePoints, this.features);
+  }
+}

package/src/opentype/GlyphIterator.js

@@ -0,0 +1,82 @@
+export default class GlyphIterator {
+  constructor(glyphs, options) {
+    this.glyphs = glyphs;
+    this.reset(options);
+  }
+
+  reset(options = {}, index = 0, markFilteringSet = null) {
+    this.options = options;
+    this.flags = options.flags || {};
+    this.markAttachmentType = options.markAttachmentType || 0;
+    this.markFilteringSet = markFilteringSet;
+    this.index = index;
+  }
+
+  get cur() {
+    return this.glyphs[this.index] || null;
+  }
+
+  shouldIgnore(glyph) {
+    // Mark skip hierarchy (OT chapter 2): ignoreMarks > mark filtering set > markAttachmentType.
+    if (glyph.isMark) {
+      if (this.flags.ignoreMarks) {
+        return true;
+      }
+      if (this.flags.useMarkFilteringSet) {
+        return !this.markFilteringSet?.has(glyph.id);
+      }
+      if (this.markAttachmentType) {
+        return glyph.markAttachmentType !== this.markAttachmentType;
+      }
+    }
+
+    return (this.flags.ignoreBaseGlyphs && glyph.isBase) ||
+           (this.flags.ignoreLigatures && glyph.isLigature);
+  }
+
+  move(dir) {
+    this.index += dir;
+    while (0 <= this.index && this.index < this.glyphs.length && this.shouldIgnore(this.glyphs[this.index])) {
+      this.index += dir;
+    }
+
+    if (0 > this.index || this.index >= this.glyphs.length) {
+      return null;
+    }
+
+    return this.glyphs[this.index];
+  }
+
+  next() {
+    return this.move(+1);
+  }
+
+  prev() {
+    return this.move(-1);
+  }
+
+  peek(count = 1) {
+    let idx = this.index;
+    let res = this.increment(count);
+    this.index = idx;
+    return res;
+  }
+
+  peekIndex(count = 1) {
+    let idx = this.index;
+    this.increment(count);
+    let res = this.index;
+    this.index = idx;
+    return res;
+  }
+
+  increment(count = 1) {
+    let dir = count < 0 ? -1 : 1;
+    count = Math.abs(count);
+    while (count--) {
+      this.move(dir);
+    }
+
+    return this.glyphs[this.index];
+  }
+}

package/src/opentype/OTLayoutEngine.js

@@ -0,0 +1,117 @@
+import ShapingPlan from './ShapingPlan';
+import * as Shapers from './shapers';
+import GlyphInfo from './GlyphInfo';
+import GSUBProcessor from './GSUBProcessor';
+import GPOSProcessor from './GPOSProcessor';
+
+export default class OTLayoutEngine {
+  constructor(font) {
+    this.font = font;
+    this.glyphInfos = null;
+    this.plan = null;
+    this.GSUBProcessor = null;
+    this.GPOSProcessor = null;
+    this.fallbackPosition = true;
+
+    if (font.GSUB) {
+      this.GSUBProcessor = new GSUBProcessor(font, font.GSUB);
+    }
+
+    if (font.GPOS) {
+      this.GPOSProcessor = new GPOSProcessor(font, font.GPOS);
+    }
+  }
+
+  setup(glyphRun) {
+    // Map glyphs to GlyphInfo objects so data can be passed between
+    // GSUB and GPOS without mutating the real (shared) Glyph objects.
+    this.glyphInfos = glyphRun.glyphs.map(glyph => new GlyphInfo(this.font, glyph.id, [...glyph.codePoints]));
+
+    // Select an OpenType script for GSUB/GPOS features.
+    let script = null;
+    if (this.GPOSProcessor) {
+      script = this.GPOSProcessor.selectScript(glyphRun.script, glyphRun.language, glyphRun.direction);
+    }
+
+    if (this.GSUBProcessor) {
+      script = this.GSUBProcessor.selectScript(glyphRun.script, glyphRun.language, glyphRun.direction);
+    }
+
+    // Choose the complex shaper from the buffer Unicode script (HB model). The OT
+    // script may fall back to DFLT/latn even for Thai text; that must not select
+    // DefaultShaper or Thai SARA AM / PUA preprocessing is skipped.
+    this.shaper = Shapers.choose(glyphRun.script || script);
+    this.plan = new ShapingPlan(this.font, script || glyphRun.script, glyphRun.direction);
+    this.plan.bufferScript = glyphRun.script;
+    this.shaper.plan(this.plan, this.glyphInfos, glyphRun.features);
+
+    // Enabled features as true, then overlay user values (e.g. aalt: 2) without mutating input.
+    let features = {};
+    for (let key in this.plan.allFeatures) {
+      features[key] = true;
+    }
+    glyphRun.features = Object.assign(features, glyphRun.features);
+  }
+
+  substitute(glyphRun) {
+    if (this.GSUBProcessor) {
+      this.plan.process(this.GSUBProcessor, this.glyphInfos);
+
+      // Map glyph infos back to normal Glyph objects
+      glyphRun.glyphs = this.glyphInfos.map(glyphInfo => this.font.getGlyph(glyphInfo.id, glyphInfo.codePoints));
+    }
+  }
+
+  position(glyphRun) {
+    if (this.shaper.zeroMarkWidths === 'BEFORE_GPOS') {
+      this.zeroMarkAdvances(glyphRun.positions);
+    }
+
+    if (this.GPOSProcessor) {
+      this.plan.process(this.GPOSProcessor, this.glyphInfos, glyphRun.positions);
+    }
+
+    if (this.shaper.zeroMarkWidths === 'AFTER_GPOS') {
+      this.zeroMarkAdvances(glyphRun.positions);
+    }
+
+    // Reverse the glyphs and positions if the script is right-to-left
+    if (glyphRun.direction === 'rtl') {
+      glyphRun.glyphs.reverse();
+      glyphRun.positions.reverse();
+    }
+
+    return this.GPOSProcessor && this.GPOSProcessor.features;
+  }
+
+  zeroMarkAdvances(positions) {
+    for (let i = 0; i < this.glyphInfos.length; i++) {
+      if (this.glyphInfos[i].isMark) {
+        positions[i].xAdvance = 0;
+        positions[i].yAdvance = 0;
+      }
+    }
+  }
+
+  cleanup() {
+    this.glyphInfos = null;
+    this.plan = null;
+    this.shaper = null;
+  }
+
+  getAvailableFeatures(script, language) {
+    let features = [];
+
+    if (this.GSUBProcessor) {
+      this.GSUBProcessor.selectScript(script, language);
+      features.push(...Object.keys(this.GSUBProcessor.features));
+    }
+
+    if (this.GPOSProcessor) {
+      this.GPOSProcessor.selectScript(script, language);
+      features.push(...Object.keys(this.GPOSProcessor.features));
+    }
+
+    return features;
+  }
+}