skrits 1.0.0

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+// src/index.ts - Main entry point
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._looksLikeSatroEncoded = exports._deleetTextBasic = exports.detectLeetBase = exports.detectMode = exports.encodeText = exports.looksLikeLeet = exports.applyLeet = exports.buildFullLeetProfile = exports.getLeetProfile = exports.availableProfiles = exports.LeetEncoder = exports.LEET_SIGNAL_CHARS = exports.DEFAULT_LEET_DENSITY = exports.READABLE_FULL_PROFILE = exports.BASIC_LEET_PROFILE = exports.LEET_TABLE = exports.Leetrovacki = exports.Utrovacki = exports.Satrovacki = void 0;
+var satrovacki_1 = require("./satrovacki");
+Object.defineProperty(exports, "Satrovacki", { enumerable: true, get: function () { return satrovacki_1.Satrovacki; } });
+var utrovacki_1 = require("./utrovacki");
+Object.defineProperty(exports, "Utrovacki", { enumerable: true, get: function () { return utrovacki_1.Utrovacki; } });
+var leetrovacki_1 = require("./leetrovacki");
+Object.defineProperty(exports, "Leetrovacki", { enumerable: true, get: function () { return leetrovacki_1.Leetrovacki; } });
+var leet_1 = require("./leet");
+Object.defineProperty(exports, "LEET_TABLE", { enumerable: true, get: function () { return leet_1.LEET_TABLE; } });
+Object.defineProperty(exports, "BASIC_LEET_PROFILE", { enumerable: true, get: function () { return leet_1.BASIC_LEET_PROFILE; } });
+Object.defineProperty(exports, "READABLE_FULL_PROFILE", { enumerable: true, get: function () { return leet_1.READABLE_FULL_PROFILE; } });
+Object.defineProperty(exports, "DEFAULT_LEET_DENSITY", { enumerable: true, get: function () { return leet_1.DEFAULT_LEET_DENSITY; } });
+Object.defineProperty(exports, "LEET_SIGNAL_CHARS", { enumerable: true, get: function () { return leet_1.LEET_SIGNAL_CHARS; } });
+Object.defineProperty(exports, "LeetEncoder", { enumerable: true, get: function () { return leet_1.LeetEncoder; } });
+Object.defineProperty(exports, "availableProfiles", { enumerable: true, get: function () { return leet_1.availableProfiles; } });
+Object.defineProperty(exports, "getLeetProfile", { enumerable: true, get: function () { return leet_1.getLeetProfile; } });
+Object.defineProperty(exports, "buildFullLeetProfile", { enumerable: true, get: function () { return leet_1.buildFullLeetProfile; } });
+Object.defineProperty(exports, "applyLeet", { enumerable: true, get: function () { return leet_1.applyLeet; } });
+Object.defineProperty(exports, "looksLikeLeet", { enumerable: true, get: function () { return leet_1.looksLikeLeet; } });
+var skrit_1 = require("./skrit");
+Object.defineProperty(exports, "encodeText", { enumerable: true, get: function () { return skrit_1.encodeText; } });
+Object.defineProperty(exports, "detectMode", { enumerable: true, get: function () { return skrit_1.detectMode; } });
+Object.defineProperty(exports, "detectLeetBase", { enumerable: true, get: function () { return skrit_1.detectLeetBase; } });
+Object.defineProperty(exports, "_deleetTextBasic", { enumerable: true, get: function () { return skrit_1._deleetTextBasic; } });
+Object.defineProperty(exports, "_looksLikeSatroEncoded", { enumerable: true, get: function () { return skrit_1._looksLikeSatroEncoded; } });
+__exportStar(require("./core/transliteration"), exports);
+__exportStar(require("./core/caseHelper"), exports);
+__exportStar(require("./core/stringUtils"), exports);
+__exportStar(require("./core/tokenizer"), exports);
+//# sourceMappingURL=index.js.map

package/dist/leet.d.ts

