text-shaper 0.0.1

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/layout/justify.d.ts

@@ -0,0 +1,88 @@
+import { GlyphBuffer } from "../buffer/glyph-buffer.ts";
+import type { Font } from "../font/font.ts";
+import type { GlyphId, Tag } from "../types.ts";
+/**
+ * Justification mode
+ */
+export declare enum JustifyMode {
+    /** Shrink text to fit */
+    Shrink = "shrink",
+    /** Extend text to fit */
+    Extend = "extend",
+    /** Auto-select based on delta */
+    Auto = "auto"
+}
+/**
+ * Justification options
+ */
+export interface JustifyOptions {
+    /** Target line width */
+    targetWidth: number;
+    /** Script tag */
+    script?: Tag;
+    /** Language tag */
+    language?: Tag;
+    /** Justification mode */
+    mode?: JustifyMode;
+    /** Maximum priority level to use (0-based) */
+    maxPriority?: number;
+    /** Enable Kashida insertion for Arabic */
+    enableKashida?: boolean;
+    /** Minimum word spacing factor (default: 0.8) */
+    minWordSpacingFactor?: number;
+    /** Maximum word spacing factor (default: 1.5) */
+    maxWordSpacingFactor?: number;
+    /** Enable inter-character spacing adjustment */
+    enableLetterSpacing?: boolean;
+    /** Maximum letter spacing in font units */
+    maxLetterSpacing?: number;
+}
+/**
+ * Justification result
+ */
+export interface JustifyResult {
+    /** Whether justification succeeded */
+    success: boolean;
+    /** Final line width after justification */
+    finalWidth: number;
+    /** Delta from target (positive = too wide, negative = too narrow) */
+    delta: number;
+    /** Priority level used */
+    priorityLevel: number;
+    /** Adjustments applied */
+    adjustments: JustifyAdjustment[];
+}
+/**
+ * Individual justification adjustment
+ */
+export interface JustifyAdjustment {
+    type: "spacing" | "kashida" | "lookup";
+    /** Glyph indices affected */
+    glyphIndices: number[];
+    /** Adjustment value */
+    value: number;
+}
+/**
+ * Calculate current line width from glyph buffer
+ */
+export declare function calculateLineWidth(buffer: GlyphBuffer): number;
+/**
+ * Justify a shaped glyph buffer to fit a target width
+ */
+export declare function justify(font: Font, buffer: GlyphBuffer, options: JustifyOptions): JustifyResult;
+/**
+ * Simple line breaking for multi-line text
+ */
+export interface LineBreakResult {
+    lines: GlyphBuffer[];
+    breakPoints: number[];
+}
+/**
+ * Break shaped text into lines at a given width
+ * Uses simple greedy algorithm
+ */
+export declare function breakIntoLines(buffer: GlyphBuffer, maxWidth: number, spaceGlyph?: GlyphId): LineBreakResult;
+/**
+ * Justify all lines in a paragraph to the same width
+ */
+export declare function justifyParagraph(font: Font, lines: GlyphBuffer[], options: JustifyOptions): JustifyResult[];

package/dist/layout/structures/class-def.d.ts

@@ -0,0 +1,15 @@
+import type { Reader } from "../../font/binary/reader.ts";
+import type { GlyphId } from "../../types.ts";
+/** Class Definition table - maps glyph IDs to class values */
+export interface ClassDef {
+    /** Get class for a glyph ID (returns 0 if not defined) */
+    get(glyphId: GlyphId): number;
+    /** Get all glyphs in a specific class */
+    glyphsInClass(classValue: number): GlyphId[];
+}
+/** Singleton empty ClassDef */
+export declare const EMPTY_CLASS_DEF: ClassDef;
+/** Parse a Class Definition table */
+export declare function parseClassDef(reader: Reader): ClassDef;
+/** Parse ClassDef from offset, or return empty if offset is 0 */
+export declare function parseClassDefAt(reader: Reader, offset: number): ClassDef;

package/dist/layout/structures/coverage.d.ts

