kidscipher 0.6.0 → 0.7.0

package/README.md

@@ -37,6 +37,7 @@ The font allows you to render encoded text as graphical symbols (necesary only f
 ### Supported Ciphers
 
 - Substitution Cipher
+  - ✅ Letter Number Cipher (A1Z26)
   - ✅ Shift Cipher
     - ✅ Shift Alphabet
     - ✅ ABCD Shift 3-rotor
@@ -48,6 +49,7 @@ The font allows you to render encoded text as graphical symbols (necesary only f
   - ✅ Different Cross (need font)
   - ❌ Square Cross (need font)
   - ❌ Knights Templar Cross (need font)
+  - ❌ Musical Code [Musical code paper](https://lair.etamu.edu/cgi/viewcontent.cgi?article=1032&context=honorstheses), [scout wiki](https://scoutwiki.scouts.org.za/wiki/Codes_and_Ciphers)
   - ✅ Mobile
   - ✅ Chess
   - ✅ Cipher table - ADFGVX/ADFGX

package/dist/index.cjs.js

@@ -484,6 +484,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 || {};
@@ -493,16 +517,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')
@@ -546,7 +573,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] ?? '';
@@ -577,9 +612,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 || {};
@@ -601,9 +697,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('');
@@ -626,9 +722,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;
             })
@@ -637,44 +733,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() {
@@ -748,22 +807,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)
@@ -1039,6 +1107,36 @@ class ChineseCipher extends SubstitutionCyclicCipher {
 }
 ChineseCipher.CHINESE_MAP = ChineseCipher.generateMap();
 
