kidscipher 0.2.0 → 0.4.0

package/dist/index.esm.js

@@ -25,7 +25,7 @@ function styleInject(css, ref) {
   }
 }
 
-var css_248z = "@font-face{font-family:Kidscipher;font-style:normal;font-weight:400;src:url(data:font/woff2;base64,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) format(\"woff2\")}";
+var css_248z = "@font-face{font-family:Kidscipher;font-style:normal;font-weight:400;src:url(data:font/woff2;base64,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) format(\"woff2\")}";
 styleInject(css_248z);
 
 var KidscipherGlyphs_1;
@@ -312,7 +312,58 @@ function requireKidscipherGlyphs () {
 	  CHINESE_Z_6: '\u{e112}',
 	  CHINESE_Z_7: '\u{e113}',
 	  CHINESE_Z_8: '\u{e114}',
-	  CHINESE_Z_9: '\u{e115}'
+	  CHINESE_Z_9: '\u{e115}',
+	  FRACTION_1_1: '\u{e116}',
+	  FRACTION_1_2: '\u{e117}',
+	  FRACTION_1_3: '\u{e118}',
+	  FRACTION_1_4: '\u{e119}',
+	  FRACTION_1_5: '\u{e11a}',
+	  FRACTION_2_1: '\u{e11b}',
+	  FRACTION_2_2: '\u{e11c}',
+	  FRACTION_2_3: '\u{e11d}',
+	  FRACTION_2_4: '\u{e11e}',
+	  FRACTION_2_5: '\u{e11f}',
+	  FRACTION_3_1: '\u{e120}',
+	  FRACTION_3_2: '\u{e121}',
+	  FRACTION_3_3: '\u{e122}',
+	  FRACTION_3_4: '\u{e123}',
+	  FRACTION_3_5: '\u{e124}',
+	  FRACTION_4_1: '\u{e125}',
+	  FRACTION_4_2: '\u{e126}',
+	  FRACTION_4_3: '\u{e127}',
+	  FRACTION_4_4: '\u{e128}',
+	  FRACTION_4_5: '\u{e129}',
+	  FRACTION_5_1: '\u{e12a}',
+	  FRACTION_5_2: '\u{e12b}',
+	  FRACTION_5_3: '\u{e12c}',
+	  FRACTION_5_4: '\u{e12d}',
+	  FRACTION_5_5: '\u{e12e}',
+	  SMALL_CROSS_A: '\u{e12f}',
+	  SMALL_CROSS_B: '\u{e130}',
+	  SMALL_CROSS_C: '\u{e131}',
+	  SMALL_CROSS_D: '\u{e132}',
+	  SMALL_CROSS_E: '\u{e133}',
+	  SMALL_CROSS_F: '\u{e134}',
+	  SMALL_CROSS_G: '\u{e135}',
+	  SMALL_CROSS_H: '\u{e136}',
+	  SMALL_CROSS_I: '\u{e137}',
+	  SMALL_CROSS_J: '\u{e138}',
+	  SMALL_CROSS_K: '\u{e139}',
+	  SMALL_CROSS_L: '\u{e13a}',
+	  SMALL_CROSS_M: '\u{e13b}',
+	  SMALL_CROSS_N: '\u{e13c}',
+	  SMALL_CROSS_O: '\u{e13d}',
+	  SMALL_CROSS_P: '\u{e13e}',
+	  SMALL_CROSS_Q: '\u{e13f}',
+	  SMALL_CROSS_R: '\u{e140}',
+	  SMALL_CROSS_S: '\u{e141}',
+	  SMALL_CROSS_T: '\u{e142}',
+	  SMALL_CROSS_U: '\u{e143}',
+	  SMALL_CROSS_V: '\u{e144}',
+	  SMALL_CROSS_W: '\u{e145}',
+	  SMALL_CROSS_X: '\u{e146}',
+	  SMALL_CROSS_Y: '\u{e147}',
+	  SMALL_CROSS_Z: '\u{e148}'
 	});
 	KidscipherGlyphs_1 = { KidscipherGlyphs };
 	return KidscipherGlyphs_1;
