text-shaper 0.0.1

package/dist/unicode/bidi/brackets.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Bidi bracket pair functions
+ * Port of bidi-js brackets.js
+ */
+export declare function openingToClosingBracket(char: string): string | null;
+export declare function closingToOpeningBracket(char: string): string | null;
+export declare function getCanonicalBracket(char: string): string | null;

package/dist/unicode/bidi/brackets.data.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    pairs: string;
+    canonical: string;
+};
+export default _default;

package/dist/unicode/bidi/char-types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Bidi character type detection
+ * Port of bidi-js charTypes.js
+ */
+export declare const TYPES: Record<string, number>;
+export declare const TYPES_TO_NAMES: Record<number, string>;
+export declare const ISOLATE_INIT_TYPES: number;
+export declare const STRONG_TYPES: number;
+export declare const NEUTRAL_ISOLATE_TYPES: number;
+export declare const BN_LIKE_TYPES: number;
+export declare const TRAILING_TYPES: number;
+/**
+ * Get the bidi character type for a character
+ */
+export declare function getBidiCharType(char: string): number;
+/**
+ * Get the name of a bidi character type
+ */
+export declare function getBidiCharTypeName(char: string): string;

package/dist/unicode/bidi/char-types.data.d.ts

@@ -0,0 +1,25 @@
+declare const _default: {
+    R: string;
+    EN: string;
+    ES: string;
+    ET: string;
+    AN: string;
+    CS: string;
+    B: string;
+    S: string;
+    WS: string;
+    ON: string;
+    BN: string;
+    NSM: string;
+    AL: string;
+    LRO: string;
+    RLO: string;
+    LRE: string;
+    RLE: string;
+    PDF: string;
+    LRI: string;
+    RLI: string;
+    FSI: string;
+    PDI: string;
+};
+export default _default;

