kidscipher 0.4.1 → 0.6.0

package/dist/index.cjs.js

@@ -27,7 +27,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,d09GMgABAAAAACiEAAsAAAAAnOwAACgxAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHFQGYACmUgqB1XSBtkEBNgIkA4okC4UUAAQgBYQuB6VPG+GJd8Juu/FPFHLbIJLw3f+ADWrYNg3q3Q6i9H4anB1hYeOANZCtk/3///8nJh1jCCAD1NKq+vt/gjuPDKqtL7TWwRqb26g0WQ9xuqe4Ss46b2zRhkXsSjfYVskppIVCisOtjGD7zrw8ZMhngXMOKYp5uV7FCapaqL1cO8QLCpi72cpBJ0EJKIDCL/F9DfG292wi8PnyERTgjmQ/OjKzgip7ZZJLUB7yzfx5dGlniHj3zr4n/S1O4aaqcAmWstzffLeywriFBwHdff7fXPmze3tlcOjqRNmiJQjyhGjCk7lddfaer5LsK1wt23Jmdu97CDh0VZMGoUSd5Of5m39a3TcljW2/QQrQVI36sBQA/PP9xc7bXWwm8IiDlvwb5Rzc3yVdzqPCgdhNcnDrge3G3pEAAewsyzb2AZxRwZDqQqm5zp9mgBsY0KAMbvFZ8kQwJxsaQubPBvg3E/v7l15K9IBu4cU7bfrfMzmVClSoAj2Us985zeB4YFgofR22jTd+6TRygxlNGX07IyAITFwzZxObtQPUBEYDxdmvbS0NQsHCOXvC5wtMGwsdgAByU0hyh1cyc6mYATWfiL72/29ep5/X7Hdjytqn4d5z/bhTqhB0CQSYIrAtwO1qmZdM2TOMOZpbztvQRDaLUMkn9l4FBiFw39qrRhcXoU+ZicuLFB8IVQoEtzO7e7T/X4iUqCVUCK41DlCiNMi2UtVVSF1tmwlQQAMFtbHskCO1AmE9TZIs1elo0vkeDbEA/fszX2xgBIpYCCzCL/LpOkb5gHSBAbCSr9HkdrMMWIuiD/+Pq77ZQYJxCCOrWM9jvVHkq/ntUu6GtRp2I3FqXinSjEm7+uzGIxQSnrKDN375QJuC2WaSwssAHXlTO8AitJFI4gFkMhiczngAOsH8uOIEEJvKQduJoTXw5Ec/TFRsSqpH53ZGl/tBDiUnhBByh3kV/ZvZw/2/w7dGW2NEi1aiRIloU4HIQ1XcuzNuPDRAAgSSHTfpPmtDm/VlfdHWIwZHaC4HGICTHgU83ke1Gc4u1KUFbiLIZzLQbsosVeuG49fyfMfmjIxi6Mne4TcAmAzgxtk9f+a4H1gJJ+Tn8OCSKvgerrpwBOC8I1vqHHgFsAFYA9x/yPLrf7o+rH7WONeHV+t7x4bd+3aEn5//wY9p/A/33gAMMS5c+yubZEXVdMO0bDR0DEwsbByIqqYbpmU7rucHYRQnaZYXZVU3LSChrOuHcZoXxHXbD0BiUfPIUlsfc7Pd7Q/H0/myrt8/v3//SggTyriQShvrfIgpl9p6R2NxeAKRRKZQaXQGk8XmcHl8SCAUiSVSmVyhVKk1sFanNxhNZsSCOrC1W5c0y4uyqpu264dxmpd124/zup/3+xEQkZBRUNHQMTCxsHFw8fAJCImISZIiTYYsOfIUKFKiTIUqNeo0aNKiTYcuPfoMGDJizGQ6my+Wq/Vmu9sfjqcz8fw/xBONzsDIxMzCysbOwcnFzfGCKMmKqumGadmO6/lBGMVJmuVFWdVNC0go6/phnOZl3fYDkFjUdIYPlmz4AJ5tNhh5uMokzEAeFJ4iUIjCKE/Ki/KmfChfikiRKDJFoagUjaJTDIpJsSg2xaG4lB/lTwVQgVQQFUzxqBAqlOpE8akwKpyKoCKpKCqaiqFiqTgqnkqgEqkkKplKoVKpNCqdyqAyqSwqm8qhcqk8Kp8qoAqpIkpACSkRJaYklJSSUXJKQSkpFaWmNJSW0lF6ykAZKRNlpiyUlbJRdspBFVMlVClVRpVTTspFuakKqpKqoqqpGqqWqqPqqQaqkWqimqkWqpVqo9qpDqoz1YXqSnWjulM9qJ5UL6o31YfqS/Wj+lMDqIHUIGowNYQaSg2jhlMjqJHUKGo0NYYaS42jxlMTqInUJGoyNYWaSk2jplMzqJnULGo2NYeaS82j5lMLqIXUImoxtYRaSi2jllN7xAR1QV1SV9Q1dUPdUnfUPfVAPVJP1DP1Qr1Sb9Q79UF9Ul/UN/VD/VJ/1D8lUCIlUTKlUCqlUTplUCZlUTblUC7lUT4VUCEVUTGVpFJUmspQWSpH5akCVaRKVJmqTFB1NlSj6lSDalItqk11qC7Vo/rUgBpSI2pMTagpNaPm1IJaUitqTW2oLbWj9tSBOlIn6oxT1if1q7HpnzjrjC7oim7QLbpD9+gBPaIn9Ixe0Ct6Q++IQzwSkIgkJCMFqUhDOjKQiSxkIwe5yEM+ClCIIhSjBKUoQzkqUIkqVKMGtQgQIoIoYqhDPRrQiCY0owWtaEM7OtAH+kRf6Bv9oF/0h/5d/i0CwNwDAKy+sL/BrYN7nz9OrnSHM8mKicPF9TrM/FY7OulczTF3536nijWSUxl9TmXUTmX0bE/9cV1sT7dvxrdTfWy3kG9eitY4T7qc3k5X9zf3NlqOljo0vSffxDvK8lshIaNFUyhY2F5P4axY7+4UmylVHe5YT+GtX2AhIs5miiQb2bxPwvrl/qfpLpcaIsBW7f4uq9T+NeZBh9ZviNFxB/oxNIojIikiGr4utOwLtaXo7AQdFE5Dt5SwXgkxWkAcGp2xa/Ht8W2J7eiHm36YFbEWX4ev0YV7jxqtj0/bs04TeP34lWxu172CTTsVs2a+eyrndxevi24Qmq0/MLPgPMY07HArJ+sn6lX/c/eEeMFBt4ThdRyrawuAlDxkqlVvQ//+AknSHj8SJQg8MYwaYXVQjbY+V5ByDX0omJEcS28INLYpwU8e3NSjqaz0DhmmHzEQOuYPXENHLKTxqCPWRHo0RzW6r+Nbz0chtbjre3r15Aus89Jbt1FYrPA9XpFzxE2lEY5pZvssGHyb/b+sLuXsTLrt0ZxMmilTtMdk7WaF6eTy7YDFMpNNPA4iAgQRq6nqrF/u+Ro67bM9UKzlb9hnlxWy53PDDdtELKJJRmzzSLd28KHdK+vA4xuaPFwpsuLqmGCSnCqFh5XrdRhnIIg71IRNf5QrPpN+lgaOw86sjOx8RBIbyEJnsZ+IDcRcc+h7lCNHd4Uvquc0vEYDEJ8jG5kluzLyM/mdhzpRGFgwPktEFr4SHU9ldQHu1zg40SaHpOwVPsoJ8ZhxWCflrUTWlZYGHmJlmqUOmY39oHtcffViW75nYie3trORrJfKfOiR7M2KR5vf9qytXHOfNgP/PFJ9InOYKypfyYEj1F2nG5vxvKvL7Rr3DsTVH54sLzYme3R92fHGlQ97aA+R6vY1GjJez886P/ZBFMA/D21/WI7npVNBRvZsretI5UG/7itr8dgF1cwGmxvG7z0BxbVUnFs1FX2jZbbEVZ50ZGzht2NZcledph8vduY+VsC1VQVrdGicWOrusvJfu1GnS3x2a9+0prpktdjBNPeaWdwxwHXCVeerbVfDdhmjYAdDx26rbIwdbroBMNdJ1aKo+0DUbhi2qEikDFppNBo6KDqtG+uZo/2FpfKUHN+7DrtFV9Th6NpZbPO+45qdkuWutXqI6j9etkg5WP+K0GZRGxSnm+vYAq1aMdMpdboaHaY6iunhWgWAL+h4cNj83ueuTXbw5ll45lozBP7M7pKgd5YL05Xse0xmGXyU/BU0Ln2WFeInWXCN6Yrnf31z5GxOUSpJLyCbldzSy4fvNePkg6YBAgRucWZ/i5Lsr8ZY7RlbadwElWceKfPIKgfEYztKc4z0Z4kOJwUroi6qMJb2LnL+Wt9LtVZq2AsK1jFndvgzac5xrN2QNzDLHwfbZdRZ3g5r++VqcbplCTFGol92mb3d7DvH2E629ZjVDisdiAMCE5uudZqYmFfpQkzpYKVOvXg5gj1z+VX0Rcum/5GgTo/svlT2uu8gc2htpZG53XPqxfYHxOb6xEdX+EnXcKM0hxFB7Ggq0JfWqK2KwlNZxNcoGdFi5C7RMjZqhH3ZL09EVW/IV9eO2BB1f2tMH2ZqwfONy32wkqgT0+NDhGG7miWmPHGG3+DUteesEw+3gV2P8rQ2q4PaKr0G0FR07uaktVtTb1ttdolOw3rpwiUfu3spkh3hmWelk9hUldmKAHLX+KIS578s4+0m/QbF2uRlr0ZK5yjeHdcrdyy2VEdubyEjRSMrrL9gw46iE7OdceYkftNasqXxsg+lV96YTk3AXmdVAoaNfYT5i48hYQkF7095Fxh6PanCkU+Wesqhsm+y+Djpq++D5n2i9K7ybkcX/9Gqjrcsj2X6fpNLiLGcNL+4VTv8tLRgjQWGqOOM28oj6McP5hN32fPPKm+pn9sBSw+NlXNUYetw1wdvmXdRWO9KfrPjOr7j/9wo8sRuL2XAtTG7796itkiI54UJW/k/GeuOpj1pt1JPoqfyVnGtnqWiEnl6BB27bcVMnX/9Qy57xbI1IFRGzOnOfBKkUqjLqre8F0OZKQ33l9lVh6oIEiBuo8oMSRjrsKpr7YYkuV1iMJYCLOhNPTMtzowI6D/flNWNBJgBN0nrpChuLwnFco+7tDdBhBRhDrdzGxamtftB1fTUUnqoqL3SId0g1Y2gjzVCvoVyZrY+kV55pFfCvGWcDVqkSEpiVjJcJQhs8eJiWhQt6imqhTCCEfZIIIepJs5FbDy5LX2L7jtzQpsk6PeZyT5kScRhv8fLXDExwf/tcQnfBOf77rTA96HDgyeeUQ3eWlA65Tq01HsVLUdnbRw7zM+gQBoXXW+zMROu2LqHhucgukWezdJnPIdNPR3xftD4/y9/af+/eFq8qD7zv3AXX5Xfwnh5S332P7HQ6ciuCm+ZIXGf4+g0TkMzcv8BGB7CQMPHJLBDYLxJH5olLzl36hCA9Cq1eDPZwrckd2KExKOLYCdUAuFU9Ei2Q0HG2l9Nyt+DkvEf4ySU6MKU6KLU6IKc6GKc6ELs6CKO9Gl+CtOUFyggNOrzngBK918IuXGPelpMDL2zxiZPfMQcxkndaMV7KiuQ6T5++RoH4BkdyNhq1CBD9xaDRS2tCJBHZkgJY508NHtbtqq7ZSOYRn5S0ntzvlyrodZcuhxmYZXNsc/WOzdzcOW7nmlp6TBO2utTG5/ZQp8hNd3yUrCdDwjA1YWEX2iKm93zKJxrdFO9SMmYrVOq/D7jIWLiDEsLqjIDY6WhQWVeoTCMmF4IAIvfqTB/fA9ubYEXRWNsPAF/B2psayu2Yv+uqjH97NFDZ1AkN7A2NbO72Wg85TYqTa6ZOnokAvUxjDHn53SWLSkDc06V7EYiCEZlovoKD3lPtFqP26UlGLjy0Mabaxnqvn5dYbGqusk1kVmtx9icfYcUMvlRPc7KVWsl97T57isuMHCaNokVb+OYLC7+NIIMuZaF+8OApixY+I6lUaEhZCUDQkVWelujqh5shvOuXGE2SwV7WiOusbVyJ1xW2q8JvfucPDk9B/ulq7JbtQmkN1tNP9JMfm3/XkF/kypkeCozUQ1umcgl7eVqCx1BA3Jx376BDzIsK1Pm/RnLEFRMk9xdHBJtrrdUmyjtWOKngUDJ+L4fOG9ueuNtssxdqtmOBCN4P9ZjsZ8lfdVEWIEUjOoCxZarV1OaWFLxgOnZs7OwuUIVMhGVRJzRkf7lbVmQVNLtzRvKGiaNYYJRI7f3xu1Rs7mkgUsPfMDVnTVcTFtmjBxbFZd7D+3npdsytxa1iodsKlS10zbcx9eKrbrs8u3EyQW22BLuztdLYGNiE7PRXEvFBfMLq8a8SQk5ePiWTuvpFWV6ePnmvb76NNLTZ9v3K7qjBPJ+d6d96dl7LoGWP60ay7RHu/2mEyc/FVWTO4PZ6ZRkAAK5iMmU9OQfMnMFOcRwJfEoHhFnBJ/B3RzmtafjGFuDCh1iew4NwXtk++46gjJ5yXg5557GrXOEodmonvUoL+fY2MAf27BFJyRjd/3BDp1ltUMhUejXXDMSZWVB9sKuUf09xm3LUsgY3gmzc0fWi6YJfVHUdUti0rHDj/h8k1AyvZE5pViuBz3qVzc2IPeP5od2dgXGYx7IExs6DBrfAVdfoPzH/OYUfQJI9dsQj32l4n81ROBKXsFfcw5BnBDIJxN2qsAiuQbunFwZH7rEDLe+sRfiyarg1yM1879Ch2dJIsg6mNM+BSnaeAAF2vhYtUEtzMN359HifIX6gEabbGBIbnIjduk4CPWt23fGg0K/2jJDShRdeFr+1vtohZNdBYX57jgBp94VqtAmha80J8He7NFDuQzVC4XO9PSm+uT6+yWwz4NTF4qd8m4J8xjDinCFVsebjfOVlBYzliYYJw4wG5ORFcyYQUBtYdZezcPLAxuzNwiNWGu9sa+NY3ltauVKv5WXRxmWwTxrCLs61abrwUi07+gxpawMFzcLFCOefRAa+PyM4PTtNKVkgnDfkiVEu2si1j3i9KeBXMbw53LpO8bG4IwtrQudzrxh5qxjW2kyb803228EFyYFT2EXpdKnWn1ubk4ZIMlxCG02AOyura0NrlU77SN43seKrD22aqKieIOn5w6v6Gpy0wyPXnvNAsggl+vVuEXRrzfXuimJYoHi0IPMJj1gqh+ULSvRpjo4zTdSxw+usZpAQDA0ShVpTGI+fSNPRt5x9nwY2l+02VEm5jLWqTKJMfwbhmAjCrCU16XwwoXpXqQ88gbmNpBi2jcPi+parb8kKXcJYkibRCCO+pTgF/8UTC/KRLpcgQr9ktWNXl/CWKWFmVy8tiVTLQIiORDthN+fsjteD/igp9WTFEeIZimD94uFCNKYTL93x+7x1TWhGTcIm0eZbDqzmRUAYNp85JgTEzeUjbyWjco0Dayh3KXQftPSJf2PXb0Yr/n8yXx+NpvNFIr3mRQdeKuEFms2D2Lhvnb6ziFsedKq0PjcBCXxUElZVXVvP/zGzbHNrDhhtix4mCCURR7mbciRRGdk+hq46iOfgkcUmj4zOmiafEZ7BEG75t/QxBLSKFfX9n6IsSmZpHybMHxWqYLiRZT6K2R3uZ4SmZD4/kDjCUkgzKhjiT9ix86LlPJOccdZc9/MkAbHxkTs+6BX29GJVlsR1n0kJk2bwHSPmG86xWDTa+ovryD0zQsKUZijfOc9/gl3MGn4itdny+KDWFh4FRbHjNnQSazHITBURyd8rMDkEzE+NxMBuoCt24gRHLzxU8rW//ewsUBjOwiAWwGu0UTg/pvP/xsKLeMRlQk0Wa1NMnjq1LAJiWLFRFOWUYA7mnWORCTKDmlosY0es1azZFDseXiSj0PGP/NsZEkGJxwKzAMLSkNbWk5+t7URmPAqjPxvVRUQQkP+GEXe2otRvNBynTJRegngO3iPeVUnChh4rm1FZfVo4PV4T+9lfCL/VycZp3uWxHpczKXcsXtqQOAc0oZmQiA3Xa4l4VG09JorFS5DXz8i0QQAEOLjU8MEmluRhNOIphabkb3lLgKWICkuoU9e2Afx8OH0K9SwBylz3WOs2b3p2IMFlTYNP8d+DUH0uEBRumfsOHTpUh2GKCRhhKlqHQDv281BXvVzutL7z9mnTepXbaRtitAhlI0Mr7xMrqmTofCbwQg2MWE6WZmqOWDuIEZA2Eihc319zyVmCqxvLfCOnRmZlZvVZFRMjXjtfHddPHyg5H+gZ5qZTbC0ntfrliKIOKk0XJ6bI6mWGJILIiYLC1TUFWF/fX7qGO6TuxfDck4fT0ri8oK8WTLf+vShh7S+GwA0fqbheFhklByW4bTCJctllTnS3PsytE8TEzrHWXN+5DetJO7s6tc5KhKNm4w7nmBqSAls+OxuuFsU7aHQXYzFFIrordK6NEXFV5CVU6rmjby8CMp1dbtuegPbGxwz+6eBjOlAhvnoUV0S1CXY6MHWVyuvPGEnvvmsRXDowrYjBVvXuFOmnWSb6hYWFy/pEsylc+aXzLEv8Yquo4cmnFW1taUI2kOheYVFc7kVooXCR2cI0icwMKMo+oD8yvGB7mxIeOoFll/0Fjaa/HU86FvD/4RwNxCU5XnEFx3y8QUv6KNfiTDU/HZveQrzzlCW4XS85j3GrxJpR/X4YKaorAxWfh6s6O2PAUCzLDV1JmYQ1RljmQjMbWb2TafvTUm9WCe5IiLHeOUlIEf05upsCHvfSU2Puu6QEvsNDs7JQmFM+CnvWT9us37SMakI0m6ZYnDIYFti4pVjeXr6eaCZTcSZt0JuAT9RHsQofp9IXkWjoS1tXGg21sLqWecS2CXyTFti0IaSSoCRR47XSOIT5QkS+hbcgpzKQDkWLgcLi/TkFVjcubePR/PkrraCaKuBEEgwahzWgWqrtHwdj5cHpqM+k702dRDo2hOTvWd+PZ0nqHcVfPTIYjDoaSoo5du+Uqs+Drh0zv2UBFY9dpV+m76Q+o0nq5Fb5eTQShDo3474nCN54w22UrI0xz11pLFJRW2K/etZhZuaSXkhq7V27JThRyx2EdzmNzSZOkwj3EJU2WQdY25h8w8ZZVi2PkF4VZLLBp/T0bdDWdWKtfytd1hkopz7GgiEvc9sPfUWCqKK1PZntBDZjerNKUYx6NNBiF/HsmaahOkRmjTzN8V+VZXY4G2loODNeEhRchiiNbGtyUlIws89rqUdyFN6+xPV4cA0f8BnvAdZvTn3YTHN5FrgpcM40MEWQcYe9aFA4GEKvcD4vVIzGDe/oJ/m4t6AUQDHpgvw9blTGrOgdN78a+wNvvjcztHgWlQEHWGlO+p9Jptoadk7B7F4srIoKBy+SIknvhdBiLvswinuywJqCYJiQKSzSZpgLlK2b2EwZdjFcTH0GPXjVj1P3tiLAeG6uLZVQ+vV8kx1HgAGBgYMiTRWY89BXNiuVBoUWHHR7a5sac/BkADKtNOcngJ9Qxd3V2ycb2IO/Wr9Dy+cduHyEzwUg2i1xlmzu8FUYxHLdbtXrarDdhBdvaDna2qHpqZHsl2Xtcg3z5h2jaFsmDKKJ96Smx8qiG01Ht7PZBFaUcQ2NCDE1CGR5i3MGn7zpkhlC1VUnFBGj6dSH2Aanbc9Pejb1+sIG/e0mwaBuz+TmU7lZ0DKtsCfNRi7gWB8QfE7z0GIhcWQ2pFa3t2yxs8oqb+Z2xBfMtuctwnEdd3GzCwwrVhmeeMytCjNEHvxSvwoEKI6ustCuyOlEs0AbSDMG5tdAQEfABZJEW8rsUXt2E1nQVBPBYl9bPaq15B35onTNjtFWaIq+zKwoqeyYWc95KqdKLeq3WXrrl6fBtKt0KDGwxk5TAzLJPEJkyTVFYO5p0kWV8rd2TM6924hhZknt1UqPDdA75khjeGrN3p4v0JhzQBQV2QKccrGS+7iq/m/wuft++5vbtgEohvTN1Qh0F4VtQosRB9/VYqSkkkBf8ybwzFY/WFIZ9xu/MnTH4UHCPJcdvPGrVsf4MH0VLFo2ZMAgseUopdpihfCtK5vaGr2RvaFsfpG+rS7BuNGKPuc0rGBgf96hRoszUKwgQcOtrjYTLHhJVA/BfGN3vbBLu42DW3La4XIKF6WMBA7Yiba+lKoLoIED0ULTcl9jPW9oSiCPK7gyAs2cqP2B8NSamON23PywHw9VexQ9qLfYinRkHakG/lnZiVEYSgN5U/ZD73HFQapY8YRFhbMaYb2MSKieZHyKNzxtXrdpUe9rlOlADWiwmNFsJsEjHEAM3m2t+9bNooBPUf4udbdCAWF7nGTFrlEVJXobu6nsscJTyUttTeb3TpmyYTSevK+GyeI+ttxpj6+cElduLjA42f29PipDZ1jaKydLr5J7I6Kq1dgaqkWxXYAnOWBgYTfm0d3K0jYF9tmtrRNONkwCjXNuYeKwkGijauphRLIvcKyypee33M4sGBa97DnzvG8guWvTsfw8f0VKJSdE2Uh6w7kbbBVcWf4nyQvVrT0s/QoJqU8FAwL/IsGhER9smM9TElmfLX3nr5YHM7dwAGEvEW2BDNZld0RtM5vYMuul0CrrPlABEcJFWOcM4Uh+VvumiBD2a57godpcY/J7adBTjZDOlxAqJow5BZOI2BQP79Ccbm04oJPoI5o21zcj2Wl4Y4OP1iygtkJQASizqoEmbDX7IhcBUF4wV3pxspjV3eAVyMkKMlsqMi6NSP/A4ddKioY04bm4i48duxOTdG01phdlMCUkRxGD1dIdjitVdagbghbOsc+Um9Xam6DeEZnBzPjNQ9NScCCN9TLfjFJbBonwBByNhkAwrjpNVfJrlQ8k3i5SJB2I1VTrxHWd4R0T2EDPpFEj3noN2tmVDJb1YYY6D1SDWpDDRdtkct0s2QB7W1HMFWuPduNii6k/bJ7IxKVnKutfS1klUx7NYE8Dp0KbL+QrH88cmTecfQ4gG2b4OEtK41PDkH2Ii3OTrx7EiJYmfsZwOTtTW5P4/Fa+uZcsFBFsAa6B2E7WiodQUy7X6t9uXCRkzj8YudNaW/+y9UmKSqS5PKm9DbYrQLHaVY1HK2qYwghGCcYaIoNZ86/l63UqyLMY9Yd1rjKEVVN3uJGDvHOrJkzrSClKjwRGES3bapqcWlOU57KvLjPD1BhEeLi0UVgMW6RQx+/DC32D+ftYi4XvnX0IkGGD8oex16pxg0SKRTUxMCsJ0KFD5jCKK8Xoy49Q7PS1M9NiTg4odO2kyfLvIKq2iRh7sSFSHPevE/c27sqHeQcG9nPH9Hd991eWFUkdCvosBc/LlrWhs2vi2ShiLj6wAEXVWqLiY3xhTPtr7bAW7d5euKCwx6s+5rgw4DcOdsSKLwHGTWGsqKCwZJgJvZ+Jh8kCNfCCoVA9gQPya6t8E0BFTJ4bzNm92gfDs2UC+UZdLgnt+FSLL2y/yICv0K/KcS0VUBwpJp8MmzfeYHCh2CE0EuXevOjIacgTxk3OIfhLQGBa1gnJSkbMTU0GrO27sqV3NQKEWlbEme0x/ZzTEyif3ADdBFplBjF/PWSK8EJ/mhSKCqGatmF1VVGRVU/Q4pEpOxzgowS8nF4OIyTRvHusF+FIzsLYW4FViHIGnYbeYNthmhQDbRN3va0tKva/fs7ut9hGX7TEnae9b5zB4B2EnpyxnR4mAaPVcRjC+zYd7r3I4sw1wgjTkqA5MR4u1SwRJ1XnLJUyWeCAHqQlXjvImVgZvdW2qFBffUKASKJZqPkl6e9/jMpm0vxg6lp+n1K/EZtwRpCiTC3fxkYNJmZSLdpVJ47odMGCelVKCzpag4jhHK2hjgIxct7qkvyme9b8aMWeBzBxa+opliWirXio1h+LepVB1WoSIG4sKZk3QjAqlbyoEmS9/uRwYPdO4dCJt/dY7W8lEBPnVxzOKfqtT6K8i5JC1m6eK1a/J49bzwsD/p7QfESY0atZRoWwLQ0Dq6PEm3vhAmVbBRMrO27FQv4HlVhCPu9y2R5jPDH5iTc0LDbElXs7kxE9VAhbzOTmBJ2xNbMofRnnlZKxn37UbtPEFVSO0ifSNBXkeskOOPCt+n8Mu+Sqghljk4M0JdOO8LDx58YeGHhT/iNAPFlPISp0jA5lBEqCJ4kIkNY52dYnd55nsgdAc9I8cDxiPAoSqvEC/mJQHWFjzAd/W86GcJBRHiP8RTCFAJhbzKd5o4epSzh/0XllzDMkt1EUKPfWVTuyCjhAmRMewakV/IoNAA/078sFPCfQiTGKtqvLEQjeuOagGAbZ8tOoUKOE2bpFRBCcCfVFiHUsThSu4QC2tKgY7u/cR7hubRWevSEcZXd0lHdMbdAeqax8FFbpINMCtGs1iiiA+ksyjZgIxP2atcYC3AJ0w9DGcun1hhselJQiegWE50sa+9ngyh1wswqa0T3MjV0mV2izGOxiy0UHZkoarZ1+w1pPOH1318mxGvvuU18XAXaUtJzhPBr3W7s+8Cb8uvqM5uYkor37P+4XFWT+Ye/R76b6pmS3yOH46T6lNwL+wXK5D9YdEelmMEmHt6e8zh+Lvb6W1bzkiWGHtV/kdXkGWDqX1uIO80TZj8fGaTzGq9U2QYQr2iZIiDwyqe3XvAeiKmvFLCfyVC769V+P37atSi5P1MAgEgCAKCVAgBQ5Uu3/SizME1lNP0YlmtC+dC/nYBrUs13c/0/AIBoAADglAkZbMmvXrTUm2vbW6FR0E1SQ/izpSsoDKRQZ5YZexMZJ4F5EpZiXOKiQNrhOor60yl7l+pGzZJnETQThwFxdPztCaNHui21vLmF8cJAubWSe5fMyHxpmmb4LQuBaL0tNd4qPZV7MTuFZkQlpfGyyPvjyrQbrBBlhNId2maUq20EtL21llHhMlioQBRzqqKmLeQRkyVcbQqK2jMVJxMJHdXPxs2xPQP1WKIII5zozKBWodXO+rqzkaigEons8ZpFdbMFSWktHd2EYOYQFrO0wTqR56VR36bXaNBUN7q7ZODMbDuoQku1mi0RMaAZuaSUlHYWhTMzsMXEXRyxaPyogsLurQT6NjN3qQPKZstSfiMMFtv2YAQd1awlM41KqjnhiBoiqEdMNHgWwLk0IvlNCHUlizxeCyQ9rmft21ty/LAwo4vEfwujmJHRXmZLMqpFiQZEKlHqFvUXT3S/PehvpoJT8RuWGbVwZSYzGxotcDVa1Pw3epsUueS3YTkk2vIbq0EwcnYXjXce7dhbKVNtF31By39XPFtP9JZJtLWa5be3xjKio1qQW799Sc9SDMU0u3IOfUEljT3vLKdcsH2MXZKAForyK6FED2sXiKWvAUCjcrhr6QcAwKPGQPVUXuz0Gee55es38AKAvy/wWR5+rltxnCA4EFKEfzuQf3MX/IPc/vSlqL6GPko+dC75GI6SU2GAuYc3TgIArABOtqX/efO8Y29X48xsIKuupGsB0fVF8tCx13NrG81H21c9Hs2vHCc/5VRtjZc30KVHosn018xlVof3jO1HQ2xfDWP6aT7W/xPyjRi8KVqIipLlOxPNojzQpZF3uYeigodlnCcqJ+br80WVUcA7lC7WWjnwHBwcg6/M2gCxd3DNSB1lrXGbJj53Q0YS3HBTtBAVJct3JppFyJ3kOP5uPO69Ch4sRnNQxynuL6qonq1NAd6brUsXq1pUOVTb5+DAMaIvMGqzaLgdj/NLNSNZfSRXLI2bqbDjofURiVI45Nj74ZBfyLt7/LvQP+3lar3Z7nhBlGRF1XQDmNCyHdfzgxDhKCZJmu3zoqxo3RyOJ9Z2/flyvd1fAiAEIyiGEyRFMyzHC6IkK6qmG6ZlO67nB2EUJ2mWF2VVN23XD+M0L+u2H+d1P+/3C6IkK6qmG6ZlO67nB2EUJ1PpTDaXLxRL5f8sfPNr9Uaz1e50e/3BcDSeTGfzxXK13mx3+8PxZI2O0n8dJldQVFJWUVVT19DU0uZ4QZRkRdV0w7Rsx/X8IIziJM3yoqzqpgUklHX9ME7zsm77AUgsah62yRvye1To/Efbsdv9QRfAAejRxpdsGCCAAoZdDRBAAgWoQAM6MIAJbIAtsAP2wAE4AifgDFwec92SR5ed/MHfE/GuOWnS/Oyv8MVX33z3w899PR40KIqiKIqiKIUkSZIkSZLksCzLsizLshJRFEVRFEVRo6qqqqqqqlpM0zRN0zRNj+u6ruu6rhsJwzAMwzAMM2mapmmapmlJsVgsFovFYrGmWq1Wq9VqtdrSbDabzWaz2ezpdrvdbrfb7Y4Mh8PhcDgcDmem0+l0Op1Op/gIhBBCCCFkKKWUUkqpIqWUUkopHWuttdZam8QYY4wxxqbWWmuttS5zzjnnnPNynud5nud5JreyXC6Xy+VyqYr1EXULtI/R/z4Ax7MDQqCJHbxvEARBCAQCgUChUCgUBoPBgrVkSbsGtX6aunuiJCuqphumxWqzO5xuFEIqbazz6j8AAA==) 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;
@@ -365,7 +365,61 @@ function requireKidscipherGlyphs () {
 	  SMALL_CROSS_W: '\u{e145}',
 	  SMALL_CROSS_X: '\u{e146}',
 	  SMALL_CROSS_Y: '\u{e147}',
-	  SMALL_CROSS_Z: '\u{e148}'
+	  SMALL_CROSS_Z: '\u{e148}',
+	  HEBREW_CROSS_A: '\u{e149}',
+	  HEBREW_CROSS_B: '\u{e14a}',
+	  HEBREW_CROSS_C: '\u{e14b}',
+	  HEBREW_CROSS_CH: '\u{e14c}',
+	  HEBREW_CROSS_D: '\u{e14d}',
+	  HEBREW_CROSS_E: '\u{e14e}',
+	  HEBREW_CROSS_F: '\u{e14f}',
+	  HEBREW_CROSS_G: '\u{e150}',
+	  HEBREW_CROSS_H: '\u{e151}',
+	  HEBREW_CROSS_I: '\u{e152}',
+	  HEBREW_CROSS_J: '\u{e153}',
+	  HEBREW_CROSS_K: '\u{e154}',
+	  HEBREW_CROSS_L: '\u{e155}',
+	  HEBREW_CROSS_M: '\u{e156}',
+	  HEBREW_CROSS_N: '\u{e157}',
+	  HEBREW_CROSS_O: '\u{e158}',
+	  HEBREW_CROSS_P: '\u{e159}',
+	  HEBREW_CROSS_Q: '\u{e15a}',
+	  HEBREW_CROSS_R: '\u{e15b}',
+	  HEBREW_CROSS_S: '\u{e15c}',
+	  HEBREW_CROSS_T: '\u{e15d}',
+	  HEBREW_CROSS_U: '\u{e15e}',
+	  HEBREW_CROSS_V: '\u{e15f}',
+	  HEBREW_CROSS_W: '\u{e160}',
+	  HEBREW_CROSS_X: '\u{e161}',
+	  HEBREW_CROSS_Y: '\u{e162}',
+	  HEBREW_CROSS_Z: '\u{e163}',
+	  DIFFERENT_CROSS_A: '\u{e164}',
+	  DIFFERENT_CROSS_B: '\u{e165}',
+	  DIFFERENT_CROSS_C: '\u{e166}',
+	  DIFFERENT_CROSS_CH: '\u{e167}',
+	  DIFFERENT_CROSS_D: '\u{e168}',
+	  DIFFERENT_CROSS_E: '\u{e169}',
+	  DIFFERENT_CROSS_F: '\u{e16a}',
+	  DIFFERENT_CROSS_G: '\u{e16b}',
+	  DIFFERENT_CROSS_H: '\u{e16c}',
+	  DIFFERENT_CROSS_I: '\u{e16d}',
+	  DIFFERENT_CROSS_J: '\u{e16e}',
+	  DIFFERENT_CROSS_K: '\u{e16f}',
+	  DIFFERENT_CROSS_L: '\u{e170}',
+	  DIFFERENT_CROSS_M: '\u{e171}',
+	  DIFFERENT_CROSS_N: '\u{e172}',
+	  DIFFERENT_CROSS_O: '\u{e173}',
+	  DIFFERENT_CROSS_P: '\u{e174}',
+	  DIFFERENT_CROSS_Q: '\u{e175}',
+	  DIFFERENT_CROSS_R: '\u{e176}',
+	  DIFFERENT_CROSS_S: '\u{e177}',
+	  DIFFERENT_CROSS_T: '\u{e178}',
+	  DIFFERENT_CROSS_U: '\u{e179}',
+	  DIFFERENT_CROSS_V: '\u{e17a}',
+	  DIFFERENT_CROSS_W: '\u{e17b}',
+	  DIFFERENT_CROSS_X: '\u{e17c}',
+	  DIFFERENT_CROSS_Y: '\u{e17d}',
+	  DIFFERENT_CROSS_Z: '\u{e17e}'
 	});
 	KidscipherGlyphs_1 = { KidscipherGlyphs };
 	return KidscipherGlyphs_1;