@@ -0,0 +1,17 @@
+import type { Reader } from "../../font/binary/reader.ts";
+import type { GlyphId } from "../../types.ts";
+/** Coverage table - maps glyph IDs to coverage indices */
+export interface Coverage {
+    /** Get coverage index for a glyph ID, or null if not covered */
+    get(glyphId: GlyphId): number | null;
+    /** Check if glyph is covered */
+    covers(glyphId: GlyphId): boolean;
+    /** Get all covered glyph IDs */
+    glyphs(): GlyphId[];
+    /** Number of covered glyphs */
+    readonly size: number;
+}
+/** Parse a Coverage table */
+export declare function parseCoverage(reader: Reader): Coverage;
+/** Parse Coverage from offset (creates sub-reader) */
+export declare function parseCoverageAt(reader: Reader, offset: number): Coverage;

package/dist/layout/structures/device.d.ts

@@ -0,0 +1,58 @@
+import type { Reader } from "../../font/binary/reader.ts";
+import type { int16, uint16 } from "../../types.ts";
+/**
+ * Device table - pixel-level adjustments for different PPEM sizes
+ * Used in GPOS for fine-tuning positioning at specific sizes
+ */
+export interface DeviceTable {
+    startSize: uint16;
+    endSize: uint16;
+    deltaFormat: uint16;
+    /** Delta values indexed by (ppem - startSize) */
+    deltaValues: int16[];
+}
+/** VariationIndex table for variable fonts (shares format with Device) */
+export interface VariationIndexTable {
+    deltaSetOuterIndex: uint16;
+    deltaSetInnerIndex: uint16;
+}
+/** Combined type - can be either Device or VariationIndex */
+export type DeviceOrVariationIndex = DeviceTable | VariationIndexTable;
+/** Check if this is a VariationIndex table */
+export declare function isVariationIndexTable(table: DeviceOrVariationIndex): table is VariationIndexTable;
+/** Parse Device or VariationIndex table at offset */
+export declare function parseDeviceAt(reader: Reader, offset: number): DeviceOrVariationIndex | null;
+/** Parse Device or VariationIndex table */
+export declare function parseDevice(reader: Reader): DeviceOrVariationIndex;
+/**
+ * Get delta adjustment for a specific PPEM size
+ * Returns 0 if the size is outside the table's range
+ */
+export declare function getDeviceDelta(device: DeviceTable, ppem: number): int16;
+/**
+ * Apply Device table adjustment to a value
+ * For variable fonts, this would need ItemVariationStore lookup instead
+ */
+export declare function applyDeviceAdjustment(device: DeviceOrVariationIndex | null, value: number, ppem: number): number;
+/**
+ * Parsed value record with resolved Device tables
+ */
+export interface ResolvedValueRecord {
+    xPlacement: number;
+    yPlacement: number;
+    xAdvance: number;
+    yAdvance: number;
+    xPlaDevice: DeviceOrVariationIndex | null;
+    yPlaDevice: DeviceOrVariationIndex | null;
+    xAdvDevice: DeviceOrVariationIndex | null;
+    yAdvDevice: DeviceOrVariationIndex | null;
+}
+/**
+ * Apply all Device adjustments to a resolved value record
+ */
+export declare function applyDeviceAdjustments(record: ResolvedValueRecord, ppem: number): {
+    xPlacement: number;
+    yPlacement: number;
+    xAdvance: number;
+    yAdvance: number;
+};

package/dist/layout/structures/feature-variations.d.ts