@@ -0,0 +1,25 @@
+export declare const LEET_TABLE: Record<string, string[]>;
+export declare const BASIC_LEET_PROFILE: Record<string, string>;
+export declare const READABLE_FULL_PROFILE: Record<string, string>;
+export type LeetProfile = 'basic' | 'readable' | 'full';
+export declare function availableProfiles(): LeetProfile[];
+export declare function getLeetProfile(name: LeetProfile | string, customMap?: Record<string, string>, complexity?: number): Record<string, string>;
+export declare function buildFullLeetProfile(complexity?: number): Record<string, string>;
+export declare const DEFAULT_LEET_DENSITY = 0.86;
+export declare const LEET_SIGNAL_CHARS: Set<string>;
+export declare function applyLeet(text: string, mapping: Record<string, string>, density?: number): string;
+export declare function looksLikeLeet(text: string): boolean;
+export interface LeetEncoderOptions {
+    profile?: LeetProfile | string;
+    customMap?: Record<string, string>;
+    complexity?: number;
+    density?: number;
+}
+export declare class LeetEncoder {
+    readonly profile: LeetProfile | string;
+    readonly mapping: Record<string, string>;
+    readonly density: number;
+    constructor(options?: LeetEncoderOptions);
+    encode(text: string): string;
+}
+//# sourceMappingURL=leet.d.ts.map

package/dist/leet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leet.d.ts","sourceRoot":"","sources":["../src/leet.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CA2B/C,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAErD,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAExD,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,CAAC;AAExD,wBAAgB,iBAAiB,IAAI,WAAW,EAAE,CAEjD;AAED,wBAAgB,cAAc,CAC5B,IAAI,EAAE,WAAW,GAAG,MAAM,EAC1B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,UAAU,SAAI,GACb,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB;AAED,wBAAgB,oBAAoB,CAAC,UAAU,SAAI,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAO3E;AAED,eAAO,MAAM,oBAAoB,OAAO,CAAC;AACzC,eAAO,MAAM,iBAAiB,aAA8D,CAAC;AAE7F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,SAAuB,GAAG,MAAM,CAiB/G;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMnD;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,WAAW;IACtB,QAAQ,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,GAAE,kBAAuB;IAM5C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAG7B"}

package/dist/leet.js

