@cantoo/fontkit 2.0.4

package/src/layout/GlyphRun.js

@@ -0,0 +1,108 @@
+import BBox from '../glyph/BBox';
+import * as Script from '../layout/Script';
+
+/**
+ * Represents a run of Glyph and GlyphPosition objects.
+ * Returned by the font layout method.
+ */
+export default class GlyphRun {
+  constructor(glyphs, features, script, language, direction) {
+    /**
+     * An array of Glyph objects in the run
+     * @type {Glyph[]}
+     */
+    this.glyphs = glyphs;
+
+    /**
+     * An array of GlyphPosition objects for each glyph in the run
+     * @type {GlyphPosition[]}
+     */
+    this.positions = null;
+
+    /**
+     * The script that was requested for shaping. This was either passed in or detected automatically.
+     * @type {string}
+     */
+    this.script = script;
+
+    /**
+     * The language requested for shaping, as passed in. If `null`, the default language for the
+     * script was used.
+     * @type {string}
+     */
+    this.language = language || null;
+
+    /**
+     * The direction requested for shaping, as passed in (either ltr or rtl).
+     * If `null`, the default direction of the script is used.
+     * @type {string}
+     */
+    this.direction = direction || Script.direction(script);
+
+    /**
+     * The features requested during shaping. This is a combination of user
+     * specified features and features chosen by the shaper.
+     * @type {object}
+     */
+    this.features = {};
+
+    // Convert features to an object
+    if (Array.isArray(features)) {
+      for (let tag of features) {
+        this.features[tag] = true;
+      }
+    } else if (typeof features === 'object') {
+      this.features = features;
+    }
+  }
+
+  /**
+   * The total advance width of the run.
+   * @type {number}
+   */
+  get advanceWidth() {
+    let width = 0;
+    for (let position of this.positions) {
+      width += position.xAdvance;
+    }
+
+    return width;
+  }
+
+ /**
+  * The total advance height of the run.
+  * @type {number}
+  */
+  get advanceHeight() {
+    let height = 0;
+    for (let position of this.positions) {
+      height += position.yAdvance;
+    }
+
+    return height;
+  }
+
+ /**
+  * The bounding box containing all glyphs in the run.
+  * @type {BBox}
+  */
+  get bbox() {
+    let bbox = new BBox;
+
+    let x = 0;
+    let y = 0;
+    for (let index = 0; index < this.glyphs.length; index++) {
+      let glyph = this.glyphs[index];
+      let p = this.positions[index];
+      let b = glyph.bbox;
+
+      bbox.addPoint(b.minX + x + p.xOffset, b.minY + y + p.yOffset);
+      bbox.addPoint(b.maxX + x + p.xOffset, b.maxY + y + p.yOffset);
+
+      x += p.xAdvance;
+      y += p.yAdvance;
+    }
+
+    return bbox;
+  }
+}

package/src/layout/KernProcessor.js