+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 = {};
@@ -1087,37 +1185,23 @@ class ShiftCipher extends SubstitutionCipher {
 
 class ShiftAlphabetCipher extends ShiftCipher {
     constructor(shift = 1) {
-        super(ShiftAlphabetCipher.DEFAULT_ALPHABET, shift);
+        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',
-];
+
+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) {
@@ -1176,44 +1260,8 @@ class ShiftRotorABCDCipher extends ShiftRotorCipher {
         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 = [];
@@ -1329,6 +1377,7 @@ class ChessCipher extends Substitution2DCipher {
         super(encodeAlphabet2D, horizontalKey, verticalKey);
     }
 }
+// base alphabet: A-Z + 0-9
 ChessCipher.BASE_ALPHABET = [
     'A',
     'B',
@@ -1368,12 +1417,77 @@ ChessCipher.BASE_ALPHABET = [
     '9',
 ];
 
+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',
+};
+
 exports.ChessCipher = ChessCipher;
 exports.ChineseCipher = ChineseCipher;
 exports.Cipher = Cipher;
 exports.DifferentCrossCipher = DifferentCrossCipher;
 exports.FractionCipher = FractionCipher;
 exports.HebrewCrossCipher = HebrewCrossCipher;
+exports.LetterNumberCipher = LetterNumberCipher;
 exports.MobileCipher = MobileCipher;
 exports.MorseCodeCipher = MorseCodeCipher;
 exports.PolandCrossCipher = PolandCrossCipher;

package/dist/index.esm.js

@@ -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() {
@@ -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)
@@ -1037,6 +1105,36 @@ class ChineseCipher extends SubstitutionCyclicCipher {
 }
 ChineseCipher.CHINESE_MAP = ChineseCipher.generateMap();
 
+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 = {};
@@ -1085,37 +1183,23 @@ class ShiftCipher extends SubstitutionCipher {
 
 class ShiftAlphabetCipher extends ShiftCipher {
     constructor(shift = 1) {
-        super(ShiftAlphabetCipher.DEFAULT_ALPHABET, shift);
+        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',
-];
+
+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) {
@@ -1174,44 +1258,8 @@ class ShiftRotorABCDCipher extends ShiftRotorCipher {
         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 = [];
@@ -1327,6 +1375,7 @@ class ChessCipher extends Substitution2DCipher {
         super(encodeAlphabet2D, horizontalKey, verticalKey);
     }
 }
+// base alphabet: A-Z + 0-9
 ChessCipher.BASE_ALPHABET = [
     'A',
     'B',
@@ -1366,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 };

package/dist/types/cipher/Cipher.d.ts

@@ -2,6 +2,13 @@ import { CipherOptions } from '../core/cipher-options/CipherOptions';
 export type CipherConfigurationsRecord = Record<string, any>;
 declare abstract class Cipher {
     abstract encodeToken(token: string, configuration?: CipherConfigurationsRecord): string;
+    /**
+     * Tokenize input using a dictionary of valid tokens.
+     * Longest tokens win.
+     */
+    protected tokenize(input: string, tokens: string[]): string[];
+    abstract getEncodeTokens(): string[];
+    abstract getDecodeTokens(): string[];
     encode(input: string, configuration?: CipherConfigurationsRecord, opts?: CipherOptions): string;
     abstract decodeToken(token: string, configuration?: CipherConfigurationsRecord): string;
     decode(input: string, configuration?: CipherConfigurationsRecord, opts?: CipherOptions): string;

package/dist/types/cipher/morsecode/MorseCodeAlphabet.d.ts

@@ -0,0 +1,16 @@
+export declare const MORSE_CODE_ALPHABETS: {
+    intl: Record<string, string>;
+    cs: {
+        CH: string;
+    };
+    de: {
+        Ä: string;
+        Ö: string;
+        Ü: string;
+        ß: string;
+    };
+    es: {
+        Ñ: string;
+    };
+};
+export type MorseCodeAlphabetKey = keyof typeof MORSE_CODE_ALPHABETS;

package/dist/types/cipher/morsecode/MorseCodeCipher.d.ts

@@ -1,16 +1,34 @@
 import SubstitutionCipher from '../substitution/SubstitutionCipher';
 import { CipherOptions } from '../../core/cipher-options/CipherOptions';
 import { CipherConfigurationsRecord } from '../Cipher';
-export type MorseCodeCipherOptions = CipherConfigurationsRecord | {
-    dotDashMapping?: {
-        dot?: string;
-        dash?: string;
-    };
+import { MorseCodeAlphabetKey } from './MorseCodeAlphabet';
+type DotDashMapping = {
+    dot: string;
+    dash: string;
+};
+type MorseCodeCipherProps = {
+    alphabetVariant?: MorseCodeAlphabetKey;
+    dotDashMapping?: Partial<DotDashMapping>;
 };
 declare class MorseCodeCipher extends SubstitutionCipher {
-    static MORSE_CODE_MAP: Record<string, string>;
-    constructor();
-    encode(input: string, configuration?: MorseCodeCipherOptions, opts?: CipherOptions): string;
-    decode(input: string, configuration?: MorseCodeCipherOptions, opts?: CipherOptions): string;
+    private readonly dotDashMapping;
+    static readonly ALPHABETS: {
+        intl: Record<string, string>;
+        cs: {
+            CH: string;
+        };
+        de: {
+            Ä: string;
+            Ö: string;
+            Ü: string;
+            ß: string;
+        };
+        es: {
+            Ñ: string;
+        };
+    };
+    constructor({ alphabetVariant, dotDashMapping, }?: MorseCodeCipherProps);
+    encode(input: string, configuration?: CipherConfigurationsRecord, opts?: CipherOptions): string;
+    decode(input: string, configuration?: CipherConfigurationsRecord, opts?: CipherOptions): string;
 }
 export default MorseCodeCipher;

package/dist/types/cipher/number/LetterNumberCipher.d.ts

@@ -0,0 +1,11 @@
+import SubstitutionCipher from '../substitution/SubstitutionCipher';
+import { CipherOptions } from '../../core/cipher-options/CipherOptions';
+import { CipherConfigurationsRecord } from '../Cipher';
+export type LetterNumberCipherOptions = CipherConfigurationsRecord;
+declare class LetterNumberCipher extends SubstitutionCipher {
+    static readonly ALPHABET: Record<string, string>;
+    constructor();
+    encode(input: string, configuration?: LetterNumberCipherOptions, opts?: CipherOptions): string;
+    decode(input: string, configuration?: LetterNumberCipherOptions, opts?: CipherOptions): string;
+}
+export default LetterNumberCipher;

package/dist/types/cipher/shift/ShiftAlphabetCipher.d.ts

@@ -1,6 +1,5 @@
 import ShiftCipher from './ShiftCipher';
 declare class ShiftAlphabetCipher extends ShiftCipher {
-    static DEFAULT_ALPHABET: string[];
     constructor(shift?: number);
 }
 export default ShiftAlphabetCipher;

package/dist/types/cipher/substitution/SubstitutionCipher.d.ts

@@ -2,7 +2,11 @@ import Cipher from '../Cipher';
 declare class SubstitutionCipher extends Cipher {
     protected encodeMap: Record<string, string>;
     protected decodeMap: Record<string, string>;
+    protected encodeTokens: string[];
+    protected decodeTokens: string[];
     constructor(encodeMap: Record<string, string>);
+    getEncodeTokens(): string[];
+    getDecodeTokens(): string[];
     encodeToken(token: string): string;
     decodeToken(token: string): string;
 }

package/dist/types/cipher/substitution/SubstitutionCyclicCipher.d.ts

@@ -4,7 +4,11 @@ declare class SubstitutionCyclicCipher extends Cipher {
     protected encodeMap: Record<string, string[]>;
     protected decodeMap: Record<string, string>;
     protected counters: Record<string, number>;
+    protected encodeTokens: string[];
+    protected decodeTokens: string[];
     constructor(encodeMap: Record<string, string | string[]>);
+    getEncodeTokens(): string[];
+    getDecodeTokens(): string[];
     resetCounters: () => void;
     encodeToken(token: string): string;
     encode(input: string, configuration?: CipherConfigurationsRecord, opts?: CipherOptions): string;

package/dist/types/core/alphabet/MapCz.d.ts

@@ -0,0 +1,47 @@
+export declare const ALPHABET_CZ: {
+    readonly A: "A";
+    readonly Á: "Á";
+    readonly B: "B";
+    readonly C: "C";
+    readonly Č: "Č";
+    readonly D: "D";
+    readonly Ď: "Ď";
+    readonly E: "E";
+    readonly É: "É";
+    readonly Ě: "Ě";
+    readonly F: "F";
+    readonly G: "G";
+    readonly H: "H";
+    readonly CH: "CH";
+    readonly I: "I";
+    readonly Í: "Í";
+    readonly J: "J";
+    readonly K: "K";
+    readonly L: "L";
+    readonly M: "M";
+    readonly N: "N";
+    readonly Ň: "Ň";
+    readonly O: "O";
+    readonly Ó: "Ó";
+    readonly P: "P";
+    readonly Q: "Q";
+    readonly R: "R";
+    readonly Ř: "Ř";
+    readonly S: "S";
+    readonly Š: "Š";
+    readonly T: "T";
+    readonly Ť: "Ť";
+    readonly U: "U";
+    readonly Ú: "Ú";
+    readonly Ů: "Ů";
+    readonly V: "V";
+    readonly W: "W";
+    readonly X: "X";
+    readonly Y: "Y";
+    readonly Ý: "Ý";
+    readonly Z: "Z";
+    readonly Ž: "Ž";
+};
+export type AlphabetCz = (typeof ALPHABET_CZ)[keyof typeof ALPHABET_CZ];
+export declare const ALPHABET_CZ_ARRAY: AlphabetCz[];
+export declare const ALPHABET_CZ_NO_PUNCTUATION_ARRAY: AlphabetCz[];

package/dist/types/core/alphabet/MapEn.d.ts

@@ -0,0 +1,30 @@
+export declare const ALPHABET_EN: {
+    readonly A: "A";
+    readonly B: "B";
+    readonly C: "C";
+    readonly D: "D";
+    readonly E: "E";
+    readonly F: "F";
+    readonly G: "G";
+    readonly H: "H";
+    readonly I: "I";
+    readonly J: "J";
+    readonly K: "K";
+    readonly L: "L";
+    readonly M: "M";
+    readonly N: "N";
+    readonly O: "O";
+    readonly P: "P";
+    readonly Q: "Q";
+    readonly R: "R";
+    readonly S: "S";
+    readonly T: "T";
+    readonly U: "U";
+    readonly V: "V";
+    readonly W: "W";
+    readonly X: "X";
+    readonly Y: "Y";
+    readonly Z: "Z";
+};
+export type AlphabetEn = (typeof ALPHABET_EN)[keyof typeof ALPHABET_EN];
+export declare const ALPHABET_EN_ARRAY: AlphabetEn[];

package/dist/types/core/alphabet/MapNumbers.d.ts

@@ -0,0 +1,14 @@
+export declare const ALPHABET_NUMBERS: {
+    '0': string;
+    '1': string;
+    '2': string;
+    '3': string;
+    '4': string;
+    '5': string;
+    '6': string;
+    '7': string;
+    '8': string;
+    '9': string;
+};
+export type AlphabetNumber = (typeof ALPHABET_NUMBERS)[keyof typeof ALPHABET_NUMBERS];
+export declare const ALPHABET_NUMBERS_ARRAY: AlphabetNumber[];

package/dist/types/index.d.ts

@@ -15,3 +15,4 @@ export { default as ShiftRotorABCDCipher } from './cipher/shift/ShiftRotorABCDCi
 export { default as Substitution2DCipher } from './cipher/substitution/Substitution2DCipher';
 export { default as TableKeyFiveToFiveCipher } from './cipher/table/TableKeyFiveToFiveCipher';
 export { default as ChessCipher } from './cipher/table/ChessCipher';
+export { default as LetterNumberCipher } from './cipher/number/LetterNumberCipher';

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "kidscipher",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "license": "MIT",
   "homepage": "https://github.com/fandau1/kidscipher",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fandau1/kidscipher.git"
+  },
   "type": "module",
   "types": "dist/types/index.d.ts",
   "exports": {