From 363fc84fd27933111893199ff45a100c573cbc6d Mon Sep 17 00:00:00 2001 From: Daniel Imms <2193314+Tyriar@users.noreply.github.com> Date: Sat, 3 Jan 2026 09:02:06 -0800 Subject: [PATCH 1/4] Merge font-ligatures into addon-ligatures Fixes #5568 --- addons/addon-ligatures/LICENSE | 26 +- addons/addon-ligatures/package.json | 7 +- addons/addon-ligatures/src/font.ts | 2 +- .../src/fontLigatures/flatten.ts | 35 ++ .../src/fontLigatures/index.ts | 262 ++++++++++++ .../src/fontLigatures/merge.ts | 372 ++++++++++++++++++ .../src/fontLigatures/mergeRange.ts | 64 +++ .../src/fontLigatures/processors/6-1.ts | 82 ++++ .../src/fontLigatures/processors/6-2.ts | 96 +++++ .../src/fontLigatures/processors/6-3.ts | 73 ++++ .../src/fontLigatures/processors/8-1.ts | 69 ++++ .../src/fontLigatures/processors/classDef.ts | 85 ++++ .../src/fontLigatures/processors/coverage.ts | 43 ++ .../src/fontLigatures/processors/helper.ts | 163 ++++++++ .../fontLigatures/processors/substitution.ts | 62 +++ .../src/fontLigatures/tables.ts | 112 ++++++ .../src/fontLigatures/types.ts | 86 ++++ .../addon-ligatures/src/fontLigatures/walk.ts | 67 ++++ addons/addon-ligatures/src/index.ts | 2 +- addons/addon-ligatures/test/index.test.ts | 360 +++++++++++++++++ addons/addon-ligatures/test/merge.test.ts | 226 +++++++++++ .../addon-ligatures/test/mergeRange.test.ts | 50 +++ addons/addon-ligatures/test/parse.test.ts | 2 +- package-lock.json | 74 ++-- 24 files changed, 2383 insertions(+), 37 deletions(-) create mode 100644 addons/addon-ligatures/src/fontLigatures/flatten.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/index.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/merge.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/mergeRange.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/6-1.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/6-2.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/6-3.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/8-1.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/classDef.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/coverage.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/helper.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/processors/substitution.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/tables.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/types.ts create mode 100644 addons/addon-ligatures/src/fontLigatures/walk.ts create mode 100644 addons/addon-ligatures/test/index.test.ts create mode 100644 addons/addon-ligatures/test/merge.test.ts create mode 100644 addons/addon-ligatures/test/mergeRange.test.ts diff --git a/addons/addon-ligatures/LICENSE b/addons/addon-ligatures/LICENSE index b442934b..b7ca5139 100644 --- a/addons/addon-ligatures/LICENSE +++ b/addons/addon-ligatures/LICENSE @@ -1,6 +1,30 @@ +Copyright (c) 2019, The xterm.js authors (https://github.com/xtermjs/xterm.js) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +--- + +The code that analyzes font ligatures is forked from https://github.com/princjef/font-ligatures with this license: + MIT License -Copyright (c) 2018 +Copyright (c) 2018 Jeffrey Principe Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/addons/addon-ligatures/package.json b/addons/addon-ligatures/package.json index 85a19c36..5150f383 100644 --- a/addons/addon-ligatures/package.json +++ b/addons/addon-ligatures/package.json @@ -32,11 +32,14 @@ ], "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/lru-cache": "^5.1.0", + "@types/opentype.js": "^0.7.0", "axios": "^1.6.0", + "font-finder": "^1.1.0", "mkdirp": "0.5.5", "yauzl": "^2.10.0" } diff --git a/addons/addon-ligatures/src/font.ts b/addons/addon-ligatures/src/font.ts index ed7910cf..196651ac 100644 --- a/addons/addon-ligatures/src/font.ts +++ b/addons/addon-ligatures/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'; diff --git a/addons/addon-ligatures/src/fontLigatures/flatten.ts b/addons/addon-ligatures/src/fontLigatures/flatten.ts new file mode 100644 index 00000000..38e99c3a --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/flatten.ts @@ -0,0 +1,35 @@ +import { LookupTree, FlattenedLookupTree, LookupTreeEntry, FlattenedLookupTreeEntry } from './types'; + +export default function flatten(tree: LookupTree): FlattenedLookupTree { + const result: FlattenedLookupTree = {}; + for (const [glyphId, entry] of Object.entries(tree.individual)) { + result[glyphId] = flattenEntry(entry); + } + + for (const { range, entry } of tree.range) { + const flattened = flattenEntry(entry); + for (let glyphId = range[0]; glyphId < range[1]; glyphId++) { + result[glyphId] = flattened; + } + } + + return result; +} + +function flattenEntry(entry: LookupTreeEntry): FlattenedLookupTreeEntry { + const result: FlattenedLookupTreeEntry = {}; + + if (entry.forward) { + result.forward = flatten(entry.forward); + } + + if (entry.reverse) { + result.reverse = flatten(entry.reverse); + } + + if (entry.lookup) { + result.lookup = entry.lookup; + } + + return result; +} diff --git a/addons/addon-ligatures/src/fontLigatures/index.ts b/addons/addon-ligatures/src/fontLigatures/index.ts new file mode 100644 index 00000000..e91eea92 --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/index.ts @@ -0,0 +1,262 @@ +import * as opentype from 'opentype.js'; +import LRUCache = require('lru-cache'); + +import { Font, LigatureData, FlattenedLookupTree, LookupTree, Options } 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 Font { + private _font: opentype.Font; + private _lookupTrees: { tree: FlattenedLookupTree; processForward: boolean; }[] = []; + private _glyphLookups: { [glyphId: string]: number[] } = {}; + private _cache?: LRUCache; + + constructor(font: opentype.Font, options: Required) { + this._font = font; + + if (options.cacheSize > 0) { + this._cache = new LRUCache({ + max: options.cacheSize, + length: ((val: LigatureData | [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: LookupTree[] = []; + 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); + } + } + } + + findLigatures(text: string): LigatureData { + 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: LigatureData = { + inputGlyphs: glyphIds, + outputGlyphs: result.sequence, + contextRanges: result.ranges + }; + if (this._cache) { + this._cache.set(text, finalResult); + } + + return finalResult; + } + + 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?: Options): Font { + const font = opentype.parse(buffer); + return new FontImpl(font, { + cacheSize: 0, + ...options + }); +} + +export { Font, LigatureData, Options }; diff --git a/addons/addon-ligatures/src/fontLigatures/merge.ts b/addons/addon-ligatures/src/fontLigatures/merge.ts new file mode 100644 index 00000000..d0b1f23e --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/merge.ts @@ -0,0 +1,372 @@ +import { LookupTree, LookupTreeEntry } 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: LookupTree[]): LookupTree { + const result: LookupTree = { + individual: {}, + range: [] + }; + + for (const tree of trees) { + mergeSubtree(result, tree); + } + + 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 + */ +function mergeSubtree(mainTree: LookupTree, mergeTree: LookupTree): 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); + } 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)); + + // 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: LookupTreeEntry = 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)); + + 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)); + + // 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)); + + // Update the remaining ranges + remainingRanges.splice(remainingIndex, 1, ...overlap.second); + break; + } else { + if (Number(glyphId) === remainingRange) { + mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry)); + 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 + */ +function mergeTreeEntry(mainTree: LookupTreeEntry, mergeTree: LookupTreeEntry): void { + 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); + } + } + + if (mergeTree.reverse) { + if (!mainTree.reverse) { + mainTree.reverse = mergeTree.reverse; + } else { + mergeSubtree(mainTree.reverse, mergeTree.reverse); + } + } +} + +interface Overlap { + 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]): Overlap { + const result: Overlap = { + 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]): Overlap { + // Disjoint + if (first < second[0] || first > second[1]) { + return { + first: [first], + second: [second], + both: null + }; + } + + const result: Overlap = { + 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; + } else { + return [start, end]; + } +} + +/** + * Clones an individual lookup tree entry. + * + * @param entry Lookup tree entry to clone + */ +function cloneEntry(entry: LookupTreeEntry): LookupTreeEntry { + const result: LookupTreeEntry = {}; + + if (entry.forward) { + result.forward = cloneTree(entry.forward); + } + + if (entry.reverse) { + result.reverse = cloneTree(entry.reverse); + } + + 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 + */ +function cloneTree(tree: LookupTree): LookupTree { + const individual: { [glyphId: string]: LookupTreeEntry; } = {}; + for (const [glyphId, entry] of Object.entries(tree.individual)) { + individual[glyphId] = cloneEntry(entry); + } + + return { + individual, + range: tree.range.map(({ range, entry }) => ({ + range: range.slice() as [number, number], + entry: cloneEntry(entry) + })) + }; +} diff --git a/addons/addon-ligatures/src/fontLigatures/mergeRange.ts b/addons/addon-ligatures/src/fontLigatures/mergeRange.ts new file mode 100644 index 00000000..7c872a8a --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/mergeRange.ts @@ -0,0 +1,64 @@ +/** + * 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; + } else 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; + } else 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; + } else 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; + } else { + // 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; +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts new file mode 100644 index 00000000..2f0dad18 --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts @@ -0,0 +1,82 @@ +import { ChainingContextualSubstitutionTable, Lookup } from '../tables'; +import { LookupTree } from '../types'; + +import { listGlyphsByIndex } from './coverage'; +import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, EntryMeta } 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.Format1, lookups: Lookup[], tableIndex: number): LookupTree { + const result: LookupTree = { + 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: EntryMeta[] = 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; +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts new file mode 100644 index 00000000..9cd8eaf3 --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts @@ -0,0 +1,96 @@ +import { ChainingContextualSubstitutionTable, Lookup } from '../tables'; +import { LookupTree } from '../types'; +import mergeTrees from '../merge'; + +import { listGlyphsByIndex } from './coverage'; +import getGlyphClass, { listClassGlyphs } from './classDef'; +import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, EntryMeta } 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.Format2, lookups: Lookup[], tableIndex: number): LookupTree { + const results: LookupTree[] = []; + + 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: LookupTree = { + individual: {}, + range: [] + }; + + let currentEntries: EntryMeta[] = 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); +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts new file mode 100644 index 00000000..fc671e7b --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts @@ -0,0 +1,73 @@ +import { ChainingContextualSubstitutionTable, Lookup } from '../tables'; +import { LookupTree } from '../types'; + +import { listGlyphsByIndex } from './coverage'; +import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, EntryMeta } 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.Format3, lookups: Lookup[], tableIndex: number): LookupTree { + const result: LookupTree = { + individual: {}, + range: [] + }; + + const firstGlyphs = listGlyphsByIndex(table.inputCoverage[0]); + + for (const { glyphId } of firstGlyphs) { + let currentEntries: EntryMeta[] = 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; +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts b/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts new file mode 100644 index 00000000..620d2e20 --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts @@ -0,0 +1,69 @@ +import { ReverseChainingContextualSingleSubstitutionTable } from '../tables'; +import { LookupTree, LookupTreeEntry } from '../types'; + +import { listGlyphsByIndex } from './coverage'; +import { processLookaheadPosition, processBacktrackPosition, EntryMeta } 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: ReverseChainingContextualSingleSubstitutionTable, tableIndex: number): LookupTree { + const result: LookupTree = { + individual: {}, + range: [] + }; + + const glyphs = listGlyphsByIndex(table.coverage); + + for (const { glyphId, index } of glyphs) { + const initialEntry: LookupTreeEntry = {}; + if (Array.isArray(glyphId)) { + result.range.push({ + entry: initialEntry, + range: glyphId + }); + } else { + result.individual[glyphId] = initialEntry; + } + + let currentEntries: EntryMeta[] = [{ + 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; +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts b/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts new file mode 100644 index 00000000..3f2dc21e --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts @@ -0,0 +1,85 @@ +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 { + 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); + } else { + 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.Format2, glyphId: [number, number]): Map { + let classStart: number = glyphId[0]; + let 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.Format2, 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 []; + } +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts b/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts new file mode 100644 index 00000000..0ee3f42d --- /dev/null +++ b/addons/addon-ligatures/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: + let 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; + } +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/helper.ts b/addons/addon-ligatures/src/fontLigatures/processors/helper.ts new file mode 100644 index 00000000..7186a22d --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/processors/helper.ts @@ -0,0 +1,163 @@ +import { LookupTreeEntry, LookupTree } from '../types'; +import { SubstitutionLookupRecord, Lookup } from '../tables'; + +import { getIndividualSubstitutionGlyph, getRangeSubstitutionGlyphs } from './substitution'; + +export interface EntryMeta { + entry: LookupTreeEntry; + substitutions: (number | null)[]; +} + +export function processInputPosition( + glyphs: (number | [number, number])[], + position: number, + currentEntries: EntryMeta[], + lookupRecords: SubstitutionLookupRecord[], + lookups: Lookup[] +): EntryMeta[] { + const nextEntries: EntryMeta[] = []; + 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: EntryMeta[] +): EntryMeta[] { + const nextEntries: EntryMeta[] = []; + for (const currentEntry of currentEntries) { + for (const glyph of glyphs) { + const entry: LookupTreeEntry = {}; + if (!currentEntry.entry.forward) { + currentEntry.entry.forward = { + individual: {}, + range: [] + }; + } + nextEntries.push({ + entry, + substitutions: currentEntry.substitutions + }); + + if (Array.isArray(glyph)) { + currentEntry.entry.forward.range.push({ + entry, + range: glyph + }); + } else { + currentEntry.entry.forward.individual[glyph] = entry; + } + } + } + + return nextEntries; +} + +export function processBacktrackPosition( + glyphs: (number | [number, number])[], + currentEntries: EntryMeta[] +): EntryMeta[] { + const nextEntries: EntryMeta[] = []; + for (const currentEntry of currentEntries) { + for (const glyph of glyphs) { + const entry: LookupTreeEntry = {}; + if (!currentEntry.entry.reverse) { + currentEntry.entry.reverse = { + individual: {}, + range: [] + }; + } + nextEntries.push({ + entry, + substitutions: currentEntry.substitutions + }); + + if (Array.isArray(glyph)) { + currentEntry.entry.reverse.range.push({ + entry, + range: glyph + }); + } else { + currentEntry.entry.reverse.individual[glyph] = entry; + } + } + } + + return nextEntries; +} + +export function getInputTree(tree: LookupTree, substitutions: SubstitutionLookupRecord[], lookups: Lookup[], inputIndex: number, glyphId: number | [number, number]): { entry: LookupTreeEntry; substitution: number | null; }[] { + const result: { entry: LookupTreeEntry; 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: LookupTreeEntry = {}; + if (Array.isArray(range)) { + tree.range.push({ range, entry }); + } else { + tree.individual[range] = {}; + } + result.push({ entry, substitution }); + } + } + + return result; +} + +function getSubstitutionAtPositionRange(substitutions: SubstitutionLookupRecord[], lookups: Lookup[], index: number, range: [number, number]): Map { + for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) { + for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.Type1).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: SubstitutionLookupRecord[], 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.Type1).subtables) { + const sub = getIndividualSubstitutionGlyph( + substitutionTable, + glyphId + ); + + if (sub !== null) { + return sub; + } + } + } + + return null; +} diff --git a/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts b/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts new file mode 100644 index 00000000..975d7a25 --- /dev/null +++ b/addons/addon-ligatures/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> { + let replacementStart: number = glyphId[0]; + let 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: + // tslint:disable-next-line + return table.substitute[coverageIndex] != null + ? table.substitute[coverageIndex] + : null; + } +} diff --git a/addons/addon-ligatures/src/fontLigatures/tables.ts b/addons/addon-ligatures/src/fontLigatures/tables.ts new file mode 100644 index 00000000..d3eccd08 --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/tables.ts @@ -0,0 +1,112 @@ +export type SubstitutionTable = SubstitutionTable.Format1 | SubstitutionTable.Format2; +export namespace SubstitutionTable { + export interface Format1 { + substFormat: 1; + coverage: CoverageTable; + deltaGlyphId: number; + } + + export interface Format2 { + substFormat: 2; + coverage: CoverageTable; + substitute: number[]; + } +} + +export type CoverageTable = CoverageTable.Format1 | CoverageTable.Format2; +export namespace CoverageTable { + export interface Format1 { + format: 1; + glyphs: number[]; + } + + export interface Format2 { + format: 2; + ranges: { + start: number; + end: number; + index: number; + }[]; + } +} + +export type ChainingContextualSubstitutionTable = ChainingContextualSubstitutionTable.Format1 | + ChainingContextualSubstitutionTable.Format2 | ChainingContextualSubstitutionTable.Format3; +export namespace ChainingContextualSubstitutionTable { + export interface Format1 { + substFormat: 1; + coverage: CoverageTable; + chainRuleSets: ChainSubRuleTable[][]; + } + + export interface Format2 { + substFormat: 2; + coverage: CoverageTable; + backtrackClassDef: ClassDefTable; + inputClassDef: ClassDefTable; + lookaheadClassDef: ClassDefTable; + chainClassSet: (null | ChainSubClassRuleTable[])[]; + } + + export interface Format3 { + substFormat: 3; + backtrackCoverage: CoverageTable[]; + inputCoverage: CoverageTable[]; + lookaheadCoverage: CoverageTable[]; + lookupRecords: SubstitutionLookupRecord[]; + } +} + +export interface ReverseChainingContextualSingleSubstitutionTable { + substFormat: 1; + coverage: CoverageTable; + backtrackCoverage: CoverageTable[]; + lookaheadCoverage: CoverageTable[]; + substitutes: number[]; +} + +export type ClassDefTable = ClassDefTable.Format2; +export namespace ClassDefTable { + export interface Format2 { + format: 2; + ranges: { + start: number; + end: number; + classId: number; + }[]; + } +} + +export interface SubstitutionLookupRecord { + sequenceIndex: number; + lookupListIndex: number; +} + +export type ChainSubRuleTable = ChainSubClassRuleTable; +export interface ChainSubClassRuleTable { + backtrack: number[]; + input: number[]; + lookahead: number[]; + lookupRecords: SubstitutionLookupRecord[]; +} + +export type Lookup = Lookup.Type1 | Lookup.Type6 | Lookup.Type8; +export namespace Lookup { + export interface Type1 { + lookupType: 1; + lookupFlag: number; + subtables: SubstitutionTable[]; + } + + export interface Type6 { + lookupType: 6; + lookupFlag: number; + subtables: ChainingContextualSubstitutionTable[]; + } + + export interface Type8 { + lookupType: 8; + lookupFlag: number; + subtables: ReverseChainingContextualSingleSubstitutionTable[]; + } +} diff --git a/addons/addon-ligatures/src/fontLigatures/types.ts b/addons/addon-ligatures/src/fontLigatures/types.ts new file mode 100644 index 00000000..9364c75c --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/types.ts @@ -0,0 +1,86 @@ +export interface SubstitutionResult { + index: number; + contextRange: [number, number]; +} + +/** + * Information about ligatures found in a sequence of text + */ +export interface LigatureData { + /** + * 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 Font { + /** + * 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): LigatureData; + + /** + * 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 Options { + /** + * 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 LookupTree { + individual: { + [glyphId: string]: LookupTreeEntry; + }; + range: { + range: [number, number]; + entry: LookupTreeEntry; + }[]; +} + +export interface LookupTreeEntry { + lookup?: LookupResult; + forward?: LookupTree; + reverse?: LookupTree; +} + +export interface LookupResult { + substitutions: (number | null)[]; + length: number; + index: number; + subIndex: number; + contextRange: [number, number]; +} + +export interface FlattenedLookupTree { + [glyphId: string]: FlattenedLookupTreeEntry; +} + +export interface FlattenedLookupTreeEntry { + lookup?: LookupResult; + forward?: FlattenedLookupTree; + reverse?: FlattenedLookupTree; +} diff --git a/addons/addon-ligatures/src/fontLigatures/walk.ts b/addons/addon-ligatures/src/fontLigatures/walk.ts new file mode 100644 index 00000000..56d6eac1 --- /dev/null +++ b/addons/addon-ligatures/src/fontLigatures/walk.ts @@ -0,0 +1,67 @@ +import { FlattenedLookupTree, LookupResult } from './types'; + +export default function walkTree(tree: FlattenedLookupTree, sequence: number[], startIndex: number, index: number): LookupResult | undefined { + const glyphId = sequence[index]; + let subtree = tree[glyphId]; + if (!subtree) { + return undefined; + } + + let lookup = subtree.lookup; + if (subtree.reverse) { + const reverseLookup = walkReverse(subtree.reverse, sequence, startIndex); + + if ( + (!lookup && reverseLookup) || + ( + reverseLookup && lookup && ( + lookup.index > reverseLookup.index || + (lookup.index === reverseLookup.index && lookup.subIndex > reverseLookup.subIndex) + ) + ) + ) { + lookup = reverseLookup; + } + } + + if (++index >= sequence.length || !subtree.forward) { + return lookup; + } + + const forwardLookup = walkTree(subtree.forward, sequence, startIndex, index); + + if ( + (!lookup && forwardLookup) || + ( + forwardLookup && lookup && ( + lookup.index > forwardLookup.index || + (lookup.index === forwardLookup.index && lookup.subIndex > forwardLookup.subIndex) + ) + ) + ) { + lookup = forwardLookup; + } + + return lookup; +} + +function walkReverse(tree: FlattenedLookupTree, sequence: number[], index: number): LookupResult | undefined { + let subtree = tree[sequence[--index]]; + let lookup: LookupResult | undefined = subtree && subtree.lookup; + while (subtree) { + if ( + (!lookup && subtree.lookup) || + (subtree.lookup && lookup && lookup.index > subtree.lookup.index) + ) { + lookup = subtree.lookup; + } + + if (--index < 0 || !subtree.reverse) { + break; + } + + subtree = subtree.reverse[sequence[index]]; + } + + return lookup; +} diff --git a/addons/addon-ligatures/src/index.ts b/addons/addon-ligatures/src/index.ts index bd8ff215..0c67f510 100644 --- a/addons/addon-ligatures/src/index.ts +++ b/addons/addon-ligatures/src/index.ts @@ -4,7 +4,7 @@ */ import type { Terminal } from '@xterm/xterm'; -import { Font } from 'font-ligatures'; +import { Font } from './fontLigatures/index'; import load from './font'; diff --git a/addons/addon-ligatures/test/index.test.ts b/addons/addon-ligatures/test/index.test.ts new file mode 100644 index 00000000..ecef7661 --- /dev/null +++ b/addons/addon-ligatures/test/index.test.ts @@ -0,0 +1,360 @@ +/** + * Copyright (c) 2018 The xterm.js authors. All rights reserved. + * @license MIT + */ + +import * as path from 'path'; +import * as fs from 'fs'; +import { assert } from 'chai'; + +const fontLigatures = require('../out-esbuild/fontLigatures/index'); +const loadBuffer: (buffer: ArrayBuffer, options?: { cacheSize?: number }) => Font = fontLigatures.loadBuffer; + +interface Font { + findLigatures(text: string): { outputGlyphs: number[]; contextRanges: [number, number][] }; + findLigatureRanges(text: string): [number, number][]; +} + +interface TestCase { + font: string; + input: string; + glyphs: number[]; + ranges: [number, number][]; +} + +const fira = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => + ({ font: 'Fira Code', input, glyphs, ranges }); + +const iosevka = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => + ({ font: 'Iosevka', input, glyphs, ranges }); + +const monoid = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => + ({ font: 'Monoid', input, glyphs, ranges }); + +const ubuntu = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => + ({ font: 'Ubuntu Mono', input, glyphs, ranges }); + +const firaCases: TestCase[] = [ + fira('abc', [133, 145, 146], []), + fira('.=', [1614, 1081], [[0, 2]]), + fira('..=', [1614, 1614, 1083], [[0, 3]]), + fira('.-', [1614, 1080], [[0, 2]]), + fira(':=', [1614, 1055], [[0, 2]]), + fira('=:=', [1614, 1614, 1483], [[0, 3]]), + fira('=!=', [1614, 1614, 1484], [[0, 3]]), + fira('__', [1614, 1099], [[0, 2]]), + fira('==', [1614, 1485], [[0, 2]]), + fira('!=', [1614, 1058], [[0, 2]]), + fira('===', [1614, 1614, 1486], [[0, 3]]), + fira('!==', [1614, 1614, 1059], [[0, 3]]), + fira('=/=', [1614, 1614, 1491], [[0, 3]]), + fira('<-<', [1614, 1614, 1513], [[0, 3]]), + fira('<<-', [1614, 1614, 1522], [[0, 3]]), + fira('<--', [1614, 1614, 1511], [[0, 3]]), + fira('<-', [1614, 1510], [[0, 2]]), + fira('<->', [1614, 1614, 1512], [[0, 3]]), + fira('->', [1614, 1064], [[0, 2]]), + fira('-->', [1614, 1614, 1063], [[0, 3]]), + fira('->>', [1614, 1614, 1065], [[0, 3]]), + fira('>->', [1614, 1614, 1493], [[0, 3]]), + fira('<=<', [1614, 1614, 1519], [[0, 3]]), + fira('<<=', [1614, 1614, 1523], [[0, 3]]), + fira('<==', [1614, 1614, 1517], [[0, 3]]), + fira('<=>', [1614, 1614, 1518], [[0, 3]]), + fira('=>', [1614, 1488], [[0, 2]]), + fira('==>', [1614, 1614, 1487], [[0, 3]]), + fira('=>>', [1614, 1614, 1489], [[0, 3]]), + fira('>=>', [1614, 1614, 1495], [[0, 3]]), + fira('>>=', [1614, 1614, 1498], [[0, 3]]), + fira('>>-', [1614, 1614, 1497], [[0, 3]]), + fira('>-', [1614, 1492], [[0, 2]]), + fira('<~>', [1614, 1614, 1526], [[0, 3]]), + fira('-<', [1614, 1066], [[0, 2]]), + fira('-<<', [1614, 1614, 1067], [[0, 3]]), + fira('=<<', [1614, 1614, 1490], [[0, 3]]), + fira('<~~', [1614, 1614, 1527], [[0, 3]]), + fira('<~', [1614, 1525], [[0, 2]]), + fira('~~', [1614, 1534], [[0, 2]]), + fira('~>', [1614, 1533], [[0, 2]]), + fira('~~>', [1614, 1614, 1535], [[0, 3]]), + fira('<<<', [1614, 1614, 1524], [[0, 3]]), + fira('<<', [1614, 1521], [[0, 2]]), + fira('<=', [1614, 1516], [[0, 2]]), + fira('<>', [1614, 1520], [[0, 2]]), + fira('>=', [1614, 1494], [[0, 2]]), + fira('>>', [1614, 1496], [[0, 2]]), + fira('>>>', [1614, 1614, 1499], [[0, 3]]), + fira('{.', [1001, 977], [[0, 2]]), + fira('{|', [1614, 1049], [[0, 2]]), + fira('[|', [1614, 1050], [[0, 2]]), + fira('<:', [1614, 1506], [[0, 2]]), + fira(':>', [1614, 1056], [[0, 2]]), + fira('|]', [1614, 1474], [[0, 2]]), + fira('|}', [1614, 1473], [[0, 2]]), + fira('.}', [977, 1002], [[0, 2]]), + fira('<|||', [1614, 1614, 1614, 1504], [[0, 4]]), + fira('<||', [1614, 1614, 1503], [[0, 3]]), + fira('<|', [1614, 1502], [[0, 2]]), + fira('<|>', [1614, 1614, 1505], [[0, 3]]), + fira('|>', [1614, 1477], [[0, 2]]), + fira('||>', [1614, 1614, 1472], [[0, 3]]), + fira('|||>', [1614, 1614, 1614, 1470], [[0, 4]]), + fira('<$', [1614, 1507], [[0, 2]]), + fira('<$>', [1614, 1614, 1508], [[0, 3]]), + fira('$>', [1614, 1479], [[0, 2]]), + fira('<+', [1614, 1514], [[0, 2]]), + fira('<+>', [1614, 1614, 1515], [[0, 3]]), + fira('+>', [1614, 1482], [[0, 2]]), + fira('<*', [1614, 1500], [[0, 2]]), + fira('<*>', [1614, 1614, 1501], [[0, 3]]), + fira('*>', [1614, 1047], [[0, 2]]), + fira('/*', [1614, 1092], [[0, 2]]), + fira('*/', [1614, 1048], [[0, 2]]), + fira('///', [1614, 1614, 1097], [[0, 3]]), + fira('//', [1614, 1096], [[0, 2]]), + fira('', [1614, 1614, 1529], [[0, 3]]), + fira('/>', [1614, 1095], [[0, 2]]), + fira('0xff', [895, 270, 166, 166], [[0, 3]]), + fira('10x10', [896, 895, 270, 896, 895], [[1, 4]]), + fira('9:45', [904, 998, 899, 900], [[0, 2]]), + fira('[:]', [1003, 998, 1004], [[0, 2]]), + fira(';;', [1614, 1091], [[0, 2]]), + fira('::', [1614, 1052], [[0, 2]]), + fira(':::', [1614, 1614, 1053], [[0, 3]]), + fira('..', [1614, 1082], [[0, 2]]), + fira('...', [1614, 1614, 1085], [[0, 3]]), + fira('..<', [1614, 1614, 1084], [[0, 3]]), + fira('!!', [1614, 1057], [[0, 2]]), + fira('??', [1614, 1090], [[0, 2]]), + fira('%%', [1614, 1536], [[0, 2]]), + fira('&&', [1614, 1468], [[0, 2]]), + fira('||', [1614, 1469], [[0, 2]]), + fira('?.', [1614, 1089], [[0, 2]]), + fira('?:', [1614, 1087], [[0, 2]]), + fira('++', [1614, 1480], [[0, 2]]), + fira('+++', [1614, 1614, 1481], [[0, 3]]), + fira('--', [1614, 1061], [[0, 2]]), + fira('---', [1614, 1614, 1062], [[0, 3]]), + fira('**', [1614, 1045], [[0, 2]]), + fira('***', [1614, 1614, 1046], [[0, 3]]), + fira('~=', [1614, 1532], [[0, 2]]), + fira('~-', [1614, 1531], [[0, 2]]), + fira('www', [1614, 1614, 271], [[0, 3]]), + fira('-~', [1614, 1068], [[0, 2]]), + fira('~@', [1614, 1530], [[0, 2]]), + fira('^=', [1614, 1478], [[0, 2]]), + fira('?=', [1614, 1088], [[0, 2]]), + fira('/=', [1614, 1093], [[0, 2]]), + fira('/==', [1614, 1614, 1094], [[0, 3]]), + fira('-|', [1614, 1060], [[0, 2]]), + fira('_|_', [1614, 1614, 1098], [[0, 3]]), + fira('|-', [1614, 1475], [[0, 2]]), + fira('|=', [1614, 1476], [[0, 2]]), + fira('||=', [1614, 1614, 1471], [[0, 3]]), + fira('#!', [1614, 1071], [[0, 2]]), + fira('#=', [1614, 1075], [[0, 2]]), + fira('##', [1614, 1072], [[0, 2]]), + fira('###', [1614, 1614, 1073], [[0, 3]]), + fira('####', [1614, 1614, 1614, 1074], [[0, 4]]), + fira('#{', [1614, 1069], [[0, 2]]), + fira('#[', [1614, 1070], [[0, 2]]), + fira(']#', [1614, 1051], [[0, 2]]), + fira('#(', [1614, 1076], [[0, 2]]), + fira('#?', [1614, 1077], [[0, 2]]), + fira('#_', [1614, 1078], [[0, 2]]), + fira('#_(', [1614, 1614, 1079], [[0, 3]]), + fira('::=', [1614, 1614, 1054], [[0, 3]]), + fira('.?', [1614, 1086], [[0, 2]]), + fira('===>', [1614, 1614, 1486, 1148], [[0, 4]]) +]; + +const iosevkaCases: TestCase[] = [ + iosevka('<-', [31, 3127], [[0, 2]]), + iosevka('<--', [31, 3129, 3139], [[0, 3]]), + iosevka('<---', [31, 3129, 3150, 3139], [[0, 4]]), + iosevka('<-----', [31, 3129, 3150, 3139, 3151, 3151], [[0, 6]]), + iosevka('->', [3126, 33], [[0, 2]]), + iosevka('-->', [3140, 3128, 33], [[0, 3]]), + iosevka('--->', [3140, 3150, 3128, 33], [[0, 4]]), + iosevka('----->', [3153, 3153, 3140, 3150, 3128, 33], [[0, 6]]), + iosevka('<->', [31, 3149, 33], [[0, 3]]), + iosevka('<-->', [31, 3129, 3128, 33], [[0, 4]]), + iosevka('<--->', [31, 3129, 3150, 3128, 33], [[0, 5]]), + iosevka('<----->', [31, 3129, 3150, 3150, 3150, 3128, 33], [[0, 7]]), + iosevka('<=', [3094, 3095], [[0, 2]]), + iosevka('<==', [31, 3158, 3168], [[0, 3]]), + iosevka('<===', [31, 3158, 3179, 3168], [[0, 4]]), + iosevka('<=====', [31, 3158, 3179, 3168, 3180, 3180], [[0, 6]]), + iosevka('=>', [3155, 33], [[0, 2]]), + iosevka('==>', [3169, 3157, 33], [[0, 3]]), + iosevka('===>', [3169, 3179, 3157, 33], [[0, 4]]), + iosevka('=====>', [3182, 3182, 3169, 3179, 3157, 33], [[0, 6]]), + iosevka('<=>', [31, 3178, 33], [[0, 3]]), + iosevka('<==>', [31, 3158, 3157, 33], [[0, 4]]), + iosevka('<===>', [31, 3158, 3179, 3157, 33], [[0, 5]]), + iosevka('<=====>', [31, 3158, 3179, 3179, 3179, 3157, 33], [[0, 7]]), + iosevka('', [779, 779, 628], [[0, 3]]), + monoid('<--', [776, 776, 627], [[0, 3]]), + monoid('->>', [780, 780, 626], [[0, 3]]), + monoid('<<-', [777, 777, 625], [[0, 3]]), + monoid('->', [781, 623], [[0, 2]]), + monoid('<-', [778, 624], [[0, 2]]), + monoid('=>', [793, 666], [[0, 2]]), + monoid('<=>', [785, 785, 760], [[0, 3]]), + monoid('<==>', [786, 786, 786, 771], [[0, 4]]), + monoid('==>', [787, 787, 672], [[0, 3]]), + monoid('<==', [788, 788, 671], [[0, 3]]), + monoid('>>=', [791, 791, 758], [[0, 3]]), + monoid('=<<', [792, 792, 759], [[0, 3]]), + monoid('--', [667, 667], [[0, 2]]), + monoid(':=', [29, 761], [[0, 2]]), + monoid('=:=', [789, 789, 665], [[0, 3]]), + monoid('==', [794, 641], [[0, 2]]), + monoid('!==', [782, 782, 646], [[0, 3]]), + monoid('!=', [783, 629], [[0, 2]]), + monoid('<=', [790, 630], [[0, 2]]), + monoid('>=', [792, 631], [[0, 2]]), + monoid('//', [621, 664], [[0, 2]]), + monoid('/**', [18, 753, 753], [[0, 3]]), + monoid('/*', [18, 753], [[0, 2]]), + monoid('*/', [754, 18], [[0, 2]]), + monoid('&&', [633, 775], [[0, 2]]), + monoid('.&', [17, 755], [[0, 2]]), + monoid('||', [634, 635], [[0, 2]]), + monoid('!!', [769, 770], [[0, 2]]), + monoid('::', [772, 773], [[0, 2]]), + monoid('>>', [637, 638], [[0, 2]]), + monoid('<<', [639, 640], [[0, 2]]), + monoid('¯\\_(ツ)_/¯', [113, 765, 66, 767, 613, 768, 66, 766, 113], [[0, 3], [3, 6], [6, 9]]), + monoid('__', [763, 764], [[0, 2]]) +]; + +const ubuntuCases: TestCase[] = [ + ubuntu('==>', [32, 32, 33], []) +]; + +const fontPaths: Record = { + 'Fira Code': path.join(__dirname, '../fonts/FiraCode-Regular.otf'), + 'Iosevka': path.join(__dirname, '../fonts/iosevka-regular.ttf'), + 'Monoid': path.join(__dirname, '../fonts/Monoid-Regular.ttf'), + 'Ubuntu Mono': path.join(__dirname, '../fonts/UbuntuMono-Regular.ttf') +}; + +const fontCache: Map = new Map(); + +function loadFont(fontName: string): Font { + let font = fontCache.get(fontName); + if (!font) { + const fontPath = fontPaths[fontName]; + const buffer = fs.readFileSync(fontPath); + font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)); + fontCache.set(fontName, font); + } + return font; +} + +describe('addon-ligatures - index', () => { + describe('findLigatures', () => { + for (const { font: fontName, input, glyphs, ranges } of [...firaCases, ...iosevkaCases, ...monoidCases, ...ubuntuCases]) { + it(`${fontName}: '${input}'`, () => { + const font = loadFont(fontName); + const result = font.findLigatures(input); + assert.deepEqual(result.outputGlyphs, glyphs); + assert.deepEqual(result.contextRanges, ranges); + }); + } + }); + + describe('findLigatureRanges', () => { + for (const { font: fontName, input, ranges } of [...firaCases, ...iosevkaCases, ...monoidCases, ...ubuntuCases]) { + it(`${fontName}: '${input}'`, () => { + const font = loadFont(fontName); + const result = font.findLigatureRanges(input); + assert.deepEqual(result, ranges); + }); + } + }); + + describe('caching', () => { + it('findLigatures caches successive calls correctly', () => { + const fontPath = fontPaths['Fira Code']; + const buffer = fs.readFileSync(fontPath); + const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 }); + const result1 = font.findLigatures('in --> out'); + const result2 = font.findLigatures('in --> out'); + assert.deepEqual(result1, result2); + }); + + it('findLigatureRanges caches successive calls correctly', () => { + const fontPath = fontPaths['Fira Code']; + const buffer = fs.readFileSync(fontPath); + const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 }); + const result1 = font.findLigatureRanges('in --> out'); + const result2 = font.findLigatureRanges('in --> out'); + assert.deepEqual(result1, result2); + }); + + it('caches calls to findLigatures after findLigatureRanges correctly', () => { + const fontPath = fontPaths['Fira Code']; + const buffer = fs.readFileSync(fontPath); + + const uncached = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)); + const uncachedResult1 = uncached.findLigatureRanges('in --> out'); + const uncachedResult2 = uncached.findLigatures('in --> out'); + + const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 }); + const result1 = font.findLigatureRanges('in --> out'); + const result2 = font.findLigatures('in --> out'); + + assert.deepEqual(result1, uncachedResult1); + assert.deepEqual(result2, uncachedResult2); + assert.deepEqual(result1, result2.contextRanges); + }); + + it('caches calls to findLigatureRanges after findLigatures correctly', () => { + const fontPath = fontPaths['Fira Code']; + const buffer = fs.readFileSync(fontPath); + + const uncached = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)); + const uncachedResult1 = uncached.findLigatures('in --> out'); + const uncachedResult2 = uncached.findLigatureRanges('in --> out'); + + const font = loadBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength), { cacheSize: 100 }); + const result1 = font.findLigatures('in --> out'); + const result2 = font.findLigatureRanges('in --> out'); + + assert.deepEqual(result1, uncachedResult1); + assert.deepEqual(result2, uncachedResult2); + assert.deepEqual(result1.contextRanges, result2); + }); + }); +}); \ No newline at end of file diff --git a/addons/addon-ligatures/test/merge.test.ts b/addons/addon-ligatures/test/merge.test.ts new file mode 100644 index 00000000..0dc157f2 --- /dev/null +++ b/addons/addon-ligatures/test/merge.test.ts @@ -0,0 +1,226 @@ +/** + * Copyright (c) 2018 The xterm.js authors. All rights reserved. + * @license MIT + */ + +import { assert } from 'chai'; + +const mergeTrees = require('../out-esbuild/fontLigatures/merge').default; + +interface LookupResult { + contextRange: [number, number]; + index: number; + subIndex: number; + length: number; + substitutions: number[]; +} + +function lookup(substitutionGlyph: number, index?: number, subIndex?: number): LookupResult { + return { + contextRange: [0, 1], + index: index || 0, + subIndex: subIndex || 0, + length: 1, + substitutions: [substitutionGlyph] + }; +} + +describe('addon-ligatures - merge', () => { + describe('mergeTrees', () => { + it('combines disjoint trees', () => { + const result = mergeTrees([ + { + individual: { + '1': { lookup: lookup(1) } + }, + range: [] + }, + { + individual: {}, + range: [{ + entry: { lookup: lookup(2) }, + range: [2, 4] + }] + }, + { + individual: { + '5': { lookup: lookup(3) } + }, + range: [] + }, + { + individual: {}, + range: [{ + entry: { lookup: lookup(4) }, + range: [8, 10] + }] + } + ]); + + assert.deepEqual(result, { + individual: { + '1': { lookup: lookup(1) }, + '5': { lookup: lookup(3) } + }, + range: [{ + entry: { lookup: lookup(2) }, + range: [2, 4] + }, { + entry: { lookup: lookup(4) }, + range: [8, 10] + }] + }); + }); + + it('merges matching individual glyphs', () => { + const result = mergeTrees([ + { + individual: { + '1': { lookup: lookup(1, 1) } + }, + range: [] + }, + { + individual: { + '1': { lookup: lookup(2, 0) } + }, + range: [] + }, + { + individual: { + '1': { lookup: lookup(3, 2) } + }, + range: [] + } + ]); + + assert.deepEqual(result, { + individual: { + '1': { lookup: lookup(2, 0) } + }, + range: [] + }); + }); + + it('merges range glyphs overlapping individual glyphs', () => { + const result = mergeTrees([ + { + individual: { + '1': { lookup: lookup(1, 0) } + }, + range: [] + }, + { + individual: {}, + range: [{ + entry: { lookup: lookup(2, 1) }, + range: [0, 4] + }] + } + ]); + + assert.deepEqual(result, { + individual: { + '0': { lookup: lookup(2, 1) }, + '1': { lookup: lookup(1, 0) } + }, + range: [{ + entry: { lookup: lookup(2, 1) }, + range: [2, 4] + }] + }); + }); + + it('merges individual glyphs overlapping range glyphs', () => { + const result = mergeTrees([ + { + individual: {}, + range: [{ + entry: { lookup: lookup(2, 1) }, + range: [0, 4] + }] + }, + { + individual: { + '1': { lookup: lookup(1, 0) } + }, + range: [] + } + ]); + + assert.deepEqual(result, { + individual: { + '0': { lookup: lookup(2, 1) }, + '1': { lookup: lookup(1, 0) } + }, + range: [{ + entry: { lookup: lookup(2, 1) }, + range: [2, 4] + }] + }); + }); + + it('merges multiple overlapping ranges', () => { + const result = mergeTrees([ + { + individual: {}, + range: [{ + entry: { lookup: lookup(1, 2) }, + range: [0, 3] + }, { + entry: { lookup: lookup(2, 1) }, + range: [6, 12] + }, { + entry: { lookup: lookup(5, 3) }, + range: [15, 20] + }, { + entry: { lookup: lookup(7, 4) }, + range: [20, 22] + }] + }, + { + individual: {}, + range: [{ + entry: { lookup: lookup(3, 0) }, + range: [2, 8] + }, { + entry: { lookup: lookup(4, 0) }, + range: [10, 13] + }, { + entry: { lookup: lookup(6, 0) }, + range: [16, 21] + }] + } + ]); + + assert.deepEqual(result, { + individual: { + '2': { lookup: lookup(3, 0) }, + '12': { lookup: lookup(4, 0) }, + '15': { lookup: lookup(5, 3) }, + '20': { lookup: lookup(6, 0) }, + '21': { lookup: lookup(7, 4) } + }, + range: [{ + entry: { lookup: lookup(1, 2) }, + range: [0, 2] + }, { + entry: { lookup: lookup(3, 0) }, + range: [6, 8] + }, { + entry: { lookup: lookup(3, 0) }, + range: [3, 6] + }, { + entry: { lookup: lookup(2, 1) }, + range: [8, 10] + }, { + entry: { lookup: lookup(4, 0) }, + range: [10, 12] + }, { + entry: { lookup: lookup(6, 0) }, + range: [16, 20] + }] + }); + }); + }); +}); \ No newline at end of file diff --git a/addons/addon-ligatures/test/mergeRange.test.ts b/addons/addon-ligatures/test/mergeRange.test.ts new file mode 100644 index 00000000..91642e8d --- /dev/null +++ b/addons/addon-ligatures/test/mergeRange.test.ts @@ -0,0 +1,50 @@ +/** + * Copyright (c) 2018 The xterm.js authors. All rights reserved. + * @license MIT + */ + +import { assert } from 'chai'; + +const mergeRange = require('../out-esbuild/fontLigatures/mergeRange').default; + +describe('addon-ligatures - mergeRange', () => { + it('inserts a new range before the existing ones', () => { + const result = mergeRange([[1, 2], [2, 3]], 0, 1); + assert.deepEqual(result, [[0, 1], [1, 2], [2, 3]]); + }); + + it('inserts in between two ranges', () => { + const result = mergeRange([[0, 2], [4, 6]], 2, 4); + assert.deepEqual(result, [[0, 2], [2, 4], [4, 6]]); + }); + + it('inserts after the last range', () => { + const result = mergeRange([[0, 2], [4, 6]], 6, 8); + assert.deepEqual(result, [[0, 2], [4, 6], [6, 8]]); + }); + + it('extends the beginning of a range', () => { + const result = mergeRange([[0, 2], [4, 6]], 3, 5); + assert.deepEqual(result, [[0, 2], [3, 6]]); + }); + + it('extends the end of a range', () => { + const result = mergeRange([[0, 2], [4, 6]], 1, 4); + assert.deepEqual(result, [[0, 4], [4, 6]]); + }); + + it('extends the last range', () => { + const result = mergeRange([[0, 2], [4, 6]], 5, 7); + assert.deepEqual(result, [[0, 2], [4, 7]]); + }); + + it('connects two ranges', () => { + const result = mergeRange([[0, 2], [4, 6]], 1, 5); + assert.deepEqual(result, [[0, 6]]); + }); + + it('connects more than two ranges', () => { + const result = mergeRange([[0, 2], [4, 6], [8, 10], [12, 14]], 1, 10); + assert.deepEqual(result, [[0, 10], [12, 14]]); + }); +}); diff --git a/addons/addon-ligatures/test/parse.test.ts b/addons/addon-ligatures/test/parse.test.ts index d6c56d2c..de846f4a 100644 --- a/addons/addon-ligatures/test/parse.test.ts +++ b/addons/addon-ligatures/test/parse.test.ts @@ -8,7 +8,7 @@ import { assert } from 'chai'; const parse = require('../out-esbuild/parse').default; // TODO: integrate tests from http://test.csswg.org/suites/css-fonts-4_dev/nightly-unstable/ -describe('parse', () => { +describe('addon-ligatures - parse', () => { it('parses individual families', () => { assert.deepEqual(parse('monospace'), ['monospace']); }); diff --git a/package-lock.json b/package-lock.json index 71dff295..e48e512c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -87,11 +87,14 @@ "version": "0.10.0", "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/lru-cache": "^5.1.0", + "@types/opentype.js": "^0.7.0", "axios": "^1.6.0", + "font-finder": "^1.1.0", "mkdirp": "0.5.5", "yauzl": "^2.10.0" }, @@ -99,6 +102,24 @@ "node": ">8.0.0" } }, + "addons/addon-ligatures/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "addons/addon-ligatures/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "license": "ISC" + }, "addons/addon-progress": { "name": "@xterm/addon-progress", "version": "0.2.0", @@ -1701,6 +1722,13 @@ "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", "dev": true }, + "node_modules/@types/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/mathjs": { "version": "6.0.12", "resolved": "https://registry.npmjs.org/@types/mathjs/-/mathjs-6.0.12.tgz", @@ -1737,6 +1765,13 @@ "undici-types": "~6.21.0" } }, + "node_modules/@types/opentype.js": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/@types/opentype.js/-/opentype.js-0.7.2.tgz", + "integrity": "sha512-Riz6WyBUBEFs7YqSsJya3SbDHJZ6BmMkY7bzNoue6rtwj+RNilLc+mgOX/eJ0Y0asq16FSU6DatBeOg8ZMy2UQ==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/puppeteer": { "version": "5.4.7", "resolved": "https://registry.npmjs.org/@types/puppeteer/-/puppeteer-5.4.7.tgz", @@ -4228,6 +4263,8 @@ "version": "1.1.0", "resolved": "https://registry.npmjs.org/font-finder/-/font-finder-1.1.0.tgz", "integrity": "sha512-wpCL2uIbi6GurJbU7ZlQ3nGd61Ho+dSU6U83/xJT5UPFfN35EeCW/rOtS+5k+IuEZu2SYmHzDIPL9eA5tSYRAw==", + "dev": true, + "license": "MIT", "dependencies": { "get-system-fonts": "^2.0.0", "promise-stream-reader": "^1.0.1" @@ -4236,35 +4273,6 @@ "node": ">8.0.0" } }, - "node_modules/font-ligatures": { - "version": "1.4.1", - "resolved": "https://registry.npmjs.org/font-ligatures/-/font-ligatures-1.4.1.tgz", - "integrity": "sha512-7W6zlfyhvCqShZ5ReUWqmSd9vBaUudW0Hxis+tqUjtHhsPU+L3Grf8mcZAtCiXHTzorhwdRTId2WeH/88gdFkw==", - "dependencies": { - "font-finder": "^1.0.3", - "lru-cache": "^6.0.0", - "opentype.js": "^0.8.0" - }, - "engines": { - "node": ">8.0.0" - } - }, - "node_modules/font-ligatures/node_modules/lru-cache": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", - "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", - "dependencies": { - "yallist": "^4.0.0" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/font-ligatures/node_modules/yallist": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" - }, "node_modules/for-each": { "version": "0.3.5", "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz", @@ -4490,6 +4498,8 @@ "version": "2.0.2", "resolved": "https://registry.npmjs.org/get-system-fonts/-/get-system-fonts-2.0.2.tgz", "integrity": "sha512-zzlgaYnHMIEgHRrfC7x0Qp0Ylhw/sHpM6MHXeVBTYIsvGf5GpbnClB+Q6rAPdn+0gd2oZZIo6Tj3EaWrt4VhDQ==", + "dev": true, + "license": "MIT", "engines": { "node": ">8.0.0" } @@ -6700,6 +6710,8 @@ "version": "1.0.1", "resolved": "https://registry.npmjs.org/promise-stream-reader/-/promise-stream-reader-1.0.1.tgz", "integrity": "sha512-Tnxit5trUjBAqqZCGWwjyxhmgMN4hGrtpW3Oc/tRI4bpm/O2+ej72BB08l6JBnGQgVDGCLvHFGjGgQS6vzhwXg==", + "dev": true, + "license": "MIT", "engines": { "node": ">8.0.0" } From 21b8f77afb5fac4142d1c1167c47611d7f1cf69f Mon Sep 17 00:00:00 2001 From: Daniel Imms <2193314+Tyriar@users.noreply.github.com> Date: Sat, 3 Jan 2026 09:16:58 -0800 Subject: [PATCH 2/4] Move unit tests to right folder, push font fixtures --- addons/addon-ligatures/.gitignore | 1 - .../addon-ligatures/fonts/FiraCode-Regular.otf | Bin 0 -> 159496 bytes .../addon-ligatures/fonts/Monoid-Regular.ttf | Bin 0 -> 79248 bytes .../fonts/UbuntuMono-Regular.ttf | Bin 0 -> 205748 bytes .../addon-ligatures/fonts/iosevka-regular.ttf | Bin 0 -> 399128 bytes .../{test => src/fontLigatures}/index.test.ts | 12 +++++------- .../{test => src/fontLigatures}/merge.test.ts | 3 +-- .../fontLigatures}/mergeRange.test.ts | 3 +-- .../{test => src}/parse.test.ts | 3 +-- addons/addon-ligatures/src/tsconfig.json | 4 +++- 10 files changed, 11 insertions(+), 15 deletions(-) create mode 100644 addons/addon-ligatures/fonts/FiraCode-Regular.otf create mode 100644 addons/addon-ligatures/fonts/Monoid-Regular.ttf create mode 100644 addons/addon-ligatures/fonts/UbuntuMono-Regular.ttf create mode 100644 addons/addon-ligatures/fonts/iosevka-regular.ttf rename addons/addon-ligatures/{test => src/fontLigatures}/index.test.ts (96%) rename addons/addon-ligatures/{test => src/fontLigatures}/merge.test.ts (98%) rename addons/addon-ligatures/{test => src/fontLigatures}/mergeRange.test.ts (94%) rename addons/addon-ligatures/{test => src}/parse.test.ts (97%) diff --git a/addons/addon-ligatures/.gitignore b/addons/addon-ligatures/.gitignore index f172c3a1..7b48eed8 100644 --- a/addons/addon-ligatures/.gitignore +++ b/addons/addon-ligatures/.gitignore @@ -3,7 +3,6 @@ node_modules/ coverage/ lib/ -fonts/ .env .vscode/ diff --git a/addons/addon-ligatures/fonts/FiraCode-Regular.otf b/addons/addon-ligatures/fonts/FiraCode-Regular.otf new file mode 100644 index 0000000000000000000000000000000000000000..e7a9fda69dad82c508e6374a053e6d3f1b82f6c0 GIT binary patch literal 159496 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

