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

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

@@ -0,0 +1,69 @@
+import { IReverseChainingContextualSingleSubstitutionTable } from '../tables';
+import { ILookupTree, ILookupTreeEntry } from '../types';
+
+import { listGlyphsByIndex } from './coverage';
+import { processLookaheadPosition, processBacktrackPosition, IEntryMeta } from './helper';
+
+/**
+ * Build lookup tree for GSUB lookup table 8, format 1.
+ * https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#81-reverse-chaining-contextual-single-substitution-format-1-coverage-based-glyph-contexts
+ *
+ * @param table JSON representation of the table
+ * @param tableIndex Index of this table in the overall lookup
+ */
+export default function buildTree(table: IReverseChainingContextualSingleSubstitutionTable, tableIndex: number): ILookupTree {
+  const result: ILookupTree = {
+    individual: {},
+    range: []
+  };
+
+  const glyphs = listGlyphsByIndex(table.coverage);
+
+  for (const { glyphId, index } of glyphs) {
+    const initialEntry: ILookupTreeEntry = {};
+    if (Array.isArray(glyphId)) {
+      result.range.push({
+        entry: initialEntry,
+        range: glyphId
+      });
+    } else {
+      result.individual[glyphId] = initialEntry;
+    }
+
+    let currentEntries: IEntryMeta[] = [{
+      entry: initialEntry,
+      substitutions: [table.substitutes[index]]
+    }];
+
+    // We walk forward, then backward
+    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, insert the lookup information
+    for (const { entry, substitutions } of currentEntries) {
+      entry.lookup = {
+        substitutions,
+        index: tableIndex,
+        subIndex: 0,
+        length: 1,
+        contextRange: [
+          -1 * table.backtrackCoverage.length,
+          1 + table.lookaheadCoverage.length
+        ]
+      };
+    }
+  }
+
+  return result;
+}

package/src/fontLigatures/processors/classDef.ts

@@ -0,0 +1,84 @@
+import { ClassDefTable } from '../tables';
+
+/**
+ * Get the number of the class to which the glyph belongs, or null if it doesn't
+ * belong to any of them.
+ *
+ * @param table JSON representation of the class def table
+ * @param glyphId Index of the glyph to look for
+ */
+export default function getGlyphClass(table: ClassDefTable, glyphId: number | [number, number]): Map<number | [number, number], number | null> {
+  switch (table.format) {
+    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-2
+    case 2:
+      if (Array.isArray(glyphId)) {
+        return getRangeGlyphClass(table, glyphId);
+      }
+      return new Map([[
+        glyphId,
+        getIndividualGlyphClass(table, glyphId)
+      ]]);
+    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table-format-1
+    default:
+      return new Map([[glyphId, null]]);
+  }
+}
+
+function getRangeGlyphClass(table: ClassDefTable.IFormat2, glyphId: [number, number]): Map<number | [number, number], number | null> {
+  const classStart: number = glyphId[0];
+  const currentClass: number | null = getIndividualGlyphClass(table, classStart);
+  let search: number = glyphId[0] + 1;
+
+  const result = new Map<[number, number] | number, number | null>();
+
+  while (search < glyphId[1]) {
+    const clazz = getIndividualGlyphClass(table, search);
+    if (clazz !== currentClass) {
+      if (search - classStart <= 1) {
+        result.set(classStart, currentClass);
+      } else {
+        result.set([classStart, search], currentClass);
+      }
+    }
+    search++;
+  }
+
+  if (search - classStart <= 1) {
+    result.set(classStart, currentClass);
+  } else {
+    result.set([classStart, search], currentClass);
+  }
+
+  return result;
+}
+
+function getIndividualGlyphClass(table: ClassDefTable.IFormat2, glyphId: number): number | null {
+  for (const range of table.ranges) {
+    if (range.start <= glyphId && range.end >= glyphId) {
+      return range.classId;
+    }
+  }
+
+  return null;
+}
+
+export function listClassGlyphs(table: ClassDefTable, index: number): (number | [number, number])[] {
+  switch (table.format) {
+    case 2:
+      const results: (number | [number, number])[] = [];
+      for (const range of table.ranges) {
+        if (range.classId !== index) {
+          continue;
+        }
+
+        if (range.end === range.start) {
+          results.push(range.start);
+        } else {
+          results.push([range.start, range.end + 1]);
+        }
+      }
+      return results;
+    default:
+      return [];
+  }
+}

