react-native-aes-lite 1.0.0 → 1.0.1-0.rc

package/README.md

@@ -1,18 +1,34 @@
 
-# react-native-aes-lite
+# 📦 react-native-aes-lite  
 
-## Install
+[![npm version](https://img.shields.io/npm/v/react-native-aes-lite.svg?color=blue)](https://www.npmjs.com/package/react-native-aes-lite)
+[![platforms](https://img.shields.io/badge/platform-react%20native%20%7C%20expo-green)]()
+[![license](https://img.shields.io/npm/l/react-native-aes-lite.svg)]()
+[![typescript](https://img.shields.io/badge/types-yes-blue)]()
 
-## npm i react-native-aes-lite
+Lightweight AES encryption/decryption utility for React Native and Expo. No native modules, no linking — just pure JavaScript.
 
+---
+
+## 📖 Overview  
+
+react-native-aes-lite provides simple AES block-based text encryption and decryption using a 256-bit key. It is ideal for app-side data scrambling, offline encoding, demos, and educational use.  
+
+
+## 🐞 Troubleshooting  
+
+### Error: AES is not a constructor
+Use default import fallback:  
 
-## Usage
 ```js
-import { AES, generateKey } from "react-native-aes-lite";
+import aesKit from "react-native-aes-lite";
+const { AES } = aesKit;
+```
 
-const aes = new AES();
-const key = generateKey("hex", { length: 16 });
-const encrypted = aes.encrypt("hello", key);
-const decrypted = aes.decrypt(encrypted, key);
+### TS2305 — generateKey missing
+Ensure latest version is installed.
 
+---
 
+## 📜 License  
+MIT © 2025 Ammachi  

package/dist/AES.js

@@ -0,0 +1,329 @@
+// AES.js
+import { randomBytes } from "./randomBytes";
+
+/* ============================================================
+   UTF-8 Encoder / Decoder (Hermes-safe)
+============================================================ */
+function utf8Encode(str) {
+  const out = [];
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i);
+    if (c < 0x80) out.push(c);
+    else if (c < 0x800) {
+      out.push(0xc0 | (c >> 6));
+      out.push(0x80 | (c & 0x3f));
+    } else {
+      out.push(0xe0 | (c >> 12));
+      out.push(0x80 | ((c >> 6) & 0x3f));
+      out.push(0x80 | (c & 0x3f));
+    }
+  }
+  return out;
+}
+
+function utf8Decode(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; ) {
+    const c = bytes[i++];
+    if (c < 0x80) {
+      s += String.fromCharCode(c);
+    } else if (c < 0xe0) {
+      const c2 = bytes[i++];
+      s += String.fromCharCode(((c & 0x1f) << 6) | (c2 & 0x3f));
+    } else {
+      const c2 = bytes[i++],
+        c3 = bytes[i++];
+      s += String.fromCharCode(
+        ((c & 0x0f) << 12) | ((c2 & 0x3f) << 6) | (c3 & 0x3f),
+      );
+    }
+  }
+  return s;
+}
+
+/* ============================================================
+   AES CLASS
+============================================================ */
+
+class AES {
+  constructor() {
+    this.encode = utf8Encode;
+    this.decode = utf8Decode;
+
+    this.SBOX = [
+      0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
+      0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
+      0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
+      0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+      0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
+      0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
+      0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
+      0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+      0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
+      0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
+      0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
+      0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+      0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
+      0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
+      0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
+      0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+      0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
+      0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
+      0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
+      0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+      0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
+      0xb0, 0x54, 0xbb, 0x16,
+    ];
+
+    this.INV_SBOX = new Array(256);
+    for (let i = 0; i < 256; i++) this.INV_SBOX[this.SBOX[i]] = i;
+
+    this.RCON = [
+      0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c,
+      0xd8, 0xab, 0x4d, 0x9a,
+    ];
+  }
+
+  /* ============================================================
+       UTILITY FUNCTIONS
+  ============================================================= */
+  hexToBytes(h) {
+    return Uint8Array.from(h.match(/../g).map((x) => parseInt(x, 16)));
+  }
+  bytesToHex(b) {
+    return [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  }
+
+  parseKey(hex) {
+    const b = this.hexToBytes(hex);
+    if (![16, 24, 32].includes(b.length))
+      throw new Error("Invalid AES key length");
+    return [...b];
+  }
+
+  pkcs7Pad(arr) {
+    const pad = 16 - (arr.length % 16);
+    return [...arr, ...Array(pad).fill(pad)];
+  }
+
+  pkcs7Unpad(arr) {
+    const pad = arr[arr.length - 1];
+    return arr.slice(0, -pad);
+  }
+
+  /* ============================================================
+       AES KEY EXPANSION
+  ============================================================= */
+  keyExpansion(key) {
+    const Nk = key.length / 4;
+    const Nr = Nk + 6;
+    const w = new Array(4 * (Nr + 1));
+
+    for (let i = 0; i < Nk; i++) {
+      w[i] = key.slice(4 * i, 4 * i + 4);
+    }
+
+    for (let i = Nk; i < w.length; i++) {
+      let t = [...w[i - 1]];
+
+      if (i % Nk === 0) {
+        t.push(t.shift());
+        t = t.map((b) => this.SBOX[b]);
+        t[0] ^= this.RCON[i / Nk];
+      } else if (Nk > 6 && i % Nk === 4) {
+        t = t.map((b) => this.SBOX[b]);
+      }
+
+      w[i] = w[i - Nk].map((b, j) => b ^ t[j]);
+    }
+
+    return { w, Nr };
+  }
+
+  /* ============================================================
+       AES ROUND FUNCTIONS
+  ============================================================= */
+  subBytes(s) {
+    for (let r = 0; r < 4; r++)
+      for (let c = 0; c < 4; c++) s[r][c] = this.SBOX[s[r][c]];
+    return s;
+  }
+
+  invSubBytes(s) {
+    for (let r = 0; r < 4; r++)
+      for (let c = 0; c < 4; c++) s[r][c] = this.INV_SBOX[s[r][c]];
+    return s;
+  }
+
+  shiftRows(s) {
+    s[1].push(s[1].shift());
+    s[2].push(...s[2].splice(0, 2));
+    s[3].unshift(s[3].pop());
+    return s;
+  }
+
+  invShiftRows(s) {
+    s[1].unshift(s[1].pop());
+    s[2].unshift(...s[2].splice(2));
+    s[3].push(s[3].shift());
+    return s;
+  }
+
+  xtime(a) {
+    return ((a << 1) ^ ((a >> 7) & 1 ? 0x1b : 0)) & 0xff;
+  }
+
+  mixColumns(s) {
+    for (let c = 0; c < 4; c++) {
+      const a = s.map((r) => r[c]);
+      s[0][c] = this.xtime(a[0]) ^ this.xtime(a[1]) ^ a[1] ^ a[2] ^ a[3];
+      s[1][c] = a[0] ^ this.xtime(a[1]) ^ this.xtime(a[2]) ^ a[2] ^ a[3];
+      s[2][c] = a[0] ^ a[1] ^ this.xtime(a[2]) ^ this.xtime(a[3]) ^ a[3];
+      s[3][c] = this.xtime(a[0]) ^ a[0] ^ a[1] ^ a[2] ^ this.xtime(a[3]);
+    }
+    return s;
+  }
+
+  invMixColumns(s) {
+    const mul = (a, b) => {
+      let res = 0;
+      for (let i = 0; i < 8; i++) {
+        if (b & 1) res ^= a;
+        const hi = a & 0x80;
+        a = (a << 1) & 0xff;
+        if (hi) a ^= 0x1b;
+        b >>= 1;
+      }
+      return res;
+    };
+
+    for (let c = 0; c < 4; c++) {
+      const a = s.map((r) => r[c]);
+      s[0][c] = mul(a[0], 14) ^ mul(a[1], 11) ^ mul(a[2], 13) ^ mul(a[3], 9);
+      s[1][c] = mul(a[0], 9) ^ mul(a[1], 14) ^ mul(a[2], 11) ^ mul(a[3], 13);
+      s[2][c] = mul(a[0], 13) ^ mul(a[1], 9) ^ mul(a[2], 14) ^ mul(a[3], 11);
+      s[3][c] = mul(a[0], 11) ^ mul(a[1], 13) ^ mul(a[2], 9) ^ mul(a[3], 14);
+    }
+    return s;
+  }
+
+  addRoundKey(s, w, r) {
+    for (let c = 0; c < 4; c++) {
+      const word = w[r * 4 + c];
+      s[0][c] ^= word[0];
+      s[1][c] ^= word[1];
+      s[2][c] ^= word[2];
+      s[3][c] ^= word[3];
+    }
+    return s;
+  }
+
+  /* ============================================================
+       CIPHER (ENCRYPT ONE BLOCK)
+  ============================================================= */
+  cipher(input, w, Nr) {
+    let s = [[], [], [], []];
+    for (let i = 0; i < 16; i++) {
+      s[i % 4][(i / 4) | 0] = input[i];
+    }
+
+    s = this.addRoundKey(s, w, 0);
+
+    for (let round = 1; round < Nr; round++) {
+      s = this.subBytes(s);
+      s = this.shiftRows(s);
+      s = this.mixColumns(s);
+      s = this.addRoundKey(s, w, round);
+    }
+
+    s = this.subBytes(s);
+    s = this.shiftRows(s);
+    s = this.addRoundKey(s, w, Nr);
+
+    const out = new Array(16);
+    for (let i = 0; i < 16; i++) {
+      out[i] = s[i % 4][(i / 4) | 0];
+    }
+    return out;
+  }
+
+  /* ============================================================
+       INVERSE CIPHER (DECRYPT ONE BLOCK)
+  ============================================================= */
+  invCipher(input, w, Nr) {
+    let s = [[], [], [], []];
+
+    for (let i = 0; i < 16; i++) {
+      s[i % 4][(i / 4) | 0] = input[i];
+    }
+
+    s = this.addRoundKey(s, w, Nr);
+
+    for (let round = Nr - 1; round >= 1; round--) {
+      s = this.invShiftRows(s);
+      s = this.invSubBytes(s);
+      s = this.addRoundKey(s, w, round);
+      s = this.invMixColumns(s);
+    }
+
+    s = this.invShiftRows(s);
+    s = this.invSubBytes(s);
+    s = this.addRoundKey(s, w, 0);
+
+    const out = new Array(16);
+    for (let i = 0; i < 16; i++) {
+      out[i] = s[i % 4][(i / 4) | 0];
+    }
+    return out;
+  }
+
+  /* ============================================================
+       CBC MODE
+  ============================================================= */
+
+  encrypt(text, keyHex) {
+    const key = this.parseKey(keyHex);
+    const { w, Nr } = this.keyExpansion(key);
+
+    const iv = randomBytes(16);
+    const pt = this.encode(text);
+    const padded = this.pkcs7Pad(pt);
+
+    let out = [];
+    let prev = iv;
+
+    for (let i = 0; i < padded.length; i += 16) {
+      const block = padded.slice(i, i + 16);
+      const xored = block.map((b, j) => b ^ prev[j]);
+      const enc = this.cipher(xored, w, Nr);
+      out.push(...enc);
+      prev = enc;
+    }
+
+    return this.bytesToHex(iv) + ":" + this.bytesToHex(out);
+  }
+
+  decrypt(input, keyHex) {
+    const [ivHex, dataHex] = input.split(":");
+    const key = this.parseKey(keyHex);
+    const { w, Nr } = this.keyExpansion(key);
+
+    const iv = [...this.hexToBytes(ivHex)];
+    const data = [...this.hexToBytes(dataHex)];
+
+    let out = [];
+    let prev = iv;
+
+    for (let i = 0; i < data.length; i += 16) {
+      const block = data.slice(i, i + 16);
+      const dec = this.invCipher(block, w, Nr);
+      const x = dec.map((b, j) => b ^ prev[j]);
+      out.push(...x);
+      prev = block;
+    }
+
+    return this.decode(this.pkcs7Unpad(out));
+  }
+}
+
+export default AES;

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export class AES {
+  encrypt(text: string, key: string): string;
+  decrypt(cipherHex: string, key: string): string;
+}
+
+export function generateKey(
+  format?: string,
+  options?: { length?: number; readable?: boolean }
+): string;
+
+declare const _default: {
+  AES: typeof AES;
+  generateKey: typeof generateKey;
+};
+
+export default _default;

package/dist/index.js

@@ -0,0 +1,4 @@
+import AES from "./AES";
+import generateKey from "./keygen";
+
+export { AES, generateKey };

package/dist/keygen.js

@@ -0,0 +1,26 @@
+// generateKey.js
+import { randomBytes } from "./randomBytes";
+
+export function generateKey(format = "hex", { length = 32 } = {}) {
+  if (![16, 24, 32].includes(length)) {
+    throw new Error("Key must be 16, 24, or 32 bytes (AES-128/192/256)");
+  }
+
+  const bytes = randomBytes(length); // <-- SAFE ALWAYS
+
+  if (format === "hex") {
+    return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+
+  if (format === "base64") {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return globalThis.btoa
+      ? btoa(binary)
+      : Buffer.from(bytes).toString("base64");
+  }
+
+  return String.fromCharCode(...bytes);
+}

package/dist/randomBytes.js

@@ -0,0 +1,23 @@
+// randomBytes.js
+
+export function randomBytes(length) {
+  const out = new Uint8Array(length);
+
+  // 1️⃣ Browser / Expo Web
+  if (
+    typeof globalThis !== "undefined" &&
+    globalThis.crypto &&
+    typeof globalThis.crypto.getRandomValues === "function"
+  ) {
+    globalThis.crypto.getRandomValues(out);
+    return out;
+  }
+
+  // 2️⃣ Hermes fallback RNG (React Native)
+  for (let i = 0; i < length; i++) {
+    out[i] = (Math.random() * 256) & 0xff;
+  }
+
+  console.warn("⚠️ Using fallback RNG (not cryptographically secure)");
+  return out;
+}

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "react-native-aes-lite",
-  "version": "1.0.0",
-  "description": "AES encryption for React Native",
-  "main": "src/index.js",
-
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "types": "src/index.d.ts",
-  "keywords": ["aes", "encryption", "react-native"],
+  "version": "1.0.10.rc",
+  "description": "AES encryption for React Native + Expo Web",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "aes",
+    "encryption",
+    "react-native",
+    "expo",
+    "web"
+  ],
   "author": "Ammachi",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^25.0.3",
-    "typescript": "^5.9.3"
-  }
+  "license": "MIT"
 }

package/src/AES.js

@@ -1,296 +0,0 @@
-class AES {
-  constructor() {
-    this.SBOX = [
-      0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
-      0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
-      0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
-      0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
-      0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
-      0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
-      0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
-      0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
-      0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
-      0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
-      0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
-      0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
-      0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
-      0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
-      0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
-      0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
-      0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
-      0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
-      0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
-      0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
-      0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
-      0xb0, 0x54, 0xbb, 0x16,
-    ];
-    this.INV_SBOX = new Array(256);
-    for (let i = 0; i < 256; i++) this.INV_SBOX[this.SBOX[i]] = i;
-    this.RCON = [
-      0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
-    ];
-  }
-
-  xtime(x) {
-    x &= 0xff;
-    return ((x << 1) ^ (((x >> 7) & 1) * 0x1b)) & 0xff;
-  }
-
-  parseKey(keyString) {
-    if (keyString.length === 32) {
-      // Assume hex
-      const bytes = [];
-      for (let i = 0; i < 32; i += 2) {
-        bytes.push(parseInt(keyString.substr(i, 2), 16));
-      }
-      if (bytes.some(isNaN)) throw new Error("Invalid hex key");
-      return bytes;
-    } else if (keyString.length === 16) {
-      // ASCII
-      return keyString.split("").map((c) => c.charCodeAt(0));
-    } else {
-      throw new Error("Key must be 16 ASCII chars or 32 hex chars");
-    }
-  }
-
-  keyExpansion(key) {
-    const w = new Array(44); // 4 * (10 + 1)
-    for (let i = 0; i < 4; i++) {
-      w[i] = [key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]];
-    }
-    for (let i = 4; i < 44; i++) {
-      let temp = w[i - 1].slice();
-      if (i % 4 === 0) {
-        // RotWord
-        const t = temp[0];
-        temp[0] = temp[1];
-        temp[1] = temp[2];
-        temp[2] = temp[3];
-        temp[3] = t;
-        // SubWord
-        for (let j = 0; j < 4; j++) {
-          temp[j] = this.SBOX[temp[j]];
-        }
-        // Rcon
-        temp[0] ^= this.RCON[i / 4];
-      }
-      w[i] = [
-        w[i - 4][0] ^ temp[0],
-        w[i - 4][1] ^ temp[1],
-        w[i - 4][2] ^ temp[2],
-        w[i - 4][3] ^ temp[3],
-      ];
-    }
-    return w;
-  }
-
-  cipher(input, w) {
-    let state = [
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-    ];
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) state[r][c] = input[r + 4 * c];
-
-    state = this.addRoundKey(state, w, 0);
-
-    for (let round = 1; round < 10; round++) {
-      state = this.subBytes(state);
-      state = this.shiftRows(state);
-      state = this.mixColumns(state);
-      state = this.addRoundKey(state, w, round);
-    }
-
-    state = this.subBytes(state);
-    state = this.shiftRows(state);
-    state = this.addRoundKey(state, w, 10);
-
-    const output = new Array(16);
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) output[r + 4 * c] = state[r][c];
-    return output;
-  }
-
-  invCipher(input, w) {
-    let state = [
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-      [0, 0, 0, 0],
-    ];
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) state[r][c] = input[r + 4 * c];
-
-    state = this.addRoundKey(state, w, 10);
-
-    for (let round = 9; round >= 1; round--) {
-      state = this.invShiftRows(state);
-      state = this.invSubBytes(state);
-      state = this.addRoundKey(state, w, round);
-      state = this.invMixColumns(state);
-    }
-
-    state = this.invShiftRows(state);
-    state = this.invSubBytes(state);
-    state = this.addRoundKey(state, w, 0);
-
-    const output = new Array(16);
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) output[r + 4 * c] = state[r][c];
-    return output;
-  }
-
-  subBytes(s) {
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) s[r][c] = this.SBOX[s[r][c]];
-    return s;
-  }
-
-  invSubBytes(s) {
-    for (let r = 0; r < 4; r++)
-      for (let c = 0; c < 4; c++) s[r][c] = this.INV_SBOX[s[r][c]];
-    return s;
-  }
-
-  shiftRows(s) {
-    const t = s.map((r) => [...r]);
-    s[1][0] = t[1][1];
-    s[1][1] = t[1][2];
-    s[1][2] = t[1][3];
-    s[1][3] = t[1][0];
-    s[2][0] = t[2][2];
-    s[2][1] = t[2][3];
-    s[2][2] = t[2][0];
-    s[2][3] = t[2][1];
-    s[3][0] = t[3][3];
-    s[3][1] = t[3][0];
-    s[3][2] = t[3][1];
-    s[3][3] = t[3][2];
-    return s;
-  }
-
-  invShiftRows(s) {
-    const t = s.map((r) => [...r]);
-    s[1][0] = t[1][3];
-    s[1][1] = t[1][0];
-    s[1][2] = t[1][1];
-    s[1][3] = t[1][2];
-    s[2][0] = t[2][2];
-    s[2][1] = t[2][3];
-    s[2][2] = t[2][0];
-    s[2][3] = t[2][1];
-    s[3][0] = t[3][1];
-    s[3][1] = t[3][2];
-    s[3][2] = t[3][3];
-    s[3][3] = t[3][0];
-    return s;
-  }
-
-  mixColumns(s) {
-    for (let c = 0; c < 4; c++) {
-      const a0 = s[0][c],
-        a1 = s[1][c],
-        a2 = s[2][c],
-        a3 = s[3][c];
-      s[0][c] = this.xtime(a0) ^ this.xtime(a1) ^ a1 ^ a2 ^ a3;
-      s[1][c] = a0 ^ this.xtime(a1) ^ this.xtime(a2) ^ a2 ^ a3;
-      s[2][c] = a0 ^ a1 ^ this.xtime(a2) ^ this.xtime(a3) ^ a3;
-      s[3][c] = this.xtime(a0) ^ a0 ^ a1 ^ a2 ^ this.xtime(a3);
-    }
-    return s;
-  }
-
-  invMixColumns(s) {
-    for (let c = 0; c < 4; c++) {
-      const a = [s[0][c], s[1][c], s[2][c], s[3][c]];
-      const xtime2 = (v) => this.xtime(v);
-      const xtime4 = (v) => this.xtime(xtime2(v));
-      const xtime8 = (v) => this.xtime(xtime4(v));
-      const mul = (v, b) => {
-        let res = 0;
-        if (b & 1) res ^= v;
-        if (b & 2) res ^= xtime2(v);
-        if (b & 4) res ^= xtime4(v);
-        if (b & 8) res ^= xtime8(v);
-        return res & 0xff;
-      };
-      s[0][c] =
-        mul(a[0], 0x0e) ^ mul(a[1], 0x0b) ^ mul(a[2], 0x0d) ^ mul(a[3], 0x09);
-      s[1][c] =
-        mul(a[0], 0x09) ^ mul(a[1], 0x0e) ^ mul(a[2], 0x0b) ^ mul(a[3], 0x0d);
-      s[2][c] =
-        mul(a[0], 0x0d) ^ mul(a[1], 0x09) ^ mul(a[2], 0x0e) ^ mul(a[3], 0x0b);
-      s[3][c] =
-        mul(a[0], 0x0b) ^ mul(a[1], 0x0d) ^ mul(a[2], 0x09) ^ mul(a[3], 0x0e);
-    }
-    return s;
-  }
-
-  addRoundKey(s, w, round) {
-    for (let c = 0; c < 4; c++) {
-      const word = w[round * 4 + c];
-      s[0][c] ^= word[0];
-      s[1][c] ^= word[1];
-      s[2][c] ^= word[2];
-      s[3][c] ^= word[3];
-    }
-    return s;
-  }
-
-  pkcs7Pad(bytes) {
-    const padding = 16 - (bytes.length % 16);
-    const result = bytes.slice();
-    for (let i = 0; i < padding; i++) result.push(padding);
-    return result;
-  }
-
-  pkcs7Unpad(bytes) {
-    const padding = bytes[bytes.length - 1];
-    if (padding < 1 || padding > 16 || bytes.length < padding) {
-      throw new Error("Invalid PKCS#7 padding");
-    }
-    for (let i = 1; i <= padding; i++) {
-      if (bytes[bytes.length - i] !== padding) {
-        throw new Error("Corrupted PKCS#7 padding");
-      }
-    }
-    return bytes.slice(0, -padding);
-  }
-
-  encrypt(text, keyString) {
-    const key = this.parseKey(keyString);
-    const w = this.keyExpansion(key);
-    let inputBytes = text.split("").map((c) => c.charCodeAt(0));
-    inputBytes = this.pkcs7Pad(inputBytes);
-    let outputBytes = [];
-    for (let i = 0; i < inputBytes.length; i += 16) {
-      outputBytes.push(...this.cipher(inputBytes.slice(i, i + 16), w));
-    }
-    return outputBytes.map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-
-  decrypt(hexString, keyString) {
-    if (hexString.length % 2 !== 0)
-      throw new Error("Hex string must have even length");
-    const key = this.parseKey(keyString);
-    const w = this.keyExpansion(key);
-    let inputBytes = [];
-    for (let i = 0; i < hexString.length; i += 2) {
-      inputBytes.push(parseInt(hexString.substr(i, 2), 16));
-    }
-    if (inputBytes.length % 16 !== 0)
-      throw new Error("Ciphertext length must be multiple of 16");
-    let decryptedBytes = [];
-    for (let i = 0; i < inputBytes.length; i += 16) {
-      decryptedBytes.push(...this.invCipher(inputBytes.slice(i, i + 16), w));
-    }
-    decryptedBytes = this.pkcs7Unpad(decryptedBytes);
-    return String.fromCharCode.apply(null, decryptedBytes);
-  }
-}
-export default AES;
-
-// Export singleton
-// export default new AES();