@@ -0,0 +1,108 @@
+"use strict";
+// src/leet.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeetEncoder = exports.LEET_SIGNAL_CHARS = exports.DEFAULT_LEET_DENSITY = exports.READABLE_FULL_PROFILE = exports.BASIC_LEET_PROFILE = exports.LEET_TABLE = void 0;
+exports.availableProfiles = availableProfiles;
+exports.getLeetProfile = getLeetProfile;
+exports.buildFullLeetProfile = buildFullLeetProfile;
+exports.applyLeet = applyLeet;
+exports.looksLikeLeet = looksLikeLeet;
+exports.LEET_TABLE = {
+    a: ['4', '@', '/\\', 'а'],
+    b: ['8', '|3', '13'],
+    c: ['(', '<', '{', '['],
+    d: ['|)', 'cl', '[)'],
+    e: ['3', '€', '[-'],
+    f: ['|=', 'ph', '|#'],
+    g: ['6', '9', '(_+'],
+    h: ['#', '|-|', '}{', ')-('],
+    i: ['1', '!', '|', ']['],
+    j: ['_|', ']', '_)'],
+    k: ['|<', '|{', 'ik'],
+    l: ['1', '|_', '|'],
+    m: ['|\\/|', '|v|', '/\\/\\', '|\\/|'],
+    n: ['|\\|', '/\\/', '|\\/|', '|\\\\|'],
+    o: ['0', '()', '[]', '<>'],
+    p: ['|*', '|o', '|>', '|"'],
+    q: ['(,)', '0_', 'kw'],
+    r: ['|2', '|?', '/2', 'I2'],
+    s: ['5', '$', 'z'],
+    t: ['7', '+', '†'],
+    u: ['00', '|_|', '\\_/'],
+    v: ['\\/', '\\/'],
+    w: ['\\/\\/', 'vv', '\\|/', '\\^/'],
+    x: ['><', '%', '}{'],
+    y: ['`/', '¥', '\\|/'],
+    z: ['2', '7_', '>_'],
+};
+exports.BASIC_LEET_PROFILE = {
+    a: '4', e: '3', i: '1', o: '0', s: '5', t: '7', u: '00', z: '2',
+};
+exports.READABLE_FULL_PROFILE = {
+    a: '4', b: '8', e: '3', g: '6', i: '1', o: '0', s: '5', t: '7', z: '2',
+};
+function availableProfiles() {
+    return ['basic', 'readable', 'full'];
+}
+function getLeetProfile(name, customMap, complexity = 0) {
+    if (customMap)
+        return customMap;
+    if (name === 'basic')
+        return { ...exports.BASIC_LEET_PROFILE };
+    if (name === 'readable')
+        return { ...exports.READABLE_FULL_PROFILE };
+    if (name === 'full')
+        return buildFullLeetProfile(complexity);
+    throw new Error(`Unknown leet profile: ${name}. Available: basic, readable, full`);
+}
+function buildFullLeetProfile(complexity = 0) {
+    const result = {};
+    for (const [letter, variants] of Object.entries(exports.LEET_TABLE)) {
+        const idx = Math.min(complexity, variants.length - 1);
+        result[letter] = variants[idx];
+    }
+    return result;
+}
+exports.DEFAULT_LEET_DENSITY = 0.86;
+exports.LEET_SIGNAL_CHARS = new Set(['4', '3', '1', '0', '5', '7', '2', '@', '$', '!']);
+function applyLeet(text, mapping, density = exports.DEFAULT_LEET_DENSITY) {
+    if (density < 0 || density > 1)
+        throw new Error('Leet density must be between 0.0 and 1.0');
+    const chars = [...text];
+    return chars.map((ch, pos) => {
+        const lower = ch.toLowerCase();
+        const replacement = mapping[lower];
+        if (!replacement)
+            return ch;
+        // Density check: deterministic pseudo-random based on char value and position
+        const charOrd = ch.codePointAt(0) ?? 0;
+        const score = (pos * 131 + charOrd * 17) % 100;
+        if (score >= density * 100)
+            return ch;
+        // Preserve case if possible
+        if (ch === ch.toUpperCase() && ch !== ch.toLowerCase()) {
+            return replacement.toUpperCase();
+        }
+        return replacement;
+    }).join('');
+}
+function looksLikeLeet(text) {
+    let signalCount = 0;
+    for (const ch of text) {
+        if (exports.LEET_SIGNAL_CHARS.has(ch))
+            signalCount++;
+    }
+    return signalCount >= 2;
+}
+class LeetEncoder {
+    constructor(options = {}) {
+        this.profile = options.profile ?? 'basic';
+        this.density = options.density ?? exports.DEFAULT_LEET_DENSITY;
+        this.mapping = getLeetProfile(this.profile, options.customMap, options.complexity ?? 0);
+    }
+    encode(text) {
+        return applyLeet(text, this.mapping, this.density);
+    }
+}
+exports.LeetEncoder = LeetEncoder;
+//# sourceMappingURL=leet.js.map

package/dist/leetrovacki.d.ts

@@ -0,0 +1,37 @@
+import { SatrovackiOptions } from './satrovacki';
+import { LeetProfile } from './leet';
+export type LeetBase = 'auto' | 'satro' | 'utro';
+export type ZaStyle = '24' | 'z4';
+export type NjeStyle = 'n73' | 'nj3' | 'њ';
+export interface LeetrovackiOptions extends SatrovackiOptions {
+    base?: LeetBase;
+    leetProfile?: LeetProfile | string;
+    leetComplexity?: number;
+    leetDensity?: number;
+    zaStyle?: ZaStyle;
+    njeStyle?: NjeStyle;
+    prefix?: string;
+    infix?: string;
+    suffix?: string;
+}
+export declare class Leetrovacki {
+    readonly base: LeetBase;
+    readonly leetProfile: LeetProfile | string;
+    readonly leetComplexity: number;
+    readonly leetDensity: number;
+    readonly zaStyle: ZaStyle;
+    readonly njeStyle: NjeStyle;
+    private readonly satroCoder;
+    private readonly utroCoder;
+    private readonly leetMapping;
+    constructor(options?: LeetrovackiOptions);
+    encode(text: string): string;
+    encodeWord(word: string): string;
+    private _resolveBase;
+    private _looksLikeUtro;
+    private _leetifyUtro;
+    private _leetifySatro;
+    private _zaReplacement;
+    private _njeReplacement;
+}
+//# sourceMappingURL=leetrovacki.d.ts.map

