text-shaper 0.0.1

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

@@ -0,0 +1,64 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Check if codepoint is a Hangul syllable
+ */
+export declare function isHangulSyllable(cp: number): boolean;
+/**
+ * Check if codepoint is a Hangul Jamo (conjoining)
+ */
+export declare function isHangulJamo(cp: number): boolean;
+/**
+ * Check if codepoint is a leading consonant (L)
+ */
+export declare function isJamoL(cp: number): boolean;
+/**
+ * Check if codepoint is a vowel (V)
+ */
+export declare function isJamoV(cp: number): boolean;
+/**
+ * Check if codepoint is a trailing consonant (T)
+ */
+export declare function isJamoT(cp: number): boolean;
+/**
+ * Decompose a precomposed Hangul syllable into Jamo
+ */
+export declare function decomposeHangul(cp: number): number[];
+/**
+ * Compose Jamo into a precomposed Hangul syllable
+ */
+export declare function composeHangul(l: number, v: number, t?: number): number | null;
+/**
+ * Hangul syllable types
+ */
+export declare enum HangulSyllableType {
+    NotApplicable = 0,
+    LeadingJamo = 1,// L
+    VowelJamo = 2,// V
+    TrailingJamo = 3,// T
+    LVSyllable = 4,// LV (no trailing)
+    LVTSyllable = 5
+}
+/**
+ * Get the syllable type of a codepoint
+ */
+export declare function getHangulSyllableType(cp: number): HangulSyllableType;
+/**
+ * Feature masks for Hangul
+ */
+export declare const HangulFeatureMask: {
+    readonly ljmo: 1;
+    readonly vjmo: 2;
+    readonly tjmo: 4;
+};
+/**
+ * Setup Hangul masks for feature application
+ */
+export declare function setupHangulMasks(infos: GlyphInfo[]): void;
+/**
+ * Normalize Hangul - compose Jamo sequences into syllables where possible
+ */
+export declare function normalizeHangul(infos: GlyphInfo[]): GlyphInfo[];
+/**
+ * Check if codepoint is Korean (Hangul or Jamo)
+ */
+export declare function isKorean(cp: number): boolean;

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

@@ -0,0 +1,28 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Hebrew character categories
+ */
+export declare enum HebrewCategory {
+    Other = 0,
+    Letter = 1,// Regular letter
+    Point = 2,// Niqqud (vowel point)
+    Dagesh = 3,// Dagesh/Mapiq
+    Shin = 4,// Shin/Sin dot
+    Rafe = 5,// Rafe mark
+    Accent = 6,// Cantillation marks
+    Maqaf = 7,// Hebrew hyphen
+    Punctuation = 8
+}
+/**
+ * Check if codepoint is Hebrew
+ */
+export declare function isHebrew(cp: number): boolean;
+/**
+ * Get Hebrew category for a codepoint
+ */
+export declare function getHebrewCategory(cp: number): HebrewCategory;
+/**
+ * Set up masks for Hebrew shaping
+ * Hebrew is relatively simple - mainly RTL with marks
+ */
+export declare function setupHebrewMasks(infos: GlyphInfo[]): void;

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

