kidscipher 0.5.0 → 0.7.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;
@@ -482,6 +482,30 @@ const processingPipeline = (text, processors) => {
 };
 
 class Cipher {
+    /**
+     * Tokenize input using a dictionary of valid tokens.
+     * Longest tokens win.
+     */
+    tokenize(input, tokens) {
+        const result = [];
+        let i = 0;
+        while (i < input.length) {
+            let matched = false;
+            for (const token of tokens) {
+                if (input.startsWith(token, i)) {
+                    result.push(token);
+                    i += token.length;
+                    matched = true;
+                    break;
+                }
+            }
+            if (!matched) {
+                result.push(input[i]);
+                i++;
+            }
+        }
+        return result;
+    }
     encode(input, configuration, opts) {
         const { caseSensitive = false, normalizeDiacritics = true, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = '///', } = opts?.input || {};
         const { casing = 'original', letterSeparator: outputLetterSeparator = '', wordSeparator: outputWordSeparator = ' ', } = opts?.output || {};
@@ -491,16 +515,19 @@ class Cipher {
         // normalize input into words and letters
         const words = preprocessedInput.split(inputWordSeparator);
         const encodedWords = words.map((word) => {
-            const letters = inputLetterSeparator
-                ? word.split(inputLetterSeparator)
-                : word.split('');
-            return letters
-                .map((symbol) => {
-                if (/\s/.test(symbol)) {
-                    return symbol;
+            const normalizedWord = caseSensitive ? word : word.toUpperCase();
+            // tokenize the word
+            // eg. [".-", "-...", ...] or ["A", "B", "CH", ...]
+            const tokens = inputLetterSeparator
+                ? normalizedWord.split(inputLetterSeparator)
+                : this.tokenize(normalizedWord, this.getEncodeTokens());
+            // console.log('Tokenized letters:', tokens);
+            return tokens
+                .map((token) => {
+                if (/\s/.test(token)) {
+                    return token;
                 }
-                const c = caseSensitive ? symbol : symbol.toUpperCase();
-                let encoded = this.encodeToken(c, configuration);
+                let encoded = this.encodeToken(token, configuration);
                 if (casing === 'upper')
                     encoded = encoded.toUpperCase();
                 if (casing === 'lower')
@@ -544,7 +571,15 @@ class SubstitutionCipher extends Cipher {
     constructor(encodeMap) {
         super();
         this.encodeMap = encodeMap;
-        this.decodeMap = Object.entries(encodeMap).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
+        this.decodeMap = Object.fromEntries(Object.entries(encodeMap).map(([k, v]) => [v, k]));
+        this.encodeTokens = Object.keys(this.encodeMap).sort((a, b) => b.length - a.length);
+        this.decodeTokens = Object.keys(this.decodeMap).sort((a, b) => b.length - a.length);
+    }
+    getEncodeTokens() {
+        return this.encodeTokens;
+    }
+    getDecodeTokens() {
+        return this.decodeTokens;
     }
     encodeToken(token) {
         return this.encodeMap[token] ?? '';
@@ -575,9 +610,70 @@ function withDefaultCipherOptions(opts, defaults) {
     };
 }
 
+const INTERNATIONAL_MORSE = {
+    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': '----.',
+};
+const CZECH_MORSE = {
+    CH: '----',
+};
+const GERMAN_MORSE = {
+    Ä: '.-.-',
+    Ö: '---.',
+    Ü: '..--',
+    ß: '...--..',
+};
+const SPANISH_MORSE = {
+    Ñ: '--.--',
+};
+const MORSE_CODE_ALPHABETS = {
+    intl: INTERNATIONAL_MORSE,
+    cs: { ...INTERNATIONAL_MORSE, ...CZECH_MORSE },
+    de: { ...INTERNATIONAL_MORSE, ...GERMAN_MORSE },
+    es: { ...INTERNATIONAL_MORSE, ...SPANISH_MORSE },
+};
+
 class MorseCodeCipher extends SubstitutionCipher {
-    constructor() {
-        super(MorseCodeCipher.MORSE_CODE_MAP);
+    constructor({ alphabetVariant = 'intl', dotDashMapping = { dot: '.', dash: '-' }, } = {}) {
+        super(MorseCodeCipher.ALPHABETS[alphabetVariant ?? 'intl']);
+        this.dotDashMapping = {
+            dot: dotDashMapping.dot ?? '.',
+            dash: dotDashMapping.dash ?? '-',
+        };
     }
     encode(input, configuration, opts) {
         const { dotDashMapping = { dot: '.', dash: '-' } } = configuration || {};
@@ -599,9 +695,9 @@ class MorseCodeCipher extends SubstitutionCipher {
                 .split('')
                 .map((char) => {
                 if (char === '.')
-                    return dotDashMapping.dot;
+                    return this.dotDashMapping.dot;
                 if (char === '-')
-                    return dotDashMapping.dash;
+                    return this.dotDashMapping.dash;
                 return char;
             })
                 .join('');
@@ -624,9 +720,9 @@ class MorseCodeCipher extends SubstitutionCipher {
             normalized = input
                 .split('')
                 .map((char) => {
-                if (char === dotDashMapping.dot)
+                if (char === this.dotDashMapping.dot)
                     return '.';
-                if (char === dotDashMapping.dash)
+                if (char === this.dotDashMapping.dash)
                     return '-';
                 return char;
             })
@@ -635,44 +731,7 @@ class MorseCodeCipher extends SubstitutionCipher {
         return super.decode(normalized, configuration, mergedOpts);
     }
 }
-MorseCodeCipher.MORSE_CODE_MAP = {
-    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': '----.',
-};
+MorseCodeCipher.ALPHABETS = MORSE_CODE_ALPHABETS;
 
 class MobileCipher extends SubstitutionCipher {
     constructor() {
@@ -688,7 +747,7 @@ class MobileCipher extends SubstitutionCipher {
             output: {
                 casing: 'original',
                 letterSeparator: ' ',
-                wordSeparator: ' | ',
+                wordSeparator: ' 1 ',
             },
         });
         return super.encode(input, configuration, mergedOpts);
@@ -698,7 +757,7 @@ class MobileCipher extends SubstitutionCipher {
             input: {
                 caseSensitive: false,
                 letterSeparator: ' ',
-                wordSeparator: ' | ',
+                wordSeparator: ' 1 ',
             },
             output: {
                 casing: 'lower',
@@ -746,22 +805,31 @@ class SubstitutionCyclicCipher extends Cipher {
                 this.counters[key] = 0;
             }
         };
-        // chech encodeMap
+        // normalize encode map to arrays
         this.encodeMap = Object.fromEntries(Object.entries(encodeMap).map(([key, value]) => [
             key,
             Array.isArray(value) ? value : [value],
         ]));
-        // decode map
+        // build decode map
         this.decodeMap = {};
         for (const [key, values] of Object.entries(this.encodeMap)) {
             for (const val of values) {
                 this.decodeMap[val] = key;
             }
         }
-        // inialization counters
+        // tokenize keys (longest first)
+        this.encodeTokens = Object.keys(this.encodeMap).sort((a, b) => b.length - a.length);
+        this.decodeTokens = Object.keys(this.decodeMap).sort((a, b) => b.length - a.length);
+        // initialize counters
         this.counters = {};
         this.resetCounters();
     }
+    getEncodeTokens() {
+        return this.encodeTokens;
+    }
+    getDecodeTokens() {
+        return this.decodeTokens;
+    }
     encodeToken(token) {
         const options = this.encodeMap[token];
         if (!options || options.length === 0)
@@ -990,29 +1058,29 @@ class FractionCipher extends SubstitutionCipher {
 }
 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,
+    B: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_1,
+    C: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_1,
+    D: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_1,
+    E: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_1,
+    F: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_2,
     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,
+    H: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_2,
+    I: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_2,
+    J: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_2,
+    K: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_3,
+    L: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_3,
     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,
+    N: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_3,
+    O: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_3,
+    P: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_4,
+    Q: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_4,
+    R: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_4,
     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,
+    T: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_4,
+    U: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_5,
+    V: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_5,
+    X: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_5,
+    Y: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_5,
     Z: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_5,
 };
 
@@ -1037,56 +1105,65 @@ class ChineseCipher extends SubstitutionCyclicCipher {
 }
 ChineseCipher.CHINESE_MAP = ChineseCipher.generateMap();
 
-class ShiftCipher extends Cipher {
-    constructor(alphabet) {
-        super();
-        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
+const ALPHABET_EN = {
+    A: 'A',
+    B: 'B',
+    C: 'C',
+    D: 'D',
+    E: 'E',
+    F: 'F',
+    G: 'G',
+    H: 'H',
+    I: 'I',
+    J: 'J',
+    K: 'K',
+    L: 'L',
+    M: 'M',
+    N: 'N',
+    O: 'O',
+    P: 'P',
+    Q: 'Q',
+    R: 'R',
+    S: 'S',
+    T: 'T',
+    U: 'U',
+    V: 'V',
+    W: 'W',
+    X: 'X',
+    Y: 'Y',
+    Z: 'Z',
+};
+const ALPHABET_EN_ARRAY = Object.values(ALPHABET_EN);
+
+class ShiftCipher extends SubstitutionCipher {
+    constructor(alphabet, shift, inputMode = 'letter', outputMode = 'letter') {
+        let encodeMap = {};
+        for (let i = 0; i < alphabet.length; i++) {
+            let fromChar;
+            let toChar;
+            switch (inputMode) {
+                case 'index':
+                    fromChar = i.toString();
+                    break;
+                case 'letter':
+                    fromChar = alphabet[i];
+                    break;
             }
-        }
-        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
+            const normalizedShiftedIndex = (((i + shift) % alphabet.length) + alphabet.length) % alphabet.length;
+            switch (outputMode) {
+                case 'index':
+                    toChar = normalizedShiftedIndex.toString();
+                    break;
+                case 'letter':
+                    toChar = alphabet[normalizedShiftedIndex];
+                    break;
             }
+            encodeMap[fromChar] = toChar;
         }
-        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;
+        super(encodeMap);
+        this.alphabet = alphabet;
+        this.inputMode = inputMode;
+        this.outputMode = outputMode;
     }
     encode(input, configuration, opts) {
         const mergedOpts = withDefaultCipherOptions(opts, {
@@ -1105,97 +1182,47 @@ class ShiftCipher extends Cipher {
 }
 
 class ShiftAlphabetCipher extends ShiftCipher {
-    constructor() {
-        super(ShiftAlphabetCipher.DEFAULT_ALPHABET);
+    constructor(shift = 1) {
+        super(ALPHABET_EN_ARRAY, shift);
     }
 }
-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();
+const ALPHABET_NUMBERS = {
+    '0': '0',
+    '1': '1',
+    '2': '2',
+    '3': '3',
+    '4': '4',
+    '5': '5',
+    '6': '6',
+    '7': '7',
+    '8': '8',
+    '9': '9',
+};
+const ALPHABET_NUMBERS_ARRAY = Object.values(ALPHABET_NUMBERS);
+
+class ShiftRotorCipher extends SubstitutionCipher {
+    constructor(baseAlphabet, rotors, shifts) {
+        let encodeMap = {};
+        if (rotors.length !== shifts.length) {
+            throw new Error(`Invalid number of shifts: expected ${rotors.length}, got ${shifts.length}`);
+        }
         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);
+        if (rotors.some((rotor) => rotor.length !== baseAlphabet.length)) {
+            throw new Error('All rotors must have the same length as the base alphabet');
         }
-        // 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}`);
+        for (let i = 0; i < baseAlphabet.length; i++) {
+            let fromChar = baseAlphabet[i];
+            let toChar = '';
+            for (let j = 0; j < rotors.length; j++) {
+                const rotor = rotors[j];
+                const normalizedShiftedIndex = (((i + shifts[j]) % rotor.length) + rotor.length) % rotor.length;
+                toChar += rotor[normalizedShiftedIndex];
+            }
+            encodeMap[fromChar] = toChar;
         }
-        const finalIndex = intersection[0];
-        const result = this.baseAlphabet.decodeToken(finalIndex.toString(), {
-            shift: 0,
-            inputAsIndex: true,
-            outputAsIndex: outputAsIndex,
-        });
-        return result;
+        super(encodeMap);
     }
     encode(input, configuration, opts) {
         const mergedOpts = withDefaultCipherOptions(opts, {
@@ -1222,53 +1249,17 @@ class ShiftRotorCipher extends Cipher {
 }
 
 class ShiftRotorABCDCipher extends ShiftRotorCipher {
-    constructor() {
+    constructor(shifts) {
         const rotors = [];
-        const baseAlphabet = new ShiftCipher(ShiftRotorABCDCipher.BASE_ALPHABET);
+        const baseAlphabet = ShiftRotorABCDCipher.BASE_ALPHABET;
         for (let i = 0; i < ShiftRotorABCDCipher.ROTOR_ALPHABETS.length; i++) {
-            rotors.push(new ShiftCipher(ShiftRotorABCDCipher.ROTOR_ALPHABETS[i]));
+            rotors.push(ShiftRotorABCDCipher.ROTOR_ALPHABETS[i]);
         }
-        super(baseAlphabet, rotors);
+        super(baseAlphabet, rotors, shifts);
     }
 }
-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',
-];
+// base alphabet: A-Z + 0-9
+ShiftRotorABCDCipher.BASE_ALPHABET = [...ALPHABET_EN_ARRAY, ...ALPHABET_NUMBERS_ARRAY];
 ShiftRotorABCDCipher.REPEAT_ALPHABET = ['A', 'B', 'C', 'D'];
 ShiftRotorABCDCipher.generateRepeatRotorAlphabet = (repeatAlphabet, repeat) => {
     let output = [];
@@ -1282,9 +1273,9 @@ ShiftRotorABCDCipher.generateRepeatRotorAlphabet = (repeatAlphabet, repeat) => {
     return output;
 };
 ShiftRotorABCDCipher.ROTOR_ALPHABETS = [
-    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 1),
-    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 3),
     ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 9),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 3),
+    ShiftRotorABCDCipher.generateRepeatRotorAlphabet(ShiftRotorABCDCipher.REPEAT_ALPHABET, 1),
 ];
 
 class Substitution2DCipher extends SubstitutionCyclicCipher {
@@ -1384,6 +1375,7 @@ class ChessCipher extends Substitution2DCipher {
         super(encodeAlphabet2D, horizontalKey, verticalKey);
     }
 }
+// base alphabet: A-Z + 0-9
 ChessCipher.BASE_ALPHABET = [
     'A',
     'B',
@@ -1423,4 +1415,68 @@ ChessCipher.BASE_ALPHABET = [
     '9',
 ];
 
-export { ChessCipher, ChineseCipher, Cipher, DifferentCrossCipher, FractionCipher, HebrewCrossCipher, MobileCipher, MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, ShiftRotorABCDCipher, SmallCrossCipher, SpiderCipher, Substitution2DCipher, SubstitutionCipher, TableKeyFiveToFiveCipher };
+class LetterNumberCipher extends SubstitutionCipher {
+    constructor() {
+        super(LetterNumberCipher.ALPHABET);
+    }
+    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);
+    }
+}
+LetterNumberCipher.ALPHABET = {
+    A: '1',
+    B: '2',
+    C: '3',
+    D: '4',
+    E: '5',
+    F: '6',
+    G: '7',
+    H: '8',
+    I: '9',
+    J: '10',
+    K: '11',
+    L: '12',
+    M: '13',
+    N: '14',
+    O: '15',
+    P: '16',
+    Q: '17',
+    R: '18',
+    S: '19',
+    T: '20',
+    U: '21',
+    V: '22',
+    W: '23',
+    X: '24',
+    Y: '25',
+    Z: '26',
+};
+
+export { ChessCipher, ChineseCipher, Cipher, DifferentCrossCipher, FractionCipher, HebrewCrossCipher, LetterNumberCipher, MobileCipher, MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, ShiftRotorABCDCipher, SmallCrossCipher, SpiderCipher, Substitution2DCipher, SubstitutionCipher, TableKeyFiveToFiveCipher };