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

package/src/fontLigatures/merge.ts

@@ -0,0 +1,393 @@
+import { ILookupTree, ILookupTreeEntry } from './types';
+
+/**
+ * Merges the provided trees into a single lookup tree. When conflicting lookups
+ * are encountered between two trees, the one with the lower index, then the
+ * lower subindex is chosen.
+ *
+ * @param trees Array of trees to merge. Entries in earlier trees are favored
+ *              over those in later trees when there is a choice.
+ */
+export default function mergeTrees(trees: ILookupTree[]): ILookupTree {
+  const result: ILookupTree = {
+    individual: {},
+    range: []
+  };
+
+  const mergedEntries = new WeakMap<ILookupTreeEntry, Set<ILookupTreeEntry>>();
+  for (const tree of trees) {
+    mergeSubtree(result, tree, mergedEntries);
+  }
+
+  return result;
+}
+
+/**
+ * Recursively merges the data for the mergeTree into the mainTree.
+ *
+ * @param mainTree The tree where the values should be merged
+ * @param mergeTree The tree to be merged into the mainTree
+ * @param mergedEntries WeakMap to track already merged entry pairs
+ */
+function mergeSubtree(mainTree: ILookupTree, mergeTree: ILookupTree, mergedEntries: WeakMap<ILookupTreeEntry, Set<ILookupTreeEntry>>): void {
+  // Need to fix this recursively (and handle lookups)
+  for (const [glyphId, value] of Object.entries(mergeTree.individual)) {
+    // The main tree is guaranteed to have no overlaps between the
+    // individual and range values, so if we match an invididual, there
+    // must not be a range
+    if (mainTree.individual[glyphId]) {
+      mergeTreeEntry(mainTree.individual[glyphId], value, mergedEntries);
+    } else {
+      let matched = false;
+      for (const [index, { range, entry }] of mainTree.range.entries()) {
+        const overlap = getIndividualOverlap(Number(glyphId), range);
+
+        // Don't overlap
+        if (overlap.both === null) {
+          continue;
+        }
+
+        matched = true;
+
+        // If they overlap, we have to split the range and then
+        // merge the overlap
+        mainTree.individual[glyphId] = value;
+        mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry), mergedEntries);
+
+        // When there's an overlap, we also have to fix up the range
+        // that we had already processed
+        mainTree.range.splice(index, 1);
+        for (const glyph of overlap.second) {
+          if (Array.isArray(glyph)) {
+            mainTree.range.push({
+              range: glyph,
+              entry: cloneEntry(entry)
+            });
+          } else {
+            mainTree.individual[glyph] = cloneEntry(entry);
+          }
+        }
+      }
+
+      if (!matched) {
+        mainTree.individual[glyphId] = value;
+      }
+    }
+  }
+
+  for (const { range, entry } of mergeTree.range) {
+    // Ranges are more complicated, because they can overlap with
+    // multiple things, individual and range alike. We start by
+    // eliminating ranges that are already present in another range
+    let remainingRanges: (number | [number, number])[] = [range];
+
+    for (let index = 0; index < mainTree.range.length; index++) {
+      const { range, entry: resultEntry } = mainTree.range[index];
+      for (const [remainingIndex, remainingRange] of remainingRanges.entries()) {
+        if (Array.isArray(remainingRange)) {
+          const overlap = getRangeOverlap(remainingRange, range);
+          if (overlap.both === null) {
+            continue;
+          }
+
+          mainTree.range.splice(index, 1);
+          index--;
+
+          const entryToMerge: ILookupTreeEntry = cloneEntry(resultEntry);
+          if (Array.isArray(overlap.both)) {
+            mainTree.range.push({
+              range: overlap.both,
+              entry: entryToMerge
+            });
+          } else {
+            mainTree.individual[overlap.both] = entryToMerge;
+          }
+
+          mergeTreeEntry(entryToMerge, cloneEntry(entry), mergedEntries);
+
+          for (const second of overlap.second) {
+            if (Array.isArray(second)) {
+              mainTree.range.push({
+                range: second,
+                entry: cloneEntry(resultEntry)
+              });
+            } else {
+              mainTree.individual[second] = cloneEntry(resultEntry);
+            }
+          }
+
+          remainingRanges = overlap.first;
+        } else {
+          const overlap = getIndividualOverlap(remainingRange, range);
+          if (overlap.both === null) {
+            continue;
+          }
+
+          // If they overlap, we have to split the range and then
+          // merge the overlap
+          mainTree.individual[remainingRange] = cloneEntry(entry);
+          mergeTreeEntry(mainTree.individual[remainingRange], cloneEntry(resultEntry), mergedEntries);
+
+          // When there's an overlap, we also have to fix up the range
+          // that we had already processed
+          mainTree.range.splice(index, 1);
+          index--;
+
+          for (const glyph of overlap.second) {
+            if (Array.isArray(glyph)) {
+              mainTree.range.push({
+                range: glyph,
+                entry: cloneEntry(resultEntry)
+              });
+            } else {
+              mainTree.individual[glyph] = cloneEntry(resultEntry);
+            }
+          }
+
+          remainingRanges.splice(remainingIndex, 1, ...overlap.first);
+          break;
+        }
+      }
+    }
+
+    // Next, we run the same against any individual glyphs
+    for (const glyphId of Object.keys(mainTree.individual)) {
+      for (const [remainingIndex, remainingRange] of remainingRanges.entries()) {
+        if (Array.isArray(remainingRange)) {
+          const overlap = getIndividualOverlap(Number(glyphId), remainingRange);
+          if (overlap.both === null) {
+            continue;
+          }
+
+          // If they overlap, we have to merge the overlap
+          mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry), mergedEntries);
+
+          // Update the remaining ranges
+          remainingRanges.splice(remainingIndex, 1, ...overlap.second);
+          break;
+        } else {
+          if (Number(glyphId) === remainingRange) {
+            mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry), mergedEntries);
+            break;
+          }
+        }
+      }
+    }
+
+    // Any remaining ranges should just be added directly
+    for (const remainingRange of remainingRanges) {
+      if (Array.isArray(remainingRange)) {
+        mainTree.range.push({
+          range: remainingRange,
+          entry: cloneEntry(entry)
+        });
+      } else {
+        mainTree.individual[remainingRange] = cloneEntry(entry);
+      }
+    }
+  }
+}
+
+/**
+ * Recursively merges the entry forr the mergeTree into the mainTree
+ *
+ * @param mainTree The entry where the values should be merged
+ * @param mergeTree The entry to merge into the mainTree
+ * @param mergedEntries WeakMap to track already merged entry pairs
+ */
+function mergeTreeEntry(mainTree: ILookupTreeEntry, mergeTree: ILookupTreeEntry, mergedEntries: WeakMap<ILookupTreeEntry, Set<ILookupTreeEntry>>): void {
+  // Check if we've already merged this pair
+  let mergedSet = mergedEntries.get(mainTree);
+  if (mergedSet?.has(mergeTree)) {
+    return;
+  }
+  if (!mergedSet) {
+    mergedSet = new Set();
+    mergedEntries.set(mainTree, mergedSet);
+  }
+  mergedSet.add(mergeTree);
+
+  if (
+    mergeTree.lookup && (
+      !mainTree.lookup ||
+      mainTree.lookup.index > mergeTree.lookup.index ||
+      (mainTree.lookup.index === mergeTree.lookup.index && mainTree.lookup.subIndex > mergeTree.lookup.subIndex)
+    )
+  ) {
+    mainTree.lookup = mergeTree.lookup;
+  }
+
+  if (mergeTree.forward) {
+    if (!mainTree.forward) {
+      mainTree.forward = mergeTree.forward;
+    } else {
+      mergeSubtree(mainTree.forward, mergeTree.forward, mergedEntries);
+    }
+  }
+
+  if (mergeTree.reverse) {
+    if (!mainTree.reverse) {
+      mainTree.reverse = mergeTree.reverse;
+    } else {
+      mergeSubtree(mainTree.reverse, mergeTree.reverse, mergedEntries);
+    }
+  }
+}
+
+interface IOverlap {
+  first: (number | [number, number])[];
+  second: (number | [number, number])[];
+  both: number | [number, number] | null;
+}
+
+/**
+ * Determines the overlap (if any) between two ranges. Returns the distinct
+ * ranges for each range and the overlap (if any).
+ *
+ * @param first First range
+ * @param second Second range
+ */
+function getRangeOverlap(first: [number, number], second: [number, number]): IOverlap {
+  const result: IOverlap = {
+    first: [],
+    second: [],
+    both: null
+  };
+
+  // Both
+  if (first[0] < second[1] && second[0] < first[1]) {
+    const start = Math.max(first[0], second[0]);
+    const end = Math.min(first[1], second[1]);
+    result.both = rangeOrIndividual(start, end);
+  }
+
+  // Before
+  if (first[0] < second[0]) {
+    const start = first[0];
+    const end = Math.min(second[0], first[1]);
+    result.first.push(rangeOrIndividual(start, end));
+  } else if (second[0] < first[0]) {
+    const start = second[0];
+    const end = Math.min(second[1], first[0]);
+    result.second.push(rangeOrIndividual(start, end));
+  }
+
+  // After
+  if (first[1] > second[1]) {
+    const start = Math.max(first[0], second[1]);
+    const end = first[1];
+    result.first.push(rangeOrIndividual(start, end));
+  } else if (second[1] > first[1]) {
+    const start = Math.max(first[1], second[0]);
+    const end = second[1];
+    result.second.push(rangeOrIndividual(start, end));
+  }
+
+  return result;
+}
+
+/**
+ * Determines the overlap (if any) between the individual glyph and the range
+ * provided. Returns the glyphs and/or ranges that are unique to each provided
+ * and the overlap (if any).
+ *
+ * @param first Individual glyph
+ * @param second Range
+ */
+function getIndividualOverlap(first: number, second: [number, number]): IOverlap {
+  // Disjoint
+  if (first < second[0] || first > second[1]) {
+    return {
+      first: [first],
+      second: [second],
+      both: null
+    };
+  }
+
+  const result: IOverlap = {
+    first: [],
+    second: [],
+    both: first
+  };
+
+  if (second[0] < first) {
+    result.second.push(rangeOrIndividual(second[0], first));
+  }
+
+  if (second[1] > first) {
+    result.second.push(rangeOrIndividual(first + 1, second[1]));
+  }
+
+  return result;
+}
+
+/**
+ * Returns an individual glyph if the range is of size one or a range if it is
+ * larger.
+ *
+ * @param start Beginning of the range (inclusive)
+ * @param end End of the range (exclusive)
+ */
+function rangeOrIndividual(start: number, end: number): number | [number, number] {
+  if (end - start === 1) {
+    return start;
+  }
+  return [start, end];
+
+}
+
+/**
+ * Clones an individual lookup tree entry.
+ *
+ * @param entry Lookup tree entry to clone
+ * @param visited Map to track already cloned entries (prevents infinite loops)
+ */
+function cloneEntry(entry: ILookupTreeEntry, visited: Map<ILookupTreeEntry, ILookupTreeEntry> = new Map()): ILookupTreeEntry {
+  if (visited.has(entry)) {
+    return visited.get(entry)!;
+  }
+
+  const result: ILookupTreeEntry = {};
+  visited.set(entry, result);
+
+  if (entry.forward) {
+    result.forward = cloneTree(entry.forward, visited);
+  }
+
+  if (entry.reverse) {
+    result.reverse = cloneTree(entry.reverse, visited);
+  }
+
+  if (entry.lookup) {
+    result.lookup = {
+      contextRange: entry.lookup.contextRange.slice() as [number, number],
+      index: entry.lookup.index,
+      length: entry.lookup.length,
+      subIndex: entry.lookup.subIndex,
+      substitutions: entry.lookup.substitutions.slice()
+    };
+  }
+
+  return result;
+}
+
+/**
+ * Clones a lookup tree.
+ *
+ * @param tree Lookup tree to clone
+ * @param visited Map to track already cloned entries (prevents infinite loops)
+ */
+function cloneTree(tree: ILookupTree, visited: Map<ILookupTreeEntry, ILookupTreeEntry> = new Map()): ILookupTree {
+  const individual: { [glyphId: string]: ILookupTreeEntry } = {};
+  for (const [glyphId, entry] of Object.entries(tree.individual)) {
+    individual[glyphId] = cloneEntry(entry, visited);
+  }
+
+  return {
+    individual,
+    range: tree.range.map(({ range, entry }) => ({
+      range: range.slice() as [number, number],
+      entry: cloneEntry(entry, visited)
+    }))
+  };
+}

