kidscipher 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 fandau1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# kidscipher
+
+Kidscipher is an npm library for encoding and decoding educational and fun ciphers. It mainly provides ciphers that can be solved as a game and also includes a custom font `Kidscipher`, which makes it possible to work with graphical ciphers and symbols.
+
+## Usage
+
+```ts
+import { PolandCrossCipher } from 'kidscipher';
+
+const cipher = new PolandCrossCipher();
+
+const encoded = cipher.encode('HELLO');
+console.log(encoded);
+
+const decoded = cipher.decode(encoded);
+console.log(decoded); // HELLO
+```
+
+### Custom font
+
+The font allows you to render encoded text as graphical symbols (necesary only for graphical outputs). The font is automatically included in the package, so you don’t need to import it separately.
+
+```html
+<p style="font-family: Kidscipher;">{encoded}</p>
+```
+
+### Supported Ciphers
+
+- ✅ Shift Cipher
+  - ✅ Shift Alphabet
+  - ❌ ABCD Shift 3-rotor
+- ✅ Substitution Cipher
+  - ✅ MorseCode
+  - ✅ Poland Cross (need font)
+  - ❌ Hebrew Cross (need font)
+  - ❌ Small Cross (need font)
+  - ❌ Different Cross (need font)
+  - ❌ Phone
+  - ❌ Chess
+  - ❌ Cipher table
+  - ❌ Fractions (need font)
+- ❌ Spider-Net Cipher
+- ❌ Chinese Cipher (need font)
+
+## Development
+
+The main focus of the project is to provide a lightweight, dependency-minimal library with high customization for ciphers.
+
+All ciphers are text-based (even the graphical ones).
+The graphical part is powered by the Kidscipher font, which is automatically generated by the script `scripts/generate-font`.
+
+This generator maps symbols to Unicode, so every graphical cipher is just normal text rendered with the custom font.
+
+### Setup
+
+1. Install dependencies:
+
+   ```bash
+   npm install
+   ```
+
+2. Prebuild fonts:
+
+   ```bash
+   npm run prebuild-fonts
+   ```
+
+3. Build the package:
+
+   ```bash
+   npm run build
+   ```
+
+### Local testing in another project
+
+To try the package in a different project without publishing to npm, you can link the built `dist` folder directly:
+
+```json
+{
+  "dependencies": {
+    "kidscipher": "file:../dist"
+  }
+}
+```
+
+> **Note:** After adding the dependency, you **must run `npm install`** in the new project.
+> This will create a symlink to the `../dist` folder, so any updates you rebuild in `kidscipher` will be immediately available in the new project without reinstalling, as long as the folder structure remains the same.
+
+## Contributing
+
+Contributions are welcome!

package/dist/font.cjs.js

@@ -0,0 +1,45 @@
+'use strict';
+
+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{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;
+}
+
+var KidscipherGlyphsExports = requireKidscipherGlyphs();
+
+exports.KidscipherGlyphs = KidscipherGlyphsExports.KidscipherGlyphs;

package/dist/font.esm.js

@@ -0,0 +1,44 @@
+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{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;
+}
+
+var KidscipherGlyphsExports = requireKidscipherGlyphs();
+
+var KidscipherGlyphs = KidscipherGlyphsExports.KidscipherGlyphs;
+export { KidscipherGlyphs };

package/dist/index.cjs.js

