text-shaper 0.0.1

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

@@ -0,0 +1,107 @@
+import { type Coverage } from "../../layout/structures/coverage.ts";
+import { type FeatureList, type ScriptList } from "../../layout/structures/layout-common.ts";
+import type { GlyphId, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+import { type ChainingContextSubstSubtable, type ContextSubstSubtable } from "./gsub-contextual.ts";
+/** GSUB lookup types */
+export declare enum GsubLookupType {
+    Single = 1,
+    Multiple = 2,
+    Alternate = 3,
+    Ligature = 4,
+    Context = 5,
+    ChainingContext = 6,
+    Extension = 7,
+    ReverseChainingSingle = 8
+}
+/** Base interface for all GSUB lookups */
+export interface GsubLookup {
+    type: GsubLookupType;
+    flag: uint16;
+    markFilteringSet?: uint16;
+}
+/** Single substitution lookup (Type 1) */
+export interface SingleSubstLookup extends GsubLookup {
+    type: GsubLookupType.Single;
+    subtables: SingleSubstSubtable[];
+}
+export interface SingleSubstSubtable {
+    format: 1 | 2;
+    coverage: Coverage;
+    deltaGlyphId?: number;
+    substituteGlyphIds?: GlyphId[];
+}
+/** Multiple substitution lookup (Type 2) */
+export interface MultipleSubstLookup extends GsubLookup {
+    type: GsubLookupType.Multiple;
+    subtables: MultipleSubstSubtable[];
+}
+export interface MultipleSubstSubtable {
+    coverage: Coverage;
+    sequences: GlyphId[][];
+}
+/** Alternate substitution lookup (Type 3) */
+export interface AlternateSubstLookup extends GsubLookup {
+    type: GsubLookupType.Alternate;
+    subtables: AlternateSubstSubtable[];
+}
+export interface AlternateSubstSubtable {
+    coverage: Coverage;
+    alternateSets: GlyphId[][];
+}
+/** Ligature substitution lookup (Type 4) */
+export interface LigatureSubstLookup extends GsubLookup {
+    type: GsubLookupType.Ligature;
+    subtables: LigatureSubstSubtable[];
+}
+export interface LigatureSubstSubtable {
+    coverage: Coverage;
+    ligatureSets: LigatureSet[];
+}
+export interface LigatureSet {
+    ligatures: Ligature[];
+}
+export interface Ligature {
+    ligatureGlyph: GlyphId;
+    componentGlyphIds: GlyphId[];
+}
+/** Context substitution lookup (Type 5) */
+export interface ContextSubstLookup extends GsubLookup {
+    type: GsubLookupType.Context;
+    subtables: ContextSubstSubtable[];
+}
+/** Chaining context substitution lookup (Type 6) */
+export interface ChainingContextSubstLookup extends GsubLookup {
+    type: GsubLookupType.ChainingContext;
+    subtables: ChainingContextSubstSubtable[];
+}
+/** Reverse chaining single substitution lookup (Type 8) */
+export interface ReverseChainingSingleSubstLookup extends GsubLookup {
+    type: GsubLookupType.ReverseChainingSingle;
+    subtables: ReverseChainingSingleSubstSubtable[];
+}
+export interface ReverseChainingSingleSubstSubtable {
+    coverage: Coverage;
+    backtrackCoverages: Coverage[];
+    lookaheadCoverages: Coverage[];
+    substituteGlyphIds: GlyphId[];
+}
+/** Union of all GSUB lookup types */
+export type AnyGsubLookup = SingleSubstLookup | MultipleSubstLookup | AlternateSubstLookup | LigatureSubstLookup | ContextSubstLookup | ChainingContextSubstLookup | ReverseChainingSingleSubstLookup;
+/** GSUB table */
+export interface GsubTable {
+    version: {
+        major: number;
+        minor: number;
+    };
+    scriptList: ScriptList;
+    featureList: FeatureList;
+    lookups: AnyGsubLookup[];
+}
+export type { SequenceLookupRecord } from "./gsub-contextual.ts";
+export declare function parseGsub(reader: Reader): GsubTable;
+export declare function applySingleSubst(lookup: SingleSubstLookup, glyphId: GlyphId): GlyphId | null;
+export declare function applyLigatureSubst(lookup: LigatureSubstLookup, glyphIds: GlyphId[], startIndex: number): {
+    ligatureGlyph: GlyphId;
+    consumed: number;
+} | null;

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

@@ -0,0 +1,56 @@
+import type { GlyphId, int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Glyph Variations table (gvar)
+ * Contains variation data for TrueType glyph outlines
+ */
+export interface GvarTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    axisCount: uint16;
+    sharedTupleCount: uint16;
+    sharedTuples: number[][];
+    glyphVariationData: GlyphVariationData[];
+}
+/**
+ * Variation data for a single glyph
+ */
+export interface GlyphVariationData {
+    tupleVariationHeaders: TupleVariationHeader[];
+}
+/**
+ * Tuple variation header
+ */
+export interface TupleVariationHeader {
+    variationDataSize: uint16;
+    tupleIndex: uint16;
+    peakTuple: number[] | null;
+    intermediateStartTuple: number[] | null;
+    intermediateEndTuple: number[] | null;
+    serializedData: Uint8Array;
+    pointNumbers: number[] | null;
+    deltas: PointDelta[];
+}
+/**
+ * Delta values for a point
+ */
+export interface PointDelta {
+    x: int16;
+    y: int16;
+}
+/**
+ * Parse gvar table
+ */
+export declare function parseGvar(reader: Reader, _numGlyphs: number): GvarTable;
+/**
+ * Parse packed deltas
+ */
+export declare function parsePackedDeltas(reader: Reader, count: number): number[];
+/**
+ * Calculate the scalar for a tuple given axis coordinates
+ */
+export declare function calculateTupleScalar(peakTuple: number[], axisCoords: number[], intermediateStart: number[] | null, intermediateEnd: number[] | null): number;
+/**
+ * Get delta for a glyph point at given variation coordinates
+ */
+export declare function getGlyphDelta(gvar: GvarTable, glyphId: GlyphId, pointIndex: number, axisCoords: number[]): PointDelta;

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

@@ -0,0 +1,47 @@
+import type { Fixed, FWord, int16, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/** Font header table */
+export interface HeadTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    fontRevision: Fixed;
+    checksumAdjustment: uint32;
+    magicNumber: uint32;
+    flags: uint16;
+    unitsPerEm: uint16;
+    created: bigint;
+    modified: bigint;
+    xMin: FWord;
+    yMin: FWord;
+    xMax: FWord;
+    yMax: FWord;
+    macStyle: uint16;
+    lowestRecPPEM: uint16;
+    fontDirectionHint: int16;
+    /** 0 = short offsets (uint16), 1 = long offsets (uint32) in loca table */
+    indexToLocFormat: int16;
+    glyphDataFormat: int16;
+}
+/** Head table flags */
+export declare const HeadFlags: {
+    readonly BaselineAtY0: 1;
+    readonly LeftSidebearingAtX0: 2;
+    readonly InstructionsDependOnPointSize: 4;
+    readonly ForcePPEMToInteger: 8;
+    readonly InstructionsAlterAdvanceWidth: 16;
+    readonly Lossless: 2048;
+    readonly Converted: 4096;
+    readonly OptimizedForClearType: 8192;
+    readonly LastResortFont: 16384;
+};
+/** Mac style flags */
+export declare const MacStyle: {
+    readonly Bold: 1;
+    readonly Italic: 2;
+    readonly Underline: 4;
+    readonly Outline: 8;
+    readonly Shadow: 16;
+    readonly Condensed: 32;
+    readonly Extended: 64;
+};
+export declare function parseHead(reader: Reader): HeadTable;

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

@@ -0,0 +1,24 @@
+import type { FWord, int16, UFWord, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/** Horizontal header table */
+export interface HheaTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    ascender: FWord;
+    descender: FWord;
+    lineGap: FWord;
+    advanceWidthMax: UFWord;
+    minLeftSideBearing: FWord;
+    minRightSideBearing: FWord;
+    xMaxExtent: FWord;
+    caretSlopeRise: int16;
+    caretSlopeRun: int16;
+    caretOffset: int16;
+    reserved1: int16;
+    reserved2: int16;
+    reserved3: int16;
+    reserved4: int16;
+    metricDataFormat: int16;
+    numberOfHMetrics: uint16;
+}
+export declare function parseHhea(reader: Reader): HheaTable;

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

@@ -0,0 +1,23 @@
+import type { FWord, GlyphId, UFWord } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/** Horizontal metric for a glyph */
+export interface LongHorMetric {
+    advanceWidth: UFWord;
+    lsb: FWord;
+}
+/** Horizontal metrics table */
+export interface HmtxTable {
+    hMetrics: LongHorMetric[];
+    leftSideBearings: FWord[];
+}
+/**
+ * Parse hmtx table.
+ * @param reader - Reader positioned at hmtx table start
+ * @param numberOfHMetrics - From hhea table
+ * @param numGlyphs - From maxp table
+ */
+export declare function parseHmtx(reader: Reader, numberOfHMetrics: number, numGlyphs: number): HmtxTable;
+/** Get advance width for a glyph */
+export declare function getAdvanceWidth(hmtx: HmtxTable, glyphId: GlyphId): number;
+/** Get left side bearing for a glyph */
+export declare function getLeftSideBearing(hmtx: HmtxTable, glyphId: GlyphId): number;

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

@@ -0,0 +1,77 @@
+import type { GlyphId, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Horizontal Metrics Variations table (HVAR)
+ * Provides variations for horizontal advance widths and LSB
+ */
+export interface HvarTable {
+    majorVersion: number;
+    minorVersion: number;
+    itemVariationStore: ItemVariationStore;
+    advanceWidthMapping: DeltaSetIndexMap | null;
+    lsbMapping: DeltaSetIndexMap | null;
+    rsbMapping: DeltaSetIndexMap | null;
+}
+/**
+ * Item Variation Store - stores delta values for variations
+ */
+export interface ItemVariationStore {
+    format: number;
+    variationRegions: VariationRegion[];
+    itemVariationData: ItemVariationData[];
+}
+/**
+ * Variation region defines the space where deltas apply
+ */
+export interface VariationRegion {
+    regionAxes: RegionAxisCoordinates[];
+}
+/**
+ * Axis coordinates for a region
+ */
+export interface RegionAxisCoordinates {
+    startCoord: number;
+    peakCoord: number;
+    endCoord: number;
+}
+/**
+ * Item variation data subtable
+ */
+export interface ItemVariationData {
+    itemCount: uint16;
+    regionIndexes: uint16[];
+    deltaSets: number[][];
+}
+/**
+ * Delta set index map for mapping glyphs to variation data
+ */
+export interface DeltaSetIndexMap {
+    format: number;
+    mapCount: uint32;
+    entryFormat: number;
+    innerIndexBitCount: number;
+    mapData: {
+        outer: number;
+        inner: number;
+    }[];
+}
+/**
+ * Parse HVAR table
+ */
+export declare function parseHvar(reader: Reader): HvarTable;
+/**
+ * Calculate scalar for a variation region given axis coordinates
+ */
+export declare function calculateRegionScalar(region: VariationRegion, coords: number[]): number;
+/**
+ * Get advance width delta for a glyph at given variation coordinates
+ */
+export declare function getAdvanceWidthDelta(hvar: HvarTable, glyphId: GlyphId, coords: number[]): number;
+/**
+ * Get left side bearing delta for a glyph at given variation coordinates
+ */
+export declare function getLsbDelta(hvar: HvarTable, glyphId: GlyphId, coords: number[]): number;
+/**
+ * Get right side bearing delta for a glyph at given variation coordinates
+ */
+export declare function getRsbDelta(hvar: HvarTable, glyphId: GlyphId, coords: number[]): number;

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

@@ -0,0 +1,97 @@
+import type { uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * JSTF table - Justification data
+ * Provides justification alternatives for scripts
+ */
+/** Justification priority levels */
+export declare const JstfPriority: {
+    /** Shrink GPOS lookups */
+    readonly ShrinkGpos: 0;
+    /** Disable GPOS lookups */
+    readonly DisableGpos: 1;
+    /** Shrink GSUB lookups */
+    readonly ShrinkGsub: 2;
+    /** Disable GSUB lookups */
+    readonly DisableGsub: 3;
+    /** Enable GPOS lookups */
+    readonly EnableGpos: 4;
+    /** Enable GSUB lookups */
+    readonly EnableGsub: 5;
+    /** Max extension GPOS lookups */
+    readonly MaxExtendGpos: 6;
+    /** Max extension GSUB lookups */
+    readonly MaxExtendGsub: 7;
+};
+/** JstfMax table - lookup indices for maximum extension */
+export interface JstfMax {
+    lookupIndices: uint16[];
+}
+/** JstfModList - enable/disable lookup list */
+export interface JstfModList {
+    lookupIndices: uint16[];
+}
+/** Justification priority record */
+export interface JstfPriorityRecord {
+    /** GSUB lookups to enable for shrinkage */
+    shrinkageEnableGsub: JstfModList | null;
+    /** GSUB lookups to disable for shrinkage */
+    shrinkageDisableGsub: JstfModList | null;
+    /** GPOS lookups to enable for shrinkage */
+    shrinkageEnableGpos: JstfModList | null;
+    /** GPOS lookups to disable for shrinkage */
+    shrinkageDisableGpos: JstfModList | null;
+    /** Maximum shrinkage GSUB */
+    shrinkageJstfMax: JstfMax | null;
+    /** GSUB lookups to enable for extension */
+    extensionEnableGsub: JstfModList | null;
+    /** GSUB lookups to disable for extension */
+    extensionDisableGsub: JstfModList | null;
+    /** GPOS lookups to enable for extension */
+    extensionEnableGpos: JstfModList | null;
+    /** GPOS lookups to disable for extension */
+    extensionDisableGpos: JstfModList | null;
+    /** Maximum extension GSUB */
+    extensionJstfMax: JstfMax | null;
+}
+/** Justification language system */
+export interface JstfLangSys {
+    priorities: JstfPriorityRecord[];
+}
+/** Justification script record */
+export interface JstfScriptRecord {
+    scriptTag: number;
+    /** Extender glyphs for Kashida-like justification */
+    extenderGlyphs: uint16[];
+    /** Default language system */
+    defaultLangSys: JstfLangSys | null;
+    /** Language-specific systems */
+    langSysRecords: Map<number, JstfLangSys>;
+}
+/** JSTF table */
+export interface JstfTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    scripts: JstfScriptRecord[];
+}
+export declare function parseJstf(reader: Reader): JstfTable;
+/** Get extender glyphs for a script (e.g., Kashida for Arabic) */
+export declare function getExtenderGlyphs(jstf: JstfTable, scriptTag: number): uint16[];
+/** Get justification priorities for a script/language */
+export declare function getJstfPriorities(jstf: JstfTable, scriptTag: number, languageTag?: number): JstfPriorityRecord[];
+/** Get lookup modifications for shrinkage at a given priority level */
+export declare function getShrinkageMods(priority: JstfPriorityRecord): {
+    enableGsub: uint16[];
+    disableGsub: uint16[];
+    enableGpos: uint16[];
+    disableGpos: uint16[];
+    maxLookups: uint16[];
+};
+/** Get lookup modifications for extension at a given priority level */
+export declare function getExtensionMods(priority: JstfPriorityRecord): {
+    enableGsub: uint16[];
+    disableGsub: uint16[];
+    enableGpos: uint16[];
+    disableGpos: uint16[];
+    maxLookups: uint16[];
+};

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

@@ -0,0 +1,44 @@
+import type { GlyphId, int16, uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Legacy kern table for kerning pairs
+ * Used when GPOS kerning is not available
+ */
+export interface KernTable {
+    version: number;
+    subtables: KernSubtable[];
+}
+export type KernSubtable = KernFormat0 | KernFormat2;
+/**
+ * Format 0: Ordered list of kerning pairs
+ */
+export interface KernFormat0 {
+    format: 0;
+    coverage: KernCoverage;
+    pairs: Map<number, int16>;
+}
+/**
+ * Format 2: Class-based kerning (two-dimensional array)
+ */
+export interface KernFormat2 {
+    format: 2;
+    coverage: KernCoverage;
+    rowWidth: uint16;
+    leftClassTable: Map<GlyphId, uint16>;
+    rightClassTable: Map<GlyphId, uint16>;
+    kerningValues: int16[][];
+}
+export interface KernCoverage {
+    horizontal: boolean;
+    minimum: boolean;
+    crossStream: boolean;
+    override: boolean;
+}
+/**
+ * Parse kern table
+ */
+export declare function parseKern(reader: Reader): KernTable;
+/**
+ * Get kerning value from kern table
+ */
+export declare function getKernValue(kern: KernTable, left: GlyphId, right: GlyphId): number;

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

@@ -0,0 +1,108 @@
+import type { GlyphId, int16, uint16, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Extended Kerning table (kerx)
+ * Apple Advanced Typography kerning
+ */
+export interface KerxTable {
+    version: uint16;
+    nTables: uint32;
+    subtables: KerxSubtable[];
+}
+/**
+ * kerx subtable types
+ */
+export declare enum KerxSubtableType {
+    OrderedList = 0,
+    StateTable = 1,
+    SimpleArray = 2,
+    ControlPoint = 4,
+    Format6 = 6
+}
+/**
+ * Coverage flags
+ */
+export interface KerxCoverage {
+    vertical: boolean;
+    crossStream: boolean;
+    variation: boolean;
+}
+/**
+ * Base subtable
+ */
+export interface KerxSubtableBase {
+    length: uint32;
+    coverage: KerxCoverage;
+    tupleCount: uint16;
+}
+export type KerxSubtable = KerxOrderedListSubtable | KerxStateTableSubtable | KerxSimpleArraySubtable | KerxControlPointSubtable | KerxFormat6Subtable;
+/**
+ * Format 0: Ordered list of kerning pairs
+ */
+export interface KerxOrderedListSubtable extends KerxSubtableBase {
+    format: KerxSubtableType.OrderedList;
+    nPairs: uint32;
+    pairs: KerxPair[];
+}
+export interface KerxPair {
+    left: GlyphId;
+    right: GlyphId;
+    value: int16;
+}
+/**
+ * Format 1: State table
+ */
+export interface KerxStateTableSubtable extends KerxSubtableBase {
+    format: KerxSubtableType.StateTable;
+    stateHeader: KerxStateHeader;
+}
+export interface KerxStateHeader {
+    nClasses: uint32;
+    classTableOffset: uint32;
+    stateArrayOffset: uint32;
+    entryTableOffset: uint32;
+    valueTableOffset: uint32;
+}
+/**
+ * Format 2: Simple array
+ */
+export interface KerxSimpleArraySubtable extends KerxSubtableBase {
+    format: KerxSubtableType.SimpleArray;
+    rowWidth: uint16;
+    leftClassTable: KerxClassTable;
+    rightClassTable: KerxClassTable;
+    kerningArray: Int16Array;
+}
+export interface KerxClassTable {
+    firstGlyph: GlyphId;
+    nGlyphs: uint16;
+    classes: Uint8Array;
+}
+/**
+ * Format 4: Control point actions
+ */
+export interface KerxControlPointSubtable extends KerxSubtableBase {
+    format: KerxSubtableType.ControlPoint;
+    flags: uint32;
+}
+/**
+ * Format 6: Extended kerning pairs
+ */
+export interface KerxFormat6Subtable extends KerxSubtableBase {
+    format: KerxSubtableType.Format6;
+    flags: uint32;
+    rowCount: uint16;
+    columnCount: uint16;
+    rowIndexTableOffset: uint32;
+    columnIndexTableOffset: uint32;
+    kerningArrayOffset: uint32;
+    kerningVectorOffset: uint32;
+}
+/**
+ * Parse kerx table
+ */
+export declare function parseKerx(reader: Reader): KerxTable;
+/**
+ * Get kerning value from kerx table
+ */
+export declare function getKerxValue(kerx: KerxTable, left: GlyphId, right: GlyphId): number;

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

@@ -0,0 +1,31 @@
+import type { GlyphId, uint32 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * loca table - Glyph location index
+ * Maps glyph IDs to byte offsets in the glyf table
+ */
+export interface LocaTable {
+    /** Glyph offsets (numGlyphs + 1 entries) */
+    offsets: uint32[];
+    /** Whether the font uses short (16-bit) or long (32-bit) offsets */
+    isShort: boolean;
+}
+/**
+ * Parse loca table
+ * @param reader - Reader positioned at start of loca table
+ * @param numGlyphs - Number of glyphs from maxp table
+ * @param indexToLocFormat - 0 for short offsets, 1 for long (from head table)
+ */
+export declare function parseLoca(reader: Reader, numGlyphs: number, indexToLocFormat: number): LocaTable;
+/**
+ * Get byte offset and length for a glyph in the glyf table
+ * Returns null if glyph has no outline (empty glyph)
+ */
+export declare function getGlyphLocation(loca: LocaTable, glyphId: GlyphId): {
+    offset: uint32;
+    length: uint32;
+} | null;
+/**
+ * Check if a glyph has outline data
+ */
+export declare function hasGlyphOutline(loca: LocaTable, glyphId: GlyphId): boolean;