package/src/fontLigatures/processors/coverage.ts

@@ -0,0 +1,43 @@
+import { CoverageTable } from '../tables';
+
+/**
+ * Get the index of the given glyph in the coverage table, or null if it is not
+ * present in the table.
+ *
+ * @param table JSON representation of the coverage table
+ * @param glyphId Index of the glyph to look for
+ */
+export default function getCoverageGlyphIndex(table: CoverageTable, glyphId: number): number | null {
+  switch (table.format) {
+    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-1
+    case 1:
+      const index = table.glyphs.indexOf(glyphId);
+      return index !== -1
+        ? index
+        : null;
+    // https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-format-2
+    case 2:
+      const range = table.ranges
+        .find(range => range.start <= glyphId && range.end >= glyphId);
+      return range
+        ? range.index
+        : null;
+  }
+}
+
+export function listGlyphsByIndex(table: CoverageTable): { glyphId: number | [number, number], index: number }[] {
+  switch (table.format) {
+    case 1:
+      return table.glyphs.map((glyphId, index) => ({ glyphId, index }));
+    case 2:
+      const results: { glyphId: number | [number, number], index: number }[] = [];
+      for (const [index, range] of table.ranges.entries()) {
+        if (range.end === range.start) {
+          results.push({ glyphId: range.start, index });
+        } else {
+          results.push({ glyphId: [range.start, range.end + 1], index });
+        }
+      }
+      return results;
+  }
+}

package/src/fontLigatures/processors/helper.ts