package/src/fontLigatures/mergeRange.ts

@@ -0,0 +1,66 @@
+/**
+ * Merges the range defined by the provided start and end into the list of
+ * existing ranges. The merge is done in place on the existing range for
+ * performance and is also returned.
+ *
+ * @param ranges Existing range list
+ * @param newRangeStart Start position of the range to merge, inclusive
+ * @param newRangeEnd End position of range to merge, exclusive
+ */
+export default function mergeRange(ranges: [number, number][], newRangeStart: number, newRangeEnd: number): [number, number][] {
+  let inRange = false;
+  for (let i = 0; i < ranges.length; i++) {
+    const range = ranges[i];
+    if (!inRange) {
+      if (newRangeEnd <= range[0]) {
+        // Case 1: New range is before the search range
+        ranges.splice(i, 0, [newRangeStart, newRangeEnd]);
+        return ranges;
+      }
+      if (newRangeEnd <= range[1]) {
+        // Case 2: New range is either wholly contained within the
+        // search range or overlaps with the front of it
+        range[0] = Math.min(newRangeStart, range[0]);
+        return ranges;
+      }
+      if (newRangeStart < range[1]) {
+        // Case 3: New range either wholly contains the search range
+        // or overlaps with the end of it
+        range[0] = Math.min(newRangeStart, range[0]);
+        inRange = true;
+      } else {
+        // Case 4: New range starts after the search range
+        continue;
+      }
+    } else {
+      if (newRangeEnd <= range[0]) {
+        // Case 5: New range extends from previous range but doesn't
+        // reach the current one
+        ranges[i - 1][1] = newRangeEnd;
+        return ranges;
+      }
+      if (newRangeEnd <= range[1]) {
+        // Case 6: New range extends from prvious range into the
+        // current range
+        ranges[i - 1][1] = Math.max(newRangeEnd, range[1]);
+        ranges.splice(i, 1);
+        inRange = false;
+        return ranges;
+      }
+      // Case 7: New range extends from previous range past the
+      // end of the current range
+      ranges.splice(i, 1);
+      i--;
+    }
+  }
+
+  if (inRange) {
+    // Case 8: New range extends past the last existing range
+    ranges[ranges.length - 1][1] = newRangeEnd;
+  } else {
+    // Case 9: New range starts after the last existing range
+    ranges.push([newRangeStart, newRangeEnd]);
+  }
+
+  return ranges;
+}