package/src/index.d.ts

@@ -1,4 +0,0 @@
-export class AES {
-  encrypt(text: string, key: string): string;
-  decrypt(hex: string, key: string): string;
-}

package/src/index.js

@@ -1,4 +0,0 @@
-const AES = require("./AES");
-const generateKey = require("./keygen");
-
-module.exports = { AES, generateKey };

package/src/keygen.js

@@ -1,39 +0,0 @@
-function generateKey(format = "hex", options = {}) {
-  const { length = 16, readable = false } = options;
-
-  if (![16, 24, 32].includes(length)) {
-    throw new Error("Key length must be 16, 24, or 32 bytes");
-  }
-
-  const bytes = new Uint8Array(length);
-
-  if (global.crypto?.getRandomValues) {
-    crypto.getRandomValues(bytes);
-  } else {
-    throw new Error("Secure random generator not available");
-  }
-
-  const toHex = (buf) =>
-    Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
-
-  const toBase64 = (buf) => Buffer.from(buf).toString("base64");
-
-  const toReadable = (buf) => {
-    const chars =
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()_+-=";
-    return Array.from(buf, (b) => chars[b % chars.length]).join("");
-  };
-
-  switch (format) {
-    case "hex":
-      return toHex(bytes);
-    case "base64":
-      return toBase64(bytes);
-    case "ascii":
-      return readable ? toReadable(bytes) : String.fromCharCode(...bytes);
-    default:
-      throw new Error("Invalid format");
-  }
-}
-
-module.exports = generateKey;