@alibarbar/common 1.0.9 → 1.1.0

package/dist/{chunk-DYBSRI7V.js → crypto.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/helper/crypto.ts
+// src/helper/crypto/index.ts
 async function sha256(data) {
   const buffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
   const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
@@ -171,11 +171,118 @@ async function importPrivateKey(keyData) {
     ["decrypt"]
   );
 }
+async function generateHMACKey() {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  return crypto.subtle.generateKey(
+    {
+      name: "HMAC",
+      hash: "SHA-256"
+    },
+    true,
+    ["sign", "verify"]
+  );
+}
+async function computeHMAC(data, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const buffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const signature = await crypto.subtle.sign("HMAC", key, buffer);
+  return base64Encode(signature);
+}
+async function verifyHMAC(data, signature, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  try {
+    const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const signatureBuffer = new Uint8Array(
+      atob(signature).split("").map((char) => char.charCodeAt(0))
+    );
+    return await crypto.subtle.verify("HMAC", key, signatureBuffer, dataBuffer);
+  } catch {
+    return false;
+  }
+}
+async function deriveKeyFromPassword(password, salt, iterations = 1e5, keyLength = 256) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const saltBuffer = typeof salt === "string" ? new TextEncoder().encode(salt) : salt;
+  const passwordKey = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits", "deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    {
+      name: "PBKDF2",
+      salt: saltBuffer,
+      iterations,
+      hash: "SHA-256"
+    },
+    passwordKey,
+    {
+      name: "AES-GCM",
+      length: keyLength
+    },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function aesGCMEncrypt(data, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encrypted = await crypto.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv
+    },
+    key,
+    dataBuffer
+  );
+  return {
+    encrypted: base64Encode(encrypted),
+    iv: base64Encode(iv.buffer)
+  };
+}
+async function aesGCMDecrypt(encryptedData, iv, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const encryptedBuffer = new Uint8Array(
+    atob(encryptedData).split("").map((char) => char.charCodeAt(0))
+  );
+  const ivBuffer = new Uint8Array(
+    atob(iv).split("").map((char) => char.charCodeAt(0))
+  );
+  const decrypted = await crypto.subtle.decrypt(
+    {
+      name: "AES-GCM",
+      iv: ivBuffer
+    },
+    key,
+    encryptedBuffer
+  );
+  return new TextDecoder().decode(decrypted);
+}
 
+exports.aesGCMDecrypt = aesGCMDecrypt;
+exports.aesGCMEncrypt = aesGCMEncrypt;
 exports.base64Decode = base64Decode;
 exports.base64Encode = base64Encode;
+exports.computeHMAC = computeHMAC;
+exports.deriveKeyFromPassword = deriveKeyFromPassword;
 exports.exportPrivateKey = exportPrivateKey;
 exports.exportPublicKey = exportPublicKey;
+exports.generateHMACKey = generateHMACKey;
 exports.generateRSAKeyPair = generateRSAKeyPair;
 exports.generateRandomString = generateRandomString;
 exports.generateUUID = generateUUID;
@@ -185,5 +292,4 @@ exports.importPublicKey = importPublicKey;
 exports.rsaDecrypt = rsaDecrypt;
 exports.rsaEncrypt = rsaEncrypt;
 exports.sha256 = sha256;
-//# sourceMappingURL=chunk-DYBSRI7V.js.map
-//# sourceMappingURL=chunk-DYBSRI7V.js.map
+exports.verifyHMAC = verifyHMAC;

package/dist/crypto.d.mts

@@ -88,5 +88,52 @@ declare function importPublicKey(keyData: string): Promise<CryptoKey>;
  * @returns Promise<CryptoKey> 私钥对象
  */
 declare function importPrivateKey(keyData: string): Promise<CryptoKey>;