@@ -0,0 +1,97 @@
+import {binarySearch} from '../utils';
+
+export default class KernProcessor {
+  constructor(font) {
+    this.kern = font.kern;
+  }
+
+  process(glyphs, positions) {
+    for (let glyphIndex = 0; glyphIndex < glyphs.length - 1; glyphIndex++) {
+      let left = glyphs[glyphIndex].id;
+      let right = glyphs[glyphIndex + 1].id;
+      positions[glyphIndex].xAdvance += this.getKerning(left, right);
+    }
+  }
+
+  getKerning(left, right) {
+    let res = 0;
+
+    for (let table of this.kern.tables) {
+      if (table.coverage.crossStream) {
+        continue;
+      }
+
+      switch (table.version) {
+        case 0:
+          if (!table.coverage.horizontal) {
+            continue;
+          }
+
+          break;
+        case 1:
+          if (table.coverage.vertical || table.coverage.variation) {
+            continue;
+          }
+
+          break;
+        default:
+          throw new Error(`Unsupported kerning table version ${table.version}`);
+      }
+
+      let val = 0;
+      let s = table.subtable;
+      switch (table.format) {
+        case 0: {
+          let pairIdx = binarySearch(s.pairs, function (pair) {
+            return (left - pair.left) || (right - pair.right);
+          });
+
+          if (pairIdx >= 0) {
+            val = s.pairs[pairIdx].value;
+          }
+
+          break;
+        }
+
+        case 2: {
+          let leftOffset, rightOffset = 0;
+          if (left >= s.leftTable.firstGlyph && left < s.leftTable.firstGlyph + s.leftTable.nGlyphs) {
+            leftOffset = s.leftTable.offsets[left - s.leftTable.firstGlyph];
+          } else {
+            leftOffset = s.array.off;
+          }
+
+          if (right >= s.rightTable.firstGlyph && right < s.rightTable.firstGlyph + s.rightTable.nGlyphs) {
+            rightOffset = s.rightTable.offsets[right - s.rightTable.firstGlyph];
+          }
+
+          let index = (leftOffset + rightOffset - s.array.off) / 2;
+          val = s.array.values.get(index);
+          break;
+        }
+
+        case 3: {
+          if (left >= s.glyphCount || right >= s.glyphCount) {
+            return 0;
+          }
+
+          val = s.kernValue[s.kernIndex[s.leftClass[left] * s.rightClassCount + s.rightClass[right]]];
+          break;
+        }
+
+        default:
+          throw new Error(`Unsupported kerning sub-table format ${table.format}`);
+      }
+
+      // Microsoft supports the override flag, which resets the result
+      // Otherwise, the sum of the results from all subtables is returned
+      if (table.coverage.override) {
+        res = val;
+      } else {
+        res += val;
+      }
+    }
+
+    return res;
+  }
+}

package/src/layout/LayoutEngine.js