@@ -0,0 +1,444 @@
+'use strict';
+
+function styleInject(css, ref) {
+  if ( ref === void 0 ) ref = {};
+  var insertAt = ref.insertAt;
+
+  if (typeof document === 'undefined') { return; }
+
+  var head = document.head || document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+
+  if (insertAt === 'top') {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+var css_248z = "@import './Kidscipher.css';\r\n";
+styleInject(css_248z);
+
+class Cipher {
+    encode(input, configuration, opts) {
+        const { caseSensitive = false, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = '///', } = opts?.input || {};
+        const { casing = 'original', letterSeparator: outputLetterSeparator = '', wordSeparator: outputWordSeparator = ' ', } = opts?.output || {};
+        // normalize input into words and letters
+        const words = input.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 c = caseSensitive ? symbol : symbol.toUpperCase();
+                let encoded = this.encodeToken(c, configuration);
+                if (casing === 'upper')
+                    encoded = encoded.toUpperCase();
+                if (casing === 'lower')
+                    encoded = encoded.toLowerCase();
+                return encoded;
+            })
+                .join(outputLetterSeparator);
+        });
+        return encodedWords.join(outputWordSeparator);
+    }
+    decode(input, configuration, opts) {
+        const { caseSensitive = false, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = ' ', } = opts?.input || {};
+        const { casing = 'original', letterSeparator: outputLetterSeparator = '', wordSeparator: outputWordSeparator = ' ', } = opts?.output || {};
+        // split encoded text into words
+        const words = input.split(inputWordSeparator);
+        const decodedWords = words.map((word) => {
+            const symbols = word.split(inputLetterSeparator);
+            return symbols
+                .map((symbol) => {
+                if (/\s/.test(symbol)) {
+                    return symbol;
+                }
+                const c = caseSensitive ? symbol : symbol.toUpperCase();
+                let decoded = this.decodeToken(c, configuration);
+                if (casing === 'upper')
+                    decoded = decoded.toUpperCase();
+                if (casing === 'lower')
+                    decoded = decoded.toLowerCase();
+                return decoded;
+            })
+                .join(outputLetterSeparator);
+        });
+        return decodedWords.join(outputWordSeparator);
+    }
+}
+
+class SubstitutionCipher extends Cipher {
+    constructor(encodeMap) {
+        super();
+        this.encodeMap = encodeMap;
+        this.decodeMap = Object.entries(encodeMap).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
+    }
+    encodeToken(token) {
+        return this.encodeMap[token] ?? '';
+    }
+    decodeToken(token) {
+        let decoded = this.decodeMap[token] ?? '';
+        return decoded;
+    }
+}
+
+function withDefaultCipherOptions(opts, defaults) {
+    return {
+        input: {
+            caseSensitive: false,
+            letterSeparator: '',
+            wordSeparator: ' ',
+            ...defaults?.input,
+            ...opts?.input,
+        },
+        output: {
+            casing: 'original',
+            letterSeparator: '',
+            wordSeparator: ' ',
+            ...defaults?.output,
+            ...opts?.output,
+        },
+    };
+}
+
+class MorseCodeCipher extends SubstitutionCipher {
+    constructor() {
+        super(MorseCodeCipher.MORSE_CODE_MAP);
+    }
+    encode(input, configuration, opts) {
+        const { dotDashMapping = { dot: '.', dash: '-' } } = configuration || {};
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: true,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'original',
+                letterSeparator: '/',
+                wordSeparator: '///',
+            },
+        });
+        const encoded = super.encode(input, configuration, mergedOpts);
+        if (dotDashMapping) {
+            return encoded
+                .split('')
+                .map((char) => {
+                if (char === '.')
+                    return dotDashMapping.dot;
+                if (char === '-')
+                    return dotDashMapping.dash;
+                return char;
+            })
+                .join('');
+        }
+        return encoded;
+    }
+    decode(input, configuration, opts) {
+        const { dotDashMapping = { dot: '.', dash: '-' } } = configuration || {};
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: true,
+                letterSeparator: '/',
+                wordSeparator: '///',
+            },
+            output: { casing: 'lower', letterSeparator: '', wordSeparator: ' ' },
+        });
+        let normalized = input;
+        if (dotDashMapping) {
+            // Map custom symbols back to "." and "-"
+            normalized = input
+                .split('')
+                .map((char) => {
+                if (char === dotDashMapping.dot)
+                    return '.';
+                if (char === dotDashMapping.dash)
+                    return '-';
+                return char;
+            })
+                .join('');
+        }
+        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': '----.',
+};
+
+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{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;
+}
+
+var KidscipherGlyphsExports = requireKidscipherGlyphs();
+
+class PolandCrossCipher extends SubstitutionCipher {
+    constructor() {
+        super(PolandCrossCipher.POLAND_CROSS_MAP);
+    }
+}
+PolandCrossCipher.POLAND_CROSS_MAP = {
+    A: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_A,
+    B: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_B,
+    C: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_C,
+    D: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_D,
+    E: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_E,
+    F: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_F,
+    G: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_G,
+    H: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_H,
+    CH: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_CH,
+    I: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_I,
+    J: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_J,
+    K: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_K,
+    L: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_L,
+    M: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_M,
+    N: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_N,
+    O: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_O,
+    P: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_P,
+    Q: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_Q,
+    R: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_R,
+    S: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_S,
+    T: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_T,
+    U: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_U,
+    V: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_V,
+    W: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_W,
+    X: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_X,
+    Y: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_Y,
+    Z: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_Z,
+};
+
+class ShiftCipher extends Cipher {
+    constructor(baseAlphabet, rotors) {
+        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.baseAlphabet = baseAlphabet;
+        this.rotors = rotors;
+    }
+    encodeToken(token, configuration) {
+        const { shifts } = configuration;
+        let encoded = '';
+        if (this.baseAlphabet.includes(token)) {
+            const index = this.baseAlphabet.indexOf(token);
+            for (let i = 0; i < this.rotors.length; i++) {
+                const wheel = this.rotors[i];
+                const shiftedIndex = (index + shifts[i]) % wheel.length;
+                encoded += wheel[shiftedIndex];
+            }
+        }
+        return encoded;
+    }
+    encode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            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: ' ',
+            },
+        });
+        return super.decode(input, configuration, mergedOpts);
+    }
+}
+
+class ShiftAlphabetCipher extends ShiftCipher {
+    constructor(alphabet) {
+        if (!alphabet) {
+            alphabet = ShiftAlphabetCipher.DEFAULT_ALPHABET;
+        }
+        super(alphabet, [alphabet]);
+    }
+    encode(input, { shift }, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'original',
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+        });
+        return super.encode(input, { shifts: [shift] }, mergedOpts);
+    }
+    decode(input, { shift }, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'original',
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+        });
+        return super.decode(input, { shifts: [shift] }, mergedOpts);
+    }
+}
+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',
+];
+
+exports.MorseCodeCipher = MorseCodeCipher;
+exports.PolandCrossCipher = PolandCrossCipher;
+exports.ShiftAlphabetCipher = ShiftAlphabetCipher;
+exports.SubstitutionCipher = SubstitutionCipher;