@@ -320,12 +371,71 @@ function requireKidscipherGlyphs () {
 
 var KidscipherGlyphsExports = requireKidscipherGlyphs();
 
+const ignoreCasingSensitive = (caseSensitive) => {
+    return (text) => (caseSensitive ? text : text.toUpperCase());
+};
+const casing = (casingOption) => {
+    return (text) => {
+        switch (casingOption) {
+            case 'upper':
+                return text.toUpperCase();
+            case 'lower':
+                return text.toLowerCase();
+            case 'original':
+                return text;
+            default:
+                throw new Error(`Invalid output casing option: ${casingOption}`);
+        }
+    };
+};
+const normalizeDiacritics = (normalize) => {
+    return (text) => {
+        return normalize
+            ? text
+                // normalize Unicode chars (etc. "é" → "e" + "´")
+                .normalize('NFD')
+                // remove diacritic symbols
+                .replace(/[\u0300-\u036f]/g, '')
+                // exceptions which are normally not normalized
+                .replace(/ß/g, 'ss')
+                .replace(/ø/g, 'o')
+                .replace(/Ø/g, 'O')
+                .replace(/đ/g, 'd')
+                .replace(/Đ/g, 'D')
+                .replace(/ł/g, 'l')
+                .replace(/Ł/g, 'L')
+                .replace(/æ/g, 'ae')
+                .replace(/Æ/g, 'AE')
+                .replace(/œ/g, 'oe')
+                .replace(/Œ/g, 'OE')
+                .replace(/ð/g, 'd')
+                .replace(/Ð/g, 'D')
+                .replace(/þ/g, 'th')
+                .replace(/Þ/g, 'Th')
+                .replace(/ñ/g, 'n')
+                .replace(/Ñ/g, 'N')
+            : text;
+    };
+};
+const Processor = {
+    ignoreCasingSensitive,
+    casing,
+    normalizeDiacritics,
+};
+
+const processingPipeline = (text, processors) => {
+    return processors.reduce((acc, processor) => processor(acc), text);
+};
+
 class Cipher {
     encode(input, configuration, opts) {
-        const { caseSensitive = false, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = '///', } = opts?.input || {};
+        const { caseSensitive = false, normalizeDiacritics = true, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = '///', } = opts?.input || {};
         const { casing = 'original', letterSeparator: outputLetterSeparator = '', wordSeparator: outputWordSeparator = ' ', } = opts?.output || {};
+        const preprocessedInput = processingPipeline(input, [
+            Processor.normalizeDiacritics(normalizeDiacritics),
+        ]);
         // normalize input into words and letters
-        const words = input.split(inputWordSeparator);
+        const words = preprocessedInput.split(inputWordSeparator);
         const encodedWords = words.map((word) => {
             const letters = inputLetterSeparator
                 ? word.split(inputLetterSeparator)
@@ -348,10 +458,13 @@ class Cipher {
         return encodedWords.join(outputWordSeparator);
     }
     decode(input, configuration, opts) {
-        const { caseSensitive = false, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = ' ', } = opts?.input || {};
+        const { caseSensitive = false, normalizeDiacritics = false, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = ' ', } = opts?.input || {};
         const { casing = 'original', letterSeparator: outputLetterSeparator = '', wordSeparator: outputWordSeparator = ' ', } = opts?.output || {};
+        const preprocessedInput = processingPipeline(input, [
+            Processor.normalizeDiacritics(normalizeDiacritics),
+        ]);
         // split encoded text into words
-        const words = input.split(inputWordSeparator);
+        const words = preprocessedInput.split(inputWordSeparator);
         const decodedWords = words.map((word) => {
             const symbols = word.split(inputLetterSeparator);
             return symbols
@@ -392,6 +505,7 @@ function withDefaultCipherOptions(opts, defaults) {
     return {
         input: {
             caseSensitive: false,
+            normalizeDiacritics: false,
             letterSeparator: '',
             wordSeparator: ' ',
             ...defaults?.input,
@@ -506,6 +620,209 @@ MorseCodeCipher.MORSE_CODE_MAP = {
     '9': '----.',
 };
 
+class MobileCipher extends SubstitutionCipher {
+    constructor() {
+        super(MobileCipher.MOBILE_KEYPAD_MAP);
+    }
+    encode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'original',
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
+            },
+        });
+        return super.encode(input, configuration, mergedOpts);
+    }
+    decode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
+            },
+            output: {
+                casing: 'lower',
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+        });
+        return super.decode(input, configuration, mergedOpts);
+    }
+}
+MobileCipher.MOBILE_KEYPAD_MAP = {
+    A: '2',
+    B: '22',
+    C: '222',
+    D: '3',
+    E: '33',
+    F: '333',
+    G: '4',
+    H: '44',
+    I: '444',
+    J: '5',
+    K: '55',
+    L: '555',
+    M: '6',
+    N: '66',
+    O: '666',
+    P: '7',
+    Q: '77',
+    R: '777',
+    S: '7777',
+    T: '8',
+    U: '88',
+    V: '888',
+    W: '9',
+    X: '99',
+    Y: '999',
+    Z: '9999',
+};
+
+class SubstitutionCyclicCipher extends Cipher {
+    constructor(encodeMap) {
+        super();
+        this.resetCounters = () => {
+            for (const key of Object.keys(this.encodeMap)) {
+                this.counters[key] = 0;
+            }
+        };
+        // chech encodeMap
+        this.encodeMap = Object.fromEntries(Object.entries(encodeMap).map(([key, value]) => [
+            key,
+            Array.isArray(value) ? value : [value],
+        ]));
+        // decode map
+        this.decodeMap = {};
+        for (const [key, values] of Object.entries(this.encodeMap)) {
+            for (const val of values) {
+                this.decodeMap[val] = key;
+            }
+        }
+        // inialization counters
+        this.counters = {};
+        this.resetCounters();
+    }
+    encodeToken(token) {
+        const options = this.encodeMap[token];
+        if (!options || options.length === 0)
+            return '';
+        const index = this.counters[token] % options.length; // cyclic
+        this.counters[token] += 1;
+        return options[index];
+    }
+    encode(input, configuration, opts) {
+        const value = super.encode(input, configuration, opts);
+        this.resetCounters();
+        return value;
+    }
+    decodeToken(token) {
+        return this.decodeMap[token] ?? '';
+    }
+}
+
+class SpiderCipher extends SubstitutionCyclicCipher {
+    constructor() {
+        super(SpiderCipher.SPIDER_MAP);
+    }
+    encode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'upper',
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
+            },
+        });
+        return super.encode(input, configuration, mergedOpts);
+    }
+    decode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
+            },
+            output: {
+                casing: 'lower',
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+        });
+        return super.decode(input, configuration, mergedOpts);
+    }
+}
+SpiderCipher.SPIDER_MAP = {
+    A: ['BC', 'JX'],
+    B: ['AC', 'EH'],
+    C: ['AB', 'OZ'],
+    D: ['EF', 'KT'],
+    E: ['BH', 'DF'],
+    F: ['DE', 'NV'],
+    G: ['HI', 'LP'],
+    H: ['BE', 'GI'],
+    I: ['GH', 'MS'],
+    J: ['AX', 'KL'],
+    K: ['DT', 'JL'],
+    L: ['GP', 'JK'],
+    M: ['IS', 'NO'],
+    N: ['FV', 'MO'],
+    O: ['CZ', 'MN'],
+    P: ['GL', 'RS'],
+    // Q: ["Q"],    // cipher can't Q
+    R: ['PS', 'UY'],
+    S: ['IM', 'PR'],
+    T: ['DK', 'UV'],
+    U: ['TV', 'RY'],
+    V: ['FN', 'TU'],
+    // W: ["W"],    // cipher can't W
+    X: ['AJ', 'YZ'],
+    Y: ['RU', 'XZ'],
+    Z: ['CO', 'XY'],
+};
+
+class FractionCipher extends SubstitutionCipher {
+    constructor() {
+        super(FractionCipher.FRACTION_MAP);
+    }
+}
+FractionCipher.FRACTION_MAP = {
+    A: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_1,
+    B: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_2,
+    C: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_3,
+    D: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_4,
+    E: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_5,
+    F: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_1,
+    G: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_2,
+    H: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_3,
+    I: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_4,
+    J: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_5,
+    K: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_1,
+    L: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_2,
+    M: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_3,
+    N: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_4,
+    O: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_5,
+    P: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_1,
+    Q: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_2,
+    R: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_3,
+    S: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_4,
+    T: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_5,
+    U: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_1,
+    V: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_2,
+    X: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_3,
+    Y: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_4,
+    Z: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_5,
+};
+
 class PolandCrossCipher extends SubstitutionCipher {
     constructor() {
         super(PolandCrossCipher.POLAND_CROSS_MAP);
@@ -541,92 +858,336 @@ PolandCrossCipher.POLAND_CROSS_MAP = {
     Z: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_Z,
 };
 
+class SmallCrossCipher extends SubstitutionCipher {
+    constructor() {
+        super(SmallCrossCipher.SMALL_CROSS_MAP);
+    }
+}
+SmallCrossCipher.SMALL_CROSS_MAP = {
+    A: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_A,
+    B: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_B,
+    C: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_C,
+    D: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_D,
+    E: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_E,
+    F: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_F,
+    G: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_G,
+    H: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_H,
+    I: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_I,
+    J: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_J,
+    K: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_K,
+    L: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_L,
+    M: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_M,
+    N: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_N,
+    O: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_O,
+    P: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_P,
+    Q: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_Q,
+    R: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_R,
+    S: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_S,
+    T: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_T,
+    U: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_U,
+    V: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_V,
+    W: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_W,
+    X: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_X,
+    Y: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_Y,
+    Z: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_Z,
+};
+
+class ChineseCipher extends SubstitutionCyclicCipher {
+    static generateMap() {
+        const map = {};
+        // considering that chinese symbol have this format CHINESE_<LETTER>_<NUMBER>
+        for (const key of Object.keys(KidscipherGlyphsExports.KidscipherGlyphs)) {
+            const match = key.match(/^CHINESE_([A-Z])_\d+$/);
+            if (match) {
+                const letter = match[1];
+                if (!map[letter])
+                    map[letter] = [];
+                map[letter].push(KidscipherGlyphsExports.KidscipherGlyphs[key]);
+            }
+        }
+        return map;
+    }
+    constructor() {
+        super(ChineseCipher.CHINESE_MAP);
+    }
+}
+ChineseCipher.CHINESE_MAP = ChineseCipher.generateMap();
+
 class ShiftCipher extends Cipher {
-    constructor(baseAlphabet, rotors) {
+    constructor(alphabet) {
         super();
-        // Check all alphabets have the same length
-        for (const alpha of rotors) {
-            if (alpha.length !== baseAlphabet.length) {
-                throw new Error('All alphabets must have the same length');
+        this.alphabet = alphabet;
+    }
+    encodeToken(token, configuration) {
+        const { shift, outputAsIndex, inputAsIndex } = configuration;
+        let index;
+        if (inputAsIndex) {
+            index = parseInt(token, 10);
+            if (isNaN(index) || index < 0 || index >= this.alphabet.length) {
+                return token; // invalid index
             }
         }
+        else {
+            if (!this.alphabet.includes(token))
+                return ''; // invalid token
+            index = this.alphabet.indexOf(token);
+        }
+        const shiftedIndex = (index + shift) % this.alphabet.length;
+        return outputAsIndex
+            ? shiftedIndex.toString()
+            : this.alphabet[shiftedIndex];
+    }
+    decodeToken(token, configuration) {
+        const { shift, inputAsIndex, outputAsIndex } = configuration;
+        let index;
+        if (inputAsIndex) {
+            index = parseInt(token, 10);
+            if (isNaN(index) || index < 0 || index >= this.alphabet.length) {
+                return ''; // invalid index
+            }
+        }
+        else {
+            if (!this.alphabet.includes(token))
+                return ''; // invalid token
+            index = this.alphabet.indexOf(token);
+        }
+        const shiftedIndex = (index - shift + this.alphabet.length) % this.alphabet.length;
+        return outputAsIndex
+            ? shiftedIndex.toString()
+            : this.alphabet[shiftedIndex];
+    }
+    getAllTokenIndexes(token, shift) {
+        if (!this.alphabet.includes(token))
+            return []; // invalid token
+        const indexes = this.alphabet.flatMap((ch, i) => ch === token
+            ? [(i - shift + this.alphabet.length) % this.alphabet.length]
+            : []);
+        return indexes;
+    }
+    encode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: { caseSensitive: false, letterSeparator: '', wordSeparator: ' ' },
+            output: { casing: 'original', letterSeparator: '', wordSeparator: ' ' },
+        });
+        return super.encode(input, configuration, mergedOpts);
+    }
+    decode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: { caseSensitive: false, letterSeparator: '', wordSeparator: ' ' },
+            output: { casing: 'original', letterSeparator: '', wordSeparator: ' ' },
+        });
+        return super.decode(input, configuration, mergedOpts);
+    }
+}
+
+class ShiftAlphabetCipher extends ShiftCipher {
+    constructor() {
+        super(ShiftAlphabetCipher.DEFAULT_ALPHABET);
+    }
+}
+ShiftAlphabetCipher.DEFAULT_ALPHABET = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+];
+
+class ShiftRotorCipher extends Cipher {
+    constructor(baseAlphabet, rotors) {
+        super();
+        if (rotors.length === 0)
+            throw new Error('At least one rotor is required');
         this.baseAlphabet = baseAlphabet;
         this.rotors = rotors;
     }
     encodeToken(token, configuration) {
-        const { shifts } = configuration;
-        let encoded = '';
-        if (this.baseAlphabet.includes(token)) {
-            const index = this.baseAlphabet.indexOf(token);
-            for (let i = 0; i < this.rotors.length; i++) {
-                const wheel = this.rotors[i];
-                const shiftedIndex = (index + shifts[i]) % wheel.length;
-                encoded += wheel[shiftedIndex];
-            }
+        const { shifts = [], outputAsIndex, inputAsIndex } = configuration;
+        let results = [];
+        let lastSymbol = token;
+        const baseSymbolIndex = this.baseAlphabet.encodeToken(lastSymbol, {
+            shift: 0,
+            inputAsIndex: false,
+            outputAsIndex: true,
+        });
+        for (let i = 0; i < this.rotors.length; i++) {
+            const rotor = this.rotors[i];
+            const shift = shifts[i % shifts.length] ?? 0;
+            lastSymbol = rotor.encodeToken(baseSymbolIndex, {
+                shift,
+                inputAsIndex: true,
+                outputAsIndex: false,
+            });
+            results.push(lastSymbol);
         }
-        return encoded;
+        // we need to reverse it
+        return results.reverse().join('');
+    }
+    decodeToken(token, configuration) {
+        const { shifts = [], outputAsIndex, inputAsIndex } = configuration;
+        const symbols = token.split('').reverse();
+        if (symbols.length != this.rotors.length) {
+            throw new Error('Invalid symbol length');
+        }
+        let includesIn = [];
+        // Reverse through rotors for decoding
+        for (let i = this.rotors.length - 1; i >= 0; i--) {
+            const rotor = this.rotors[i];
+            const shift = shifts[i % shifts.length] ?? 0;
+            const symbol = symbols[i];
+            const ocurencies = rotor.getAllTokenIndexes(symbol, shift);
+            includesIn.push(ocurencies);
+        }
+        // Find intersection of all arrays (items common to all rotors)
+        const intersection = includesIn.reduce((acc, arr) => acc.filter((x) => arr.includes(x)));
+        // If there is exactly one common index, decode it
+        if (intersection.length !== 1) {
+            throw new Error(`Invalid decoding — intersection size is ${intersection.length}`);
+        }
+        const finalIndex = intersection[0];
+        const result = this.baseAlphabet.decodeToken(finalIndex.toString(), {
+            shift: 0,
+            inputAsIndex: true,
+            outputAsIndex: outputAsIndex,
+        });
+        return result;
     }
     encode(input, configuration, opts) {
         const mergedOpts = withDefaultCipherOptions(opts, {
-            input: {
-                caseSensitive: false,
-                letterSeparator: '',
-                wordSeparator: ' ',
-            },
+            input: { caseSensitive: false, letterSeparator: '', wordSeparator: ' ' },
             output: {
                 casing: 'original',
-                letterSeparator: '',
-                wordSeparator: ' ',
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
             },
         });
         return super.encode(input, configuration, mergedOpts);
     }
-    decodeToken(token, configuration) {
-        const { shifts } = configuration;
-        let encoded = '';
-        if (token.length === this.rotors.length) {
-            let currentIndex = -1;
-            for (let i = this.rotors.length - 1; 0 <= i; i--) {
-                if (this.rotors[i].includes(token[i])) {
-                    currentIndex = this.rotors[i].indexOf(token[i]);
-                    currentIndex =
-                        (currentIndex - shifts[i] + this.baseAlphabet.length) %
-                            this.baseAlphabet.length;
-                }
-                else {
-                    // invalid token
-                    return '';
-                }
-            }
-            encoded = this.baseAlphabet[currentIndex];
-        }
-        return encoded;
-    }
     decode(input, configuration, opts) {
         const mergedOpts = withDefaultCipherOptions(opts, {
             input: {
                 caseSensitive: false,
-                letterSeparator: '',
-                wordSeparator: ' ',
-            },
-            output: {
-                casing: 'original',
-                letterSeparator: '',
-                wordSeparator: ' ',
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
             },
+            output: { casing: 'original', letterSeparator: '', wordSeparator: ' ' },
         });
         return super.decode(input, configuration, mergedOpts);
     }
 }
 
-class ShiftAlphabetCipher extends ShiftCipher {
-    constructor(alphabet) {
-        if (!alphabet) {
-            alphabet = ShiftAlphabetCipher.DEFAULT_ALPHABET;
+class ShiftRotorABCDCipher extends ShiftRotorCipher {
+    constructor() {
+        const rotors = [];
+        const baseAlphabet = new ShiftCipher(ShiftRotorABCDCipher.BASE_ALPHABET);
+        for (let i = 0; i < ShiftRotorABCDCipher.ROTOR_ALPHABETS.length; i++) {
+            rotors.push(new ShiftCipher(ShiftRotorABCDCipher.ROTOR_ALPHABETS[i]));
+        }
+        super(baseAlphabet, rotors);
+    }
+}
+ShiftRotorABCDCipher.BASE_ALPHABET = [
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+];
+ShiftRotorABCDCipher.REPEAT_ALPHABET = ['A', 'B', 'C', 'D'];
+ShiftRotorABCDCipher.generateRepeatRotorAlphabet = (repeatAlphabet, repeat) => {
+    let output = [];
+    while (output.length < ShiftRotorABCDCipher.BASE_ALPHABET.length) {
+        for (let i = 0; i < repeatAlphabet.length; i++) {
+            for (let k = 0; k < repeat; k++) {
+                output.push(repeatAlphabet[i]);
+            }
         }
-        super(alphabet, [alphabet]);
     }
-    encode(input, { shift }, opts) {
+    return output;
+};
+ShiftRotorABCDCipher.ROTOR_ALPHABETS = [
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 1),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 3),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 9),
+];
+
+class Substitution2DCipher extends SubstitutionCyclicCipher {
+    constructor(alphabet, horizontalKey, verticalKey) {
+        // Validation checks
+        if (alphabet.length !== verticalKey.length) {
+            throw new Error(`Alphabet row count (${alphabet.length}) must match verticalKey length (${verticalKey.length})`);
+        }
+        for (const [rowIndex, row] of alphabet.entries()) {
+            if (row.length !== horizontalKey.length) {
+                throw new Error(`Alphabet column count in row ${rowIndex} (${row.length}) must match horizontalKey length (${horizontalKey.length})`);
+            }
+        }
+        const encodeMap = {};
+        // Build the coordinate map
+        for (const [rowIndex, rowKey] of verticalKey.entries()) {
+            for (const [colIndex, colKey] of horizontalKey.entries()) {
+                const value = alphabet[rowIndex][colIndex];
+                const coord = `${rowKey}${colKey}`;
+                if (!encodeMap[value])
+                    encodeMap[value] = [];
+                encodeMap[value].push(coord);
+            }
+        }
+        super(encodeMap);
+    }
+    encode(input, configuration, opts) {
         const mergedOpts = withDefaultCipherOptions(opts, {
             input: {
                 caseSensitive: false,
@@ -635,29 +1196,71 @@ class ShiftAlphabetCipher extends ShiftCipher {
             },
             output: {
                 casing: 'original',
-                letterSeparator: '',
-                wordSeparator: ' ',
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
             },
         });
-        return super.encode(input, { shifts: [shift] }, mergedOpts);
+        return super.encode(input, configuration, mergedOpts);
     }
-    decode(input, { shift }, opts) {
+    decode(input, configuration, opts) {
         const mergedOpts = withDefaultCipherOptions(opts, {
             input: {
-                caseSensitive: false,
-                letterSeparator: '',
-                wordSeparator: ' ',
+                caseSensitive: true,
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
             },
             output: {
-                casing: 'original',
+                casing: 'lower',
                 letterSeparator: '',
                 wordSeparator: ' ',
             },
         });
-        return super.decode(input, { shifts: [shift] }, mergedOpts);
+        return super.decode(input, configuration, mergedOpts);
     }
 }
-ShiftAlphabetCipher.DEFAULT_ALPHABET = [
+
+class TableKeyFiveToFiveCipher extends Substitution2DCipher {
+    constructor(horizontalKey, verticalKey) {
+        super(TableKeyFiveToFiveCipher.ALPHABET, horizontalKey, verticalKey);
+    }
+}
+TableKeyFiveToFiveCipher.ALPHABET = [
+    ['A', 'B', 'C', 'D', 'E'],
+    ['F', 'G', 'H', 'I', 'J'],
+    ['K', 'L', 'M', 'N', 'O'],
+    ['P', 'R', 'S', 'T', 'U'],
+    ['V', 'W', 'X', 'Y', 'Z'],
+];
+
+class ChessCipher extends Substitution2DCipher {
+    constructor(height, width) {
+        const totalCells = height * width;
+        if (totalCells < ChessCipher.BASE_ALPHABET.length) {
+            throw new Error(`Invalid board size: ${height}x${width} = ${totalCells} cells, but alphabet requires at least ${ChessCipher.BASE_ALPHABET.length} cells.`);
+        }
+        // horizontal key (rows 1, 2, 3, …)
+        const horizontalKey = [];
+        for (let i = 0; i < width; i++) {
+            horizontalKey.push((i + 1).toString());
+        }
+        // vertical key (columns A, B, C, …)
+        const verticalKey = [];
+        for (let i = 0; i < height; i++) {
+            verticalKey.push(String.fromCharCode('A'.charCodeAt(0) + i));
+        }
+        // create 2D table
+        const encodeAlphabet2D = [];
+        for (let row = 0; row < height; row++) {
+            encodeAlphabet2D[row] = [];
+            for (let col = 0; col < width; col++) {
+                const index = (row * width + col) % ChessCipher.BASE_ALPHABET.length; // repeat alphabet
+                encodeAlphabet2D[row][col] = ChessCipher.BASE_ALPHABET[index];
+            }
+        }
+        super(encodeAlphabet2D, horizontalKey, verticalKey);
+    }
+}
+ChessCipher.BASE_ALPHABET = [
     'A',
     'B',
     'C',
@@ -684,61 +1287,16 @@ ShiftAlphabetCipher.DEFAULT_ALPHABET = [
     'X',
     'Y',
     'Z',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
 ];
 
-class SubstitutionCyclicCipher extends Cipher {
-    constructor(encodeMap) {
-        super();
-        // chech encodeMap
-        this.encodeMap = Object.fromEntries(Object.entries(encodeMap).map(([key, value]) => [
-            key,
-            Array.isArray(value) ? value : [value],
-        ]));
-        // decode map
-        this.decodeMap = {};
-        for (const [key, values] of Object.entries(this.encodeMap)) {
-            for (const val of values) {
-                this.decodeMap[val] = key;
-            }
-        }
-        // inialization counters
-        this.counters = {};
-        for (const key of Object.keys(this.encodeMap)) {
-            this.counters[key] = 0;
-        }
-    }
-    encodeToken(token) {
-        const options = this.encodeMap[token];
-        if (!options || options.length === 0)
-            return '';
-        const index = this.counters[token] % options.length; // cyclic
-        this.counters[token] += 1;
-        return options[index];
-    }
-    decodeToken(token) {
-        return this.decodeMap[token] ?? '';
-    }
-}
-
-class ChineseCipher extends SubstitutionCyclicCipher {
-    static generateMap() {
-        const map = {};
-        // considering that chinese symbol have this format CHINESE_<LETTER>_<NUMBER>
-        for (const key of Object.keys(KidscipherGlyphsExports.KidscipherGlyphs)) {
-            const match = key.match(/^CHINESE_([A-Z])_\d+$/);
-            if (match) {
-                const letter = match[1];
-                if (!map[letter])
-                    map[letter] = [];
-                map[letter].push(KidscipherGlyphsExports.KidscipherGlyphs[key]);
-            }
-        }
-        return map;
-    }
-    constructor() {
-        super(ChineseCipher.CHINESE_MAP);
-    }
-}
-ChineseCipher.CHINESE_MAP = ChineseCipher.generateMap();
-
-export { ChineseCipher, Cipher, MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, SubstitutionCipher };
+export { ChessCipher, ChineseCipher, Cipher, FractionCipher, MobileCipher, MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, ShiftRotorABCDCipher, SmallCrossCipher, SpiderCipher, Substitution2DCipher, SubstitutionCipher, TableKeyFiveToFiveCipher };