@@ -0,0 +1,82 @@
+import type { Reader } from "../../font/binary/reader.ts";
+import type { Tag, uint16 } from "../../types.ts";
+/**
+ * FeatureVariations table
+ * Allows different feature substitutions based on variation axis coordinates
+ * Used in GSUB/GPOS for variable fonts
+ */
+export interface FeatureVariations {
+    majorVersion: number;
+    minorVersion: number;
+    featureVariationRecords: FeatureVariationRecord[];
+}
+/**
+ * Feature variation record
+ * Contains a condition set and feature substitutions to apply when conditions are met
+ */
+export interface FeatureVariationRecord {
+    conditionSet: ConditionSet;
+    featureTableSubstitution: FeatureTableSubstitution;
+}
+/**
+ * Condition set - all conditions must be met
+ */
+export interface ConditionSet {
+    conditions: Condition[];
+}
+/**
+ * Single axis condition
+ */
+export interface Condition {
+    format: number;
+    axisIndex: uint16;
+    filterRangeMinValue: number;
+    filterRangeMaxValue: number;
+}
+/**
+ * Feature table substitution
+ * Maps feature indices to replacement feature tables
+ */
+export interface FeatureTableSubstitution {
+    majorVersion: number;
+    minorVersion: number;
+    substitutions: FeatureSubstitutionRecord[];
+}
+/**
+ * Single feature substitution record
+ */
+export interface FeatureSubstitutionRecord {
+    featureIndex: uint16;
+    alternateFeature: AlternateFeature;
+}
+/**
+ * Alternate feature table
+ */
+export interface AlternateFeature {
+    featureParamsOffset: uint16;
+    lookupListIndices: uint16[];
+}
+/**
+ * Parse FeatureVariations table
+ */
+export declare function parseFeatureVariations(reader: Reader): FeatureVariations;
+/**
+ * Evaluate condition set against axis coordinates
+ * Returns true if all conditions are met
+ */
+export declare function evaluateConditionSet(conditionSet: ConditionSet, axisCoords: number[]): boolean;
+/**
+ * Find matching feature variation record for given axis coordinates
+ * Returns the first matching record, or null if none match
+ */
+export declare function findMatchingFeatureVariation(featureVariations: FeatureVariations, axisCoords: number[]): FeatureVariationRecord | null;
+/**
+ * Get substituted lookup list indices for a feature
+ * Returns the original lookups if no substitution applies
+ */
+export declare function getSubstitutedLookups(featureVariations: FeatureVariations | null, featureIndex: number, originalLookups: uint16[], axisCoords: number[] | null): uint16[];
+/**
+ * Apply feature variations to a feature list
+ * Returns a modified feature list with substituted lookup indices
+ */
+export declare function applyFeatureVariations(featureVariations: FeatureVariations | null, featureLookups: Map<Tag, uint16[]>, featureIndices: Map<Tag, number>, axisCoords: number[] | null): Map<Tag, uint16[]>;

package/dist/layout/structures/layout-common.d.ts

@@ -0,0 +1,77 @@
+import type { Reader } from "../../font/binary/reader.ts";
+import type { Tag, uint16 } from "../../types.ts";
+/** Language system record */
+export interface LangSysRecord {
+    langSysTag: Tag;
+    langSys: LangSys;
+}
+/** Language system table */
+export interface LangSys {
+    /** Required feature index (0xFFFF if none) */
+    requiredFeatureIndex: uint16;
+    /** Feature indices */
+    featureIndices: uint16[];
+}
+/** Script record */
+export interface ScriptRecord {
+    scriptTag: Tag;
+    script: Script;
+}
+/** Script table */
+export interface Script {
+    /** Default language system (may be null) */
+    defaultLangSys: LangSys | null;
+    /** Language system records */
+    langSysRecords: LangSysRecord[];
+}
+/** Script list table */
+export interface ScriptList {
+    scripts: ScriptRecord[];
+}
+/** Feature record */
+export interface FeatureRecord {
+    featureTag: Tag;
+    feature: Feature;
+}
+/** Feature table */
+export interface Feature {
+    /** Feature parameters offset (usually 0) */
+    featureParamsOffset: uint16;
+    /** Lookup indices */
+    lookupListIndices: uint16[];
+}
+/** Feature list table */
+export interface FeatureList {
+    features: FeatureRecord[];
+}
+/** Lookup table header */
+export interface LookupHeader {
+    lookupType: uint16;
+    lookupFlag: uint16;
+    subtableOffsets: uint16[];
+    /** Mark filtering set (if UseMarkFilteringSet flag is set) */
+    markFilteringSet?: uint16;
+}
+/** Lookup flags */
+export declare const LookupFlag: {
+    readonly RightToLeft: 1;
+    readonly IgnoreBaseGlyphs: 2;
+    readonly IgnoreLigatures: 4;
+    readonly IgnoreMarks: 8;
+    readonly UseMarkFilteringSet: 16;
+    readonly MarkAttachmentTypeMask: 65280;
+};
+/** Extract mark attachment type from lookup flag */
+export declare function getMarkAttachmentType(lookupFlag: uint16): number;
+/** Parse ScriptList */
+export declare function parseScriptList(reader: Reader): ScriptList;
+/** Parse FeatureList */
+export declare function parseFeatureList(reader: Reader): FeatureList;
+/** Parse lookup headers (does not parse subtables) */
+export declare function parseLookupHeaders(reader: Reader): LookupHeader[];
+/** Find script in script list */
+export declare function findScript(scriptList: ScriptList, scriptTag: Tag): Script | null;
+/** Find language system in script */
+export declare function findLangSys(script: Script, langSysTag: Tag | null): LangSys | null;
+/** Get feature by index */
+export declare function getFeature(featureList: FeatureList, index: number): FeatureRecord | null;