@@ -0,0 +1,190 @@
+import KernProcessor from './KernProcessor';
+import UnicodeLayoutEngine from './UnicodeLayoutEngine';
+import GlyphRun from './GlyphRun';
+import GlyphPosition from './GlyphPosition';
+import * as Script from './Script';
+import AATLayoutEngine from '../aat/AATLayoutEngine';
+import OTLayoutEngine from '../opentype/OTLayoutEngine';
+
+export default class LayoutEngine {
+  constructor(font) {
+    this.font = font;
+    this.unicodeLayoutEngine = null;
+    this.kernProcessor = null;
+
+    // Choose an advanced layout engine. We try the AAT morx table first since more
+    // scripts are currently supported because the shaping logic is built into the font.
+    if (this.font.morx) {
+      this.engine = new AATLayoutEngine(this.font);
+
+    } else if (this.font.GSUB || this.font.GPOS) {
+      this.engine = new OTLayoutEngine(this.font);
+    }
+  }
+
+  layout(string, features, script, language, direction) {
+    // Make the features parameter optional
+    if (typeof features === 'string') {
+      direction = language;
+      language = script;
+      script = features;
+      features = [];
+    }
+
+    // Map string to glyphs if needed
+    let glyphs;
+    if (typeof string === 'string') {
+      // Attempt to detect the script from the string if not provided.
+      if (script == null) {
+        script = Script.forString(string);
+      }
+
+      glyphs = this.font.glyphsForString(string);
+    } else {
+      // Attempt to detect the script from the glyph code points if not provided.
+      if (script == null) {
+        let codePoints = [];
+        for (let glyph of string) {
+          codePoints.push(...glyph.codePoints);
+        }
+
+        script = Script.forCodePoints(codePoints);
+      }
+
+      glyphs = string;
+    }
+
+    let glyphRun = new GlyphRun(glyphs, features, script, language, direction);
+
+    // Return early if there are no glyphs
+    if (glyphs.length === 0) {
+      glyphRun.positions = [];
+      return glyphRun;
+    }
+
+    // Setup the advanced layout engine
+    if (this.engine && this.engine.setup) {
+      this.engine.setup(glyphRun);
+    }
+
+    // Substitute and position the glyphs
+    this.substitute(glyphRun);
+    this.position(glyphRun);
+
+    this.hideDefaultIgnorables(glyphRun.glyphs, glyphRun.positions);
+
+    // Let the layout engine clean up any state it might have
+    if (this.engine && this.engine.cleanup) {
+      this.engine.cleanup();
+    }
+
+    return glyphRun;
+  }
+
+  substitute(glyphRun) {
+    // Call the advanced layout engine to make substitutions
+    if (this.engine && this.engine.substitute) {
+      this.engine.substitute(glyphRun);
+    }
+  }
+
+  position(glyphRun) {
+    // Get initial glyph positions
+    glyphRun.positions = glyphRun.glyphs.map(glyph => new GlyphPosition(glyph.advanceWidth));
+    let positioned = null;
+
+    // Call the advanced layout engine. Returns the features applied.
+    if (this.engine && this.engine.position) {
+      positioned = this.engine.position(glyphRun);
+    }
+
+    // if there is no GPOS table, use unicode properties to position marks.
+    if (!positioned && (!this.engine || this.engine.fallbackPosition)) {
+      if (!this.unicodeLayoutEngine) {
+        this.unicodeLayoutEngine = new UnicodeLayoutEngine(this.font);
+      }
+
+      this.unicodeLayoutEngine.positionGlyphs(glyphRun.glyphs, glyphRun.positions);
+    }
+
+    // if kerning is not supported by GPOS, do kerning with the TrueType/AAT kern table
+    if ((!positioned || !positioned.kern) && glyphRun.features.kern !== false && this.font.kern) {
+      if (!this.kernProcessor) {
+        this.kernProcessor = new KernProcessor(this.font);
+      }
+
+      this.kernProcessor.process(glyphRun.glyphs, glyphRun.positions);
+      glyphRun.features.kern = true;
+    }
+  }
+
+  hideDefaultIgnorables(glyphs, positions) {
+    let space = this.font.glyphForCodePoint(0x20);
+    for (let i = 0; i < glyphs.length; i++) {
+      if (this.isDefaultIgnorable(glyphs[i].codePoints[0])) {
+        glyphs[i] = space;
+        positions[i].xAdvance = 0;
+        positions[i].yAdvance = 0;
+      }
+    }
+  }
+
+  isDefaultIgnorable(ch) {
+    // From DerivedCoreProperties.txt in the Unicode database,
+    // minus U+115F, U+1160, U+3164 and U+FFA0, which is what
+    // Harfbuzz and Uniscribe do.
+    let plane = ch >> 16;
+    if (plane === 0) {
+      // BMP
+      switch (ch >> 8) {
+      	case 0x00: return ch === 0x00AD;
+      	case 0x03: return ch === 0x034F;
+      	case 0x06: return ch === 0x061C;
+      	case 0x17: return 0x17B4 <= ch && ch <= 0x17B5;
+      	case 0x18: return 0x180B <= ch && ch <= 0x180E;
+      	case 0x20: return (0x200B <= ch && ch <= 0x200F) || (0x202A <= ch && ch <= 0x202E) || (0x2060 <= ch && ch <= 0x206F);
+      	case 0xFE: return (0xFE00 <= ch && ch <= 0xFE0F) || ch === 0xFEFF;
+      	case 0xFF: return 0xFFF0 <= ch && ch <= 0xFFF8;
+      	default:   return false;
+      }
+    } else {
+      // Other planes
+      switch (plane) {
+      	case 0x01: return (0x1BCA0 <= ch && ch <= 0x1BCA3) || (0x1D173 <= ch && ch <= 0x1D17A);
+      	case 0x0E: return 0xE0000 <= ch && ch <= 0xE0FFF;
+      	default:   return false;
+      }
+    }
+  }
+
+  getAvailableFeatures(script, language) {
+    let features = [];
+
+    if (this.engine) {
+      features.push(...this.engine.getAvailableFeatures(script, language));
+    }
+
+    if (this.font.kern && features.indexOf('kern') === -1) {
+      features.push('kern');
+    }
+
+    return features;
+  }
+
+  stringsForGlyph(gid) {
+    let result = new Set;
+
+    let codePoints = this.font._cmapProcessor.codePointsForGlyph(gid);
+    for (let codePoint of codePoints) {
+      result.add(String.fromCodePoint(codePoint));
+    }
+
+    if (this.engine && this.engine.stringsForGlyph) {
+      for (let string of this.engine.stringsForGlyph(gid)) {
+        result.add(string);
+      }
+    }
+
+    return Array.from(result);
+  }
+}

package/src/layout/Script.js