+/**
+ * 生成 HMAC 密钥
+ * @returns Promise<CryptoKey> HMAC 密钥
+ */
+declare function generateHMACKey(): Promise<CryptoKey>;
+/**
+ * 计算 HMAC 签名
+ * @param data - 要签名的数据（字符串或ArrayBuffer）
+ * @param key - HMAC密钥
+ * @returns Promise<string> Base64编码的HMAC签名
+ */
+declare function computeHMAC(data: string | ArrayBuffer, key: CryptoKey): Promise<string>;
+/**
+ * 验证 HMAC 签名
+ * @param data - 原始数据（字符串或ArrayBuffer）
+ * @param signature - Base64编码的HMAC签名
+ * @param key - HMAC密钥
+ * @returns Promise<boolean> 签名是否有效
+ */
+declare function verifyHMAC(data: string | ArrayBuffer, signature: string, key: CryptoKey): Promise<boolean>;
+/**
+ * 使用 PBKDF2 派生密钥
+ * @param password - 密码（字符串）
+ * @param salt - 盐值（ArrayBuffer 或字符串）
+ * @param iterations - 迭代次数，默认为 100000
+ * @param keyLength - 密钥长度（位），默认为 256
+ * @returns Promise<CryptoKey> 派生的密钥
+ */
+declare function deriveKeyFromPassword(password: string, salt: ArrayBuffer | string, iterations?: number, keyLength?: number): Promise<CryptoKey>;
+/**
+ * 使用 AES-GCM 加密数据
+ * @param data - 要加密的数据（字符串或ArrayBuffer）
+ * @param key - AES密钥
+ * @returns Promise<{encrypted: string, iv: string}> 加密后的数据和初始向量（Base64编码）
+ */
+declare function aesGCMEncrypt(data: string | ArrayBuffer, key: CryptoKey): Promise<{
+    encrypted: string;
+    iv: string;
+}>;
+/**
+ * 使用 AES-GCM 解密数据
+ * @param encryptedData - Base64编码的加密数据
+ * @param iv - Base64编码的初始向量
+ * @param key - AES密钥
+ * @returns Promise<string> 解密后的字符串
+ */
+declare function aesGCMDecrypt(encryptedData: string, iv: string, key: CryptoKey): Promise<string>;
 
-export { type RSAKeyPair, base64Decode, base64Encode, exportPrivateKey, exportPublicKey, generateRSAKeyPair, generateRandomString, generateUUID, hash, importPrivateKey, importPublicKey, rsaDecrypt, rsaEncrypt, sha256 };
+export { type RSAKeyPair, aesGCMDecrypt, aesGCMEncrypt, base64Decode, base64Encode, computeHMAC, deriveKeyFromPassword, exportPrivateKey, exportPublicKey, generateHMACKey, generateRSAKeyPair, generateRandomString, generateUUID, hash, importPrivateKey, importPublicKey, rsaDecrypt, rsaEncrypt, sha256, verifyHMAC };

package/dist/crypto.d.ts

@@ -88,5 +88,52 @@ declare function importPublicKey(keyData: string): Promise<CryptoKey>;
  * @returns Promise<CryptoKey> 私钥对象
  */
 declare function importPrivateKey(keyData: string): Promise<CryptoKey>;
+/**
+ * 生成 HMAC 密钥
+ * @returns Promise<CryptoKey> HMAC 密钥
+ */
+declare function generateHMACKey(): Promise<CryptoKey>;
+/**
+ * 计算 HMAC 签名
+ * @param data - 要签名的数据（字符串或ArrayBuffer）
+ * @param key - HMAC密钥
+ * @returns Promise<string> Base64编码的HMAC签名
+ */
+declare function computeHMAC(data: string | ArrayBuffer, key: CryptoKey): Promise<string>;
+/**
+ * 验证 HMAC 签名
+ * @param data - 原始数据（字符串或ArrayBuffer）
+ * @param signature - Base64编码的HMAC签名
+ * @param key - HMAC密钥
+ * @returns Promise<boolean> 签名是否有效
+ */
+declare function verifyHMAC(data: string | ArrayBuffer, signature: string, key: CryptoKey): Promise<boolean>;
+/**
+ * 使用 PBKDF2 派生密钥
+ * @param password - 密码（字符串）
+ * @param salt - 盐值（ArrayBuffer 或字符串）
+ * @param iterations - 迭代次数，默认为 100000
+ * @param keyLength - 密钥长度（位），默认为 256
+ * @returns Promise<CryptoKey> 派生的密钥
+ */
+declare function deriveKeyFromPassword(password: string, salt: ArrayBuffer | string, iterations?: number, keyLength?: number): Promise<CryptoKey>;
+/**
+ * 使用 AES-GCM 加密数据
+ * @param data - 要加密的数据（字符串或ArrayBuffer）
+ * @param key - AES密钥
+ * @returns Promise<{encrypted: string, iv: string}> 加密后的数据和初始向量（Base64编码）
+ */
+declare function aesGCMEncrypt(data: string | ArrayBuffer, key: CryptoKey): Promise<{
+    encrypted: string;
+    iv: string;
+}>;
+/**
+ * 使用 AES-GCM 解密数据
+ * @param encryptedData - Base64编码的加密数据
+ * @param iv - Base64编码的初始向量
+ * @param key - AES密钥
+ * @returns Promise<string> 解密后的字符串
+ */
+declare function aesGCMDecrypt(encryptedData: string, iv: string, key: CryptoKey): Promise<string>;
 