package/dist/index.esm.js

@@ -0,0 +1,439 @@
+function styleInject(css, ref) {
+  if ( ref === void 0 ) ref = {};
+  var insertAt = ref.insertAt;
+
+  if (typeof document === 'undefined') { return; }
+
+  var head = document.head || document.getElementsByTagName('head')[0];
+  var style = document.createElement('style');
+  style.type = 'text/css';
+
+  if (insertAt === 'top') {
+    if (head.firstChild) {
+      head.insertBefore(style, head.firstChild);
+    } else {
+      head.appendChild(style);
+    }
+  } else {
+    head.appendChild(style);
+  }
+
+  if (style.styleSheet) {
+    style.styleSheet.cssText = css;
+  } else {
+    style.appendChild(document.createTextNode(css));
+  }
+}
+
+var css_248z = "@import './Kidscipher.css';\r\n";
+styleInject(css_248z);
+
+class Cipher {
+    encode(input, configuration, opts) {
+        const { caseSensitive = false, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = '///', } = opts?.input || {};
+        const { casing = 'original', letterSeparator: outputLetterSeparator = '', wordSeparator: outputWordSeparator = ' ', } = opts?.output || {};
+        // normalize input into words and letters
+        const words = input.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 c = caseSensitive ? symbol : symbol.toUpperCase();
+                let encoded = this.encodeToken(c, configuration);
+                if (casing === 'upper')
+                    encoded = encoded.toUpperCase();
+                if (casing === 'lower')
+                    encoded = encoded.toLowerCase();
+                return encoded;
+            })
+                .join(outputLetterSeparator);
+        });
+        return encodedWords.join(outputWordSeparator);
+    }
+    decode(input, configuration, opts) {
+        const { caseSensitive = false, letterSeparator: inputLetterSeparator = '', wordSeparator: inputWordSeparator = ' ', } = opts?.input || {};
+        const { casing = 'original', letterSeparator: outputLetterSeparator = '', wordSeparator: outputWordSeparator = ' ', } = opts?.output || {};
+        // split encoded text into words
+        const words = input.split(inputWordSeparator);
+        const decodedWords = words.map((word) => {
+            const symbols = word.split(inputLetterSeparator);
+            return symbols
+                .map((symbol) => {
+                if (/\s/.test(symbol)) {
+                    return symbol;
+                }
+                const c = caseSensitive ? symbol : symbol.toUpperCase();
+                let decoded = this.decodeToken(c, configuration);
+                if (casing === 'upper')
+                    decoded = decoded.toUpperCase();
+                if (casing === 'lower')
+                    decoded = decoded.toLowerCase();
+                return decoded;
+            })
+                .join(outputLetterSeparator);
+        });
+        return decodedWords.join(outputWordSeparator);
+    }
+}
+
+class SubstitutionCipher extends Cipher {
+    constructor(encodeMap) {
+        super();
+        this.encodeMap = encodeMap;
+        this.decodeMap = Object.entries(encodeMap).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
+    }
+    encodeToken(token) {
+        return this.encodeMap[token] ?? '';
+    }
+    decodeToken(token) {
+        let decoded = this.decodeMap[token] ?? '';
+        return decoded;
+    }
+}
+
+function withDefaultCipherOptions(opts, defaults) {
+    return {
+        input: {
+            caseSensitive: false,
+            letterSeparator: '',
+            wordSeparator: ' ',
+            ...defaults?.input,
+            ...opts?.input,
+        },
+        output: {
+            casing: 'original',
+            letterSeparator: '',
+            wordSeparator: ' ',
+            ...defaults?.output,
+            ...opts?.output,
+        },
+    };
+}
+
+class MorseCodeCipher extends SubstitutionCipher {
+    constructor() {
+        super(MorseCodeCipher.MORSE_CODE_MAP);
+    }
+    encode(input, configuration, opts) {
+        const { dotDashMapping = { dot: '.', dash: '-' } } = configuration || {};
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: true,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'original',
+                letterSeparator: '/',
+                wordSeparator: '///',
+            },
+        });
+        const encoded = super.encode(input, configuration, mergedOpts);
+        if (dotDashMapping) {
+            return encoded
+                .split('')
+                .map((char) => {
+                if (char === '.')
+                    return dotDashMapping.dot;
+                if (char === '-')
+                    return dotDashMapping.dash;
+                return char;
+            })
+                .join('');
+        }
+        return encoded;
+    }
+    decode(input, configuration, opts) {
+        const { dotDashMapping = { dot: '.', dash: '-' } } = configuration || {};
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: true,
+                letterSeparator: '/',
+                wordSeparator: '///',
+            },
+            output: { casing: 'lower', letterSeparator: '', wordSeparator: ' ' },
+        });
+        let normalized = input;
+        if (dotDashMapping) {
+            // Map custom symbols back to "." and "-"
+            normalized = input
+                .split('')
+                .map((char) => {
+                if (char === dotDashMapping.dot)
+                    return '.';
+                if (char === dotDashMapping.dash)
+                    return '-';
+                return char;
+            })
+                .join('');
+        }
+        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': '----.',
+};
+
+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{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;
+}
+
+var KidscipherGlyphsExports = requireKidscipherGlyphs();
+
+class PolandCrossCipher extends SubstitutionCipher {
+    constructor() {
+        super(PolandCrossCipher.POLAND_CROSS_MAP);
+    }
+}
+PolandCrossCipher.POLAND_CROSS_MAP = {
+    A: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_A,
+    B: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_B,
+    C: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_C,
+    D: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_D,
+    E: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_E,
+    F: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_F,
+    G: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_G,
+    H: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_H,
+    CH: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_CH,
+    I: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_I,
+    J: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_J,
+    K: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_K,
+    L: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_L,
+    M: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_M,
+    N: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_N,
+    O: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_O,
+    P: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_P,
+    Q: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_Q,
+    R: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_R,
+    S: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_S,
+    T: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_T,
+    U: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_U,
+    V: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_V,
+    W: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_W,
+    X: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_X,
+    Y: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_Y,
+    Z: KidscipherGlyphsExports.KidscipherGlyphs.POLAND_CROSS_Z,
+};
+
+class ShiftCipher extends Cipher {
+    constructor(baseAlphabet, rotors) {
+        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.baseAlphabet = baseAlphabet;
+        this.rotors = rotors;
+    }
+    encodeToken(token, configuration) {
+        const { shifts } = configuration;
+        let encoded = '';
+        if (this.baseAlphabet.includes(token)) {
+            const index = this.baseAlphabet.indexOf(token);
+            for (let i = 0; i < this.rotors.length; i++) {
+                const wheel = this.rotors[i];
+                const shiftedIndex = (index + shifts[i]) % wheel.length;
+                encoded += wheel[shiftedIndex];
+            }
+        }
+        return encoded;
+    }
+    encode(input, configuration, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            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: ' ',
+            },
+        });
+        return super.decode(input, configuration, mergedOpts);
+    }
+}
+
+class ShiftAlphabetCipher extends ShiftCipher {
+    constructor(alphabet) {
+        if (!alphabet) {
+            alphabet = ShiftAlphabetCipher.DEFAULT_ALPHABET;
+        }
+        super(alphabet, [alphabet]);
+    }
+    encode(input, { shift }, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'original',
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+        });
+        return super.encode(input, { shifts: [shift] }, mergedOpts);
+    }
+    decode(input, { shift }, opts) {
+        const mergedOpts = withDefaultCipherOptions(opts, {
+            input: {
+                caseSensitive: false,
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+            output: {
+                casing: 'original',
+                letterSeparator: '',
+                wordSeparator: ' ',
+            },
+        });
+        return super.decode(input, { shifts: [shift] }, mergedOpts);
+    }
+}
+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',
+];
+
+export { MorseCodeCipher, PolandCrossCipher, ShiftAlphabetCipher, SubstitutionCipher };

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