package/src/fontLigatures/processors/6-1.ts

@@ -0,0 +1,82 @@
+import { ChainingContextualSubstitutionTable, Lookup } from '../tables';
+import { ILookupTree } from '../types';
+
+import { listGlyphsByIndex } from './coverage';
+import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper';
+
+/**
+ * Build lookup tree for GSUB lookup table 6, format 1.
+ * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#61-chaining-context-substitution-format-1-simple-glyph-contexts
+ *
+ * @param table JSON representation of the table
+ * @param lookups List of lookup tables
+ * @param tableIndex Index of this table in the overall lookup
+ */
+export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat1, lookups: Lookup[], tableIndex: number): ILookupTree {
+  const result: ILookupTree = {
+    individual: {},
+    range: []
+  };
+
+  const firstGlyphs = listGlyphsByIndex(table.coverage);
+
+  for (const { glyphId, index } of firstGlyphs) {
+    const chainRuleSet = table.chainRuleSets[index];
+
+    // If the chain rule set is null there's nothing to do with this table.
+    if (!chainRuleSet) {
+      continue;
+    }
+
+    for (const [subIndex, subTable] of chainRuleSet.entries()) {
+      let currentEntries: IEntryMeta[] = getInputTree(
+        result,
+        subTable.lookupRecords,
+        lookups,
+        0,
+        glyphId
+      ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] }));
+
+      // We walk forward, then backward
+      for (const [index, glyph] of subTable.input.entries()) {
+        currentEntries = processInputPosition(
+          [glyph],
+          index + 1,
+          currentEntries,
+          subTable.lookupRecords,
+          lookups
+        );
+      }
+
+      for (const glyph of subTable.lookahead) {
+        currentEntries = processLookaheadPosition(
+          [glyph],
+          currentEntries
+        );
+      }
+
+      for (const glyph of subTable.backtrack) {
+        currentEntries = processBacktrackPosition(
+          [glyph],
+          currentEntries
+        );
+      }
+
+      // When we get to the end, insert the lookup information
+      for (const { entry, substitutions } of currentEntries) {
+        entry.lookup = {
+          substitutions,
+          length: subTable.input.length + 1,
+          index: tableIndex,
+          subIndex,
+          contextRange: [
+            -1 * subTable.backtrack.length,
+            1 + subTable.input.length + subTable.lookahead.length
+          ]
+        };
+      }
+    }
+  }
+
+  return result;
+}

