@xterm/addon-ligatures 0.11.0-beta.9 → 0.11.0-beta.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xterm/addon-ligatures",
-  "version": "0.11.0-beta.9",
+  "version": "0.11.0-beta.90",
   "description": "Add support for programming ligatures to xterm.js",
   "author": {
     "name": "The xterm.js authors",
@@ -32,18 +32,19 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "font-finder": "^1.1.0",
-    "font-ligatures": "^1.4.1"
+    "lru-cache": "^6.0.0",
+    "opentype.js": "^0.8.0"
   },
   "devDependencies": {
-    "@types/sinon": "^5.0.1",
+    "@types/lru-cache": "^5.1.0",
+    "@types/opentype.js": "^0.7.0",
     "axios": "^1.6.0",
+    "font-finder": "^1.1.0",
     "mkdirp": "0.5.5",
-    "sinon": "6.3.5",
     "yauzl": "^2.10.0"
   },
-  "commit": "269d8c20aed41b71c743690b1fe70d82dbd420d6",
+  "commit": "c97abced76fe3ca2191b86f6c03c1275b6d4e696",
   "peerDependencies": {
-    "@xterm/xterm": "^6.1.0-beta.9"
+    "@xterm/xterm": "^6.1.0-beta.90"
   }
 }

package/src/font.ts

@@ -3,7 +3,7 @@
  * @license MIT
  */
 
-import { Font, loadBuffer } from 'font-ligatures';
+import { Font, loadBuffer } from './fontLigatures/index';
 
 import parse from './parse';
 

package/src/fontLigatures/flatten.ts

@@ -0,0 +1,40 @@
+import { ILookupTree, IFlattenedLookupTree, ILookupTreeEntry, IFlattenedLookupTreeEntry } from './types';
+
+export default function flatten(tree: ILookupTree, visited: Map<ILookupTreeEntry, IFlattenedLookupTreeEntry> = new Map()): IFlattenedLookupTree {
+  const result: IFlattenedLookupTree = {};
+  for (const [glyphId, entry] of Object.entries(tree.individual)) {
+    result[glyphId] = flattenEntry(entry, visited);
+  }
+
+  for (const { range, entry } of tree.range) {
+    const flattened = flattenEntry(entry, visited);
+    for (let glyphId = range[0]; glyphId < range[1]; glyphId++) {
+      result[glyphId] = flattened;
+    }
+  }
+
+  return result;
+}
+
+function flattenEntry(entry: ILookupTreeEntry, visited: Map<ILookupTreeEntry, IFlattenedLookupTreeEntry>): IFlattenedLookupTreeEntry {
+  if (visited.has(entry)) {
+    return visited.get(entry)!;
+  }
+
+  const result: IFlattenedLookupTreeEntry = {};
+  visited.set(entry, result);
+
+  if (entry.forward) {
+    result.forward = flatten(entry.forward, visited);
+  }
+
+  if (entry.reverse) {
+    result.reverse = flatten(entry.reverse, visited);
+  }
+
+  if (entry.lookup) {
+    result.lookup = entry.lookup;
+  }
+
+  return result;
+}

package/src/fontLigatures/index.ts