@@ -0,0 +1,9 @@
+import { CipherOptions } from '../core/cipher-options/CipherOptions';
+export type CipherConfigurationsRecord = Record<string, any>;
+declare abstract class Cipher {
+    abstract encodeToken(token: string, configuration?: CipherConfigurationsRecord): string;
+    encode(input: string, configuration?: CipherConfigurationsRecord, opts?: CipherOptions): string;
+    abstract decodeToken(token: string, configuration?: CipherConfigurationsRecord): string;
+    decode(input: string, configuration?: CipherConfigurationsRecord, opts?: CipherOptions): string;
+}
+export default Cipher;

package/dist/types/cipher/cross/different/DifferentCrossConfig.d.ts

@@ -0,0 +1,8 @@
+export type DifferentCrossConfig = {
+    topLine: boolean;
+    bottomLine: boolean;
+    leftLine: 0 | 1 | 2;
+    rightLine: 0 | 1 | 2;
+    maxDots: 2 | 3;
+    dotPosition: 0 | 1 | 2;
+};

package/dist/types/cipher/cross/hebrew/HebrewCrossConfig.d.ts

@@ -0,0 +1,7 @@
+export type HebrewCrossConfig = {
+    topLine: boolean;
+    bottomLine: boolean;
+    leftLine: boolean;
+    rightLine: boolean;
+    dots: 0 | 1 | 2;
+};

