@alibarbar/common 1.0.9 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,4543 @@
+'use strict';
+
+var Qs = require('qs');
+var axios = require('axios');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Qs__default = /*#__PURE__*/_interopDefault(Qs);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+// src/core/string/index.ts
+function capitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+function camelCase(str) {
+  if (!str) return str;
+  const words = str.replace(/[A-Z]/g, (letter) => ` ${letter.toLowerCase()}`).split(/[\s\-_]+/).filter((word) => word.length > 0);
+  if (words.length === 0) return "";
+  return words[0].toLowerCase() + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function truncate(str, length, suffix = "...") {
+  if (str.length <= length) return str;
+  return str.slice(0, length - suffix.length) + suffix;
+}
+function snakeCase(str) {
+  if (!str) return str;
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`).replace(/[\s-]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function pascalCase(str) {
+  if (!str) return str;
+  const camel = camelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function mask(str, options = {}) {
+  if (!str) return str;
+  const { start = 0, end = str.length, maskChar = "*" } = options;
+  const startIndex = Math.max(0, start);
+  const endIndex = Math.min(str.length, end);
+  if (startIndex >= endIndex) return str;
+  return str.slice(0, startIndex) + maskChar.repeat(endIndex - startIndex) + str.slice(endIndex);
+}
+function maskPhone(phone) {
+  if (!phone || phone.length < 7) return phone;
+  return mask(phone, { start: 3, end: phone.length - 4 });
+}
+function maskEmail(email) {
+  if (!email || !email.includes("@")) return email;
+  const [local, domain] = email.split("@");
+  if (local.length <= 2) return email;
+  return `${local.slice(0, 2)}***@${domain}`;
+}
+function slugify(str) {
+  if (!str) return "";
+  return str.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function removeAccents(str) {
+  if (!str) return str;
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function escapeHtml(str) {
+  if (!str) return str;
+  const map = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => map[char]);
+}
+function unescapeHtml(str) {
+  if (!str) return str;
+  const map = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&amp;|&lt;|&gt;|&quot;|&#39;/g, (char) => map[char]);
+}
+function template(template2, data) {
+  if (!template2) return template2;
+  return template2.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    const value = data[key];
+    return value !== void 0 && value !== null ? String(value) : match;
+  });
+}
+function highlight(text, keyword, tag = "mark") {
+  if (!text || !keyword) return text;
+  const regex = new RegExp(`(${escapeRegex(keyword)})`, "gi");
+  return text.replace(regex, `<${tag}>$1</${tag}>`);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/core/array/index.ts
+function unique(arr) {
+  return Array.from(new Set(arr));
+}
+function groupBy(arr, keyFn) {
+  const getKey = typeof keyFn === "string" ? (item) => item[keyFn] : keyFn;
+  return arr.reduce(
+    (acc, item) => {
+      const key = getKey(item);
+      if (!acc[key]) {
+        acc[key] = [];
+      }
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+}
+function chunk(arr, size) {
+  const chunks = [];
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size));
+  }
+  return chunks;
+}
+function flatten(arr, depth = 1) {
+  return depth > 0 ? arr.reduce(
+    (acc, val) => acc.concat(Array.isArray(val) ? flatten(val, depth - 1) : val),
+    []
+  ) : arr;
+}
+function shuffle(arr) {
+  const result = [...arr];
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+function sample(arr, count = 1) {
+  if (arr.length === 0) {
+    throw new Error("Cannot sample from empty array");
+  }
+  if (count === 1) {
+    const shuffled2 = shuffle(arr);
+    return shuffled2[0];
+  }
+  if (count >= arr.length) return [...arr];
+  const shuffled = shuffle(arr);
+  return shuffled.slice(0, count);
+}
+function difference(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => !set2.has(item));
+}
+function intersection(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return arr1.filter((item) => set2.has(item));
+}
+function union(arr1, arr2) {
+  return unique([...arr1, ...arr2]);
+}
+function sortBy(arr, keyFn, order = "asc") {
+  const getKey = typeof keyFn === "string" ? (item) => item[keyFn] : keyFn;
+  const result = [...arr];
+  result.sort((a, b) => {
+    const keyA = getKey(a);
+    const keyB = getKey(b);
+    if (keyA < keyB) return order === "asc" ? -1 : 1;
+    if (keyA > keyB) return order === "asc" ? 1 : -1;
+    return 0;
+  });
+  return result;
+}
+function findIndexBy(arr, predicate) {
+  return arr.findIndex(predicate);
+}
+function partition(arr, predicate) {
+  const truthy = [];
+  const falsy = [];
+  arr.forEach((item) => {
+    if (predicate(item)) {
+      truthy.push(item);
+    } else {
+      falsy.push(item);
+    }
+  });
+  return [truthy, falsy];
+}
+function zip(...arrays) {
+  const maxLength = Math.max(...arrays.map((arr) => arr.length));
+  const result = [];
+  for (let i = 0; i < maxLength; i++) {
+    result.push(
+      arrays.map((arr) => arr[i])
+    );
+  }
+  return result;
+}
+function unzip(array) {
+  if (array.length === 0) return [];
+  const length = array[0].length;
+  const result = Array.from({ length }, () => []);
+  array.forEach((item) => {
+    item.forEach((val, index) => {
+      result[index].push(val);
+    });
+  });
+  return result;
+}
+function compact(arr) {
+  return arr.filter((item) => Boolean(item));
+}
+function take(arr, n) {
+  return arr.slice(0, n);
+}
+function drop(arr, n) {
+  return arr.slice(n);
+}
+function takeWhile(arr, predicate) {
+  const result = [];
+  for (const item of arr) {
+    if (!predicate(item)) break;
+    result.push(item);
+  }
+  return result;
+}
+function dropWhile(arr, predicate) {
+  let index = 0;
+  while (index < arr.length && predicate(arr[index])) {
+    index++;
+  }
+  return arr.slice(index);
+}
+
+// src/core/object/index.ts
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  if (typeof obj === "object") {
+    const clonedObj = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        clonedObj[key] = deepClone(obj[key]);
+      }
+    }
+    return clonedObj;
+  }
+  return obj;
+}
+function merge(target, ...sources) {
+  return Object.assign({}, target, ...sources);
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (!source) {
+    return deepMerge(target, ...sources);
+  }
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (isObject(sourceValue) && isObject(targetValue)) {
+          target[key] = deepMerge(
+            targetValue,
+            sourceValue
+          );
+        } else if (sourceValue !== void 0) {
+          target[key] = sourceValue;
+        }
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+function isObject(item) {
+  return item !== null && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && !(item instanceof RegExp) && !(item instanceof Map) && !(item instanceof Set);
+}
+function get(obj, path, defaultValue) {
+  if (!obj || typeof obj !== "object") {
+    return defaultValue;
+  }
+  const keys2 = Array.isArray(path) ? path : path.split(".");
+  if (keys2.length === 0) {
+    return defaultValue;
+  }
+  let result = obj;
+  for (const key of keys2) {
+    if (result == null || typeof result !== "object" || Array.isArray(result)) {
+      return defaultValue;
+    }
+    const record = result;
+    if (!(key in record)) {
+      return defaultValue;
+    }
+    result = record[key];
+  }
+  return result !== void 0 ? result : defaultValue;
+}
+function set(obj, path, value) {
+  const keys2 = Array.isArray(path) ? path : path.split(".");
+  if (keys2.length === 0) return obj;
+  const result = deepClone(obj);
+  let current = result;
+  for (let i = 0; i < keys2.length - 1; i++) {
+    const key = keys2[i];
+    if (!(key in current) || typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys2[keys2.length - 1]] = value;
+  return result;
+}
+function pick(obj, keys2) {
+  const result = {};
+  keys2.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+function omit(obj, keys2) {
+  const result = { ...obj };
+  keys2.forEach((key) => {
+    delete result[key];
+  });
+  return result;
+}
+function keys(obj, deep = false) {
+  if (!deep) return Object.keys(obj);
+  const result = [];
+  const traverse = (current, prefix = "") => {
+    Object.keys(current).forEach((key) => {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      result.push(fullKey);
+      const value = current[key];
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp)) {
+        traverse(value, fullKey);
+      }
+    });
+  };
+  traverse(obj);
+  return result;
+}
+function values(obj, deep = false) {
+  if (!deep) return Object.values(obj);
+  const result = [];
+  const traverse = (current) => {
+    Object.values(current).forEach((value) => {
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp)) {
+        traverse(value);
+      } else {
+        result.push(value);
+      }
+    });
+  };
+  traverse(obj);
+  return result;
+}
+function mapKeys(obj, fn) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const newKey = fn(key, obj[key]);
+    result[newKey] = obj[key];
+  });
+  return result;
+}
+function mapValues(obj, fn) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    result[key] = fn(obj[key], key);
+  });
+  return result;
+}
+function invert(obj) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    result[String(obj[key])] = key;
+  });
+  return result;
+}
+function defaults(obj, ...defaults2) {
+  const result = { ...obj };
+  defaults2.reverse().forEach((defaultObj) => {
+    Object.keys(defaultObj).forEach((key) => {
+      const typedKey = key;
+      if (!(typedKey in result) || result[typedKey] === void 0) {
+        result[typedKey] = defaultObj[typedKey];
+      }
+    });
+  });
+  return result;
+}
+function isEmptyObject(obj) {
+  return Object.keys(obj).length === 0;
+}
+function isEqual(obj1, obj2) {
+  if (obj1 === obj2) return true;
+  if (obj1 === null || obj2 === null) return false;
+  if (typeof obj1 !== "object" || typeof obj2 !== "object") return false;
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
+  }
+  if (Array.isArray(obj1) && Array.isArray(obj2)) {
+    if (obj1.length !== obj2.length) return false;
+    return obj1.every((item, index) => isEqual(item, obj2[index]));
+  }
+  if (Array.isArray(obj1) || Array.isArray(obj2)) return false;
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  return keys1.every((key) => {
+    const val1 = obj1[key];
+    const val2 = obj2[key];
+    return isEqual(val1, val2);
+  });
+}
+function transform(obj, iteratee, accumulator = {}) {
+  Object.keys(obj).forEach((key) => {
+    iteratee(accumulator, obj[key], key);
+  });
+  return accumulator;
+}
+function pickBy(obj, predicate) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const typedKey = key;
+    if (predicate(obj[typedKey], key)) {
+      result[typedKey] = obj[typedKey];
+    }
+  });
+  return result;
+}
+function omitBy(obj, predicate) {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    const typedKey = key;
+    if (!predicate(obj[typedKey], key)) {
+      result[typedKey] = obj[typedKey];
+    }
+  });
+  return result;
+}
+
+// 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();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const hours = String(d.getHours()).padStart(2, "0");
+  const minutes = String(d.getMinutes()).padStart(2, "0");
+  const seconds = String(d.getSeconds()).padStart(2, "0");
+  return format.replace("YYYY", String(year)).replace("MM", month).replace("DD", day).replace("HH", hours).replace("mm", minutes).replace("ss", seconds);
+}
+function getRelativeTime(date) {
+  const now = /* @__PURE__ */ new Date();
+  const target = typeof date === "number" ? new Date(date) : date;
+  const diff = now.getTime() - target.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+  if (years > 0) return `${years}\u5E74\u524D`;
+  if (months > 0) return `${months}\u4E2A\u6708\u524D`;
+  if (days > 0) return `${days}\u5929\u524D`;
+  if (hours > 0) return `${hours}\u5C0F\u65F6\u524D`;
+  if (minutes > 0) return `${minutes}\u5206\u949F\u524D`;
+  if (seconds > 0) return `${seconds}\u79D2\u524D`;
+  return "\u521A\u521A";
+}
+function isToday(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const today = /* @__PURE__ */ new Date();
+  return d.getDate() === today.getDate() && d.getMonth() === today.getMonth() && d.getFullYear() === today.getFullYear();
+}
+function isYesterday(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  return d.getDate() === yesterday.getDate() && d.getMonth() === yesterday.getMonth() && d.getFullYear() === yesterday.getFullYear();
+}
+function getTimeFromGMT(gmt) {
+  const now = /* @__PURE__ */ new Date();
+  const localOffset = now.getTimezoneOffset();
+  const gmtOffsetMinutes = gmt * 60;
+  const targetTime = new Date(now.getTime() + localOffset * 6e4 + gmtOffsetMinutes * 6e4);
+  const format = getDateFormatByGMT(gmt);
+  return formatDate(targetTime, format);
+}
+function getDateFormatByGMT(gmt) {
+  switch (gmt) {
+    case 0:
+      return "YYYY-MM-DD HH:mm:ss";
+    case 1:
+    case 2:
+    case 3:
+      return "YYYY-MM-DD HH:mm:ss";
+    case 8:
+      return "YYYY-MM-DD HH:mm:ss";
+    case 9:
+      return "YYYY-MM-DD HH:mm:ss";
+    case -5:
+    case -6:
+    case -7:
+    case -8:
+      return "MM/DD/YYYY HH:mm:ss";
+    default:
+      return "YYYY-MM-DD HH:mm:ss";
+  }
+}
+function addDays(date, days) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setDate(d.getDate() + days);
+  return d;
+}
+function addMonths(date, months) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setMonth(d.getMonth() + months);
+  return d;
+}
+function addYears(date, years) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setFullYear(d.getFullYear() + years);
+  return d;
+}
+function diffDays(date1, date2) {
+  const d1 = typeof date1 === "number" ? new Date(date1) : date1;
+  const d2 = typeof date2 === "number" ? new Date(date2) : date2;
+  const diff = d1.getTime() - d2.getTime();
+  return Math.floor(diff / (1e3 * 60 * 60 * 24));
+}
+function startOfDay(date) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+}
+function endOfDay(date) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  d.setHours(23, 59, 59, 999);
+  return d;
+}
+function isWeekend(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  const day = d.getDay();
+  return day === 0 || day === 6;
+}
+function isWeekday(date) {
+  return !isWeekend(date);
+}
+function getWeekNumber(date) {
+  const d = typeof date === "number" ? new Date(date) : new Date(date);
+  const target = new Date(d.valueOf());
+  const dayNr = (d.getDay() + 6) % 7;
+  target.setDate(target.getDate() - dayNr + 3);
+  const firstThursday = target.valueOf();
+  target.setMonth(0, 1);
+  if (target.getDay() !== 4) {
+    target.setMonth(0, 1 + (4 - target.getDay() + 7) % 7);
+  }
+  return 1 + Math.ceil((firstThursday - target.valueOf()) / 6048e5);
+}
+function getQuarter(date) {
+  const d = typeof date === "number" ? new Date(date) : date;
+  return Math.floor(d.getMonth() / 3) + 1;
+}
+
+// src/core/validation/index.ts
+function isValidEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+function isValidPhone(phone) {
+  const phoneRegex = /^1[3-9]\d{9}$/;
+  return phoneRegex.test(phone);
+}
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidIdCard(idCard) {
+  const idCardRegex = /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\d{3}[\dXx]$/;
+  return idCardRegex.test(idCard);
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function isValidUUID(uuid) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(uuid);
+}
+function isValidIP(ip) {
+  const ipRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+  return ipRegex.test(ip);
+}
+function isValidDomain(domain) {
+  const domainRegex = /^([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}$/i;
+  return domainRegex.test(domain);
+}
+function isValidHexColor(color) {
+  const hexColorRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
+  return hexColorRegex.test(color);
+}
+function isValidJSON(json) {
+  try {
+    JSON.parse(json);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isNumeric(value) {
+  if (typeof value === "number") return !isNaN(value) && isFinite(value);
+  if (typeof value === "string") {
+    return value.trim() !== "" && !isNaN(Number(value)) && isFinite(Number(value));
+  }
+  return false;
+}
+function isInteger(value) {
+  if (typeof value === "number") return Number.isInteger(value);
+  if (typeof value === "string") {
+    const num = Number(value);
+    return !isNaN(num) && Number.isInteger(num);
+  }
+  return false;
+}
+function isFloat(value) {
+  if (typeof value === "number")
+    return !isNaN(value) && isFinite(value) && !Number.isInteger(value);
+  if (typeof value === "string") {
+    const num = Number(value);
+    return !isNaN(num) && isFinite(num) && !Number.isInteger(num);
+  }
+  return false;
+}
+
+// src/format/number/index.ts
+function formatNumber(num, options = {}) {
+  const { decimals, separator = ",", decimalPoint = ".", minimumFractionDigits } = options;
+  let numStr;
+  if (decimals !== void 0) {
+    numStr = num.toFixed(decimals);
+  } else if (minimumFractionDigits !== void 0) {
+    numStr = num.toFixed(minimumFractionDigits);
+  } else {
+    const str = num.toString();
+    if (str.includes(".")) {
+      numStr = str;
+    } else {
+      numStr = num.toFixed(0);
+    }
+  }
+  const parts = numStr.split(".");
+  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  return parts.join(decimalPoint);
+}
+function random(min, max, integer = false) {
+  const value = Math.random() * (max - min) + min;
+  return integer ? Math.floor(value) : value;
+}
+function clamp(num, min, max) {
+  return Math.min(Math.max(num, min), max);
+}
+function round(num, decimals = 0) {
+  const factor = Math.pow(10, decimals);
+  return Math.round(num * factor) / factor;
+}
+function floor(num, decimals = 0) {
+  const factor = Math.pow(10, decimals);
+  return Math.floor(num * factor) / factor;
+}
+function ceil(num, decimals = 0) {
+  const factor = Math.pow(10, decimals);
+  return Math.ceil(num * factor) / factor;
+}
+function toFixed(num, decimals) {
+  return num.toFixed(decimals);
+}
+function parseNumber(str, defaultValue = 0) {
+  const num = Number(str);
+  return isNaN(num) ? defaultValue : num;
+}
+function isBetween(num, min, max, inclusive = true) {
+  if (inclusive) {
+    return num >= min && num <= max;
+  }
+  return num > min && num < max;
+}
+function percent(value, decimalsOrTotal, decimals) {
+  if (value >= 0 && value <= 1 && (decimalsOrTotal === void 0 || decimalsOrTotal < 10)) {
+    const dec2 = decimalsOrTotal ?? 0;
+    return Number((value * 100).toFixed(dec2));
+  }
+  if (decimalsOrTotal !== void 0 && decimalsOrTotal >= 10) {
+    const total = decimalsOrTotal;
+    const dec2 = decimals ?? 2;
+    if (total === 0) return "0%";
+    return `${(value / total * 100).toFixed(dec2)}%`;
+  }
+  const dec = decimalsOrTotal ?? 0;
+  return Number((value * 100).toFixed(dec));
+}
+function formatCurrency(num, currency = "\xA5", decimals = 2) {
+  return `${currency}${formatNumber(num, { decimals, separator: "," })}`;
+}
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
+
+// src/format/url/index.ts
+function parseUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    return {
+      protocol: urlObj.protocol,
+      host: urlObj.host,
+      hostname: urlObj.hostname,
+      port: urlObj.port,
+      pathname: urlObj.pathname,
+      search: urlObj.search,
+      hash: urlObj.hash,
+      origin: urlObj.origin
+    };
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function buildUrl(parts) {
+  const { protocol = "https:", host = "", pathname = "/", search = "", hash: hash2 = "" } = parts;
+  return `${protocol}//${host}${pathname}${search}${hash2}`;
+}
+function getQueryParams(url) {
+  const searchParams = url ? new URL(url).searchParams : new URLSearchParams(window.location.search);
+  const params = {};
+  searchParams.forEach((value, key) => {
+    params[key] = value;
+  });
+  return params;
+}
+function setQueryParams(url, params) {
+  try {
+    const urlObj = new URL(url);
+    Object.keys(params).forEach((key) => {
+      urlObj.searchParams.set(key, String(params[key]));
+    });
+    return urlObj.toString();
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function removeQueryParams(url, keys2) {
+  try {
+    const urlObj = new URL(url);
+    keys2.forEach((key) => {
+      urlObj.searchParams.delete(key);
+    });
+    return urlObj.toString();
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function updateQueryParams(url, params) {
+  try {
+    const urlObj = new URL(url);
+    Object.keys(params).forEach((key) => {
+      const value = params[key];
+      if (value === null) {
+        urlObj.searchParams.delete(key);
+      } else {
+        urlObj.searchParams.set(key, String(value));
+      }
+    });
+    return urlObj.toString();
+  } catch {
+    throw new Error(`Invalid URL: ${url}`);
+  }
+}
+function isAbsoluteUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return /^https?:\/\//i.test(url);
+  }
+}
+function joinUrl(baseUrl, ...paths) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const joinedPaths = paths.map((path) => path.replace(/^\/+|\/+$/g, "")).filter((path) => path.length > 0).join("/");
+  return `${base}/${joinedPaths}`;
+}
+function normalizeUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    urlObj.pathname = urlObj.pathname.replace(/\/+/g, "/");
+    return urlObj.toString();
+  } catch {
+    return url;
+  }
+}
+
+// src/format/color/index.ts
+function hexToRgb(hex) {
+  const cleanHex = hex.replace("#", "");
+  if (!/^[0-9A-Fa-f]{6}$/.test(cleanHex)) {
+    throw new Error("Invalid hex color format");
+  }
+  return {
+    r: parseInt(cleanHex.substring(0, 2), 16),
+    g: parseInt(cleanHex.substring(2, 4), 16),
+    b: parseInt(cleanHex.substring(4, 6), 16)
+  };
+}
+function rgbToHex(rgb) {
+  let r;
+  let g;
+  let b;
+  if (typeof rgb === "string") {
+    const match = rgb.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+    if (!match) {
+      throw new Error("Invalid RGB string format");
+    }
+    r = parseInt(match[1], 10);
+    g = parseInt(match[2], 10);
+    b = parseInt(match[3], 10);
+  } else {
+    r = rgb.r;
+    g = rgb.g;
+    b = rgb.b;
+  }
+  r = Math.max(0, Math.min(255, Math.round(r)));
+  g = Math.max(0, Math.min(255, Math.round(g)));
+  b = Math.max(0, Math.min(255, Math.round(b)));
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`.toUpperCase();
+}
+function rgbToHsl(rgb) {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+    if (max === r) {
+      h = ((g - b) / delta + (g < b ? 6 : 0)) / 6;
+    } else if (max === g) {
+      h = ((b - r) / delta + 2) / 6;
+    } else {
+      h = ((r - g) / delta + 4) / 6;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToRgb(hsl) {
+  const h = hsl.h / 360;
+  const s = hsl.s / 100;
+  const l = hsl.l / 100;
+  let r;
+  let g;
+  let b;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(b * 255)
+  };
+}
+function lighten(color, amount) {
+  const rgb = typeof color === "string" ? hexToRgb(color) : color;
+  const hsl = rgbToHsl(rgb);
+  hsl.l = Math.min(100, hsl.l + amount);
+  return rgbToHex(hslToRgb(hsl));
+}
+function darken(color, amount) {
+  const rgb = typeof color === "string" ? hexToRgb(color) : color;
+  const hsl = rgbToHsl(rgb);
+  hsl.l = Math.max(0, hsl.l - amount);
+  return rgbToHex(hslToRgb(hsl));
+}
+function mix(color1, color2, ratio) {
+  const rgb1 = hexToRgb(color1);
+  const rgb2 = hexToRgb(color2);
+  const r = Math.round(rgb1.r * (1 - ratio) + rgb2.r * ratio);
+  const g = Math.round(rgb1.g * (1 - ratio) + rgb2.g * ratio);
+  const b = Math.round(rgb1.b * (1 - ratio) + rgb2.b * ratio);
+  return rgbToHex({ r, g, b });
+}
+function contrast(color1, color2) {
+  const rgb1 = hexToRgb(color1);
+  const rgb2 = hexToRgb(color2);
+  const getLuminance = (rgb) => {
+    const normalize = (value) => {
+      value = value / 255;
+      return value <= 0.03928 ? value / 12.92 : Math.pow((value + 0.055) / 1.055, 2.4);
+    };
+    return 0.2126 * normalize(rgb.r) + 0.7152 * normalize(rgb.g) + 0.0722 * normalize(rgb.b);
+  };
+  const lum1 = getLuminance(rgb1);
+  const lum2 = getLuminance(rgb2);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+// src/format/i18n/index.ts
+function getLocale() {
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  return "en-US";
+}
+function formatNumberI18n(value, locale, options) {
+  const loc = locale || getLocale();
+  return new Intl.NumberFormat(loc, options).format(value);
+}
+function formatDateI18n(date, locale, options) {
+  const loc = locale || getLocale();
+  const dateObj = typeof date === "number" ? new Date(date) : date;
+  return new Intl.DateTimeFormat(loc, options).format(dateObj);
+}
+function formatCurrencyI18n(value, currency, locale, options) {
+  const loc = locale || getLocale();
+  return new Intl.NumberFormat(loc, {
+    style: "currency",
+    currency,
+    ...options
+  }).format(value);
+}
+function translate(key, dictionary, defaultValue) {
+  const keys2 = key.split(".");
+  let current = dictionary;
+  for (const k of keys2) {
+    if (typeof current === "object" && current !== null && k in current) {
+      current = current[k];
+    } else {
+      return defaultValue || key;
+    }
+  }
+  if (typeof current === "string") {
+    return current;
+  }
+  return defaultValue || key;
+}
+function createTranslator(dictionary) {
+  return (key, defaultValue) => {
+    return translate(key, dictionary, defaultValue);
+  };
+}
+function formatRelativeTime(date, locale) {
+  const loc = locale || getLocale();
+  const dateObj = typeof date === "number" ? new Date(date) : date;
+  const now = /* @__PURE__ */ new Date();
+  const diffInSeconds = Math.floor((now.getTime() - dateObj.getTime()) / 1e3);
+  const rtf = new Intl.RelativeTimeFormat(loc, { numeric: "auto" });
+  const intervals = [
+    { unit: "year", seconds: 31536e3 },
+    { unit: "month", seconds: 2592e3 },
+    { unit: "week", seconds: 604800 },
+    { unit: "day", seconds: 86400 },
+    { unit: "hour", seconds: 3600 },
+    { unit: "minute", seconds: 60 },
+    { unit: "second", seconds: 1 }
+  ];
+  for (const interval of intervals) {
+    const count = Math.floor(Math.abs(diffInSeconds) / interval.seconds);
+    if (count >= 1) {
+      return rtf.format(diffInSeconds < 0 ? count : -count, interval.unit);
+    }
+  }
+  return rtf.format(0, "second");
+}
+function pluralize(count, singular, plural, locale) {
+  const loc = locale || getLocale();
+  const pluralForm = plural || `${singular}s`;
+  const pluralRules = new Intl.PluralRules(loc);
+  const rule = pluralRules.select(count);
+  if (rule === "one" || count === 1) {
+    return `${count} ${singular}`;
+  }
+  return `${count} ${pluralForm}`;
+}
+
+// src/browser/file/index.ts
+async function calculateFileMD5(file) {
+  return new Promise((resolve, reject) => {
+    if (typeof FileReader === "undefined") {
+      reject(new Error("FileReader is not supported in this environment"));
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = async (e) => {
+      try {
+        const arrayBuffer = e.target?.result;
+        if (!arrayBuffer) {
+          reject(new Error("Failed to read file"));
+          return;
+        }
+        const hashBuffer = await crypto.subtle.digest("SHA-256", arrayBuffer);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        resolve(hashHex);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(file);
+  });
+}
+async function calculateBlobMD5(blob) {
+  return new Promise((resolve, reject) => {
+    if (typeof FileReader === "undefined") {
+      reject(new Error("FileReader is not supported in this environment"));
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = async (e) => {
+      try {
+        const arrayBuffer = e.target?.result;
+        if (!arrayBuffer) {
+          reject(new Error("Failed to read blob"));
+          return;
+        }
+        const hashBuffer = await crypto.subtle.digest("SHA-256", arrayBuffer);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        resolve(hashHex);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function splitFileIntoChunks(file, chunkSize) {
+  const chunks = [];
+  let start = 0;
+  while (start < file.size) {
+    const end = Math.min(start + chunkSize, file.size);
+    chunks.push(file.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function getFileExtension(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  return lastDot > 0 ? fileName.slice(lastDot + 1) : "";
+}
+function getFileNameWithoutExtension(fileName) {
+  const lastDot = fileName.lastIndexOf(".");
+  return lastDot > 0 ? fileName.slice(0, lastDot) : fileName;
+}
+
+// src/types/upload.ts
+var UploadStatus = /* @__PURE__ */ ((UploadStatus2) => {
+  UploadStatus2["PENDING"] = "pending";
+  UploadStatus2["UPLOADING"] = "uploading";
+  UploadStatus2["PAUSED"] = "paused";
+  UploadStatus2["COMPLETED"] = "completed";
+  UploadStatus2["FAILED"] = "failed";
+  UploadStatus2["CANCELLED"] = "cancelled";
+  return UploadStatus2;
+})(UploadStatus || {});
+
+// src/browser/upload/index.ts
+var ChunkUploader = class {
+  constructor(file, options = {}) {
+    this.taskId = null;
+    this.chunks = [];
+    this.uploadedChunks = /* @__PURE__ */ new Set();
+    this.status = "pending" /* PENDING */;
+    this.abortController = null;
+    this.file = file;
+    this.options = {
+      chunkSize: options.chunkSize || 2 * 1024 * 1024,
+      // 默认2MB
+      concurrency: options.concurrency || 3,
+      retryCount: options.retryCount || 3,
+      retryDelay: options.retryDelay || 1e3,
+      baseURL: options.baseURL || "",
+      headers: options.headers || {},
+      onProgress: options.onProgress || (() => {
+      }),
+      onComplete: options.onComplete || (() => {
+      }),
+      onError: options.onError || (() => {
+      })
+    };
+  }
+  /**
+   * 初始化上传
+   */
+  async initUpload() {
+    const fileMd5 = await this.calculateFileMD5();
+    const request2 = {
+      fileName: this.file.name,
+      fileSize: this.file.size,
+      fileMd5,
+      chunkSize: this.options.chunkSize
+    };
+    const response = await this.request("/api/files/common/init", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.options.headers
+      },
+      body: JSON.stringify(request2)
+    });
+    if (response.code !== 200) {
+      throw new Error(response.message || "\u521D\u59CB\u5316\u4E0A\u4F20\u5931\u8D25");
+    }
+    return response.data;
+  }
+  /**
+   * 计算文件MD5
+   */
+  async calculateFileMD5() {
+    const chunks = splitFileIntoChunks(this.file, this.options.chunkSize);
+    const md5Promises = chunks.map(
+      (chunk2, index) => calculateBlobMD5(chunk2).then((md5) => ({ index, md5 }))
+    );
+    const md5Results = await Promise.all(md5Promises);
+    return md5Results.map((r) => r.md5).join("");
+  }
+  /**
+   * 准备分片
+   */
+  prepareChunks() {
+    const blobChunks = splitFileIntoChunks(this.file, this.options.chunkSize);
+    this.chunks = blobChunks.map((blob, index) => ({
+      index,
+      start: index * this.options.chunkSize,
+      end: Math.min((index + 1) * this.options.chunkSize, this.file.size),
+      blob
+    }));
+  }
+  /**
+   * 获取已上传的分片列表（用于断点续传）
+   */
+  async getUploadedChunks() {
+    if (!this.taskId) return [];
+    try {
+      const response = await this.request(
+        `/api/files/common/chunks/${this.taskId}`,
+        {
+          method: "GET",
+          headers: this.options.headers
+        }
+      );
+      if (response.code === 200) {
+        return response.data || [];
+      }
+    } catch (error) {
+      console.warn("\u83B7\u53D6\u5DF2\u4E0A\u4F20\u5206\u7247\u5931\u8D25:", error);
+    }
+    return [];
+  }
+  /**
+   * 上传单个分片
+   */
+  async uploadChunk(chunkInfo, retryCount = 0) {
+    if (!this.taskId) {
+      throw new Error("\u4EFB\u52A1ID\u4E0D\u5B58\u5728");
+    }
+    if (this.uploadedChunks.has(chunkInfo.index)) {
+      return;
+    }
+    try {
+      const chunkMd5 = await calculateBlobMD5(chunkInfo.blob);
+      const formData = new FormData();
+      formData.append("file", chunkInfo.blob, this.file.name);
+      const url = `/api/files/common/chunk?taskId=${this.taskId}&chunkIndex=${chunkInfo.index}&chunkMd5=${chunkMd5}`;
+      const response = await this.request(url, {
+        method: "POST",
+        headers: this.options.headers,
+        body: formData
+      });
+      if (response.code === 200 && response.data.success) {
+        this.uploadedChunks.add(chunkInfo.index);
+        await this.updateProgress();
+      } else {
+        throw new Error(response.message || "\u5206\u7247\u4E0A\u4F20\u5931\u8D25");
+      }
+    } catch (error) {
+      if (retryCount < this.options.retryCount) {
+        await this.delay(this.options.retryDelay);
+        return this.uploadChunk(chunkInfo, retryCount + 1);
+      }
+      throw error;
+    }
+  }
+  /**
+   * 并发上传分片
+   */
+  async uploadChunksConcurrently() {
+    const chunksToUpload = this.chunks.filter((chunk2) => !this.uploadedChunks.has(chunk2.index));
+    if (chunksToUpload.length === 0) {
+      return;
+    }
+    let currentIndex = 0;
+    const uploadNext = async () => {
+      while (this.status === "uploading" /* UPLOADING */) {
+        const chunkIndex = currentIndex++;
+        if (chunkIndex >= chunksToUpload.length) {
+          break;
+        }
+        const chunk2 = chunksToUpload[chunkIndex];
+        await this.uploadChunk(chunk2);
+      }
+    };
+    const tasks = Array(this.options.concurrency).fill(null).map(() => uploadNext());
+    await Promise.all(tasks);
+  }
+  /**
+   * 更新上传进度（仅用于回调前端显示）
+   */
+  async updateProgress() {
+    if (!this.taskId) return;
+    try {
+      const response = await this.request(
+        `/api/files/common/progress/${this.taskId}`,
+        {
+          method: "GET",
+          headers: this.options.headers
+        }
+      );
+      if (response.code === 200 && response.data) {
+        this.options.onProgress(response.data);
+      }
+    } catch (error) {
+      console.warn("\u83B7\u53D6\u4E0A\u4F20\u8FDB\u5EA6\u5931\u8D25:", error);
+    }
+  }
+  /**
+   * 获取上传进度
+   */
+  async getUploadProgress() {
+    if (!this.taskId) {
+      return null;
+    }
+    try {
+      const response = await this.request(
+        `/api/files/common/progress/${this.taskId}`,
+        {
+          method: "GET",
+          headers: this.options.headers
+        }
+      );
+      if (response.code === 200 && response.data) {
+        console.log("[\u83B7\u53D6\u8FDB\u5EA6]", response.data);
+        return response.data;
+      }
+    } catch (error) {
+      console.warn("\u83B7\u53D6\u4E0A\u4F20\u8FDB\u5EA6\u5931\u8D25:", error);
+    }
+    return null;
+  }
+  /**
+   * 完成上传（调用后端合并分片接口）
+   */
+  async completeUpload() {
+    if (!this.taskId) {
+      throw new Error("\u4EFB\u52A1ID\u4E0D\u5B58\u5728");
+    }
+    console.log("[\u5B8C\u6210\u4E0A\u4F20] \u8C03\u7528\u5B8C\u6210\u63A5\u53E3:", `/api/files/common/complete/${this.taskId}`);
+    const response = await this.request(
+      `/api/files/common/complete/${this.taskId}`,
+      {
+        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");
+    }
+    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");
+      }
+    }
+  }
+  if (initOptions.autoGenerateKeys && !globalKeyPair) {
+    try {
+      globalKeyPair = await generateRSAKeyPair(initOptions.keyModulusLength);
+      if (initOptions.enableHMAC && !globalHMACKey) {
+        globalHMACKey = await generateHMACKey();
+      }
+      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) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("Failed to generate storage keys");
+      }
+      throw error;
+    }
+  }
+  if (initOptions.enableHMAC && !globalHMACKey) {
+    globalHMACKey = await generateHMACKey();
+  }
+}
+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");
+      }
+    }
+  }
+}
+function getKeyUsageCount() {
+  return keyUsageCount;
+}
+function resetKeyUsageCount() {
+  keyUsageCount = 0;
+}
+async function ensureKeyPair() {
+  if (globalKeyPair) {
+    keyUsageCount++;
+    return;
+  }
+  if (!initOptions.autoGenerateKeys) {
+    return;
+  }
+  if (initializationPromise) {
+    await initializationPromise;
+    if (globalKeyPair) {
+      keyUsageCount++;
+    }
+    return;
+  }
+  initializationPromise = initializeStorageKeys();
+  try {
+    await initializationPromise;
+  } finally {
+    initializationPromise = null;
+  }
+  if (globalKeyPair) {
+    keyUsageCount++;
+  }
+}
+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;
+  }
+}
+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;
+}
+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;
+  }
+}
+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, 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 (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 = {
+  /**
+   * 设置值
+   * @param key - 键
+   * @param value - 值
+   * @param options - 选项（过期时间、密钥等）
+   * @returns Promise<void>
+   */
+  async set(key, value, options = {}) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      throw new Error("localStorage is not available");
+    }
+    const { expiry, publicKey } = options;
+    const item = {
+      value,
+      expiry: expiry ? Date.now() + expiry : void 0
+    };
+    try {
+      const jsonStr = JSON.stringify(item);
+      await ensureKeyPair();
+      const keyToUse = publicKey || globalKeyPair?.publicKey;
+      if (keyToUse) {
+        const encrypted = await encryptValue(jsonStr, keyToUse, globalHMACKey);
+        window.localStorage.setItem(key, encrypted);
+      } else {
+        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) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.set error:", error);
+      }
+      throw error;
+    }
+  },
+  /**
+   * 获取值
+   * @param key - 键
+   * @param options - 选项（默认值、私钥等）
+   * @returns Promise<T | undefined> 值或默认值
+   */
+  async get(key, options = {}) {
+    if (typeof window === "undefined" || !window.localStorage) {
+      return options.defaultValue;
+    }
+    const { defaultValue, privateKey } = options;
+    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, globalHMACKey);
+        } catch (error) {
+          try {
+            decryptedStr = await handleDecryptError(error, encryptedStr, key);
+          } catch {
+            return defaultValue;
+          }
+        }
+      } else {
+        try {
+          decryptedStr = handleNoKeyDecode(encryptedStr, key);
+        } catch {
+          return defaultValue;
+        }
+      }
+      const item = safeParseJSON(decryptedStr, "object");
+      if (item.expiry && Date.now() > item.expiry) {
+        window.localStorage.removeItem(key);
+        return defaultValue;
+      }
+      return item.value;
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+        console.warn(`Failed to parse storage item for key "${key}"`);
+      }
+      return defaultValue;
+    }
+  },
+  /**
+   * 移除值
+   * @param key - 键
+   */
+  remove(key) {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    try {
+      window.localStorage.removeItem(key);
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.remove error");
+      }
+    }
+  },
+  /**
+   * 清空所有值
+   */
+  clear() {
+    if (typeof window === "undefined" || !window.localStorage) return;
+    try {
+      window.localStorage.clear();
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.clear error");
+      }
+    }
+  },
+  /**
+   * 获取所有键
+   * @returns 键数组
+   */
+  keys() {
+    if (typeof window === "undefined" || !window.localStorage) return [];
+    const keys2 = [];
+    try {
+      for (let i = 0; i < window.localStorage.length; i++) {
+        const key = window.localStorage.key(i);
+        if (key) keys2.push(key);
+      }
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("localStorage.keys error");
+      }
+    }
+    return keys2;
+  }
+};
+var sessionStorage = {
+  /**
+   * 设置值
+   * @param key - 键
+   * @param value - 值
+   * @param options - 选项（公钥等）
+   * @returns Promise<void>
+   */
+  async set(key, value, options = {}) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+      throw new Error("sessionStorage is not available");
+    }
+    const { publicKey } = options;
+    try {
+      const jsonStr = JSON.stringify(value);
+      await ensureKeyPair();
+      const keyToUse = publicKey || globalKeyPair?.publicKey;
+      if (keyToUse) {
+        const encrypted = await encryptValue(jsonStr, keyToUse, globalHMACKey);
+        window.sessionStorage.setItem(key, encrypted);
+      } else {
+        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) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("sessionStorage.set error:", error);
+      }
+      throw error;
+    }
+  },
+  /**
+   * 获取值
+   * @param key - 键
+   * @param options - 选项（默认值、私钥等）
+   * @returns Promise<T | undefined> 值或默认值
+   */
+  async get(key, options = {}) {
+    if (typeof window === "undefined" || !window.sessionStorage) {
+      return options.defaultValue;
+    }
+    const { defaultValue, privateKey } = options;
+    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, globalHMACKey);
+        } catch (error) {
+          try {
+            decryptedStr = await handleDecryptError(error, encryptedStr, key);
+          } catch {
+            return defaultValue;
+          }
+        }
+      } else {
+        try {
+          decryptedStr = handleNoKeyDecode(encryptedStr, key);
+        } catch {
+          return defaultValue;
+        }
+      }
+      return safeParseJSON(decryptedStr);
+    } catch {
+      return defaultValue;
+    }
+  },
+  /**
+   * 移除值
+   * @param key - 键
+   */
+  remove(key) {
+    if (typeof window === "undefined" || !window.sessionStorage) return;
+    try {
+      window.sessionStorage.removeItem(key);
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("sessionStorage.remove error");
+      }
+    }
+  },
+  /**
+   * 清空所有值
+   */
+  clear() {
+    if (typeof window === "undefined" || !window.sessionStorage) return;
+    try {
+      window.sessionStorage.clear();
+    } catch (error) {
+      if (!initOptions.isProduction && typeof console !== "undefined" && console.error) {
+        console.error("sessionStorage.clear error");
+      }
+    }
+  }
+};
+var cookie = {
+  /**
+   * 设置Cookie
+   * @param key - 键
+   * @param value - 值
+   * @param options - Cookie选项
+   */
+  set(key, value, options = {}) {
+    if (typeof document === "undefined") {
+      throw new Error("document is not available");
+    }
+    let cookieStr = `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+    if (options.expires) {
+      const expiresDate = options.expires instanceof Date ? options.expires : new Date(Date.now() + options.expires * 24 * 60 * 60 * 1e3);
+      cookieStr += `; expires=${expiresDate.toUTCString()}`;
+    }
+    if (options.path) cookieStr += `; path=${options.path}`;
+    if (options.domain) cookieStr += `; domain=${options.domain}`;
+    if (options.secure) cookieStr += "; secure";
+    if (options.sameSite) cookieStr += `; sameSite=${options.sameSite}`;
+    document.cookie = cookieStr;
+  },
+  /**
+   * 获取Cookie
+   * @param key - 键
+   * @returns Cookie值
+   */
+  get(key) {
+    if (typeof document === "undefined") return void 0;
+    const name = encodeURIComponent(key);
+    const cookies = document.cookie.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);
+      }
+    }
+    return void 0;
+  },
+  /**
+   * 移除Cookie
+   * @param key - 键
+   * @param options - Cookie选项
+   */
+  remove(key, options = {}) {
+    cookie.set(key, "", {
+      ...options,
+      expires: /* @__PURE__ */ new Date(0)
+    });
+  },
+  /**
+   * 获取所有Cookie
+   * @returns Cookie对象
+   */
+  getAll() {
+    if (typeof document === "undefined") return {};
+    const cookies = {};
+    document.cookie.split(";").forEach((cookieStr) => {
+      const trimmed = cookieStr.trim();
+      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);
+      }
+    });
+    return cookies;
+  }
+};
+var storage = {
+  /**
+   * 设置值（优先使用localStorage，失败则使用sessionStorage）
+   * @param key - 键
+   * @param value - 值
+   * @param options - 选项（过期时间、公钥等）
+   * @returns Promise<void>
+   */
+  async set(key, value, options = {}) {
+    try {
+      await localStorage.set(key, value, options);
+    } catch {
+      try {
+        await sessionStorage.set(key, value, { publicKey: options.publicKey });
+      } catch {
+        if (!initOptions.isProduction && typeof console !== "undefined" && console.warn) {
+          console.warn("Both localStorage and sessionStorage are not available");
+        }
+      }
+    }
+  },
+  /**
+   * 获取值
+   * @param key - 键
+   * @param options - 选项（默认值、私钥等）
+   * @returns Promise<T | undefined> 值或默认值
+   */
+  async get(key, options = {}) {
+    const localValue = await localStorage.get(key, options);
+    if (localValue !== void 0) return localValue;
+    const sessionValue = await sessionStorage.get(key, options);
+    return sessionValue !== void 0 ? sessionValue : options.defaultValue;
+  },
+  /**
+   * 移除值
+   * @param key - 键
+   */
+  remove(key) {
+    localStorage.remove(key);
+    sessionStorage.remove(key);
+  },
+  /**
+   * 清空所有值
+   */
+  clear() {
+    localStorage.clear();
+    sessionStorage.clear();
+  }
+};
+
+// src/browser/network/index.ts
+async function fetchWithRetry(url, options = {}, retryCount = 3, retryDelay = 1e3) {
+  let lastError = null;
+  for (let i = 0; i <= retryCount; i++) {
+    try {
+      const response = await fetch(url, options);
+      if (response.ok) {
+        return response;
+      }
+      if (i < retryCount) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        continue;
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i < retryCount) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      }
+    }
+  }
+  throw lastError || new Error("Fetch failed after retries");
+}
+async function fetchWithTimeout(url, options = {}, timeout2 = 5e3) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout2);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(`Request timeout after ${timeout2}ms`);
+    }
+    throw error;
+  }
+}
+async function downloadFile(url, filename) {
+  if (typeof window === "undefined") {
+    throw new Error("downloadFile is only available in browser environment");
+  }
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to download file: ${response.statusText}`);
+    }
+    const blob = await response.blob();
+    const downloadUrl = window.URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = downloadUrl;
+    link.download = filename || url.split("/").pop() || "download";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    window.URL.revokeObjectURL(downloadUrl);
+  } catch (error) {
+    throw error instanceof Error ? error : new Error(String(error));
+  }
+}
+function checkOnline() {
+  if (typeof navigator === "undefined") return true;
+  return navigator.onLine;
+}
+async function request(url, options = {}) {
+  const { method = "GET", headers = {}, body, timeout: timeout2, retry: retry2 = 0 } = options;
+  const fetchOptions = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    }
+  };
+  if (body) {
+    fetchOptions.body = typeof body === "string" ? body : JSON.stringify(body);
+  }
+  let fetchFn = fetch;
+  if (timeout2) {
+    fetchFn = (url2, opts) => fetchWithTimeout(url2, opts, timeout2);
+  }
+  if (retry2 > 0) {
+    fetchFn = (url2, opts) => fetchWithRetry(url2, opts, retry2);
+  }
+  const response = await fetchFn(url, fetchOptions);
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  const contentType = response.headers.get("content-type");
+  if (contentType && contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+
+// src/browser/dom/index.ts
+function $(selector, context = document) {
+  return context.querySelector(selector);
+}
+function $$(selector, context = document) {
+  return Array.from(context.querySelectorAll(selector));
+}
+function addClass(element, className) {
+  element.classList.add(className);
+}
+function removeClass(element, className) {
+  element.classList.remove(className);
+}
+function toggleClass(element, className) {
+  return element.classList.toggle(className);
+}
+function getStyle(element, property) {
+  return window.getComputedStyle(element).getPropertyValue(property);
+}
+function setStyle(element, property, value) {
+  if (typeof property === "string" && value !== void 0) {
+    element.style.setProperty(property, value);
+  } else if (typeof property === "object") {
+    Object.keys(property).forEach((key) => {
+      element.style.setProperty(key, property[key]);
+    });
+  }
+}
+function scrollTo(target, options = {}) {
+  if (typeof window === "undefined") return;
+  const { behavior = "smooth", block = "start", inline = "nearest" } = options;
+  if (typeof target === "number") {
+    window.scrollTo({ top: target, behavior });
+    return;
+  }
+  const element = typeof target === "string" ? $(target) : target;
+  if (element) {
+    element.scrollIntoView({ behavior, block, inline });
+  }
+}
+function getScrollPosition() {
+  if (typeof window === "undefined") return { x: 0, y: 0 };
+  return {
+    x: window.pageXOffset || document.documentElement.scrollLeft || 0,
+    y: window.pageYOffset || document.documentElement.scrollTop || 0
+  };
+}
+function isInViewport(element, threshold = 0) {
+  if (typeof window === "undefined") return false;
+  const rect = element.getBoundingClientRect();
+  const windowHeight = window.innerHeight || document.documentElement.clientHeight;
+  const windowWidth = window.innerWidth || document.documentElement.clientWidth;
+  return rect.top >= -threshold * rect.height && rect.left >= -threshold * rect.width && rect.bottom <= windowHeight + threshold * rect.height && rect.right <= windowWidth + threshold * rect.width;
+}
+function getElementOffset(element) {
+  const rect = element.getBoundingClientRect();
+  return {
+    top: rect.top + (window.pageYOffset || document.documentElement.scrollTop),
+    left: rect.left + (window.pageXOffset || document.documentElement.scrollLeft)
+  };
+}
+async function copyToClipboard(text) {
+  if (typeof navigator === "undefined" || !navigator.clipboard) {
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.style.position = "fixed";
+    textArea.style.opacity = "0";
+    document.body.appendChild(textArea);
+    textArea.select();
+    try {
+      document.execCommand("copy");
+    } catch (error) {
+      throw new Error("Failed to copy text");
+    }
+    document.body.removeChild(textArea);
+    return;
+  }
+  try {
+    await navigator.clipboard.writeText(text);
+  } catch (error) {
+    throw new Error("Failed to copy text");
+  }
+}
+
+// src/data/transform/index.ts
+function csvToJson(csv, options = {}) {
+  const { delimiter = ",", headers, skipEmptyLines = true } = options;
+  const lines = csv.split(/\r?\n/).filter((line) => {
+    if (skipEmptyLines) {
+      return line.trim().length > 0;
+    }
+    return true;
+  });
+  if (lines.length === 0) return [];
+  const headerRow = headers || lines[0].split(delimiter).map((h) => h.trim());
+  const dataLines = headers ? lines : lines.slice(1);
+  return dataLines.map((line) => {
+    const values2 = parseCsvLine(line, delimiter);
+    const obj = {};
+    headerRow.forEach((header, index) => {
+      const val = values2[index];
+      obj[header] = val !== void 0 ? val : "";
+    });
+    return obj;
+  });
+}
+function parseCsvLine(line, delimiter) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    const nextChar = line[i + 1];
+    if (char === '"') {
+      if (inQuotes && nextChar === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (char === delimiter && !inQuotes) {
+      result.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+function jsonToCsv(data, options = {}) {
+  const { delimiter = ",", headers, includeHeaders = true } = options;
+  if (data.length === 0) return "";
+  const headerRow = headers || Object.keys(data[0]);
+  const lines = [];
+  if (includeHeaders) {
+    lines.push(headerRow.map(escapeCsvValue).join(delimiter));
+  }
+  data.forEach((item) => {
+    const values2 = headerRow.map((header) => {
+      const value = item[header];
+      return escapeCsvValue(value != null ? String(value) : "");
+    });
+    lines.push(values2.join(delimiter));
+  });
+  return lines.join("\n");
+}
+function escapeCsvValue(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function xmlToJson(xml) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xml, "text/xml");
+  const parseError = doc.querySelector("parsererror");
+  if (parseError) {
+    throw new Error("Invalid XML: " + parseError.textContent);
+  }
+  const result = xmlNodeToJson(doc.documentElement);
+  if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+    return result;
+  }
+  return { value: result };
+}
+function xmlNodeToJson(node) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    const text = node.textContent?.trim();
+    return text || null;
+  }
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const element = node;
+    const result = {};
+    if (element.attributes.length > 0) {
+      const attrs = {};
+      for (let i = 0; i < element.attributes.length; i++) {
+        const attr = element.attributes[i];
+        attrs[attr.name] = attr.value;
+      }
+      result["@attributes"] = attrs;
+    }
+    const children = {};
+    let hasText = false;
+    let textContent = "";
+    for (let i = 0; i < element.childNodes.length; i++) {
+      const child = element.childNodes[i];
+      if (child.nodeType === Node.TEXT_NODE) {
+        const text = child.textContent?.trim();
+        if (text) {
+          textContent += text;
+          hasText = true;
+        }
+      } else if (child.nodeType === Node.ELEMENT_NODE) {
+        const childElement = child;
+        const childName = childElement.tagName;
+        const childValue = xmlNodeToJson(childElement);
+        if (!children[childName]) {
+          children[childName] = [];
+        }
+        children[childName].push(childValue);
+      }
+    }
+    if (hasText && Object.keys(children).length === 0) {
+      return textContent;
+    }
+    Object.keys(children).forEach((key) => {
+      result[key] = children[key].length === 1 ? children[key][0] : children[key];
+    });
+    if (hasText) {
+      result["#text"] = textContent;
+    }
+    return result;
+  }
+  return null;
+}
+function jsonToXml(json, rootTag = "root") {
+  return jsonToXmlElement(json, rootTag);
+}
+function jsonToXmlElement(obj, tagName) {
+  if (obj === null || obj === void 0) {
+    return `<${tagName}></${tagName}>`;
+  }
+  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean") {
+    return `<${tagName}>${escapeXml(String(obj))}</${tagName}>`;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => jsonToXmlElement(item, tagName)).join("");
+  }
+  if (typeof obj === "object") {
+    const record = obj;
+    let xml = `<${tagName}`;
+    if (record["@attributes"]) {
+      const attrs = record["@attributes"];
+      Object.keys(attrs).forEach((key) => {
+        xml += ` ${key}="${escapeXml(String(attrs[key]))}"`;
+      });
+    }
+    xml += ">";
+    if (record["#text"]) {
+      xml += escapeXml(String(record["#text"]));
+    }
+    Object.keys(record).forEach((key) => {
+      if (key !== "@attributes" && key !== "#text") {
+        const value = record[key];
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            xml += jsonToXmlElement(item, key);
+          });
+        } else {
+          xml += jsonToXmlElement(value, key);
+        }
+      }
+    });
+    xml += `</${tagName}>`;
+    return xml;
+  }
+  return `<${tagName}></${tagName}>`;
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function yamlToJson(yaml) {
+  const lines = yaml.split(/\r?\n/);
+  const result = {};
+  const stack = [
+    { obj: result, indent: -1 }
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const current = stack[stack.length - 1];
+    while (stack.length > 1 && indent <= current.indent) {
+      stack.pop();
+    }
+    const match = trimmed.match(/^([^:]+):\s*(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      const valueStr = match[2].trim();
+      let parsedValue;
+      if (valueStr === "") {
+        parsedValue = {};
+      } else if (valueStr === "[]") {
+        parsedValue = [];
+      } else if (valueStr.startsWith("[") && valueStr.endsWith("]")) {
+        parsedValue = parseYamlArray(valueStr);
+      } else if (valueStr === "true" || valueStr === "True") {
+        parsedValue = true;
+      } else if (valueStr === "false" || valueStr === "False") {
+        parsedValue = false;
+      } else if (valueStr === "null" || valueStr === "Null" || valueStr === "~") {
+        parsedValue = null;
+      } else if (/^-?\d+$/.test(valueStr)) {
+        parsedValue = parseInt(valueStr, 10);
+      } else if (/^-?\d+\.\d+$/.test(valueStr)) {
+        parsedValue = parseFloat(valueStr);
+      } else if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
+        parsedValue = valueStr.slice(1, -1).replace(/\\"/g, '"');
+      } else if (valueStr.startsWith("'") && valueStr.endsWith("'")) {
+        parsedValue = valueStr.slice(1, -1);
+      } else {
+        parsedValue = valueStr;
+      }
+      const currentObj = stack[stack.length - 1].obj;
+      if (typeof parsedValue === "object" && parsedValue !== null && !Array.isArray(parsedValue)) {
+        stack.push({ obj: parsedValue, indent });
+      }
+      currentObj[key] = parsedValue;
+    }
+  }
+  return result;
+}
+function parseYamlArray(str) {
+  const content = str.slice(1, -1).trim();
+  if (!content) return [];
+  const items = [];
+  const parts = content.split(",").map((s) => s.trim());
+  parts.forEach((part) => {
+    if (part.startsWith('"') && part.endsWith('"')) {
+      items.push(part.slice(1, -1).replace(/\\"/g, '"'));
+    } else if (part.startsWith("'") && part.endsWith("'")) {
+      items.push(part.slice(1, -1));
+    } else if (part === "true" || part === "True") {
+      items.push(true);
+    } else if (part === "false" || part === "False") {
+      items.push(false);
+    } else if (part === "null" || part === "Null") {
+      items.push(null);
+    } else if (/^-?\d+$/.test(part)) {
+      items.push(parseInt(part, 10));
+    } else if (/^-?\d+\.\d+$/.test(part)) {
+      items.push(parseFloat(part));
+    } else {
+      items.push(part);
+    }
+  });
+  return items;
+}
+function jsonToYaml(json, indent = 2) {
+  return jsonToYamlValue(json, 0, indent);
+}
+function jsonToYamlValue(value, level, indent) {
+  const spaces = " ".repeat(level * indent);
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    if (value.includes(":") || value.includes("\n") || value.includes('"')) {
+      return `"${value.replace(/"/g, '\\"')}"`;
+    }
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    return value.map((item) => `${spaces}- ${jsonToYamlValue(item, level + 1, indent)}`).join("\n");
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys2 = Object.keys(obj);
+    if (keys2.length === 0) {
+      return "{}";
+    }
+    return keys2.map((key) => {
+      const val = obj[key];
+      const keyStr = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key) ? key : `"${key}"`;
+      const valStr = jsonToYamlValue(val, level + 1, indent);
+      if (typeof val === "object" && val !== null) {
+        return `${spaces}${keyStr}:
+${valStr}`;
+      }
+      return `${spaces}${keyStr}: ${valStr}`;
+    }).join("\n");
+  }
+  return String(value);
+}
+
+// src/data/data-structure/index.ts
+var Stack = class {
+  constructor() {
+    this.items = [];
+  }
+  /**
+   * 入栈
+   */
+  push(item) {
+    this.items.push(item);
+  }
+  /**
+   * 出栈
+   */
+  pop() {
+    return this.items.pop();
+  }
+  /**
+   * 查看栈顶元素
+   */
+  peek() {
+    return this.items[this.items.length - 1];
+  }
+  /**
+   * 判断栈是否为空
+   */
+  isEmpty() {
+    return this.items.length === 0;
+  }
+  /**
+   * 获取栈的大小
+   */
+  size() {
+    return this.items.length;
+  }
+  /**
+   * 清空栈
+   */
+  clear() {
+    this.items = [];
+  }
+  /**
+   * 转换为数组
+   */
+  toArray() {
+    return [...this.items];
+  }
+};
+var DataQueue = class {
+  constructor() {
+    this.items = [];
+  }
+  /**
+   * 入队
+   */
+  enqueue(item) {
+    this.items.push(item);
+  }
+  /**
+   * 出队
+   */
+  dequeue() {
+    return this.items.shift();
+  }
+  /**
+   * 查看队首元素
+   */
+  front() {
+    return this.items[0];
+  }
+  /**
+   * 判断队列是否为空
+   */
+  isEmpty() {
+    return this.items.length === 0;
+  }
+  /**
+   * 获取队列的大小
+   */
+  size() {
+    return this.items.length;
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.items = [];
+  }
+  /**
+   * 转换为数组
+   */
+  toArray() {
+    return [...this.items];
+  }
+};
+var ListNode = class {
+  constructor(value) {
+    this.next = null;
+    this.value = value;
+  }
+};
+var LinkedList = class {
+  constructor() {
+    this.head = null;
+    this.length = 0;
+  }
+  /**
+   * 在链表末尾添加元素
+   */
+  append(value) {
+    const newNode = new ListNode(value);
+    if (!this.head) {
+      this.head = newNode;
+    } else {
+      let current = this.head;
+      while (current.next) {
+        current = current.next;
+      }
+      current.next = newNode;
+    }
+    this.length++;
+  }
+  /**
+   * 在指定位置插入元素
+   */
+  insert(index, value) {
+    if (index < 0 || index > this.length) {
+      return false;
+    }
+    const newNode = new ListNode(value);
+    if (index === 0) {
+      newNode.next = this.head;
+      this.head = newNode;
+    } else {
+      let current = this.head;
+      for (let i = 0; i < index - 1; i++) {
+        current = current.next;
+      }
+      newNode.next = current.next;
+      current.next = newNode;
+    }
+    this.length++;
+    return true;
+  }
+  /**
+   * 删除指定位置的元素
+   */
+  removeAt(index) {
+    if (index < 0 || index >= this.length || !this.head) {
+      return null;
+    }
+    let current = this.head;
+    if (index === 0) {
+      this.head = current.next;
+      this.length--;
+      return current.value;
+    }
+    for (let i = 0; i < index - 1; i++) {
+      current = current.next;
+    }
+    const removed = current.next;
+    current.next = removed.next;
+    this.length--;
+    return removed.value;
+  }
+  /**
+   * 查找元素索引
+   */
+  indexOf(value) {
+    let current = this.head;
+    let index = 0;
+    while (current) {
+      if (current.value === value) {
+        return index;
+      }
+      current = current.next;
+      index++;
+    }
+    return -1;
+  }
+  /**
+   * 获取指定位置的元素
+   */
+  get(index) {
+    if (index < 0 || index >= this.length || !this.head) {
+      return null;
+    }
+    let current = this.head;
+    for (let i = 0; i < index; i++) {
+      current = current.next;
+    }
+    return current.value;
+  }
+  /**
+   * 判断链表是否为空
+   */
+  isEmpty() {
+    return this.length === 0;
+  }
+  /**
+   * 获取链表长度
+   */
+  size() {
+    return this.length;
+  }
+  /**
+   * 转换为数组
+   */
+  toArray() {
+    const result = [];
+    let current = this.head;
+    while (current) {
+      result.push(current.value);
+      current = current.next;
+    }
+    return result;
+  }
+};
+var TreeNode = class {
+  constructor(value) {
+    this.left = null;
+    this.right = null;
+    this.value = value;
+  }
+};
+var BinaryTree = class {
+  constructor() {
+    this.root = null;
+  }
+  /**
+   * 插入节点
+   */
+  insert(value) {
+    const newNode = new TreeNode(value);
+    if (!this.root) {
+      this.root = newNode;
+      return;
+    }
+    this.insertNode(this.root, newNode);
+  }
+  insertNode(node, newNode) {
+    if (newNode.value <= node.value) {
+      if (!node.left) {
+        node.left = newNode;
+      } else {
+        this.insertNode(node.left, newNode);
+      }
+    } else {
+      if (!node.right) {
+        node.right = newNode;
+      } else {
+        this.insertNode(node.right, newNode);
+      }
+    }
+  }
+  /**
+   * 查找节点
+   */
+  search(value) {
+    return this.searchNode(this.root, value);
+  }
+  searchNode(node, value) {
+    if (!node) {
+      return false;
+    }
+    if (value === node.value) {
+      return true;
+    }
+    if (value < node.value) {
+      return this.searchNode(node.left, value);
+    }
+    return this.searchNode(node.right, value);
+  }
+  /**
+   * 中序遍历
+   */
+  inOrder() {
+    const result = [];
+    this.inOrderTraverse(this.root, result);
+    return result;
+  }
+  inOrderTraverse(node, result) {
+    if (node) {
+      this.inOrderTraverse(node.left, result);
+      result.push(node.value);
+      this.inOrderTraverse(node.right, result);
+    }
+  }
+  /**
+   * 前序遍历
+   */
+  preOrder() {
+    const result = [];
+    this.preOrderTraverse(this.root, result);
+    return result;
+  }
+  preOrderTraverse(node, result) {
+    if (node) {
+      result.push(node.value);
+      this.preOrderTraverse(node.left, result);
+      this.preOrderTraverse(node.right, result);
+    }
+  }
+  /**
+   * 后序遍历
+   */
+  postOrder() {
+    const result = [];
+    this.postOrderTraverse(this.root, result);
+    return result;
+  }
+  postOrderTraverse(node, result) {
+    if (node) {
+      this.postOrderTraverse(node.left, result);
+      this.postOrderTraverse(node.right, result);
+      result.push(node.value);
+    }
+  }
+};
+var Graph = class {
+  constructor() {
+    this.vertices = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 添加顶点
+   */
+  addVertex(vertex) {
+    if (!this.vertices.has(vertex)) {
+      this.vertices.set(vertex, []);
+    }
+  }
+  /**
+   * 添加边（无向图）
+   */
+  addEdge(vertex1, vertex2) {
+    if (!this.vertices.has(vertex1)) {
+      this.addVertex(vertex1);
+    }
+    if (!this.vertices.has(vertex2)) {
+      this.addVertex(vertex2);
+    }
+    const neighbors1 = this.vertices.get(vertex1);
+    const neighbors2 = this.vertices.get(vertex2);
+    if (!neighbors1.includes(vertex2)) {
+      neighbors1.push(vertex2);
+    }
+    if (!neighbors2.includes(vertex1)) {
+      neighbors2.push(vertex1);
+    }
+  }
+  /**
+   * 获取顶点的邻居
+   */
+  getNeighbors(vertex) {
+    return this.vertices.get(vertex) || [];
+  }
+  /**
+   * 深度优先搜索
+   */
+  dfs(start, callback) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const dfsVisit = (vertex) => {
+      visited.add(vertex);
+      result.push(vertex);
+      if (callback) {
+        callback(vertex);
+      }
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          dfsVisit(neighbor);
+        }
+      }
+    };
+    dfsVisit(start);
+    return result;
+  }
+  /**
+   * 广度优先搜索
+   */
+  bfs(start, callback) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [start];
+    const result = [];
+    visited.add(start);
+    while (queue.length > 0) {
+      const vertex = queue.shift();
+      result.push(vertex);
+      if (callback) {
+        callback(vertex);
+      }
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          queue.push(neighbor);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 获取所有顶点
+   */
+  getVertices() {
+    return Array.from(this.vertices.keys());
+  }
+};
+var LRUCache = class {
+  constructor(capacity) {
+    if (capacity <= 0) {
+      throw new Error("Capacity must be greater than 0");
+    }
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 获取值
+   */
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    const value = this.cache.get(key);
+    this.cache.delete(key);
+    this.cache.set(key, value);
+    return value;
+  }
+  /**
+   * 设置值
+   */
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.capacity) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  /**
+   * 删除键
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * 清空缓存
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * 判断是否包含键
+   */
+  has(key) {
+    return this.cache.has(key);
+  }
+  /**
+   * 获取缓存大小
+   */
+  size() {
+    return this.cache.size;
+  }
+  /**
+   * 获取所有键
+   */
+  keys() {
+    return Array.from(this.cache.keys()).filter((key) => key !== void 0);
+  }
+  /**
+   * 获取所有值
+   */
+  values() {
+    return Array.from(this.cache.values());
+  }
+};
+
+// src/data/algorithm/index.ts
+function binarySearch(array, target, compareFn) {
+  let left = 0;
+  let right = array.length - 1;
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+    const comparison = compare(array[mid], target);
+    if (comparison === 0) {
+      return mid;
+    } else if (comparison < 0) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+  return -1;
+}
+function quickSort(array, compareFn) {
+  if (array.length <= 1) {
+    return [...array];
+  }
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const pivot = array[Math.floor(array.length / 2)];
+  const left = [];
+  const right = [];
+  const equal = [];
+  for (const item of array) {
+    const comparison = compare(item, pivot);
+    if (comparison < 0) {
+      left.push(item);
+    } else if (comparison > 0) {
+      right.push(item);
+    } else {
+      equal.push(item);
+    }
+  }
+  return [...quickSort(left, compareFn), ...equal, ...quickSort(right, compareFn)];
+}
+function mergeSort(array, compareFn) {
+  if (array.length <= 1) {
+    return [...array];
+  }
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const mid = Math.floor(array.length / 2);
+  const left = mergeSort(array.slice(0, mid), compareFn);
+  const right = mergeSort(array.slice(mid), compareFn);
+  return merge2(left, right, compare);
+}
+function merge2(left, right, compareFn) {
+  const result = [];
+  let i = 0;
+  let j = 0;
+  while (i < left.length && j < right.length) {
+    if (compareFn(left[i], right[j]) <= 0) {
+      result.push(left[i]);
+      i++;
+    } else {
+      result.push(right[j]);
+      j++;
+    }
+  }
+  return result.concat(left.slice(i)).concat(right.slice(j));
+}
+function bubbleSort(array, compareFn) {
+  const result = [...array];
+  const compare = compareFn || ((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const n = result.length;
+  for (let i = 0; i < n - 1; i++) {
+    let swapped = false;
+    for (let j = 0; j < n - i - 1; j++) {
+      if (compare(result[j], result[j + 1]) > 0) {
+        [result[j], result[j + 1]] = [result[j + 1], result[j]];
+        swapped = true;
+      }
+    }
+    if (!swapped) {
+      break;
+    }
+  }
+  return result;
+}
+function fibonacci(n) {
+  if (n < 0) {
+    throw new Error("n must be non-negative");
+  }
+  if (n === 0) return 0;
+  if (n === 1) return 1;
+  let a = 0;
+  let b = 1;
+  for (let i = 2; i <= n; i++) {
+    [a, b] = [b, a + b];
+  }
+  return b;
+}
+function fibonacciSequence(n) {
+  if (n <= 0) return [];
+  if (n === 1) return [0];
+  if (n === 2) return [0, 1];
+  const sequence = [0, 1];
+  for (let i = 2; i < n; i++) {
+    sequence.push(sequence[i - 1] + sequence[i - 2]);
+  }
+  return sequence;
+}
+function factorial(n) {
+  if (n < 0) {
+    throw new Error("n must be non-negative");
+  }
+  if (n === 0 || n === 1) {
+    return 1;
+  }
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+function gcd(a, b) {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    [a, b] = [b, a % b];
+  }
+  return a;
+}
+function lcm(a, b) {
+  return Math.abs(a * b) / gcd(a, b);
+}
+
+// src/helper/performance/index.ts
+function debounce(fn, delay) {
+  let timeoutId = null;
+  return function(...args) {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn.apply(this, args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+function throttle(fn, delay) {
+  let lastCall = 0;
+  let timeoutId = null;
+  return function(...args) {
+    const now = Date.now();
+    const timeSinceLastCall = now - lastCall;
+    if (timeSinceLastCall >= delay) {
+      lastCall = now;
+      fn.apply(this, args);
+    } else {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      timeoutId = setTimeout(() => {
+        lastCall = Date.now();
+        fn.apply(this, args);
+        timeoutId = null;
+      }, delay - timeSinceLastCall);
+    }
+  };
+}
+function memoize(fn, keyFn) {
+  const cache = /* @__PURE__ */ new Map();
+  return ((...args) => {
+    const key = keyFn ? keyFn(...args) : JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  });
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return ((...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
+  });
+}
+async function retry(fn, retryCount = 3, retryDelay = 1e3) {
+  let lastError = null;
+  for (let i = 0; i <= retryCount; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (i < retryCount) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+async function timeout(fn, timeout2) {
+  return Promise.race([
+    fn(),
+    new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(`Operation timeout after ${timeout2}ms`)), timeout2);
+    })
+  ]);
+}
+async function batch(items, fn, batchSize = 10) {
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch2 = items.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch2.map(fn));
+    results.push(...batchResults);
+  }
+  return results;
+}
+var Queue = class {
+  constructor() {
+    this.items = [];
+    this.processing = false;
+  }
+  /**
+   * 添加项到队列
+   * @param item - 要添加的项
+   */
+  enqueue(item) {
+    this.items.push(item);
+    if (!this.processing && this.processor) {
+      this.processItems();
+    }
+  }
+  /**
+   * 设置处理函数并开始处理
+   * @param processor - 处理函数
+   */
+  async start(processor) {
+    this.processor = processor;
+    if (!this.processing) {
+      await this.processItems();
+    }
+  }
+  /**
+   * 处理队列
+   */
+  async processItems() {
+    if (!this.processor || this.processing) return;
+    this.processing = true;
+    while (this.items.length > 0) {
+      const item = this.items.shift();
+      if (item && this.processor) {
+        try {
+          await this.processor(item);
+        } catch (error) {
+          console.error("Queue processing error:", error);
+        }
+      }
+    }
+    this.processing = false;
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.items = [];
+  }
+  /**
+   * 获取队列长度
+   */
+  get length() {
+    return this.items.length;
+  }
+};
+
+// src/helper/tracking/index.ts
+var Tracker = class {
+  constructor(options) {
+    this.eventQueue = [];
+    this.batchTimer = null;
+    this.userInfo = {};
+    this.exposureObservers = /* @__PURE__ */ new Map();
+    this.exposureTimers = /* @__PURE__ */ new Map();
+    this.exposedElements = /* @__PURE__ */ new Set();
+    if (!options.endpoint && !options.customSend) {
+      throw new Error("Either endpoint or customSend must be provided");
+    }
+    this.options = {
+      endpoint: options.endpoint || "",
+      batchSize: options.batchSize ?? 10,
+      batchDelay: options.batchDelay ?? 3e3,
+      autoTrackPageView: options.autoTrackPageView ?? true,
+      autoTrackClick: options.autoTrackClick ?? false,
+      commonParams: options.commonParams || {},
+      customSend: options.customSend,
+      debug: options.debug ?? false
+    };
+    this.sessionId = this.generateSessionId();
+    if (this.options.autoTrackPageView && typeof window !== "undefined") {
+      this.trackPageView();
+      this.setupPageViewListener();
+    }
+    if (this.options.autoTrackClick && typeof window !== "undefined") {
+      this.setupClickListener();
+    }
+  }
+  /**
+   * 生成会话ID
+   */
+  generateSessionId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * 获取公共数据
+   */
+  getCommonData() {
+    const data = {
+      timestamp: Date.now(),
+      sessionId: this.sessionId,
+      ...this.options.commonParams,
+      ...this.userInfo
+    };
+    if (typeof window !== "undefined") {
+      data.url = window.location.href;
+      data.userAgent = navigator.userAgent;
+    }
+    return data;
+  }
+  /**
+   * 添加事件到队列
+   */
+  enqueue(event) {
+    this.eventQueue.push(event);
+    if (this.options.debug) {
+      console.log("[Tracker] Event enqueued:", event);
+    }
+    if (this.eventQueue.length >= this.options.batchSize) {
+      this.flush();
+    } else {
+      this.scheduleBatch();
+    }
+  }
+  /**
+   * 安排批量上报
+   */
+  scheduleBatch() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+    }
+    this.batchTimer = setTimeout(() => {
+      this.flush();
+    }, this.options.batchDelay);
+  }
+  /**
+   * 上报事件
+   */
+  async sendEvents(events) {
+    if (events.length === 0) return;
+    try {
+      if (this.options.customSend) {
+        await this.options.customSend(events);
+      } else if (this.options.endpoint) {
+        await this.sendToEndpoint(events);
+      }
+      if (this.options.debug) {
+        console.log("[Tracker] Events sent:", events);
+      }
+    } catch (error) {
+      console.error("[Tracker] Failed to send events:", error);
+      this.eventQueue.unshift(...events);
+    }
+  }
+  /**
+   * 发送到上报接口
+   */
+  async sendToEndpoint(events) {
+    const response = await fetch(this.options.endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ events })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+  }
+  /**
+   * 立即上报所有待上报事件
+   */
+  async flush() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+      this.batchTimer = null;
+    }
+    if (this.eventQueue.length === 0) return;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    await this.sendEvents(events);
+  }
+  /**
+   * 追踪事件
+   */
+  trackEvent(name, params) {
+    const event = {
+      type: "event",
+      name,
+      params,
+      ...this.getCommonData()
+    };
+    this.enqueue(event);
+  }
+  /**
+   * 追踪页面浏览
+   */
+  trackPageView(params) {
+    const event = {
+      type: "pageview",
+      name: "pageview",
+      params: {
+        path: typeof window !== "undefined" ? window.location.pathname : void 0,
+        search: typeof window !== "undefined" ? window.location.search : void 0,
+        hash: typeof window !== "undefined" ? window.location.hash : void 0,
+        ...params
+      },
+      ...this.getCommonData()
+    };
+    this.enqueue(event);
+  }
+  /**
+   * 追踪点击事件
+   */
+  trackClick(element, params) {
+    const el = typeof element === "string" ? document.querySelector(element) : element;
+    if (!el) {
+      if (this.options.debug) {
+        console.warn("[Tracker] Element not found:", element);
+      }
+      return;
+    }
+    const event = {
+      type: "click",
+      name: "click",
+      params: {
+        element: el.tagName.toLowerCase(),
+        id: el.id || void 0,
+        className: el.className || void 0,
+        text: el.textContent?.trim().substring(0, 100) || void 0,
+        ...params
+      },
+      ...this.getCommonData()
+    };
+    this.enqueue(event);
+  }
+  /**
+   * 追踪曝光事件
+   */
+  trackExposure(element, options, params) {
+    if (typeof window === "undefined" || !window.IntersectionObserver) {
+      if (this.options.debug) {
+        console.warn("[Tracker] IntersectionObserver is not supported");
+      }
+      return;
+    }
+    const el = typeof element === "string" ? document.querySelector(element) : element;
+    if (!el) {
+      if (this.options.debug) {
+        console.warn("[Tracker] Element not found:", element);
+      }
+      return;
+    }
+    const { threshold = 0.5, duration = 1e3, once: once2 = true } = options || {};
+    const elementId = `${Date.now()}-${Math.random()}`;
+    if (once2 && this.exposedElements.has(el)) {
+      return;
+    }
+    let exposureTimer = null;
+    let startTime = null;
+    const observer = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          if (entry.isIntersecting && entry.intersectionRatio >= threshold) {
+            if (!startTime) {
+              startTime = Date.now();
+              const currentStartTime = startTime;
+              exposureTimer = setTimeout(() => {
+                const event = {
+                  type: "exposure",
+                  name: "exposure",
+                  params: {
+                    element: el.tagName.toLowerCase(),
+                    id: el.id || void 0,
+                    className: el.className || void 0,
+                    duration: currentStartTime ? Date.now() - currentStartTime : duration,
+                    ...params
+                  },
+                  ...this.getCommonData()
+                };
+                this.enqueue(event);
+                this.exposedElements.add(el);
+                observer.disconnect();
+                this.exposureObservers.delete(elementId);
+                if (exposureTimer) {
+                  clearTimeout(exposureTimer);
+                  this.exposureTimers.delete(elementId);
+                }
+              }, duration);
+              this.exposureTimers.set(elementId, exposureTimer);
+            }
+          } else {
+            if (exposureTimer) {
+              clearTimeout(exposureTimer);
+              this.exposureTimers.delete(elementId);
+            }
+            startTime = null;
+          }
+        });
+      },
+      {
+        threshold: [threshold]
+      }
+    );
+    observer.observe(el);
+    this.exposureObservers.set(elementId, observer);
+  }
+  /**
+   * 设置用户信息
+   */
+  setUserInfo(userInfo) {
+    this.userInfo = { ...this.userInfo, ...userInfo };
+  }
+  /**
+   * 设置公共参数
+   */
+  setCommonParams(params) {
+    this.options.commonParams = { ...this.options.commonParams, ...params };
+  }
+  /**
+   * 设置页面浏览监听器（SPA应用）
+   */
+  setupPageViewListener() {
+    if (typeof window === "undefined") return;
+    window.addEventListener("popstate", () => {
+      this.trackPageView();
+    });
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = function(...args) {
+      originalPushState.apply(history, args);
+      window.dispatchEvent(new Event("pushstate"));
+    };
+    history.replaceState = function(...args) {
+      originalReplaceState.apply(history, args);
+      window.dispatchEvent(new Event("replacestate"));
+    };
+    window.addEventListener("pushstate", () => {
+      this.trackPageView();
+    });
+    window.addEventListener("replacestate", () => {
+      this.trackPageView();
+    });
+  }
+  /**
+   * 设置点击事件监听器
+   */
+  setupClickListener() {
+    if (typeof window === "undefined" || typeof document === "undefined") return;
+    document.addEventListener(
+      "click",
+      (event) => {
+        const target = event.target;
+        if (target) {
+          this.trackClick(target);
+        }
+      },
+      true
+      // 使用捕获阶段
+    );
+  }
+  /**
+   * 清理资源
+   */
+  destroy() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+      this.batchTimer = null;
+    }
+    this.exposureObservers.forEach((observer) => observer.disconnect());
+    this.exposureObservers.clear();
+    this.exposureTimers.forEach((timer) => clearTimeout(timer));
+    this.exposureTimers.clear();
+    this.flush().catch(console.error);
+  }
+};
+function createTracker(options) {
+  return new Tracker(options);
+}
+var defaultTracker = null;
+function initTracker(options) {
+  if (defaultTracker) {
+    console.warn("[Tracker] Default tracker already initialized");
+    return defaultTracker;
+  }
+  defaultTracker = new Tracker(options);
+  return defaultTracker;
+}
+function getTracker() {
+  if (!defaultTracker) {
+    throw new Error("Tracker not initialized. Call initTracker() first.");
+  }
+  return defaultTracker;
+}
+function trackEvent(name, params) {
+  getTracker().trackEvent(name, params);
+}
+function trackPageView(params) {
+  getTracker().trackPageView(params);
+}
+function trackClick(element, params) {
+  getTracker().trackClick(element, params);
+}
+function trackExposure(element, options, params) {
+  getTracker().trackExposure(element, options, params);
+}
+function setUserInfo(userInfo) {
+  getTracker().setUserInfo(userInfo);
+}
+function setCommonParams(params) {
+  getTracker().setCommonParams(params);
+}
+async function flush() {
+  await getTracker().flush();
+}
+var serviceEventHandlers = {
+  message: null
+};
+function setServiceEventHandlers(handlers = {}) {
+  Object.assign(serviceEventHandlers, handlers);
+}
+function emitMessageEvent(payload) {
+  const handler = serviceEventHandlers.message;
+  if (typeof handler === "function") {
+    handler(payload);
+    return;
+  }
+  const { type = "error", message, code, status } = payload;
+  const prefix = `[service][${type}]`;
+  const extra = [];
+  if (typeof code !== "undefined") extra.push(`code=${code}`);
+  if (typeof status !== "undefined") extra.push(`status=${status}`);
+  const suffix = extra.length ? ` (${extra.join(", ")})` : "";
+  if (type === "info" || type === "success") {
+    console.info(`${prefix} ${message}${suffix}`);
+  } else if (type === "warn" || type === "warning") {
+    console.warn(`${prefix} ${message}${suffix}`);
+  } else {
+    console.error(`${prefix} ${message}${suffix}`);
+  }
+}
+function filterEmptyKey(params, emptyString) {
+  Object.keys(params).forEach((key) => {
+    if (params[key] === null || emptyString && params[key] === "" || emptyString && Array.isArray(params[key]) && params[key].length <= 0) {
+      delete params[key];
+    }
+  });
+}
+function getTransformRequest(contentType) {
+  if (!contentType) {
+    return (data) => Qs__default.default.stringify(data);
+  }
+  const normalizedType = contentType.toLowerCase().trim();
+  if (normalizedType.startsWith("application/json")) {
+    return (data) => JSON.stringify(data);
+  }
+  if (normalizedType.startsWith("application/x-www-form-urlencoded")) {
+    return (data) => Qs__default.default.stringify(data);
+  }
+  return void 0;
+}
+var service = axios__default.default.create({
+  baseURL: "",
+  timeout: 6e4,
+  // 不设置默认 transformRequest，根据 Content-Type 自动选择
+  headers: {
+    "Cache-Control": "no-cache",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "X-Requested-With": "XMLHttpRequest"
+  }
+});
+service.interceptors.request.use(
+  async (config) => {
+    const contentType = config.headers?.["Content-Type"] || config.headers?.["content-type"];
+    if (!config.transformRequest && contentType) {
+      const transformRequest = getTransformRequest(
+        typeof contentType === "string" ? contentType : void 0
+      );
+      if (transformRequest) {
+        config.transformRequest = transformRequest;
+      }
+    } else if (!config.transformRequest) {
+      config.transformRequest = (data) => Qs__default.default.stringify(data);
+    }
+    if (config.method === "post" || config.method === "put" || config.method === "patch") {
+      const params = { ...config.data || {} };
+      filterEmptyKey(params, config.emptyParams ?? false);
+      config.data = params;
+    } else if (config.method === "get" || config.method === "delete") {
+      if (!config.disableTimestamp) {
+        config.params = {
+          _t: Math.floor(Date.now() / 1e3),
+          ...config.params || {}
+        };
+      }
+      filterEmptyKey(config.params, true);
+    }
+    return config;
+  },
+  (error) => Promise.reject(error)
+);
+function extractErrorMessage(responseData) {
+  return responseData?.errorMessage || responseData?.message || responseData?.msg || "Unknown server error";
+}
+function handle401Error(config, error) {
+  emitMessageEvent({
+    type: "info",
+    message: "Authentication required",
+    status: 401,
+    config,
+    error
+  });
+}
+function isServiceResponseData(data) {
+  return typeof data === "object" && data !== null && !(data instanceof Blob) && ("success" in data || "code" in data || "data" in data || "message" in data || "msg" in data);
+}
+function hasDataField(responseData) {
+  return "data" in responseData && responseData.data !== void 0;
+}
+function extractResponseData(response) {
+  const { data } = response;
+  if (data instanceof Blob) {
+    return data;
+  }
+  if (!isServiceResponseData(data)) {
+    return data;
+  }
+  if (hasDataField(data)) {
+    return data.data;
+  }
+  return data;
+}
+service.interceptors.response.use(
+  (res) => {
+    const { data, config } = res;
+    const extendedConfig = config;
+    if (extendedConfig.file && res.status === 200 && data instanceof Blob) {
+      convertRes2Blob(res);
+      return void 0;
+    }
+    if (!isServiceResponseData(data)) {
+      return data;
+    }
+    const responseData = data;
+    if ((!responseData.success || responseData.success === "false") && responseData.code !== 200 && responseData.code !== 0) {
+      const msg = extractErrorMessage(responseData);
+      const code = responseData.errorCode || responseData.code || -1e3;
+      if (!extendedConfig.hidden) {
+        emitMessageEvent({
+          type: code === 401 ? "info" : "error",
+          message: `${extendedConfig.action || "Request"} failed: ${msg}`,
+          code,
+          status: res.status,
+          config: extendedConfig
+        });
+      }
+      return Promise.reject({ code, message: msg });
+    }
+    const extractedData = extractResponseData(res);
+    return extractedData;
+  },
+  (error) => {
+    try {
+      const axiosError = error;
+      const config = axiosError.config || {};
+      const status = axiosError.response?.status;
+      const messageText = String(axiosError?.message || "");
+      const isAborted = axiosError.code === "ECONNABORTED";
+      if (status === 401) {
+        handle401Error(config, error);
+      }
+      if (isAborted && config && !config._noAutoRetry) {
+        config._retryCount = config._retryCount || 0;
+        if (config._retryCount < 2) {
+          config._retryCount++;
+          console.debug(
+            `[request] aborted, retry attempt #${config._retryCount} -> ${config.url || ""}`
+          );
+          return new Promise((resolve) => setTimeout(resolve, 300)).then(
+            () => service.request(config)
+          );
+        }
+      }
+      if (!config?.hidden && !isAborted) {
+        let friendly = messageText;
+        if (status === 403) friendly = "No permission";
+        else if (status === 502) friendly = "System is upgrading or unavailable";
+        else if (status === 504) friendly = "System timeout";
+        emitMessageEvent({
+          type: status === 401 ? "info" : "error",
+          message: `${config.action || "Request"} failed: ${friendly}`,
+          status,
+          config,
+          error
+        });
+      }
+    } catch (e) {
+      console.error("error in response error handler", e);
+    }
+    return Promise.reject(error);
+  }
+);
+service.json = function(url, params, config) {
+  const newConfig = {
+    headers: { "Content-Type": "application/json", ...config?.headers },
+    ...config
+  };
+  return service.post(
+    url,
+    Array.isArray(params) ? params : params,
+    newConfig
+  );
+};
+service.put = function(url, params, config) {
+  const newConfig = {
+    headers: { "Content-Type": "application/json", ...config?.headers },
+    ...config
+  };
+  return service.put(url, Array.isArray(params) ? params : params, newConfig).then((res) => res);
+};
+service.arrayGet = function(url, config) {
+  if (config) {
+    config.paramsSerializer = (params) => Qs__default.default.stringify(params, { arrayFormat: "repeat" });
+  }
+  return service.get(url, config);
+};
+service.download = function(url, config = {}) {
+  const { type = "get", params } = config;
+  const newConfig = {
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json; charset=utf-8",
+      ...config.headers
+    },
+    withCredentials: true,
+    file: true,
+    responseType: "blob",
+    ...config
+  };
+  if (type === "get") {
+    newConfig.params = params;
+    return service.get(url, newConfig);
+  } else {
+    newConfig.params = {};
+    return service.post(url, params, newConfig).then(() => void 0);
+  }
+};
+function convertRes2Blob(response) {
+  const contentDisposition = response.headers["content-disposition"];
+  let fileName = "file.xlsx";
+  if (contentDisposition) {
+    const rfc5987Match = contentDisposition.match(/filename\*=UTF-8''([^;]+)/i);
+    if (rfc5987Match) {
+      fileName = decodeURIComponent(rfc5987Match[1]);
+    } else {
+      const standardMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/i);
+      if (standardMatch) {
+        fileName = standardMatch[1];
+        fileName = fileName.replace(/^['"]|['"]$/g, "");
+        try {
+          fileName = decodeURIComponent(fileName);
+        } catch (e) {
+          try {
+            fileName = decodeURI(fileName);
+          } catch (e2) {
+          }
+        }
+      }
+    }
+    fileName = fileName.trim().replace(/^_+|_+$/g, "");
+  }
+  const blob = new Blob([response.data], { type: "application/vnd.ms-excel;charset=utf-8" });
+  if (typeof window.navigator.msSaveBlob !== "undefined") {
+    window.navigator.msSaveBlob(blob, fileName);
+  } else {
+    const blobURL = window.URL.createObjectURL(blob);
+    const tempLink = document.createElement("a");
+    tempLink.style.display = "none";
+    tempLink.href = blobURL;
+    tempLink.setAttribute("download", fileName);
+    if (typeof tempLink.download === "undefined") {
+      tempLink.setAttribute("target", "_blank");
+    }
+    document.body.appendChild(tempLink);
+    tempLink.click();
+    document.body.removeChild(tempLink);
+    window.URL.revokeObjectURL(blobURL);
+  }
+}
+
+exports.$ = $;
+exports.$$ = $$;
+exports.BinaryTree = BinaryTree;
+exports.ChunkUploader = ChunkUploader;
+exports.DataQueue = DataQueue;
+exports.Graph = Graph;
+exports.LRUCache = LRUCache;
+exports.LinkedList = LinkedList;
+exports.Queue = Queue;
+exports.Stack = Stack;
+exports.Tracker = Tracker;
+exports.UploadStatus = UploadStatus;
+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;
+exports.binarySearch = binarySearch;
+exports.bubbleSort = bubbleSort;
+exports.buildUrl = buildUrl;
+exports.calculateBlobMD5 = calculateBlobMD5;
+exports.calculateFileMD5 = calculateFileMD5;
+exports.camelCase = camelCase;
+exports.capitalize = capitalize;
+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;
+exports.createTracker = createTracker;
+exports.createTranslator = createTranslator;
+exports.createUploader = createUploader;
+exports.csvToJson = csvToJson;
+exports.darken = darken;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.deepMerge = deepMerge;
+exports.defaults = defaults;
+exports.deriveKeyFromPassword = deriveKeyFromPassword;
+exports.diffDays = diffDays;
+exports.difference = difference;
+exports.downloadFile = downloadFile;
+exports.drop = drop;
+exports.dropWhile = dropWhile;
+exports.endOfDay = endOfDay;
+exports.escapeHtml = escapeHtml;
+exports.exportPrivateKey = exportPrivateKey;
+exports.exportPublicKey = exportPublicKey;
+exports.factorial = factorial;
+exports.fetchWithRetry = fetchWithRetry;
+exports.fetchWithTimeout = fetchWithTimeout;
+exports.fibonacci = fibonacci;
+exports.fibonacciSequence = fibonacciSequence;
+exports.findIndexBy = findIndexBy;
+exports.flatten = flatten;
+exports.floor = floor;
+exports.flush = flush;
+exports.formatBytes = formatBytes;
+exports.formatCurrency = formatCurrency;
+exports.formatCurrencyI18n = formatCurrencyI18n;
+exports.formatDate = formatDate;
+exports.formatDateI18n = formatDateI18n;
+exports.formatFileSize = formatFileSize;
+exports.formatNumber = formatNumber;
+exports.formatNumberI18n = formatNumberI18n;
+exports.formatRelativeTime = formatRelativeTime;
+exports.gcd = gcd;
+exports.generateHMACKey = generateHMACKey;
+exports.generateRSAKeyPair = generateRSAKeyPair;
+exports.generateRandomString = generateRandomString;
+exports.generateUUID = generateUUID;
+exports.get = get;
+exports.getDateFormatByGMT = getDateFormatByGMT;
+exports.getElementOffset = getElementOffset;
+exports.getFileExtension = getFileExtension;
+exports.getFileNameWithoutExtension = getFileNameWithoutExtension;
+exports.getKeyUsageCount = getKeyUsageCount;
+exports.getLocale = getLocale;
+exports.getQuarter = getQuarter;
+exports.getQueryParams = getQueryParams;
+exports.getRelativeTime = getRelativeTime;
+exports.getScrollPosition = getScrollPosition;
+exports.getStorageKeyPair = getStorageKeyPair;
+exports.getStyle = getStyle;
+exports.getTimeFromGMT = getTimeFromGMT;
+exports.getTracker = getTracker;
+exports.getWeekNumber = getWeekNumber;
+exports.groupBy = groupBy;
+exports.hash = hash;
+exports.hexToRgb = hexToRgb;
+exports.highlight = highlight;
+exports.hslToRgb = hslToRgb;
+exports.importPrivateKey = importPrivateKey;
+exports.importPublicKey = importPublicKey;
+exports.initTracker = initTracker;
+exports.initializeStorageKeys = initializeStorageKeys;
+exports.intersection = intersection;
+exports.invert = invert;
+exports.isAbsoluteUrl = isAbsoluteUrl;
+exports.isBetween = isBetween;
+exports.isEmpty = isEmpty;
+exports.isEmptyObject = isEmptyObject;
+exports.isEqual = isEqual;
+exports.isFloat = isFloat;
+exports.isInViewport = isInViewport;
+exports.isInteger = isInteger;
+exports.isNumeric = isNumeric;
+exports.isToday = isToday;
+exports.isValidDomain = isValidDomain;
+exports.isValidEmail = isValidEmail;
+exports.isValidHexColor = isValidHexColor;
+exports.isValidIP = isValidIP;
+exports.isValidIdCard = isValidIdCard;
+exports.isValidJSON = isValidJSON;
+exports.isValidPhone = isValidPhone;
+exports.isValidUUID = isValidUUID;
+exports.isValidUrl = isValidUrl;
+exports.isWeekday = isWeekday;
+exports.isWeekend = isWeekend;
+exports.isYesterday = isYesterday;
+exports.joinUrl = joinUrl;
+exports.jsonToCsv = jsonToCsv;
+exports.jsonToXml = jsonToXml;
+exports.jsonToYaml = jsonToYaml;
+exports.kebabCase = kebabCase;
+exports.keys = keys;
+exports.lcm = lcm;
+exports.lighten = lighten;
+exports.localStorage = localStorage;
+exports.mapKeys = mapKeys;
+exports.mapValues = mapValues;
+exports.mask = mask;
+exports.maskEmail = maskEmail;
+exports.maskPhone = maskPhone;
+exports.memoize = memoize;
+exports.merge = merge;
+exports.mergeSort = mergeSort;
+exports.mix = mix;
+exports.normalizeUrl = normalizeUrl;
+exports.omit = omit;
+exports.omitBy = omitBy;
+exports.once = once;
+exports.parseNumber = parseNumber;
+exports.parseUrl = parseUrl;
+exports.partition = partition;
+exports.pascalCase = pascalCase;
+exports.percent = percent;
+exports.pick = pick;
+exports.pickBy = pickBy;
+exports.pluralize = pluralize;
+exports.quickSort = quickSort;
+exports.random = random;
+exports.removeAccents = removeAccents;
+exports.removeClass = removeClass;
+exports.removeQueryParams = removeQueryParams;
+exports.request = request;
+exports.resetKeyUsageCount = resetKeyUsageCount;
+exports.retry = retry;
+exports.rgbToHex = rgbToHex;
+exports.rgbToHsl = rgbToHsl;
+exports.round = round;
+exports.rsaDecrypt = rsaDecrypt;
+exports.rsaEncrypt = rsaEncrypt;
+exports.sample = sample;
+exports.scrollTo = scrollTo;
+exports.sessionStorage = sessionStorage;
+exports.set = set;
+exports.setCommonParams = setCommonParams;
+exports.setQueryParams = setQueryParams;
+exports.setServiceEventHandlers = setServiceEventHandlers;
+exports.setStorageKeyPair = setStorageKeyPair;
+exports.setStyle = setStyle;
+exports.setUserInfo = setUserInfo;
+exports.sha256 = sha256;
+exports.shuffle = shuffle;
+exports.slugify = slugify;
+exports.snakeCase = snakeCase;
+exports.sortBy = sortBy;
+exports.splitFileIntoChunks = splitFileIntoChunks;
+exports.startOfDay = startOfDay;
+exports.storage = storage;
+exports.take = take;
+exports.takeWhile = takeWhile;
+exports.template = template;
+exports.throttle = throttle;
+exports.timeout = timeout;
+exports.toFixed = toFixed;
+exports.toggleClass = toggleClass;
+exports.trackClick = trackClick;
+exports.trackEvent = trackEvent;
+exports.trackExposure = trackExposure;
+exports.trackPageView = trackPageView;
+exports.transform = transform;
+exports.translate = translate;
+exports.truncate = truncate;
+exports.unescapeHtml = unescapeHtml;
+exports.union = union;
+exports.unique = unique;
+exports.unzip = unzip;
+exports.updateQueryParams = updateQueryParams;
+exports.uploadFile = uploadFile;
+exports.values = values;
+exports.verifyHMAC = verifyHMAC;
+exports.xmlToJson = xmlToJson;
+exports.yamlToJson = yamlToJson;
+exports.zip = zip;