package/dist/unicode/bidi/embedding-levels.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bidi embedding levels calculation (UAX #9)
+ * Port of bidi-js embeddingLevels.js
+ */
+export interface EmbeddingLevelsResult {
+    paragraphs: Array<{
+        start: number;
+        end: number;
+        level: number;
+    }>;
+    levels: Uint8Array;
+}
+/**
+ * This function applies the Bidirectional Algorithm to a string, returning the resolved embedding levels
+ * in a single Uint8Array plus a list of objects holding each paragraph's start and end indices and resolved
+ * base embedding level.
+ */
+export declare function getEmbeddingLevels(string: string, baseDirection?: "ltr" | "rtl" | "auto"): EmbeddingLevelsResult;

package/dist/unicode/bidi/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bidi algorithm implementation
+ * Port of bidi-js
+ */
+export { closingToOpeningBracket, getCanonicalBracket, openingToClosingBracket, } from "./brackets.ts";
+export { BN_LIKE_TYPES, getBidiCharType, getBidiCharTypeName, ISOLATE_INIT_TYPES, NEUTRAL_ISOLATE_TYPES, STRONG_TYPES, TRAILING_TYPES, TYPES, TYPES_TO_NAMES, } from "./char-types.ts";
+export { type EmbeddingLevelsResult, getEmbeddingLevels, } from "./embedding-levels.ts";
+export { getMirroredCharacter, getMirroredCharactersMap, } from "./mirroring.ts";
+export { getReorderedIndices, getReorderedString, getReorderSegments, } from "./reordering.ts";

package/dist/unicode/bidi/mirroring.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bidi character mirroring
+ * Port of bidi-js mirroring.js
+ */
+export declare function getMirroredCharacter(char: string): string | null;
+/**
+ * Given a string and its resolved embedding levels, build a map of indices to replacement chars
+ * for any characters in right-to-left segments that have defined mirrored characters.
+ */
+export declare function getMirroredCharactersMap(string: string, embeddingLevels: Uint8Array, start?: number, end?: number): Map<number, string>;

package/dist/unicode/bidi/mirroring.data.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "14>1,j>2,t>2,u>2,1a>g,2v3>1,1>1,1ge>1,1wd>1,b>1,1j>1,f>1,ai>3,-2>3,+1,8>1k0,-1jq>1y7,-1y6>1hf,-1he>1h6,-1h5>1ha,-1h8>1qi,-1pu>1,6>3u,-3s>7,6>1,1>1,f>1,1>1,+2,3>1,1>1,+13,4>1,1>1,6>1eo,-1ee>1,3>1mg,-1me>1mk,-1mj>1mi,-1mg>1mi,-1md>1,1>1,+2,1>10k,-103>1,1>1,4>1,5>1,1>1,+10,3>1,1>8,-7>8,+1,-6>7,+1,a>1,1>1,u>1,u6>1,1>1,+5,26>1,1>1,2>1,2>2,8>1,7>1,4>1,1>1,+5,b8>1,1>1,+3,1>3,-2>1,2>1,1>1,+2,c>1,3>1,1>1,+2,h>1,3>1,a>1,1>1,2>1,3>1,1>1,d>1,f>1,3>1,1a>1,1>1,6>1,7>1,13>1,k>1,1>1,+19,4>1,1>1,+2,2>1,1>1,+18,m>1,a>1,1>1,lk>1,1>1,4>1,2>1,f>1,3>1,1>1,+3,db>1,1>1,+3,3>1,1>1,+2,14qm>1,1>1,+1,6>1,4j>1,j>2,t>2,u>2,2>1,+1";
+export default _default;

package/dist/unicode/bidi/parse-character-map.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parses an string that holds encoded codepoint mappings, e.g. for bracket pairs or
+ * mirroring characters. Returns an object holding the `map`, and optionally a `reverseMap`.
+ */
+export declare function parseCharacterMap(encodedString: string, includeReverse: boolean): {
+    map: Map<string, string>;
+    reverseMap: Map<string, string> | null;
+};

package/dist/unicode/bidi/reordering.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bidi reordering
+ * Port of bidi-js reordering.js
+ */
+import type { EmbeddingLevelsResult } from "./embedding-levels.ts";
+/**
+ * Given a start and end denoting a single line within a string, and a set of precalculated
+ * bidi embedding levels, produce a list of segments whose ordering should be flipped, in sequence.
+ */
+export declare function getReorderSegments(string: string, embeddingLevelsResult: EmbeddingLevelsResult, start?: number, end?: number): Array<[number, number]>;
+/**
+ * Get the reordered string with bidi segments reversed
+ */
+export declare function getReorderedString(string: string, embedLevelsResult: EmbeddingLevelsResult, start?: number, end?: number): string;
+/**
+ * Get an array with character indices in their new bidi order
+ */
+export declare function getReorderedIndices(string: string, embedLevelsResult: EmbeddingLevelsResult, start?: number, end?: number): number[];

package/dist/unicode/bidi.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Bidirectional text processing (UAX #9)
+ */
+import type { GlyphInfo } from "../types.ts";
+import { Direction } from "../types.ts";
+/**
+ * Result of BiDi processing
+ */
+export interface BidiResult {
+    /** Embedding levels per character */
+    levels: Uint8Array;
+    /** Paragraph information */
+    paragraphs: BidiParagraph[];
+}
+/**
+ * Paragraph info from BiDi algorithm
+ */
+export interface BidiParagraph {
+    start: number;
+    end: number;
+    level: number;
+}
+/**
+ * Get embedding levels for a string
+ */
+export declare function getEmbeddings(text: string, baseDirection?: Direction): BidiResult;
+/**
+ * Get reordered indices for visual display
+ */
+export declare function getVisualOrder(text: string, result: BidiResult, start?: number, end?: number): number[];
+/**
+ * Apply BiDi reordering to glyph infos
+ */
+export declare function reorderGlyphs(infos: GlyphInfo[], result: BidiResult): GlyphInfo[];
+/**
+ * Get mirrored character for RTL contexts
+ */
+export declare function getMirror(codepoint: number): number;
+/**
+ * Apply character mirroring for RTL runs
+ */
+export declare function applyMirroring(infos: GlyphInfo[], levels: Uint8Array): void;
+/**
+ * BiDi character type constants
+ */
+export declare const BidiType: {
+    readonly L: 1;
+    readonly R: 2;
+    readonly EN: 4;
+    readonly ES: 8;
+    readonly ET: 16;
+    readonly AN: 32;
+    readonly CS: 64;
+    readonly B: 128;
+    readonly S: 256;
+    readonly WS: 512;
+    readonly ON: 1024;
+    readonly BN: 2048;
+    readonly NSM: 4096;
+    readonly AL: 8192;
+    readonly LRO: 16384;
+    readonly RLO: 32768;
+    readonly LRE: 65536;
+    readonly RLE: 131072;
+    readonly PDF: 262144;
+    readonly LRI: 524288;
+    readonly RLI: 1048576;
+    readonly FSI: 2097152;
+    readonly PDI: 4194304;
+};
+/**
+ * Get BiDi character type for a character
+ */
+export declare function getCharType(char: string): number;
+/**
+ * Check if a character is strongly RTL
+ */
+export declare function isRTL(codepoint: number): boolean;
+/**
+ * Check if a character is strongly LTR
+ */
+export declare function isLTR(codepoint: number): boolean;
+/**
+ * Detect base direction from text content
+ */
+export declare function detectDirection(text: string): Direction;
+/**
+ * Full BiDi processing for shaping
+ */
+export declare function processBidi(infos: GlyphInfo[], baseDirection?: Direction): {
+    infos: GlyphInfo[];
+    levels: Uint8Array;
+};

package/dist/unicode/line-break.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Unicode Line Breaking Algorithm (UAX #14)
+ * Determines line break opportunities in text
+ */
+import type { GlyphInfo } from "../types.ts";
+/**
+ * Line break class from UAX #14
+ */
+export declare enum LineBreakClass {
+    BK = 0,// Mandatory Break
+    CR = 1,// Carriage Return
+    LF = 2,// Line Feed
+    CM = 3,// Combining Mark
+    NL = 4,// Next Line
+    SG = 5,// Surrogate (not used)
+    WJ = 6,// Word Joiner
+    ZW = 7,// Zero Width Space
+    GL = 8,// Non-breaking ("Glue")
+    SP = 9,// Space
+    ZWJ = 10,// Zero Width Joiner
+    B2 = 11,// Break Opportunity Before and After
+    BA = 12,// Break After
+    BB = 13,// Break Before
+    HY = 14,// Hyphen
+    CB = 15,// Contingent Break Opportunity
+    CL = 16,// Close Punctuation
+    CP = 17,// Close Parenthesis
+    EX = 18,// Exclamation/Interrogation
+    IN = 19,// Inseparable
+    NS = 20,// Nonstarter
+    OP = 21,// Open Punctuation
+    QU = 22,// Quotation
+    IS = 23,// Infix Numeric Separator
+    NU = 24,// Numeric
+    PO = 25,// Postfix Numeric
+    PR = 26,// Prefix Numeric
+    SY = 27,// Symbols Allowing Break After
+    AI = 28,// Ambiguous (Alphabetic or Ideographic)
+    AL = 29,// Alphabetic
+    CJ = 30,// Conditional Japanese Starter
+    EB = 31,// Emoji Base
+    EM = 32,// Emoji Modifier
+    H2 = 33,// Hangul LV Syllable
+    H3 = 34,// Hangul LVT Syllable
+    HL = 35,// Hebrew Letter
+    ID = 36,// Ideographic
+    JL = 37,// Hangul L Jamo
+    JV = 38,// Hangul V Jamo
+    JT = 39,// Hangul T Jamo
+    RI = 40,// Regional Indicator
+    SA = 41,// Complex Context Dependent (South East Asian)
+    XX = 42
+}
+/**
+ * Break action
+ */
+export declare enum BreakAction {
+    Direct = 0,// Direct break opportunity (after space)
+    Indirect = 1,// Indirect break (only if spaces intervene)
+    CombiningIndirect = 2,// Indirect break for combining marks
+    CombiningProhibited = 3,// Prohibited break for combining marks
+    Prohibited = 4,// No break allowed
+    Explicit = 5
+}
+/**
+ * Line break opportunity
+ */
+export declare enum BreakOpportunity {
+    NoBreak = 0,
+    Optional = 1,
+    Mandatory = 2
+}
+/**
+ * Get line break class for a codepoint
+ */
+export declare function getLineBreakClass(cp: number): LineBreakClass;
+/**
+ * Result of line break analysis
+ */
+export interface LineBreakAnalysis {
+    /** Break opportunities (one per character boundary) */
+    breaks: BreakOpportunity[];
+    /** Line break classes for each character */
+    classes: LineBreakClass[];
+}
+/**
+ * Analyze line break opportunities in text
+ */
+export declare function analyzeLineBreaks(text: string): LineBreakAnalysis;
+/**
+ * Analyze line break opportunities from codepoints
+ */
+export declare function analyzeLineBreaksFromCodepoints(codepoints: number[]): LineBreakAnalysis;
+/**
+ * Analyze line breaks for glyph infos
+ */
+export declare function analyzeLineBreaksForGlyphs(infos: GlyphInfo[]): LineBreakAnalysis;
+/**
+ * Find next line break opportunity
+ */
+export declare function findNextBreak(analysis: LineBreakAnalysis, startIndex: number): number;
+/**
+ * Check if break is allowed at position
+ */
+export declare function canBreakAt(analysis: LineBreakAnalysis, index: number): boolean;
+/**
+ * Check if break is mandatory at position
+ */
+export declare function mustBreakAt(analysis: LineBreakAnalysis, index: number): boolean;
+/**
+ * Get all break opportunities
+ */
+export declare function getAllBreakOpportunities(analysis: LineBreakAnalysis): number[];

package/dist/unicode/normalize.d.ts

@@ -0,0 +1,36 @@
+import type { GlyphInfo } from "../types.ts";
+/**
+ * Normalization mode for shaping
+ */
+export declare enum NormalizationMode {
+    /** No normalization */
+    None = 0,
+    /** Decompose (NFD-like) */
+    Decompose = 1,
+    /** Compose (NFC-like) */
+    Compose = 2,
+    /** Auto-detect based on script */
+    Auto = 3
+}
+/**
+ * Canonical Combining Class (ccc) for combining marks
+ * Based on Unicode 15.0
+ */
+export declare function getCombiningClass(cp: number): number;
+/**
+ * Reorder combining marks according to canonical combining class
+ */
+export declare function reorderMarks(infos: GlyphInfo[]): void;
+/**
+ * Decompose a codepoint if it has a canonical decomposition
+ */
+export declare function decompose(cp: number): number[] | null;
+/**
+ * Try to compose a base character with a combining mark
+ * Returns the composed character or null if no composition exists
+ */
+export declare function tryCompose(base: number, combining: number): number | null;
+/**
+ * Apply normalization to glyph infos
+ */
+export declare function normalize(infos: GlyphInfo[], mode: NormalizationMode): GlyphInfo[];

package/dist/unicode/script.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Unicode Script Detection
+ * Detects the script of text based on codepoints
+ */
+/**
+ * Unicode script values (ISO 15924)
+ */
+export declare enum Script {
+    Common = "Zyyy",
+    Inherited = "Zinh",
+    Unknown = "Zzzz",
+    Latin = "Latn",
+    Greek = "Grek",
+    Cyrillic = "Cyrl",
+    Armenian = "Armn",
+    Hebrew = "Hebr",
+    Arabic = "Arab",
+    Syriac = "Syrc",
+    Thaana = "Thaa",
+    Devanagari = "Deva",
+    Bengali = "Beng",
+    Gurmukhi = "Guru",
+    Gujarati = "Gujr",
+    Oriya = "Orya",
+    Tamil = "Taml",
+    Telugu = "Telu",
+    Kannada = "Knda",
+    Malayalam = "Mlym",
+    Sinhala = "Sinh",
+    Thai = "Thai",
+    Lao = "Laoo",
+    Tibetan = "Tibt",
+    Myanmar = "Mymr",
+    Georgian = "Geor",
+    Hangul = "Hang",
+    Ethiopic = "Ethi",
+    Cherokee = "Cher",
+    CanadianAboriginal = "Cans",
+    Ogham = "Ogam",
+    Runic = "Runr",
+    Khmer = "Khmr",
+    Mongolian = "Mong",
+    Hiragana = "Hira",
+    Katakana = "Kana",
+    Bopomofo = "Bopo",
+    Han = "Hani",
+    Yi = "Yiii",
+    OldItalic = "Ital",
+    Gothic = "Goth",
+    Deseret = "Dsrt",
+    Tagalog = "Tglg",
+    Hanunoo = "Hano",
+    Buhid = "Buhd",
+    Tagbanwa = "Tagb",
+    Limbu = "Limb",
+    TaiLe = "Tale",
+    LinearB = "Linb",
+    Ugaritic = "Ugar",
+    Shavian = "Shaw",
+    Osmanya = "Osma",
+    Cypriot = "Cprt",
+    Braille = "Brai",
+    Buginese = "Bugi",
+    Coptic = "Copt",
+    NewTaiLue = "Talu",
+    Glagolitic = "Glag",
+    Tifinagh = "Tfng",
+    SylotiNagri = "Sylo",
+    OldPersian = "Xpeo",
+    Kharoshthi = "Khar",
+    Balinese = "Bali",
+    Cuneiform = "Xsux",
+    Phoenician = "Phnx",
+    PhagsPa = "Phag",
+    Nko = "Nkoo",
+    Sundanese = "Sund",
+    Lepcha = "Lepc",
+    OlChiki = "Olck",
+    Vai = "Vaii",
+    Saurashtra = "Saur",
+    KayahLi = "Kali",
+    Rejang = "Rjng",
+    Lycian = "Lyci",
+    Carian = "Cari",
+    Lydian = "Lydi",
+    Cham = "Cham",
+    TaiTham = "Lana",
+    TaiViet = "Tavt",
+    Avestan = "Avst",
+    EgyptianHieroglyphs = "Egyp",
+    Samaritan = "Samr",
+    Lisu = "Lisu",
+    Bamum = "Bamu",
+    Javanese = "Java",
+    MeeteiMayek = "Mtei",
+    ImperialAramaic = "Armi",
+    OldSouthArabian = "Sarb",
+    InscriptionalParthian = "Prti",
+    InscriptionalPahlavi = "Phli",
+    OldTurkic = "Orkh",
+    Kaithi = "Kthi",
+    Batak = "Batk",
+    Brahmi = "Brah",
+    Mandaic = "Mand",
+    Chakma = "Cakm",
+    MeroiticCursive = "Merc",
+    MeroiticHieroglyphs = "Mero",
+    Miao = "Plrd",
+    Sharada = "Shrd",
+    SoraSompeng = "Sora",
+    Takri = "Takr",
+    CaucasianAlbanian = "Aghb",
+    BassaVah = "Bass",
+    Duployan = "Dupl",
+    Elbasan = "Elba",
+    Grantha = "Gran",
+    PahawhHmong = "Hmng",
+    Khojki = "Khoj",
+    LinearA = "Lina",
+    Mahajani = "Mahj",
+    Manichaean = "Mani",
+    MendeKikakui = "Mend",
+    Modi = "Modi",
+    Mro = "Mroo",
+    OldNorthArabian = "Narb",
+    Nabataean = "Nbat",
+    Palmyrene = "Palm",
+    PauCinHau = "Pauc",
+    OldPermic = "Perm",
+    PsalterPahlavi = "Phlp",
+    Siddham = "Sidd",
+    Khudawadi = "Sind",
+    Tirhuta = "Tirh",
+    WarangCiti = "Wara",
+    Ahom = "Ahom",
+    AnatolianHieroglyphs = "Hluw",
+    Hatran = "Hatr",
+    Multani = "Mult",
+    OldHungarian = "Hung",
+    SignWriting = "Sgnw",
+    Adlam = "Adlm",
+    Bhaiksuki = "Bhks",
+    Marchen = "Marc",
+    Newa = "Newa",
+    Osage = "Osge",
+    Tangut = "Tang",
+    MasaramGondi = "Gonm",
+    Nushu = "Nshu",
+    Soyombo = "Soyo",
+    ZanabazarSquare = "Zanb",
+    Dogra = "Dogr",
+    GunjalaGondi = "Gong",
+    Makasar = "Maka",
+    Medefaidrin = "Medf",
+    HanifiRohingya = "Rohg",
+    Sogdian = "Sogd",
+    OldSogdian = "Sogo",
+    Elymaic = "Elym",
+    Nandinagari = "Nand",
+    NyiakengPuachueHmong = "Hmnp",
+    Wancho = "Wcho",
+    Yezidi = "Yezi",
+    Chorasmian = "Chrs",
+    DivesAkuru = "Diak",
+    KhitanSmallScript = "Kits",
+    Vithkuqi = "Vith",
+    OldUyghur = "Ougr",
+    Cypro_Minoan = "Cpmn",
+    Tangsa = "Tnsa",
+    Toto = "Toto",
+    Kawi = "Kawi",
+    NagMundari = "Nagm"
+}
+/**
+ * Get script for a codepoint using binary search
+ */
+export declare function getScript(cp: number): Script;
+/**
+ * Get script for a string (returns the dominant non-Common/Inherited script)
+ */
+export declare function detectScript(text: string): Script;
+/**
+ * Get all scripts present in text
+ */
+export declare function getScripts(text: string): Script[];
+/**
+ * Check if text contains only characters from a specific script
+ * (Common and Inherited are allowed)
+ */
+export declare function isScript(text: string, script: Script): boolean;
+/**
+ * Script run - a contiguous sequence of characters with the same script
+ */
+export interface ScriptRun {
+    script: Script;
+    start: number;
+    end: number;
+    text: string;
+}
+/**
+ * Split text into script runs
+ */
+export declare function getScriptRuns(text: string): ScriptRun[];
+/**
+ * Get OpenType script tag for a Unicode script
+ */
+export declare function getScriptTag(script: Script): string;
+/**
+ * Check if a script requires complex shaping
+ */
+export declare function isComplexScript(script: Script): boolean;
+/**
+ * Get script direction (LTR or RTL)
+ */
+export declare function getScriptDirection(script: Script): "ltr" | "rtl";