text-shaper 0.0.1

package/dist/font/tables/fvar.d.ts

@@ -0,0 +1,77 @@
+import type { Fixed, Tag } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Font Variations table (fvar)
+ * Defines axes of variation in a variable font
+ */
+export interface FvarTable {
+    majorVersion: number;
+    minorVersion: number;
+    axes: VariationAxis[];
+    instances: NamedInstance[];
+}
+/**
+ * Variation axis definition
+ */
+export interface VariationAxis {
+    /** 4-byte axis tag (e.g., 'wght', 'wdth', 'ital') */
+    tag: Tag;
+    /** Minimum coordinate value */
+    minValue: Fixed;
+    /** Default coordinate value */
+    defaultValue: Fixed;
+    /** Maximum coordinate value */
+    maxValue: Fixed;
+    /** Axis qualifiers (flags) */
+    flags: number;
+    /** Name ID for this axis */
+    axisNameId: number;
+}
+/**
+ * Named instance (predefined variation)
+ */
+export interface NamedInstance {
+    /** Name ID for this instance */
+    subfamilyNameId: number;
+    /** Flags */
+    flags: number;
+    /** Coordinate values for each axis */
+    coordinates: Fixed[];
+    /** PostScript name ID (optional) */
+    postScriptNameId?: number;
+}
+/**
+ * Common axis tags
+ */
+export declare const AxisTags: {
+    /** Weight (100-900, default 400) */
+    readonly wght: 2003265652;
+    /** Width (50-200%, default 100) */
+    readonly wdth: 2003072104;
+    /** Italic (0-1) */
+    readonly ital: 1769234796;
+    /** Slant (-90 to 90 degrees) */
+    readonly slnt: 1936486004;
+    /** Optical size (in points) */
+    readonly opsz: 1869640570;
+};
+/**
+ * Parse fvar table
+ */
+export declare function parseFvar(reader: Reader): FvarTable;
+/**
+ * Normalize axis value to range [-1, 1]
+ */
+export declare function normalizeAxisValue(axis: VariationAxis, value: number): number;
+/**
+ * Get axis by tag
+ */
+export declare function getAxis(fvar: FvarTable, axisTag: Tag): VariationAxis | null;
+/**
+ * Get axis index by tag
+ */
+export declare function getAxisIndex(fvar: FvarTable, axisTag: Tag): number;
+/**
+ * Debug: Print axis info
+ */
+export declare function formatAxis(axis: VariationAxis): string;

package/dist/font/tables/gdef.d.ts

@@ -0,0 +1,45 @@
+import { type ClassDef } from "../../layout/structures/class-def.ts";
+import type { GlyphId, uint16 } from "../../types.ts";
+import { GlyphClass } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/** Attach point for a glyph */
+export interface AttachPoint {
+    pointIndices: uint16[];
+}
+/** Ligature caret for a ligature glyph */
+export interface LigatureCaret {
+    caretValues: number[];
+}
+/** Mark glyph sets */
+export interface MarkGlyphSets {
+    /** Check if glyph is in mark set */
+    has(setIndex: number, glyphId: GlyphId): boolean;
+}
+/** Glyph Definition table */
+export interface GdefTable {
+    version: {
+        major: number;
+        minor: number;
+    };
+    /** Glyph class definitions (Base=1, Ligature=2, Mark=3, Component=4) */
+    glyphClassDef: ClassDef;
+    /** Attachment point list (optional) */
+    attachList: Map<GlyphId, AttachPoint> | null;
+    /** Ligature caret list (optional) */
+    ligCaretList: Map<GlyphId, LigatureCaret> | null;
+    /** Mark attachment class definitions */
+    markAttachClassDef: ClassDef;
+    /** Mark glyph sets (version 1.2+) */
+    markGlyphSets: MarkGlyphSets | null;
+}
+export declare function parseGdef(reader: Reader): GdefTable;
+/** Get glyph class from GDEF */
+export declare function getGlyphClass(gdef: GdefTable | null, glyphId: GlyphId): GlyphClass | 0;
+/** Check if glyph is a base glyph */
+export declare function isBaseGlyph(gdef: GdefTable | null, glyphId: GlyphId): boolean;
+/** Check if glyph is a ligature */
+export declare function isLigature(gdef: GdefTable | null, glyphId: GlyphId): boolean;
+/** Check if glyph is a mark */
+export declare function isMark(gdef: GdefTable | null, glyphId: GlyphId): boolean;
+/** Check if glyph is a component */
+export declare function isComponent(gdef: GdefTable | null, glyphId: GlyphId): boolean;