@@ -0,0 +1,187 @@
+import { ILookupTreeEntry, ILookupTree } from '../types';
+import { ISubstitutionLookupRecord, Lookup } from '../tables';
+
+import { getIndividualSubstitutionGlyph, getRangeSubstitutionGlyphs } from './substitution';
+
+export interface IEntryMeta {
+  entry: ILookupTreeEntry;
+  substitutions: (number | null)[];
+}
+
+export function processInputPosition(
+  glyphs: (number | [number, number])[],
+  position: number,
+  currentEntries: IEntryMeta[],
+  lookupRecords: ISubstitutionLookupRecord[],
+  lookups: Lookup[]
+): IEntryMeta[] {
+  const nextEntries: IEntryMeta[] = [];
+  for (const currentEntry of currentEntries) {
+    currentEntry.entry.forward = {
+      individual: {},
+      range: []
+    };
+    for (const glyph of glyphs) {
+      nextEntries.push(...getInputTree(
+        currentEntry.entry.forward,
+        lookupRecords,
+        lookups,
+        position,
+        glyph
+      ).map(({ entry, substitution }) => ({
+        entry,
+        substitutions: [...currentEntry.substitutions, substitution]
+      })));
+    }
+  }
+
+  return nextEntries;
+}
+
+export function processLookaheadPosition(
+  glyphs: (number | [number, number])[],
+  currentEntries: IEntryMeta[]
+): IEntryMeta[] {
+  const nextEntries: IEntryMeta[] = [];
+  const processedEntries = new Set<ILookupTreeEntry>();
+
+  for (const currentEntry of currentEntries) {
+    // Skip if we've already processed this entry object
+    if (processedEntries.has(currentEntry.entry)) {
+      continue;
+    }
+    processedEntries.add(currentEntry.entry);
+
+    if (!currentEntry.entry.forward) {
+      currentEntry.entry.forward = {
+        individual: {},
+        range: []
+      };
+    }
+
+    // All glyphs at this position share ONE entry - lookahead just needs to match,
+    // all paths lead to the same result
+    const sharedEntry: ILookupTreeEntry = {};
+
+    for (const glyph of glyphs) {
+      if (Array.isArray(glyph)) {
+        currentEntry.entry.forward.range.push({
+          entry: sharedEntry,
+          range: glyph
+        });
+      } else {
+        currentEntry.entry.forward.individual[glyph] = sharedEntry;
+      }
+    }
+
+    nextEntries.push({
+      entry: sharedEntry,
+      substitutions: currentEntry.substitutions
+    });
+  }
+
+  return nextEntries;
+}
+
+export function processBacktrackPosition(
+  glyphs: (number | [number, number])[],
+  currentEntries: IEntryMeta[]
+): IEntryMeta[] {
+  const nextEntries: IEntryMeta[] = [];
+  const processedEntries = new Set<ILookupTreeEntry>();
+
+  for (const currentEntry of currentEntries) {
+    // Skip if we've already processed this entry object
+    if (processedEntries.has(currentEntry.entry)) {
+      continue;
+    }
+    processedEntries.add(currentEntry.entry);
+
+    if (!currentEntry.entry.reverse) {
+      currentEntry.entry.reverse = {
+        individual: {},
+        range: []
+      };
+    }
+
+    // All glyphs at this position share ONE entry - backtrack just needs to match,
+    // all paths lead to the same result
+    const sharedEntry: ILookupTreeEntry = {};
+
+    for (const glyph of glyphs) {
+      if (Array.isArray(glyph)) {
+        currentEntry.entry.reverse.range.push({
+          entry: sharedEntry,
+          range: glyph
+        });
+      } else {
+        currentEntry.entry.reverse.individual[glyph] = sharedEntry;
+      }
+    }
+
+    nextEntries.push({
+      entry: sharedEntry,
+      substitutions: currentEntry.substitutions
+    });
+  }
+
+  return nextEntries;
+}
+
+export function getInputTree(tree: ILookupTree, substitutions: ISubstitutionLookupRecord[], lookups: Lookup[], inputIndex: number, glyphId: number | [number, number]): { entry: ILookupTreeEntry, substitution: number | null }[] {
+  const result: { entry: ILookupTreeEntry, substitution: number | null }[] = [];
+  if (!Array.isArray(glyphId)) {
+    tree.individual[glyphId] = {};
+    result.push({
+      entry: tree.individual[glyphId],
+      substitution: getSubstitutionAtPosition(substitutions, lookups, inputIndex, glyphId)
+    });
+  } else {
+    const subs = getSubstitutionAtPositionRange(substitutions, lookups, inputIndex, glyphId);
+    for (const [range, substitution] of subs) {
+      const entry: ILookupTreeEntry = {};
+      if (Array.isArray(range)) {
+        tree.range.push({ range, entry });
+      } else {
+        tree.individual[range] = {};
+      }
+      result.push({ entry, substitution });
+    }
+  }
+
+  return result;
+}
+
+function getSubstitutionAtPositionRange(substitutions: ISubstitutionLookupRecord[], lookups: Lookup[], index: number, range: [number, number]): Map<number | [number, number], number | null> {
+  for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) {
+    for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.IType1).subtables) {
+      const sub = getRangeSubstitutionGlyphs(
+        substitutionTable,
+        range
+      );
+
+      if (!Array.from(sub.values()).every(val => val !== null)) {
+        return sub;
+      }
+    }
+  }
+
+  return new Map([[range, null]]);
+}
+
+function getSubstitutionAtPosition(substitutions: ISubstitutionLookupRecord[], lookups: Lookup[], index: number, glyphId: number): number | null {
+  for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) {
+    for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.IType1).subtables) {
+      const sub = getIndividualSubstitutionGlyph(
+        substitutionTable,
+        glyphId
+      );
+
+      if (sub !== null) {
+        return sub;
+      }
+    }
+  }
+
+  return null;
+}

package/src/fontLigatures/processors/substitution.ts