@@ -0,0 +1,262 @@
+import * as opentype from 'opentype.js';
+import LRUCache = require('lru-cache');
+
+import { IFont, ILigatureData, IFlattenedLookupTree, ILookupTree, IOptions } from './types';
+import mergeTrees from './merge';
+import walkTree from './walk';
+import mergeRange from './mergeRange';
+
+import buildTreeGsubType6Format1 from './processors/6-1';
+import buildTreeGsubType6Format2 from './processors/6-2';
+import buildTreeGsubType6Format3 from './processors/6-3';
+import buildTreeGsubType8Format1 from './processors/8-1';
+import flatten from './flatten';
+
+class FontImpl implements IFont {
+  private _font: opentype.Font;
+  private _lookupTrees: { tree: IFlattenedLookupTree, processForward: boolean }[] = [];
+  private _glyphLookups: { [glyphId: string]: number[] } = {};
+  private _cache?: LRUCache<string, ILigatureData | [number, number][]>;
+
+  constructor(font: opentype.Font, options: Required<IOptions>) {
+    this._font = font;
+
+    if (options.cacheSize > 0) {
+      this._cache = new LRUCache({
+        max: options.cacheSize,
+        length: ((val: ILigatureData | [number, number][], key: string) => key.length) as any
+      });
+    }
+
+    const caltFeatures = this._font.tables.gsub && this._font.tables.gsub.features.filter((f: { tag: string }) => f.tag === 'calt') || [];
+    const lookupIndices: number[] = caltFeatures
+      .reduce((acc: number[], val: { feature: { lookupListIndexes: number[] } }) => [...acc, ...val.feature.lookupListIndexes], []);
+
+    const allLookups = this._font.tables.gsub && this._font.tables.gsub.lookups || [];
+    const lookupGroups = allLookups.filter((l: unknown, i: number) => lookupIndices.some(idx => idx === i));
+
+    for (const [index, lookup] of lookupGroups.entries()) {
+      const trees: ILookupTree[] = [];
+      switch (lookup.lookupType) {
+        case 6:
+          for (const [index, table] of lookup.subtables.entries()) {
+            switch (table.substFormat) {
+              case 1:
+                trees.push(buildTreeGsubType6Format1(table, allLookups, index));
+                break;
+              case 2:
+                trees.push(buildTreeGsubType6Format2(table, allLookups, index));
+                break;
+              case 3:
+                trees.push(buildTreeGsubType6Format3(table, allLookups, index));
+                break;
+            }
+          }
+          break;
+        case 8:
+          for (const [index, table] of lookup.subtables.entries()) {
+            trees.push(buildTreeGsubType8Format1(table, index));
+          }
+          break;
+      }
+
+      const tree = flatten(mergeTrees(trees));
+
+      this._lookupTrees.push({
+        tree,
+        processForward: lookup.lookupType !== 8
+      });
+
+      for (const glyphId of Object.keys(tree)) {
+        if (!this._glyphLookups[glyphId]) {
+          this._glyphLookups[glyphId] = [];
+        }
+
+        this._glyphLookups[glyphId].push(index);
+      }
+    }
+  }
+
+  public findLigatures(text: string): ILigatureData {
+    const cached = this._cache && this._cache.get(text);
+    if (cached && !Array.isArray(cached)) {
+      return cached;
+    }
+
+    const glyphIds: number[] = [];
+    for (const char of text) {
+      glyphIds.push(this._font.charToGlyphIndex(char));
+    }
+
+    // If there are no lookup groups, there's no point looking for
+    // replacements. This gives us a minor performance boost for fonts with
+    // no ligatures
+    if (this._lookupTrees.length === 0) {
+      return {
+        inputGlyphs: glyphIds,
+        outputGlyphs: glyphIds,
+        contextRanges: []
+      };
+    }
+
+    const result = this._findInternal(glyphIds.slice());
+    const finalResult: ILigatureData = {
+      inputGlyphs: glyphIds,
+      outputGlyphs: result.sequence,
+      contextRanges: result.ranges
+    };
+    if (this._cache) {
+      this._cache.set(text, finalResult);
+    }
+
+    return finalResult;
+  }
+
+  public findLigatureRanges(text: string): [number, number][] {
+    // Short circuit the process if there are no possible ligatures in the
+    // font
+    if (this._lookupTrees.length === 0) {
+      return [];
+    }
+
+    const cached = this._cache && this._cache.get(text);
+    if (cached) {
+      return Array.isArray(cached) ? cached : cached.contextRanges;
+    }
+
+    const glyphIds: number[] = [];
+    for (const char of text) {
+      glyphIds.push(this._font.charToGlyphIndex(char));
+    }
+
+    const result = this._findInternal(glyphIds);
+    if (this._cache) {
+      this._cache.set(text, result.ranges);
+    }
+
+    return result.ranges;
+  }
+
+  private _findInternal(sequence: number[]): { sequence: number[], ranges: [number, number][] } {
+    const ranges: [number, number][] = [];
+
+    let nextLookup = this._getNextLookup(sequence, 0);
+    while (nextLookup.index !== null) {
+      const lookup = this._lookupTrees[nextLookup.index];
+      if (lookup.processForward) {
+        let lastGlyphIndex = nextLookup.last;
+        for (let i = nextLookup.first; i < lastGlyphIndex; i++) {
+          const result = walkTree(lookup.tree, sequence, i, i);
+          if (result) {
+            for (let j = 0; j < result.substitutions.length; j++) {
+              const sub = result.substitutions[j];
+              if (sub !== null) {
+                sequence[i + j] = sub;
+              }
+            }
+
+            mergeRange(
+              ranges,
+              result.contextRange[0] + i,
+              result.contextRange[1] + i
+            );
+
+            // Substitutions can end up extending the search range
+            if (i + result.length >= lastGlyphIndex) {
+              lastGlyphIndex = i + result.length + 1;
+            }
+
+            i += result.length - 1;
+          }
+        }
+      } else {
+        // We don't need to do the lastGlyphIndex tracking here because
+        // reverse processing isn't allowed to replace more than one
+        // character at a time.
+        for (let i = nextLookup.last - 1; i >= nextLookup.first; i--) {
+          const result = walkTree(lookup.tree, sequence, i, i);
+          if (result) {
+            for (let j = 0; j < result.substitutions.length; j++) {
+              const sub = result.substitutions[j];
+              if (sub !== null) {
+                sequence[i + j] = sub;
+              }
+            }
+
+            mergeRange(
+              ranges,
+              result.contextRange[0] + i,
+              result.contextRange[1] + i
+            );
+
+            i -= result.length - 1;
+          }
+        }
+      }
+
+      nextLookup = this._getNextLookup(sequence, nextLookup.index + 1);
+    }
+
+    return { sequence, ranges };
+  }
+
+  /**
+   * Returns the lookup and glyph range for the first lookup that might
+   * contain a match.
+   *
+   * @param sequence Input glyph sequence
+   * @param start The first input to try
+   */
+  private _getNextLookup(sequence: number[], start: number): { index: number | null, first: number, last: number } {
+    const result: { index: number | null, first: number, last: number } = {
+      index: null,
+      first: Infinity,
+      last: -1
+    };
+
+    // Loop through each glyph and find the first valid lookup for it
+    for (let i = 0; i < sequence.length; i++) {
+      const lookups = this._glyphLookups[sequence[i]];
+      if (!lookups) {
+        continue;
+      }
+
+      for (let j = 0; j < lookups.length; j++) {
+        const lookupIndex = lookups[j];
+        if (lookupIndex >= start) {
+          // Update the lookup information if it's the one we're
+          // storing or earlier than it.
+          if (result.index === null || lookupIndex <= result.index) {
+            result.index = lookupIndex;
+
+            if (result.first > i) {
+              result.first = i;
+            }
+
+            result.last = i + 1;
+          }
+
+          break;
+        }
+      }
+    }
+
+    return result;
+  }
+}
+
+/**
+ * Load the font from it's binary data. The returned value can be used to find
+ * ligatures for the font.
+ *
+ * @param buffer ArrayBuffer of the font to load
+ */
+export function loadBuffer(buffer: ArrayBuffer, options?: IOptions): IFont {
+  const font = opentype.parse(buffer);
+  return new FontImpl(font, {
+    cacheSize: 0,
+    ...options
+  });
+}
+
+export { IFont as Font, ILigatureData as LigatureData, IOptions as Options };