kidscipher 0.1.0 → 0.3.0

package/dist/index.esm.js

@@ -25,15 +25,391 @@ function styleInject(css, ref) {
   }
 }
 
-var css_248z = "@import './Kidscipher.css';\r\n";
+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;
+var hasRequiredKidscipherGlyphs;
+
+function requireKidscipherGlyphs () {
+	if (hasRequiredKidscipherGlyphs) return KidscipherGlyphs_1;
+	hasRequiredKidscipherGlyphs = 1;
+	// Auto-generated by generate-font
+	const KidscipherGlyphs = Object.freeze({
+	  POLAND_CROSS_A: '\u{e001}',
+	  POLAND_CROSS_B: '\u{e002}',
+	  POLAND_CROSS_C: '\u{e003}',
+	  POLAND_CROSS_CH: '\u{e004}',
+	  POLAND_CROSS_D: '\u{e005}',
+	  POLAND_CROSS_E: '\u{e006}',
+	  POLAND_CROSS_F: '\u{e007}',
+	  POLAND_CROSS_G: '\u{e008}',
+	  POLAND_CROSS_H: '\u{e009}',
+	  POLAND_CROSS_I: '\u{e00a}',
+	  POLAND_CROSS_J: '\u{e00b}',
+	  POLAND_CROSS_K: '\u{e00c}',
+	  POLAND_CROSS_L: '\u{e00d}',
+	  POLAND_CROSS_M: '\u{e00e}',
+	  POLAND_CROSS_N: '\u{e00f}',
+	  POLAND_CROSS_O: '\u{e010}',
+	  POLAND_CROSS_P: '\u{e011}',
+	  POLAND_CROSS_Q: '\u{e012}',
+	  POLAND_CROSS_R: '\u{e013}',
+	  POLAND_CROSS_S: '\u{e014}',
+	  POLAND_CROSS_T: '\u{e015}',
+	  POLAND_CROSS_U: '\u{e016}',
+	  POLAND_CROSS_V: '\u{e017}',
+	  POLAND_CROSS_W: '\u{e018}',
+	  POLAND_CROSS_X: '\u{e019}',
+	  POLAND_CROSS_Y: '\u{e01a}',
+	  POLAND_CROSS_Z: '\u{e01b}',
+	  CHINESE_A_1: '\u{e01c}',
+	  CHINESE_A_10: '\u{e01d}',
+	  CHINESE_A_2: '\u{e01e}',
+	  CHINESE_A_3: '\u{e01f}',
+	  CHINESE_A_4: '\u{e020}',
+	  CHINESE_A_5: '\u{e021}',
+	  CHINESE_A_6: '\u{e022}',
+	  CHINESE_A_7: '\u{e023}',
+	  CHINESE_A_8: '\u{e024}',
+	  CHINESE_A_9: '\u{e025}',
+	  CHINESE_B_1: '\u{e026}',
+	  CHINESE_B_10: '\u{e027}',
+	  CHINESE_B_2: '\u{e028}',
+	  CHINESE_B_3: '\u{e029}',
+	  CHINESE_B_4: '\u{e02a}',
+	  CHINESE_B_5: '\u{e02b}',
+	  CHINESE_B_6: '\u{e02c}',
+	  CHINESE_B_7: '\u{e02d}',
+	  CHINESE_B_8: '\u{e02e}',
+	  CHINESE_B_9: '\u{e02f}',
+	  CHINESE_C_1: '\u{e030}',
+	  CHINESE_C_10: '\u{e031}',
+	  CHINESE_C_2: '\u{e032}',
+	  CHINESE_C_3: '\u{e033}',
+	  CHINESE_C_4: '\u{e034}',
+	  CHINESE_C_5: '\u{e035}',
+	  CHINESE_C_6: '\u{e036}',
+	  CHINESE_C_7: '\u{e037}',
+	  CHINESE_C_8: '\u{e038}',
+	  CHINESE_C_9: '\u{e039}',
+	  CHINESE_D_1: '\u{e03a}',
+	  CHINESE_D_10: '\u{e03b}',
+	  CHINESE_D_2: '\u{e03c}',
+	  CHINESE_D_3: '\u{e03d}',
+	  CHINESE_D_4: '\u{e03e}',
+	  CHINESE_D_5: '\u{e03f}',
+	  CHINESE_D_6: '\u{e040}',
+	  CHINESE_D_7: '\u{e041}',
+	  CHINESE_D_8: '\u{e042}',
+	  CHINESE_D_9: '\u{e043}',
+	  CHINESE_E_1: '\u{e044}',
+	  CHINESE_E_10: '\u{e045}',
+	  CHINESE_E_2: '\u{e046}',
+	  CHINESE_E_3: '\u{e047}',
+	  CHINESE_E_4: '\u{e048}',
+	  CHINESE_E_5: '\u{e049}',
+	  CHINESE_E_6: '\u{e04a}',
+	  CHINESE_E_7: '\u{e04b}',
+	  CHINESE_E_8: '\u{e04c}',
+	  CHINESE_E_9: '\u{e04d}',
+	  CHINESE_F_1: '\u{e04e}',
+	  CHINESE_F_10: '\u{e04f}',
+	  CHINESE_F_2: '\u{e050}',
+	  CHINESE_F_3: '\u{e051}',
+	  CHINESE_F_4: '\u{e052}',
+	  CHINESE_F_5: '\u{e053}',
+	  CHINESE_F_6: '\u{e054}',
+	  CHINESE_F_7: '\u{e055}',
+	  CHINESE_F_8: '\u{e056}',
+	  CHINESE_F_9: '\u{e057}',
+	  CHINESE_G_1: '\u{e058}',
+	  CHINESE_G_10: '\u{e059}',
+	  CHINESE_G_2: '\u{e05a}',
+	  CHINESE_G_3: '\u{e05b}',
+	  CHINESE_G_4: '\u{e05c}',
+	  CHINESE_G_5: '\u{e05d}',
+	  CHINESE_G_6: '\u{e05e}',
+	  CHINESE_G_7: '\u{e05f}',
+	  CHINESE_G_8: '\u{e060}',
+	  CHINESE_G_9: '\u{e061}',
+	  CHINESE_H_1: '\u{e062}',
+	  CHINESE_H_10: '\u{e063}',
+	  CHINESE_H_2: '\u{e064}',
+	  CHINESE_H_3: '\u{e065}',
+	  CHINESE_H_4: '\u{e066}',
+	  CHINESE_H_5: '\u{e067}',
+	  CHINESE_H_6: '\u{e068}',
+	  CHINESE_H_7: '\u{e069}',
+	  CHINESE_H_8: '\u{e06a}',
+	  CHINESE_H_9: '\u{e06b}',
+	  CHINESE_I_1: '\u{e06c}',
+	  CHINESE_I_10: '\u{e06d}',
+	  CHINESE_I_2: '\u{e06e}',
+	  CHINESE_I_3: '\u{e06f}',
+	  CHINESE_I_4: '\u{e070}',
+	  CHINESE_I_5: '\u{e071}',
+	  CHINESE_I_6: '\u{e072}',
+	  CHINESE_I_7: '\u{e073}',
+	  CHINESE_I_8: '\u{e074}',
+	  CHINESE_I_9: '\u{e075}',
+	  CHINESE_J_1: '\u{e076}',
+	  CHINESE_J_10: '\u{e077}',
+	  CHINESE_J_2: '\u{e078}',
+	  CHINESE_J_3: '\u{e079}',
+	  CHINESE_J_4: '\u{e07a}',
+	  CHINESE_J_5: '\u{e07b}',
+	  CHINESE_J_6: '\u{e07c}',
+	  CHINESE_J_7: '\u{e07d}',
+	  CHINESE_J_8: '\u{e07e}',
+	  CHINESE_J_9: '\u{e07f}',
+	  CHINESE_K_1: '\u{e080}',
+	  CHINESE_K_10: '\u{e081}',
+	  CHINESE_K_2: '\u{e082}',
+	  CHINESE_K_3: '\u{e083}',
+	  CHINESE_K_4: '\u{e084}',
+	  CHINESE_K_5: '\u{e085}',
+	  CHINESE_K_6: '\u{e086}',
+	  CHINESE_K_7: '\u{e087}',
+	  CHINESE_K_8: '\u{e088}',
+	  CHINESE_K_9: '\u{e089}',
+	  CHINESE_L_1: '\u{e08a}',
+	  CHINESE_L_10: '\u{e08b}',
+	  CHINESE_L_2: '\u{e08c}',
+	  CHINESE_L_3: '\u{e08d}',
+	  CHINESE_L_4: '\u{e08e}',
+	  CHINESE_L_5: '\u{e08f}',
+	  CHINESE_L_6: '\u{e090}',
+	  CHINESE_L_7: '\u{e091}',
+	  CHINESE_L_8: '\u{e092}',
+	  CHINESE_L_9: '\u{e093}',
+	  CHINESE_M_1: '\u{e094}',
+	  CHINESE_M_10: '\u{e095}',
+	  CHINESE_M_2: '\u{e096}',
+	  CHINESE_M_3: '\u{e097}',
+	  CHINESE_M_4: '\u{e098}',
+	  CHINESE_M_5: '\u{e099}',
+	  CHINESE_M_6: '\u{e09a}',
+	  CHINESE_M_7: '\u{e09b}',
+	  CHINESE_M_8: '\u{e09c}',
+	  CHINESE_M_9: '\u{e09d}',
+	  CHINESE_N_1: '\u{e09e}',
+	  CHINESE_N_10: '\u{e09f}',
+	  CHINESE_N_2: '\u{e0a0}',
+	  CHINESE_N_3: '\u{e0a1}',
+	  CHINESE_N_4: '\u{e0a2}',
+	  CHINESE_N_5: '\u{e0a3}',
+	  CHINESE_N_6: '\u{e0a4}',
+	  CHINESE_N_7: '\u{e0a5}',
+	  CHINESE_N_8: '\u{e0a6}',
+	  CHINESE_N_9: '\u{e0a7}',
+	  CHINESE_O_1: '\u{e0a8}',
+	  CHINESE_O_10: '\u{e0a9}',
+	  CHINESE_O_2: '\u{e0aa}',
+	  CHINESE_O_3: '\u{e0ab}',
+	  CHINESE_O_4: '\u{e0ac}',
+	  CHINESE_O_5: '\u{e0ad}',
+	  CHINESE_O_6: '\u{e0ae}',
+	  CHINESE_O_7: '\u{e0af}',
+	  CHINESE_O_8: '\u{e0b0}',
+	  CHINESE_O_9: '\u{e0b1}',
+	  CHINESE_P_1: '\u{e0b2}',
+	  CHINESE_P_10: '\u{e0b3}',
+	  CHINESE_P_2: '\u{e0b4}',
+	  CHINESE_P_3: '\u{e0b5}',
+	  CHINESE_P_4: '\u{e0b6}',
+	  CHINESE_P_5: '\u{e0b7}',
+	  CHINESE_P_6: '\u{e0b8}',
+	  CHINESE_P_7: '\u{e0b9}',
+	  CHINESE_P_8: '\u{e0ba}',
+	  CHINESE_P_9: '\u{e0bb}',
+	  CHINESE_R_1: '\u{e0bc}',
+	  CHINESE_R_10: '\u{e0bd}',
+	  CHINESE_R_2: '\u{e0be}',
+	  CHINESE_R_3: '\u{e0bf}',
+	  CHINESE_R_4: '\u{e0c0}',
+	  CHINESE_R_5: '\u{e0c1}',
+	  CHINESE_R_6: '\u{e0c2}',
+	  CHINESE_R_7: '\u{e0c3}',
+	  CHINESE_R_8: '\u{e0c4}',
+	  CHINESE_R_9: '\u{e0c5}',
+	  CHINESE_S_1: '\u{e0c6}',
+	  CHINESE_S_10: '\u{e0c7}',
+	  CHINESE_S_2: '\u{e0c8}',
+	  CHINESE_S_3: '\u{e0c9}',
+	  CHINESE_S_4: '\u{e0ca}',
+	  CHINESE_S_5: '\u{e0cb}',
+	  CHINESE_S_6: '\u{e0cc}',
+	  CHINESE_S_7: '\u{e0cd}',
+	  CHINESE_S_8: '\u{e0ce}',
+	  CHINESE_S_9: '\u{e0cf}',
+	  CHINESE_T_1: '\u{e0d0}',
+	  CHINESE_T_10: '\u{e0d1}',
+	  CHINESE_T_2: '\u{e0d2}',
+	  CHINESE_T_3: '\u{e0d3}',
+	  CHINESE_T_4: '\u{e0d4}',
+	  CHINESE_T_5: '\u{e0d5}',
+	  CHINESE_T_6: '\u{e0d6}',
+	  CHINESE_T_7: '\u{e0d7}',
+	  CHINESE_T_8: '\u{e0d8}',
+	  CHINESE_T_9: '\u{e0d9}',
+	  CHINESE_U_1: '\u{e0da}',
+	  CHINESE_U_10: '\u{e0db}',
+	  CHINESE_U_2: '\u{e0dc}',
+	  CHINESE_U_3: '\u{e0dd}',
+	  CHINESE_U_4: '\u{e0de}',
+	  CHINESE_U_5: '\u{e0df}',
+	  CHINESE_U_6: '\u{e0e0}',
+	  CHINESE_U_7: '\u{e0e1}',
+	  CHINESE_U_8: '\u{e0e2}',
+	  CHINESE_U_9: '\u{e0e3}',
+	  CHINESE_V_1: '\u{e0e4}',
+	  CHINESE_V_10: '\u{e0e5}',
+	  CHINESE_V_2: '\u{e0e6}',
+	  CHINESE_V_3: '\u{e0e7}',
+	  CHINESE_V_4: '\u{e0e8}',
+	  CHINESE_V_5: '\u{e0e9}',
+	  CHINESE_V_6: '\u{e0ea}',
+	  CHINESE_V_7: '\u{e0eb}',
+	  CHINESE_V_8: '\u{e0ec}',
+	  CHINESE_V_9: '\u{e0ed}',
+	  CHINESE_W_1: '\u{e0ee}',
+	  CHINESE_W_10: '\u{e0ef}',
+	  CHINESE_W_2: '\u{e0f0}',
+	  CHINESE_W_3: '\u{e0f1}',
+	  CHINESE_W_4: '\u{e0f2}',
+	  CHINESE_W_5: '\u{e0f3}',
+	  CHINESE_W_6: '\u{e0f4}',
+	  CHINESE_W_7: '\u{e0f5}',
+	  CHINESE_W_8: '\u{e0f6}',
+	  CHINESE_W_9: '\u{e0f7}',
+	  CHINESE_X_1: '\u{e0f8}',
+	  CHINESE_X_10: '\u{e0f9}',
+	  CHINESE_X_2: '\u{e0fa}',
+	  CHINESE_X_3: '\u{e0fb}',
+	  CHINESE_X_4: '\u{e0fc}',
+	  CHINESE_X_5: '\u{e0fd}',
+	  CHINESE_X_6: '\u{e0fe}',
+	  CHINESE_X_7: '\u{e0ff}',
+	  CHINESE_X_8: '\u{e100}',
+	  CHINESE_X_9: '\u{e101}',
+	  CHINESE_Y_1: '\u{e102}',
+	  CHINESE_Y_10: '\u{e103}',
+	  CHINESE_Y_2: '\u{e104}',
+	  CHINESE_Y_3: '\u{e105}',
+	  CHINESE_Y_4: '\u{e106}',
+	  CHINESE_Y_5: '\u{e107}',
+	  CHINESE_Y_6: '\u{e108}',
+	  CHINESE_Y_7: '\u{e109}',
+	  CHINESE_Y_8: '\u{e10a}',
+	  CHINESE_Y_9: '\u{e10b}',
+	  CHINESE_Z_1: '\u{e10c}',
+	  CHINESE_Z_10: '\u{e10d}',
+	  CHINESE_Z_2: '\u{e10e}',
+	  CHINESE_Z_3: '\u{e10f}',
+	  CHINESE_Z_4: '\u{e110}',
+	  CHINESE_Z_5: '\u{e111}',
+	  CHINESE_Z_6: '\u{e112}',
+	  CHINESE_Z_7: '\u{e113}',
+	  CHINESE_Z_8: '\u{e114}',
+	  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;
+}
+
+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)
@@ -56,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
@@ -100,6 +479,7 @@ function withDefaultCipherOptions(opts, defaults) {
     return {
         input: {
             caseSensitive: false,
+            normalizeDiacritics: false,
             letterSeparator: '',
             wordSeparator: ' ',
             ...defaults?.input,
@@ -123,7 +503,7 @@ class MorseCodeCipher extends SubstitutionCipher {
         const { dotDashMapping = { dot: '.', dash: '-' } } = configuration || {};
         const mergedOpts = withDefaultCipherOptions(opts, {
             input: {
-                caseSensitive: true,
+                caseSensitive: false,
                 letterSeparator: '',
                 wordSeparator: ' ',
             },
@@ -152,7 +532,7 @@ class MorseCodeCipher extends SubstitutionCipher {
         const { dotDashMapping = { dot: '.', dash: '-' } } = configuration || {};
         const mergedOpts = withDefaultCipherOptions(opts, {
             input: {
-                caseSensitive: true,
+                caseSensitive: false,
                 letterSeparator: '/',
                 wordSeparator: '///',
             },
@@ -214,47 +594,208 @@ MorseCodeCipher.MORSE_CODE_MAP = {
     '9': '----.',
 };
 
-var KidscipherGlyphs_1;
-var hasRequiredKidscipherGlyphs;
+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',
+};
 
-function requireKidscipherGlyphs () {
-	if (hasRequiredKidscipherGlyphs) return KidscipherGlyphs_1;
-	hasRequiredKidscipherGlyphs = 1;
-	// Auto-generated by generate-font
-	const KidscipherGlyphs = Object.freeze({
-	  POLAND_CROSS_A: '\u{64}',
-	  POLAND_CROSS_B: '\u{65}',
-	  POLAND_CROSS_C: '\u{66}',
-	  POLAND_CROSS_CH: '\u{67}',
-	  POLAND_CROSS_D: '\u{68}',
-	  POLAND_CROSS_E: '\u{69}',
-	  POLAND_CROSS_F: '\u{6a}',
-	  POLAND_CROSS_G: '\u{6b}',
-	  POLAND_CROSS_H: '\u{6c}',
-	  POLAND_CROSS_I: '\u{6d}',
-	  POLAND_CROSS_J: '\u{6e}',
-	  POLAND_CROSS_K: '\u{6f}',
-	  POLAND_CROSS_L: '\u{70}',
-	  POLAND_CROSS_M: '\u{71}',
-	  POLAND_CROSS_N: '\u{72}',
-	  POLAND_CROSS_O: '\u{73}',
-	  POLAND_CROSS_P: '\u{74}',
-	  POLAND_CROSS_Q: '\u{75}',
-	  POLAND_CROSS_R: '\u{76}',
-	  POLAND_CROSS_S: '\u{77}',
-	  POLAND_CROSS_T: '\u{78}',
-	  POLAND_CROSS_U: '\u{79}',
-	  POLAND_CROSS_V: '\u{7a}',
-	  POLAND_CROSS_W: '\u{7b}',
-	  POLAND_CROSS_X: '\u{7c}',
-	  POLAND_CROSS_Y: '\u{7d}',
-	  POLAND_CROSS_Z: '\u{7e}'
-	});
-	KidscipherGlyphs_1 = { KidscipherGlyphs };
-	return KidscipherGlyphs_1;
+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] ?? '';
+    }
 }
 
-var KidscipherGlyphsExports = requireKidscipherGlyphs();
+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() {
@@ -291,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);
         }
-        super(alphabet, [alphabet]);
+        // we need to reverse it
+        return results.reverse().join('');
     }
-    encode(input, { shift }, opts) {
+    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, { 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',
@@ -434,6 +1074,33 @@ ShiftAlphabetCipher.DEFAULT_ALPHABET = [
     '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]);
+            }
+        }
+    }
+    return output;
+};
+ShiftRotorABCDCipher.ROTOR_ALPHABETS = [
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 1),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 3),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 9),
 ];
 
-export { MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, SubstitutionCipher };
+export { ChineseCipher, Cipher, FractionCipher, MobileCipher, MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, ShiftRotorABCDCipher, SpiderCipher, SubstitutionCipher };