@@ -0,0 +1,117 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Indic syllable categories based on Unicode and OpenType spec
+ */
+export declare enum IndicCategory {
+    X = 0,// Other/Unknown
+    C = 1,// Consonant
+    V = 2,// Independent vowel
+    N = 3,// Nukta
+    H = 4,// Halant/Virama
+    ZWNJ = 5,// Zero Width Non-Joiner
+    ZWJ = 6,// Zero Width Joiner
+    M = 7,// Matra (dependent vowel)
+    SM = 8,// Syllable modifier (anusvara, visarga)
+    A = 9,// Accent mark
+    VD = 10,// Vedic mark
+    Placeholder = 11,// Placeholder (dotted circle)
+    Dotted_Circle = 12,// Explicit dotted circle
+    RS = 13,// Repha form
+    Coeng = 14,// Coeng (Khmer virama)
+    Ra = 15,// Ra consonant (for repha)
+    CM = 16,// Consonant modifier
+    Symbol = 17,// Symbol
+    CS = 18
+}
+/**
+ * Indic syllabic position
+ */
+export declare enum IndicPosition {
+    Start = 0,
+    RaToBecomeReph = 1,
+    PreM = 2,
+    PreC = 3,
+    BaseC = 4,
+    AfterMain = 5,
+    AboveC = 6,
+    BeforeSub = 7,
+    BelowC = 8,
+    AfterSub = 9,
+    BeforePost = 10,
+    PostC = 11,
+    AfterPost = 12,
+    FinalC = 13,
+    SMVD = 14,
+    End = 15
+}
+/**
+ * Per-glyph Indic shaping data
+ */
+export interface IndicGlyphData {
+    category: IndicCategory;
+    position: IndicPosition;
+    syllableIndex: number;
+}
+/**
+ * Check if a codepoint is an Indic script
+ */
+export declare function isIndic(cp: number): boolean;
+/**
+ * Get the Indic category for a codepoint
+ */
+export declare function getIndicCategory(cp: number): IndicCategory;
+/**
+ * Syllable structure for Indic scripts
+ */
+interface Syllable {
+    start: number;
+    end: number;
+    hasReph: boolean;
+    baseConsonant: number;
+}
+/**
+ * Find syllable boundaries in the glyph buffer
+ */
+export declare function findSyllables(infos: GlyphInfo[]): Syllable[];
+/**
+ * Indic feature masks for OpenType features
+ */
+export declare const IndicFeatureMask: {
+    readonly nukt: 1;
+    readonly akhn: 2;
+    readonly rphf: 4;
+    readonly rkrf: 8;
+    readonly pref: 16;
+    readonly blwf: 32;
+    readonly abvf: 64;
+    readonly half: 128;
+    readonly pstf: 256;
+    readonly vatu: 512;
+    readonly cjct: 1024;
+    readonly init: 2048;
+    readonly pres: 4096;
+    readonly abvs: 8192;
+    readonly blws: 16384;
+    readonly psts: 32768;
+};
+/**
+ * Matra position in syllable
+ */
+export declare enum MatraPosition {
+    PreBase = 0,
+    AboveBase = 1,
+    BelowBase = 2,
+    PostBase = 3
+}
+/**
+ * Set up masks and syllable indices for Indic shaping
+ */
+export declare function setupIndicMasks(infos: GlyphInfo[]): void;
+/**
+ * Reorder glyphs within a syllable for correct visual display
+ * This handles:
+ * - Moving pre-base matras before the base consonant
+ * - Moving reph to its final position
+ */
+export declare function reorderIndic(infos: GlyphInfo[]): void;
+export {};

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

@@ -0,0 +1,48 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Khmer character categories
+ */
+export declare enum KhmerCategory {
+    Other = 0,
+    Consonant = 1,
+    IndependentVowel = 2,
+    DependentVowel = 3,
+    Coeng = 4,// Subscript sign (្)
+    Register = 5,// Register shifters
+    Robat = 6,// Consonant shifter (៌)
+    Sign = 7,
+    Anusvara = 8,// Nikahit (ំ)
+    Visarga = 9
+}
+/**
+ * Get Khmer character category
+ */
+export declare function getKhmerCategory(cp: number): KhmerCategory;
+/**
+ * Khmer feature masks
+ */
+export declare const KhmerFeatureMask: {
+    readonly pref: 1;
+    readonly blwf: 2;
+    readonly abvf: 4;
+    readonly pstf: 8;
+    readonly cfar: 16;
+    readonly pres: 32;
+    readonly abvs: 64;
+    readonly blws: 128;
+    readonly psts: 256;
+    readonly clig: 512;
+};
+/**
+ * Check if codepoint is Khmer
+ */
+export declare function isKhmer(cp: number): boolean;
+/**
+ * Setup Khmer masks for feature application
+ */
+export declare function setupKhmerMasks(infos: GlyphInfo[]): void;
+/**
+ * Reorder Khmer pre-base vowels
+ * Pre-base vowels (◌េ ◌ែ ◌ៃ) should visually appear before the base
+ */
+export declare function reorderKhmer(infos: GlyphInfo[]): void;

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