package/dist/leetrovacki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leetrovacki.d.ts","sourceRoot":"","sources":["../src/leetrovacki.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAE7D,OAAO,EAAmD,WAAW,EAAE,MAAM,QAAQ,CAAC;AAKtF,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AACjD,MAAM,MAAM,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;AAClC,MAAM,MAAM,QAAQ,GAAG,KAAK,GAAG,KAAK,GAAG,GAAG,CAAC;AAE3C,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB;IAC3D,IAAI,CAAC,EAAE,QAAQ,CAAC;IAChB,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,WAAW;IACtB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;gBAEzC,OAAO,GAAE,kBAAuB;IA6B5C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAO5B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAahC,OAAO,CAAC,YAAY;IAQpB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,YAAY;IA4BpB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,eAAe;CAKxB"}

package/dist/leetrovacki.js

@@ -0,0 +1,109 @@
+"use strict";
+// src/leetrovacki.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Leetrovacki = void 0;
+const satrovacki_1 = require("./satrovacki");
+const utrovacki_1 = require("./utrovacki");
+const leet_1 = require("./leet");
+const tokenizer_1 = require("./core/tokenizer");
+const stringUtils_1 = require("./core/stringUtils");
+class Leetrovacki {
+    constructor(options = {}) {
+        this.base = options.base ?? 'auto';
+        this.leetProfile = options.leetProfile ?? 'basic';
+        this.leetComplexity = options.leetComplexity ?? 0;
+        this.leetDensity = options.leetDensity ?? leet_1.DEFAULT_LEET_DENSITY;
+        this.zaStyle = options.zaStyle ?? '24';
+        this.njeStyle = options.njeStyle ?? 'n73';
+        if (this.leetDensity < 0 || this.leetDensity > 1) {
+            throw new Error('leet_density must be between 0.0 and 1.0');
+        }
+        const sharedOpts = {
+            minWordLength: options.minWordLength,
+            plainCTarget: options.plainCTarget,
+            softTjToCyrillic: options.softTjToCyrillic,
+            exceptions: options.exceptions,
+        };
+        this.satroCoder = new satrovacki_1.Satrovacki(sharedOpts);
+        this.utroCoder = new utrovacki_1.Utrovacki({
+            ...sharedOpts,
+            prefix: options.prefix,
+            infix: options.infix,
+            suffix: options.suffix,
+        });
+        this.leetMapping = (0, leet_1.getLeetProfile)(this.leetProfile, undefined, this.leetComplexity);
+    }
+    encode(text) {
+        return (0, tokenizer_1.tokenize)(text).map(token => {
+            if ((0, tokenizer_1.isAlpha)(token))
+                return this.encodeWord(token);
+            return token;
+        }).join('');
+    }
+    encodeWord(word) {
+        if ((0, stringUtils_1.strLen)(word) < (this.satroCoder.minWordLength))
+            return word;
+        const resolvedBase = this._resolveBase(word);
+        if (resolvedBase === 'utro') {
+            const utroEncoded = this.utroCoder.encodeWord(word);
+            return this._leetifyUtro(utroEncoded);
+        }
+        else {
+            const satroEncoded = this.satroCoder.encodeWord(word);
+            return this._leetifySatro(satroEncoded);
+        }
+    }
+    _resolveBase(word) {
+        if (this.base === 'utro')
+            return 'utro';
+        if (this.base === 'satro')
+            return 'satro';
+        // auto: check if word looks like utro encoded
+        if (this._looksLikeUtro(word))
+            return 'utro';
+        return 'satro';
+    }
+    _looksLikeUtro(word) {
+        return this.utroCoder.canDecodeWord(word);
+    }
+    _leetifyUtro(encoded) {
+        // In utro mode: apply leet but handle 'za' and 'nje' styling
+        const lower = encoded.toLowerCase();
+        const pre = this.utroCoder.prefix.toLowerCase();
+        const inf = this.utroCoder.infix.toLowerCase();
+        const suf = this.utroCoder.suffix.toLowerCase();
+        // Find the structural parts
+        if (lower.startsWith(pre) && lower.endsWith(suf)) {
+            const inner = lower.slice(pre.length, lower.length - suf.length);
+            const infIdx = inner.indexOf(inf);
+            if (infIdx !== -1) {
+                const part2 = inner.slice(0, infIdx);
+                const part1 = inner.slice(infIdx + inf.length);
+                const leetPart2 = (0, leet_1.applyLeet)(part2, this.leetMapping, this.leetDensity);
+                const leetPart1 = (0, leet_1.applyLeet)(part1, this.leetMapping, this.leetDensity);
+                const zaStr = this._zaReplacement();
+                const njeStr = this._njeReplacement();
+                return pre + leetPart2 + zaStr + leetPart1 + njeStr;
+            }
+        }
+        // Fallback: apply leet to whole thing
+        return (0, leet_1.applyLeet)(encoded, this.leetMapping, this.leetDensity);
+    }
+    _leetifySatro(encoded) {
+        return (0, leet_1.applyLeet)(encoded, this.leetMapping, this.leetDensity);
+    }
+    _zaReplacement() {
+        if (this.zaStyle === 'z4')
+            return 'z4';
+        return '24'; // default '24'
+    }
+    _njeReplacement() {
+        if (this.njeStyle === 'nj3')
+            return 'nj3';
+        if (this.njeStyle === 'њ')
+            return 'њ';
+        return 'n73'; // default
+    }
+}
+exports.Leetrovacki = Leetrovacki;
+//# sourceMappingURL=leetrovacki.js.map