@@ -0,0 +1,62 @@
+import { SubstitutionTable } from '../tables';
+
+import getCoverageGlyphIndex from './coverage';
+
+/**
+ * Get the substitution glyph for the givne glyph, or null if the glyph was not
+ * found in the table.
+ *
+ * @param table JSON representation of the substitution table
+ * @param glyphId The index of the glpyh to find substitutions for
+ */
+export function getRangeSubstitutionGlyphs(table: SubstitutionTable, glyphId: [number, number]): Map<[number, number] | number, number | null> {
+  const replacementStart: number = glyphId[0];
+  const currentReplacement: number | null = getIndividualSubstitutionGlyph(table, replacementStart);
+  let search: number = glyphId[0] + 1;
+
+  const result = new Map<[number, number] | number, number | null>();
+
+  while (search < glyphId[1]) {
+    const sub = getIndividualSubstitutionGlyph(table, search);
+    if (sub !== currentReplacement) {
+      if (search - replacementStart <= 1) {
+        result.set(replacementStart, currentReplacement);
+      } else {
+        result.set([replacementStart, search], currentReplacement);
+      }
+    }
+
+    search++;
+  }
+
+  if (search - replacementStart <= 1) {
+    result.set(replacementStart, currentReplacement);
+  } else {
+    result.set([replacementStart, search], currentReplacement);
+  }
+
+  return result;
+}
+
+export function getIndividualSubstitutionGlyph(table: SubstitutionTable, glyphId: number): number | null {
+  const coverageIndex = getCoverageGlyphIndex(table.coverage, glyphId);
+
+  // istanbul ignore next - invalid font
+  if (coverageIndex === null) {
+    return null;
+  }
+
+  switch (table.substFormat) {
+    // https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#11-single-substitution-format-1
+    case 1:
+      // TODO: determine if there's a rhyme or reason to the 16-bit
+      // wraparound and if it can ever be a different number
+      return (glyphId + table.deltaGlyphId) % (2 ** 16);
+    // https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#12-single-substitution-format-2
+    case 2:
+      // eslint-disable-next-line eqeqeq
+      return table.substitute[coverageIndex] != null
+        ? table.substitute[coverageIndex]
+        : null;
+  }
+}

package/src/fontLigatures/tables.ts

@@ -0,0 +1,112 @@
+export type SubstitutionTable = SubstitutionTable.IFormat1 | SubstitutionTable.IFormat2;
+export namespace SubstitutionTable {
+  export interface IFormat1 {
+    substFormat: 1;
+    coverage: CoverageTable;
+    deltaGlyphId: number;
+  }
+
+  export interface IFormat2 {
+    substFormat: 2;
+    coverage: CoverageTable;
+    substitute: number[];
+  }
+}
+
+export type CoverageTable = CoverageTable.IFormat1 | CoverageTable.IFormat2;
+export namespace CoverageTable {
+  export interface IFormat1 {
+    format: 1;
+    glyphs: number[];
+  }
+
+  export interface IFormat2 {
+    format: 2;
+    ranges: {
+      start: number;
+      end: number;
+      index: number;
+    }[];
+  }
+}
+
+export type ChainingContextualSubstitutionTable = ChainingContextualSubstitutionTable.IFormat1 |
+  ChainingContextualSubstitutionTable.IFormat2 | ChainingContextualSubstitutionTable.IFormat3;
+export namespace ChainingContextualSubstitutionTable {
+  export interface IFormat1 {
+    substFormat: 1;
+    coverage: CoverageTable;
+    chainRuleSets: ChainSubRuleTable[][];
+  }
+
+  export interface IFormat2 {
+    substFormat: 2;
+    coverage: CoverageTable;
+    backtrackClassDef: ClassDefTable;
+    inputClassDef: ClassDefTable;
+    lookaheadClassDef: ClassDefTable;
+    chainClassSet: (null | IChainSubClassRuleTable[])[];
+  }
+
+  export interface IFormat3 {
+    substFormat: 3;
+    backtrackCoverage: CoverageTable[];
+    inputCoverage: CoverageTable[];
+    lookaheadCoverage: CoverageTable[];
+    lookupRecords: ISubstitutionLookupRecord[];
+  }
+}
+
+export interface IReverseChainingContextualSingleSubstitutionTable {
+  substFormat: 1;
+  coverage: CoverageTable;
+  backtrackCoverage: CoverageTable[];
+  lookaheadCoverage: CoverageTable[];
+  substitutes: number[];
+}
+
+export type ClassDefTable = ClassDefTable.IFormat2;
+export namespace ClassDefTable {
+  export interface IFormat2 {
+    format: 2;
+    ranges: {
+      start: number;
+      end: number;
+      classId: number;
+    }[];
+  }
+}
+
+export interface ISubstitutionLookupRecord {
+  sequenceIndex: number;
+  lookupListIndex: number;
+}
+
+export type ChainSubRuleTable = IChainSubClassRuleTable;
+export interface IChainSubClassRuleTable {
+  backtrack: number[];
+  input: number[];
+  lookahead: number[];
+  lookupRecords: ISubstitutionLookupRecord[];
+}
+
+export type Lookup = Lookup.IType1 | Lookup.IType6 | Lookup.IType8;
+export namespace Lookup {
+  export interface IType1 {
+    lookupType: 1;
+    lookupFlag: number;
+    subtables: SubstitutionTable[];
+  }
+
+  export interface IType6 {
+    lookupType: 6;
+    lookupFlag: number;
+    subtables: ChainingContextualSubstitutionTable[];
+  }
+
+  export interface IType8 {
+    lookupType: 8;
+    lookupFlag: number;
+    subtables: IReverseChainingContextualSingleSubstitutionTable[];
+  }
+}