package/dist/types/cipher/cross/poland/PolandCrossCipher.d.ts

@@ -0,0 +1,6 @@
+import SubstitutionCipher from '../../substitution/SubstitutionCipher';
+declare class PolandCrossCipher extends SubstitutionCipher {
+    static POLAND_CROSS_MAP: Record<string, string>;
+    constructor();
+}
+export default PolandCrossCipher;

package/dist/types/cipher/cross/small/SmallCrossConfig.d.ts

@@ -0,0 +1,8 @@
+export type SmallCrossConfig = {
+    isSquare: boolean;
+    topLine: boolean;
+    bottomLine: boolean;
+    leftLine: boolean;
+    rightLine: boolean;
+    dot: boolean;
+};

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

@@ -0,0 +1,16 @@
+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;
+    };
+};
+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;
+}
+export default MorseCodeCipher;

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

@@ -0,0 +1,13 @@
+import { CipherOptions } from '../../core/cipher-options/CipherOptions';
+import { CipherConfigurationsRecord } from '../Cipher';
+import ShiftCipher from './ShiftCipher';
+type ShiftAlphabetCipherOptions = CipherConfigurationsRecord | {
+    shift: number;
+};
+declare class ShiftAlphabetCipher extends ShiftCipher {
+    static DEFAULT_ALPHABET: string[];
+    constructor(alphabet?: string[]);
+    encode(input: string, { shift }: ShiftAlphabetCipherOptions, opts?: CipherOptions): string;
+    decode(input: string, { shift }: ShiftAlphabetCipherOptions, opts?: CipherOptions): string;
+}
+export default ShiftAlphabetCipher;

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