@@ -0,0 +1,89 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Mongolian shaper
+ * Handles Traditional Mongolian, Manchu, and Sibe scripts
+ *
+ * Mongolian is written vertically (top to bottom, left to right columns).
+ * Like Arabic, it has context-sensitive letter forms:
+ * - Initial, Medial, Final, and Isolated forms
+ *
+ * Key characteristics:
+ * - Vertical writing
+ * - Positional forms (like Arabic joining)
+ * - Free variation selectors (FVS1-FVS4)
+ * - Vowel separators (MVS, NNBSP)
+ */
+/**
+ * Mongolian character categories
+ */
+export declare enum MongolianCategory {
+    Other = 0,
+    Letter = 1,// Regular letters
+    Vowel = 2,// Vowels
+    Digit = 3,// Digits
+    Punctuation = 4,// Punctuation
+    FVS = 5,// Free Variation Selector
+    MVS = 6,// Mongolian Vowel Separator (180E)
+    NNBSP = 7,// Narrow No-Break Space (202F)
+    ZWJ = 8,// Zero Width Joiner
+    ZWNJ = 9
+}
+/**
+ * Mongolian joining types (like Arabic)
+ */
+export declare enum MongolianJoining {
+    NonJoining = 0,
+    RightJoining = 1,// Joins to right (previous in text order)
+    DualJoining = 2,// Joins both sides
+    LeftJoining = 3,// Joins to left (next in text order) - rare
+    Transparent = 4,// Invisible control characters
+    Causing = 5
+}
+/**
+ * Get Mongolian category
+ */
+export declare function getMongolianCategory(cp: number): MongolianCategory;
+/**
+ * Get Mongolian joining type for a codepoint
+ */
+export declare function getMongolianJoining(cp: number): MongolianJoining;
+/**
+ * Mongolian positional forms
+ */
+export declare enum MongolianForm {
+    Isolated = 0,
+    Initial = 1,
+    Medial = 2,
+    Final = 3
+}
+/**
+ * Determine positional form for a Mongolian character
+ */
+export declare function getMongolianForm(prev: MongolianJoining, current: MongolianJoining, next: MongolianJoining): MongolianForm;
+/**
+ * Mongolian feature masks
+ */
+export declare const MongolianFeatureMask: {
+    readonly ccmp: 1;
+    readonly locl: 2;
+    readonly isol: 4;
+    readonly init: 8;
+    readonly medi: 16;
+    readonly fina: 32;
+    readonly rlig: 64;
+    readonly calt: 128;
+    readonly liga: 256;
+    readonly vert: 512;
+};
+/**
+ * Set up masks for Mongolian shaping
+ */
+export declare function setupMongolianMasks(infos: GlyphInfo[]): void;
+/**
+ * Get default Mongolian features in order
+ */
+export declare function getMongolianFeatures(): string[];
+/**
+ * Check if script uses Mongolian shaper
+ */
+export declare function usesMongolian(script: string): boolean;

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

@@ -0,0 +1,47 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Myanmar character categories
+ */
+export declare enum MyanmarCategory {
+    Other = 0,
+    Consonant = 1,
+    IndependentVowel = 2,
+    DependentVowel = 3,
+    Medial = 4,
+    Asat = 5,// Killer (္)
+    Anusvara = 6,// Dot below
+    Visarga = 7,// Visarga
+    Sign = 8,
+    Number = 9,
+    Placeholder = 10
+}
+/**
+ * Get Myanmar character category
+ */
+export declare function getMyanmarCategory(cp: number): MyanmarCategory;
+/**
+ * Myanmar feature masks
+ */
+export declare const MyanmarFeatureMask: {
+    readonly rphf: 1;
+    readonly pref: 2;
+    readonly blwf: 4;
+    readonly pstf: 8;
+    readonly pres: 16;
+    readonly abvs: 32;
+    readonly blws: 64;
+    readonly psts: 128;
+};
+/**
+ * Check if codepoint is Myanmar
+ */
+export declare function isMyanmar(cp: number): boolean;
+/**
+ * Setup Myanmar masks for feature application
+ */
+export declare function setupMyanmarMasks(infos: GlyphInfo[]): void;
+/**
+ * Reorder Myanmar pre-base vowels and medials
+ * ေ and ြ should visually appear before the base consonant
+ */
+export declare function reorderMyanmar(infos: GlyphInfo[]): void;

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