@@ -0,0 +1,231 @@
+import {getScript} from '../packages/unicode-properties/index.js';
+
+// This maps the Unicode Script property to an OpenType script tag
+// Data from http://www.microsoft.com/typography/otspec/scripttags.htm
+// and http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt.
+const UNICODE_SCRIPTS = {
+  Caucasian_Albanian: 'aghb',
+  Arabic: 'arab',
+  Imperial_Aramaic: 'armi',
+  Armenian: 'armn',
+  Avestan: 'avst',
+  Balinese: 'bali',
+  Bamum: 'bamu',
+  Bassa_Vah: 'bass',
+  Batak: 'batk',
+  Bengali: ['bng2', 'beng'],
+  Bopomofo: 'bopo',
+  Brahmi: 'brah',
+  Braille: 'brai',
+  Buginese: 'bugi',
+  Buhid: 'buhd',
+  Chakma: 'cakm',
+  Canadian_Aboriginal: 'cans',
+  Carian: 'cari',
+  Cham: 'cham',
+  Cherokee: 'cher',
+  Coptic: 'copt',
+  Cypriot: 'cprt',
+  Cyrillic: 'cyrl',
+  Devanagari: ['dev2', 'deva'],
+  Deseret: 'dsrt',
+  Duployan: 'dupl',
+  Egyptian_Hieroglyphs: 'egyp',
+  Elbasan: 'elba',
+  Ethiopic: 'ethi',
+  Georgian: 'geor',
+  Glagolitic: 'glag',
+  Gothic: 'goth',
+  Grantha: 'gran',
+  Greek: 'grek',
+  Gujarati: ['gjr2', 'gujr'],
+  Gurmukhi: ['gur2', 'guru'],
+  Hangul: 'hang',
+  Han: 'hani',
+  Hanunoo: 'hano',
+  Hebrew: 'hebr',
+  Hiragana: 'hira',
+  Pahawh_Hmong: 'hmng',
+  Katakana_Or_Hiragana: 'hrkt',
+  Old_Italic: 'ital',
+  Javanese: 'java',
+  Kayah_Li: 'kali',
+  Katakana: 'kana',
+  Kharoshthi: 'khar',
+  Khmer: 'khmr',
+  Khojki: 'khoj',
+  Kannada: ['knd2', 'knda'],
+  Kaithi: 'kthi',
+  Tai_Tham: 'lana',
+  Lao: 'lao ',
+  Latin: 'latn',
+  Lepcha: 'lepc',
+  Limbu: 'limb',
+  Linear_A: 'lina',
+  Linear_B: 'linb',
+  Lisu: 'lisu',
+  Lycian: 'lyci',
+  Lydian: 'lydi',
+  Mahajani: 'mahj',
+  Mandaic: 'mand',
+  Manichaean: 'mani',
+  Mende_Kikakui: 'mend',
+  Meroitic_Cursive: 'merc',
+  Meroitic_Hieroglyphs: 'mero',
+  Malayalam: ['mlm2', 'mlym'],
+  Modi: 'modi',
+  Mongolian: 'mong',
+  Mro: 'mroo',
+  Meetei_Mayek: 'mtei',
+  Myanmar: ['mym2', 'mymr'],
+  Old_North_Arabian: 'narb',
+  Nabataean: 'nbat',
+  Nko: 'nko ',
+  Ogham: 'ogam',
+  Ol_Chiki: 'olck',
+  Old_Turkic: 'orkh',
+  Oriya: ['ory2', 'orya'],
+  Osmanya: 'osma',
+  Palmyrene: 'palm',
+  Pau_Cin_Hau: 'pauc',
+  Old_Permic: 'perm',
+  Phags_Pa: 'phag',
+  Inscriptional_Pahlavi: 'phli',
+  Psalter_Pahlavi: 'phlp',
+  Phoenician: 'phnx',
+  Miao: 'plrd',
+  Inscriptional_Parthian: 'prti',
+  Rejang: 'rjng',
+  Runic: 'runr',
+  Samaritan: 'samr',
+  Old_South_Arabian: 'sarb',
+  Saurashtra: 'saur',
+  Shavian: 'shaw',
+  Sharada: 'shrd',
+  Siddham: 'sidd',
+  Khudawadi: 'sind',
+  Sinhala: 'sinh',
+  Sora_Sompeng: 'sora',
+  Sundanese: 'sund',
+  Syloti_Nagri: 'sylo',
+  Syriac: 'syrc',
+  Tagbanwa: 'tagb',
+  Takri: 'takr',
+  Tai_Le: 'tale',
+  New_Tai_Lue: 'talu',
+  Tamil: ['tml2', 'taml'],
+  Tai_Viet: 'tavt',
+  Telugu: ['tel2', 'telu'],
+  Tifinagh: 'tfng',
+  Tagalog: 'tglg',
+  Thaana: 'thaa',
+  Thai: 'thai',
+  Tibetan: 'tibt',
+  Tirhuta: 'tirh',
+  Ugaritic: 'ugar',
+  Vai: 'vai ',
+  Warang_Citi: 'wara',
+  Old_Persian: 'xpeo',
+  Cuneiform: 'xsux',
+  Yi: 'yi  ',
+  Inherited: 'zinh',
+  Common: 'zyyy',
+  Unknown: 'zzzz'
+};
+
+const OPENTYPE_SCRIPTS = {};
+for (let script in UNICODE_SCRIPTS) {
+  let tag = UNICODE_SCRIPTS[script];
+  if (Array.isArray(tag)) {
+    for (let t of tag) {
+      OPENTYPE_SCRIPTS[t] = script;
+    }
+  } else {
+    OPENTYPE_SCRIPTS[tag] = script;
+  }
+}
+
+export function fromUnicode(script) {
+  return UNICODE_SCRIPTS[script];
+}
+
+export function fromOpenType(tag) {
+  return OPENTYPE_SCRIPTS[tag];
+}
+
+export function forString(string) {
+  let len = string.length;
+  let idx = 0;
+  while (idx < len) {
+    let code = string.charCodeAt(idx++);
+
+    // Check if this is a high surrogate
+    if (0xd800 <= code && code <= 0xdbff && idx < len) {
+      let next = string.charCodeAt(idx);
+
+      // Check if this is a low surrogate
+      if (0xdc00 <= next && next <= 0xdfff) {
+        idx++;
+        code = ((code & 0x3FF) << 10) + (next & 0x3FF) + 0x10000;
+      }
+    }
+
+    let script = getScript(code);
+    if (script !== 'Common' && script !== 'Inherited' && script !== 'Unknown') {
+      return UNICODE_SCRIPTS[script];
+    }
+  }
+
+  return UNICODE_SCRIPTS.Unknown;
+}
+
+export function forCodePoints(codePoints) {
+  for (let i = 0; i < codePoints.length; i++) {
+    let codePoint = codePoints[i];
+    let script = getScript(codePoint);
+    if (script !== 'Common' && script !== 'Inherited' && script !== 'Unknown') {
+      return UNICODE_SCRIPTS[script];
+    }
+  }
+
+  return UNICODE_SCRIPTS.Unknown;
+}
+
+// The scripts in this map are written from right to left
+const RTL = {
+  arab: true,   // Arabic
+  hebr: true,   // Hebrew
+  syrc: true,   // Syriac
+  thaa: true,   // Thaana
+  cprt: true,   // Cypriot Syllabary
+  khar: true,   // Kharosthi
+  phnx: true,   // Phoenician
+  'nko ': true, // N'Ko
+  lydi: true,   // Lydian
+  avst: true,   // Avestan
+  armi: true,   // Imperial Aramaic
+  phli: true,   // Inscriptional Pahlavi
+  prti: true,   // Inscriptional Parthian
+  sarb: true,   // Old South Arabian
+  orkh: true,   // Old Turkic, Orkhon Runic
+  samr: true,   // Samaritan
+  mand: true,   // Mandaic, Mandaean
+  merc: true,   // Meroitic Cursive
+  mero: true,   // Meroitic Hieroglyphs
+
+  // Unicode 7.0 (not listed on http://www.microsoft.com/typography/otspec/scripttags.htm)
+  mani: true,   // Manichaean
+  mend: true,   // Mende Kikakui
+  nbat: true,   // Nabataean
+  narb: true,   // Old North Arabian
+  palm: true,   // Palmyrene
+  phlp: true    // Psalter Pahlavi
+};
+
+export function direction(script) {
+  if (RTL[script]) {
+    return 'rtl';
+  }
+
+  return 'ltr';
+}