package/dist/satrovacki.d.ts

@@ -0,0 +1,25 @@
+export interface SatrovackiOptions {
+    minWordLength?: number;
+    plainCTarget?: string;
+    softTjToCyrillic?: boolean;
+    exceptions?: Record<string, string>;
+}
+export declare class Satrovacki {
+    readonly minWordLength: number;
+    readonly plainCTarget: string;
+    readonly softTjToCyrillic: boolean;
+    readonly exceptions: Record<string, string>;
+    constructor(options?: SatrovackiOptions);
+    encode(text: string): string;
+    decode(text: string): string;
+    encodeWord(word: string): string;
+    decodeWord(word: string): string;
+    canDecodeWord(word: string): boolean;
+    _encodeLatinWord(lowerWord: string): string;
+    _encodeLatinWordPlain(lowerWord: string): string;
+    _decodeCandidates(lowerWord: string): Array<[number, string]>;
+    _pickBestDecodeCandidate(candidates: Array<[number, string]>): string;
+    protected _findSplitIndex(word: string): number;
+    protected _isVowelAt(word: string, i: number): boolean;
+}
+//# sourceMappingURL=satrovacki.d.ts.map

package/dist/satrovacki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"satrovacki.d.ts","sourceRoot":"","sources":["../src/satrovacki.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,iBAAiB;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACrC;AAID,qBAAa,UAAU;IACrB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAEhC,OAAO,GAAE,iBAAsB;IAO3C,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAO5B,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAO5B,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAehC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAyBhC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAcpC,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAM3C,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAQhD,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAiB7D,wBAAwB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM;IAoBrE,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAc/C,SAAS,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;CAavD"}

package/dist/satrovacki.js