@@ -0,0 +1,80 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Syriac shaper
+ * Handles Syriac script (Estrangela, Serto, Eastern)
+ *
+ * Syriac is a right-to-left script with:
+ * - Joining behavior (like Arabic)
+ * - Vowel marks (diacritics above/below)
+ * - Multiple script styles (Estrangela, Serto, East Syriac)
+ * - Dalath/Rish distinction marks
+ */
+/**
+ * Syriac joining types
+ */
+export declare enum SyriacJoining {
+    NonJoining = 0,
+    RightJoining = 1,
+    DualJoining = 2,
+    LeftJoining = 3,
+    Transparent = 4,
+    Causing = 5
+}
+/**
+ * Syriac character categories
+ */
+export declare enum SyriacCategory {
+    Other = 0,
+    Letter = 1,
+    Diacritic = 2,
+    Punctuation = 3,
+    Digit = 4
+}
+/**
+ * Get Syriac joining type for codepoint
+ */
+export declare function getSyriacJoining(cp: number): SyriacJoining;
+/**
+ * Get Syriac category
+ */
+export declare function getSyriacCategory(cp: number): SyriacCategory;
+/**
+ * Syriac positional forms
+ */
+export declare enum SyriacForm {
+    Isolated = 0,
+    Initial = 1,
+    Medial = 2,
+    Final = 3
+}
+/**
+ * Determine Syriac positional form
+ */
+export declare function getSyriacForm(prev: SyriacJoining, current: SyriacJoining, next: SyriacJoining): SyriacForm;
+/**
+ * Syriac feature masks
+ */
+export declare const SyriacFeatureMask: {
+    readonly ccmp: 1;
+    readonly locl: 2;
+    readonly isol: 4;
+    readonly init: 8;
+    readonly medi: 16;
+    readonly fina: 32;
+    readonly rlig: 64;
+    readonly calt: 128;
+    readonly liga: 256;
+    readonly stch: 512;
+};
+/**
+ * Set up masks for Syriac shaping
+ */
+export declare function setupSyriacMasks(infos: GlyphInfo[]): void;
+/**
+ * Get default Syriac features in order
+ */
+export declare function getSyriacFeatures(): string[];
+/**
+ * Check if script uses Syriac shaper
+ */
+export declare function usesSyriac(script: string): boolean;

package/dist/shaper/complex/thai-lao.d.ts

@@ -0,0 +1,42 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Thai/Lao character categories
+ */
+export declare enum ThaiLaoCategory {
+    Other = 0,
+    Consonant = 1,
+    LeadingVowel = 2,// Vowels that appear before consonant
+    AboveVowel = 3,// Vowels above consonant
+    BelowVowel = 4,// Vowels below consonant
+    FollowingVowel = 5,// Vowels after consonant
+    Tone = 6,// Tone marks
+    NikhahitMaiEk = 7,// Special combining marks
+    SaraAm = 8,// Thai Sara Am (combines anusvara + aa)
+    Symbol = 9
+}
+/**
+ * Check if codepoint is Thai
+ */
+export declare function isThai(cp: number): boolean;
+/**
+ * Check if codepoint is Lao
+ */
+export declare function isLao(cp: number): boolean;
+/**
+ * Get Thai/Lao category for a codepoint
+ */
+export declare function getThaiLaoCategory(cp: number): ThaiLaoCategory;
+/**
+ * Set up masks for Thai/Lao shaping
+ *
+ * Thai/Lao require:
+ * 1. Reordering of pre-base vowels (they appear before consonant visually but after in Unicode)
+ * 2. Proper stacking of above/below vowels and tone marks
+ */
+export declare function setupThaiLaoMasks(infos: GlyphInfo[]): void;
+/**
+ * Reorder Thai/Lao clusters
+ * Leading vowels (Sara E, Sara Ae, Sara O, Sara Ai Mai Muan, Sara Ai Mai Malai)
+ * are stored after consonant in Unicode but displayed before
+ */
+export declare function reorderThaiLao(infos: GlyphInfo[]): void;

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

@@ -0,0 +1,57 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Tibetan shaper
+ * Handles Tibetan script complex text layout
+ *
+ * Tibetan is an Indic-derived script with:
+ * - Base consonants (Ka, Kha, Ga, etc.)
+ * - Subjoined consonants (below base)
+ * - Vowel signs (above/below)
+ * - Head letters (pre-composed stacks)
+ * - Various combining marks
+ */
+/**
+ * Tibetan character categories
+ */
+export declare enum TibetanCategory {
+    Other = 0,
+    Base = 1,// Base consonants (Ka-A)
+    Subjoined = 2,// Subjoined consonants (0F90-0FBC)
+    VowelAbove = 3,// Vowel signs above (0F71-0F7D, 0F80-0F83)
+    VowelBelow = 4,// Vowel signs below (0F71, 0F7A-0F7D)
+    ASubjoin = 5,// Subjoined A (0FB0)
+    HeadMark = 6,// Head marks (0F39)
+    Anusvara = 7,// Anusvara/Candrabindu (0F7E, 0F7F, 0F82, 0F83)
+    Halanta = 8,// Halanta (0F84)
+    Digit = 9,// Digits (0F20-0F33)
+    Symbol = 10,// Symbols and punctuation
+    ZWNJ = 11,// Zero Width Non-Joiner
+    ZWJ = 12
+}
+/**
+ * Classify Tibetan codepoint
+ */
+export declare function getTibetanCategory(cp: number): TibetanCategory;
+/**
+ * Tibetan feature masks
+ */
+export declare const TibetanFeatureMask: {
+    readonly ccmp: 1;
+    readonly locl: 2;
+    readonly abvs: 4;
+    readonly blws: 8;
+    readonly calt: 16;
+    readonly liga: 32;
+};
+/**
+ * Set up masks for Tibetan shaping
+ */
+export declare function setupTibetanMasks(infos: GlyphInfo[]): void;
+/**
+ * Get default Tibetan features in order
+ */
+export declare function getTibetanFeatures(): string[];
+/**
+ * Check if script uses Tibetan shaper
+ */
+export declare function usesTibetan(script: string): boolean;

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