package/dist/font/tables/glyf.d.ts

@@ -0,0 +1,118 @@
+import type { GlyphId, int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+import type { GvarTable, PointDelta } from "./gvar.ts";
+import type { LocaTable } from "./loca.ts";
+/**
+ * glyf table - Glyph outline data
+ * Contains TrueType glyph contours as quadratic Bézier curves
+ */
+/** Point flags */
+export declare const PointFlag: {
+    readonly OnCurve: 1;
+    readonly XShortVector: 2;
+    readonly YShortVector: 4;
+    readonly Repeat: 8;
+    readonly XIsSameOrPositive: 16;
+    readonly YIsSameOrPositive: 32;
+    readonly OverlapSimple: 64;
+};
+/** Composite glyph flags */
+export declare const CompositeFlag: {
+    readonly Arg1And2AreWords: 1;
+    readonly ArgsAreXYValues: 2;
+    readonly RoundXYToGrid: 4;
+    readonly WeHaveAScale: 8;
+    readonly MoreComponents: 32;
+    readonly WeHaveAnXAndYScale: 64;
+    readonly WeHaveATwoByTwo: 128;
+    readonly WeHaveInstructions: 256;
+    readonly UseMyMetrics: 512;
+    readonly OverlapCompound: 1024;
+    readonly ScaledComponentOffset: 2048;
+    readonly UnscaledComponentOffset: 4096;
+};
+/** A point in a glyph contour */
+export interface GlyphPoint {
+    x: number;
+    y: number;
+    onCurve: boolean;
+}
+/** A contour is a closed path of points */
+export type Contour = GlyphPoint[];
+/** Simple glyph with contours */
+export interface SimpleGlyph {
+    type: "simple";
+    numberOfContours: int16;
+    xMin: int16;
+    yMin: int16;
+    xMax: int16;
+    yMax: int16;
+    contours: Contour[];
+    instructions: Uint8Array<ArrayBufferLike>;
+}
+/** Component of a composite glyph */
+export interface GlyphComponent {
+    glyphId: GlyphId;
+    flags: uint16;
+    /** X offset or point number */
+    arg1: number;
+    /** Y offset or point number */
+    arg2: number;
+    /** Transformation matrix [a, b, c, d] */
+    transform: [number, number, number, number];
+}
+/** Composite glyph made of other glyphs */
+export interface CompositeGlyph {
+    type: "composite";
+    numberOfContours: int16;
+    xMin: int16;
+    yMin: int16;
+    xMax: int16;
+    yMax: int16;
+    components: GlyphComponent[];
+    instructions: Uint8Array<ArrayBufferLike>;
+}
+/** Empty glyph (space, etc.) */
+export interface EmptyGlyph {
+    type: "empty";
+}
+export type Glyph = SimpleGlyph | CompositeGlyph | EmptyGlyph;
+/** glyf table stores the raw reader for on-demand glyph parsing */
+export interface GlyfTable {
+    reader: Reader;
+}
+export declare function parseGlyf(reader: Reader): GlyfTable;
+/**
+ * Parse a single glyph from the glyf table
+ */
+export declare function parseGlyph(glyf: GlyfTable, loca: LocaTable, glyphId: GlyphId): Glyph;
+/**
+ * Flatten a composite glyph into simple contours
+ * Recursively resolves all component glyphs and applies transformations
+ */
+export declare function flattenCompositeGlyph(glyf: GlyfTable, loca: LocaTable, glyph: CompositeGlyph, depth?: number): Contour[];
+/**
+ * Get all contours for a glyph, flattening composites
+ */
+export declare function getGlyphContours(glyf: GlyfTable, loca: LocaTable, glyphId: GlyphId): Contour[];
+/**
+ * Get bounding box for a glyph
+ */
+export declare function getGlyphBounds(glyf: GlyfTable, loca: LocaTable, glyphId: GlyphId): {
+    xMin: number;
+    yMin: number;
+    xMax: number;
+    yMax: number;
+} | null;
+/**
+ * Get all deltas for a glyph at given variation coordinates
+ */
+export declare function getGlyphDeltas(gvar: GvarTable, glyphId: GlyphId, numPoints: number, axisCoords: number[]): PointDelta[];
+/**
+ * Apply variation deltas to contours
+ */
+export declare function applyVariationDeltas(contours: Contour[], deltas: PointDelta[]): Contour[];
+/**
+ * Get contours for a glyph with variation applied
+ */
+export declare function getGlyphContoursWithVariation(glyf: GlyfTable, loca: LocaTable, gvar: GvarTable | null, glyphId: GlyphId, axisCoords?: number[]): Contour[];

package/dist/font/tables/gpos-contextual.d.ts

@@ -0,0 +1,88 @@
+import { type ClassDef } from "../../layout/structures/class-def.ts";
+import { type Coverage } from "../../layout/structures/coverage.ts";
+import type { GlyphId, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+import type { GposLookup } from "./gpos.ts";
+/** Position lookup record - applies a lookup at a position */
+export interface PosLookupRecord {
+    sequenceIndex: uint16;
+    lookupListIndex: uint16;
+}
+/** Context positioning lookup (Type 7) */
+export interface ContextPosLookup extends GposLookup {
+    type: 7;
+    subtables: ContextPosSubtable[];
+}
+export type ContextPosSubtable = ContextPosFormat1 | ContextPosFormat2 | ContextPosFormat3;
+/** Format 1: Simple glyph contexts */
+export interface ContextPosFormat1 {
+    format: 1;
+    coverage: Coverage;
+    ruleSets: (PosContextRule[] | null)[];
+}
+export interface PosContextRule {
+    glyphCount: uint16;
+    inputSequence: GlyphId[];
+    lookupRecords: PosLookupRecord[];
+}
+/** Format 2: Class-based contexts */
+export interface ContextPosFormat2 {
+    format: 2;
+    coverage: Coverage;
+    classDef: ClassDef;
+    classRuleSets: (PosClassRule[] | null)[];
+}
+export interface PosClassRule {
+    glyphCount: uint16;
+    inputClasses: uint16[];
+    lookupRecords: PosLookupRecord[];
+}
+/** Format 3: Coverage-based contexts */
+export interface ContextPosFormat3 {
+    format: 3;
+    coverages: Coverage[];
+    lookupRecords: PosLookupRecord[];
+}
+/** Chaining context positioning lookup (Type 8) */
+export interface ChainingContextPosLookup extends GposLookup {
+    type: 8;
+    subtables: ChainingContextPosSubtable[];
+}
+export type ChainingContextPosSubtable = ChainingContextPosFormat1 | ChainingContextPosFormat2 | ChainingContextPosFormat3;
+/** Format 1: Simple chaining context */
+export interface ChainingContextPosFormat1 {
+    format: 1;
+    coverage: Coverage;
+    chainRuleSets: (PosChainRule[] | null)[];
+}
+export interface PosChainRule {
+    backtrackSequence: GlyphId[];
+    inputSequence: GlyphId[];
+    lookaheadSequence: GlyphId[];
+    lookupRecords: PosLookupRecord[];
+}
+/** Format 2: Class-based chaining context */
+export interface ChainingContextPosFormat2 {
+    format: 2;
+    coverage: Coverage;
+    backtrackClassDef: ClassDef;
+    inputClassDef: ClassDef;
+    lookaheadClassDef: ClassDef;
+    chainClassRuleSets: (PosChainClassRule[] | null)[];
+}
+export interface PosChainClassRule {
+    backtrackClasses: uint16[];
+    inputClasses: uint16[];
+    lookaheadClasses: uint16[];
+    lookupRecords: PosLookupRecord[];
+}
+/** Format 3: Coverage-based chaining context */
+export interface ChainingContextPosFormat3 {
+    format: 3;
+    backtrackCoverages: Coverage[];
+    inputCoverages: Coverage[];
+    lookaheadCoverages: Coverage[];
+    lookupRecords: PosLookupRecord[];
+}
+export declare function parseContextPos(reader: Reader, subtableOffsets: number[]): ContextPosSubtable[];
+export declare function parseChainingContextPos(reader: Reader, subtableOffsets: number[]): ChainingContextPosSubtable[];

package/dist/font/tables/gpos-mark.d.ts

@@ -0,0 +1,95 @@
+import { type Coverage } from "../../layout/structures/coverage.ts";
+import type { int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+import type { GposLookup } from "./gpos.ts";
+/** Anchor point for attachment */
+export interface Anchor {
+    xCoordinate: int16;
+    yCoordinate: int16;
+    /** Contour point index (format 2) */
+    anchorPoint?: uint16;
+    /** Device table offsets (format 3) */
+    xDeviceOffset?: uint16;
+    yDeviceOffset?: uint16;
+}
+/** Mark record */
+export interface MarkRecord {
+    markClass: uint16;
+    markAnchor: Anchor;
+}
+/** Mark array */
+export interface MarkArray {
+    markRecords: MarkRecord[];
+}
+/** Base record for mark-to-base */
+export interface BaseRecord {
+    baseAnchors: (Anchor | null)[];
+}
+/** Ligature attach record */
+export interface LigatureAttach {
+    componentRecords: ComponentRecord[];
+}
+/** Component record for ligature */
+export interface ComponentRecord {
+    ligatureAnchors: (Anchor | null)[];
+}
+/** Mark2 record for mark-to-mark */
+export interface Mark2Record {
+    mark2Anchors: (Anchor | null)[];
+}
+/** Cursive attachment lookup (Type 3) */
+export interface CursivePosLookup extends GposLookup {
+    type: 3;
+    subtables: CursivePosSubtable[];
+}
+export interface CursivePosSubtable {
+    coverage: Coverage;
+    entryExitRecords: EntryExitRecord[];
+}
+export interface EntryExitRecord {
+    entryAnchor: Anchor | null;
+    exitAnchor: Anchor | null;
+}
+/** Mark-to-base attachment lookup (Type 4) */
+export interface MarkBasePosLookup extends GposLookup {
+    type: 4;
+    subtables: MarkBasePosSubtable[];
+}
+export interface MarkBasePosSubtable {
+    markCoverage: Coverage;
+    baseCoverage: Coverage;
+    markClassCount: uint16;
+    markArray: MarkArray;
+    baseArray: BaseRecord[];
+}
+/** Mark-to-ligature attachment lookup (Type 5) */
+export interface MarkLigaturePosLookup extends GposLookup {
+    type: 5;
+    subtables: MarkLigaturePosSubtable[];
+}
+export interface MarkLigaturePosSubtable {
+    markCoverage: Coverage;
+    ligatureCoverage: Coverage;
+    markClassCount: uint16;
+    markArray: MarkArray;
+    ligatureArray: LigatureAttach[];
+}
+/** Mark-to-mark attachment lookup (Type 6) */
+export interface MarkMarkPosLookup extends GposLookup {
+    type: 6;
+    subtables: MarkMarkPosSubtable[];
+}
+export interface MarkMarkPosSubtable {
+    mark1Coverage: Coverage;
+    mark2Coverage: Coverage;
+    markClassCount: uint16;
+    mark1Array: MarkArray;
+    mark2Array: Mark2Record[];
+}
+export declare function parseAnchor(reader: Reader): Anchor;
+export declare function parseAnchorAt(reader: Reader, offset: number): Anchor | null;
+export declare function parseMarkArray(reader: Reader): MarkArray;
+export declare function parseCursivePos(reader: Reader, subtableOffsets: number[]): CursivePosSubtable[];
+export declare function parseMarkBasePos(reader: Reader, subtableOffsets: number[]): MarkBasePosSubtable[];
+export declare function parseMarkLigaturePos(reader: Reader, subtableOffsets: number[]): MarkLigaturePosSubtable[];
+export declare function parseMarkMarkPos(reader: Reader, subtableOffsets: number[]): MarkMarkPosSubtable[];

package/dist/font/tables/gpos.d.ts

@@ -0,0 +1,137 @@
+import { type ClassDef } from "../../layout/structures/class-def.ts";
+import { type Coverage } from "../../layout/structures/coverage.ts";
+import { type DeviceOrVariationIndex } from "../../layout/structures/device.ts";
+import { type FeatureList, type ScriptList } from "../../layout/structures/layout-common.ts";
+import type { GlyphId, int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+import { type ChainingContextPosLookup, type ContextPosLookup } from "./gpos-contextual.ts";
+import { type CursivePosSubtable, type MarkBasePosSubtable, type MarkLigaturePosSubtable, type MarkMarkPosSubtable } from "./gpos-mark.ts";
+/** GPOS lookup types */
+export declare enum GposLookupType {
+    Single = 1,
+    Pair = 2,
+    Cursive = 3,
+    MarkToBase = 4,
+    MarkToLigature = 5,
+    MarkToMark = 6,
+    Context = 7,
+    ChainingContext = 8,
+    Extension = 9
+}
+/** Value record - positioning adjustments */
+export interface ValueRecord {
+    xPlacement?: int16;
+    yPlacement?: int16;
+    xAdvance?: int16;
+    yAdvance?: int16;
+    xPlaDevice?: DeviceOrVariationIndex;
+    yPlaDevice?: DeviceOrVariationIndex;
+    xAdvDevice?: DeviceOrVariationIndex;
+    yAdvDevice?: DeviceOrVariationIndex;
+}
+/** Value format flags */
+export declare const ValueFormat: {
+    readonly XPlacement: 1;
+    readonly YPlacement: 2;
+    readonly XAdvance: 4;
+    readonly YAdvance: 8;
+    readonly XPlaDevice: 16;
+    readonly YPlaDevice: 32;
+    readonly XAdvDevice: 64;
+    readonly YAdvDevice: 128;
+};
+/** Base interface for all GPOS lookups */
+export interface GposLookup {
+    type: GposLookupType;
+    flag: uint16;
+    markFilteringSet?: uint16;
+}
+/** Single adjustment lookup (Type 1) */
+export interface SinglePosLookup extends GposLookup {
+    type: GposLookupType.Single;
+    subtables: SinglePosSubtable[];
+}
+export interface SinglePosSubtable {
+    format: 1 | 2;
+    coverage: Coverage;
+    valueFormat: uint16;
+    value?: ValueRecord;
+    values?: ValueRecord[];
+}
+/** Pair adjustment lookup (Type 2) - kerning */
+export interface PairPosLookup extends GposLookup {
+    type: GposLookupType.Pair;
+    subtables: PairPosSubtable[];
+}
+export type PairPosSubtable = PairPosFormat1 | PairPosFormat2;
+export interface PairPosFormat1 {
+    format: 1;
+    coverage: Coverage;
+    valueFormat1: uint16;
+    valueFormat2: uint16;
+    pairSets: PairSet[];
+}
+export interface PairSet {
+    pairValueRecords: PairValueRecord[];
+}
+export interface PairValueRecord {
+    secondGlyph: GlyphId;
+    value1: ValueRecord;
+    value2: ValueRecord;
+}
+export interface PairPosFormat2 {
+    format: 2;
+    coverage: Coverage;
+    valueFormat1: uint16;
+    valueFormat2: uint16;
+    classDef1: ClassDef;
+    classDef2: ClassDef;
+    class1Count: uint16;
+    class2Count: uint16;
+    class1Records: Class1Record[];
+}
+export interface Class1Record {
+    class2Records: Class2Record[];
+}
+export interface Class2Record {
+    value1: ValueRecord;
+    value2: ValueRecord;
+}
+/** Cursive attachment lookup (Type 3) */
+export interface CursivePosLookup extends GposLookup {
+    type: GposLookupType.Cursive;
+    subtables: CursivePosSubtable[];
+}
+/** Mark-to-base attachment lookup (Type 4) */
+export interface MarkBasePosLookup extends GposLookup {
+    type: GposLookupType.MarkToBase;
+    subtables: MarkBasePosSubtable[];
+}
+/** Mark-to-ligature attachment lookup (Type 5) */
+export interface MarkLigaturePosLookup extends GposLookup {
+    type: GposLookupType.MarkToLigature;
+    subtables: MarkLigaturePosSubtable[];
+}
+/** Mark-to-mark attachment lookup (Type 6) */
+export interface MarkMarkPosLookup extends GposLookup {
+    type: GposLookupType.MarkToMark;
+    subtables: MarkMarkPosSubtable[];
+}
+/** Union of all GPOS lookup types */
+export type AnyGposLookup = SinglePosLookup | PairPosLookup | CursivePosLookup | MarkBasePosLookup | MarkLigaturePosLookup | MarkMarkPosLookup | ContextPosLookup | ChainingContextPosLookup;
+/** GPOS table */
+export interface GposTable {
+    version: {
+        major: number;
+        minor: number;
+    };
+    scriptList: ScriptList;
+    featureList: FeatureList;
+    lookups: AnyGposLookup[];
+}
+export type { Anchor, MarkArray } from "./gpos-mark.ts";
+export declare function parseGpos(reader: Reader): GposTable;
+export declare function getKerning(lookup: PairPosLookup, firstGlyph: GlyphId, secondGlyph: GlyphId): {
+    xAdvance1: number;
+    xAdvance2: number;
+} | null;

package/dist/font/tables/gsub-contextual.d.ts

@@ -0,0 +1,88 @@
+import { type ClassDef } from "../../layout/structures/class-def.ts";
+import { type Coverage } from "../../layout/structures/coverage.ts";
+import type { GlyphId, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+import type { GsubLookup } from "./gsub.ts";
+/** Sequence lookup record - applies a lookup at a position */
+export interface SequenceLookupRecord {
+    sequenceIndex: uint16;
+    lookupListIndex: uint16;
+}
+/** Context substitution lookup (Type 5) */
+export interface ContextSubstLookup extends GsubLookup {
+    type: 5;
+    subtables: ContextSubstSubtable[];
+}
+export type ContextSubstSubtable = ContextSubstFormat1 | ContextSubstFormat2 | ContextSubstFormat3;
+/** Format 1: Simple glyph contexts */
+export interface ContextSubstFormat1 {
+    format: 1;
+    coverage: Coverage;
+    ruleSets: (ContextRule[] | null)[];
+}
+export interface ContextRule {
+    glyphCount: uint16;
+    inputSequence: GlyphId[];
+    lookupRecords: SequenceLookupRecord[];
+}
+/** Format 2: Class-based contexts */
+export interface ContextSubstFormat2 {
+    format: 2;
+    coverage: Coverage;
+    classDef: ClassDef;
+    classRuleSets: (ClassRule[] | null)[];
+}
+export interface ClassRule {
+    glyphCount: uint16;
+    inputClasses: uint16[];
+    lookupRecords: SequenceLookupRecord[];
+}
+/** Format 3: Coverage-based contexts */
+export interface ContextSubstFormat3 {
+    format: 3;
+    coverages: Coverage[];
+    lookupRecords: SequenceLookupRecord[];
+}
+/** Chaining context substitution lookup (Type 6) */
+export interface ChainingContextSubstLookup extends GsubLookup {
+    type: 6;
+    subtables: ChainingContextSubstSubtable[];
+}
+export type ChainingContextSubstSubtable = ChainingContextFormat1 | ChainingContextFormat2 | ChainingContextFormat3;
+/** Format 1: Simple chaining context */
+export interface ChainingContextFormat1 {
+    format: 1;
+    coverage: Coverage;
+    chainRuleSets: (ChainRule[] | null)[];
+}
+export interface ChainRule {
+    backtrackSequence: GlyphId[];
+    inputSequence: GlyphId[];
+    lookaheadSequence: GlyphId[];
+    lookupRecords: SequenceLookupRecord[];
+}
+/** Format 2: Class-based chaining context */
+export interface ChainingContextFormat2 {
+    format: 2;
+    coverage: Coverage;
+    backtrackClassDef: ClassDef;
+    inputClassDef: ClassDef;
+    lookaheadClassDef: ClassDef;
+    chainClassRuleSets: (ChainClassRule[] | null)[];
+}
+export interface ChainClassRule {
+    backtrackClasses: uint16[];
+    inputClasses: uint16[];
+    lookaheadClasses: uint16[];
+    lookupRecords: SequenceLookupRecord[];
+}
+/** Format 3: Coverage-based chaining context */
+export interface ChainingContextFormat3 {
+    format: 3;
+    backtrackCoverages: Coverage[];
+    inputCoverages: Coverage[];
+    lookaheadCoverages: Coverage[];
+    lookupRecords: SequenceLookupRecord[];
+}
+export declare function parseContextSubst(reader: Reader, subtableOffsets: number[]): ContextSubstSubtable[];
+export declare function parseChainingContextSubst(reader: Reader, subtableOffsets: number[]): ChainingContextSubstSubtable[];