@@ -0,0 +1,157 @@
+"use strict";
+// D:\Projects\SkriTS\src\satrovacki.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Satrovacki = void 0;
+const transliteration_1 = require("./core/transliteration");
+const caseHelper_1 = require("./core/caseHelper");
+const tokenizer_1 = require("./core/tokenizer");
+const stringUtils_1 = require("./core/stringUtils");
+const VOWELS = new Set(['a', 'e', 'i', 'o', 'u', 'а', 'е', 'и', 'о', 'у']);
+class Satrovacki {
+    constructor(options = {}) {
+        this.minWordLength = options.minWordLength ?? 3;
+        this.plainCTarget = options.plainCTarget ?? 'ц';
+        this.softTjToCyrillic = options.softTjToCyrillic ?? false;
+        this.exceptions = options.exceptions ?? {};
+    }
+    encode(text) {
+        return (0, tokenizer_1.tokenize)(text).map(token => {
+            if ((0, tokenizer_1.isAlpha)(token))
+                return this.encodeWord(token);
+            return token;
+        }).join('');
+    }
+    decode(text) {
+        return (0, tokenizer_1.tokenize)(text).map(token => {
+            if ((0, tokenizer_1.isAlpha)(token))
+                return this.decodeWord(token);
+            return token;
+        }).join('');
+    }
+    encodeWord(word) {
+        if ((0, stringUtils_1.strLen)(word) < this.minWordLength)
+            return word;
+        const isCyr = (0, transliteration_1.containsCyrillic)(word);
+        const latin = isCyr ? (0, transliteration_1.cyrillicToLatin)(word) : word;
+        const latinLower = latin.toLowerCase();
+        const replaced = this._encodeLatinWord(latinLower);
+        let result = (0, caseHelper_1.applyCase)(latin, replaced);
+        if (isCyr) {
+            result = (0, transliteration_1.latinToCyrillic)(result, this.softTjToCyrillic, this.plainCTarget);
+        }
+        return result;
+    }
+    decodeWord(word) {
+        if ((0, stringUtils_1.strLen)(word) < this.minWordLength)
+            return word;
+        const isCyr = (0, transliteration_1.containsCyrillic)(word);
+        const latin = isCyr ? (0, transliteration_1.cyrillicToLatin)(word) : word;
+        const latinLower = latin.toLowerCase();
+        const reverseExceptions = {};
+        for (const [k, v] of Object.entries(this.exceptions)) {
+            reverseExceptions[v] = k;
+        }
+        let replaced = reverseExceptions[latinLower] ?? null;
+        if (replaced === null) {
+            const candidates = this._decodeCandidates(latinLower);
+            replaced = candidates.length > 0 ? this._pickBestDecodeCandidate(candidates) : latinLower;
+        }
+        let result = (0, caseHelper_1.applyCase)(latin, replaced);
+        if (isCyr) {
+            result = (0, transliteration_1.latinToCyrillic)(result, this.softTjToCyrillic, this.plainCTarget);
+        }
+        return result;
+    }
+    canDecodeWord(word) {
+        if ((0, stringUtils_1.strLen)(word) < this.minWordLength)
+            return false;
+        const isCyr = (0, transliteration_1.containsCyrillic)(word);
+        const latin = isCyr ? (0, transliteration_1.cyrillicToLatin)(word) : word;
+        const lower = latin.toLowerCase();
+        const reverseExceptions = {};
+        for (const [k, v] of Object.entries(this.exceptions)) {
+            reverseExceptions[v] = k;
+        }
+        if (reverseExceptions[lower] !== undefined)
+            return true;
+        return this._decodeCandidates(lower).length > 0;
+    }
+    _encodeLatinWord(lowerWord) {
+        const exc = this.exceptions[lowerWord];
+        if (exc !== undefined)
+            return exc;
+        return this._encodeLatinWordPlain(lowerWord);
+    }
+    _encodeLatinWordPlain(lowerWord) {
+        const splitIdx = this._findSplitIndex(lowerWord);
+        const n = (0, stringUtils_1.strLen)(lowerWord);
+        if (splitIdx <= 0 || splitIdx >= n)
+            return lowerWord;
+        const chars = (0, stringUtils_1.splitChars)(lowerWord);
+        return chars.slice(splitIdx).join('') + chars.slice(0, splitIdx).join('');
+    }
+    _decodeCandidates(lowerWord) {
+        const candidates = [];
+        const n = (0, stringUtils_1.strLen)(lowerWord);
+        const chars = (0, stringUtils_1.splitChars)(lowerWord);
+        for (let splitIndex = 1; splitIndex < n; splitIndex++) {
+            // Right-rotate by splitIndex: take last splitIndex chars + rest
+            const candidate = chars.slice(n - splitIndex).join('') + chars.slice(0, n - splitIndex).join('');
+            const encodedWithExc = this._encodeLatinWord(candidate);
+            const encodedPlain = this._encodeLatinWordPlain(candidate);
+            if (encodedWithExc === lowerWord || encodedPlain === lowerWord) {
+                candidates.push([splitIndex, candidate]);
+            }
+        }
+        return candidates;
+    }
+    _pickBestDecodeCandidate(candidates) {
+        const half = (0, stringUtils_1.strLen)(candidates[0][1]) / 2.0;
+        const score = ([splitIndex, candidate]) => {
+            const secondIsVowel = ((0, stringUtils_1.strLen)(candidate) > 1 && this._isVowelAt(candidate, 1)) ? 1 : 0;
+            const startsWithConsonant = (candidate.length > 0 && !this._isVowelAt(candidate, 0)) ? 1 : 0;
+            return [Math.abs(splitIndex - half), -secondIsVowel, -startsWithConsonant, splitIndex];
+        };
+        return candidates.reduce((best, cur) => {
+            const bs = score(best);
+            const cs = score(cur);
+            for (let i = 0; i < 4; i++) {
+                if (cs[i] < bs[i])
+                    return cur;
+                if (cs[i] > bs[i])
+                    return best;
+            }
+            return best;
+        })[1];
+    }
+    _findSplitIndex(word) {
+        const n = (0, stringUtils_1.strLen)(word);
+        for (let i = 0; i < n; i++) {
+            if (this._isVowelAt(word, i)) {
+                let splitIdx = i + 1;
+                while (splitIdx < n && this._isVowelAt(word, splitIdx)) {
+                    splitIdx++;
+                }
+                return splitIdx;
+            }
+        }
+        return Math.floor(n / 2);
+    }
+    _isVowelAt(word, i) {
+        const chars = (0, stringUtils_1.splitChars)(word);
+        if (i < 0 || i >= chars.length)
+            return false;
+        const ch = chars[i].toLowerCase();
+        if (VOWELS.has(ch))
+            return true;
+        // Syllabic r: 'r' between consonants, not at word edges
+        if (ch === 'r' && i > 0 && i < chars.length - 1) {
+            const prev = chars[i - 1].toLowerCase();
+            const next = chars[i + 1].toLowerCase();
+            return !VOWELS.has(prev) && !VOWELS.has(next);
+        }
+        return false;
+    }
+}
+exports.Satrovacki = Satrovacki;
+//# sourceMappingURL=satrovacki.js.map

