@alibarbar/common 1.0.10 → 1.1.1

package/dist/index.cjs

@@ -8,209 +8,7 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var Qs__default = /*#__PURE__*/_interopDefault(Qs);
 var axios__default = /*#__PURE__*/_interopDefault(axios);
 
-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 chunk2 = dataBuffer.slice(i, i + maxChunkSize);
-    const encrypted = await crypto.subtle.encrypt(
-      {
-        name: "RSA-OAEP"
-      },
-      publicKey,
-      chunk2
-    );
-    chunks.push(encrypted);
-  }
-  const totalLength = chunks.reduce((sum, chunk2) => sum + chunk2.byteLength, 0);
-  const merged = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk2 of chunks) {
-    merged.set(new Uint8Array(chunk2), offset);
-    offset += chunk2.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 chunk2 = encryptedArray.slice(i, i + chunkSize);
-    const decrypted = await crypto.subtle.decrypt(
-      {
-        name: "RSA-OAEP"
-      },
-      privateKey,
-      chunk2
-    );
-    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/core/string.ts
+// src/core/string/index.ts
 function capitalize(str) {
   if (!str) return str;
   return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
@@ -301,7 +99,7 @@ function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/core/array.ts
+// src/core/array/index.ts
 function unique(arr) {
   return Array.from(new Set(arr));
 }
@@ -436,7 +234,7 @@ function dropWhile(arr, predicate) {
   return arr.slice(index);
 }
 
-// src/core/object.ts
+// src/core/object/index.ts
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") {
     return obj;
@@ -673,7 +471,7 @@ function omitBy(obj, predicate) {
   return result;
 }
 
-// src/core/date.ts
+// src/core/date/index.ts
 function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
   const d = typeof date === "number" ? new Date(date) : date;
   const year = d.getFullYear();
@@ -798,7 +596,7 @@ function getQuarter(date) {
   return Math.floor(d.getMonth() / 3) + 1;
 }
 
-// src/core/validation.ts
+// src/core/validation/index.ts
 function isValidEmail(email) {
   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
   return emailRegex.test(email);
@@ -875,7 +673,7 @@ function isFloat(value) {
   return false;
 }
 
-// src/format/number.ts
+// src/format/number/index.ts
 function formatNumber(num, options = {}) {
   const { decimals, separator = ",", decimalPoint = ".", minimumFractionDigits } = options;
   let numStr;
@@ -952,7 +750,7 @@ function formatBytes(bytes, decimals = 2) {
   return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
 }
 
-// src/format/url.ts
+// src/format/url/index.ts
 function parseUrl(url) {
   try {
     const urlObj = new URL(url);
@@ -1043,7 +841,7 @@ function normalizeUrl(url) {
   }
 }
 
-// src/format/color.ts
+// src/format/color/index.ts
 function hexToRgb(hex) {
   const cleanHex = hex.replace("#", "");
   if (!/^[0-9A-Fa-f]{6}$/.test(cleanHex)) {
@@ -1170,7 +968,7 @@ function contrast(color1, color2) {
   return (lighter + 0.05) / (darker + 0.05);
 }
 
-// src/format/i18n.ts
+// src/format/i18n/index.ts
 function getLocale() {
   if (typeof navigator !== "undefined" && navigator.language) {
     return navigator.language;
@@ -1248,7 +1046,7 @@ function pluralize(count, singular, plural, locale) {
   return `${count} ${pluralForm}`;
 }
 
-// src/browser/file.ts
+// src/browser/file/index.ts
 async function calculateFileMD5(file) {
   return new Promise((resolve, reject) => {
     if (typeof FileReader === "undefined") {
@@ -1338,7 +1136,7 @@ var UploadStatus = /* @__PURE__ */ ((UploadStatus2) => {
   return UploadStatus2;
 })(UploadStatus || {});
 
-// src/browser/upload.ts
+// src/browser/upload/index.ts
 var ChunkUploader = class {
   constructor(file, options = {}) {
     this.taskId = null;
@@ -1545,186 +1343,757 @@ var ChunkUploader = class {
         method: "POST",
         headers: this.options.headers
       }
-    );
-    console.log("[\u5B8C\u6210\u4E0A\u4F20] \u63A5\u53E3\u54CD\u5E94:", response);
-    if (response.code !== 200) {
-      throw new Error(response.message || "\u5B8C\u6210\u4E0A\u4F20\u5931\u8D25");
+    );
+    console.log("[\u5B8C\u6210\u4E0A\u4F20] \u63A5\u53E3\u54CD\u5E94:", response);
+    if (response.code !== 200) {
+      throw new Error(response.message || "\u5B8C\u6210\u4E0A\u4F20\u5931\u8D25");
+    }
+    return response.data;
+  }
+  /**
+   * 开始上传
+   */
+  async upload() {
+    try {
+      this.status = "uploading" /* UPLOADING */;
+      this.abortController = new AbortController();
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 1. \u521D\u59CB\u5316\u4E0A\u4F20");
+      const initResponse = await this.initUpload();
+      this.taskId = initResponse.taskId;
+      if (initResponse.instantUpload && initResponse.fileUrl) {
+        console.log("[\u4E0A\u4F20\u6D41\u7A0B] \u79D2\u4F20\u6210\u529F");
+        this.status = "completed" /* COMPLETED */;
+        const result = {
+          taskId: this.taskId,
+          fileUrl: initResponse.fileUrl,
+          fileName: this.file.name,
+          fileSize: this.file.size,
+          fileMd5: "",
+          success: true,
+          message: "\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u79D2\u4F20\u6210\u529F"
+        };
+        this.options.onComplete(result);
+        return result;
+      }
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 2. \u51C6\u5907\u5206\u7247");
+      this.prepareChunks();
+      const totalChunks = this.chunks.length;
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] \u5171 ${totalChunks} \u4E2A\u5206\u7247`);
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 3. \u68C0\u67E5\u5DF2\u4E0A\u4F20\u5206\u7247");
+      const existingChunks = await this.getUploadedChunks();
+      existingChunks.forEach((index) => this.uploadedChunks.add(index));
+      console.log(
+        `[\u4E0A\u4F20\u6D41\u7A0B] \u5DF2\u4E0A\u4F20 ${existingChunks.length} \u4E2A\u5206\u7247\uFF0C\u8FD8\u9700\u4E0A\u4F20 ${totalChunks - existingChunks.length} \u4E2A`
+      );
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 4. \u5F00\u59CB\u4E0A\u4F20\u5206\u7247");
+      await this.uploadChunksConcurrently();
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 5. \u6240\u6709\u5206\u7247\u4E0A\u4F20\u5B8C\u6210");
+      const uploadedCount = this.uploadedChunks.size;
+      if (uploadedCount < totalChunks) {
+        throw new Error(`\u4E0A\u4F20\u9A8C\u8BC1\u5931\u8D25\uFF1A\u5DF2\u4E0A\u4F20 ${uploadedCount}/${totalChunks} \u4E2A\u5206\u7247`);
+      }
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 6. \u9A8C\u8BC1\u901A\u8FC7\uFF1A${uploadedCount}/${totalChunks} \u4E2A\u5206\u7247\u5DF2\u4E0A\u4F20`);
+      const localPercentage = Math.round(uploadedCount / totalChunks * 100);
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 7. \u672C\u5730\u8FDB\u5EA6\uFF1A${localPercentage}%`);
+      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 8. \u83B7\u53D6\u670D\u52A1\u7AEF\u8FDB\u5EA6");
+      const serverProgress = await this.getUploadProgress();
+      const serverPercentage = serverProgress?.percentage ?? 0;
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] \u670D\u52A1\u7AEF\u8FDB\u5EA6\uFF1A${serverPercentage}%`);
+      const finalPercentage = serverProgress?.percentage ?? localPercentage;
+      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 9. \u6700\u7EC8\u8FDB\u5EA6\uFF1A${finalPercentage}%`);
+      if (finalPercentage >= 100) {
+        console.log("[\u4E0A\u4F20\u6D41\u7A0B] 10. \u2705 \u8FDB\u5EA6\u8FBE\u5230100%\uFF0C\u8C03\u7528\u5B8C\u6210\u63A5\u53E3");
+        const result = await this.completeUpload();
+        this.status = "completed" /* COMPLETED */;
+        this.options.onComplete(result);
+        console.log("[\u4E0A\u4F20\u6D41\u7A0B] \u2705 \u4E0A\u4F20\u5B8C\u6210");
+        return result;
+      } else {
+        console.error(`[\u4E0A\u4F20\u6D41\u7A0B] \u274C \u8FDB\u5EA6\u4E0D\u8DB3100%\uFF1A${finalPercentage}%`);
+        throw new Error(`\u4E0A\u4F20\u672A\u5B8C\u6210\uFF1A\u5F53\u524D\u8FDB\u5EA6 ${finalPercentage.toFixed(2)}%`);
+      }
+    } catch (error) {
+      this.status = "failed" /* FAILED */;
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.options.onError(err);
+      console.error("[\u4E0A\u4F20\u6D41\u7A0B] \u274C \u4E0A\u4F20\u5931\u8D25:", err);
+      throw err;
+    }
+  }
+  /**
+   * 暂停上传
+   */
+  pause() {
+    if (this.status === "uploading" /* UPLOADING */) {
+      this.status = "paused" /* PAUSED */;
+      if (this.abortController) {
+        this.abortController.abort();
+      }
+    }
+  }
+  /**
+   * 恢复上传
+   */
+  async resume() {
+    if (this.status === "paused" /* PAUSED */) {
+      return this.upload();
+    }
+    throw new Error("\u5F53\u524D\u72B6\u6001\u65E0\u6CD5\u6062\u590D\u4E0A\u4F20");
+  }
+  /**
+   * 取消上传
+   */
+  async cancel() {
+    if (this.taskId && this.status === "uploading" /* UPLOADING */) {
+      try {
+        await this.request(`/api/files/common/cancel/${this.taskId}`, {
+          method: "POST",
+          headers: this.options.headers
+        });
+      } catch (error) {
+        console.warn("\u53D6\u6D88\u4E0A\u4F20\u5931\u8D25:", error);
+      }
+    }
+    this.status = "cancelled" /* CANCELLED */;
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  /**
+   * 获取当前状态
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * 获取任务ID
+   */
+  getTaskId() {
+    return this.taskId;
+  }
+  /**
+   * HTTP请求封装
+   */
+  async request(url, options = {}) {
+    const fullUrl = `${this.options.baseURL}${url}`;
+    const signal = this.abortController?.signal;
+    const response = await fetch(fullUrl, {
+      ...options,
+      signal
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP\u9519\u8BEF: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * 延迟函数
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+function createUploader(file, options) {
+  return new ChunkUploader(file, options);
+}
+async function uploadFile(file, options) {
+  const uploader = createUploader(file, options);
+  return uploader.upload();
+}
+
+// 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 chunk2 = dataBuffer.slice(i, i + maxChunkSize);
+    const encrypted = await crypto.subtle.encrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      publicKey,
+      chunk2
+    );
+    chunks.push(encrypted);
+  }
+  const totalLength = chunks.reduce((sum, chunk2) => sum + chunk2.byteLength, 0);
+  const merged = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk2 of chunks) {
+    merged.set(new Uint8Array(chunk2), offset);
+    offset += chunk2.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 chunk2 = encryptedArray.slice(i, i + chunkSize);
+    const decrypted = await crypto.subtle.decrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      privateKey,
+      chunk2
+    );
+    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);
+}
+
+// src/browser/SecureStorage/index.ts
+var globalKeyPair = null;
+var globalHMACKey = null;
+var keyPairInitialized = false;
+var initOptions = {
+  autoGenerateKeys: true,
+  persistKeys: false,
+  keyStorageKey: void 0,
+  // 将自动生成随机键名
+  keyEncryptionPassword: void 0,
+  pbkdf2Iterations: 1e5,
+  keyModulusLength: 2048,
+  enableHMAC: true,
+  enableTimestampValidation: true,
+  timestampMaxAge: 7 * 24 * 60 * 60 * 1e3,
+  // 7 天
+  isProduction: false
+};
+var actualKeyStorageKey = null;
+var keyUsageCount = 0;
+var initializationPromise = null;
+function generateKeyStorageKey() {
+  return `_sk_${generateRandomString(32)}_${Date.now()}`;
+}
+async function initializeStorageKeys(options = {}) {
+  if (options.forceReinitialize) {
+    globalKeyPair = null;
+    globalHMACKey = null;
+    keyPairInitialized = false;
+    actualKeyStorageKey = null;
+    keyUsageCount = 0;
+    initializationPromise = null;
+  } else if (keyPairInitialized && globalKeyPair) {
+    initOptions = { ...initOptions, ...options };
+    return;
+  }
+  initOptions = { ...initOptions, ...options };
+  if (initOptions.keyStorageKey) {
+    actualKeyStorageKey = initOptions.keyStorageKey;
+  } else {
+    actualKeyStorageKey = generateKeyStorageKey();
+  }
+  if (initOptions.persistKeys && typeof window !== "undefined" && window.localStorage) {
+    try {
+      const storedKeys = window.localStorage.getItem(actualKeyStorageKey);
+      if (storedKeys) {
+        const keyData = JSON.parse(storedKeys);
+        if (keyData.encrypted && keyData.privateKeyEncrypted && keyData.salt) {
+          if (!initOptions.keyEncryptionPassword) {
+            if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+              console.error("Encrypted keys found but no password provided");
+            }
+            throw new Error("Password required to decrypt stored keys");
+          }
+          const saltArray = new Uint8Array(
+            atob(keyData.salt).split("").map((char) => char.charCodeAt(0))
+          );
+          const iterations = keyData.pbkdf2Iterations || initOptions.pbkdf2Iterations;
+          const derivedKey = await deriveKeyFromPassword(
+            initOptions.keyEncryptionPassword,
+            saltArray.buffer,
+            iterations
+          );
+          const decryptedPrivateKey = await aesGCMDecrypt(
+            keyData.privateKeyEncrypted,
+            keyData.iv,
+            derivedKey
+          );
+          globalKeyPair = {
+            publicKey: await importPublicKey(keyData.publicKey),
+            privateKey: await importPrivateKey(decryptedPrivateKey)
+          };
+        } else if (keyData.publicKey && keyData.privateKey) {
+          if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+            console.warn(
+              "\u26A0\uFE0F SECURITY WARNING: Loading unencrypted keys from storage. Consider re-initializing with password encryption."
+            );
+          }
+          globalKeyPair = {
+            publicKey: await importPublicKey(keyData.publicKey),
+            privateKey: await importPrivateKey(keyData.privateKey)
+          };
+        }
+        if (globalKeyPair) {
+          keyPairInitialized = true;
+          if (initOptions.enableHMAC && !globalHMACKey) {
+            globalHMACKey = await generateHMACKey();
+          }
+          return;
+        }
+      }
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+        console.warn("Failed to load persisted keys, will generate new ones");
+      }
     }
-    return response.data;
   }
-  /**
-   * 开始上传
-   */
-  async upload() {
+  if (initOptions.autoGenerateKeys && !globalKeyPair) {
     try {
-      this.status = "uploading" /* UPLOADING */;
-      this.abortController = new AbortController();
-      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 1. \u521D\u59CB\u5316\u4E0A\u4F20");
-      const initResponse = await this.initUpload();
-      this.taskId = initResponse.taskId;
-      if (initResponse.instantUpload && initResponse.fileUrl) {
-        console.log("[\u4E0A\u4F20\u6D41\u7A0B] \u79D2\u4F20\u6210\u529F");
-        this.status = "completed" /* COMPLETED */;
-        const result = {
-          taskId: this.taskId,
-          fileUrl: initResponse.fileUrl,
-          fileName: this.file.name,
-          fileSize: this.file.size,
-          fileMd5: "",
-          success: true,
-          message: "\u6587\u4EF6\u5DF2\u5B58\u5728\uFF0C\u79D2\u4F20\u6210\u529F"
-        };
-        this.options.onComplete(result);
-        return result;
-      }
-      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 2. \u51C6\u5907\u5206\u7247");
-      this.prepareChunks();
-      const totalChunks = this.chunks.length;
-      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] \u5171 ${totalChunks} \u4E2A\u5206\u7247`);
-      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 3. \u68C0\u67E5\u5DF2\u4E0A\u4F20\u5206\u7247");
-      const existingChunks = await this.getUploadedChunks();
-      existingChunks.forEach((index) => this.uploadedChunks.add(index));
-      console.log(
-        `[\u4E0A\u4F20\u6D41\u7A0B] \u5DF2\u4E0A\u4F20 ${existingChunks.length} \u4E2A\u5206\u7247\uFF0C\u8FD8\u9700\u4E0A\u4F20 ${totalChunks - existingChunks.length} \u4E2A`
-      );
-      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 4. \u5F00\u59CB\u4E0A\u4F20\u5206\u7247");
-      await this.uploadChunksConcurrently();
-      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 5. \u6240\u6709\u5206\u7247\u4E0A\u4F20\u5B8C\u6210");
-      const uploadedCount = this.uploadedChunks.size;
-      if (uploadedCount < totalChunks) {
-        throw new Error(`\u4E0A\u4F20\u9A8C\u8BC1\u5931\u8D25\uFF1A\u5DF2\u4E0A\u4F20 ${uploadedCount}/${totalChunks} \u4E2A\u5206\u7247`);
+      globalKeyPair = await generateRSAKeyPair(initOptions.keyModulusLength);
+      if (initOptions.enableHMAC && !globalHMACKey) {
+        globalHMACKey = await generateHMACKey();
       }
-      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 6. \u9A8C\u8BC1\u901A\u8FC7\uFF1A${uploadedCount}/${totalChunks} \u4E2A\u5206\u7247\u5DF2\u4E0A\u4F20`);
-      const localPercentage = Math.round(uploadedCount / totalChunks * 100);
-      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 7. \u672C\u5730\u8FDB\u5EA6\uFF1A${localPercentage}%`);
-      console.log("[\u4E0A\u4F20\u6D41\u7A0B] 8. \u83B7\u53D6\u670D\u52A1\u7AEF\u8FDB\u5EA6");
-      const serverProgress = await this.getUploadProgress();
-      const serverPercentage = serverProgress?.percentage ?? 0;
-      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] \u670D\u52A1\u7AEF\u8FDB\u5EA6\uFF1A${serverPercentage}%`);
-      const finalPercentage = serverProgress?.percentage ?? localPercentage;
-      console.log(`[\u4E0A\u4F20\u6D41\u7A0B] 9. \u6700\u7EC8\u8FDB\u5EA6\uFF1A${finalPercentage}%`);
-      if (finalPercentage >= 100) {
-        console.log("[\u4E0A\u4F20\u6D41\u7A0B] 10. \u2705 \u8FDB\u5EA6\u8FBE\u5230100%\uFF0C\u8C03\u7528\u5B8C\u6210\u63A5\u53E3");
-        const result = await this.completeUpload();
-        this.status = "completed" /* COMPLETED */;
-        this.options.onComplete(result);
-        console.log("[\u4E0A\u4F20\u6D41\u7A0B] \u2705 \u4E0A\u4F20\u5B8C\u6210");
-        return result;
-      } else {
-        console.error(`[\u4E0A\u4F20\u6D41\u7A0B] \u274C \u8FDB\u5EA6\u4E0D\u8DB3100%\uFF1A${finalPercentage}%`);
-        throw new Error(`\u4E0A\u4F20\u672A\u5B8C\u6210\uFF1A\u5F53\u524D\u8FDB\u5EA6 ${finalPercentage.toFixed(2)}%`);
+      keyPairInitialized = true;
+      keyUsageCount = 0;
+      if (initOptions.persistKeys && typeof window !== "undefined" && window.localStorage) {
+        try {
+          const publicKeyStr = await exportPublicKey(globalKeyPair.publicKey);
+          if (initOptions.keyEncryptionPassword) {
+            const privateKeyStr = await exportPrivateKey(globalKeyPair.privateKey);
+            const salt = crypto.getRandomValues(new Uint8Array(16));
+            const derivedKey = await deriveKeyFromPassword(
+              initOptions.keyEncryptionPassword,
+              salt.buffer,
+              initOptions.pbkdf2Iterations
+            );
+            const { encrypted, iv } = await aesGCMEncrypt(privateKeyStr, derivedKey);
+            const keyData = {
+              encrypted: true,
+              publicKey: publicKeyStr,
+              privateKeyEncrypted: encrypted,
+              iv,
+              salt: base64Encode(salt.buffer),
+              pbkdf2Iterations: initOptions.pbkdf2Iterations
+            };
+            window.localStorage.setItem(actualKeyStorageKey, JSON.stringify(keyData));
+            if (!initOptions.isProduction && typeof console !== "undefined" && console.info) {
+              console.info("\u2705 Keys encrypted and stored securely");
+            }
+          } else {
+            if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+              console.warn(
+                "\u26A0\uFE0F SECURITY WARNING: Storing private keys without encryption! Private keys will be stored in plain text (Base64 encoded). Provide keyEncryptionPassword for secure storage."
+              );
+            }
+            const keyData = {
+              publicKey: publicKeyStr,
+              privateKey: await exportPrivateKey(globalKeyPair.privateKey)
+            };
+            window.localStorage.setItem(actualKeyStorageKey, JSON.stringify(keyData));
+          }
+        } catch (error) {
+          if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+            console.error("Failed to persist keys");
+          }
+        }
       }
     } catch (error) {
-      this.status = "failed" /* FAILED */;
-      const err = error instanceof Error ? error : new Error(String(error));
-      this.options.onError(err);
-      console.error("[\u4E0A\u4F20\u6D41\u7A0B] \u274C \u4E0A\u4F20\u5931\u8D25:", err);
-      throw err;
-    }
-  }
-  /**
-   * 暂停上传
-   */
-  pause() {
-    if (this.status === "uploading" /* UPLOADING */) {
-      this.status = "paused" /* PAUSED */;
-      if (this.abortController) {
-        this.abortController.abort();
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("Failed to generate storage keys");
       }
+      throw error;
     }
   }
-  /**
-   * 恢复上传
-   */
-  async resume() {
-    if (this.status === "paused" /* PAUSED */) {
-      return this.upload();
-    }
-    throw new Error("\u5F53\u524D\u72B6\u6001\u65E0\u6CD5\u6062\u590D\u4E0A\u4F20");
+  if (initOptions.enableHMAC && !globalHMACKey) {
+    globalHMACKey = await generateHMACKey();
   }
-  /**
-   * 取消上传
-   */
-  async cancel() {
-    if (this.taskId && this.status === "uploading" /* UPLOADING */) {
-      try {
-        await this.request(`/api/files/common/cancel/${this.taskId}`, {
-          method: "POST",
-          headers: this.options.headers
-        });
-      } catch (error) {
-        console.warn("\u53D6\u6D88\u4E0A\u4F20\u5931\u8D25:", error);
+}
+function setStorageKeyPair(keyPair) {
+  globalKeyPair = keyPair;
+  keyPairInitialized = true;
+}
+function getStorageKeyPair() {
+  return globalKeyPair;
+}
+function clearPersistedKeys() {
+  if (typeof window !== "undefined" && window.localStorage && actualKeyStorageKey) {
+    try {
+      window.localStorage.removeItem(actualKeyStorageKey);
+      actualKeyStorageKey = null;
+      keyPairInitialized = false;
+      globalKeyPair = null;
+      globalHMACKey = null;
+      keyUsageCount = 0;
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("Failed to clear persisted keys");
       }
     }
-    this.status = "cancelled" /* CANCELLED */;
-    if (this.abortController) {
-      this.abortController.abort();
-    }
   }
-  /**
-   * 获取当前状态
-   */
-  getStatus() {
-    return this.status;
+}
+function getKeyUsageCount() {
+  return keyUsageCount;
+}
+function resetKeyUsageCount() {
+  keyUsageCount = 0;
+}
+async function ensureKeyPair() {
+  if (globalKeyPair) {
+    keyUsageCount++;
+    return;
   }
-  /**
-   * 获取任务ID
-   */
-  getTaskId() {
-    return this.taskId;
+  if (!initOptions.autoGenerateKeys) {
+    return;
   }
-  /**
-   * HTTP请求封装
-   */
-  async request(url, options = {}) {
-    const fullUrl = `${this.options.baseURL}${url}`;
-    const signal = this.abortController?.signal;
-    const response = await fetch(fullUrl, {
-      ...options,
-      signal
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP\u9519\u8BEF: ${response.status} ${response.statusText}`);
+  if (initializationPromise) {
+    await initializationPromise;
+    if (globalKeyPair) {
+      keyUsageCount++;
     }
-    return response.json();
+    return;
   }
-  /**
-   * 延迟函数
-   */
-  delay(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+  initializationPromise = initializeStorageKeys();
+  try {
+    await initializationPromise;
+  } finally {
+    initializationPromise = null;
+  }
+  if (globalKeyPair) {
+    keyUsageCount++;
   }
-};
-function createUploader(file, options) {
-  return new ChunkUploader(file, options);
 }
-async function uploadFile(file, options) {
-  const uploader = createUploader(file, options);
-  return uploader.upload();
+function safeParseJSON(jsonStr, expectedType) {
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (expectedType === "object" && (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))) {
+      throw new Error("Expected object but got different type");
+    }
+    if (expectedType === "array" && !Array.isArray(parsed)) {
+      throw new Error("Expected array but got different type");
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON format: ${error.message}`);
+    }
+    throw error;
+  }
 }
-
-// src/browser/storage.ts
-init_crypto();
-var globalKeyPair = null;
-function setStorageKeyPair(keyPair) {
-  globalKeyPair = keyPair;
+function validateTimestamp(timestamp, maxClockSkew = 5 * 60 * 1e3) {
+  if (!initOptions.enableTimestampValidation || !timestamp) {
+    return true;
+  }
+  if (initOptions.timestampMaxAge === 0) {
+    return true;
+  }
+  const now = Date.now();
+  const age = now - timestamp;
+  const maxAge = initOptions.timestampMaxAge || 7 * 24 * 60 * 60 * 1e3;
+  if (age < -maxClockSkew) {
+    return false;
+  }
+  return age >= -maxClockSkew && age <= maxAge;
 }
-function getStorageKeyPair() {
-  return globalKeyPair;
+async function encryptValue(value, publicKey, hmacKey) {
+  const encryptedData = await rsaEncrypt(value, publicKey);
+  if (hmacKey) {
+    const hmac = await computeHMAC(encryptedData, hmacKey);
+    const item = {
+      data: encryptedData,
+      hmac,
+      encrypted: true,
+      timestamp: Date.now()
+    };
+    return JSON.stringify(item);
+  }
+  return encryptedData;
+}
+async function handleDecryptError(error, encryptedStr, key) {
+  if (error instanceof Error && error.message.includes("HMAC verification failed")) {
+    if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+      console.error(
+        "\u26A0\uFE0F SECURITY ALERT: Data integrity check failed! Data may have been tampered with."
+      );
+    }
+    throw error;
+  }
+  if (error instanceof Error && error.message.includes("Data timestamp validation failed")) {
+    if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+      console.warn("\u26A0\uFE0F SECURITY WARNING: Data timestamp validation failed");
+    }
+    throw error;
+  }
+  try {
+    const decryptedStr = base64Decode(encryptedStr);
+    if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+      console.warn(
+        `\u26A0\uFE0F SECURITY WARNING: Reading unencrypted data for key "${key}". This may be a security risk if sensitive data was stored without encryption.`
+      );
+    }
+    return decryptedStr;
+  } catch {
+    throw error;
+  }
 }
-async function encryptValue(value, publicKey) {
-  return rsaEncrypt(value, publicKey);
+function handleNoKeyDecode(encryptedStr, key) {
+  try {
+    const decryptedStr = base64Decode(encryptedStr);
+    if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+      console.warn(
+        `\u26A0\uFE0F SECURITY WARNING: Reading unencrypted data for key "${key}" without encryption keys.`
+      );
+    }
+    return decryptedStr;
+  } catch (error) {
+    throw new Error(`Failed to decode storage value for key "${key}"`);
+  }
 }
-async function decryptValue(encryptedValue, privateKey) {
+async function decryptValue(encryptedValue, privateKey, hmacKey) {
   try {
+    const item = JSON.parse(encryptedValue);
+    if (item.encrypted && item.data && item.hmac) {
+      if (hmacKey) {
+        const isValid = await verifyHMAC(item.data, item.hmac, hmacKey);
+        if (!isValid) {
+          throw new Error("HMAC verification failed: data may have been tampered with");
+        }
+      }
+      if (item.timestamp && !validateTimestamp(item.timestamp)) {
+        throw new Error("Data timestamp validation failed: data may be expired or replayed");
+      }
+      return await rsaDecrypt(item.data, privateKey);
+    }
     return await rsaDecrypt(encryptedValue, privateKey);
-  } catch {
-    try {
-      JSON.parse(encryptedValue);
-      return encryptedValue;
-    } catch {
-      throw new Error("Failed to decrypt storage value");
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("HMAC verification failed")) {
+      throw error;
     }
+    throw new Error("Failed to decrypt storage value: invalid format or corrupted data");
   }
 }
 var localStorage = {
@@ -1746,17 +2115,24 @@ var localStorage = {
     };
     try {
       const jsonStr = JSON.stringify(item);
+      await ensureKeyPair();
       const keyToUse = publicKey || globalKeyPair?.publicKey;
       if (keyToUse) {
-        const encrypted = await encryptValue(jsonStr, keyToUse);
+        const encrypted = await encryptValue(jsonStr, keyToUse, globalHMACKey);
         window.localStorage.setItem(key, encrypted);
       } else {
-        const { base64Encode: base64Encode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
-        const encoded = base64Encode2(jsonStr);
+        if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+          console.warn(
+            `\u26A0\uFE0F SECURITY WARNING: Storing data without encryption for key "${key}". Data is only Base64 encoded, not encrypted!`
+          );
+        }
+        const encoded = base64Encode(jsonStr);
         window.localStorage.setItem(key, encoded);
       }
     } catch (error) {
-      console.error("localStorage.set error:", error);
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.set error:", error);
+      }
       throw error;
     }
   },
@@ -1774,34 +2150,36 @@ var localStorage = {
     try {
       const encryptedStr = window.localStorage.getItem(key);
       if (!encryptedStr) return defaultValue;
+      await ensureKeyPair();
       let decryptedStr;
       const keyToUse = privateKey || globalKeyPair?.privateKey;
       if (keyToUse) {
         try {
-          decryptedStr = await decryptValue(encryptedStr, keyToUse);
-        } catch {
-          const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+          decryptedStr = await decryptValue(encryptedStr, keyToUse, globalHMACKey);
+        } catch (error) {
           try {
-            decryptedStr = base64Decode2(encryptedStr);
+            decryptedStr = await handleDecryptError(error, encryptedStr, key);
           } catch {
             return defaultValue;
           }
         }
       } else {
-        const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
         try {
-          decryptedStr = base64Decode2(encryptedStr);
+          decryptedStr = handleNoKeyDecode(encryptedStr, key);
         } catch {
           return defaultValue;
         }
       }
-      const item = JSON.parse(decryptedStr);
+      const item = safeParseJSON(decryptedStr, "object");
       if (item.expiry && Date.now() > item.expiry) {
         window.localStorage.removeItem(key);
         return defaultValue;
       }
       return item.value;
-    } catch {
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+        console.warn(`Failed to parse storage item for key "${key}"`);
+      }
       return defaultValue;
     }
   },
@@ -1814,7 +2192,9 @@ var localStorage = {
     try {
       window.localStorage.removeItem(key);
     } catch (error) {
-      console.error("localStorage.remove error:", error);
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.remove error");
+      }
     }
   },
   /**
@@ -1825,7 +2205,9 @@ var localStorage = {
     try {
       window.localStorage.clear();
     } catch (error) {
-      console.error("localStorage.clear error:", error);
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.clear error");
+      }
     }
   },
   /**
@@ -1841,7 +2223,9 @@ var localStorage = {
         if (key) keys2.push(key);
       }
     } catch (error) {
-      console.error("localStorage.keys error:", error);
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.keys error");
+      }
     }
     return keys2;
   }
@@ -1861,17 +2245,24 @@ var sessionStorage = {
     const { publicKey } = options;
     try {
       const jsonStr = JSON.stringify(value);
+      await ensureKeyPair();
       const keyToUse = publicKey || globalKeyPair?.publicKey;
       if (keyToUse) {
-        const encrypted = await encryptValue(jsonStr, keyToUse);
+        const encrypted = await encryptValue(jsonStr, keyToUse, globalHMACKey);
         window.sessionStorage.setItem(key, encrypted);
       } else {
-        const { base64Encode: base64Encode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
-        const encoded = base64Encode2(jsonStr);
+        if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+          console.warn(
+            `\u26A0\uFE0F SECURITY WARNING: Storing data without encryption for key "${key}". Data is only Base64 encoded, not encrypted!`
+          );
+        }
+        const encoded = base64Encode(jsonStr);
         window.sessionStorage.setItem(key, encoded);
       }
     } catch (error) {
-      console.error("sessionStorage.set error:", error);
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("sessionStorage.set error:", error);
+      }
       throw error;
     }
   },
@@ -1889,28 +2280,27 @@ var sessionStorage = {
     try {
       const encryptedStr = window.sessionStorage.getItem(key);
       if (!encryptedStr) return defaultValue;
+      await ensureKeyPair();
       let decryptedStr;
       const keyToUse = privateKey || globalKeyPair?.privateKey;
       if (keyToUse) {
         try {
-          decryptedStr = await decryptValue(encryptedStr, keyToUse);
-        } catch {
-          const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
+          decryptedStr = await decryptValue(encryptedStr, keyToUse, globalHMACKey);
+        } catch (error) {
           try {
-            decryptedStr = base64Decode2(encryptedStr);
+            decryptedStr = await handleDecryptError(error, encryptedStr, key);
           } catch {
             return defaultValue;
           }
         }
       } else {
-        const { base64Decode: base64Decode2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
         try {
-          decryptedStr = base64Decode2(encryptedStr);
+          decryptedStr = handleNoKeyDecode(encryptedStr, key);
         } catch {
           return defaultValue;
         }
       }
-      return JSON.parse(decryptedStr);
+      return safeParseJSON(decryptedStr);
     } catch {
       return defaultValue;
     }
@@ -1924,7 +2314,9 @@ var sessionStorage = {
     try {
       window.sessionStorage.removeItem(key);
     } catch (error) {
-      console.error("sessionStorage.remove error:", error);
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("sessionStorage.remove error");
+      }
     }
   },
   /**
@@ -1935,7 +2327,9 @@ var sessionStorage = {
     try {
       window.sessionStorage.clear();
     } catch (error) {
-      console.error("sessionStorage.clear error:", error);
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("sessionStorage.clear error");
+      }
     }
   }
 };
@@ -1970,10 +2364,15 @@ var cookie = {
     if (typeof document === "undefined") return void 0;
     const name = encodeURIComponent(key);
     const cookies = document.cookie.split(";");
-    for (const cookie2 of cookies) {
-      const [cookieKey, cookieValue] = cookie2.trim().split("=");
+    for (const cookieStr of cookies) {
+      const trimmed = cookieStr.trim();
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) continue;
+      const cookieKey = trimmed.substring(0, eqIndex).trim();
+      const cookieValue = trimmed.substring(eqIndex + 1).trim();
       if (cookieKey === name) {
-        return decodeURIComponent(cookieValue);
+        const decoded = decodeURIComponent(cookieValue);
+        return decoded === "" ? void 0 : decoded;
       }
     }
     return void 0;
@@ -1997,15 +2396,24 @@ var cookie = {
     if (typeof document === "undefined") return {};
     const cookies = {};
     document.cookie.split(";").forEach((cookieStr) => {
-      const [key, value] = cookieStr.trim().split("=");
+      const trimmed = cookieStr.trim();
+      if (!trimmed) return;
+      const eqIndex = trimmed.indexOf("=");
+      if (eqIndex === -1) return;
+      const key = trimmed.substring(0, eqIndex).trim();
+      const value = trimmed.substring(eqIndex + 1).trim();
       if (key && value) {
-        cookies[decodeURIComponent(key)] = decodeURIComponent(value);
+        const decodedKey = decodeURIComponent(key);
+        const decodedValue = decodeURIComponent(value);
+        if (decodedValue !== "") {
+          cookies[decodedKey] = decodedValue;
+        }
       }
     });
     return cookies;
   }
 };
-var storage = {
+var secureStorage = {
   /**
    * 设置值（优先使用localStorage，失败则使用sessionStorage）
    * @param key - 键
@@ -2020,7 +2428,9 @@ var storage = {
       try {
         await sessionStorage.set(key, value, { publicKey: options.publicKey });
       } catch {
-        console.warn("Both localStorage and sessionStorage are not available");
+        if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+          console.warn("Both localStorage and sessionStorage are not available");
+        }
       }
     }
   },
@@ -2050,10 +2460,28 @@ var storage = {
   clear() {
     localStorage.clear();
     sessionStorage.clear();
+  },
+  /**
+   * 获取所有键名
+   * @returns 键名数组
+   */
+  keys() {
+    const localKeys = localStorage.keys();
+    const sessionKeys = [];
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      try {
+        for (let i = 0; i < window.sessionStorage.length; i++) {
+          const key = window.sessionStorage.key(i);
+          if (key) sessionKeys.push(key);
+        }
+      } catch (error) {
+      }
+    }
+    return Array.from(/* @__PURE__ */ new Set([...localKeys, ...sessionKeys]));
   }
 };
 
-// src/browser/network.ts
+// src/browser/network/index.ts
 async function fetchWithRetry(url, options = {}, retryCount = 3, retryDelay = 1e3) {
   let lastError = null;
   for (let i = 0; i <= retryCount; i++) {
@@ -2150,7 +2578,7 @@ async function request(url, options = {}) {
   return response.text();
 }
 
-// src/browser/dom.ts
+// src/browser/dom/index.ts
 function $(selector, context = document) {
   return context.querySelector(selector);
 }
@@ -2234,7 +2662,7 @@ async function copyToClipboard(text) {
   }
 }
 
-// src/data/transform.ts
+// src/data/transform/index.ts
 function csvToJson(csv, options = {}) {
   const { delimiter = ",", headers, skipEmptyLines = true } = options;
   const lines = csv.split(/\r?\n/).filter((line) => {
@@ -2533,7 +2961,7 @@ ${valStr}`;
   return String(value);
 }
 
-// src/data/data-structure.ts
+// src/data/data-structure/index.ts
 var Stack = class {
   constructor() {
     this.items = [];
@@ -3014,7 +3442,7 @@ var LRUCache = class {
   }
 };
 
-// src/data/algorithm.ts
+// src/data/algorithm/index.ts
 function binarySearch(array, target, compareFn) {
   let left = 0;
   let right = array.length - 1;
@@ -3144,7 +3572,7 @@ function lcm(a, b) {
   return Math.abs(a * b) / gcd(a, b);
 }
 
-// src/helper/performance.ts
+// src/helper/performance/index.ts
 function debounce(fn, delay) {
   let timeoutId = null;
   return function(...args) {
@@ -3289,10 +3717,7 @@ var Queue = class {
   }
 };
 
-// src/index.ts
-init_crypto();
-
-// src/helper/tracking.ts
+// src/helper/tracking/index.ts
 var Tracker = class {
   constructor(options) {
     this.eventQueue = [];
@@ -3941,6 +4366,8 @@ exports.addClass = addClass;
 exports.addDays = addDays;
 exports.addMonths = addMonths;
 exports.addYears = addYears;
+exports.aesGCMDecrypt = aesGCMDecrypt;
+exports.aesGCMEncrypt = aesGCMEncrypt;
 exports.base64Decode = base64Decode;
 exports.base64Encode = base64Encode;
 exports.batch = batch;
@@ -3955,7 +4382,9 @@ exports.ceil = ceil;
 exports.checkOnline = checkOnline;
 exports.chunk = chunk;
 exports.clamp = clamp;
+exports.clearPersistedKeys = clearPersistedKeys;
 exports.compact = compact;
+exports.computeHMAC = computeHMAC;
 exports.contrast = contrast;
 exports.cookie = cookie;
 exports.copyToClipboard = copyToClipboard;
@@ -3968,6 +4397,7 @@ exports.debounce = debounce;
 exports.deepClone = deepClone;
 exports.deepMerge = deepMerge;
 exports.defaults = defaults;
+exports.deriveKeyFromPassword = deriveKeyFromPassword;
 exports.diffDays = diffDays;
 exports.difference = difference;
 exports.downloadFile = downloadFile;
@@ -3996,6 +4426,7 @@ exports.formatNumber = formatNumber;
 exports.formatNumberI18n = formatNumberI18n;
 exports.formatRelativeTime = formatRelativeTime;
 exports.gcd = gcd;
+exports.generateHMACKey = generateHMACKey;
 exports.generateRSAKeyPair = generateRSAKeyPair;
 exports.generateRandomString = generateRandomString;
 exports.generateUUID = generateUUID;
@@ -4004,6 +4435,7 @@ exports.getDateFormatByGMT = getDateFormatByGMT;
 exports.getElementOffset = getElementOffset;
 exports.getFileExtension = getFileExtension;
 exports.getFileNameWithoutExtension = getFileNameWithoutExtension;
+exports.getKeyUsageCount = getKeyUsageCount;
 exports.getLocale = getLocale;
 exports.getQuarter = getQuarter;
 exports.getQueryParams = getQueryParams;
@@ -4022,6 +4454,7 @@ exports.hslToRgb = hslToRgb;
 exports.importPrivateKey = importPrivateKey;
 exports.importPublicKey = importPublicKey;
 exports.initTracker = initTracker;
+exports.initializeStorageKeys = initializeStorageKeys;
 exports.intersection = intersection;
 exports.invert = invert;
 exports.isAbsoluteUrl = isAbsoluteUrl;
@@ -4054,7 +4487,6 @@ exports.kebabCase = kebabCase;
 exports.keys = keys;
 exports.lcm = lcm;
 exports.lighten = lighten;
-exports.localStorage = localStorage;
 exports.mapKeys = mapKeys;
 exports.mapValues = mapValues;
 exports.mask = mask;
@@ -4082,6 +4514,7 @@ exports.removeAccents = removeAccents;
 exports.removeClass = removeClass;
 exports.removeQueryParams = removeQueryParams;
 exports.request = request;
+exports.resetKeyUsageCount = resetKeyUsageCount;
 exports.retry = retry;
 exports.rgbToHex = rgbToHex;
 exports.rgbToHsl = rgbToHsl;
@@ -4090,7 +4523,7 @@ exports.rsaDecrypt = rsaDecrypt;
 exports.rsaEncrypt = rsaEncrypt;
 exports.sample = sample;
 exports.scrollTo = scrollTo;
-exports.sessionStorage = sessionStorage;
+exports.secureStorage = secureStorage;
 exports.set = set;
 exports.setCommonParams = setCommonParams;
 exports.setQueryParams = setQueryParams;
@@ -4105,7 +4538,6 @@ exports.snakeCase = snakeCase;
 exports.sortBy = sortBy;
 exports.splitFileIntoChunks = splitFileIntoChunks;
 exports.startOfDay = startOfDay;
-exports.storage = storage;
 exports.take = take;
 exports.takeWhile = takeWhile;
 exports.template = template;
@@ -4127,6 +4559,7 @@ exports.unzip = unzip;
 exports.updateQueryParams = updateQueryParams;
 exports.uploadFile = uploadFile;
 exports.values = values;
+exports.verifyHMAC = verifyHMAC;
 exports.xmlToJson = xmlToJson;
 exports.yamlToJson = yamlToJson;
 exports.zip = zip;