package/dist/render/path.d.ts

@@ -0,0 +1,136 @@
+import type { GlyphBuffer } from "../buffer/glyph-buffer.ts";
+import type { Font } from "../font/font.ts";
+import type { Contour } from "../font/tables/glyf.ts";
+import type { GlyphId } from "../types.ts";
+/**
+ * Path command types for glyph rendering
+ */
+export type PathCommand = {
+    type: "M";
+    x: number;
+    y: number;
+} | {
+    type: "L";
+    x: number;
+    y: number;
+} | {
+    type: "Q";
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    type: "C";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: "Z";
+};
+/**
+ * A glyph path is a series of drawing commands
+ */
+export interface GlyphPath {
+    commands: PathCommand[];
+    bounds: {
+        xMin: number;
+        yMin: number;
+        xMax: number;
+        yMax: number;
+    } | null;
+}
+/**
+ * Convert TrueType contours to path commands
+ * TrueType uses quadratic Bézier curves with on-curve and off-curve points
+ */
+export declare function contourToPath(contour: Contour): PathCommand[];
+/**
+ * Get path commands for a glyph
+ */
+export declare function getGlyphPath(font: Font, glyphId: GlyphId): GlyphPath | null;
+/**
+ * Convert path commands to SVG path data string
+ */
+export declare function pathToSVG(path: GlyphPath, options?: {
+    flipY?: boolean;
+    scale?: number;
+}): string;
+/**
+ * Render path commands to a Canvas 2D context
+ */
+export declare function pathToCanvas(ctx: CanvasRenderingContext2D | Path2D, path: GlyphPath, options?: {
+    flipY?: boolean;
+    scale?: number;
+    offsetX?: number;
+    offsetY?: number;
+}): void;
+/**
+ * Generate an SVG element for a glyph
+ */
+export declare function glyphToSVG(font: Font, glyphId: GlyphId, options?: {
+    fontSize?: number;
+    fill?: string;
+}): string | null;
+/**
+ * Render shaped text to Canvas
+ */
+export interface ShapedGlyph {
+    glyphId: GlyphId;
+    xOffset: number;
+    yOffset: number;
+    xAdvance: number;
+    yAdvance: number;
+}
+export declare function renderShapedText(ctx: CanvasRenderingContext2D, font: Font, glyphs: ShapedGlyph[], options?: {
+    fontSize?: number;
+    x?: number;
+    y?: number;
+    fill?: string;
+}): void;
+/**
+ * Generate SVG for shaped text
+ */
+export declare function shapedTextToSVG(font: Font, glyphs: ShapedGlyph[], options?: {
+    fontSize?: number;
+    fill?: string;
+}): string;
+/**
+ * Convert GlyphBuffer output to ShapedGlyph array
+ */
+export declare function glyphBufferToShapedGlyphs(buffer: GlyphBuffer): ShapedGlyph[];
+/**
+ * Get glyph path with variable font variation applied
+ */
+export declare function getGlyphPathWithVariation(font: Font, glyphId: GlyphId, axisCoords: number[]): GlyphPath | null;
+/**
+ * Render shaped text with variable font support
+ */
+export declare function renderShapedTextWithVariation(ctx: CanvasRenderingContext2D, font: Font, glyphs: ShapedGlyph[], axisCoords: number[], options?: {
+    fontSize?: number;
+    x?: number;
+    y?: number;
+    fill?: string;
+}): void;
+/**
+ * Generate SVG for shaped text with variable font support
+ */
+export declare function shapedTextToSVGWithVariation(font: Font, glyphs: ShapedGlyph[], axisCoords: number[], options?: {
+    fontSize?: number;
+    fill?: string;
+}): string;
+/**
+ * Calculate the total advance width of shaped text
+ */
+export declare function getTextWidth(glyphs: ShapedGlyph[], font: Font, fontSize: number): number;
+/**
+ * Create a Path2D object from glyph path
+ */
+export declare function createPath2D(path: GlyphPath, options?: {
+    flipY?: boolean;
+    scale?: number;
+    offsetX?: number;
+    offsetY?: number;
+}): Path2D;