package/dist/skrit.d.ts

@@ -0,0 +1,28 @@
+import { SatrovackiOptions } from './satrovacki';
+import { LeetBase } from './leetrovacki';
+import { LeetProfile } from './leet';
+export type Mode = 'auto' | 'satro' | 'utro' | 'leet';
+export type DetectFrom = 'satro' | 'utro' | 'leet' | null;
+export interface SkritOptions {
+    mode?: Mode;
+    detectFrom?: DetectFrom;
+    minWordLength?: number;
+    plainCTarget?: string;
+    softTjToCyrillic?: boolean;
+    exceptions?: Record<string, string>;
+    leetBase?: LeetBase;
+    leetProfile?: LeetProfile | string;
+    leetComplexity?: number;
+    leetDensity?: number;
+    zaStyle?: '24' | 'z4';
+    njeStyle?: 'n73' | 'nj3' | 'њ';
+    utroPrefix?: string;
+    utroInfix?: string;
+    utroSuffix?: string;
+}
+export declare function detectMode(text: string, options?: SkritOptions): 'satro' | 'utro' | 'leet';
+export declare function detectLeetBase(text: string, options?: SkritOptions): 'satro' | 'utro';
+export declare function encodeText(text: string, options?: SkritOptions): string;
+export declare function _deleetTextBasic(text: string): string;
+export declare function _looksLikeSatroEncoded(word: string, options?: SatrovackiOptions): boolean;
+//# sourceMappingURL=skrit.d.ts.map

package/dist/skrit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skrit.d.ts","sourceRoot":"","sources":["../src/skrit.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAE7D,OAAO,EAAmC,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAuE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAG1G,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AACtD,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAE1D,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC;IACnC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,GAAG,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAsB9F;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,GAAG,MAAM,CAWzF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,MAAM,CAkD3E;AAsCD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAcrD;AAiBD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAE7F"}