@@ -0,0 +1,80 @@
+import type { GlyphInfo } from "../../types.ts";
+/**
+ * Universal Shaping Engine (USE) categories
+ * Based on Unicode USE specification
+ */
+export declare enum UseCategory {
+    O = 0,// Other
+    B = 1,// Base
+    CGJ = 2,// Combining Grapheme Joiner
+    CM = 3,// Consonant modifier
+    CS = 4,// Consonant with stacker
+    F = 5,// Final
+    FM = 6,// Final modifier
+    GB = 7,// Generic base
+    H = 8,// Halant/Virama
+    HN = 9,// Halant or Nukta
+    IND = 10,// Independent
+    J = 11,// Joiner
+    N = 12,// Nukta
+    R = 13,// Repha
+    S = 14,// Symbol
+    SB = 15,// Symbol modifier
+    SE = 16,// Syllable ending
+    SUB = 17,// Subjoined
+    VS = 18,// Variation selector
+    WJ = 19,// Word joiner
+    ZWJ = 20,// Zero Width Joiner
+    ZWNJ = 21,// Zero Width Non-Joiner
+    V = 22,// Vowel (independent)
+    VD = 23,// Vowel dependent
+    VMAbv = 24,// Vowel modifier above
+    VMBlw = 25,// Vowel modifier below
+    VMPre = 26,// Vowel modifier pre
+    VMPst = 27,// Vowel modifier post
+    VAbv = 28,// Vowel above
+    VBlw = 29,// Vowel below
+    VPre = 30,// Vowel pre
+    VPst = 31,// Vowel post
+    SMAbv = 32,// Syllable modifier above
+    SMBlw = 33,// Syllable modifier below
+    FAbv = 34,// Final above
+    FBlw = 35,// Final below
+    FPst = 36,// Final post
+    MAbv = 37,// Medial above
+    MBlw = 38,// Medial below
+    MPre = 39,// Medial pre
+    MPst = 40
+}
+/**
+ * Check if a script uses USE
+ */
+export declare function usesUSE(script: string): boolean;
+/**
+ * Get USE category for a codepoint
+ */
+export declare function getUseCategory(cp: number): UseCategory;
+/** USE feature masks */
+export declare const UseFeatureMask: {
+    readonly rphf: 1;
+    readonly pref: 2;
+    readonly blwf: 4;
+    readonly abvf: 8;
+    readonly pstf: 16;
+    readonly half: 32;
+    readonly cjct: 64;
+    readonly vatu: 128;
+    readonly pres: 256;
+    readonly abvs: 512;
+    readonly blws: 1024;
+    readonly psts: 2048;
+    readonly haln: 4096;
+};
+/**
+ * Set up masks for USE shaping
+ */
+export declare function setupUseMasks(infos: GlyphInfo[]): void;
+/**
+ * Reorder USE syllables (pre-base vowels, reph)
+ */
+export declare function reorderUSE(infos: GlyphInfo[]): void;

package/dist/shaper/fallback.d.ts

@@ -0,0 +1,16 @@
+import type { Font } from "../font/font.ts";
+import type { GlyphInfo, GlyphPosition } from "../types.ts";
+/**
+ * Fallback mark positioning when GPOS is not available
+ * Uses combining class information to position marks
+ */
+export declare function applyFallbackMarkPositioning(font: Font, infos: GlyphInfo[], positions: GlyphPosition[]): void;
+/**
+ * Apply fallback kerning using kern table
+ */
+export declare function applyFallbackKerning(font: Font, infos: GlyphInfo[], positions: GlyphPosition[]): void;
+/**
+ * Recategorize combining marks for proper processing
+ * Some scripts need marks to be processed in specific order
+ */
+export declare function recategorizeCombiningMarks(_font: Font, infos: GlyphInfo[]): void;