package/src/fontLigatures/processors/6-2.ts

@@ -0,0 +1,96 @@
+import { ChainingContextualSubstitutionTable, Lookup } from '../tables';
+import { ILookupTree } from '../types';
+import mergeTrees from '../merge';
+
+import { listGlyphsByIndex } from './coverage';
+import getGlyphClass, { listClassGlyphs } from './classDef';
+import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper';
+
+/**
+ * Build lookup tree for GSUB lookup table 6, format 2.
+ * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#62-chaining-context-substitution-format-2-class-based-glyph-contexts
+ *
+ * @param table JSON representation of the table
+ * @param lookups List of lookup tables
+ * @param tableIndex Index of this table in the overall lookup
+ */
+export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat2, lookups: Lookup[], tableIndex: number): ILookupTree {
+  const results: ILookupTree[] = [];
+
+  const firstGlyphs = listGlyphsByIndex(table.coverage);
+
+  for (const { glyphId } of firstGlyphs) {
+    const firstInputClass = getGlyphClass(table.inputClassDef, glyphId);
+    for (const [glyphId, inputClass] of firstInputClass.entries()) {
+      // istanbul ignore next - invalid font
+      if (inputClass === null) {
+        continue;
+      }
+
+      const classSet = table.chainClassSet[inputClass];
+
+      // If the class set is null there's nothing to do with this table.
+      if (!classSet) {
+        continue;
+      }
+
+      for (const [subIndex, subTable] of classSet.entries()) {
+        const result: ILookupTree = {
+          individual: {},
+          range: []
+        };
+
+        let currentEntries: IEntryMeta[] = getInputTree(
+          result,
+          subTable.lookupRecords,
+          lookups,
+          0,
+          glyphId
+        ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] }));
+
+        for (const [index, classNum] of subTable.input.entries()) {
+          currentEntries = processInputPosition(
+            listClassGlyphs(table.inputClassDef, classNum),
+            index + 1,
+            currentEntries,
+            subTable.lookupRecords,
+            lookups
+          );
+        }
+
+        for (const classNum of subTable.lookahead) {
+          currentEntries = processLookaheadPosition(
+            listClassGlyphs(table.lookaheadClassDef, classNum),
+            currentEntries
+          );
+        }
+
+        for (const classNum of subTable.backtrack) {
+          currentEntries = processBacktrackPosition(
+            listClassGlyphs(table.backtrackClassDef, classNum),
+            currentEntries
+          );
+        }
+
+        // When we get to the end, all of the entries we've accumulated
+        // should have a lookup defined
+        for (const { entry, substitutions } of currentEntries) {
+          entry.lookup = {
+            substitutions,
+            index: tableIndex,
+            subIndex,
+            length: subTable.input.length + 1,
+            contextRange: [
+              -1 * subTable.backtrack.length,
+              1 + subTable.input.length + subTable.lookahead.length
+            ]
+          };
+        }
+
+        results.push(result);
+      }
+    }
+  }
+
+  return mergeTrees(results);
+}