package/dist/shaper/complex/arabic.d.ts

@@ -0,0 +1,60 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Arabic joining types from Unicode
+ */
+export declare enum ArabicJoiningType {
+    NonJoining = "U",// Non_Joining
+    RightJoining = "R",// Right_Joining (joins on the right)
+    DualJoining = "D",// Dual_Joining (joins on both sides)
+    JoinCausing = "C",// Join_Causing (like TATWEEL)
+    LeftJoining = "L",// Left_Joining (rare)
+    Transparent = "T"
+}
+/**
+ * Action to take for each glyph based on context
+ */
+export declare enum JoiningAction {
+    None = 0,
+    Isol = 1,// Isolated form
+    Fina = 2,// Final form
+    Medi = 3,// Medial form
+    Init = 4
+}
+/**
+ * Arabic joining group for specific shaping behavior
+ */
+export declare enum ArabicJoiningGroup {
+    None = 0,
+    Alaph = 1,
+    DalathRish = 2
+}
+/**
+ * Per-glyph info for Arabic shaping
+ */
+export interface ArabicGlyphData {
+    joiningType: ArabicJoiningType;
+    joiningGroup: ArabicJoiningGroup;
+    action: JoiningAction;
+}
+/**
+ * Check if a codepoint is in Arabic script range
+ */
+export declare function isArabic(cp: number): boolean;
+/**
+ * Get the joining type for a codepoint
+ * Based on Unicode Arabic Shaping data
+ */
+export declare function getJoiningType(cp: number): ArabicJoiningType;
+/**
+ * Analyze joining for a sequence of glyphs.
+ * Returns the action to take for each glyph.
+ */
+export declare function analyzeJoining(infos: GlyphInfo[]): JoiningAction[];
+/**
+ * Get the feature tag for a joining action
+ */
+export declare function getFeatureForAction(action: JoiningAction): string | null;
+/**
+ * Set the feature mask for each glyph based on joining analysis
+ */
+export declare function setupArabicMasks(infos: GlyphInfo[]): void;

package/dist/shaper/complex/ethiopic.d.ts