-export { type RSAKeyPair, base64Decode, base64Encode, exportPrivateKey, exportPublicKey, generateRSAKeyPair, generateRandomString, generateUUID, hash, importPrivateKey, importPublicKey, rsaDecrypt, rsaEncrypt, sha256 };
+export { type RSAKeyPair, aesGCMDecrypt, aesGCMEncrypt, base64Decode, base64Encode, computeHMAC, deriveKeyFromPassword, exportPrivateKey, exportPublicKey, generateHMACKey, generateRSAKeyPair, generateRandomString, generateUUID, hash, importPrivateKey, importPublicKey, rsaDecrypt, rsaEncrypt, sha256, verifyHMAC };

package/dist/crypto.js

@@ -1,61 +1,275 @@
-'use strict';
+// src/helper/crypto/index.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"]
+  );
+}
+async function generateHMACKey() {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  return crypto.subtle.generateKey(
+    {
+      name: "HMAC",
+      hash: "SHA-256"
+    },
+    true,
+    ["sign", "verify"]
+  );
+}
+async function computeHMAC(data, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const buffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const signature = await crypto.subtle.sign("HMAC", key, buffer);
+  return base64Encode(signature);
+}
+async function verifyHMAC(data, signature, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  try {
+    const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const signatureBuffer = new Uint8Array(
+      atob(signature).split("").map((char) => char.charCodeAt(0))
+    );
+    return await crypto.subtle.verify("HMAC", key, signatureBuffer, dataBuffer);
+  } catch {
+    return false;
+  }
+}
+async function deriveKeyFromPassword(password, salt, iterations = 1e5, keyLength = 256) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const saltBuffer = typeof salt === "string" ? new TextEncoder().encode(salt) : salt;
+  const passwordKey = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    "PBKDF2",
+    false,
+    ["deriveBits", "deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    {
+      name: "PBKDF2",
+      salt: saltBuffer,
+      iterations,
+      hash: "SHA-256"
+    },
+    passwordKey,
+    {
+      name: "AES-GCM",
+      length: keyLength
+    },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function aesGCMEncrypt(data, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const encrypted = await crypto.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv
+    },
+    key,
+    dataBuffer
+  );
+  return {
+    encrypted: base64Encode(encrypted),
+    iv: base64Encode(iv.buffer)
+  };
+}
+async function aesGCMDecrypt(encryptedData, iv, key) {
+  if (typeof crypto === "undefined" || !crypto.subtle) {
+    throw new Error("Web Crypto API is not available");
+  }
+  const encryptedBuffer = new Uint8Array(
+    atob(encryptedData).split("").map((char) => char.charCodeAt(0))
+  );
+  const ivBuffer = new Uint8Array(
+    atob(iv).split("").map((char) => char.charCodeAt(0))
+  );
+  const decrypted = await crypto.subtle.decrypt(
+    {
+      name: "AES-GCM",
+      iv: ivBuffer
+    },
+    key,
+    encryptedBuffer
+  );
+  return new TextDecoder().decode(decrypted);
+}
 
-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 { aesGCMDecrypt, aesGCMEncrypt, base64Decode, base64Encode, computeHMAC, deriveKeyFromPassword, exportPrivateKey, exportPublicKey, generateHMACKey, generateRSAKeyPair, generateRandomString, generateUUID, hash, importPrivateKey, importPublicKey, rsaDecrypt, rsaEncrypt, sha256, verifyHMAC };

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

@@ -1,6 +1,6 @@
 'use strict';
 
-// src/data/data-structure.ts
+// src/data/data-structure/index.ts
 var Stack = class {
   constructor() {
     this.items = [];
@@ -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