skrits 1.0.0

package/tests/leet.test.ts

@@ -0,0 +1,117 @@
+import {
+  LEET_TABLE,
+  BASIC_LEET_PROFILE,
+  availableProfiles,
+  getLeetProfile,
+  buildFullLeetProfile,
+  applyLeet,
+  looksLikeLeet,
+  LeetEncoder,
+  DEFAULT_LEET_DENSITY,
+} from '../src/leet';
+
+describe('Leet', () => {
+  describe('availableProfiles', () => {
+    test('returns three profiles', () => {
+      const profiles = availableProfiles();
+      expect(profiles).toContain('basic');
+      expect(profiles).toContain('readable');
+      expect(profiles).toContain('full');
+    });
+  });
+
+  describe('LEET_TABLE', () => {
+    test('has 26 letters', () => {
+      expect(Object.keys(LEET_TABLE).length).toBe(26);
+    });
+
+    test('each letter has at least one variant', () => {
+      for (const variants of Object.values(LEET_TABLE)) {
+        expect(variants.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('getLeetProfile', () => {
+    test('basic profile returns BASIC_LEET_PROFILE', () => {
+      const profile = getLeetProfile('basic');
+      expect(profile).toEqual(BASIC_LEET_PROFILE);
+    });
+
+    test('unknown profile throws', () => {
+      expect(() => getLeetProfile('unknown')).toThrow();
+    });
+
+    test('custom map returned as-is', () => {
+      const custom = { a: 'x' };
+      expect(getLeetProfile('basic', custom)).toEqual(custom);
+    });
+  });
+
+  describe('buildFullLeetProfile', () => {
+    test('complexity 0 returns first variant', () => {
+      const profile = buildFullLeetProfile(0);
+      expect(profile['a']).toBe(LEET_TABLE['a'][0]);
+    });
+
+    test('complexity 1 returns second variant where available', () => {
+      const profile = buildFullLeetProfile(1);
+      expect(profile['a']).toBe(LEET_TABLE['a'][1]);
+    });
+  });
+
+  describe('applyLeet', () => {
+    test('density 1.0 replaces all mappable chars', () => {
+      const result = applyLeet('a', { a: '4' }, 1.0);
+      expect(result).toBe('4');
+    });
+
+    test('density 0.0 replaces nothing', () => {
+      const result = applyLeet('aaaa', { a: '4' }, 0.0);
+      expect(result).toBe('aaaa');
+    });
+
+    test('non-mapped chars unchanged', () => {
+      const result = applyLeet('xyz', { a: '4' }, 1.0);
+      expect(result).toBe('xyz');
+    });
+
+    test('invalid density throws', () => {
+      expect(() => applyLeet('a', { a: '4' }, 1.5)).toThrow();
+      expect(() => applyLeet('a', { a: '4' }, -0.1)).toThrow();
+    });
+  });
+
+  describe('looksLikeLeet', () => {
+    test('leet text detected', () => {
+      expect(looksLikeLeet('h3ll0')).toBe(true);
+    });
+
+    test('plain text not leet', () => {
+      expect(looksLikeLeet('hello')).toBe(false);
+    });
+
+    test('single signal char not enough', () => {
+      expect(looksLikeLeet('h3llo')).toBe(false); // only one signal char
+    });
+  });
+
+  describe('LeetEncoder', () => {
+    test('basic profile encodes', () => {
+      const enc = new LeetEncoder({ profile: 'basic', density: 1.0 });
+      // 'a' -> '4' at density 1.0
+      const result = enc.encode('aaa');
+      expect(result).not.toBe('aaa');
+    });
+
+    test('density 0 encodes nothing', () => {
+      const enc = new LeetEncoder({ profile: 'basic', density: 0.0 });
+      expect(enc.encode('aeiou')).toBe('aeiou');
+    });
+
+    test('default density is 0.86', () => {
+      const enc = new LeetEncoder();
+      expect(enc.density).toBe(DEFAULT_LEET_DENSITY);
+    });
+  });
+});

package/tests/leetrovacki.test.ts

@@ -0,0 +1,76 @@
+import { Leetrovacki } from '../src/leetrovacki';
+
+describe('Leetrovacki', () => {
+  describe('basic encoding', () => {
+    test('encodes word with leet applied', () => {
+      const l = new Leetrovacki({ base: 'satro', leetDensity: 1.0 });
+      const result = l.encodeWord('bazen');
+      // zenba with leet at 100% density: z->2, e->3, n unchanged, b unchanged, a->4
+      expect(result).not.toBe('bazen');
+      expect(typeof result).toBe('string');
+    });
+
+    test('short words unchanged', () => {
+      const l = new Leetrovacki();
+      expect(l.encodeWord('na')).toBe('na');
+    });
+
+    test('utro base uses utro format', () => {
+      const l = new Leetrovacki({ base: 'utro', leetDensity: 0.0 });
+      const result = l.encodeWord('bazen');
+      // zaStyle='24' replaces 'za', njeStyle='n73' replaces 'nje' - these always apply in utro mode
+      expect(result).toContain('24');
+      expect(result).toContain('n73');
+    });
+
+    test('sentence encode', () => {
+      const l = new Leetrovacki({ base: 'satro' });
+      const result = l.encode('bazen voda');
+      expect(result.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('validation', () => {
+    test('invalid density throws', () => {
+      expect(() => new Leetrovacki({ leetDensity: 1.5 })).toThrow();
+    });
+
+    test('invalid density negative throws', () => {
+      expect(() => new Leetrovacki({ leetDensity: -0.1 })).toThrow();
+    });
+  });
+
+  describe('za style', () => {
+    test('zaStyle z4 used in utro mode', () => {
+      const l = new Leetrovacki({ base: 'utro', zaStyle: 'z4', leetDensity: 0.0 });
+      const result = l.encodeWord('bazen');
+      expect(result).toContain('z4');
+    });
+
+    test('zaStyle 24 used in utro mode', () => {
+      const l = new Leetrovacki({ base: 'utro', zaStyle: '24', leetDensity: 0.0 });
+      const result = l.encodeWord('bazen');
+      expect(result).toContain('24');
+    });
+  });
+
+  describe('nje style', () => {
+    test('njeStyle n73 in utro mode', () => {
+      const l = new Leetrovacki({ base: 'utro', njeStyle: 'n73', leetDensity: 0.0 });
+      const result = l.encodeWord('bazen');
+      expect(result).toContain('n73');
+    });
+  });
+
+  describe('leet profiles', () => {
+    test('basic profile', () => {
+      const l = new Leetrovacki({ base: 'satro', leetProfile: 'basic', leetDensity: 1.0 });
+      expect(typeof l.encodeWord('bazen')).toBe('string');
+    });
+
+    test('full profile complexity', () => {
+      const l = new Leetrovacki({ base: 'satro', leetProfile: 'full', leetComplexity: 0, leetDensity: 1.0 });
+      expect(typeof l.encodeWord('bazen')).toBe('string');
+    });
+  });
+});

package/tests/satrovacki.test.ts

@@ -0,0 +1,112 @@
+import { Satrovacki } from '../src/satrovacki';
+
+describe('Satrovacki', () => {
+  const s = new Satrovacki();
+
+  describe('encode', () => {
+    test('basic latin word', () => {
+      expect(s.encodeWord('bazen')).toBe('zenba');
+    });
+
+    test('Beograd title case', () => {
+      expect(s.encodeWord('Beograd')).toBe('Gradbeo');
+    });
+
+    test('riba', () => {
+      expect(s.encodeWord('riba')).toBe('bari');
+    });
+
+    test('uppercase', () => {
+      expect(s.encodeWord('BAZEN')).toBe('ZENBA');
+    });
+
+    test('word shorter than minWordLength unchanged', () => {
+      expect(s.encodeWord('na')).toBe('na');
+    });
+
+    test('word exactly at minWordLength encoded', () => {
+      expect(s.encodeWord('pas')).not.toBe('pas');
+    });
+
+    test('sentence with punctuation', () => {
+      const result = s.encode('Zdravo, svete!');
+      expect(result).toContain(',');
+      expect(result).toContain('!');
+    });
+
+    test('numbers unchanged', () => {
+      expect(s.encode('test 123')).toContain('123');
+    });
+
+    test('cyrillic word', () => {
+      // Земун -> Мунзе
+      expect(s.encodeWord('Земун')).toBe('Мунзе');
+    });
+
+    test('cyrillic sentence', () => {
+      const result = s.encode('Земун закон матори');
+      expect(result).toMatch(/^[А-ЯЁа-яёЂЃЄЅІЇЈЉЊЋЌЍЎЏ\s]+$/u);
+    });
+
+    test('exception brate -> tebra', () => {
+      const exc = new Satrovacki({ exceptions: { brate: 'tebra' } });
+      expect(exc.encodeWord('brate')).toBe('tebra');
+    });
+
+    test('exception case-insensitive key', () => {
+      const exc = new Satrovacki({ exceptions: { brate: 'tebra' } });
+      expect(exc.encodeWord('BRATE')).toBe('TEBRA');
+    });
+
+    test('matori unchanged (exception)', () => {
+      const exc = new Satrovacki({ exceptions: { matori: 'matori' } });
+      expect(exc.encodeWord('matori')).toBe('matori');
+    });
+
+    test('syllabic r - no vowels fallback', () => {
+      // "brk" - all consonants except r which is syllabic
+      const result = s.encodeWord('brk');
+      expect(typeof result).toBe('string');
+      expect(result.length).toBe(3);
+    });
+  });
+
+  describe('decode', () => {
+    test('decode zenba -> bazen', () => {
+      expect(s.decodeWord('zenba')).toBe('bazen');
+    });
+
+    test('decode Gradbeo -> Beograd', () => {
+      expect(s.decodeWord('Gradbeo')).toBe('Beograd');
+    });
+
+    test('roundtrip', () => {
+      const words = ['bazen', 'zemlja', 'srbija', 'kafa', 'beograd'];
+      for (const w of words) {
+        expect(s.decodeWord(s.encodeWord(w))).toBe(w);
+      }
+    });
+
+    test('cyrillic roundtrip', () => {
+      const encoded = s.encodeWord('Земун');
+      expect(s.decodeWord(encoded)).toBe('Земун');
+    });
+  });
+
+  describe('canDecodeWord', () => {
+    test('encoded word can be decoded', () => {
+      expect(s.canDecodeWord('zenba')).toBe(true);
+    });
+
+    test('short word cannot be decoded', () => {
+      expect(s.canDecodeWord('na')).toBe(false);
+    });
+  });
+
+  describe('options', () => {
+    test('custom minWordLength', () => {
+      const s4 = new Satrovacki({ minWordLength: 4 });
+      expect(s4.encodeWord('pas')).toBe('pas'); // 3 < 4
+    });
+  });
+});

package/tests/skrit.test.ts

@@ -0,0 +1,80 @@
+import { encodeText, detectMode, detectLeetBase, _deleetTextBasic } from '../src/skrit';
+import { Satrovacki } from '../src/satrovacki';
+import { Utrovacki } from '../src/utrovacki';
+
+describe('Skrit Router', () => {
+  describe('detectMode', () => {
+    test('plain text detected as satro', () => {
+      expect(detectMode('bazen voda')).toBe('satro');
+    });
+
+    test('utro encoded text detected as utro', () => {
+      // Encode some utro words first
+      const u = new Utrovacki();
+      const encoded = u.encode('bazen zemlja kafa');
+      expect(detectMode(encoded)).toBe('utro');
+    });
+  });
+
+  describe('encodeText', () => {
+    test('satro mode', () => {
+      const result = encodeText('bazen', { mode: 'satro' });
+      expect(result).toBe('zenba');
+    });
+
+    test('utro mode', () => {
+      const result = encodeText('bazen', { mode: 'utro' });
+      expect(result).toBe('uzenzabanje');
+    });
+
+    test('auto mode on plain text encodes as satro', () => {
+      const result = encodeText('bazen', { mode: 'auto' });
+      // On plain text that isn't encoded, should encode to satro
+      expect(result).toBe('zenba');
+    });
+
+    test('auto mode decodes utro', () => {
+      const u = new Utrovacki();
+      const encoded = u.encodeWord('bazen');
+      const result = encodeText(encoded, { mode: 'auto' });
+      expect(result).toBe('bazen');
+    });
+
+    test('auto mode decodes satro', () => {
+      const s = new Satrovacki();
+      const encoded = s.encodeWord('bazen');
+      const result = encodeText(encoded, { mode: 'auto', detectFrom: 'satro' });
+      expect(result).toBe('bazen');
+    });
+
+    test('leet mode', () => {
+      const result = encodeText('bazen', { mode: 'leet', leetDensity: 1.0 });
+      expect(result).not.toBe('bazen');
+    });
+  });
+
+  describe('_deleetTextBasic', () => {
+    test('reverses basic leet', () => {
+      expect(_deleetTextBasic('h3ll0')).toBe('hello');
+    });
+
+    test('4 -> a', () => {
+      expect(_deleetTextBasic('4')).toBe('a');
+    });
+
+    test('00 -> u', () => {
+      expect(_deleetTextBasic('00')).toBe('u');
+    });
+
+    test('non-leet chars unchanged', () => {
+      expect(_deleetTextBasic('xyz')).toBe('xyz');
+    });
+  });
+
+  describe('detectLeetBase', () => {
+    test('returns satro or utro', () => {
+      const base = detectLeetBase('zenba');
+      expect(['satro', 'utro']).toContain(base);
+    });
+  });
+});

package/tests/transliteration.test.ts

@@ -0,0 +1,64 @@
+import { cyrillicToLatin, latinToCyrillic, containsCyrillic } from '../src/core/transliteration';
+
+describe('Transliteration', () => {
+  describe('cyrillicToLatin', () => {
+    test('basic cyrillic to latin', () => {
+      expect(cyrillicToLatin('земун')).toBe('zemun');
+    });
+
+    test('uppercase cyrillic', () => {
+      expect(cyrillicToLatin('ЗЕМУН')).toBe('ZEMUN');
+    });
+
+    test('digraphs', () => {
+      expect(cyrillicToLatin('љ')).toBe('lj');
+      expect(cyrillicToLatin('њ')).toBe('nj');
+      expect(cyrillicToLatin('џ')).toBe('dž');
+    });
+
+    test('mixed text passes through non-cyrillic', () => {
+      expect(cyrillicToLatin('abc')).toBe('abc');
+    });
+  });
+
+  describe('latinToCyrillic', () => {
+    test('basic latin to cyrillic', () => {
+      expect(latinToCyrillic('zemun')).toBe('земун');
+    });
+
+    test('digraphs', () => {
+      expect(latinToCyrillic('lj')).toBe('љ');
+      expect(latinToCyrillic('nj')).toBe('њ');
+    });
+
+    test('plain c -> ц by default', () => {
+      expect(latinToCyrillic('c')).toBe('ц');
+    });
+
+    test('plain c -> ч with plainCTarget=ч', () => {
+      expect(latinToCyrillic('c', false, 'ч')).toBe('ч');
+    });
+
+    test('soft tj -> ć when enabled', () => {
+      expect(latinToCyrillic('tj', true)).toBe('ћ');
+    });
+
+    test('tj stays as t+j when disabled', () => {
+      expect(latinToCyrillic('tj', false)).toBe('тј');
+    });
+  });
+
+  describe('containsCyrillic', () => {
+    test('cyrillic text detected', () => {
+      expect(containsCyrillic('земун')).toBe(true);
+    });
+
+    test('latin text not detected', () => {
+      expect(containsCyrillic('zemun')).toBe(false);
+    });
+
+    test('mixed text detected', () => {
+      expect(containsCyrillic('zemун')).toBe(true);
+    });
+  });
+});

package/tests/utrovacki.test.ts

@@ -0,0 +1,83 @@
+import { Utrovacki } from '../src/utrovacki';
+
+describe('Utrovacki', () => {
+  const u = new Utrovacki();
+
+  describe('encode', () => {
+    test('bazen -> uzenzabanje', () => {
+      expect(u.encodeWord('bazen')).toBe('uzenzabanje');
+    });
+
+    test('title case', () => {
+      // Zemun: z=consonant, e=vowel at idx1, splitIdx=2 (after 'ze'), part2='mun'
+      // encoded = u + mun + za + ze + nje = 'umunzazenje' -> title -> 'Umunzazenje'
+      expect(u.encodeWord('Zemun')).toBe('Umunzazenje');
+    });
+
+    test('short word unchanged', () => {
+      expect(u.encodeWord('na')).toBe('na');
+    });
+
+    test('cyrillic', () => {
+      const result = u.encodeWord('Земун');
+      expect(result).toMatch(/^[\u0400-\u04FF]+$/u);
+    });
+
+    test('custom affixes', () => {
+      const custom = new Utrovacki({ prefix: 'ku', infix: 'ma', suffix: 'la' });
+      const result = custom.encodeWord('bazen');
+      expect(result).toContain('ku');
+      expect(result).toContain('ma');
+      expect(result).toContain('la');
+    });
+
+    test('sentence', () => {
+      const result = u.encode('bazen voda');
+      expect(result).toContain('nje');
+    });
+  });
+
+  describe('decode', () => {
+    test('decode uzenzabanje -> bazen', () => {
+      expect(u.decodeWord('uzenzabanje')).toBe('bazen');
+    });
+
+    test('roundtrip', () => {
+      const words = ['bazen', 'zemlja', 'kafa'];
+      for (const w of words) {
+        const encoded = u.encodeWord(w);
+        expect(u.decodeWord(encoded)).toBe(w);
+      }
+    });
+
+    test('cyrillic roundtrip', () => {
+      const encoded = u.encodeWord('земун');
+      expect(u.decodeWord(encoded)).toBe('земун');
+    });
+  });
+
+  describe('canDecodeWord', () => {
+    test('utro word detectable', () => {
+      expect(u.canDecodeWord('uzenzabanje')).toBe(true);
+    });
+
+    test('plain word not utro', () => {
+      expect(u.canDecodeWord('bazen')).toBe(false);
+    });
+
+    test('short word false', () => {
+      expect(u.canDecodeWord('uz')).toBe(false);
+    });
+  });
+
+  describe('_splitEncodedParts', () => {
+    test('splits correctly', () => {
+      const parts = u._splitEncodedParts('uzenzabanje');
+      expect(parts).toEqual(['ba', 'zen']);
+    });
+
+    test('invalid returns null', () => {
+      expect(u._splitEncodedParts('bazen')).toBeNull();
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}