@alibarbar/common 1.0.8 → 1.0.10

package/dist/{chunk-WZDOPUJW.js → storage.cjs}

@@ -1,8 +1,209 @@
 'use strict';
 
-var chunkDYBSRI7V_js = require('./chunk-DYBSRI7V.js');
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/helper/crypto.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode,
+  exportPrivateKey: () => exportPrivateKey,
+  exportPublicKey: () => exportPublicKey,
+  generateRSAKeyPair: () => generateRSAKeyPair,
+  generateRandomString: () => generateRandomString,
+  generateUUID: () => generateUUID,
+  hash: () => hash,
+  importPrivateKey: () => importPrivateKey,
+  importPublicKey: () => importPublicKey,
+  rsaDecrypt: () => rsaDecrypt,
+  rsaEncrypt: () => rsaEncrypt,
+  sha256: () => sha256
+});
+async function sha256(data) {
+  const buffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function base64Encode(data) {
+  if (typeof data === "string") {
+    return btoa(unescape(encodeURIComponent(data)));
+  }
+  const bytes = new Uint8Array(data);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64Decode(data) {
+  try {
+    return decodeURIComponent(escape(atob(data)));
+  } catch {
+    throw new Error("Invalid Base64 string");
+  }
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateRandomString(length, charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += charset.charAt(Math.floor(Math.random() * charset.length));
+  }
+  return result;
+}
+function hash(data) {
+  let hashValue = 0;
+  for (let i = 0; i < data.length; i++) {
+    const char = data.charCodeAt(i);
+    hashValue = (hashValue << 5) - hashValue + char;
+    hashValue = hashValue & hashValue;
+  }
+  return Math.abs(hashValue);
+}
+async function generateRSAKeyPair(modulusLength = 2048) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const keyPair = await crypto.subtle.generateKey(
+    {
+      name: "RSA-OAEP",
+      modulusLength,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: "SHA-256"
+    },
+    true,
+    ["encrypt", "decrypt"]
+  );
+  return {
+    publicKey: keyPair.publicKey,
+    privateKey: keyPair.privateKey
+  };
+}
+async function rsaEncrypt(data, publicKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const encoder = new TextEncoder();
+  const dataBuffer = encoder.encode(data);
+  const maxChunkSize = 245;
+  const chunks = [];
+  for (let i = 0; i < dataBuffer.length; i += maxChunkSize) {
+    const chunk = dataBuffer.slice(i, i + maxChunkSize);
+    const encrypted = await crypto.subtle.encrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      publicKey,
+      chunk
+    );
+    chunks.push(encrypted);
+  }
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(new Uint8Array(chunk), offset);
+    offset += chunk.byteLength;
+  }
+  return base64Encode(merged.buffer);
+}
+async function rsaDecrypt(encryptedData, privateKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const binaryString = atob(encryptedData);
+  const encryptedArray = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    encryptedArray[i] = binaryString.charCodeAt(i);
+  }
+  const chunkSize = 256;
+  const chunks = [];
+  for (let i = 0; i < encryptedArray.length; i += chunkSize) {
+    const chunk = encryptedArray.slice(i, i + chunkSize);
+    const decrypted = await crypto.subtle.decrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      privateKey,
+      chunk
+    );
+    const decoder = new TextDecoder();
+    chunks.push(decoder.decode(decrypted));
+  }
+  return chunks.join("");
+}
+async function exportPublicKey(publicKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const exported = await crypto.subtle.exportKey("spki", publicKey);
+  return base64Encode(exported);
+}
+async function exportPrivateKey(privateKey) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const exported = await crypto.subtle.exportKey("pkcs8", privateKey);
+  return base64Encode(exported);
+}
+async function importPublicKey(keyData) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const keyBuffer = base64Decode(keyData);
+  const keyArray = new Uint8Array(keyBuffer.split("").map((char) => char.charCodeAt(0)));
+  return crypto.subtle.importKey(
+    "spki",
+    keyArray.buffer,
+    {
+      name: "RSA-OAEP",
+      hash: "SHA-256"
+    },
+    true,
+    ["encrypt"]
+  );
+}
+async function importPrivateKey(keyData) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const keyBuffer = base64Decode(keyData);
+  const keyArray = new Uint8Array(keyBuffer.split("").map((char) => char.charCodeAt(0)));
+  return crypto.subtle.importKey(
+    "pkcs8",
+    keyArray.buffer,
+    {
+      name: "RSA-OAEP",
+      hash: "SHA-256"
+    },
+    true,
+    ["decrypt"]
+  );
+}
+var init_crypto = __esm({
+  "src/helper/crypto.ts"() {
+  }
+});
 
 // src/browser/storage.ts
