@irfanshadikrishad/cipher 1.2.0 → 1.3.0

package/README.md

@@ -2,9 +2,9 @@
 
 A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications with zero/0 dependencies.
 
-![NPM Version](https://img.shields.io/npm/v/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=81B29A)
-![NPM Downloads](https://img.shields.io/npm/dw/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=BE9A60)
-![NPM Unpacked Size](https://img.shields.io/npm/unpacked-size/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=655699)
+![NPM Version](https://img.shields.io/npm/v/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=141b23&color=%2385c1dc)
+![NPM Downloads](https://img.shields.io/npm/dw/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=81B29A)
+![NPM Unpacked Size](https://img.shields.io/npm/unpacked-size/%40irfanshadikrishad%2Fcipher?style=for-the-badge&labelColor=202020&color=BE9A60)
 
 #### 🚀 Installation
 
@@ -31,12 +31,12 @@ bun add @irfanshadikrishad/cipher
 Import the library and use a cipher algorithm:
 
 ```ts
-import { Cipher } from "@irfanshadikrishad/cipher"
+import { Cipher } from '@irfanshadikrishad/cipher'
 
 // Create a Caesar Cipher instance with a shift of 6
 const caesar = new Cipher.Caesar(6)
 
-console.log(caesar.encrypt("hello world")) // Output: "nkrru cuxrj"
+console.log(caesar.encrypt('hello world')) // Output: "nkrru cuxrj"
 ```
 
 #### 🔐 Supported Ciphers

package/dist/Cipher.d.ts

@@ -1,13 +1,13 @@
-import { Caesar } from "./ciphers/Caesar.js";
-import { Atbash } from "./ciphers/Atbash.js";
-import { Playfair } from "./ciphers/Playfair.js";
-import { Vigenere } from "./ciphers/Vigenere.js";
-import { Alphabet } from "./ciphers/Alphabet.js";
-import { Salsa20 } from "./ciphers/Salsa20.js";
-import { ADFGVX } from "./ciphers/ADFGVX.js";
-import { AES } from "./ciphers/AES.js";
-import { DES } from "./ciphers/DES.js";
-import { ECC } from "./ciphers/ECC.js";
+import { ADFGVX } from './ciphers/ADFGVX.js';
+import { AES } from './ciphers/AES.js';
+import { Alphabet } from './ciphers/Alphabet.js';
+import { Atbash } from './ciphers/Atbash.js';
+import { Caesar } from './ciphers/Caesar.js';
+import { DES } from './ciphers/DES.js';
+import { ECC } from './ciphers/ECC.js';
+import { Playfair } from './ciphers/Playfair.js';
+import { Salsa20 } from './ciphers/Salsa20.js';
+import { Vigenere } from './ciphers/Vigenere.js';
 export declare abstract class Cipher {
     /**
      * Caesar cipher is a substitution cipher where each letter in the plaintext is shifted a certain number of places down the alphabet.

package/dist/ciphers/ADFGVX.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class ADFGVX extends Cipher {
     private key;
     private codeword;

package/dist/ciphers/ADFGVX.js

@@ -1,12 +1,12 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export class ADFGVX extends Cipher {
     constructor(key, codeword) {
         super();
-        this.key = "CIPHER";
-        this.codeword = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        this.key = 'CIPHER';
+        this.codeword = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
         this.polybiusSquare = new Map();
         this.reverseSquare = new Map();
-        this.adfgvx = ["A", "D", "F", "G", "V", "X"];
+        this.adfgvx = ['A', 'D', 'F', 'G', 'V', 'X'];
         if (key)
             this.key = key.toUpperCase();
         if (codeword)
@@ -20,8 +20,8 @@ export class ADFGVX extends Cipher {
                 uniqueLetters.push(char);
             }
         }
-        const remainingChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-            .split("")
+        const remainingChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+            .split('')
             .filter((char) => !uniqueLetters.includes(char));
         const alphabet = [...uniqueLetters, ...remainingChars];
         let index = 0;
@@ -42,7 +42,7 @@ export class ADFGVX extends Cipher {
             .map((item) => item.index);
         const numCols = this.key.length;
         const numRows = Math.ceil(text.length / numCols);
-        const grid = Array.from({ length: numRows }, () => new Array(numCols).fill(""));
+        const grid = Array.from({ length: numRows }, () => new Array(numCols).fill(''));
         if (!decrypt) {
             let charIndex = 0;
             for (let row = 0; row < numRows; row++) {
@@ -53,8 +53,8 @@ export class ADFGVX extends Cipher {
                 }
             }
             return keyOrder
-                .map((col) => grid.map((row) => row[col]).join(""))
-                .join("");
+                .map((col) => grid.map((row) => row[col]).join(''))
+                .join('');
         }
         else {
             const sortedKeyOrder = [...keyOrder].sort((a, b) => this.key[a].localeCompare(this.key[b]));
@@ -66,23 +66,23 @@ export class ADFGVX extends Cipher {
                     }
                 }
             }
-            return grid.flat().join("");
+            return grid.flat().join('');
         }
     }
     encrypt(text) {
-        const plaintext = text.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+        const plaintext = text.replace(/[^A-Za-z0-9]/g, '').toUpperCase();
         const polybiusText = plaintext
-            .split("")
-            .map((char) => this.polybiusSquare.get(char) || "")
-            .join("");
+            .split('')
+            .map((char) => this.polybiusSquare.get(char) || '')
+            .join('');
         return this.columnarTranspose(polybiusText);
     }
     decrypt(text) {
-        const encrypted = text.replace(/[^A-Za-z0-9]/g, "").toUpperCase();
+        const encrypted = text.replace(/[^A-Za-z0-9]/g, '').toUpperCase();
         const intermediate = this.columnarTranspose(encrypted, true);
         const polybiusText = intermediate.match(/.{1,2}/g)?.map((char) => {
-            return this.reverseSquare.get(char) || "";
+            return this.reverseSquare.get(char) || '';
         }) || [];
-        return polybiusText.join("");
+        return polybiusText.join('');
     }
 }

package/dist/ciphers/AES.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class AES extends Cipher {
     private key;
     private iv;

package/dist/ciphers/AES.js

@@ -1,28 +1,28 @@
-import crypto from "crypto";
-import { Cipher } from "../Cipher.js";
-import { Buffer } from "buffer";
+import { Buffer } from 'buffer';
+import crypto from 'crypto';
+import { Cipher } from '../Cipher.js';
 export class AES extends Cipher {
     constructor(key, iv) {
         super();
-        this.key = Buffer.from(key, "hex");
-        this.iv = Buffer.from(iv, "hex");
+        this.key = Buffer.from(key, 'hex');
+        this.iv = Buffer.from(iv, 'hex');
         if (this.key.length !== 32) {
-            throw new Error("Invalid key length: AES-256 requires a 32-byte key");
+            throw new Error('Invalid key length: AES-256 requires a 32-byte key');
         }
         if (this.iv.length !== 16) {
-            throw new Error("Invalid IV length: AES requires a 16-byte IV");
+            throw new Error('Invalid IV length: AES requires a 16-byte IV');
         }
     }
     encrypt(plaintext) {
-        const cipher = crypto.createCipheriv("aes-256-cbc", this.key, this.iv);
-        let encrypted = cipher.update(plaintext, "utf8", "hex");
-        encrypted += cipher.final("hex");
+        const cipher = crypto.createCipheriv('aes-256-cbc', this.key, this.iv);
+        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
         return encrypted;
     }
     decrypt(ciphertext) {
-        const decipher = crypto.createDecipheriv("aes-256-cbc", this.key, this.iv);
-        let decrypted = decipher.update(ciphertext, "hex", "utf8");
-        decrypted += decipher.final("utf8");
+        const decipher = crypto.createDecipheriv('aes-256-cbc', this.key, this.iv);
+        let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
         return decrypted;
     }
 }

package/dist/ciphers/Alphabet.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class Alphabet extends Cipher {
     private keyword;
     private static alphabet;

package/dist/ciphers/Alphabet.js

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export class Alphabet extends Cipher {
     constructor(keyword) {
         super();
@@ -12,7 +12,7 @@ export class Alphabet extends Cipher {
     encrypt(message) {
         message = message.toLowerCase();
         const table = Alphabet.getVigenereTable();
-        let result = "";
+        let result = '';
         for (let i = 0; i < message.length; i++) {
             const msgChar = message[i];
             const keyChar = this.keyword[i % this.keyword.length];
@@ -34,7 +34,7 @@ export class Alphabet extends Cipher {
     decrypt(ciphertext) {
         ciphertext = ciphertext.toLowerCase();
         const table = Alphabet.getVigenereTable();
-        let result = "";
+        let result = '';
         for (let i = 0; i < ciphertext.length; i++) {
             const cipherChar = ciphertext[i];
             const keyChar = this.keyword[i % this.keyword.length];
@@ -56,10 +56,10 @@ export class Alphabet extends Cipher {
         for (let i = 0; i < 26; i++) {
             table[i] = Alphabet.alphabet
                 .slice(i)
-                .split("")
-                .concat(Alphabet.alphabet.slice(0, i).split(""));
+                .split('')
+                .concat(Alphabet.alphabet.slice(0, i).split(''));
         }
         return table;
     }
 }
-Alphabet.alphabet = "abcdefghijklmnopqrstuvwxyz";
+Alphabet.alphabet = 'abcdefghijklmnopqrstuvwxyz';

package/dist/ciphers/Atbash.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class Atbash extends Cipher {
     encrypt(text: string): string;
     decrypt(text: string): string;

package/dist/ciphers/Atbash.js

@@ -1,8 +1,8 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export class Atbash extends Cipher {
     encrypt(text) {
         return text
-            .split("")
+            .split('')
             .map((char) => {
             const code = char.charCodeAt(0);
             if (code >= 65 && code <= 90) {
@@ -13,7 +13,7 @@ export class Atbash extends Cipher {
             }
             return char;
         })
-            .join("");
+            .join('');
     }
     decrypt(text) {
         // Since Atbash is a reciprocal cipher, encryption and decryption are identical.

package/dist/ciphers/Caesar.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class Caesar extends Cipher {
     private shift;
     constructor(shift: number);

package/dist/ciphers/Caesar.js

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export class Caesar extends Cipher {
     constructor(shift) {
         super();
@@ -6,7 +6,7 @@ export class Caesar extends Cipher {
     }
     encrypt(text) {
         return text
-            .split("")
+            .split('')
             .map((char) => {
             const code = char.charCodeAt(0);
             if (code >= 65 && code <= 90) {
@@ -17,11 +17,11 @@ export class Caesar extends Cipher {
             }
             return char;
         })
-            .join("");
+            .join('');
     }
     decrypt(text) {
         return text
-            .split("")
+            .split('')
             .map((char) => {
             const code = char.charCodeAt(0);
             if (code >= 65 && code <= 90) {
@@ -32,6 +32,6 @@ export class Caesar extends Cipher {
             }
             return char;
         })
-            .join("");
+            .join('');
     }
 }

package/dist/ciphers/DES.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class DES extends Cipher {
     private key;
     constructor(key: string);

package/dist/ciphers/DES.js

@@ -1,5 +1,5 @@
-import { Cipher } from "../Cipher.js";
-import { Buffer } from "buffer";
+import { Buffer } from 'buffer';
+import { Cipher } from '../Cipher.js';
 const IP = [
     // Initial Permutation
     58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38,
@@ -18,7 +18,7 @@ export class DES extends Cipher {
     constructor(key) {
         super();
         if (key.length !== 8)
-            throw new Error("DES key must be exactly 8 characters.");
+            throw new Error('DES key must be exactly 8 characters.');
         this.key = this.stringToBigInt(key);
     }
     encrypt(text) {
@@ -30,15 +30,15 @@ export class DES extends Cipher {
             const permuted = this.permute(input, IP);
             const encrypted = this.feistel(permuted);
             const finalPerm = this.permute(encrypted, FP);
-            encryptedBlocks.push(finalPerm.toString(16).padStart(16, "0"));
+            encryptedBlocks.push(finalPerm.toString(16).padStart(16, '0'));
         }
-        return encryptedBlocks.join(""); // Concatenate hex strings
+        return encryptedBlocks.join(''); // Concatenate hex strings
     }
     decrypt(text) {
-        let decryptedText = "";
+        let decryptedText = '';
         for (let i = 0; i < text.length; i += 16) {
             // 16 hex chars = 8 bytes
-            const block = BigInt("0x" + text.substring(i, i + 16));
+            const block = BigInt('0x' + text.substring(i, i + 16));
             const permuted = this.permute(block, IP);
             const decrypted = this.feistel(permuted);
             const finalPerm = this.permute(decrypted, FP);
@@ -79,9 +79,9 @@ export class DES extends Cipher {
         return output;
     }
     stringToBigInt(str) {
-        return BigInt("0x" + Buffer.from(str, "utf8").toString("hex"));
+        return BigInt('0x' + Buffer.from(str, 'utf8').toString('hex'));
     }
     bigIntToString(num) {
-        return Buffer.from(num.toString(16).padStart(16, "0"), "hex").toString("utf8");
+        return Buffer.from(num.toString(16).padStart(16, '0'), 'hex').toString('utf8');
     }
 }

package/dist/ciphers/ECC.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class ECC extends Cipher {
     private recipientPublicKey?;
     private ownPrivateKey?;

package/dist/ciphers/ECC.js

@@ -1,5 +1,5 @@
-import crypto from "crypto";
-import { Cipher } from "../Cipher.js";
+import crypto from 'crypto';
+import { Cipher } from '../Cipher.js';
 export class ECC extends Cipher {
     constructor(recipientPublicKey, ownPrivateKey) {
         super();
@@ -7,16 +7,16 @@ export class ECC extends Cipher {
         this.ownPrivateKey = ownPrivateKey;
     }
     static async generate() {
-        const { publicKey, privateKey } = await crypto.subtle.generateKey({ name: "ECDH", namedCurve: "P-256" }, true, ["deriveKey", "deriveBits"]);
+        const { publicKey, privateKey } = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: 'P-256' }, true, ['deriveKey', 'deriveBits']);
         return new ECC(publicKey, privateKey);
     }
     async encrypt(plaintext) {
         if (!this.recipientPublicKey)
-            throw new Error("Recipient public key not set");
+            throw new Error('Recipient public key not set');
         const ephemeral = await ECC.generate();
-        const sharedKey = await crypto.subtle.deriveKey({ name: "ECDH", public: this.recipientPublicKey }, ephemeral.ownPrivateKey, { name: "AES-GCM", length: 256 }, false, ["encrypt"]);
+        const sharedKey = await crypto.subtle.deriveKey({ name: 'ECDH', public: this.recipientPublicKey }, ephemeral.ownPrivateKey, { name: 'AES-GCM', length: 256 }, false, ['encrypt']);
         const iv = crypto.getRandomValues(new Uint8Array(12));
-        const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, sharedKey, new TextEncoder().encode(plaintext));
+        const encrypted = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, sharedKey, new TextEncoder().encode(plaintext));
         const payload = {
             iv: ECC.bufToHex(iv),
             ciphertext: ECC.bufToHex(new Uint8Array(encrypted)),
@@ -26,24 +26,24 @@ export class ECC extends Cipher {
     }
     async decrypt(data) {
         if (!this.ownPrivateKey)
-            throw new Error("Own private key not set");
+            throw new Error('Own private key not set');
         const { iv, ciphertext, ephemeralPublicHex } = JSON.parse(data);
         const ephemeralPubKey = await ECC.importPublicKey(ephemeralPublicHex);
-        const sharedKey = await crypto.subtle.deriveKey({ name: "ECDH", public: ephemeralPubKey }, this.ownPrivateKey, { name: "AES-GCM", length: 256 }, false, ["decrypt"]);
-        const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv: ECC.hexToBuf(iv) }, sharedKey, ECC.hexToBuf(ciphertext));
+        const sharedKey = await crypto.subtle.deriveKey({ name: 'ECDH', public: ephemeralPubKey }, this.ownPrivateKey, { name: 'AES-GCM', length: 256 }, false, ['decrypt']);
+        const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv: ECC.hexToBuf(iv) }, sharedKey, ECC.hexToBuf(ciphertext));
         return new TextDecoder().decode(decrypted);
     }
     async exportPublicKey() {
-        const raw = await crypto.subtle.exportKey("raw", this.recipientPublicKey || this.ownPrivateKey);
+        const raw = await crypto.subtle.exportKey('raw', this.recipientPublicKey || this.ownPrivateKey);
         return ECC.bufToHex(new Uint8Array(raw));
     }
     static async importPublicKey(hex) {
         const raw = ECC.hexToBuf(hex);
-        return crypto.subtle.importKey("raw", raw, { name: "ECDH", namedCurve: "P-256" }, true, []);
+        return crypto.subtle.importKey('raw', raw, { name: 'ECDH', namedCurve: 'P-256' }, true, []);
     }
     // Helpers
     static bufToHex(buf) {
-        return [...buf].map((b) => b.toString(16).padStart(2, "0")).join("");
+        return [...buf].map((b) => b.toString(16).padStart(2, '0')).join('');
     }
     static hexToBuf(hex) {
         const bytes = new Uint8Array(hex.length / 2);

package/dist/ciphers/Playfair.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class Playfair extends Cipher {
     private keyMatrix;
     constructor(key: string);

package/dist/ciphers/Playfair.js

@@ -1,14 +1,14 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export class Playfair extends Cipher {
     constructor(key) {
         super();
         this.keyMatrix = this.generateKeyMatrix(key);
     }
     generateKeyMatrix(key) {
-        key = key.toUpperCase().replace(/J/g, "I");
+        key = key.toUpperCase().replace(/J/g, 'I');
         const seen = new Set();
         const matrix = [];
-        const alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ";
+        const alphabet = 'ABCDEFGHIKLMNOPQRSTUVWXYZ';
         key += alphabet;
         for (const char of key) {
             if (!seen.has(char) && alphabet.includes(char)) {
@@ -31,14 +31,14 @@ export class Playfair extends Cipher {
     prepareText(text) {
         text = text
             .toUpperCase()
-            .replace(/J/g, "I")
-            .replace(/[^A-Z]/g, "");
-        let result = "";
+            .replace(/J/g, 'I')
+            .replace(/[^A-Z]/g, '');
+        let result = '';
         for (let i = 0; i < text.length; i += 2) {
             const a = text[i];
-            const b = text[i + 1] || "X";
+            const b = text[i + 1] || 'X';
             if (a === b) {
-                result += a + "X";
+                result += a + 'X';
                 i--;
             }
             else {
@@ -48,7 +48,7 @@ export class Playfair extends Cipher {
         return result;
     }
     processPairs(text, encrypt) {
-        let result = "";
+        let result = '';
         const shift = encrypt ? 1 : -1;
         for (let i = 0; i < text.length; i += 2) {
             const [row1, col1] = this.findPosition(text[i]);

package/dist/ciphers/Salsa20.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class Salsa20 extends Cipher {
     private key;
     private nonce;

package/dist/ciphers/Salsa20.js

@@ -1,17 +1,17 @@
-import { Cipher } from "../Cipher.js";
-import crypto from "crypto";
-import { Buffer } from "buffer";
+import { Buffer } from 'buffer';
+import crypto from 'crypto';
+import { Cipher } from '../Cipher.js';
 export class Salsa20 extends Cipher {
     constructor(key, nonce, counter = 0) {
         super();
-        if (typeof key === "string")
-            key = Buffer.from(key, "base64");
-        if (typeof nonce === "string")
-            nonce = Buffer.from(nonce, "base64");
+        if (typeof key === 'string')
+            key = Buffer.from(key, 'base64');
+        if (typeof nonce === 'string')
+            nonce = Buffer.from(nonce, 'base64');
         if (key.length !== 32)
-            throw new Error("Key must be 32 bytes (256-bit).");
+            throw new Error('Key must be 32 bytes (256-bit).');
         if (nonce.length !== 8)
-            throw new Error("Nonce must be 8 bytes (64-bit).");
+            throw new Error('Nonce must be 8 bytes (64-bit).');
         this.key = new Uint32Array(new Uint8Array(key).buffer);
         this.nonce = new Uint32Array(new Uint8Array(nonce).buffer);
         this.counter = counter;
@@ -86,9 +86,9 @@ export class Salsa20 extends Cipher {
         return Salsa20.encodeBase64(crypto.getRandomValues(new Uint8Array(8)));
     }
     static encodeBase64(uint8array) {
-        return Buffer.from(uint8array).toString("base64");
+        return Buffer.from(uint8array).toString('base64');
     }
     static decodeBase64(base64) {
-        return new Uint8Array(Buffer.from(base64, "base64"));
+        return new Uint8Array(Buffer.from(base64, 'base64'));
     }
 }

package/dist/ciphers/Vigenere.d.ts

@@ -1,4 +1,4 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export declare class Vigenere extends Cipher {
     private key;
     constructor(key: string);

package/dist/ciphers/Vigenere.js

@@ -1,14 +1,14 @@
-import { Cipher } from "../Cipher.js";
+import { Cipher } from '../Cipher.js';
 export class Vigenere extends Cipher {
     constructor(key) {
         super();
         if (!key || !/^[a-zA-Z]+$/.test(key)) {
-            throw new Error("Key must be a non-empty string containing only letters.");
+            throw new Error('Key must be a non-empty string containing only letters.');
         }
         this.key = key.toUpperCase();
     }
     repeatKey(text) {
-        let repeatedKey = "";
+        let repeatedKey = '';
         for (let i = 0, j = 0; i < text.length; i++) {
             const char = text[i];
             if (/[a-zA-Z]/.test(char)) {
@@ -24,16 +24,16 @@ export class Vigenere extends Cipher {
     encrypt(text) {
         const key = this.repeatKey(text);
         return text
-            .split("")
+            .split('')
             .map((char, i) => {
-            if (char >= "A" && char <= "Z") {
+            if (char >= 'A' && char <= 'Z') {
                 return String.fromCharCode(((char.charCodeAt(0) -
                     65 +
                     (key[i].toUpperCase().charCodeAt(0) - 65)) %
                     26) +
                     65);
             }
-            else if (char >= "a" && char <= "z") {
+            else if (char >= 'a' && char <= 'z') {
                 return String.fromCharCode(((char.charCodeAt(0) -
                     97 +
                     (key[i].toLowerCase().charCodeAt(0) - 97)) %
@@ -42,14 +42,14 @@ export class Vigenere extends Cipher {
             }
             return char;
         })
-            .join("");
+            .join('');
     }
     decrypt(text) {
         const key = this.repeatKey(text);
         return text
-            .split("")
+            .split('')
             .map((char, i) => {
-            if (char >= "A" && char <= "Z") {
+            if (char >= 'A' && char <= 'Z') {
                 return String.fromCharCode(((char.charCodeAt(0) -
                     65 -
                     (key[i].toUpperCase().charCodeAt(0) - 65) +
@@ -57,7 +57,7 @@ export class Vigenere extends Cipher {
                     26) +
                     65);
             }
-            else if (char >= "a" && char <= "z") {
+            else if (char >= 'a' && char <= 'z') {
                 return String.fromCharCode(((char.charCodeAt(0) -
                     97 -
                     (key[i].toLowerCase().charCodeAt(0) - 97) +
@@ -67,6 +67,6 @@ export class Vigenere extends Cipher {
             }
             return char;
         })
-            .join("");
+            .join('');
     }
 }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { Cipher } from "./Cipher.js";
+import { Cipher } from './Cipher.js';
 export { Cipher };

package/dist/index.js

@@ -1,14 +1,14 @@
-import { Cipher } from "./Cipher.js";
-import { Caesar } from "./ciphers/Caesar.js";
-import { Atbash } from "./ciphers/Atbash.js";
-import { Playfair } from "./ciphers/Playfair.js";
-import { Vigenere } from "./ciphers/Vigenere.js";
-import { Alphabet } from "./ciphers/Alphabet.js";
-import { Salsa20 } from "./ciphers/Salsa20.js";
-import { ADFGVX } from "./ciphers/ADFGVX.js";
-import { AES } from "./ciphers/AES.js";
-import { DES } from "./ciphers/DES.js";
-import { ECC } from "./ciphers/ECC.js";
+import { Cipher } from './Cipher.js';
+import { ADFGVX } from './ciphers/ADFGVX.js';
+import { AES } from './ciphers/AES.js';
+import { Alphabet } from './ciphers/Alphabet.js';
+import { Atbash } from './ciphers/Atbash.js';
+import { Caesar } from './ciphers/Caesar.js';
+import { DES } from './ciphers/DES.js';
+import { ECC } from './ciphers/ECC.js';
+import { Playfair } from './ciphers/Playfair.js';
+import { Salsa20 } from './ciphers/Salsa20.js';
+import { Vigenere } from './ciphers/Vigenere.js';
 Cipher.Caesar = Caesar;
 Cipher.Atbash = Atbash;
 Cipher.Playfair = Playfair;

package/package.json

@@ -1,63 +1,65 @@
 {
-  "name": "@irfanshadikrishad/cipher",
-  "version": "1.2.0",
-  "description": "A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications with zero/0 dependencies.",
-  "homepage": "https://github.com/irfanshadikrishad/cipher#readme",
-  "bugs": {
-    "url": "https://github.com/irfanshadikrishad/cipher/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/irfanshadikrishad/cipher.git"
-  },
-  "files": [
-    "dist"
-  ],
-  "directories": {
-    "test": "test",
-    "lib": "src"
-  },
-  "license": "MPL-2.0",
-  "author": {
-    "name": "Irfan Shadik Rishad"
-  },
-  "type": "module",
-  "main": "./dist/index.js",
-  "publishConfig": {
-    "access": "public"
-  },
-  "bin": {
-    "cipher": "./dist/index.js"
-  },
-  "scripts": {
-    "build": "rm -rf ./dist && tsc",
-    "build:watch": "rm -rf ./dist && tsc -w",
-    "format": "prettier . --write",
-    "lint": "eslint . --ext .ts",
-    "lint:fix": "eslint . --ext .ts --fix",
-    "test": "jest ./tests",
-    "prepare": "husky",
-    "all": "npm run build && npm run format && npm run lint && npm run test"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.27.0",
-    "@types/jest": "^29.5.14",
-    "@typescript-eslint/eslint-plugin": "^8.33.0",
-    "@typescript-eslint/parser": "^8.33.0",
-    "eslint": "^9.27.0",
-    "globals": "^16.2.0",
-    "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "prettier": "^3.5.3",
-    "ts-jest": "^29.3.4",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.33.0"
-  },
-  "keywords": [
-    "security",
-    "cipher",
-    "cryptography",
-    "encryption",
-    "decryption"
-  ]
+	"name": "@irfanshadikrishad/cipher",
+	"version": "1.3.0",
+	"description": "A versatile and secure cryptographic library for implementing various cipher algorithms in Node.js applications with zero/0 dependencies.",
+	"homepage": "https://github.com/irfanshadikrishad/cipher#readme",
+	"bugs": {
+		"url": "https://github.com/irfanshadikrishad/cipher/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/irfanshadikrishad/cipher.git"
+	},
+	"files": [
+		"dist"
+	],
+	"directories": {
+		"test": "test",
+		"lib": "src"
+	},
+	"license": "MPL-2.0",
+	"author": {
+		"name": "Irfan Shadik Rishad"
+	},
+	"type": "module",
+	"main": "./dist/index.js",
+	"publishConfig": {
+		"access": "public"
+	},
+	"bin": {
+		"cipher": "./dist/index.js"
+	},
+	"scripts": {
+		"build": "rm -rf ./dist && tsc",
+		"build:watch": "rm -rf ./dist && tsc -w",
+		"format": "prettier . --write",
+		"lint": "eslint . --ext .ts",
+		"lint:fix": "eslint . --ext .ts --fix",
+		"test": "jest ./tests",
+		"prepare": "husky",
+		"all": "npm run build && npm run format && npm run lint && npm run test"
+	},
+	"prettier": "@irfanshadikrishad/prettier",
+	"devDependencies": {
+		"@eslint/js": "^9.29.0",
+		"@irfanshadikrishad/prettier": "^1.1.0",
+		"@types/jest": "^30.0.0",
+		"@typescript-eslint/eslint-plugin": "^8.34.0",
+		"@typescript-eslint/parser": "^8.34.0",
+		"eslint": "^9.29.0",
+		"globals": "^16.2.0",
+		"husky": "^9.1.7",
+		"jest": "^30.0.2",
+		"prettier": "^3.5.3",
+		"ts-jest": "^29.4.0",
+		"typescript": "^5.8.3",
+		"typescript-eslint": "^8.34.0"
+	},
+	"keywords": [
+		"security",
+		"cipher",
+		"cryptography",
+		"encryption",
+		"decryption"
+	]
 }