@@ -636,7 +690,7 @@ class MobileCipher extends SubstitutionCipher {
             output: {
                 casing: 'original',
                 letterSeparator: ' ',
-                wordSeparator: ' | ',
+                wordSeparator: ' 1 ',
             },
         });
         return super.encode(input, configuration, mergedOpts);
@@ -646,7 +700,7 @@ class MobileCipher extends SubstitutionCipher {
             input: {
                 caseSensitive: false,
                 letterSeparator: ' ',
-                wordSeparator: ' | ',
+                wordSeparator: ' 1 ',
             },
             output: {
                 casing: 'lower',
@@ -792,39 +846,6 @@ SpiderCipher.SPIDER_MAP = {
     Z: ['CO', 'XY'],
 };
 
-class FractionCipher extends SubstitutionCipher {
-    constructor() {
-        super(FractionCipher.FRACTION_MAP);
-    }
-}
-FractionCipher.FRACTION_MAP = {
-    A: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_1,
-    B: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_2,
-    C: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_3,
-    D: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_4,
-    E: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_5,
-    F: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_1,
-    G: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_2,
-    H: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_3,
-    I: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_4,
-    J: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_2_5,
-    K: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_1,
-    L: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_2,
-    M: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_3,
-    N: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_4,
-    O: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_3_5,
-    P: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_1,
-    Q: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_2,
-    R: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_3,
-    S: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_4,
-    T: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_4_5,
-    U: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_1,
-    V: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_2,
-    X: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_3,
-    Y: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_4,
-    Z: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_5_5,
-};
-
 class PolandCrossCipher extends SubstitutionCipher {
     constructor() {
         super(PolandCrossCipher.POLAND_CROSS_MAP);
@@ -894,6 +915,109 @@ SmallCrossCipher.SMALL_CROSS_MAP = {
     Z: KidscipherGlyphsExports.KidscipherGlyphs.SMALL_CROSS_Z,
 };
 
+class HebrewCrossCipher extends SubstitutionCipher {
+    constructor() {
+        super(HebrewCrossCipher.HEBREW_CROSS_MAP);
+    }
+}
+HebrewCrossCipher.HEBREW_CROSS_MAP = {
+    A: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_A,
+    B: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_B,
+    C: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_C,
+    D: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_D,
+    E: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_E,
+    F: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_F,
+    G: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_G,
+    H: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_H,
+    CH: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_CH,
+    I: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_I,
+    J: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_J,
+    K: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_K,
+    L: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_L,
+    M: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_M,
+    N: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_N,
+    O: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_O,
+    P: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_P,
+    Q: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_Q,
+    R: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_R,
+    S: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_S,
+    T: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_T,
+    U: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_U,
+    V: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_V,
+    W: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_W,
+    X: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_X,
+    Y: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_Y,
+    Z: KidscipherGlyphsExports.KidscipherGlyphs.HEBREW_CROSS_Z,
+};
+
+class DifferentCrossCipher extends SubstitutionCipher {
+    constructor() {
+        super(DifferentCrossCipher.DIFFERENT_CROSS_MAP);
+    }
+}
+DifferentCrossCipher.DIFFERENT_CROSS_MAP = {
+    A: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_A,
+    B: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_B,
+    C: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_C,
+    D: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_D,
+    E: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_E,
+    F: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_F,
+    G: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_G,
+    H: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_H,
+    CH: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_CH,
+    I: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_I,
+    J: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_J,
+    K: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_K,
+    L: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_L,
+    M: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_M,
+    N: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_N,
+    O: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_O,
+    P: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_P,
+    Q: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_Q,
+    R: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_R,
+    S: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_S,
+    T: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_T,
+    U: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_U,
+    V: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_V,
+    W: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_W,
+    X: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_X,
+    Y: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_Y,
+    Z: KidscipherGlyphsExports.KidscipherGlyphs.DIFFERENT_CROSS_Z,
+};
+
+class FractionCipher extends SubstitutionCipher {
+    constructor() {
+        super(FractionCipher.FRACTION_MAP);
+    }
+}
+FractionCipher.FRACTION_MAP = {
+    A: KidscipherGlyphsExports.KidscipherGlyphs.FRACTION_1_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_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_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_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,
+};
+
 class ChineseCipher extends SubstitutionCyclicCipher {
     static generateMap() {
         const map = {};
@@ -915,56 +1039,35 @@ 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
+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, {
@@ -983,8 +1086,8 @@ class ShiftCipher extends Cipher {
 }
 
 class ShiftAlphabetCipher extends ShiftCipher {
-    constructor() {
-        super(ShiftAlphabetCipher.DEFAULT_ALPHABET);
+    constructor(shift = 1) {
+        super(ShiftAlphabetCipher.DEFAULT_ALPHABET, shift);
     }
 }
 ShiftAlphabetCipher.DEFAULT_ALPHABET = [
@@ -1016,64 +1119,28 @@ ShiftAlphabetCipher.DEFAULT_ALPHABET = [
     'Z',
 ];
 
-class ShiftRotorCipher extends Cipher {
-    constructor(baseAlphabet, rotors) {
-        super();
+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);
-        }
-        // 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);
+        if (rotors.some((rotor) => rotor.length !== baseAlphabet.length)) {
+            throw new Error('All rotors must have the same length as the base alphabet');
         }
-        // Find intersection of all arrays (items common to all rotors)
-        const intersection = includesIn.reduce((acc, arr) => acc.filter((x) => arr.includes(x)));
-        // If there is exactly one common index, decode it
-        if (intersection.length !== 1) {
-            throw new Error(`Invalid decoding — intersection size is ${intersection.length}`);
+        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, {
@@ -1100,13 +1167,13 @@ 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 = [
@@ -1160,9 +1227,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 {
@@ -1304,7 +1371,9 @@ ChessCipher.BASE_ALPHABET = [
 exports.ChessCipher = ChessCipher;
 exports.ChineseCipher = ChineseCipher;
 exports.Cipher = Cipher;
+exports.DifferentCrossCipher = DifferentCrossCipher;
 exports.FractionCipher = FractionCipher;
+exports.HebrewCrossCipher = HebrewCrossCipher;
 exports.MobileCipher = MobileCipher;
 exports.MorseCodeCipher = MorseCodeCipher;
 exports.PolandCrossCipher = PolandCrossCipher;