@alibarbar/common 1.0.8 → 1.0.10

package/dist/crypto.js

@@ -1,61 +1,173 @@
-'use strict';
+// src/helper/crypto.ts
+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 chunkDYBSRI7V_js = require('./chunk-DYBSRI7V.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "base64Decode", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.base64Decode; }
-});
-Object.defineProperty(exports, "base64Encode", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.base64Encode; }
-});
-Object.defineProperty(exports, "exportPrivateKey", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.exportPrivateKey; }
-});
-Object.defineProperty(exports, "exportPublicKey", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.exportPublicKey; }
-});
-Object.defineProperty(exports, "generateRSAKeyPair", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.generateRSAKeyPair; }
-});
-Object.defineProperty(exports, "generateRandomString", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.generateRandomString; }
-});
-Object.defineProperty(exports, "generateUUID", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.generateUUID; }
-});
-Object.defineProperty(exports, "hash", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.hash; }
-});
-Object.defineProperty(exports, "importPrivateKey", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.importPrivateKey; }
-});
-Object.defineProperty(exports, "importPublicKey", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.importPublicKey; }
-});
-Object.defineProperty(exports, "rsaDecrypt", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.rsaDecrypt; }
-});
-Object.defineProperty(exports, "rsaEncrypt", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.rsaEncrypt; }
-});
-Object.defineProperty(exports, "sha256", {
-  enumerable: true,
-  get: function () { return chunkDYBSRI7V_js.sha256; }
-});
-//# sourceMappingURL=crypto.js.map
-//# sourceMappingURL=crypto.js.map
+export { base64Decode, base64Encode, exportPrivateKey, exportPublicKey, generateRSAKeyPair, generateRandomString, generateUUID, hash, importPrivateKey, importPublicKey, rsaDecrypt, rsaEncrypt, sha256 };

package/dist/{chunk-BHCRFURU.js → data-structure.cjs}

@@ -487,5 +487,3 @@ exports.Graph = Graph;
 exports.LRUCache = LRUCache;
 exports.LinkedList = LinkedList;
 exports.Stack = Stack;
-//# sourceMappingURL=chunk-BHCRFURU.js.map
-//# sourceMappingURL=chunk-BHCRFURU.js.map