@mark1russell7/typeset 0.1.2 → 0.1.3

package/src/fonts/kerning.ts

@@ -25,8 +25,22 @@ export interface PairLookup {
   readonly skip?: (glyph: number) => boolean;
   /** This function gives the value for a pair, or `undefined` when no subtable applies. */
   pair(first: number, second: number): PairValue | undefined;
+  /**
+   * This function gives the largest positive value of each glyph of a pair, over the pairs with two glyphs of `glyphs`.
+   * A value is at least 0. It uses the values of the instance, so it includes each variation delta.
+   */
+  largest(glyphs: ReadonlySet<number>): LargestKerning;
+}
+
+/** The largest positive kerning of the first glyph and of the second glyph of a pair, in font units. */
+export interface LargestKerning {
+  readonly first: number;
+  readonly second: number;
 }
 
+/** One PairPos subtable. */
+type PairSubtable = Pick<PairLookup, "pair" | "largest">;
+
 /** The lookup flags of OpenType. */
 export const IGNORE_BASE = 0x2;
 export const IGNORE_LIGATURES = 0x4;
@@ -63,8 +77,8 @@ function pairValue(first: { value: number; delta: number }, second: { value: num
   return { first: first.value, second: second.value, firstDelta: first.delta, secondDelta: second.delta, skipSecond };
 }
 
-/** This function makes the pair function of one PairPos subtable. */
-function pairSubtable(table: Reader, store: VariationStore | undefined): (first: number, second: number) => PairValue | undefined {
+/** This function makes the functions of one PairPos subtable. */
+function pairSubtable(table: Reader, store: VariationStore | undefined): PairSubtable {
   const format = table.u16(0);
   const coverage = table.part(table.u16(2));
   const format1 = table.u16(4);
@@ -73,11 +87,11 @@ function pairSubtable(table: Reader, store: VariationStore | undefined): (first:
   const size2 = valueSize(format2);
   const skipSecond = format2 !== 0;
   if (format === 1) {
-    return (first, second) => {
+    const recordSize = 2 + size1 + size2;
+    const pair = (first: number, second: number): PairValue | undefined => {
       const index = coverageIndex(coverage, first);
       if (index < 0) return undefined;
       const set = table.part(table.u16(10 + index * 2));
-      const recordSize = 2 + size1 + size2;
       let low = 0;
       let high = set.u16(0) - 1;
       while (low <= high) {
@@ -90,13 +104,30 @@ function pairSubtable(table: Reader, store: VariationStore | undefined): (first:
       }
       return undefined;
     };
+    const largest = (glyphs: ReadonlySet<number>): LargestKerning => {
+      let first = 0;
+      let second = 0;
+      for (const glyph of glyphs) {
+        const index = coverageIndex(coverage, glyph);
+        if (index < 0) continue;
+        const set = table.part(table.u16(10 + index * 2));
+        for (let record = 0; record < set.u16(0); record++) {
+          const at = 2 + record * recordSize;
+          if (!glyphs.has(set.u16(at))) continue;
+          first = Math.max(first, xAdvance(set, at + 2, format1, set, store).value);
+          second = Math.max(second, xAdvance(set, at + 2 + size1, format2, set, store).value);
+        }
+      }
+      return { first, second };
+    };
+    return { pair, largest };
   }
   if (format === 2) {
     const classes1 = table.part(table.u16(8));
     const classes2 = table.part(table.u16(10));
     const count1 = table.u16(12);
     const count2 = table.u16(14);
-    return (first, second) => {
+    const pair = (first: number, second: number): PairValue | undefined => {
       if (coverageIndex(coverage, first) < 0) return undefined;
       const class1 = classOf(classes1, first);
       const class2 = classOf(classes2, second);
@@ -104,6 +135,26 @@ function pairSubtable(table: Reader, store: VariationStore | undefined): (first:
       const at = 16 + (class1 * count2 + class2) * (size1 + size2);
       return pairValue(xAdvance(table, at, format1, table, store), xAdvance(table, at + size1, format2, table, store), skipSecond);
     };
+    const largest = (glyphs: ReadonlySet<number>): LargestKerning => {
+      const firsts = new Set<number>();
+      const seconds = new Set<number>();
+      for (const glyph of glyphs) {
+        if (coverageIndex(coverage, glyph) >= 0) firsts.add(classOf(classes1, glyph));
+        seconds.add(classOf(classes2, glyph));
+      }
+      let first = 0;
+      let second = 0;
+      for (const class1 of firsts) {
+        for (const class2 of seconds) {
+          if (class1 >= count1 || class2 >= count2) continue;
+          const at = 16 + (class1 * count2 + class2) * (size1 + size2);
+          first = Math.max(first, xAdvance(table, at, format1, table, store).value);
+          second = Math.max(second, xAdvance(table, at + size1, format2, table, store).value);
+        }
+      }
+      return { first, second };
+    };
+    return { pair, largest };
   }
   throw new Error(`the PairPos format ${format} is unknown`);
 }
@@ -150,7 +201,7 @@ export function readGposKerning(gpos: Reader, script: string, store?: VariationS
   }
   return [...indices].sort((a, b) => a - b).flatMap((index) => {
     const lookup = lookups.part(lookups.u16(2 + index * 2));
-    const subtables: ((first: number, second: number) => PairValue | undefined)[] = [];
+    const subtables: PairSubtable[] = [];
     const type = lookup.u16(0);
     for (let s = 0; s < lookup.u16(4); s++) {
       let subtable = lookup.part(lookup.u16(6 + s * 2));
@@ -176,11 +227,16 @@ export function readGposKerning(gpos: Reader, script: string, store?: VariationS
       ...(skip === undefined ? {} : { skip }),
       pair(first: number, second: number): PairValue | undefined {
         for (const subtable of subtables) {
-          const value = subtable(first, second);
+          const value = subtable.pair(first, second);
           if (value !== undefined) return value;
         }
         return undefined;
       },
+      // A pair gets the value of one subtable, so the largest value of a lookup is the largest value of its subtables
+      largest(glyphs: ReadonlySet<number>): LargestKerning {
+        const values = subtables.map((subtable) => subtable.largest(glyphs));
+        return { first: Math.max(...values.map((value) => value.first)), second: Math.max(...values.map((value) => value.second)) };
+      },
     }];
   });
 }
@@ -213,5 +269,10 @@ export function readKernTable(kern: Reader): PairLookup[] {
       const value = pairs.get(first * 0x10000 + second);
       return value === undefined ? undefined : { first: value, second: 0, skipSecond: false };
     },
+    largest(glyphs: ReadonlySet<number>): LargestKerning {
+      let first = 0;
+      for (const [key, value] of pairs) if (glyphs.has(Math.floor(key / 0x10000)) && glyphs.has(key % 0x10000)) first = Math.max(first, value);
+      return { first, second: 0 };
+    },
   }];
 }

package/src/fonts/substitution.ts

@@ -1,6 +1,6 @@
 import type { Reader } from "./binary.ts";
 import { IGNORE_BASE, IGNORE_LIGATURES, IGNORE_MARKS, scriptTags } from "./kerning.ts";
-import { classOf, coverageIndex } from "./tables.ts";
+import { classOf, coverageGlyphs, coverageIndex } from "./tables.ts";
 
 /**
  * The GSUB features that the default model applies: the features that HarfBuzz and Chromium apply to horizontal text
@@ -66,6 +66,16 @@ export interface GlyphInfo {
   readonly codePoint: number;
 }
 
+/** One substitution that a lookup can do, with no context. */
+export interface SubstitutionRule {
+  /** The glyph that the rule replaces. The first glyph of a ligature is this glyph. */
+  readonly from: number;
+  /** The glyphs that replace it. A multiple substitution can give no glyph. */
+  readonly to: readonly number[];
+  /** The other glyphs of a ligature, in order. Another rule has no such glyphs. */
+  readonly components?: readonly number[];
+}
+
 /** A lookup of GSUB for one script and one set of features. */
 export interface SubstitutionLookup {
   /** The index of the lookup in the lookup list of GSUB. */
@@ -93,6 +103,12 @@ export interface SubstitutionLookup {
    * `hb_ot_layout_lookup_would_substitute` with zero context tells it. A context rule with backtrack or lookahead does not apply.
    */
   wouldApply(glyphs: readonly number[]): boolean;
+  /**
+   * This function gives the rules of the lookup, and the rules of each lookup that it nests in a context rule. Each lookup
+   * has one list, and the list of this lookup is the first. The lists do not tell a context, so each nested rule counts.
+   * An alternate substitution gives one rule for each alternate.
+   */
+  rules(): readonly (readonly SubstitutionRule[])[];
 }
 
 /** One lookup of the lookup list, with the subtables of an extension lookup resolved. */
@@ -113,6 +129,71 @@ function records(table: Reader, at: number, count: number): SequenceRecord[] {
   return Array.from({ length: count }, (_, k) => ({ sequenceIndex: table.u16(at + k * 4), lookupIndex: table.u16(at + k * 4 + 2) }));
 }
 
+/** This function gives each rule table of the rule sets at `at` of a context subtable of format 1 or 2. An offset 0 is an empty set. */
+function ruleTables(t: Reader, at: number): Reader[] {
+  const tables: Reader[] = [];
+  for (let s = 0; s < t.u16(at); s++) {
+    const offset = t.u16(at + 2 + s * 2);
+    if (offset === 0) continue;
+    const set = t.part(offset);
+    for (let r = 0; r < set.u16(0); r++) tables.push(set.part(set.u16(2 + r * 2)));
+  }
+  return tables;
+}
+
+/** This function gives the records of each rule of a context subtable (lookup type 5). */
+function contextRecords(t: Reader): SequenceRecord[] {
+  const format = t.u16(0);
+  if (format === 3) return records(t, 6 + t.u16(2) * 2, t.u16(4));
+  return ruleTables(t, format === 2 ? 6 : 4).flatMap((rule) => records(rule, 4 + (rule.u16(0) - 1) * 2, rule.u16(2)));
+}
+
+/** This function gives the records of each rule of a chained context subtable (lookup type 6). */
+function chainRecords(t: Reader): SequenceRecord[] {
+  const format = t.u16(0);
+  if (format === 3) {
+    const inputAt = 4 + t.u16(2) * 2;
+    const aheadAt = inputAt + 2 + t.u16(inputAt) * 2;
+    const recordsAt = aheadAt + 2 + t.u16(aheadAt) * 2;
+    return records(t, recordsAt + 2, t.u16(recordsAt));
+  }
+  return ruleTables(t, format === 2 ? 10 : 4).flatMap((rule) => {
+    const inputAt = 2 + rule.u16(0) * 2;
+    const aheadAt = inputAt + 2 + Math.max(0, rule.u16(inputAt) - 1) * 2;
+    const recordsAt = aheadAt + 2 + rule.u16(aheadAt) * 2;
+    return records(rule, recordsAt + 2, rule.u16(recordsAt));
+  });
+}
+
+/** This function adds the rules of one subtable of a lookup type to `rules`, and each nested lookup to `nested`. */
+function readRules(type: number, t: Reader, rules: SubstitutionRule[], nested: number[]): void {
+  if (type === 5 || type === 6) {
+    for (const record of type === 5 ? contextRecords(t) : chainRecords(t)) nested.push(record.lookupIndex);
+    return;
+  }
+  if (type < 1 || type > 8 || type === 7) return;
+  const format = t.u16(0);
+  for (const [from, index] of coverageGlyphs(t.part(t.u16(2)))) {
+    if (type === 1) rules.push({ from, to: [format === 1 ? (from + t.i16(4)) & 0xffff : t.u16(6 + index * 2)] });
+    else if (type === 2) {
+      const sequence = t.part(t.u16(6 + index * 2));
+      rules.push({ from, to: Array.from({ length: sequence.u16(0) }, (_, k) => sequence.u16(2 + k * 2)) });
+    } else if (type === 3) {
+      const set = t.part(t.u16(6 + index * 2));
+      for (let k = 0; k < set.u16(0); k++) rules.push({ from, to: [set.u16(2 + k * 2)] });
+    } else if (type === 4) {
+      const set = t.part(t.u16(6 + index * 2));
+      for (let l = 0; l < set.u16(0); l++) {
+        const ligature = set.part(set.u16(2 + l * 2));
+        rules.push({ from, to: [ligature.u16(0)], components: Array.from({ length: ligature.u16(2) - 1 }, (_, k) => ligature.u16(4 + k * 2)) });
+      }
+    } else {
+      const aheadAt = 6 + t.u16(4) * 2;
+      rules.push({ from, to: [t.u16(aheadAt + 2 + t.u16(aheadAt) * 2 + 2 + index * 2)] });
+    }
+  }
+}
+
 /** The lookups of one GSUB table. It reads each lookup at its first use. */
 class Gsub {
   private readonly lookups: Reader;
@@ -392,6 +473,24 @@ class Gsub {
     });
   }
 
+  /** This function gives the rules of a lookup and of each lookup that it nests, as `rules` of `SubstitutionLookup` tells. */
+  rulesOf(index: number): SubstitutionRule[][] {
+    const lists: SubstitutionRule[][] = [];
+    const seen = new Set<number>();
+    const visit = (at: number): void => {
+      const lookup = this.lookup(at);
+      if (seen.has(at) || lookup === undefined) return;
+      seen.add(at);
+      const rules: SubstitutionRule[] = [];
+      const nested: number[] = [];
+      for (const subtable of lookup.subtables) readRules(lookup.type, subtable, rules, nested);
+      lists.push(rules);
+      nested.forEach(visit);
+    };
+    visit(index);
+    return lists;
+  }
+
   /** This function applies one subtable at `i`. It gives the next position, or -1 when the subtable does not match. */
   private subtable(lookup: Lookup, t: Reader, glyphs: number[], i: number, depth: number): number {
     const glyph = glyphs[i]!;
@@ -580,6 +679,7 @@ export function readSubstitutions(gsub: Reader, script: string, features: readon
       apply: (glyphs: number[], masks?: number[], mask?: number) => table.applyAll(index, glyphs, masks, mask),
       applyInfos: (glyphs: number[], infos: GlyphInfo[], mask: number, perSyllable: boolean) => table.applyRun(index, glyphs, infos, mask, perSyllable),
       wouldApply: (glyphs: readonly number[]) => table.wouldApply(index, glyphs),
+      rules: () => table.rulesOf(index),
     });
   }
   return result;

package/src/fonts/tables.ts

@@ -130,6 +130,28 @@ export function coverageIndex(table: Reader, glyph: number): number {
   throw new Error(`the Coverage format ${format} is unknown`);
 }
 
+/** This function gives each glyph of a Coverage table with its coverage index, in the order of the table. */
+export function coverageGlyphs(table: Reader): (readonly [glyph: number, index: number])[] {
+  const format = table.u16(0);
+  const count = table.u16(2);
+  const glyphs: (readonly [number, number])[] = [];
+  if (format === 1) {
+    for (let k = 0; k < count; k++) glyphs.push([table.u16(4 + k * 2), k]);
+    return glyphs;
+  }
+  if (format === 2) {
+    for (let k = 0; k < count; k++) {
+      const at = 4 + k * 6;
+      const start = table.u16(at);
+      const end = table.u16(at + 2);
+      const index = table.u16(at + 4);
+      for (let glyph = start; glyph <= end; glyph++) glyphs.push([glyph, index + glyph - start]);
+    }
+    return glyphs;
+  }
+  throw new Error(`the Coverage format ${format} is unknown`);
+}
+
 /** The GDEF glyph classes: 1 base, 2 ligature, 3 mark, 4 component. */
 export function readGlyphClasses(gdef: Reader | undefined): ((glyph: number) => number) {
   if (gdef === undefined) return () => 0;

package/src/fonts.ts

@@ -3,6 +3,7 @@
  * the width of a text as the text engine of a browser gives it. The host gives the bytes of the font files.
  */
 export { measureWidth, readFont, type Font, type MeasureOptions, type ReadOptions } from "./fonts/font.ts";
+export { widthBound, type WidthBound } from "./fonts/bound.ts";
 export { engines, isEngineName, type EngineName, type EngineRules } from "./fonts/engines.ts";
 export type { Decompress } from "./fonts/sfnt.ts";
 export type { Axis, Instance } from "./fonts/variations.ts";