package/src/fontLigatures/types.ts

@@ -0,0 +1,86 @@
+export interface ISubstitutionResult {
+  index: number;
+  contextRange: [number, number];
+}
+
+/**
+ * Information about ligatures found in a sequence of text
+ */
+export interface ILigatureData {
+  /**
+   * The list of font glyphs in the input text.
+   */
+  inputGlyphs: number[];
+
+  /**
+   * The list of font glyphs after performing replacements for font ligatures.
+   */
+  outputGlyphs: number[];
+
+  /**
+   * Sorted array of ranges that must be rendered together to produce the
+   * ligatures in the output sequence. The ranges are inclusive on the left and
+   * exclusive on the right.
+   */
+  contextRanges: [number, number][];
+}
+
+export interface IFont {
+  /**
+   * Scans the provided text for font ligatures, returning an object with
+   * metadata about the text and any ligatures found.
+   *
+   * @param text String to search for ligatures
+   */
+  findLigatures(text: string): ILigatureData;
+
+  /**
+   * Scans the provided text for font ligatures, returning an array of ranges
+   * where ligatures are located.
+   *
+   * @param text String to search for ligatures
+   */
+  findLigatureRanges(text: string): [number, number][];
+}
+
+export interface IOptions {
+  /**
+   * Optional size of previous results to store, measured in total number of
+   * characters from input strings. Defaults to no cache (0)
+   */
+  cacheSize?: number;
+}
+
+export interface ILookupTree {
+  individual: {
+    [glyphId: string]: ILookupTreeEntry;
+  };
+  range: {
+    range: [number, number];
+    entry: ILookupTreeEntry;
+  }[];
+}
+
+export interface ILookupTreeEntry {
+  lookup?: ILookupResult;
+  forward?: ILookupTree;
+  reverse?: ILookupTree;
+}
+
+export interface ILookupResult {
+  substitutions: (number | null)[];
+  length: number;
+  index: number;
+  subIndex: number;
+  contextRange: [number, number];
+}
+
+export interface IFlattenedLookupTree {
+  [glyphId: string]: IFlattenedLookupTreeEntry;
+}
+
+export interface IFlattenedLookupTreeEntry {
+  lookup?: ILookupResult;
+  forward?: IFlattenedLookupTree;
+  reverse?: IFlattenedLookupTree;
+}