@@ -0,0 +1,15 @@
+import { CipherOptions } from '../../core/cipher-options/CipherOptions';
+import Cipher, { CipherConfigurationsRecord } from '../Cipher';
+type ShiftCipherOptions = CipherConfigurationsRecord | {
+    shifts: number[];
+};
+declare abstract class ShiftCipher extends Cipher {
+    private baseAlphabet;
+    private rotors;
+    constructor(baseAlphabet: string[], rotors: string[][]);
+    encodeToken(token: string, configuration: ShiftCipherOptions): string;
+    encode(input: string, configuration?: ShiftCipherOptions, opts?: CipherOptions): string;
+    decodeToken(token: string, configuration: ShiftCipherOptions): string;
+    decode(input: string, configuration?: ShiftCipherOptions, opts?: CipherOptions): string;
+}
+export default ShiftCipher;

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

@@ -0,0 +1,9 @@
+import Cipher from '../Cipher';
+declare class SubstitutionCipher extends Cipher {
+    protected encodeMap: Record<string, string>;
+    protected decodeMap: Record<string, string>;
+    constructor(encodeMap: Record<string, string>);
+    encodeToken(token: string): string;
+    decodeToken(token: string): string;
+}
+export default SubstitutionCipher;

package/dist/types/core/cipher-options/CipherOptionsDefault.d.ts

@@ -0,0 +1,5 @@
+import { CipherOptions } from './CipherOptions';
+export declare function withDefaultCipherOptions(opts?: CipherOptions, defaults?: {
+    input?: Partial<CipherOptions['input']>;
+    output?: Partial<CipherOptions['output']>;
+}): CipherOptions;

package/dist/types/core/cipher-options/Processor.d.ts

@@ -0,0 +1,7 @@
+import { CasingOptions } from "./CipherOptions";
+export type TextProcessor = (text: string) => string;
+declare const Processor: {
+    ignoreCasingSensitive: (caseSensitive?: boolean) => TextProcessor;
+    casing: (casingOption: CasingOptions) => TextProcessor;
+};
+export default Processor;

package/dist/types/core/cipher-options/ProcessorPipeline.d.ts

@@ -0,0 +1,3 @@
+import { TextProcessor } from "./Processor";
+declare const processingPipeline: (text: string, processors: TextProcessor[]) => string;
+export default processingPipeline;

package/dist/types/font.d.ts

@@ -0,0 +1 @@
+export { KidscipherGlyphs } from './fonts/KidscipherGlyphs';

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+import './styles.css';
+export { default as SubstitutionCipher } from './cipher/substitution/SubstitutionCipher';
+export { default as MorseCodeCipher } from './cipher/morsecode/MorseCodeCipher';
+export { default as PolandCrossCipher } from './cipher/cross/poland/PolandCrossCipher';
+export { default as ShiftAlphabetCipher } from './cipher/shift/ShiftAlphabetCipher';

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "kidscipher",
+  "version": "0.1.0",
+  "license": "MIT",
+  "homepage": "https://github.com/fandau1/kidscipher",
+  "type": "module",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.cjs.js"
+    },
+    "./font": {
+      "import": "./dist/font.esm.js",
+      "require": "./dist/font.cjs.js"
+    },
+    "./kidscipher.css": "./dist/kidscipher.css"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "test": "vitest",
+    "generate-font-svg": "node scripts/generate_font/generate_svg/index.js",
+    "generate-font": "node scripts/generate_font/index.js",
+    "prebuild-fonts": "npm run generate-font-svg && npm run generate-font"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.35.0",
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-url": "^8.0.2",
+    "@types/node": "^24.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.42.0",
+    "@typescript-eslint/parser": "^8.42.0",
+    "eslint": "^9.35.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "prettier": "^3.6.2",
+    "rollup": "^4.50.0",
+    "rollup-plugin-postcss": "^4.0.2",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "svg2ttf": "^6.0.3",
+    "svgicons2svgfont": "^15.0.1",
+    "ttf2woff": "^3.0.0",
+    "ttf2woff2": "^8.0.0",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  }
+}