+init_crypto();
 var globalKeyPair = null;
 function setStorageKeyPair(keyPair) {
   globalKeyPair = keyPair;
@@ -11,11 +212,11 @@ function getStorageKeyPair() {
   return globalKeyPair;
 }
 async function encryptValue(value, publicKey) {
-  return chunkDYBSRI7V_js.rsaEncrypt(value, publicKey);
+  return rsaEncrypt(value, publicKey);
 }
 async function decryptValue(encryptedValue, privateKey) {
   try {
-    return await chunkDYBSRI7V_js.rsaDecrypt(encryptedValue, privateKey);
+    return await rsaDecrypt(encryptedValue, privateKey);
   } catch {
     try {
       JSON.parse(encryptedValue);
@@ -49,8 +250,8 @@ var localStorage = {
         const encrypted = await encryptValue(jsonStr, keyToUse);
         window.localStorage.setItem(key, encrypted);
       } else {
-        const { base64Encode } = await import('./crypto.js');
-        const encoded = base64Encode(jsonStr);
+        const { base64Encode: base64Encode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+        const encoded = base64Encode2(jsonStr);
         window.localStorage.setItem(key, encoded);
       }
     } catch (error) {
@@ -78,17 +279,17 @@ var localStorage = {
         try {
           decryptedStr = await decryptValue(encryptedStr, keyToUse);
         } catch {
-          const { base64Decode } = await import('./crypto.js');
+          const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
           try {
-            decryptedStr = base64Decode(encryptedStr);
+            decryptedStr = base64Decode2(encryptedStr);
           } catch {
             return defaultValue;
           }
         }
       } else {
-        const { base64Decode } = await import('./crypto.js');
+        const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
         try {
-          decryptedStr = base64Decode(encryptedStr);
+          decryptedStr = base64Decode2(encryptedStr);
         } catch {
           return defaultValue;
         }
@@ -164,8 +365,8 @@ var sessionStorage = {
         const encrypted = await encryptValue(jsonStr, keyToUse);
         window.sessionStorage.setItem(key, encrypted);
       } else {
-        const { base64Encode } = await import('./crypto.js');
-        const encoded = base64Encode(jsonStr);
+        const { base64Encode: base64Encode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+        const encoded = base64Encode2(jsonStr);
         window.sessionStorage.setItem(key, encoded);
       }
     } catch (error) {
@@ -193,17 +394,17 @@ var sessionStorage = {
         try {
           decryptedStr = await decryptValue(encryptedStr, keyToUse);
         } catch {
-          const { base64Decode } = await import('./crypto.js');
+          const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
           try {
-            decryptedStr = base64Decode(encryptedStr);
+            decryptedStr = base64Decode2(encryptedStr);
           } catch {
             return defaultValue;
           }
         }
       } else {
-        const { base64Decode } = await import('./crypto.js');
+        const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
         try {
-          decryptedStr = base64Decode(encryptedStr);
+          decryptedStr = base64Decode2(encryptedStr);
         } catch {
           return defaultValue;
         }
@@ -357,5 +558,3 @@ exports.localStorage = localStorage;
 exports.sessionStorage = sessionStorage;
 exports.setStorageKeyPair = setStorageKeyPair;
 exports.storage = storage;
-//# sourceMappingURL=chunk-WZDOPUJW.js.map
-//# sourceMappingURL=chunk-WZDOPUJW.js.map