text-shaper 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+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.

package/README.md

@@ -0,0 +1,161 @@
+# text-shaper
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![GitHub Sponsors](https://img.shields.io/badge/Sponsor-vivy--company-ea4aaa)](https://github.com/sponsors/vivy-company)
+
+Pure TypeScript text shaping engine. A port of [rustybuzz](https://github.com/RazrFalcon/rustybuzz)/[HarfBuzz](https://github.com/harfbuzz/harfbuzz) for the browser and Node.js.
+
+## Features
+
+- **OpenType Layout**: Full GSUB (substitution) and GPOS (positioning) support
+- **Complex Scripts**: Arabic, Indic, USE (Universal Shaping Engine) shapers
+- **Variable Fonts**: fvar, gvar, avar, HVAR, VVAR, MVAR tables
+- **AAT Support**: morx, kerx, trak tables for Apple fonts
+- **Color Fonts**: SVG, sbix, CBDT/CBLC tables
+- **BiDi**: UAX #9 bidirectional text algorithm
+- **Zero Dependencies**: Pure TypeScript, works in browser and Node.js
+
+## Installation
+
+```bash
+npm install text-shaper
+# or
+bun add text-shaper
+```
+
+## Usage
+
+```typescript
+import { Font, shape, UnicodeBuffer } from "text-shaper";
+
+// Load a font
+const fontData = await Bun.file("path/to/font.ttf").arrayBuffer();
+const font = new Font(fontData);
+
+// Create a buffer with text
+const buffer = new UnicodeBuffer();
+buffer.addString("Hello, World!");
+
+// Shape the text
+const glyphBuffer = shape(font, buffer);
+
+// Access shaped glyphs
+for (let i = 0; i < glyphBuffer.length; i++) {
+  const info = glyphBuffer.info[i];
+  const pos = glyphBuffer.pos[i];
+  console.log(`Glyph ${info.glyphId}: advance=${pos.xAdvance}, offset=(${pos.xOffset}, ${pos.yOffset})`);
+}
+```
+
+### With Features
+
+```typescript
+import { Font, shape, UnicodeBuffer, feature, features } from "text-shaper";
+
+const glyphBuffer = shape(font, buffer, {
+  features: features(
+    feature("smcp", 1),  // Small caps
+    feature("liga", 1),  // Ligatures
+    feature("kern", 1),  // Kerning
+  ),
+});
+```
+
+### Variable Fonts
+
+```typescript
+import { Font, shape, UnicodeBuffer, tag } from "text-shaper";
+
+const glyphBuffer = shape(font, buffer, {
+  variations: [
+    { tag: tag("wght"), value: 700 },  // Bold
+    { tag: tag("wdth"), value: 75 },   // Condensed
+  ],
+});
+```
+
+### Rendering to SVG
+
+```typescript
+import { Font, shape, UnicodeBuffer, shapedTextToSVG } from "text-shaper";
+
+const buffer = new UnicodeBuffer();
+buffer.addString("Hello");
+
+const glyphBuffer = shape(font, buffer);
+const svg = shapedTextToSVG(font, glyphBuffer, { fontSize: 48 });
+```
+
+## API
+
+### Core Classes
+
+- `Font` - Load and parse OpenType/TrueType fonts
+- `Face` - Font face with variation coordinates applied
+- `UnicodeBuffer` - Input buffer for text to shape
+- `GlyphBuffer` - Output buffer containing shaped glyphs
+
+### Shaping
+
+- `shape(font, buffer, options?)` - Shape text in a buffer
+- `createShapePlan(font, options)` - Create a reusable shape plan
+
+### Rendering
+
+- `getGlyphPath(font, glyphId)` - Get glyph outline as path commands
+- `shapedTextToSVG(font, buffer, options)` - Render shaped text to SVG
+- `renderShapedText(ctx, font, buffer, options)` - Render to Canvas 2D context
+
+### Feature Helpers
+
+```typescript
+// Ligatures
+standardLigatures()      // liga
+discretionaryLigatures() // dlig
+contextualAlternates()   // calt
+
+// Caps
+smallCaps()              // smcp
+capsToSmallCaps()        // c2sc
+allSmallCaps()           // smcp + c2sc
+
+// Figures
+oldstyleFigures()        // onum
+liningFigures()          // lnum
+tabularFigures()         // tnum
+proportionalFigures()    // pnum
+
+// Stylistic
+stylisticSet(n)          // ss01-ss20
+characterVariant(n)      // cv01-cv99
+swash()                  // swsh
+
+// And many more...
+```
+
+## Supported Tables
+
+### Required
+head, hhea, hmtx, maxp, cmap, loca, glyf, name, OS/2, post
+
+### OpenType Layout
+GDEF, GSUB, GPOS, BASE
+
+### CFF
+CFF, CFF2
+
+### Variable Fonts
+fvar, gvar, avar, HVAR, VVAR, MVAR, STAT
+
+### AAT (Apple)
+morx, kerx, kern, trak
+
+### Color
+COLR, CPAL, SVG, sbix, CBDT, CBLC
+
+### Vertical
+vhea, vmtx, VORG
+
+## License
+
+[MIT](LICENSE)

package/dist/aat/state-machine.d.ts

@@ -0,0 +1,34 @@
+import type { ClassTable, MorxContextualSubtable, MorxInsertionSubtable, MorxLigatureSubtable, MorxRearrangementSubtable } from "../font/tables/morx.ts";
+import type { GlyphId, GlyphInfo } from "../types.ts";
+/**
+ * State machine driver for AAT processing
+ */
+export interface StateMachineContext {
+    /** Current position in buffer */
+    pos: number;
+    /** Mark position (for some operations) */
+    mark: number;
+    /** Glyph stack for ligatures */
+    stack: number[];
+}
+/**
+ * Get class for a glyph
+ */
+export declare function getGlyphClass(classTable: ClassTable, glyphId: GlyphId): number;
+/**
+ * Process rearrangement subtable
+ * Reorders glyphs based on state machine
+ */
+export declare function processRearrangement(subtable: MorxRearrangementSubtable, infos: GlyphInfo[]): void;
+/**
+ * Process contextual substitution subtable
+ */
+export declare function processContextual(subtable: MorxContextualSubtable, infos: GlyphInfo[]): void;
+/**
+ * Process ligature subtable
+ */
+export declare function processLigature(subtable: MorxLigatureSubtable, infos: GlyphInfo[]): GlyphInfo[];
+/**
+ * Process insertion subtable
+ */
+export declare function processInsertion(subtable: MorxInsertionSubtable, infos: GlyphInfo[]): GlyphInfo[];

package/dist/buffer/glyph-buffer.d.ts

@@ -0,0 +1,55 @@
+import { Direction, type GlyphId, type GlyphInfo, type GlyphPosition } from "../types.ts";
+/**
+ * Output buffer containing shaped glyphs.
+ * Result of the shaping process.
+ */
+export declare class GlyphBuffer {
+    /** Direction used during shaping */
+    direction: Direction;
+    /** Script used during shaping */
+    script: string;
+    /** Language used during shaping */
+    language: string | null;
+    /** Glyph information array */
+    infos: GlyphInfo[];
+    /** Glyph position array */
+    positions: GlyphPosition[];
+    /** Create buffer with pre-allocated capacity */
+    static withCapacity(capacity: number): GlyphBuffer;
+    /** Number of glyphs */
+    get length(): number;
+    /** Initialize from glyph infos (positions zeroed) */
+    initFromInfos(infos: GlyphInfo[]): void;
+    /** Set advance width for a glyph */
+    setAdvance(index: number, xAdvance: number, yAdvance?: number): void;
+    /** Add offset to a glyph position */
+    addOffset(index: number, xOffset: number, yOffset: number): void;
+    /** Replace glyph at index */
+    replaceGlyph(index: number, glyphId: GlyphId): void;
+    /** Insert glyph at index */
+    insertGlyph(index: number, info: GlyphInfo, position: GlyphPosition): void;
+    /** Remove glyphs in range [start, end) */
+    removeRange(start: number, end: number): void;
+    /** Merge clusters from start to end (inclusive) */
+    mergeClusters(start: number, end: number): void;
+    /** Reverse glyph order (for RTL) */
+    reverse(): void;
+    /** Reverse range [start, end) */
+    reverseRange(start: number, end: number): void;
+    /** Get total advance width */
+    getTotalAdvance(): {
+        x: number;
+        y: number;
+    };
+    /** Serialize to HarfBuzz-compatible format */
+    serialize(): string;
+    /** Get glyph IDs as array */
+    glyphIds(): GlyphId[];
+    /** Get clusters as array */
+    clusters(): number[];
+    /** Iterator for glyph info/position pairs */
+    [Symbol.iterator](): Iterator<{
+        info: GlyphInfo;
+        position: GlyphPosition;
+    }>;
+}

package/dist/buffer/unicode-buffer.d.ts

@@ -0,0 +1,51 @@
+import { BufferFlags, ClusterLevel, Direction, type GlyphInfo } from "../types.ts";
+/**
+ * Input buffer for text to be shaped.
+ * Holds Unicode codepoints with associated properties.
+ */
+export declare class UnicodeBuffer {
+    private _direction;
+    private _script;
+    private _language;
+    private _clusterLevel;
+    private _flags;
+    /** Codepoints to shape */
+    readonly codepoints: number[];
+    /** Cluster indices (maps each codepoint to its cluster) */
+    readonly clusters: number[];
+    /** Pre-context (text before the buffer for contextual shaping) */
+    preContext: number[];
+    /** Post-context (text after the buffer for contextual shaping) */
+    postContext: number[];
+    /** Add a string to the buffer */
+    addStr(text: string, startCluster?: number): this;
+    /** Add codepoints directly */
+    addCodepoints(codepoints: number[], startCluster?: number): this;
+    /** Add a single codepoint */
+    addCodepoint(codepoint: number, cluster?: number): this;
+    /** Set text direction */
+    setDirection(direction: Direction): this;
+    /** Set script (ISO 15924 tag, e.g., 'Latn', 'Arab') */
+    setScript(script: string): this;
+    /** Set language (BCP 47 tag, e.g., 'en', 'ar') */
+    setLanguage(language: string | null): this;
+    /** Set cluster level */
+    setClusterLevel(level: ClusterLevel): this;
+    /** Set buffer flags */
+    setFlags(flags: BufferFlags): this;
+    /** Set pre-context string */
+    setPreContext(text: string): this;
+    /** Set post-context string */
+    setPostContext(text: string): this;
+    /** Clear the buffer */
+    clear(): this;
+    /** Number of codepoints */
+    get length(): number;
+    get direction(): Direction;
+    get script(): string;
+    get language(): string | null;
+    get clusterLevel(): ClusterLevel;
+    get flags(): BufferFlags;
+    /** Convert to initial glyph infos (codepoint = glyphId initially) */
+    toGlyphInfos(): GlyphInfo[];
+}

package/dist/font/binary/reader.d.ts

@@ -0,0 +1,72 @@
+import type { F2Dot14, Fixed, int16, int32, Offset16, Offset32, Tag, uint8, uint16, uint32 } from "../../types.ts";
+/**
+ * Zero-copy binary reader for OpenType font data.
+ * All multi-byte values are big-endian per OpenType spec.
+ */
+export declare class Reader {
+    private readonly data;
+    private readonly start;
+    private readonly end;
+    private pos;
+    constructor(buffer: ArrayBuffer | DataView, offset?: number, length?: number);
+    /** Current read position relative to start */
+    get offset(): number;
+    /** Bytes remaining to read */
+    get remaining(): number;
+    /** Total length of this reader's view */
+    get length(): number;
+    /** Seek to absolute offset (relative to this reader's start) */
+    seek(offset: number): void;
+    /** Skip bytes */
+    skip(bytes: number): void;
+    /** Create a sub-reader (zero-copy slice) */
+    slice(offset: number, length: number): Reader;
+    /** Create a sub-reader from current position */
+    sliceFrom(offset: number): Reader;
+    /** Peek at a value without advancing position */
+    peek<T>(fn: () => T): T;
+    uint8(): uint8;
+    int8(): number;
+    uint16(): uint16;
+    int16(): int16;
+    uint32(): uint32;
+    int32(): int32;
+    /** 16.16 fixed-point number */
+    fixed(): Fixed;
+    /** 2.14 fixed-point number */
+    f2dot14(): F2Dot14;
+    /** Signed 16-bit integer in font design units */
+    fword(): int16;
+    /** Unsigned 16-bit integer in font design units */
+    ufword(): uint16;
+    /** 64-bit signed integer (seconds since 1904-01-01) */
+    longDateTime(): bigint;
+    /** 4-byte ASCII tag as packed uint32 */
+    tag(): Tag;
+    /** 4-byte ASCII tag as string */
+    tagString(): string;
+    /** 16-bit offset */
+    offset16(): Offset16;
+    /** 32-bit offset */
+    offset32(): Offset32;
+    /** 24-bit unsigned integer */
+    uint24(): number;
+    uint8Array(count: number): Uint8Array;
+    uint16Array(count: number): Uint16Array;
+    int16Array(count: number): Int16Array;
+    uint32Array(count: number): Uint32Array;
+    /** Read array using custom reader function */
+    array<T>(count: number, readFn: (reader: Reader) => T): T[];
+    /** Read ASCII string of given length */
+    ascii(length: number): string;
+    /** Read UTF-16BE string (used in 'name' table) */
+    utf16be(length: number): string;
+    /** Check if there are enough bytes remaining */
+    hasRemaining(bytes: number): boolean;
+    /** Throw if not enough bytes remaining */
+    ensureRemaining(bytes: number): void;
+    /** Get raw bytes as Uint8Array (zero-copy view) */
+    bytes(length: number): Uint8Array;
+    /** Read value at specific offset without moving position */
+    readAt<T>(offset: number, fn: (reader: Reader) => T): T;
+}

package/dist/font/face.d.ts

@@ -0,0 +1,65 @@
+import type { GlyphId, Tag, Variation } from "../types.ts";
+import type { Font } from "./font.ts";
+import { type VariationAxis } from "./tables/fvar.ts";
+/**
+ * A Face represents a specific instance of a variable font.
+ * For non-variable fonts, it simply wraps the Font.
+ */
+export declare class Face {
+    readonly font: Font;
+    /** Normalized axis coordinates [-1, 1] */
+    private _coords;
+    /** User-space axis values */
+    private _variations;
+    constructor(font: Font, variations?: Record<string, number> | Variation[]);
+    /**
+     * Set variation axis values
+     * @param variations Object with axis tags as keys (e.g., { wght: 700, wdth: 100 })
+     *                   or array of Variation objects
+     */
+    setVariations(variations: Record<string, number> | Variation[]): void;
+    /**
+     * Get normalized coordinates for variation processing
+     */
+    get normalizedCoords(): number[];
+    /**
+     * Check if this is a variable font instance
+     */
+    get isVariable(): boolean;
+    /**
+     * Get variation axes
+     */
+    get axes(): VariationAxis[];
+    /**
+     * Get current value for an axis
+     */
+    getAxisValue(axisTag: Tag | string): number | null;
+    /**
+     * Get advance width for a glyph, including variation deltas
+     */
+    advanceWidth(glyphId: GlyphId): number;
+    /**
+     * Get left side bearing for a glyph, including variation deltas
+     */
+    leftSideBearing(glyphId: GlyphId): number;
+    get numGlyphs(): number;
+    get unitsPerEm(): number;
+    get ascender(): number;
+    get descender(): number;
+    get lineGap(): number;
+    glyphId(codepoint: number): GlyphId;
+    glyphIdForChar(char: string): GlyphId;
+    hasTable(t: Tag): boolean;
+    get gdef(): import("./tables/gdef.ts").GdefTable | null;
+    get gsub(): import("./tables/gsub.ts").GsubTable | null;
+    get gpos(): import("./tables/gpos.ts").GposTable | null;
+    get kern(): import("./tables/kern.ts").KernTable | null;
+    get morx(): import("./tables/morx.ts").MorxTable | null;
+    get cmap(): import("./tables/cmap.ts").CmapTable;
+    get hmtx(): import("./tables/hmtx.ts").HmtxTable;
+    get hhea(): import("./tables/hhea.ts").HheaTable;
+}
+/**
+ * Create a face from a font with optional variations
+ */
+export declare function createFace(font: Font, variations?: Record<string, number> | Variation[]): Face;

package/dist/font/font.d.ts

@@ -0,0 +1,189 @@
+import type { GlyphId, TableRecord, Tag } from "../types.ts";
+import { Reader } from "./binary/reader.ts";
+import { type AvarTable } from "./tables/avar.ts";
+import { type BaseTable } from "./tables/base.ts";
+import { type CbdtTable, type CblcTable } from "./tables/cbdt.ts";
+import { type CffTable } from "./tables/cff.ts";
+import { type Cff2Table } from "./tables/cff2.ts";
+import { type CmapTable } from "./tables/cmap.ts";
+import { type ColrTable } from "./tables/colr.ts";
+import { type CpalTable } from "./tables/cpal.ts";
+import { type FvarTable } from "./tables/fvar.ts";
+import { type GdefTable } from "./tables/gdef.ts";
+import { type Contour, type GlyfTable, type Glyph } from "./tables/glyf.ts";
+import { type GposTable } from "./tables/gpos.ts";
+import { type GsubTable } from "./tables/gsub.ts";
+import { type GvarTable } from "./tables/gvar.ts";
+import { type HeadTable } from "./tables/head.ts";
+import { type HheaTable } from "./tables/hhea.ts";
+import { type HmtxTable } from "./tables/hmtx.ts";
+import { type HvarTable } from "./tables/hvar.ts";
+import { type JstfTable } from "./tables/jstf.ts";
+import { type KernTable } from "./tables/kern.ts";
+import { type KerxTable } from "./tables/kerx.ts";
+import { type LocaTable } from "./tables/loca.ts";
+import { type MathTable } from "./tables/math.ts";
+import { type MaxpTable } from "./tables/maxp.ts";
+import { type MorxTable } from "./tables/morx.ts";
+import { type MvarTable } from "./tables/mvar.ts";
+import { type NameTable } from "./tables/name.ts";
+import { type Os2Table } from "./tables/os2.ts";
+import { type PostTable } from "./tables/post.ts";
+import { type SbixTable } from "./tables/sbix.ts";
+import { type FeatTable } from "./tables/feat.ts";
+import { type StatTable } from "./tables/stat.ts";
+import { type SvgTable } from "./tables/svg.ts";
+import { type TrakTable } from "./tables/trak.ts";
+import { type VheaTable } from "./tables/vhea.ts";
+import { type VmtxTable } from "./tables/vmtx.ts";
+import { type VorgTable } from "./tables/vorg.ts";
+import { type VvarTable } from "./tables/vvar.ts";
+/** Font loading options */
+export interface FontLoadOptions {
+    /** Tables to parse eagerly (default: lazy) */
+    eagerTables?: Tag[];
+}
+/**
+ * Represents a loaded font file.
+ * Tables are parsed lazily on first access.
+ */
+export declare class Font {
+    private readonly reader;
+    private readonly directory;
+    private _head;
+    private _maxp;
+    private _hhea;
+    private _hmtx;
+    private _cmap;
+    private _gdef;
+    private _gsub;
+    private _gpos;
+    private _kern;
+    private _fvar;
+    private _hvar;
+    private _vhea;
+    private _vmtx;
+    private _morx;
+    private _gvar;
+    private _avar;
+    private _kerx;
+    private _trak;
+    private _cff;
+    private _cff2;
+    private _colr;
+    private _cpal;
+    private _vvar;
+    private _mvar;
+    private _os2;
+    private _name;
+    private _post;
+    private _base;
+    private _jstf;
+    private _math;
+    private _loca;
+    private _glyf;
+    private _svg;
+    private _vorg;
+    private _sbix;
+    private _stat;
+    private _cbdt;
+    private _cblc;
+    private _feat;
+    private constructor();
+    /** Load font from ArrayBuffer */
+    static load(buffer: ArrayBuffer, options?: FontLoadOptions): Font;
+    /** Load font from URL (works in browser and Bun) */
+    static fromURL(url: string, options?: FontLoadOptions): Promise<Font>;
+    /** Load font from file path (Bun only) */
+    static fromFile(path: string, options?: FontLoadOptions): Promise<Font>;
+    /** Check if font has a specific table */
+    hasTable(tag: Tag): boolean;
+    /** Get table record */
+    getTableRecord(tag: Tag): TableRecord | undefined;
+    /** Get reader for a table */
+    getTableReader(tag: Tag): Reader | null;
+    get head(): HeadTable;
+    get maxp(): MaxpTable;
+    get hhea(): HheaTable;
+    get hmtx(): HmtxTable;
+    get cmap(): CmapTable;
+    get gdef(): GdefTable | null;
+    get gsub(): GsubTable | null;
+    get gpos(): GposTable | null;
+    get kern(): KernTable | null;
+    get fvar(): FvarTable | null;
+    get hvar(): HvarTable | null;
+    get vhea(): VheaTable | null;
+    get vmtx(): VmtxTable | null;
+    get morx(): MorxTable | null;
+    get gvar(): GvarTable | null;
+    get avar(): AvarTable | null;
+    get kerx(): KerxTable | null;
+    get trak(): TrakTable | null;
+    get cff(): CffTable | null;
+    get cff2(): Cff2Table | null;
+    get colr(): ColrTable | null;
+    get cpal(): CpalTable | null;
+    get vvar(): VvarTable | null;
+    get mvar(): MvarTable | null;
+    get os2(): Os2Table | null;
+    get name(): NameTable | null;
+    get post(): PostTable | null;
+    get base(): BaseTable | null;
+    get jstf(): JstfTable | null;
+    get math(): MathTable | null;
+    get loca(): LocaTable | null;
+    get glyf(): GlyfTable | null;
+    get svg(): SvgTable | null;
+    get vorg(): VorgTable | null;
+    get sbix(): SbixTable | null;
+    get stat(): StatTable | null;
+    get cblc(): CblcTable | null;
+    get cbdt(): CbdtTable | null;
+    get feat(): FeatTable | null;
+    /** Number of glyphs in the font */
+    get numGlyphs(): number;
+    /** Units per em */
+    get unitsPerEm(): number;
+    /** Ascender (from hhea) */
+    get ascender(): number;
+    /** Descender (from hhea) */
+    get descender(): number;
+    /** Line gap (from hhea) */
+    get lineGap(): number;
+    /** Is this a TrueType font (vs CFF)? */
+    get isTrueType(): boolean;
+    /** Is this a CFF font? */
+    get isCFF(): boolean;
+    /** Is this a variable font? */
+    get isVariable(): boolean;
+    /** Has OpenType layout tables? */
+    get hasOpenTypeLayout(): boolean;
+    /** Has AAT layout tables? */
+    get hasAATLayout(): boolean;
+    /** Is this a color font? */
+    get isColorFont(): boolean;
+    /** Get glyph ID for a Unicode codepoint */
+    glyphId(codepoint: number): GlyphId;
+    /** Get glyph ID for a character */
+    glyphIdForChar(char: string): GlyphId;
+    /** Get advance width for a glyph */
+    advanceWidth(glyphId: GlyphId): number;
+    /** Get left side bearing for a glyph */
+    leftSideBearing(glyphId: GlyphId): number;
+    /** List all table tags in the font */
+    listTables(): string[];
+    /** Get raw glyph data (simple or composite) */
+    getGlyph(glyphId: GlyphId): Glyph | null;
+    /** Get flattened contours for a glyph (resolves composites) */
+    getGlyphContours(glyphId: GlyphId): Contour[] | null;
+    /** Get bounding box for a glyph */
+    getGlyphBounds(glyphId: GlyphId): {
+        xMin: number;
+        yMin: number;
+        xMax: number;
+        yMax: number;
+    } | null;
+    /** Get contours for a glyph with variation applied */
+    getGlyphContoursWithVariation(glyphId: GlyphId, axisCoords: number[]): Contour[] | null;
+}

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

@@ -0,0 +1,36 @@
+import type { uint16 } from "../../types.ts";
+import type { Reader } from "../binary/reader.ts";
+/**
+ * Axis Variations table (avar)
+ * Maps user-facing axis values to normalized coordinates
+ */
+export interface AvarTable {
+    majorVersion: uint16;
+    minorVersion: uint16;
+    axisSegmentMaps: AxisSegmentMap[];
+}
+/**
+ * Segment map for an axis
+ */
+export interface AxisSegmentMap {
+    axisValueMaps: AxisValueMap[];
+}
+/**
+ * Single value mapping
+ */
+export interface AxisValueMap {
+    fromCoordinate: number;
+    toCoordinate: number;
+}
+/**
+ * Parse avar table
+ */
+export declare function parseAvar(reader: Reader, axisCount: number): AvarTable;
+/**
+ * Apply avar mapping to a normalized coordinate
+ */
+export declare function applyAvarMapping(segmentMap: AxisSegmentMap, coord: number): number;
+/**
+ * Apply avar mappings to all axis coordinates
+ */
+export declare function applyAvar(avar: AvarTable, coords: number[]): number[];