kidscipher 0.2.0 → 0.3.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,32 @@ 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}'
 	});
 	KidscipherGlyphs_1 = { KidscipherGlyphs };
 	return KidscipherGlyphs_1;
@@ -320,12 +345,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 +432,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 +479,7 @@ function withDefaultCipherOptions(opts, defaults) {
     return {
         input: {
             caseSensitive: false,
+            normalizeDiacritics: false,
             letterSeparator: '',
             wordSeparator: ' ',
             ...defaults?.input,
@@ -506,6 +594,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,123 +832,222 @@ PolandCrossCipher.POLAND_CROSS_MAP = {
     Z: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_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
             }
         }
-        this.baseAlphabet = baseAlphabet;
-        this.rotors = rotors;
+        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];
     }
-    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];
+    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
             }
         }
-        return encoded;
+        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: ' ',
-            },
+            input: { caseSensitive: false, letterSeparator: '', wordSeparator: ' ' },
+            output: { casing: 'original', 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: ' ',
-            },
+            input: { caseSensitive: false, 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;
+    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 = [], 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);
+        }
+        // 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);
         }
-        super(alphabet, [alphabet]);
+        // 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, { shift }, opts) {
+    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, { 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: ' ',
-            },
-            output: {
-                casing: 'original',
-                letterSeparator: '',
-                wordSeparator: ' ',
+                letterSeparator: ' ',
+                wordSeparator: ' | ',
             },
+            output: { casing: 'original', letterSeparator: '', wordSeparator: ' ' },
         });
-        return super.decode(input, { shifts: [shift] }, mergedOpts);
+        return super.decode(input, configuration, mergedOpts);
     }
 }
-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',
@@ -684,61 +1074,33 @@ 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]);
+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]);
             }
         }
-        return map;
-    }
-    constructor() {
-        super(ChineseCipher.CHINESE_MAP);
     }
-}
-ChineseCipher.CHINESE_MAP = ChineseCipher.generateMap();
+    return output;
+};
+ShiftRotorABCDCipher.ROTOR_ALPHABETS = [
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 1),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 3),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 9),
+];
 
-export { ChineseCipher, Cipher, MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, SubstitutionCipher };
+export { ChineseCipher, Cipher, FractionCipher, MobileCipher, MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, ShiftRotorABCDCipher, SpiderCipher, SubstitutionCipher };