@@ -0,0 +1,70 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Ethiopic shaper
+ * Handles Ethiopic/Ge'ez script
+ *
+ * Ethiopic is an abugida (alphasyllabary) where:
+ * - Base consonants have inherent vowel 'a'
+ * - Vowels modify the base consonant shape
+ * - No joining behavior (unlike Arabic)
+ * - Left-to-right direction
+ *
+ * Key features:
+ * - Syllable-based writing (CV or CVC)
+ * - Labialization marks (W modifier)
+ * - Extended character sets for various languages
+ */
+/**
+ * Ethiopic character categories
+ */
+export declare enum EthiopicCategory {
+    Other = 0,
+    Syllable = 1,// Main syllabic characters (consonant + vowel)
+    Digit = 2,// Ethiopic digits
+    Punctuation = 3,// Ethiopic punctuation
+    Modifier = 4,// Combining marks
+    ToneMark = 5
+}
+/**
+ * Get Ethiopic category for codepoint
+ */
+export declare function getEthiopicCategory(cp: number): EthiopicCategory;
+/**
+ * Check if codepoint is an Ethiopic syllable
+ */
+export declare function isEthiopicSyllable(cp: number): boolean;
+/**
+ * Get the vowel form of an Ethiopic syllable (0-7)
+ * 0 = First form (inherent ä or a)
+ * 1 = Second form (u)
+ * 2 = Third form (i)
+ * 3 = Fourth form (a)
+ * 4 = Fifth form (e)
+ * 5 = Sixth form (ə or no vowel)
+ * 6 = Seventh form (o)
+ * 7 = Eighth form (wa) - labialized
+ */
+export declare function getEthiopicVowelForm(cp: number): number;
+/**
+ * Ethiopic feature masks
+ */
+export declare const EthiopicFeatureMask: {
+    readonly ccmp: 1;
+    readonly locl: 2;
+    readonly calt: 4;
+    readonly liga: 8;
+    readonly ss01: 16;
+    readonly ss02: 32;
+};
+/**
+ * Set up masks for Ethiopic shaping
+ */
+export declare function setupEthiopicMasks(infos: GlyphInfo[]): void;
+/**
+ * Get default Ethiopic features in order
+ */
+export declare function getEthiopicFeatures(): string[];
+/**
+ * Check if script uses Ethiopic shaper
+ */
+export declare function usesEthiopic(script: string): boolean;

package/dist/shaper/complex/georgian.d.ts

@@ -0,0 +1,69 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Georgian shaper
+ * Handles Georgian script (Mkhedruli, Asomtavruli, Nuskhuri)
+ *
+ * Georgian is relatively simple compared to other complex scripts:
+ * - No complex reordering
+ * - No joining behavior
+ * - Case transformations (Mkhedruli lowercase, Mtavruli uppercase)
+ * - Historical scripts (Asomtavruli, Nuskhuri)
+ *
+ * Main complexity:
+ * - Mtavruli (uppercase) added in Unicode 11.0
+ * - Stylistic variants between scripts
+ * - Small caps via 'smcp' feature
+ */
+/**
+ * Georgian character categories
+ */
+export declare enum GeorgianCategory {
+    Other = 0,
+    Mkhedruli = 1,// Modern lowercase (10D0-10FA, 10FC, 10FD-10FF)
+    Mtavruli = 2,// Modern uppercase (1C90-1CBA, 1CBD-1CBF)
+    Asomtavruli = 3,// Old Church uppercase (10A0-10C5, 10C7, 10CD)
+    Nuskhuri = 4,// Old Church lowercase (2D00-2D25, 2D27, 2D2D)
+    Modifier = 5,// Modifiers (10FB)
+    Punctuation = 6,// Punctuation (10FB)
+    Digit = 7,// Digits (using Latin digits with Georgian)
+    Letter = 8
+}
+/**
+ * Get Georgian category for codepoint
+ */
+export declare function getGeorgianCategory(cp: number): GeorgianCategory;
+/**
+ * Check if character is a Georgian letter
+ */
+export declare function isGeorgianLetter(cp: number): boolean;
+/**
+ * Georgian case mapping (Mkhedruli <-> Mtavruli)
+ * Returns the corresponding uppercase/lowercase codepoint, or 0 if none
+ */
+export declare function georgianToUpper(cp: number): number;
+export declare function georgianToLower(cp: number): number;
+/**
+ * Georgian feature masks
+ */
+export declare const GeorgianFeatureMask: {
+    readonly ccmp: 1;
+    readonly locl: 2;
+    readonly calt: 4;
+    readonly liga: 8;
+    readonly smcp: 16;
+    readonly c2sc: 32;
+    readonly case_: 64;
+    readonly cpsp: 128;
+};
+/**
+ * Set up masks for Georgian shaping
+ */
+export declare function setupGeorgianMasks(infos: GlyphInfo[]): void;
+/**
+ * Get default Georgian features in order
+ */
+export declare function getGeorgianFeatures(): string[];
+/**
+ * Check if script uses Georgian shaper
+ */
+export declare function usesGeorgian(script: string): boolean;