package/src/fontLigatures/processors/6-3.ts

@@ -0,0 +1,73 @@
+import { ChainingContextualSubstitutionTable, Lookup } from '../tables';
+import { ILookupTree } from '../types';
+
+import { listGlyphsByIndex } from './coverage';
+import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper';
+
+/**
+ * Build lookup tree for GSUB lookup table 6, format 3.
+ * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#63-chaining-context-substitution-format-3-coverage-based-glyph-contexts
+ *
+ * @param table JSON representation of the table
+ * @param lookups List of lookup tables
+ * @param tableIndex Index of this table in the overall lookup
+ */
+export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat3, lookups: Lookup[], tableIndex: number): ILookupTree {
+  const result: ILookupTree = {
+    individual: {},
+    range: []
+  };
+
+  const firstGlyphs = listGlyphsByIndex(table.inputCoverage[0]);
+
+  for (const { glyphId } of firstGlyphs) {
+    let currentEntries: IEntryMeta[] = getInputTree(
+      result,
+      table.lookupRecords,
+      lookups,
+      0,
+      glyphId
+    ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] }));
+
+    for (const [index, coverage] of table.inputCoverage.slice(1).entries()) {
+      currentEntries = processInputPosition(
+        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
+        index + 1,
+        currentEntries,
+        table.lookupRecords,
+        lookups
+      );
+    }
+
+    for (const coverage of table.lookaheadCoverage) {
+      currentEntries = processLookaheadPosition(
+        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
+        currentEntries
+      );
+    }
+
+    for (const coverage of table.backtrackCoverage) {
+      currentEntries = processBacktrackPosition(
+        listGlyphsByIndex(coverage).map(glyph => glyph.glyphId),
+        currentEntries
+      );
+    }
+
+    // When we get to the end, all of the entries we've accumulated
+    // should have a lookup defined
+    for (const { entry, substitutions } of currentEntries) {
+      entry.lookup = {
+        substitutions,
+        index: tableIndex,
+        subIndex: 0,
+        length: table.inputCoverage.length,
+        contextRange: [
+          -1 * table.backtrackCoverage.length,
+          table.inputCoverage.length + table.lookaheadCoverage.length
+        ]
+      };
+    }
+  }
+
+  return result;
+}