lipilekhika 0.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,615 @@
+declare type acronym_type = (typeof ACRONYMS)[number];
+
+declare const ACRONYMS: readonly ["dev", "te", "tel", "tam", "tam-ex", "ben", "be", "ka", "kan", "gu", "guj", "mal", "or", "od", "oriya", "si", "sinh", "sin", "en", "rom", "gur", "as", "sa", "san", "hin", "hi", "mar", "ne", "nep", "pun"];
+
+export declare const ALL_LANG_SCRIPT_LIST: script_and_lang_list_type[];
+
+declare type CommonListTypeAttributes = {
+    text: string;
+    /** In the post processing step the keys for which it is not mapped shall be left empty.
+     * It can map to multiple krama keys
+     * Each key should have at least one key krama. Scan for this too in the compilation step.
+     */
+    text_krama: KramaKeysExtendedType[];
+    /** This contains duplicates of the key, for eg:- some nuqta symbols and mAtrAs.
+     * In the processing/compiling step it should be verified as a key of this list, display and throw the error
+     */
+    duplicates?: string[];
+    /** In case if no entry is found for the key in krama even after de-duplication resolution
+     * then fallback array will be used. Like for malayalam .100 it can be .1+.0+.0
+     * If the fallback array is not provided, then the key_krama should be empty and will also be ignored
+     */
+    fallback?: KramaKeysExtendedType[];
+    /** Prevent Auto Matching
+     * Useful for Cases where we dont want to use the text referenced in the key to be used for transliteration from that script to another script
+     * Like when changing from Tamil to Devanagari , kirupA it should be kirupA and not kRpA.
+     * So we can prevent the list item "text": iru, krama R) from being used to reduce itself from that form during transliteration
+     */
+    prevent_auto_matching?: boolean;
+};
+
+declare type CommonScriptData = {
+    /** Stores the key of the current script along with the reference to the index in `list` for info about the key
+     * `string` is the actual key, number(nullable) is the index of the key in the compiled `list`
+     */
+    krama_text_arr: [krama_key: string, list_arr_ref: number | null][];
+    /** To be used for binary search on the `krama_key_map` */
+    krama_text_arr_index: number[];
+    /** `string` used for search. Usable for Duplication Remova, Fallback Behaviour
+     * and for `other` scripts type. Like Normal
+     * This will be a sorted array, so binary search can be directly used in it */
+    text_to_krama_map: [
+    text: string,
+        {
+        next?: string[] | null;
+        /** Multiple krama index references are useful to some intermediate states. For eg:- Normal A -> A, AU -> A, U and AUM -> AUM
+         * This will be useful only when there are more than two transition states. As double transition state outputs dont need multiple krama references.
+         * For eg -> The Bengali kz (actually k + nukta) will be a two step mapping, k -> k (next :nukta,... ) and k+nukta->kz krama reference in the main transliteration array
+         * There is also an option to prevent this auto behaviour. Like for tamil we dont iru in tamil to map to R in krama key so we manually disable it
+         * This can also be used to define the fallback combination. The array allows a multiple krama keys to be combined together to form a fallback
+         * Like .100 = .1+.0+.0
+         */
+        krama?: number[] | null;
+        /** This will be useful to get info related to the fallback if they happen to be a svara or a vyanjana
+         * eg. The Malayalam .n,.N, etc
+         */
+        fallback_list_ref?: number | null;
+    }
+    ][];
+    list: {
+        /** Indexes of the the corresponding entries in `krama_key_map` corresponding to the `key_krama` */
+        krama_ref: number[];
+        type: NonNullable<NonNullable<InputOtherScriptType['list']>[number]['type']>;
+    }[];
+};
+
+declare type CustomOptionList = keyof typeof _default;
+
+declare type CustomOptionType = {
+    [key in CustomOptionList]?: boolean;
+};
+
+declare const _default: {
+    "all_to_normal:replace_pancham_varga_varna_with_n": {
+        "from_script_type": "all",
+        "to_script_name": [
+        "Normal"
+        ],
+        "check_in": "output",
+        "rules": [
+            {
+            "type": "replace_prev_krama_keys",
+            "check_in": "output",
+            "prev": [
+            60
+            ],
+            "following": [
+            52,
+            53,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59
+            ],
+            "replace_with": [
+            72
+            ]
+        },
+            {
+            "type": "replace_prev_krama_keys",
+            "check_in": "output",
+            "prev": [
+            67
+            ],
+            "following": [
+            61,
+            62,
+            63,
+            64,
+            65,
+            66
+            ],
+            "replace_with": [
+            72
+            ]
+        }
+        ]
+    },
+    "brahmic_to_brahmic:replace_pancham_varga_varna_with_anuvsvAra": {
+        "from_script_type": "brahmic",
+        "to_script_type": "brahmic",
+        "check_in": "input",
+        "rules": [
+            {
+            "type": "replace_prev_krama_keys",
+            "check_in": "input",
+            "prev": [
+            60,
+            49
+            ],
+            "following": [
+            52,
+            53,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59
+            ],
+            "replace_with": [
+            45
+            ]
+        },
+            {
+            "type": "replace_prev_krama_keys",
+            "check_in": "input",
+            "prev": [
+            67,
+            49
+            ],
+            "following": [
+            61,
+            62,
+            63,
+            64,
+            65,
+            66
+            ],
+            "replace_with": [
+            45
+            ]
+        },
+            {
+            "type": "replace_prev_krama_keys",
+            "check_in": "input",
+            "prev": [
+            81,
+            49
+            ],
+            "following": [
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80
+            ],
+            "replace_with": [
+            45
+            ]
+        },
+            {
+            "type": "replace_prev_krama_keys",
+            "check_in": "input",
+            "prev": [
+            72,
+            49
+            ],
+            "following": [
+            68,
+            69,
+            70,
+            71
+            ],
+            "replace_with": [
+            45
+            ]
+        },
+            {
+            "type": "replace_prev_krama_keys",
+            "check_in": "input",
+            "prev": [
+            88,
+            49
+            ],
+            "following": [
+            82,
+            83,
+            85,
+            86,
+            87
+            ],
+            "replace_with": [
+            45
+            ]
+        }
+        ]
+    },
+    "all_to_sinhala:use_conjuct_enabling_halant": {
+        "from_script_type": "all",
+        "to_script_name": [
+        "Sinhala"
+        ],
+        "check_in": "output",
+        "rules": [
+            {
+            "type": "direct_replace",
+            "check_in": "output",
+            "to_replace": [
+            [
+            49
+            ]
+            ],
+            "replace_with": [
+            49,
+            117
+            ]
+        }
+        ]
+    },
+    "all_to_normal:remove_virAma_and_double_virAma": {
+        "from_script_type": "all",
+        "to_script_name": [
+        "Normal",
+        "Romanized"
+        ],
+        "check_in": "output",
+        "rules": [
+            {
+            "type": "direct_replace",
+            "check_in": "output",
+            "to_replace": [
+            [
+            116
+            ],
+            [
+            115
+            ]
+            ],
+            "replace_with": [
+            -1
+            ]
+        }
+        ]
+    },
+    "all_to_normal:replace_avagraha_with_a": {
+        "from_script_type": "all",
+        "to_script_name": [
+        "Normal",
+        "Romanized"
+        ],
+        "check_in": "output",
+        "rules": [
+            {
+            "type": "direct_replace",
+            "check_in": "output",
+            "to_replace": [
+            [
+            48
+            ]
+            ],
+            "replace_with": [
+            1
+            ]
+        }
+        ]
+    }
+};
+
+/**
+ * This returns the list of all supported custom options for
+ * transliterations for the provided script pair
+ * @param from_script_name - The script/language to transliterate from
+ * @param to_script_name - The script/language to transliterate to
+ * @returns The list of all supported custom options for the provided script pair
+ */
+export declare function getAllOptions(from_script_name: ScriptLangType, to_script_name: ScriptLangType): Promise<("all_to_normal:replace_pancham_varga_varna_with_n" | "brahmic_to_brahmic:replace_pancham_varga_varna_with_anuvsvAra" | "all_to_sinhala:use_conjuct_enabling_halant" | "all_to_normal:remove_virAma_and_double_virAma" | "all_to_normal:replace_avagraha_with_a")[]>;
+
+declare type InputBrahmicScriptType = {
+    script_name: script_list_type;
+    script_id: number;
+    script_type: 'brahmic';
+    /**
+     * An attribute for some ancient scripts which use 4 byte utf-8 representation.
+     * Instead of the usual 3 byte for most modern indian scripts.
+     * Examples(non-bmp scripts): Brahmi, Grantha, Siddham, Sharada, Modi, etc.
+     *
+     * BMP (Basic Multilingual Plane)
+     */
+    non_bmp_script?: boolean;
+    /**
+     * A sorted range array. Used to check if the incomming character has to be processed or can be ignored.
+     * Main Ranges will be specified manually (Like for a Brahmic Script). And Ranges for Additional charcters used shall be added manually
+     *
+     * This will help us more strictly specify what to process and what not to.
+     * In future this will be a mandatory field and ?
+     */
+    ranges?: [[number, number][]];
+    halant: string;
+    nuqta?: string;
+    /**
+     * Schwa deletion indicator for the script(or rather language in most cases).
+     * This will be used for live typing and not for conversion.
+     * It can be overriden later on provided as a argument in the typing tool
+     */
+    schwa_property: boolean;
+    /**
+     * This has a lower precedence than the auto generated/compiled krama key map from the `list` items. So it will be overwritten by them.
+     * Moreover the keys here will not be checked to exist in `list`. This allows direct keymaps and can be useful for scripts like Normal, Romanized
+     * Intermediate steps will be auto generated. Eg. for Normal ख : kh will add both k (next h) and kh in the
+     */
+    manual_krama_text_map?: {
+        [key in KramaKeysExtendedType]?: string;
+    };
+    /** One important need of this list is to just contain information about the keys.
+     * The keys for which it does not contain information can be considered as type `anya`.
+     * So not all keys need to be present in this list.
+     */
+    list: (CommonListTypeAttributes & ({
+        type: 'svara';
+        mAtrA: string;
+        mAtrA_text_krama: KramaKeysExtendedType[];
+        mAtrA_duplicates?: string[];
+        mAtrA_fallback?: KramaKeysExtendedType[];
+    } | {
+        type: 'vyanjana' | 'anya';
+    }))[];
+};
+
+declare type InputOtherScriptType = {
+    script_name: script_list_type;
+    script_id: number;
+    script_type: 'other';
+    /** Schwa deletion character, usually `a` */
+    schwa_character: string;
+    manual_krama_text_map: {
+        [key in KramaKeysExtendedType]?: string;
+    };
+    /** This might not be needed here usually as most of the work would be done using the `manual_krama_text_map` */
+    list?: (CommonListTypeAttributes & {
+        /** `type` is kind of redundant here as other scripts don't have a concept of svara and vyanjana */
+        type?: 'anya';
+    })[];
+};
+
+declare const KramaKeysArray: (keyof typeof KramaKeysMap)[];
+
+/** This type will be used as a convinient method to dscribe the krama key which we want to map to
+ * This shall be ultimately converted to KramaKeysType
+ */
+declare type KramaKeysExtendedType = KramaKeysType | KramaKeysLabelType;
+
+declare type KramaKeysLabelType = (typeof KramaKeysMap)[KramaKeysType];
+
+/**
+ * These Krama keys are written in an order where the keys which comes first shall take precedence if in the krama_text_map two have the same key
+ * then the one that comes first shall be chosen
+ * For eg. kau (from Bengali)
+ * the "au" can land both on au and auU because of tne nature of the binary search algorithm
+ * so to componsate that we chose the first one in case of multiple possible mappings
+ *
+ * So Be careful with similar mAtrAs, different forms of the same vyanajana (like with nuqta and other forms)
+ */
+declare const KramaKeysMap: {
+    readonly ॐ: "AUM";
+    readonly अ: "a-svara";
+    readonly '': "a-mAtrA";
+    readonly ॳ: "a1-svara";
+    readonly '\u093A': "a1-mAtrA";
+    readonly आ: "A-svara";
+    readonly '\u093E': "A-mAtrA";
+    readonly ॴ: "A1-svara";
+    readonly '\u093B': "A1-mAtrA";
+    readonly इ: "i-svara";
+    readonly '\u093F': "i-mAtrA";
+    readonly ई: "I-svara";
+    readonly '\u0940': "I-mAtrA";
+    readonly उ: "u-svara";
+    readonly '\u0941': "u-mAtrA";
+    readonly ॶ: "u1-svara";
+    readonly '\u0956': "u1-mAtrA";
+    readonly ऊ: "U-svara";
+    readonly '\u0942': "U-mAtrA";
+    readonly ॷ: "U1-svara";
+    readonly '\u0957': "U1-mAtrA";
+    readonly ए: "E-svara";
+    readonly '\u0947': "E-mAtrA";
+    readonly ऎ: "e-svara";
+    readonly '\u0946': "e-mAtrA";
+    readonly ऐ: "ai-svara";
+    readonly '\u0948': "ai-mAtrA";
+    readonly ऍ: "aiI-svara";
+    readonly '\u0945': "aiI-mAtrA";
+    readonly ओ: "O-svara";
+    readonly '\u094B': "O-mAtrA";
+    readonly ऒ: "o-svara";
+    readonly '\u094A': "o-mAtrA";
+    readonly औ: "au-svara";
+    readonly '\u094C': "au-mAtrA";
+    readonly ऑ: "auU-svara";
+    readonly '\u0949': "auU-mAtrA";
+    readonly ऋ: "R-svara";
+    readonly '\u0943': "R-mAtrA";
+    readonly ॠ: "RR-svara";
+    readonly '\u0944': "RR-mAtrA";
+    readonly ऌ: "LR-svara";
+    readonly '\u0962': "LR-mAtrA";
+    readonly ॡ: "LRR-svara";
+    readonly '\u0963': "LRR-mAtrA";
+    readonly '\u0902': "anusvAra";
+    readonly '\u0901': "anunAnAsika";
+    readonly '\u0903': "visarga";
+    readonly ऽ: "avagraha";
+    readonly '\u094D': "halant";
+    readonly '\u093C': "nuqta";
+    readonly '\u0970': "saMkShepachihna";
+    readonly क: "k";
+    readonly क़: "kz";
+    readonly ख: "kh";
+    readonly ख़: "khz";
+    readonly ग: "g";
+    readonly ग़: "gz";
+    readonly ॻ: "g1";
+    readonly घ: "gh";
+    readonly ङ: "G";
+    readonly च: "C";
+    readonly छ: "Ch";
+    readonly ज: "j";
+    readonly ज़: "jz";
+    readonly ॼ: "j1";
+    readonly झ: "jh";
+    readonly ञ: "J";
+    readonly त: "t";
+    readonly थ: "th";
+    readonly द: "d";
+    readonly ध: "dh";
+    readonly न: "n";
+    readonly ऩ: "nz";
+    readonly ट: "T";
+    readonly ठ: "Th";
+    readonly ड: "D";
+    readonly ड़: "Dz";
+    readonly ॾ: "D1";
+    readonly ढ: "Dh";
+    readonly ढ़: "Dhz";
+    readonly ण: "N";
+    readonly प: "p";
+    readonly फ: "ph";
+    readonly फ़: "phz";
+    readonly ब: "b";
+    readonly ॿ: "b1";
+    readonly भ: "bh";
+    readonly म: "m";
+    readonly य: "y";
+    readonly य़: "yz";
+    readonly व: "v";
+    readonly र: "r";
+    readonly ऱ: "rz";
+    readonly ल: "l";
+    readonly ळ: "L";
+    readonly ऴ: "Lz";
+    readonly ह: "h";
+    readonly स: "s";
+    readonly श: "sh";
+    readonly ष: "Sh";
+    readonly '\u0952': "anudAttA";
+    readonly '\u0951': "udAtta-1";
+    readonly '\u1CDA': "udAtta-2";
+    readonly '\u1CDB': "udAtta-3";
+    readonly '\u0966': "0";
+    readonly '\u0967': "1";
+    readonly '\u0968': "2";
+    readonly '\u0969': "3";
+    readonly '\u096A': "4";
+    readonly '\u096B': "5";
+    readonly '\u096C': "6";
+    readonly '\u096D': "7";
+    readonly '\u096E': "8";
+    readonly '\u096F': "9";
+    readonly '\u0964': "virama";
+    readonly '\u0965': "double_virama";
+    readonly '\u200D': "zero_width_joiner";
+};
+
+/**
+ * Krama(क्रम) is the array in which most of the keys used in scripts are present
+ * It is an array which contains and describes common elements of different scripts allowing fast and efficient lookup
+ * and transliteration of different scripts
+ */
+declare type KramaKeysType = (typeof KramaKeysArray)[number];
+
+export declare const LANG_LIST: lang_list_type[];
+
+declare const lang_list: {
+    English: number;
+    Sanskrit: number;
+    Hindi: number;
+    Telugu: number;
+    Tamil: number;
+    Bengali: number;
+    Kannada: number;
+    Gujarati: number;
+    Malayalam: number;
+    Odia: number;
+    Sinhala: number;
+    Marathi: number;
+    Nepali: number;
+    Punjabi: number;
+    Assamese: number;
+};
+
+declare type lang_list_type = keyof typeof lang_list;
+
+/** Type of the language list */
+export declare type LangListType = lang_list_type;
+
+declare type OutputBrahmicScriptData = Pick<InputBrahmicScriptType, 'script_name' | 'script_id' | 'halant' | 'nuqta' | 'schwa_property' | 'script_type'> & Omit<CommonScriptData, 'list'> & {
+    list: (Pick<CommonScriptData['list'][number], 'krama_ref'> & ({
+        type: Exclude<InputBrahmicScriptType['list'][number]['type'] | 'mAtrA', 'svara'>;
+    } | {
+        type: 'svara';
+        mAtrA_krama_ref?: number[] | null;
+    }))[];
+};
+
+declare type OutputOtherScriptData = Pick<InputOtherScriptType, 'script_name' | 'script_id' | 'script_type' | 'schwa_character'> & CommonScriptData;
+
+declare type OutputScriptData = OutputBrahmicScriptData | OutputOtherScriptData;
+
+/**
+ * Preloads the script data. Useful for browsers as avoids the fetch latency
+ * @param name - The name of the script/language to preload
+ * @returns The script data
+ * @public
+ */
+export declare const preloadScriptData: (name: script_input_name_type) => Promise<OutputScriptData>;
+
+declare type script_and_lang_list_type = script_list_type | lang_list_type;
+
+declare type script_input_name_type = acronym_type | script_and_lang_list_type;
+
+export declare const SCRIPT_LIST: script_list_type[];
+
+declare const script_list: {
+    Devanagari: number;
+    Telugu: number;
+    Tamil: number;
+    "Tamil-Extended": number;
+    Bengali: number;
+    Kannada: number;
+    Gujarati: number;
+    Malayalam: number;
+    Odia: number;
+    Sinhala: number;
+    Normal: number;
+    Romanized: number;
+    Gurumukhi: number;
+    Assamese: number;
+    "Purna-Devanagari": number;
+    Brahmi: number;
+    Granth: number;
+    Modi: number;
+    Sharada: number;
+    Siddham: number;
+};
+
+declare type script_list_type = keyof typeof script_list;
+
+/** Type of the script and language list */
+export declare type ScriptAndLangListType = script_and_lang_list_type;
+
+/**
+ * Supported script/language identifier types
+ */
+export declare type ScriptLangType = script_input_name_type;
+
+/** Type of the script list */
+export declare type ScriptListType = script_list_type;
+
+/**
+ * Transliterates `text` from `from` to `to`.
+ * @param text - The text to transliterate
+ * @param from - The script/language to transliterate from
+ * @param to - The script/language to transliterate to
+ * @param options - The custom options to use for the transliteration
+ * @returns The transliterated text
+ */
+export declare function transliterate(text: string, from: ScriptLangType, to: ScriptLangType, options?: CustomOptionType): Promise<string>;
+
+export declare type TransliterationOptions = CustomOptionType;
+
+export { }