MPVd<+J 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%0DG? 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%0Aopr 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 VE_#YS1aU4pF@TRPy4-d8F94u@-NOI? literal 0 HcmV?d00001 diff --git a/addons/addon-ligatures/fonts/UbuntuMono-Regular.ttf b/addons/addon-ligatures/fonts/UbuntuMono-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..fdd309d716629f4e5339d5e5508225ed857a3ede GIT binary patch literal 205748 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 L<|2NP7a14;dV*d7 literal 0 HcmV?d00001 diff --git a/addons/addon-ligatures/fonts/iosevka-regular.ttf b/addons/addon-ligatures/fonts/iosevka-regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..963cbe2a654a8e5ab284a622575c57464e8f1b35 GIT binary patch literal 399128 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

ifyxeEG&qLyw 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

    Ac)sp~N+D}ho2 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 z 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 Font = fontLigatures.loadBuffer; +import { loadBuffer } from './index'; interface Font { findLigatures(text: string): { outputGlyphs: number[]; contextRanges: [number, number][] }; @@ -263,10 +261,10 @@ const ubuntuCases: TestCase[] = [ ]; const fontPaths: Record = { - 'Fira Code': path.join(__dirname, '../fonts/FiraCode-Regular.otf'), - 'Iosevka': path.join(__dirname, '../fonts/iosevka-regular.ttf'), - 'Monoid': path.join(__dirname, '../fonts/Monoid-Regular.ttf'), - 'Ubuntu Mono': path.join(__dirname, '../fonts/UbuntuMono-Regular.ttf') + 'Fira Code': path.join(__dirname, '../../fonts/FiraCode-Regular.otf'), + 'Iosevka': path.join(__dirname, '../../fonts/iosevka-regular.ttf'), + 'Monoid': path.join(__dirname, '../../fonts/Monoid-Regular.ttf'), + 'Ubuntu Mono': path.join(__dirname, '../../fonts/UbuntuMono-Regular.ttf') }; const fontCache: Map = new Map(); diff --git a/addons/addon-ligatures/test/merge.test.ts b/addons/addon-ligatures/src/fontLigatures/merge.test.ts similarity index 98% rename from addons/addon-ligatures/test/merge.test.ts rename to addons/addon-ligatures/src/fontLigatures/merge.test.ts index 0dc157f2..e56c8dae 100644 --- a/addons/addon-ligatures/test/merge.test.ts +++ b/addons/addon-ligatures/src/fontLigatures/merge.test.ts @@ -4,8 +4,7 @@ */ import { assert } from 'chai'; - -const mergeTrees = require('../out-esbuild/fontLigatures/merge').default; +import mergeTrees from './merge'; interface LookupResult { contextRange: [number, number]; diff --git a/addons/addon-ligatures/test/mergeRange.test.ts b/addons/addon-ligatures/src/fontLigatures/mergeRange.test.ts similarity index 94% rename from addons/addon-ligatures/test/mergeRange.test.ts rename to addons/addon-ligatures/src/fontLigatures/mergeRange.test.ts index 91642e8d..790ea666 100644 --- a/addons/addon-ligatures/test/mergeRange.test.ts +++ b/addons/addon-ligatures/src/fontLigatures/mergeRange.test.ts @@ -4,8 +4,7 @@ */ import { assert } from 'chai'; - -const mergeRange = require('../out-esbuild/fontLigatures/mergeRange').default; +import mergeRange from './mergeRange'; describe('addon-ligatures - mergeRange', () => { it('inserts a new range before the existing ones', () => { diff --git a/addons/addon-ligatures/test/parse.test.ts b/addons/addon-ligatures/src/parse.test.ts similarity index 97% rename from addons/addon-ligatures/test/parse.test.ts rename to addons/addon-ligatures/src/parse.test.ts index de846f4a..d2150e9d 100644 --- a/addons/addon-ligatures/test/parse.test.ts +++ b/addons/addon-ligatures/src/parse.test.ts @@ -4,8 +4,7 @@ */ import { assert } from 'chai'; - -const parse = require('../out-esbuild/parse').default; +import parse from './parse'; // TODO: integrate tests from http://test.csswg.org/suites/css-fonts-4_dev/nightly-unstable/ describe('addon-ligatures - parse', () => { diff --git a/addons/addon-ligatures/src/tsconfig.json b/addons/addon-ligatures/src/tsconfig.json index cc9a9bef..f54111a3 100644 --- a/addons/addon-ligatures/src/tsconfig.json +++ b/addons/addon-ligatures/src/tsconfig.json @@ -9,7 +9,9 @@ "noUnusedLocals": true, "preserveWatchOutput": true, "types": [ - "../../../node_modules/@types/mocha" + "../../../node_modules/@types/mocha", + // HACK: src shouldn't use node types but it's needed for index.test.ts + "../../../node_modules/@types/node" ], "paths": { "@xterm/addon-ligatures" : [ From ec03109c39cde7ef8f33cee273913eac72726bed Mon Sep 17 00:00:00 2001 From: Daniel Imms <2193314+Tyriar@users.noreply.github.com> Date: Sat, 3 Jan 2026 09:25:39 -0800 Subject: [PATCH 3/4] 2 space indent --- .../src/fontLigatures/flatten.ts | 42 +- .../src/fontLigatures/index.ts | 420 +++++++------- .../src/fontLigatures/merge.ts | 520 +++++++++--------- .../src/fontLigatures/mergeRange.ts | 100 ++-- .../src/fontLigatures/processors/6-1.ts | 122 ++-- .../src/fontLigatures/processors/6-2.ts | 138 ++--- .../src/fontLigatures/processors/6-3.ts | 104 ++-- .../src/fontLigatures/processors/8-1.ts | 100 ++-- .../src/fontLigatures/processors/classDef.ts | 112 ++-- .../src/fontLigatures/processors/coverage.ts | 58 +- .../src/fontLigatures/processors/helper.ts | 238 ++++---- .../fontLigatures/processors/substitution.ts | 76 +-- .../src/fontLigatures/tables.ts | 154 +++--- .../src/fontLigatures/types.ts | 108 ++-- .../addon-ligatures/src/fontLigatures/walk.ts | 100 ++-- 15 files changed, 1196 insertions(+), 1196 deletions(-) diff --git a/addons/addon-ligatures/src/fontLigatures/flatten.ts b/addons/addon-ligatures/src/fontLigatures/flatten.ts index 38e99c3a..f911b986 100644 --- a/addons/addon-ligatures/src/fontLigatures/flatten.ts +++ b/addons/addon-ligatures/src/fontLigatures/flatten.ts @@ -1,35 +1,35 @@ import { LookupTree, FlattenedLookupTree, LookupTreeEntry, FlattenedLookupTreeEntry } from './types'; export default function flatten(tree: LookupTree): FlattenedLookupTree { - const result: FlattenedLookupTree = {}; - for (const [glyphId, entry] of Object.entries(tree.individual)) { - result[glyphId] = flattenEntry(entry); - } + const result: FlattenedLookupTree = {}; + for (const [glyphId, entry] of Object.entries(tree.individual)) { + result[glyphId] = flattenEntry(entry); + } - for (const { range, entry } of tree.range) { - const flattened = flattenEntry(entry); - for (let glyphId = range[0]; glyphId < range[1]; glyphId++) { - result[glyphId] = flattened; - } + for (const { range, entry } of tree.range) { + const flattened = flattenEntry(entry); + for (let glyphId = range[0]; glyphId < range[1]; glyphId++) { + result[glyphId] = flattened; } + } - return result; + return result; } function flattenEntry(entry: LookupTreeEntry): FlattenedLookupTreeEntry { - const result: FlattenedLookupTreeEntry = {}; + const result: FlattenedLookupTreeEntry = {}; - if (entry.forward) { - result.forward = flatten(entry.forward); - } + if (entry.forward) { + result.forward = flatten(entry.forward); + } - if (entry.reverse) { - result.reverse = flatten(entry.reverse); - } + if (entry.reverse) { + result.reverse = flatten(entry.reverse); + } - if (entry.lookup) { - result.lookup = entry.lookup; - } + if (entry.lookup) { + result.lookup = entry.lookup; + } - return result; + return result; } diff --git a/addons/addon-ligatures/src/fontLigatures/index.ts b/addons/addon-ligatures/src/fontLigatures/index.ts index e91eea92..f15bd32a 100644 --- a/addons/addon-ligatures/src/fontLigatures/index.ts +++ b/addons/addon-ligatures/src/fontLigatures/index.ts @@ -13,236 +13,236 @@ import buildTreeGsubType8Format1 from './processors/8-1'; import flatten from './flatten'; class FontImpl implements Font { - private _font: opentype.Font; - private _lookupTrees: { tree: FlattenedLookupTree; processForward: boolean; }[] = []; - private _glyphLookups: { [glyphId: string]: number[] } = {}; - private _cache?: LRUCache; + private _font: opentype.Font; + private _lookupTrees: { tree: FlattenedLookupTree; processForward: boolean; }[] = []; + private _glyphLookups: { [glyphId: string]: number[] } = {}; + private _cache?: LRUCache; - constructor(font: opentype.Font, options: Required) { - this._font = font; + constructor(font: opentype.Font, options: Required) { + this._font = font; - if (options.cacheSize > 0) { - this._cache = new LRUCache({ - max: options.cacheSize, - length: ((val: LigatureData | [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: LookupTree[] = []; - 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); - } - } + if (options.cacheSize > 0) { + this._cache = new LRUCache({ + max: options.cacheSize, + length: ((val: LigatureData | [number, number][], key: string) => key.length) as any + }); } - findLigatures(text: string): LigatureData { - const cached = this._cache && this._cache.get(text); - if (cached && !Array.isArray(cached)) { - return cached; + 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: LookupTree[] = []; + 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] = []; } - const glyphIds: number[] = []; - for (const char of text) { - glyphIds.push(this._font.charToGlyphIndex(char)); - } + this._glyphLookups[glyphId].push(index); + } + } + } - // 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: LigatureData = { - inputGlyphs: glyphIds, - outputGlyphs: result.sequence, - contextRanges: result.ranges - }; - if (this._cache) { - this._cache.set(text, finalResult); - } - - return finalResult; + findLigatures(text: string): LigatureData { + const cached = this._cache && this._cache.get(text); + if (cached && !Array.isArray(cached)) { + return cached; } - 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; + const glyphIds: number[] = []; + for (const char of text) { + glyphIds.push(this._font.charToGlyphIndex(char)); } - private _findInternal(sequence: number[]): { sequence: number[]; ranges: [number, number][]; } { - const ranges: [number, number][] = []; + // 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: [] + }; + } - 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; - } - } + const result = this._findInternal(glyphIds.slice()); + const finalResult: LigatureData = { + inputGlyphs: glyphIds, + outputGlyphs: result.sequence, + contextRanges: result.ranges + }; + if (this._cache) { + this._cache.set(text, finalResult); + } - mergeRange( - ranges, - result.contextRange[0] + i, - result.contextRange[1] + i - ); + return finalResult; + } - // Substitutions can end up extending the search range - if (i + result.length >= lastGlyphIndex) { - lastGlyphIndex = i + result.length + 1; - } + findLigatureRanges(text: string): [number, number][] { + // Short circuit the process if there are no possible ligatures in the + // font + if (this._lookupTrees.length === 0) { + return []; + } - 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; - } - } + const cached = this._cache && this._cache.get(text); + if (cached) { + return Array.isArray(cached) ? cached : cached.contextRanges; + } - mergeRange( - ranges, - result.contextRange[0] + i, - result.contextRange[1] + i - ); + const glyphIds: number[] = []; + for (const char of text) { + glyphIds.push(this._font.charToGlyphIndex(char)); + } - i -= result.length - 1; - } - } + 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; + } } - nextLookup = this._getNextLookup(sequence, nextLookup.index + 1); - } + mergeRange( + ranges, + result.contextRange[0] + i, + result.contextRange[1] + i + ); - 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; + // Substitutions can end up extending the search range + if (i + result.length >= lastGlyphIndex) { + lastGlyphIndex = i + result.length + 1; } - 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; - } - } + 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; + } + } - return result; + 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; + } } /** @@ -252,11 +252,11 @@ class FontImpl implements Font { * @param buffer ArrayBuffer of the font to load */ export function loadBuffer(buffer: ArrayBuffer, options?: Options): Font { - const font = opentype.parse(buffer); - return new FontImpl(font, { - cacheSize: 0, - ...options - }); + const font = opentype.parse(buffer); + return new FontImpl(font, { + cacheSize: 0, + ...options + }); } export { Font, LigatureData, Options }; diff --git a/addons/addon-ligatures/src/fontLigatures/merge.ts b/addons/addon-ligatures/src/fontLigatures/merge.ts index d0b1f23e..13c87733 100644 --- a/addons/addon-ligatures/src/fontLigatures/merge.ts +++ b/addons/addon-ligatures/src/fontLigatures/merge.ts @@ -9,16 +9,16 @@ import { LookupTree, LookupTreeEntry } from './types'; * over those in later trees when there is a choice. */ export default function mergeTrees(trees: LookupTree[]): LookupTree { - const result: LookupTree = { - individual: {}, - range: [] - }; + const result: LookupTree = { + individual: {}, + range: [] + }; - for (const tree of trees) { - mergeSubtree(result, tree); - } + for (const tree of trees) { + mergeSubtree(result, tree); + } - return result; + return result; } /** @@ -28,162 +28,162 @@ export default function mergeTrees(trees: LookupTree[]): LookupTree { * @param mergeTree The tree to be merged into the mainTree */ function mergeSubtree(mainTree: LookupTree, mergeTree: LookupTree): 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); - } else { - let matched = false; - for (const [index, { range, entry }] of mainTree.range.entries()) { - const overlap = getIndividualOverlap(Number(glyphId), range); + // 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); + } 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)); - - // 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; - } + // 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)); + + // 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 (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; - } + 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--; + mainTree.range.splice(index, 1); + index--; - const entryToMerge: LookupTreeEntry = cloneEntry(resultEntry); - if (Array.isArray(overlap.both)) { - mainTree.range.push({ - range: overlap.both, - entry: entryToMerge - }); - } else { - mainTree.individual[overlap.both] = entryToMerge; - } + const entryToMerge: LookupTreeEntry = 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)); + mergeTreeEntry(entryToMerge, cloneEntry(entry)); - 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)); - - // 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)); - - // Update the remaining ranges - remainingRanges.splice(remainingIndex, 1, ...overlap.second); - break; - } else { - if (Number(glyphId) === remainingRange) { - mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry)); - 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) - }); + for (const second of overlap.second) { + if (Array.isArray(second)) { + mainTree.range.push({ + range: second, + entry: cloneEntry(resultEntry) + }); } else { - mainTree.individual[remainingRange] = cloneEntry(entry); + 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)); + + // 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)); + + // Update the remaining ranges + remainingRanges.splice(remainingIndex, 1, ...overlap.second); + break; + } else { + if (Number(glyphId) === remainingRange) { + mergeTreeEntry(mainTree.individual[glyphId], cloneEntry(entry)); + 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); + } + } + } } /** @@ -193,37 +193,37 @@ function mergeSubtree(mainTree: LookupTree, mergeTree: LookupTree): void { * @param mergeTree The entry to merge into the mainTree */ function mergeTreeEntry(mainTree: LookupTreeEntry, mergeTree: LookupTreeEntry): void { - 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.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); - } + if (mergeTree.forward) { + if (!mainTree.forward) { + mainTree.forward = mergeTree.forward; + } else { + mergeSubtree(mainTree.forward, mergeTree.forward); } + } - if (mergeTree.reverse) { - if (!mainTree.reverse) { - mainTree.reverse = mergeTree.reverse; - } else { - mergeSubtree(mainTree.reverse, mergeTree.reverse); - } + if (mergeTree.reverse) { + if (!mainTree.reverse) { + mainTree.reverse = mergeTree.reverse; + } else { + mergeSubtree(mainTree.reverse, mergeTree.reverse); } + } } interface Overlap { - first: (number | [number, number])[]; - second: (number | [number, number])[]; - both: number | [number, number] | null; + first: (number | [number, number])[]; + second: (number | [number, number])[]; + both: number | [number, number] | null; } /** @@ -234,42 +234,42 @@ interface Overlap { * @param second Second range */ function getRangeOverlap(first: [number, number], second: [number, number]): Overlap { - const result: Overlap = { - first: [], - second: [], - both: null - }; + const result: Overlap = { + 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); - } + // 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)); - } + // 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)); - } + // 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; + return result; } /** @@ -281,30 +281,30 @@ function getRangeOverlap(first: [number, number], second: [number, number]): Ove * @param second Range */ function getIndividualOverlap(first: number, second: [number, number]): Overlap { - // Disjoint - if (first < second[0] || first > second[1]) { - return { - first: [first], - second: [second], - both: null - }; - } - - const result: Overlap = { - first: [], - second: [], - both: first + // Disjoint + if (first < second[0] || first > second[1]) { + return { + first: [first], + second: [second], + both: null }; + } - if (second[0] < first) { - result.second.push(rangeOrIndividual(second[0], first)); - } + const result: Overlap = { + first: [], + second: [], + both: first + }; - if (second[1] > first) { - result.second.push(rangeOrIndividual(first + 1, second[1])); - } + if (second[0] < first) { + result.second.push(rangeOrIndividual(second[0], first)); + } - return result; + if (second[1] > first) { + result.second.push(rangeOrIndividual(first + 1, second[1])); + } + + return result; } /** @@ -315,11 +315,11 @@ function getIndividualOverlap(first: number, second: [number, number]): Overlap * @param end End of the range (exclusive) */ function rangeOrIndividual(start: number, end: number): number | [number, number] { - if (end - start === 1) { - return start; - } else { - return [start, end]; - } + if (end - start === 1) { + return start; + } else { + return [start, end]; + } } /** @@ -328,27 +328,27 @@ function rangeOrIndividual(start: number, end: number): number | [number, number * @param entry Lookup tree entry to clone */ function cloneEntry(entry: LookupTreeEntry): LookupTreeEntry { - const result: LookupTreeEntry = {}; + const result: LookupTreeEntry = {}; - if (entry.forward) { - result.forward = cloneTree(entry.forward); - } + if (entry.forward) { + result.forward = cloneTree(entry.forward); + } - if (entry.reverse) { - result.reverse = cloneTree(entry.reverse); - } + if (entry.reverse) { + result.reverse = cloneTree(entry.reverse); + } - 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() - }; - } + 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; + return result; } /** @@ -357,16 +357,16 @@ function cloneEntry(entry: LookupTreeEntry): LookupTreeEntry { * @param tree Lookup tree to clone */ function cloneTree(tree: LookupTree): LookupTree { - const individual: { [glyphId: string]: LookupTreeEntry; } = {}; - for (const [glyphId, entry] of Object.entries(tree.individual)) { - individual[glyphId] = cloneEntry(entry); - } + const individual: { [glyphId: string]: LookupTreeEntry; } = {}; + for (const [glyphId, entry] of Object.entries(tree.individual)) { + individual[glyphId] = cloneEntry(entry); + } - return { - individual, - range: tree.range.map(({ range, entry }) => ({ - range: range.slice() as [number, number], - entry: cloneEntry(entry) - })) - }; + return { + individual, + range: tree.range.map(({ range, entry }) => ({ + range: range.slice() as [number, number], + entry: cloneEntry(entry) + })) + }; } diff --git a/addons/addon-ligatures/src/fontLigatures/mergeRange.ts b/addons/addon-ligatures/src/fontLigatures/mergeRange.ts index 7c872a8a..2b9ac6b7 100644 --- a/addons/addon-ligatures/src/fontLigatures/mergeRange.ts +++ b/addons/addon-ligatures/src/fontLigatures/mergeRange.ts @@ -8,57 +8,57 @@ * @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; - } else 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; - } else 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; - } else 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; - } else { - // 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; + 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; + } else 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; + } else 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 { - // Case 9: New range starts after the last existing range - ranges.push([newRangeStart, newRangeEnd]); + 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; + } else 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; + } else { + // Case 7: New range extends from previous range past the + // end of the current range + ranges.splice(i, 1); + i--; + } } + } - return ranges; + 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; } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts index 2f0dad18..dc2e8917 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts @@ -13,70 +13,70 @@ import { processInputPosition, processLookaheadPosition, processBacktrackPositio * @param tableIndex Index of this table in the overall lookup */ export default function buildTree(table: ChainingContextualSubstitutionTable.Format1, lookups: Lookup[], tableIndex: number): LookupTree { - const result: LookupTree = { - individual: {}, - range: [] - }; + const result: LookupTree = { + individual: {}, + range: [] + }; - const firstGlyphs = listGlyphsByIndex(table.coverage); + const firstGlyphs = listGlyphsByIndex(table.coverage); - for (const { glyphId, index } of firstGlyphs) { - const chainRuleSet = table.chainRuleSets[index]; + 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: EntryMeta[] = 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 - ] - }; - } - } + // If the chain rule set is null there's nothing to do with this table. + if (!chainRuleSet) { + continue; } - return result; + for (const [subIndex, subTable] of chainRuleSet.entries()) { + let currentEntries: EntryMeta[] = 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; } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts index 9cd8eaf3..f0f9245c 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts @@ -15,82 +15,82 @@ import { processInputPosition, processLookaheadPosition, processBacktrackPositio * @param tableIndex Index of this table in the overall lookup */ export default function buildTree(table: ChainingContextualSubstitutionTable.Format2, lookups: Lookup[], tableIndex: number): LookupTree { - const results: LookupTree[] = []; + const results: LookupTree[] = []; - const firstGlyphs = listGlyphsByIndex(table.coverage); + 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; - } + 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]; + const classSet = table.chainClassSet[inputClass]; - // If the class set is null there's nothing to do with this table. - if (!classSet) { - continue; - } + // 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: LookupTree = { - individual: {}, - range: [] - }; + for (const [subIndex, subTable] of classSet.entries()) { + const result: LookupTree = { + individual: {}, + range: [] + }; - let currentEntries: EntryMeta[] = getInputTree( - result, - subTable.lookupRecords, - lookups, - 0, - glyphId - ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] })); + let currentEntries: EntryMeta[] = 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); - } + for (const [index, classNum] of subTable.input.entries()) { + currentEntries = processInputPosition( + listClassGlyphs(table.inputClassDef, classNum), + index + 1, + currentEntries, + subTable.lookupRecords, + lookups + ); } - } - return mergeTrees(results); + 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); } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts index fc671e7b..07e4681f 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts @@ -13,61 +13,61 @@ import { processInputPosition, processLookaheadPosition, processBacktrackPositio * @param tableIndex Index of this table in the overall lookup */ export default function buildTree(table: ChainingContextualSubstitutionTable.Format3, lookups: Lookup[], tableIndex: number): LookupTree { - const result: LookupTree = { - individual: {}, - range: [] - }; + const result: LookupTree = { + individual: {}, + range: [] + }; - const firstGlyphs = listGlyphsByIndex(table.inputCoverage[0]); + const firstGlyphs = listGlyphsByIndex(table.inputCoverage[0]); - for (const { glyphId } of firstGlyphs) { - let currentEntries: EntryMeta[] = getInputTree( - result, - table.lookupRecords, - lookups, - 0, - glyphId - ).map(({ entry, substitution }) => ({ entry, substitutions: [substitution] })); + for (const { glyphId } of firstGlyphs) { + let currentEntries: EntryMeta[] = 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 - ] - }; - } + for (const [index, coverage] of table.inputCoverage.slice(1).entries()) { + currentEntries = processInputPosition( + listGlyphsByIndex(coverage).map(glyph => glyph.glyphId), + index + 1, + currentEntries, + table.lookupRecords, + lookups + ); } - return result; + 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; } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts b/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts index 620d2e20..8f127f6b 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts @@ -12,58 +12,58 @@ import { processLookaheadPosition, processBacktrackPosition, EntryMeta } from '. * @param tableIndex Index of this table in the overall lookup */ export default function buildTree(table: ReverseChainingContextualSingleSubstitutionTable, tableIndex: number): LookupTree { - const result: LookupTree = { - individual: {}, - range: [] - }; + const result: LookupTree = { + individual: {}, + range: [] + }; - const glyphs = listGlyphsByIndex(table.coverage); + const glyphs = listGlyphsByIndex(table.coverage); - for (const { glyphId, index } of glyphs) { - const initialEntry: LookupTreeEntry = {}; - if (Array.isArray(glyphId)) { - result.range.push({ - entry: initialEntry, - range: glyphId - }); - } else { - result.individual[glyphId] = initialEntry; - } - - let currentEntries: EntryMeta[] = [{ - 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 - ] - }; - } + for (const { glyphId, index } of glyphs) { + const initialEntry: LookupTreeEntry = {}; + if (Array.isArray(glyphId)) { + result.range.push({ + entry: initialEntry, + range: glyphId + }); + } else { + result.individual[glyphId] = initialEntry; } - return result; + let currentEntries: EntryMeta[] = [{ + 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; } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts b/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts index 3f2dc21e..bcf98ea6 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts @@ -8,78 +8,78 @@ import { ClassDefTable } from '../tables'; * @param glyphId Index of the glyph to look for */ export default function getGlyphClass(table: ClassDefTable, glyphId: number | [number, number]): Map { - 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); - } else { - 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]]); - } + 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); + } else { + 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.Format2, glyphId: [number, number]): Map { - let classStart: number = glyphId[0]; - let currentClass: number | null = getIndividualGlyphClass(table, classStart); - let search: number = glyphId[0] + 1; + let classStart: number = glyphId[0]; + let currentClass: number | null = getIndividualGlyphClass(table, classStart); + let search: number = glyphId[0] + 1; - const result = new Map<[number, number] | number, number | null>(); + 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) { + while (search < glyphId[1]) { + const clazz = getIndividualGlyphClass(table, search); + if (clazz !== currentClass) { + if (search - classStart <= 1) { result.set(classStart, currentClass); - } else { + } else { result.set([classStart, search], currentClass); + } } + search++; + } - return result; + if (search - classStart <= 1) { + result.set(classStart, currentClass); + } else { + result.set([classStart, search], currentClass); + } + + return result; } function getIndividualGlyphClass(table: ClassDefTable.Format2, glyphId: number): number | null { - for (const range of table.ranges) { - if (range.start <= glyphId && range.end >= glyphId) { - return range.classId; - } + for (const range of table.ranges) { + if (range.start <= glyphId && range.end >= glyphId) { + return range.classId; } + } - return null; + 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; - } + 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 []; - } + if (range.end === range.start) { + results.push(range.start); + } else { + results.push([range.start, range.end + 1]); + } + } + return results; + default: + return []; + } } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts b/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts index 0ee3f42d..02d518d0 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts @@ -8,36 +8,36 @@ import { CoverageTable } from '../tables'; * @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; - } + 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: - let 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; - } + switch (table.format) { + case 1: + return table.glyphs.map((glyphId, index) => ({ glyphId, index })); + case 2: + let 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; + } } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/helper.ts b/addons/addon-ligatures/src/fontLigatures/processors/helper.ts index 7186a22d..c15c0c92 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/helper.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/helper.ts @@ -4,160 +4,160 @@ import { SubstitutionLookupRecord, Lookup } from '../tables'; import { getIndividualSubstitutionGlyph, getRangeSubstitutionGlyphs } from './substitution'; export interface EntryMeta { - entry: LookupTreeEntry; - substitutions: (number | null)[]; + entry: LookupTreeEntry; + substitutions: (number | null)[]; } export function processInputPosition( - glyphs: (number | [number, number])[], - position: number, - currentEntries: EntryMeta[], - lookupRecords: SubstitutionLookupRecord[], - lookups: Lookup[] + glyphs: (number | [number, number])[], + position: number, + currentEntries: EntryMeta[], + lookupRecords: SubstitutionLookupRecord[], + lookups: Lookup[] ): EntryMeta[] { - const nextEntries: EntryMeta[] = []; - 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] - }))); - } + const nextEntries: EntryMeta[] = []; + 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; + return nextEntries; } export function processLookaheadPosition( - glyphs: (number | [number, number])[], - currentEntries: EntryMeta[] + glyphs: (number | [number, number])[], + currentEntries: EntryMeta[] ): EntryMeta[] { - const nextEntries: EntryMeta[] = []; - for (const currentEntry of currentEntries) { - for (const glyph of glyphs) { - const entry: LookupTreeEntry = {}; - if (!currentEntry.entry.forward) { - currentEntry.entry.forward = { - individual: {}, - range: [] - }; - } - nextEntries.push({ - entry, - substitutions: currentEntry.substitutions - }); + const nextEntries: EntryMeta[] = []; + for (const currentEntry of currentEntries) { + for (const glyph of glyphs) { + const entry: LookupTreeEntry = {}; + if (!currentEntry.entry.forward) { + currentEntry.entry.forward = { + individual: {}, + range: [] + }; + } + nextEntries.push({ + entry, + substitutions: currentEntry.substitutions + }); - if (Array.isArray(glyph)) { - currentEntry.entry.forward.range.push({ - entry, - range: glyph - }); - } else { - currentEntry.entry.forward.individual[glyph] = entry; - } - } + if (Array.isArray(glyph)) { + currentEntry.entry.forward.range.push({ + entry, + range: glyph + }); + } else { + currentEntry.entry.forward.individual[glyph] = entry; + } } + } - return nextEntries; + return nextEntries; } export function processBacktrackPosition( - glyphs: (number | [number, number])[], - currentEntries: EntryMeta[] + glyphs: (number | [number, number])[], + currentEntries: EntryMeta[] ): EntryMeta[] { - const nextEntries: EntryMeta[] = []; - for (const currentEntry of currentEntries) { - for (const glyph of glyphs) { - const entry: LookupTreeEntry = {}; - if (!currentEntry.entry.reverse) { - currentEntry.entry.reverse = { - individual: {}, - range: [] - }; - } - nextEntries.push({ - entry, - substitutions: currentEntry.substitutions - }); + const nextEntries: EntryMeta[] = []; + for (const currentEntry of currentEntries) { + for (const glyph of glyphs) { + const entry: LookupTreeEntry = {}; + if (!currentEntry.entry.reverse) { + currentEntry.entry.reverse = { + individual: {}, + range: [] + }; + } + nextEntries.push({ + entry, + substitutions: currentEntry.substitutions + }); - if (Array.isArray(glyph)) { - currentEntry.entry.reverse.range.push({ - entry, - range: glyph - }); - } else { - currentEntry.entry.reverse.individual[glyph] = entry; - } - } + if (Array.isArray(glyph)) { + currentEntry.entry.reverse.range.push({ + entry, + range: glyph + }); + } else { + currentEntry.entry.reverse.individual[glyph] = entry; + } } + } - return nextEntries; + return nextEntries; } export function getInputTree(tree: LookupTree, substitutions: SubstitutionLookupRecord[], lookups: Lookup[], inputIndex: number, glyphId: number | [number, number]): { entry: LookupTreeEntry; substitution: number | null; }[] { - const result: { entry: LookupTreeEntry; 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: LookupTreeEntry = {}; - if (Array.isArray(range)) { - tree.range.push({ range, entry }); - } else { - tree.individual[range] = {}; - } - result.push({ entry, substitution }); - } + const result: { entry: LookupTreeEntry; 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: LookupTreeEntry = {}; + if (Array.isArray(range)) { + tree.range.push({ range, entry }); + } else { + tree.individual[range] = {}; + } + result.push({ entry, substitution }); } + } - return result; + return result; } function getSubstitutionAtPositionRange(substitutions: SubstitutionLookupRecord[], lookups: Lookup[], index: number, range: [number, number]): Map { - for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) { - for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.Type1).subtables) { - const sub = getRangeSubstitutionGlyphs( - substitutionTable, - range - ); + for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) { + for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.Type1).subtables) { + const sub = getRangeSubstitutionGlyphs( + substitutionTable, + range + ); - if (!Array.from(sub.values()).every(val => val !== null)) { - return sub; - } - } + if (!Array.from(sub.values()).every(val => val !== null)) { + return sub; + } } + } - return new Map([[range, null]]); + return new Map([[range, null]]); } function getSubstitutionAtPosition(substitutions: SubstitutionLookupRecord[], 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.Type1).subtables) { - const sub = getIndividualSubstitutionGlyph( - substitutionTable, - glyphId - ); + for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) { + for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.Type1).subtables) { + const sub = getIndividualSubstitutionGlyph( + substitutionTable, + glyphId + ); - if (sub !== null) { - return sub; - } - } + if (sub !== null) { + return sub; + } } + } - return null; + return null; } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts b/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts index 975d7a25..e277bd49 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts @@ -10,53 +10,53 @@ import getCoverageGlyphIndex from './coverage'; * @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> { - let replacementStart: number = glyphId[0]; - let currentReplacement: number | null = getIndividualSubstitutionGlyph(table, replacementStart); - let search: number = glyphId[0] + 1; + let replacementStart: number = glyphId[0]; + let currentReplacement: number | null = getIndividualSubstitutionGlyph(table, replacementStart); + let search: number = glyphId[0] + 1; - const result = new Map<[number, number] | number, number | null>(); + 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) { + while (search < glyphId[1]) { + const sub = getIndividualSubstitutionGlyph(table, search); + if (sub !== currentReplacement) { + if (search - replacementStart <= 1) { result.set(replacementStart, currentReplacement); - } else { + } else { result.set([replacementStart, search], currentReplacement); + } } - return result; + 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); + const coverageIndex = getCoverageGlyphIndex(table.coverage, glyphId); - // istanbul ignore next - invalid font - if (coverageIndex === null) { - return null; - } + // 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: - // tslint:disable-next-line - return table.substitute[coverageIndex] != null - ? table.substitute[coverageIndex] - : 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: + // tslint:disable-next-line + return table.substitute[coverageIndex] != null + ? table.substitute[coverageIndex] + : null; + } } diff --git a/addons/addon-ligatures/src/fontLigatures/tables.ts b/addons/addon-ligatures/src/fontLigatures/tables.ts index d3eccd08..ec6f3604 100644 --- a/addons/addon-ligatures/src/fontLigatures/tables.ts +++ b/addons/addon-ligatures/src/fontLigatures/tables.ts @@ -1,112 +1,112 @@ export type SubstitutionTable = SubstitutionTable.Format1 | SubstitutionTable.Format2; export namespace SubstitutionTable { - export interface Format1 { - substFormat: 1; - coverage: CoverageTable; - deltaGlyphId: number; - } + export interface Format1 { + substFormat: 1; + coverage: CoverageTable; + deltaGlyphId: number; + } - export interface Format2 { - substFormat: 2; - coverage: CoverageTable; - substitute: number[]; - } + export interface Format2 { + substFormat: 2; + coverage: CoverageTable; + substitute: number[]; + } } export type CoverageTable = CoverageTable.Format1 | CoverageTable.Format2; export namespace CoverageTable { - export interface Format1 { - format: 1; - glyphs: number[]; - } + export interface Format1 { + format: 1; + glyphs: number[]; + } - export interface Format2 { - format: 2; - ranges: { - start: number; - end: number; - index: number; - }[]; - } + export interface Format2 { + format: 2; + ranges: { + start: number; + end: number; + index: number; + }[]; + } } export type ChainingContextualSubstitutionTable = ChainingContextualSubstitutionTable.Format1 | - ChainingContextualSubstitutionTable.Format2 | ChainingContextualSubstitutionTable.Format3; + ChainingContextualSubstitutionTable.Format2 | ChainingContextualSubstitutionTable.Format3; export namespace ChainingContextualSubstitutionTable { - export interface Format1 { - substFormat: 1; - coverage: CoverageTable; - chainRuleSets: ChainSubRuleTable[][]; - } + export interface Format1 { + substFormat: 1; + coverage: CoverageTable; + chainRuleSets: ChainSubRuleTable[][]; + } - export interface Format2 { - substFormat: 2; - coverage: CoverageTable; - backtrackClassDef: ClassDefTable; - inputClassDef: ClassDefTable; - lookaheadClassDef: ClassDefTable; - chainClassSet: (null | ChainSubClassRuleTable[])[]; - } + export interface Format2 { + substFormat: 2; + coverage: CoverageTable; + backtrackClassDef: ClassDefTable; + inputClassDef: ClassDefTable; + lookaheadClassDef: ClassDefTable; + chainClassSet: (null | ChainSubClassRuleTable[])[]; + } - export interface Format3 { - substFormat: 3; - backtrackCoverage: CoverageTable[]; - inputCoverage: CoverageTable[]; - lookaheadCoverage: CoverageTable[]; - lookupRecords: SubstitutionLookupRecord[]; - } + export interface Format3 { + substFormat: 3; + backtrackCoverage: CoverageTable[]; + inputCoverage: CoverageTable[]; + lookaheadCoverage: CoverageTable[]; + lookupRecords: SubstitutionLookupRecord[]; + } } export interface ReverseChainingContextualSingleSubstitutionTable { - substFormat: 1; - coverage: CoverageTable; - backtrackCoverage: CoverageTable[]; - lookaheadCoverage: CoverageTable[]; - substitutes: number[]; + substFormat: 1; + coverage: CoverageTable; + backtrackCoverage: CoverageTable[]; + lookaheadCoverage: CoverageTable[]; + substitutes: number[]; } export type ClassDefTable = ClassDefTable.Format2; export namespace ClassDefTable { - export interface Format2 { - format: 2; - ranges: { - start: number; - end: number; - classId: number; - }[]; - } + export interface Format2 { + format: 2; + ranges: { + start: number; + end: number; + classId: number; + }[]; + } } export interface SubstitutionLookupRecord { - sequenceIndex: number; - lookupListIndex: number; + sequenceIndex: number; + lookupListIndex: number; } export type ChainSubRuleTable = ChainSubClassRuleTable; export interface ChainSubClassRuleTable { - backtrack: number[]; - input: number[]; - lookahead: number[]; - lookupRecords: SubstitutionLookupRecord[]; + backtrack: number[]; + input: number[]; + lookahead: number[]; + lookupRecords: SubstitutionLookupRecord[]; } export type Lookup = Lookup.Type1 | Lookup.Type6 | Lookup.Type8; export namespace Lookup { - export interface Type1 { - lookupType: 1; - lookupFlag: number; - subtables: SubstitutionTable[]; - } + export interface Type1 { + lookupType: 1; + lookupFlag: number; + subtables: SubstitutionTable[]; + } - export interface Type6 { - lookupType: 6; - lookupFlag: number; - subtables: ChainingContextualSubstitutionTable[]; - } + export interface Type6 { + lookupType: 6; + lookupFlag: number; + subtables: ChainingContextualSubstitutionTable[]; + } - export interface Type8 { - lookupType: 8; - lookupFlag: number; - subtables: ReverseChainingContextualSingleSubstitutionTable[]; - } + export interface Type8 { + lookupType: 8; + lookupFlag: number; + subtables: ReverseChainingContextualSingleSubstitutionTable[]; + } } diff --git a/addons/addon-ligatures/src/fontLigatures/types.ts b/addons/addon-ligatures/src/fontLigatures/types.ts index 9364c75c..789fed38 100644 --- a/addons/addon-ligatures/src/fontLigatures/types.ts +++ b/addons/addon-ligatures/src/fontLigatures/types.ts @@ -1,86 +1,86 @@ export interface SubstitutionResult { - index: number; - contextRange: [number, number]; + index: number; + contextRange: [number, number]; } /** * Information about ligatures found in a sequence of text */ export interface LigatureData { - /** - * The list of font glyphs in the input text. - */ - inputGlyphs: number[]; + /** + * The list of font glyphs in the input text. + */ + inputGlyphs: number[]; - /** - * The list of font glyphs after performing replacements for font ligatures. - */ - outputGlyphs: 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][]; + /** + * 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 Font { - /** - * 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): LigatureData; + /** + * 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): LigatureData; - /** - * 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][]; + /** + * 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 Options { - /** - * Optional size of previous results to store, measured in total number of - * characters from input strings. Defaults to no cache (0) - */ - cacheSize?: number; + /** + * 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 LookupTree { - individual: { - [glyphId: string]: LookupTreeEntry; - }; - range: { - range: [number, number]; - entry: LookupTreeEntry; - }[]; + individual: { + [glyphId: string]: LookupTreeEntry; + }; + range: { + range: [number, number]; + entry: LookupTreeEntry; + }[]; } export interface LookupTreeEntry { - lookup?: LookupResult; - forward?: LookupTree; - reverse?: LookupTree; + lookup?: LookupResult; + forward?: LookupTree; + reverse?: LookupTree; } export interface LookupResult { - substitutions: (number | null)[]; - length: number; - index: number; - subIndex: number; - contextRange: [number, number]; + substitutions: (number | null)[]; + length: number; + index: number; + subIndex: number; + contextRange: [number, number]; } export interface FlattenedLookupTree { - [glyphId: string]: FlattenedLookupTreeEntry; + [glyphId: string]: FlattenedLookupTreeEntry; } export interface FlattenedLookupTreeEntry { - lookup?: LookupResult; - forward?: FlattenedLookupTree; - reverse?: FlattenedLookupTree; + lookup?: LookupResult; + forward?: FlattenedLookupTree; + reverse?: FlattenedLookupTree; } diff --git a/addons/addon-ligatures/src/fontLigatures/walk.ts b/addons/addon-ligatures/src/fontLigatures/walk.ts index 56d6eac1..b122897e 100644 --- a/addons/addon-ligatures/src/fontLigatures/walk.ts +++ b/addons/addon-ligatures/src/fontLigatures/walk.ts @@ -1,67 +1,67 @@ import { FlattenedLookupTree, LookupResult } from './types'; export default function walkTree(tree: FlattenedLookupTree, sequence: number[], startIndex: number, index: number): LookupResult | undefined { - const glyphId = sequence[index]; - let subtree = tree[glyphId]; - if (!subtree) { - return undefined; - } + const glyphId = sequence[index]; + let subtree = tree[glyphId]; + if (!subtree) { + return undefined; + } - let lookup = subtree.lookup; - if (subtree.reverse) { - const reverseLookup = walkReverse(subtree.reverse, sequence, startIndex); - - if ( - (!lookup && reverseLookup) || - ( - reverseLookup && lookup && ( - lookup.index > reverseLookup.index || - (lookup.index === reverseLookup.index && lookup.subIndex > reverseLookup.subIndex) - ) - ) - ) { - lookup = reverseLookup; - } - } - - if (++index >= sequence.length || !subtree.forward) { - return lookup; - } - - const forwardLookup = walkTree(subtree.forward, sequence, startIndex, index); + let lookup = subtree.lookup; + if (subtree.reverse) { + const reverseLookup = walkReverse(subtree.reverse, sequence, startIndex); if ( - (!lookup && forwardLookup) || - ( - forwardLookup && lookup && ( - lookup.index > forwardLookup.index || - (lookup.index === forwardLookup.index && lookup.subIndex > forwardLookup.subIndex) - ) + (!lookup && reverseLookup) || + ( + reverseLookup && lookup && ( + lookup.index > reverseLookup.index || + (lookup.index === reverseLookup.index && lookup.subIndex > reverseLookup.subIndex) ) + ) ) { - lookup = forwardLookup; + lookup = reverseLookup; } + } + if (++index >= sequence.length || !subtree.forward) { return lookup; + } + + const forwardLookup = walkTree(subtree.forward, sequence, startIndex, index); + + if ( + (!lookup && forwardLookup) || + ( + forwardLookup && lookup && ( + lookup.index > forwardLookup.index || + (lookup.index === forwardLookup.index && lookup.subIndex > forwardLookup.subIndex) + ) + ) + ) { + lookup = forwardLookup; + } + + return lookup; } function walkReverse(tree: FlattenedLookupTree, sequence: number[], index: number): LookupResult | undefined { - let subtree = tree[sequence[--index]]; - let lookup: LookupResult | undefined = subtree && subtree.lookup; - while (subtree) { - if ( - (!lookup && subtree.lookup) || - (subtree.lookup && lookup && lookup.index > subtree.lookup.index) - ) { - lookup = subtree.lookup; - } - - if (--index < 0 || !subtree.reverse) { - break; - } - - subtree = subtree.reverse[sequence[index]]; + let subtree = tree[sequence[--index]]; + let lookup: LookupResult | undefined = subtree && subtree.lookup; + while (subtree) { + if ( + (!lookup && subtree.lookup) || + (subtree.lookup && lookup && lookup.index > subtree.lookup.index) + ) { + lookup = subtree.lookup; } - return lookup; + if (--index < 0 || !subtree.reverse) { + break; + } + + subtree = subtree.reverse[sequence[index]]; + } + + return lookup; } From f84384c83ac67f29637274adb4eef7c39c9e0808 Mon Sep 17 00:00:00 2001 From: Daniel Imms <2193314+Tyriar@users.noreply.github.com> Date: Sat, 3 Jan 2026 09:31:45 -0800 Subject: [PATCH 4/4] Fix lint --- .../src/fontLigatures/flatten.ts | 10 ++-- .../src/fontLigatures/index.test.ts | 26 +++++----- .../src/fontLigatures/index.ts | 30 +++++------ .../src/fontLigatures/merge.test.ts | 4 +- .../src/fontLigatures/merge.ts | 34 ++++++------- .../src/fontLigatures/mergeRange.ts | 18 ++++--- .../src/fontLigatures/processors/6-1.ts | 10 ++-- .../src/fontLigatures/processors/6-2.ts | 12 ++--- .../src/fontLigatures/processors/6-3.ts | 10 ++-- .../src/fontLigatures/processors/8-1.ts | 14 +++--- .../src/fontLigatures/processors/classDef.ts | 17 +++---- .../src/fontLigatures/processors/coverage.ts | 4 +- .../src/fontLigatures/processors/helper.ts | 46 ++++++++--------- .../fontLigatures/processors/substitution.ts | 6 +-- .../src/fontLigatures/tables.ts | 50 +++++++++---------- .../src/fontLigatures/types.ts | 38 +++++++------- .../addon-ligatures/src/fontLigatures/walk.ts | 10 ++-- 17 files changed, 170 insertions(+), 169 deletions(-) diff --git a/addons/addon-ligatures/src/fontLigatures/flatten.ts b/addons/addon-ligatures/src/fontLigatures/flatten.ts index f911b986..843f9acf 100644 --- a/addons/addon-ligatures/src/fontLigatures/flatten.ts +++ b/addons/addon-ligatures/src/fontLigatures/flatten.ts @@ -1,7 +1,7 @@ -import { LookupTree, FlattenedLookupTree, LookupTreeEntry, FlattenedLookupTreeEntry } from './types'; +import { ILookupTree, IFlattenedLookupTree, ILookupTreeEntry, IFlattenedLookupTreeEntry } from './types'; -export default function flatten(tree: LookupTree): FlattenedLookupTree { - const result: FlattenedLookupTree = {}; +export default function flatten(tree: ILookupTree): IFlattenedLookupTree { + const result: IFlattenedLookupTree = {}; for (const [glyphId, entry] of Object.entries(tree.individual)) { result[glyphId] = flattenEntry(entry); } @@ -16,8 +16,8 @@ export default function flatten(tree: LookupTree): FlattenedLookupTree { return result; } -function flattenEntry(entry: LookupTreeEntry): FlattenedLookupTreeEntry { - const result: FlattenedLookupTreeEntry = {}; +function flattenEntry(entry: ILookupTreeEntry): IFlattenedLookupTreeEntry { + const result: IFlattenedLookupTreeEntry = {}; if (entry.forward) { result.forward = flatten(entry.forward); diff --git a/addons/addon-ligatures/src/fontLigatures/index.test.ts b/addons/addon-ligatures/src/fontLigatures/index.test.ts index d8af5dfa..7f4949b1 100644 --- a/addons/addon-ligatures/src/fontLigatures/index.test.ts +++ b/addons/addon-ligatures/src/fontLigatures/index.test.ts @@ -8,31 +8,31 @@ import * as fs from 'fs'; import { assert } from 'chai'; import { loadBuffer } from './index'; -interface Font { - findLigatures(text: string): { outputGlyphs: number[]; contextRanges: [number, number][] }; +interface IFont { + findLigatures(text: string): { outputGlyphs: number[], contextRanges: [number, number][] }; findLigatureRanges(text: string): [number, number][]; } -interface TestCase { +interface ITestCase { font: string; input: string; glyphs: number[]; ranges: [number, number][]; } -const fira = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => +const fira = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase => ({ font: 'Fira Code', input, glyphs, ranges }); -const iosevka = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => +const iosevka = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase => ({ font: 'Iosevka', input, glyphs, ranges }); -const monoid = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => +const monoid = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase => ({ font: 'Monoid', input, glyphs, ranges }); -const ubuntu = (input: string, glyphs: number[], ranges: [number, number][]): TestCase => +const ubuntu = (input: string, glyphs: number[], ranges: [number, number][]): ITestCase => ({ font: 'Ubuntu Mono', input, glyphs, ranges }); -const firaCases: TestCase[] = [ +const firaCases: ITestCase[] = [ fira('abc', [133, 145, 146], []), fira('.=', [1614, 1081], [[0, 2]]), fira('..=', [1614, 1614, 1083], [[0, 3]]), @@ -168,7 +168,7 @@ const firaCases: TestCase[] = [ fira('===>', [1614, 1614, 1486, 1148], [[0, 4]]) ]; -const iosevkaCases: TestCase[] = [ +const iosevkaCases: ITestCase[] = [ iosevka('<-', [31, 3127], [[0, 2]]), iosevka('<--', [31, 3129, 3139], [[0, 3]]), iosevka('<---', [31, 3129, 3150, 3139], [[0, 4]]), @@ -218,7 +218,7 @@ const iosevkaCases: TestCase[] = [ iosevka('!===', [3100, 3085, 3085, 3084], [[0, 4]]) ]; -const monoidCases: TestCase[] = [ +const monoidCases: ITestCase[] = [ monoid('', [779, 779, 628], [[0, 3]]), monoid('<--', [776, 776, 627], [[0, 3]]), @@ -256,7 +256,7 @@ const monoidCases: TestCase[] = [ monoid('__', [763, 764], [[0, 2]]) ]; -const ubuntuCases: TestCase[] = [ +const ubuntuCases: ITestCase[] = [ ubuntu('==>', [32, 32, 33], []) ]; @@ -267,9 +267,9 @@ const fontPaths: Record = { 'Ubuntu Mono': path.join(__dirname, '../../fonts/UbuntuMono-Regular.ttf') }; -const fontCache: Map = new Map(); +const fontCache: Map = new Map(); -function loadFont(fontName: string): Font { +function loadFont(fontName: string): IFont { let font = fontCache.get(fontName); if (!font) { const fontPath = fontPaths[fontName]; diff --git a/addons/addon-ligatures/src/fontLigatures/index.ts b/addons/addon-ligatures/src/fontLigatures/index.ts index f15bd32a..d65e73bc 100644 --- a/addons/addon-ligatures/src/fontLigatures/index.ts +++ b/addons/addon-ligatures/src/fontLigatures/index.ts @@ -1,7 +1,7 @@ import * as opentype from 'opentype.js'; import LRUCache = require('lru-cache'); -import { Font, LigatureData, FlattenedLookupTree, LookupTree, Options } from './types'; +import { IFont, ILigatureData, IFlattenedLookupTree, ILookupTree, IOptions } from './types'; import mergeTrees from './merge'; import walkTree from './walk'; import mergeRange from './mergeRange'; @@ -12,19 +12,19 @@ import buildTreeGsubType6Format3 from './processors/6-3'; import buildTreeGsubType8Format1 from './processors/8-1'; import flatten from './flatten'; -class FontImpl implements Font { +class FontImpl implements IFont { private _font: opentype.Font; - private _lookupTrees: { tree: FlattenedLookupTree; processForward: boolean; }[] = []; + private _lookupTrees: { tree: IFlattenedLookupTree, processForward: boolean }[] = []; private _glyphLookups: { [glyphId: string]: number[] } = {}; - private _cache?: LRUCache; + private _cache?: LRUCache; - constructor(font: opentype.Font, options: Required) { + constructor(font: opentype.Font, options: Required) { this._font = font; if (options.cacheSize > 0) { this._cache = new LRUCache({ max: options.cacheSize, - length: ((val: LigatureData | [number, number][], key: string) => key.length) as any + length: ((val: ILigatureData | [number, number][], key: string) => key.length) as any }); } @@ -36,7 +36,7 @@ class FontImpl implements Font { const lookupGroups = allLookups.filter((l: unknown, i: number) => lookupIndices.some(idx => idx === i)); for (const [index, lookup] of lookupGroups.entries()) { - const trees: LookupTree[] = []; + const trees: ILookupTree[] = []; switch (lookup.lookupType) { case 6: for (const [index, table] of lookup.subtables.entries()) { @@ -77,7 +77,7 @@ class FontImpl implements Font { } } - findLigatures(text: string): LigatureData { + public findLigatures(text: string): ILigatureData { const cached = this._cache && this._cache.get(text); if (cached && !Array.isArray(cached)) { return cached; @@ -100,7 +100,7 @@ class FontImpl implements Font { } const result = this._findInternal(glyphIds.slice()); - const finalResult: LigatureData = { + const finalResult: ILigatureData = { inputGlyphs: glyphIds, outputGlyphs: result.sequence, contextRanges: result.ranges @@ -112,7 +112,7 @@ class FontImpl implements Font { return finalResult; } - findLigatureRanges(text: string): [number, number][] { + public findLigatureRanges(text: string): [number, number][] { // Short circuit the process if there are no possible ligatures in the // font if (this._lookupTrees.length === 0) { @@ -137,7 +137,7 @@ class FontImpl implements Font { return result.ranges; } - private _findInternal(sequence: number[]): { sequence: number[]; ranges: [number, number][]; } { + private _findInternal(sequence: number[]): { sequence: number[], ranges: [number, number][] } { const ranges: [number, number][] = []; let nextLookup = this._getNextLookup(sequence, 0); @@ -207,8 +207,8 @@ class FontImpl implements Font { * @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; } = { + 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 @@ -251,7 +251,7 @@ class FontImpl implements Font { * * @param buffer ArrayBuffer of the font to load */ -export function loadBuffer(buffer: ArrayBuffer, options?: Options): Font { +export function loadBuffer(buffer: ArrayBuffer, options?: IOptions): IFont { const font = opentype.parse(buffer); return new FontImpl(font, { cacheSize: 0, @@ -259,4 +259,4 @@ export function loadBuffer(buffer: ArrayBuffer, options?: Options): Font { }); } -export { Font, LigatureData, Options }; +export { IFont as Font, ILigatureData as LigatureData, IOptions as Options }; diff --git a/addons/addon-ligatures/src/fontLigatures/merge.test.ts b/addons/addon-ligatures/src/fontLigatures/merge.test.ts index e56c8dae..d4e138a8 100644 --- a/addons/addon-ligatures/src/fontLigatures/merge.test.ts +++ b/addons/addon-ligatures/src/fontLigatures/merge.test.ts @@ -6,7 +6,7 @@ import { assert } from 'chai'; import mergeTrees from './merge'; -interface LookupResult { +interface ILookupResult { contextRange: [number, number]; index: number; subIndex: number; @@ -14,7 +14,7 @@ interface LookupResult { substitutions: number[]; } -function lookup(substitutionGlyph: number, index?: number, subIndex?: number): LookupResult { +function lookup(substitutionGlyph: number, index?: number, subIndex?: number): ILookupResult { return { contextRange: [0, 1], index: index || 0, diff --git a/addons/addon-ligatures/src/fontLigatures/merge.ts b/addons/addon-ligatures/src/fontLigatures/merge.ts index 13c87733..3e127048 100644 --- a/addons/addon-ligatures/src/fontLigatures/merge.ts +++ b/addons/addon-ligatures/src/fontLigatures/merge.ts @@ -1,4 +1,4 @@ -import { LookupTree, LookupTreeEntry } from './types'; +import { ILookupTree, ILookupTreeEntry } from './types'; /** * Merges the provided trees into a single lookup tree. When conflicting lookups @@ -8,8 +8,8 @@ import { LookupTree, LookupTreeEntry } from './types'; * @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: LookupTree[]): LookupTree { - const result: LookupTree = { +export default function mergeTrees(trees: ILookupTree[]): ILookupTree { + const result: ILookupTree = { individual: {}, range: [] }; @@ -27,7 +27,7 @@ export default function mergeTrees(trees: LookupTree[]): LookupTree { * @param mainTree The tree where the values should be merged * @param mergeTree The tree to be merged into the mainTree */ -function mergeSubtree(mainTree: LookupTree, mergeTree: LookupTree): void { +function mergeSubtree(mainTree: ILookupTree, mergeTree: ILookupTree): 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 @@ -91,7 +91,7 @@ function mergeSubtree(mainTree: LookupTree, mergeTree: LookupTree): void { mainTree.range.splice(index, 1); index--; - const entryToMerge: LookupTreeEntry = cloneEntry(resultEntry); + const entryToMerge: ILookupTreeEntry = cloneEntry(resultEntry); if (Array.isArray(overlap.both)) { mainTree.range.push({ range: overlap.both, @@ -192,7 +192,7 @@ function mergeSubtree(mainTree: LookupTree, mergeTree: LookupTree): void { * @param mainTree The entry where the values should be merged * @param mergeTree The entry to merge into the mainTree */ -function mergeTreeEntry(mainTree: LookupTreeEntry, mergeTree: LookupTreeEntry): void { +function mergeTreeEntry(mainTree: ILookupTreeEntry, mergeTree: ILookupTreeEntry): void { if ( mergeTree.lookup && ( !mainTree.lookup || @@ -220,7 +220,7 @@ function mergeTreeEntry(mainTree: LookupTreeEntry, mergeTree: LookupTreeEntry): } } -interface Overlap { +interface IOverlap { first: (number | [number, number])[]; second: (number | [number, number])[]; both: number | [number, number] | null; @@ -233,8 +233,8 @@ interface Overlap { * @param first First range * @param second Second range */ -function getRangeOverlap(first: [number, number], second: [number, number]): Overlap { - const result: Overlap = { +function getRangeOverlap(first: [number, number], second: [number, number]): IOverlap { + const result: IOverlap = { first: [], second: [], both: null @@ -280,7 +280,7 @@ function getRangeOverlap(first: [number, number], second: [number, number]): Ove * @param first Individual glyph * @param second Range */ -function getIndividualOverlap(first: number, second: [number, number]): Overlap { +function getIndividualOverlap(first: number, second: [number, number]): IOverlap { // Disjoint if (first < second[0] || first > second[1]) { return { @@ -290,7 +290,7 @@ function getIndividualOverlap(first: number, second: [number, number]): Overlap }; } - const result: Overlap = { + const result: IOverlap = { first: [], second: [], both: first @@ -317,9 +317,9 @@ function getIndividualOverlap(first: number, second: [number, number]): Overlap function rangeOrIndividual(start: number, end: number): number | [number, number] { if (end - start === 1) { return start; - } else { - return [start, end]; } + return [start, end]; + } /** @@ -327,8 +327,8 @@ function rangeOrIndividual(start: number, end: number): number | [number, number * * @param entry Lookup tree entry to clone */ -function cloneEntry(entry: LookupTreeEntry): LookupTreeEntry { - const result: LookupTreeEntry = {}; +function cloneEntry(entry: ILookupTreeEntry): ILookupTreeEntry { + const result: ILookupTreeEntry = {}; if (entry.forward) { result.forward = cloneTree(entry.forward); @@ -356,8 +356,8 @@ function cloneEntry(entry: LookupTreeEntry): LookupTreeEntry { * * @param tree Lookup tree to clone */ -function cloneTree(tree: LookupTree): LookupTree { - const individual: { [glyphId: string]: LookupTreeEntry; } = {}; +function cloneTree(tree: ILookupTree): ILookupTree { + const individual: { [glyphId: string]: ILookupTreeEntry } = {}; for (const [glyphId, entry] of Object.entries(tree.individual)) { individual[glyphId] = cloneEntry(entry); } diff --git a/addons/addon-ligatures/src/fontLigatures/mergeRange.ts b/addons/addon-ligatures/src/fontLigatures/mergeRange.ts index 2b9ac6b7..ec530508 100644 --- a/addons/addon-ligatures/src/fontLigatures/mergeRange.ts +++ b/addons/addon-ligatures/src/fontLigatures/mergeRange.ts @@ -16,12 +16,14 @@ export default function mergeRange(ranges: [number, number][], newRangeStart: nu // Case 1: New range is before the search range ranges.splice(i, 0, [newRangeStart, newRangeEnd]); return ranges; - } else if (newRangeEnd <= range[1]) { + } + 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; - } else if (newRangeStart < range[1]) { + } + 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]); @@ -36,19 +38,19 @@ export default function mergeRange(ranges: [number, number][], newRangeStart: nu // reach the current one ranges[i - 1][1] = newRangeEnd; return ranges; - } else if (newRangeEnd <= range[1]) { + } + 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; - } else { - // Case 7: New range extends from previous range past the - // end of the current range - ranges.splice(i, 1); - i--; } + // Case 7: New range extends from previous range past the + // end of the current range + ranges.splice(i, 1); + i--; } } diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts index dc2e8917..c7f03b53 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-1.ts @@ -1,8 +1,8 @@ import { ChainingContextualSubstitutionTable, Lookup } from '../tables'; -import { LookupTree } from '../types'; +import { ILookupTree } from '../types'; import { listGlyphsByIndex } from './coverage'; -import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, EntryMeta } from './helper'; +import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper'; /** * Build lookup tree for GSUB lookup table 6, format 1. @@ -12,8 +12,8 @@ import { processInputPosition, processLookaheadPosition, processBacktrackPositio * @param lookups List of lookup tables * @param tableIndex Index of this table in the overall lookup */ -export default function buildTree(table: ChainingContextualSubstitutionTable.Format1, lookups: Lookup[], tableIndex: number): LookupTree { - const result: LookupTree = { +export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat1, lookups: Lookup[], tableIndex: number): ILookupTree { + const result: ILookupTree = { individual: {}, range: [] }; @@ -29,7 +29,7 @@ export default function buildTree(table: ChainingContextualSubstitutionTable.For } for (const [subIndex, subTable] of chainRuleSet.entries()) { - let currentEntries: EntryMeta[] = getInputTree( + let currentEntries: IEntryMeta[] = getInputTree( result, subTable.lookupRecords, lookups, diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts index f0f9245c..f3968242 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-2.ts @@ -1,10 +1,10 @@ import { ChainingContextualSubstitutionTable, Lookup } from '../tables'; -import { LookupTree } from '../types'; +import { ILookupTree } from '../types'; import mergeTrees from '../merge'; import { listGlyphsByIndex } from './coverage'; import getGlyphClass, { listClassGlyphs } from './classDef'; -import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, EntryMeta } from './helper'; +import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper'; /** * Build lookup tree for GSUB lookup table 6, format 2. @@ -14,8 +14,8 @@ import { processInputPosition, processLookaheadPosition, processBacktrackPositio * @param lookups List of lookup tables * @param tableIndex Index of this table in the overall lookup */ -export default function buildTree(table: ChainingContextualSubstitutionTable.Format2, lookups: Lookup[], tableIndex: number): LookupTree { - const results: LookupTree[] = []; +export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat2, lookups: Lookup[], tableIndex: number): ILookupTree { + const results: ILookupTree[] = []; const firstGlyphs = listGlyphsByIndex(table.coverage); @@ -35,12 +35,12 @@ export default function buildTree(table: ChainingContextualSubstitutionTable.For } for (const [subIndex, subTable] of classSet.entries()) { - const result: LookupTree = { + const result: ILookupTree = { individual: {}, range: [] }; - let currentEntries: EntryMeta[] = getInputTree( + let currentEntries: IEntryMeta[] = getInputTree( result, subTable.lookupRecords, lookups, diff --git a/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts b/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts index 07e4681f..334e6a56 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/6-3.ts @@ -1,8 +1,8 @@ import { ChainingContextualSubstitutionTable, Lookup } from '../tables'; -import { LookupTree } from '../types'; +import { ILookupTree } from '../types'; import { listGlyphsByIndex } from './coverage'; -import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, EntryMeta } from './helper'; +import { processInputPosition, processLookaheadPosition, processBacktrackPosition, getInputTree, IEntryMeta } from './helper'; /** * Build lookup tree for GSUB lookup table 6, format 3. @@ -12,8 +12,8 @@ import { processInputPosition, processLookaheadPosition, processBacktrackPositio * @param lookups List of lookup tables * @param tableIndex Index of this table in the overall lookup */ -export default function buildTree(table: ChainingContextualSubstitutionTable.Format3, lookups: Lookup[], tableIndex: number): LookupTree { - const result: LookupTree = { +export default function buildTree(table: ChainingContextualSubstitutionTable.IFormat3, lookups: Lookup[], tableIndex: number): ILookupTree { + const result: ILookupTree = { individual: {}, range: [] }; @@ -21,7 +21,7 @@ export default function buildTree(table: ChainingContextualSubstitutionTable.For const firstGlyphs = listGlyphsByIndex(table.inputCoverage[0]); for (const { glyphId } of firstGlyphs) { - let currentEntries: EntryMeta[] = getInputTree( + let currentEntries: IEntryMeta[] = getInputTree( result, table.lookupRecords, lookups, diff --git a/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts b/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts index 8f127f6b..536b38c7 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/8-1.ts @@ -1,8 +1,8 @@ -import { ReverseChainingContextualSingleSubstitutionTable } from '../tables'; -import { LookupTree, LookupTreeEntry } from '../types'; +import { IReverseChainingContextualSingleSubstitutionTable } from '../tables'; +import { ILookupTree, ILookupTreeEntry } from '../types'; import { listGlyphsByIndex } from './coverage'; -import { processLookaheadPosition, processBacktrackPosition, EntryMeta } from './helper'; +import { processLookaheadPosition, processBacktrackPosition, IEntryMeta } from './helper'; /** * Build lookup tree for GSUB lookup table 8, format 1. @@ -11,8 +11,8 @@ import { processLookaheadPosition, processBacktrackPosition, EntryMeta } from '. * @param table JSON representation of the table * @param tableIndex Index of this table in the overall lookup */ -export default function buildTree(table: ReverseChainingContextualSingleSubstitutionTable, tableIndex: number): LookupTree { - const result: LookupTree = { +export default function buildTree(table: IReverseChainingContextualSingleSubstitutionTable, tableIndex: number): ILookupTree { + const result: ILookupTree = { individual: {}, range: [] }; @@ -20,7 +20,7 @@ export default function buildTree(table: ReverseChainingContextualSingleSubstitu const glyphs = listGlyphsByIndex(table.coverage); for (const { glyphId, index } of glyphs) { - const initialEntry: LookupTreeEntry = {}; + const initialEntry: ILookupTreeEntry = {}; if (Array.isArray(glyphId)) { result.range.push({ entry: initialEntry, @@ -30,7 +30,7 @@ export default function buildTree(table: ReverseChainingContextualSingleSubstitu result.individual[glyphId] = initialEntry; } - let currentEntries: EntryMeta[] = [{ + let currentEntries: IEntryMeta[] = [{ entry: initialEntry, substitutions: [table.substitutes[index]] }]; diff --git a/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts b/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts index bcf98ea6..5dac85a1 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/classDef.ts @@ -13,21 +13,20 @@ export default function getGlyphClass(table: ClassDefTable, glyphId: number | [n case 2: if (Array.isArray(glyphId)) { return getRangeGlyphClass(table, glyphId); - } else { - return new Map([[ - glyphId, - getIndividualGlyphClass(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.Format2, glyphId: [number, number]): Map { - let classStart: number = glyphId[0]; - let currentClass: number | null = getIndividualGlyphClass(table, classStart); +function getRangeGlyphClass(table: ClassDefTable.IFormat2, glyphId: [number, number]): Map { + 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>(); @@ -53,7 +52,7 @@ function getRangeGlyphClass(table: ClassDefTable.Format2, glyphId: [number, numb return result; } -function getIndividualGlyphClass(table: ClassDefTable.Format2, glyphId: number): number | null { +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; diff --git a/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts b/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts index 02d518d0..b287a2f7 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/coverage.ts @@ -25,12 +25,12 @@ export default function getCoverageGlyphIndex(table: CoverageTable, glyphId: num } } -export function listGlyphsByIndex(table: CoverageTable): { glyphId: number | [number, number]; index: number; }[] { +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: - let results: { glyphId: number | [number, number]; index: number; }[] = []; + 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 }); diff --git a/addons/addon-ligatures/src/fontLigatures/processors/helper.ts b/addons/addon-ligatures/src/fontLigatures/processors/helper.ts index c15c0c92..b05e1e2e 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/helper.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/helper.ts @@ -1,21 +1,21 @@ -import { LookupTreeEntry, LookupTree } from '../types'; -import { SubstitutionLookupRecord, Lookup } from '../tables'; +import { ILookupTreeEntry, ILookupTree } from '../types'; +import { ISubstitutionLookupRecord, Lookup } from '../tables'; import { getIndividualSubstitutionGlyph, getRangeSubstitutionGlyphs } from './substitution'; -export interface EntryMeta { - entry: LookupTreeEntry; +export interface IEntryMeta { + entry: ILookupTreeEntry; substitutions: (number | null)[]; } export function processInputPosition( glyphs: (number | [number, number])[], position: number, - currentEntries: EntryMeta[], - lookupRecords: SubstitutionLookupRecord[], + currentEntries: IEntryMeta[], + lookupRecords: ISubstitutionLookupRecord[], lookups: Lookup[] -): EntryMeta[] { - const nextEntries: EntryMeta[] = []; +): IEntryMeta[] { + const nextEntries: IEntryMeta[] = []; for (const currentEntry of currentEntries) { currentEntry.entry.forward = { individual: {}, @@ -40,12 +40,12 @@ export function processInputPosition( export function processLookaheadPosition( glyphs: (number | [number, number])[], - currentEntries: EntryMeta[] -): EntryMeta[] { - const nextEntries: EntryMeta[] = []; + currentEntries: IEntryMeta[] +): IEntryMeta[] { + const nextEntries: IEntryMeta[] = []; for (const currentEntry of currentEntries) { for (const glyph of glyphs) { - const entry: LookupTreeEntry = {}; + const entry: ILookupTreeEntry = {}; if (!currentEntry.entry.forward) { currentEntry.entry.forward = { individual: {}, @@ -73,12 +73,12 @@ export function processLookaheadPosition( export function processBacktrackPosition( glyphs: (number | [number, number])[], - currentEntries: EntryMeta[] -): EntryMeta[] { - const nextEntries: EntryMeta[] = []; + currentEntries: IEntryMeta[] +): IEntryMeta[] { + const nextEntries: IEntryMeta[] = []; for (const currentEntry of currentEntries) { for (const glyph of glyphs) { - const entry: LookupTreeEntry = {}; + const entry: ILookupTreeEntry = {}; if (!currentEntry.entry.reverse) { currentEntry.entry.reverse = { individual: {}, @@ -104,8 +104,8 @@ export function processBacktrackPosition( return nextEntries; } -export function getInputTree(tree: LookupTree, substitutions: SubstitutionLookupRecord[], lookups: Lookup[], inputIndex: number, glyphId: number | [number, number]): { entry: LookupTreeEntry; substitution: number | null; }[] { - const result: { entry: LookupTreeEntry; substitution: number | null; }[] = []; +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({ @@ -115,7 +115,7 @@ export function getInputTree(tree: LookupTree, substitutions: SubstitutionLookup } else { const subs = getSubstitutionAtPositionRange(substitutions, lookups, inputIndex, glyphId); for (const [range, substitution] of subs) { - const entry: LookupTreeEntry = {}; + const entry: ILookupTreeEntry = {}; if (Array.isArray(range)) { tree.range.push({ range, entry }); } else { @@ -128,9 +128,9 @@ export function getInputTree(tree: LookupTree, substitutions: SubstitutionLookup return result; } -function getSubstitutionAtPositionRange(substitutions: SubstitutionLookupRecord[], lookups: Lookup[], index: number, range: [number, number]): Map { +function getSubstitutionAtPositionRange(substitutions: ISubstitutionLookupRecord[], lookups: Lookup[], index: number, range: [number, number]): Map { for (const substitution of substitutions.filter(s => s.sequenceIndex === index)) { - for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.Type1).subtables) { + for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.IType1).subtables) { const sub = getRangeSubstitutionGlyphs( substitutionTable, range @@ -145,9 +145,9 @@ function getSubstitutionAtPositionRange(substitutions: SubstitutionLookupRecord[ return new Map([[range, null]]); } -function getSubstitutionAtPosition(substitutions: SubstitutionLookupRecord[], lookups: Lookup[], index: number, glyphId: number): number | 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.Type1).subtables) { + for (const substitutionTable of (lookups[substitution.lookupListIndex] as Lookup.IType1).subtables) { const sub = getIndividualSubstitutionGlyph( substitutionTable, glyphId diff --git a/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts b/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts index e277bd49..5eae2476 100644 --- a/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts +++ b/addons/addon-ligatures/src/fontLigatures/processors/substitution.ts @@ -10,8 +10,8 @@ import getCoverageGlyphIndex from './coverage'; * @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> { - let replacementStart: number = glyphId[0]; - let currentReplacement: number | null = getIndividualSubstitutionGlyph(table, replacementStart); + 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>(); @@ -54,7 +54,7 @@ export function getIndividualSubstitutionGlyph(table: SubstitutionTable, glyphId return (glyphId + table.deltaGlyphId) % (2 ** 16); // https://docs.microsoft.com/en-us/typography/opentype/spec/gsub#12-single-substitution-format-2 case 2: - // tslint:disable-next-line + // eslint-disable-next-line eqeqeq return table.substitute[coverageIndex] != null ? table.substitute[coverageIndex] : null; diff --git a/addons/addon-ligatures/src/fontLigatures/tables.ts b/addons/addon-ligatures/src/fontLigatures/tables.ts index ec6f3604..a2433dbf 100644 --- a/addons/addon-ligatures/src/fontLigatures/tables.ts +++ b/addons/addon-ligatures/src/fontLigatures/tables.ts @@ -1,26 +1,26 @@ -export type SubstitutionTable = SubstitutionTable.Format1 | SubstitutionTable.Format2; +export type SubstitutionTable = SubstitutionTable.IFormat1 | SubstitutionTable.IFormat2; export namespace SubstitutionTable { - export interface Format1 { + export interface IFormat1 { substFormat: 1; coverage: CoverageTable; deltaGlyphId: number; } - export interface Format2 { + export interface IFormat2 { substFormat: 2; coverage: CoverageTable; substitute: number[]; } } -export type CoverageTable = CoverageTable.Format1 | CoverageTable.Format2; +export type CoverageTable = CoverageTable.IFormat1 | CoverageTable.IFormat2; export namespace CoverageTable { - export interface Format1 { + export interface IFormat1 { format: 1; glyphs: number[]; } - export interface Format2 { + export interface IFormat2 { format: 2; ranges: { start: number; @@ -30,34 +30,34 @@ export namespace CoverageTable { } } -export type ChainingContextualSubstitutionTable = ChainingContextualSubstitutionTable.Format1 | - ChainingContextualSubstitutionTable.Format2 | ChainingContextualSubstitutionTable.Format3; +export type ChainingContextualSubstitutionTable = ChainingContextualSubstitutionTable.IFormat1 | + ChainingContextualSubstitutionTable.IFormat2 | ChainingContextualSubstitutionTable.IFormat3; export namespace ChainingContextualSubstitutionTable { - export interface Format1 { + export interface IFormat1 { substFormat: 1; coverage: CoverageTable; chainRuleSets: ChainSubRuleTable[][]; } - export interface Format2 { + export interface IFormat2 { substFormat: 2; coverage: CoverageTable; backtrackClassDef: ClassDefTable; inputClassDef: ClassDefTable; lookaheadClassDef: ClassDefTable; - chainClassSet: (null | ChainSubClassRuleTable[])[]; + chainClassSet: (null | IChainSubClassRuleTable[])[]; } - export interface Format3 { + export interface IFormat3 { substFormat: 3; backtrackCoverage: CoverageTable[]; inputCoverage: CoverageTable[]; lookaheadCoverage: CoverageTable[]; - lookupRecords: SubstitutionLookupRecord[]; + lookupRecords: ISubstitutionLookupRecord[]; } } -export interface ReverseChainingContextualSingleSubstitutionTable { +export interface IReverseChainingContextualSingleSubstitutionTable { substFormat: 1; coverage: CoverageTable; backtrackCoverage: CoverageTable[]; @@ -65,9 +65,9 @@ export interface ReverseChainingContextualSingleSubstitutionTable { substitutes: number[]; } -export type ClassDefTable = ClassDefTable.Format2; +export type ClassDefTable = ClassDefTable.IFormat2; export namespace ClassDefTable { - export interface Format2 { + export interface IFormat2 { format: 2; ranges: { start: number; @@ -77,36 +77,36 @@ export namespace ClassDefTable { } } -export interface SubstitutionLookupRecord { +export interface ISubstitutionLookupRecord { sequenceIndex: number; lookupListIndex: number; } -export type ChainSubRuleTable = ChainSubClassRuleTable; -export interface ChainSubClassRuleTable { +export type ChainSubRuleTable = IChainSubClassRuleTable; +export interface IChainSubClassRuleTable { backtrack: number[]; input: number[]; lookahead: number[]; - lookupRecords: SubstitutionLookupRecord[]; + lookupRecords: ISubstitutionLookupRecord[]; } -export type Lookup = Lookup.Type1 | Lookup.Type6 | Lookup.Type8; +export type Lookup = Lookup.IType1 | Lookup.IType6 | Lookup.IType8; export namespace Lookup { - export interface Type1 { + export interface IType1 { lookupType: 1; lookupFlag: number; subtables: SubstitutionTable[]; } - export interface Type6 { + export interface IType6 { lookupType: 6; lookupFlag: number; subtables: ChainingContextualSubstitutionTable[]; } - export interface Type8 { + export interface IType8 { lookupType: 8; lookupFlag: number; - subtables: ReverseChainingContextualSingleSubstitutionTable[]; + subtables: IReverseChainingContextualSingleSubstitutionTable[]; } } diff --git a/addons/addon-ligatures/src/fontLigatures/types.ts b/addons/addon-ligatures/src/fontLigatures/types.ts index 789fed38..4d6f44a0 100644 --- a/addons/addon-ligatures/src/fontLigatures/types.ts +++ b/addons/addon-ligatures/src/fontLigatures/types.ts @@ -1,4 +1,4 @@ -export interface SubstitutionResult { +export interface ISubstitutionResult { index: number; contextRange: [number, number]; } @@ -6,7 +6,7 @@ export interface SubstitutionResult { /** * Information about ligatures found in a sequence of text */ -export interface LigatureData { +export interface ILigatureData { /** * The list of font glyphs in the input text. */ @@ -25,14 +25,14 @@ export interface LigatureData { contextRanges: [number, number][]; } -export interface Font { +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): LigatureData; + findLigatures(text: string): ILigatureData; /** * Scans the provided text for font ligatures, returning an array of ranges @@ -43,7 +43,7 @@ export interface Font { findLigatureRanges(text: string): [number, number][]; } -export interface Options { +export interface IOptions { /** * Optional size of previous results to store, measured in total number of * characters from input strings. Defaults to no cache (0) @@ -51,23 +51,23 @@ export interface Options { cacheSize?: number; } -export interface LookupTree { +export interface ILookupTree { individual: { - [glyphId: string]: LookupTreeEntry; + [glyphId: string]: ILookupTreeEntry; }; range: { range: [number, number]; - entry: LookupTreeEntry; + entry: ILookupTreeEntry; }[]; } -export interface LookupTreeEntry { - lookup?: LookupResult; - forward?: LookupTree; - reverse?: LookupTree; +export interface ILookupTreeEntry { + lookup?: ILookupResult; + forward?: ILookupTree; + reverse?: ILookupTree; } -export interface LookupResult { +export interface ILookupResult { substitutions: (number | null)[]; length: number; index: number; @@ -75,12 +75,12 @@ export interface LookupResult { contextRange: [number, number]; } -export interface FlattenedLookupTree { - [glyphId: string]: FlattenedLookupTreeEntry; +export interface IFlattenedLookupTree { + [glyphId: string]: IFlattenedLookupTreeEntry; } -export interface FlattenedLookupTreeEntry { - lookup?: LookupResult; - forward?: FlattenedLookupTree; - reverse?: FlattenedLookupTree; +export interface IFlattenedLookupTreeEntry { + lookup?: ILookupResult; + forward?: IFlattenedLookupTree; + reverse?: IFlattenedLookupTree; } diff --git a/addons/addon-ligatures/src/fontLigatures/walk.ts b/addons/addon-ligatures/src/fontLigatures/walk.ts index b122897e..cfcf1252 100644 --- a/addons/addon-ligatures/src/fontLigatures/walk.ts +++ b/addons/addon-ligatures/src/fontLigatures/walk.ts @@ -1,8 +1,8 @@ -import { FlattenedLookupTree, LookupResult } from './types'; +import { IFlattenedLookupTree, ILookupResult } from './types'; -export default function walkTree(tree: FlattenedLookupTree, sequence: number[], startIndex: number, index: number): LookupResult | undefined { +export default function walkTree(tree: IFlattenedLookupTree, sequence: number[], startIndex: number, index: number): ILookupResult | undefined { const glyphId = sequence[index]; - let subtree = tree[glyphId]; + const subtree = tree[glyphId]; if (!subtree) { return undefined; } @@ -45,9 +45,9 @@ export default function walkTree(tree: FlattenedLookupTree, sequence: number[], return lookup; } -function walkReverse(tree: FlattenedLookupTree, sequence: number[], index: number): LookupResult | undefined { +function walkReverse(tree: IFlattenedLookupTree, sequence: number[], index: number): ILookupResult | undefined { let subtree = tree[sequence[--index]]; - let lookup: LookupResult | undefined = subtree && subtree.lookup; + let lookup: ILookupResult | undefined = subtree && subtree.lookup; while (subtree) { if ( (!lookup && subtree.lookup) ||