@szkj/utils 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1850 @@
+'use strict';
+
+var CryptoJS = require('crypto-js');
+var smCrypto = require('sm-crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var CryptoJS__default = /*#__PURE__*/_interopDefault(CryptoJS);
+var smCrypto__default = /*#__PURE__*/_interopDefault(smCrypto);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/mask/maskOptions.ts
+function maskByKeepEnds(value, defaults, options = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const start = normalizeCount(
+    (_b = (_a = options.start) != null ? _a : defaults.start) != null ? _b : 0
+  );
+  const end = normalizeCount(
+    (_d = (_c = options.end) != null ? _c : defaults.end) != null ? _d : 0
+  );
+  const maskChar = options.maskChar || defaults.maskChar || "*";
+  if (value.length <= start + end) {
+    const hiddenLength2 = Math.max(
+      value.length - start,
+      0
+    );
+    const maskLength2 = normalizeCount(
+      (_f = (_e = options.maskLength) != null ? _e : defaults.maskLength) != null ? _f : hiddenLength2
+    );
+    return value.slice(0, start) + maskChar.repeat(maskLength2);
+  }
+  const hiddenLength = Math.max(
+    value.length - start - end,
+    0
+  );
+  const maskLength = normalizeCount(
+    (_h = (_g = options.maskLength) != null ? _g : defaults.maskLength) != null ? _h : hiddenLength
+  );
+  return value.slice(0, start) + maskChar.repeat(maskLength) + (end > 0 ? value.slice(-end) : "");
+}
+function normalizeCount(value) {
+  return Math.max(0, Math.floor(value));
+}
+
+// src/mask/mask.ts
+function mask(value, options = {}) {
+  if (!value) return "";
+  if (options.pattern) {
+    return maskByPattern(value, options);
+  }
+  if (options.range) {
+    return maskByRange(value, options);
+  }
+  return maskByKeepEnds(value, {}, options);
+}
+function maskByPattern(value, options) {
+  const {
+    pattern,
+    replacement,
+    maskChar = "*"
+  } = options;
+  if (!pattern) return value;
+  return value.replace(pattern, (match) => {
+    if (typeof replacement === "function") {
+      return replacement(match);
+    }
+    if (typeof replacement === "string") {
+      return replacement;
+    }
+    return maskChar.repeat(
+      getMaskLength(match.length, options)
+    );
+  });
+}
+function maskByRange(value, options) {
+  const [rawStart, rawEnd] = options.range || [0, 0];
+  const start = clampIndex(rawStart, value.length);
+  const end = clampIndex(rawEnd, value.length);
+  const from = Math.min(start, end);
+  const to = Math.max(start, end);
+  const maskChar = options.maskChar || "*";
+  return value.slice(0, from) + maskChar.repeat(
+    getMaskLength(to - from, options)
+  ) + value.slice(to);
+}
+function getMaskLength(hiddenLength, options) {
+  var _a;
+  return Math.max(
+    0,
+    Math.floor(
+      (_a = options.maskLength) != null ? _a : hiddenLength
+    )
+  );
+}
+function clampIndex(value, length) {
+  return Math.min(
+    Math.max(0, Math.floor(value)),
+    length
+  );
+}
+
+// src/mask/maskName.ts
+function maskName(name, options) {
+  if (!name) return "";
+  return maskByKeepEnds(
+    name,
+    {
+      start: 1,
+      end: 1,
+      maskChar: "*"
+    },
+    options
+  );
+}
+
+// src/mask/maskPhone.ts
+function maskPhone(phone, options) {
+  if (!phone) return "";
+  if (!/^\d{11}$/.test(phone)) return phone;
+  return maskByKeepEnds(
+    phone,
+    {
+      start: 3,
+      end: 4,
+      maskChar: "*",
+      maskLength: 4
+    },
+    options
+  );
+}
+
+// src/mask/maskFixedPhone.ts
+function maskFixedPhone(phone, options) {
+  if (!phone) return "";
+  const normalized = phone.replace(/[\s-]/g, "");
+  if (!/^\d{10,12}$/.test(normalized)) {
+    return phone;
+  }
+  const areaCodeLength = getAreaCodeLength(
+    phone,
+    normalized
+  );
+  return maskByKeepEnds(
+    normalized,
+    {
+      start: areaCodeLength,
+      end: 4,
+      maskChar: "*"
+    },
+    options
+  );
+}
+function getAreaCodeLength(phone, normalized) {
+  const areaCodeMatch = phone.match(/^(\d{3,4})-/);
+  if (areaCodeMatch) {
+    return areaCodeMatch[1].length;
+  }
+  if (normalized.length === 10) {
+    return 3;
+  }
+  return isThreeDigitAreaCode(normalized) ? 3 : 4;
+}
+function isThreeDigitAreaCode(value) {
+  return /^(010|020|021|022|023|024|025|027|028|029)/.test(
+    value
+  );
+}
+
+// src/mask/maskEmail.ts
+function maskEmail(email, options) {
+  if (!email) return "";
+  const [name, domain] = email.split("@");
+  if (!name || !domain) return email;
+  const masked = maskByKeepEnds(
+    name,
+    {
+      start: 2,
+      end: 0,
+      maskChar: "*",
+      maskLength: 4
+    },
+    options
+  );
+  return `${masked}@${domain}`;
+}
+
+// src/mask/maskIdCard.ts
+function maskIdCard(idCard, options) {
+  if (!idCard) return "";
+  if (idCard.length <= 8) return idCard;
+  return maskByKeepEnds(
+    idCard,
+    {
+      start: 4,
+      end: 4,
+      maskChar: "*",
+      maskLength: 10
+    },
+    options
+  );
+}
+
+// src/mask/maskBankCard.ts
+function maskBankCard(cardNo, options) {
+  if (!cardNo) return "";
+  const normalized = cardNo.replace(/[\s-]/g, "");
+  if (!/^\d{10,30}$/.test(normalized)) {
+    return cardNo;
+  }
+  return maskByKeepEnds(
+    normalized,
+    {
+      start: 6,
+      end: 4,
+      maskChar: "*"
+    },
+    options
+  );
+}
+
+// src/mask/maskAddress.ts
+function maskAddress(address, options = {}) {
+  var _a, _b;
+  if (!address) return "";
+  const keepLength = (_a = options.keepLength) != null ? _a : getRegionEndIndex(address);
+  const maskChar = options.maskChar || "*";
+  const maskLength = Math.max(
+    0,
+    Math.floor((_b = options.maskLength) != null ? _b : 4)
+  );
+  return address.slice(0, keepLength) + maskChar.repeat(maskLength);
+}
+function getRegionEndIndex(address) {
+  const regionMatch = address.match(
+    /^(.+?(省|自治区|特别行政区))?(.+?(市|自治州|地区|盟))?(.+?(区|县|自治县|旗|自治旗|市))/
+  );
+  if (regionMatch) {
+    return regionMatch[0].length;
+  }
+  return Math.min(6, address.length);
+}
+
+// src/mask/maskPassport.ts
+function maskPassport(passport, options) {
+  if (!passport) return "";
+  return maskByKeepEnds(
+    passport,
+    {
+      start: 2,
+      end: 2,
+      maskChar: "*"
+    },
+    options
+  );
+}
+
+// src/mask/maskCarPlate.ts
+function maskCarPlate(plate, options) {
+  if (!plate) return "";
+  return maskByKeepEnds(
+    plate,
+    {
+      start: 2,
+      end: 1,
+      maskChar: "*"
+    },
+    options
+  );
+}
+
+// src/mask/maskIp.ts
+function maskIp(ip, options = {}) {
+  if (!ip) return "";
+  if (ip.includes(":")) {
+    return maskIpv6(ip, options);
+  }
+  return maskIpv4(ip, options);
+}
+function maskIpv4(ip, options) {
+  var _a;
+  const segments = ip.split(".");
+  if (segments.length !== 4 || segments.some((segment) => !isIpv4Segment(segment))) {
+    return ip;
+  }
+  const target = Math.min(
+    Math.max((_a = options.segment) != null ? _a : 3, 0),
+    3
+  );
+  segments[target] = options.maskChar || "*";
+  return segments.join(".");
+}
+function maskIpv6(ip, options) {
+  var _a;
+  const segments = ip.split(":");
+  if (segments.length < 3) return ip;
+  const target = Math.min(
+    Math.max(
+      (_a = options.segment) != null ? _a : segments.length - 1,
+      0
+    ),
+    segments.length - 1
+  );
+  segments[target] = options.maskChar || "*";
+  return segments.join(":");
+}
+function isIpv4Segment(segment) {
+  if (!/^\d+$/.test(segment)) return false;
+  const value = Number(segment);
+  return value >= 0 && value <= 255;
+}
+
+// src/mask/maskAccount.ts
+function maskAccount(account, options) {
+  if (!account) return "";
+  return maskByKeepEnds(
+    account,
+    {
+      start: 2,
+      end: 2,
+      maskChar: "*"
+    },
+    options
+  );
+}
+
+// src/mask/maskSecret.ts
+function maskSecret(secret, options) {
+  if (!secret) return "";
+  return maskByKeepEnds(
+    secret,
+    {
+      start: 4,
+      end: 4,
+      maskChar: "*",
+      maskLength: 6
+    },
+    options
+  );
+}
+
+// src/regexp/index.ts
+var REGEXP_PHONE = /^1[3-9]\d{9}$/;
+var REGEXP_FIXED_PHONE = /^0\d{2,3}-?\d{7,8}$/;
+var REGEXP_EMAIL = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
+var REGEXP_ID_CARD = /^[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]$/;
+var REGEXP_BANK_CARD = /^\d{10,30}$/;
+var REGEXP_PASSPORT = /^([A-Za-z]\d{8}|[A-Za-z]{2}\d{7})$/;
+var REGEXP_CAR_PLATE = /^[\u4e00-\u9fa5][A-Z][A-Z0-9]{5,6}$/;
+var REGEXP_URL = /^https?:\/\/[^\s/$.?#].[^\s]*$/i;
+var REGEXP_IPV4 = /^(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d{2}|[1-9]?\d)){3}$/;
+var REGEXP_IPV6 = /^(([0-9A-Fa-f]{1,4}:){7}[0-9A-Fa-f]{1,4}|(([0-9A-Fa-f]{1,4}:){1,7}:)|(([0-9A-Fa-f]{1,4}:){1,6}:[0-9A-Fa-f]{1,4})|(([0-9A-Fa-f]{1,4}:){1,5}(:[0-9A-Fa-f]{1,4}){1,2})|(([0-9A-Fa-f]{1,4}:){1,4}(:[0-9A-Fa-f]{1,4}){1,3})|(([0-9A-Fa-f]{1,4}:){1,3}(:[0-9A-Fa-f]{1,4}){1,4})|(([0-9A-Fa-f]{1,4}:){1,2}(:[0-9A-Fa-f]{1,4}){1,5})|([0-9A-Fa-f]{1,4}:)((:[0-9A-Fa-f]{1,4}){1,6})|:(:([0-9A-Fa-f]{1,4}){1,7}|:))$/;
+var REGEXP_PORT = /^([0-9]|[1-9]\d{1,3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$/;
+var REGEXP_CHINESE = /^[\u4e00-\u9fa5]+$/;
+var REGEXP_POSTAL_CODE = /^[1-9]\d{5}$/;
+var REGEXP_QQ = /^[1-9]\d{4,10}$/;
+var REGEXP_USERNAME = /^[A-Za-z][A-Za-z0-9_]{3,19}$/;
+var REGEXP_PASSWORD = /^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d\S]{8,20}$/;
+var REGEXP_STRONG_PASSWORD = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,20}$/;
+var REGEXP_INTEGER = /^-?\d+$/;
+var REGEXP_POSITIVE_INTEGER = /^[1-9]\d*$/;
+var REGEXP_DECIMAL = /^-?(0|[1-9]\d*)(\.\d+)?$/;
+var REGEXP_AMOUNT = /^(0|[1-9]\d*)(\.\d{1,2})?$/;
+var regexp = {
+  phone: REGEXP_PHONE,
+  fixedPhone: REGEXP_FIXED_PHONE,
+  email: REGEXP_EMAIL,
+  idCard: REGEXP_ID_CARD,
+  bankCard: REGEXP_BANK_CARD,
+  passport: REGEXP_PASSPORT,
+  carPlate: REGEXP_CAR_PLATE,
+  url: REGEXP_URL,
+  ipv4: REGEXP_IPV4,
+  ipv6: REGEXP_IPV6,
+  port: REGEXP_PORT,
+  chinese: REGEXP_CHINESE,
+  postalCode: REGEXP_POSTAL_CODE,
+  qq: REGEXP_QQ,
+  username: REGEXP_USERNAME,
+  password: REGEXP_PASSWORD,
+  strongPassword: REGEXP_STRONG_PASSWORD,
+  integer: REGEXP_INTEGER,
+  positiveInteger: REGEXP_POSITIVE_INTEGER,
+  decimal: REGEXP_DECIMAL,
+  amount: REGEXP_AMOUNT
+};
+function testRegexp(value, pattern) {
+  pattern.lastIndex = 0;
+  return pattern.test(value);
+}
+var isPhone = (value) => testRegexp(value, REGEXP_PHONE);
+var isFixedPhone = (value) => testRegexp(value, REGEXP_FIXED_PHONE);
+var isEmail = (value) => testRegexp(value, REGEXP_EMAIL);
+var isIdCard = (value) => testRegexp(value, REGEXP_ID_CARD);
+var isBankCard = (value) => testRegexp(value, REGEXP_BANK_CARD);
+var isPassport = (value) => testRegexp(value, REGEXP_PASSPORT);
+var isCarPlate = (value) => testRegexp(value, REGEXP_CAR_PLATE);
+var isUrl = (value) => testRegexp(value, REGEXP_URL);
+var isIpv4 = (value) => testRegexp(value, REGEXP_IPV4);
+var isIpv6 = (value) => testRegexp(value, REGEXP_IPV6);
+var isPort = (value) => testRegexp(value, REGEXP_PORT);
+var isChinese = (value) => testRegexp(value, REGEXP_CHINESE);
+var isPostalCode = (value) => testRegexp(value, REGEXP_POSTAL_CODE);
+var isQq = (value) => testRegexp(value, REGEXP_QQ);
+var isUsername = (value) => testRegexp(value, REGEXP_USERNAME);
+var isPassword = (value) => testRegexp(value, REGEXP_PASSWORD);
+var isStrongPassword = (value) => testRegexp(value, REGEXP_STRONG_PASSWORD);
+var isInteger = (value) => testRegexp(value, REGEXP_INTEGER);
+var isPositiveInteger = (value) => testRegexp(value, REGEXP_POSITIVE_INTEGER);
+var isDecimal = (value) => testRegexp(value, REGEXP_DECIMAL);
+var isAmount = (value) => testRegexp(value, REGEXP_AMOUNT);
+
+// src/cache/index.ts
+function createCache(options = {}) {
+  var _a;
+  const prefix = (_a = options.prefix) != null ? _a : "szkj:cache:";
+  const memory = /* @__PURE__ */ new Map();
+  const resolveKey = (key) => `${prefix}${key}`;
+  const unresolveKey = (key) => key.startsWith(prefix) ? key.slice(prefix.length) : key;
+  const getExpiresAt = (ttl = options.ttl) => {
+    if (typeof ttl !== "number") return null;
+    return Date.now() + Math.max(0, ttl);
+  };
+  const read = (resolvedKey) => {
+    if (!options.storage) {
+      return memory.get(resolvedKey);
+    }
+    const raw = options.storage.getItem(resolvedKey);
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      options.storage.removeItem(resolvedKey);
+      return void 0;
+    }
+  };
+  const write = (resolvedKey, record) => {
+    if (!options.storage) {
+      memory.set(resolvedKey, record);
+      return;
+    }
+    options.storage.setItem(
+      resolvedKey,
+      JSON.stringify(record)
+    );
+  };
+  const removeResolved = (resolvedKey) => {
+    if (!options.storage) {
+      memory.delete(resolvedKey);
+      return;
+    }
+    options.storage.removeItem(resolvedKey);
+  };
+  const isExpired = (record) => typeof record.expiresAt === "number" && record.expiresAt <= Date.now();
+  const getResolvedKeys = () => {
+    if (!options.storage) {
+      return Array.from(memory.keys()).filter(
+        (key) => key.startsWith(prefix)
+      );
+    }
+    const keys2 = [];
+    for (let index = 0; index < options.storage.length; index += 1) {
+      const key = options.storage.key(index);
+      if (key == null ? void 0 : key.startsWith(prefix)) {
+        keys2.push(key);
+      }
+    }
+    return keys2;
+  };
+  const get2 = (key) => {
+    const resolvedKey = resolveKey(key);
+    const record = read(resolvedKey);
+    if (!record) return void 0;
+    if (isExpired(record)) {
+      removeResolved(resolvedKey);
+      return void 0;
+    }
+    return record.value;
+  };
+  const keys = () => getResolvedKeys().reduce((result, key) => {
+    const record = read(key);
+    if (!record || isExpired(record)) {
+      removeResolved(key);
+      return result;
+    }
+    result.push(unresolveKey(key));
+    return result;
+  }, []);
+  return {
+    set(key, value, setOptions = {}) {
+      write(resolveKey(key), {
+        value,
+        expiresAt: getExpiresAt(setOptions.ttl)
+      });
+    },
+    get: get2,
+    has(key) {
+      return get2(key) !== void 0;
+    },
+    remove(key) {
+      removeResolved(resolveKey(key));
+    },
+    clear() {
+      getResolvedKeys().forEach(removeResolved);
+    },
+    keys,
+    size() {
+      return keys().length;
+    }
+  };
+}
+var cache = createCache();
+var { sm2, sm4 } = smCrypto__default.default;
+function createCrypto(options = {}) {
+  return {
+    encrypt(value, secret) {
+      return encrypt(
+        value,
+        getRequiredKey(secret != null ? secret : options.aesKey, "AES key"),
+        options.aesOptions
+      );
+    },
+    decrypt(value, secret) {
+      return decrypt(
+        value,
+        getRequiredKey(secret != null ? secret : options.aesKey, "AES key"),
+        options.aesOptions
+      );
+    },
+    encryptAes(value, secret) {
+      return encryptAes(
+        value,
+        getRequiredKey(secret != null ? secret : options.aesKey, "AES key"),
+        options.aesOptions
+      );
+    },
+    decryptAes(value, secret) {
+      return decryptAes(
+        value,
+        getRequiredKey(secret != null ? secret : options.aesKey, "AES key"),
+        options.aesOptions
+      );
+    },
+    encryptRsa(value, publicKey) {
+      return encryptRsa(
+        value,
+        getRequiredKey(
+          publicKey != null ? publicKey : options.rsaPublicKey,
+          "RSA public key"
+        )
+      );
+    },
+    decryptRsa(value, privateKey) {
+      return decryptRsa(
+        value,
+        getRequiredKey(
+          privateKey != null ? privateKey : options.rsaPrivateKey,
+          "RSA private key"
+        )
+      );
+    },
+    encryptSm2(value, publicKey) {
+      return encryptSm2(
+        value,
+        getRequiredKey(
+          publicKey != null ? publicKey : options.sm2PublicKey,
+          "SM2 public key"
+        ),
+        options.sm2Options
+      );
+    },
+    decryptSm2(value, privateKey) {
+      return decryptSm2(
+        value,
+        getRequiredKey(
+          privateKey != null ? privateKey : options.sm2PrivateKey,
+          "SM2 private key"
+        ),
+        options.sm2Options
+      );
+    },
+    encryptSm4(value, key) {
+      return encryptSm4(
+        value,
+        getRequiredKey(key != null ? key : options.sm4Key, "SM4 key"),
+        options.sm4Options
+      );
+    },
+    decryptSm4(value, key) {
+      return decryptSm4(
+        value,
+        getRequiredKey(key != null ? key : options.sm4Key, "SM4 key"),
+        options.sm4Options
+      );
+    }
+  };
+}
+function encrypt(value, secret, options) {
+  return encryptAes(value, secret, options);
+}
+function decrypt(value, secret, options) {
+  return decryptAes(value, secret, options);
+}
+function encryptAes(value, secret, options) {
+  return CryptoJS__default.default.AES.encrypt(
+    value,
+    getAesKey(secret, options),
+    getAesOptions(options)
+  ).toString();
+}
+function decryptAes(value, secret, options) {
+  return CryptoJS__default.default.AES.decrypt(
+    value,
+    getAesKey(secret, options),
+    getAesOptions(options)
+  ).toString(CryptoJS__default.default.enc.Utf8);
+}
+function encryptRsa(value, publicKey) {
+  const rsa = createRsa({
+    publicKey
+  });
+  const encrypted = rsa.encryptLong(value);
+  if (!encrypted) {
+    throw new Error("RSA encrypt failed");
+  }
+  return encrypted;
+}
+function decryptRsa(value, privateKey) {
+  const rsa = createRsa({
+    privateKey
+  });
+  const decrypted = rsa.decryptLong(value);
+  if (!decrypted) {
+    throw new Error("RSA decrypt failed");
+  }
+  return decrypted;
+}
+function encryptSm2(value, publicKey, options = {}) {
+  var _a;
+  return sm2.doEncrypt(
+    value,
+    publicKey,
+    (_a = options.cipherMode) != null ? _a : 1
+  );
+}
+function decryptSm2(value, privateKey, options = {}) {
+  var _a;
+  return sm2.doDecrypt(
+    value,
+    privateKey,
+    (_a = options.cipherMode) != null ? _a : 1
+  );
+}
+function encryptSm4(value, key, options = {}) {
+  return sm4.encrypt(value, key, options);
+}
+function decryptSm4(value, key, options = {}) {
+  return sm4.decrypt(value, key, options);
+}
+function md5(value) {
+  return CryptoJS__default.default.MD5(value).toString();
+}
+function sha256(value) {
+  return CryptoJS__default.default.SHA256(value).toString();
+}
+function toBase64(value) {
+  return CryptoJS__default.default.enc.Base64.stringify(
+    CryptoJS__default.default.enc.Utf8.parse(value)
+  );
+}
+function fromBase64(value) {
+  return CryptoJS__default.default.enc.Base64.parse(value).toString(
+    CryptoJS__default.default.enc.Utf8
+  );
+}
+function getAesKey(secret, options) {
+  if ((options == null ? void 0 : options.keyMode) === "passphrase") {
+    return secret;
+  }
+  return CryptoJS__default.default.enc.Utf8.parse(secret);
+}
+function getAesOptions(options) {
+  var _a, _b;
+  if ((options == null ? void 0 : options.keyMode) === "passphrase") {
+    return {};
+  }
+  const aesOptions = {
+    mode: CryptoJS__default.default.mode[(_a = options == null ? void 0 : options.mode) != null ? _a : "ECB"],
+    padding: CryptoJS__default.default.pad[(_b = options == null ? void 0 : options.padding) != null ? _b : "Pkcs7"]
+  };
+  if (options == null ? void 0 : options.iv) {
+    aesOptions.iv = CryptoJS__default.default.enc.Utf8.parse(options.iv);
+  }
+  return aesOptions;
+}
+function createRsa(options) {
+  const EncryptLong = getEncryptLong();
+  const rsa = new EncryptLong();
+  if (options.publicKey) {
+    rsa.setPublicKey(options.publicKey);
+  }
+  if (options.privateKey) {
+    rsa.setPrivateKey(options.privateKey);
+  }
+  return rsa;
+}
+function getEncryptLong() {
+  if (typeof window === "undefined") {
+    throw new Error("RSA is only available in browser environments");
+  }
+  const requireFn = getRequire();
+  if (!requireFn) {
+    throw new Error("RSA is only available in CommonJS-compatible environments");
+  }
+  const module = requireFn("encryptlong");
+  return "default" in module ? module.default : module;
+}
+function getRequire() {
+  return typeof __require === "function" ? __require : void 0;
+}
+function getRequiredKey(key, name) {
+  if (!key) {
+    throw new Error(`${name} is required`);
+  }
+  return key;
+}
+
+// src/date/index.ts
+function toDate(value) {
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  return new Date(value);
+}
+function isValidDate(value) {
+  return !Number.isNaN(toDate(value).getTime());
+}
+function formatDate(value, pattern = "YYYY-MM-DD HH:mm:ss") {
+  const date = toDate(value);
+  if (Number.isNaN(date.getTime())) return "";
+  const tokens = {
+    YYYY: String(date.getFullYear()),
+    YY: String(date.getFullYear()).slice(-2),
+    MM: pad(date.getMonth() + 1),
+    M: String(date.getMonth() + 1),
+    DD: pad(date.getDate()),
+    D: String(date.getDate()),
+    HH: pad(date.getHours()),
+    H: String(date.getHours()),
+    mm: pad(date.getMinutes()),
+    m: String(date.getMinutes()),
+    ss: pad(date.getSeconds()),
+    s: String(date.getSeconds()),
+    SSS: pad(date.getMilliseconds(), 3)
+  };
+  return pattern.replace(
+    /YYYY|YY|SSS|MM|M|DD|D|HH|H|mm|m|ss|s/g,
+    (token) => tokens[token]
+  );
+}
+function startOfDay(value) {
+  const date = toDate(value);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+function endOfDay(value) {
+  const date = toDate(value);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+function addDays(value, amount) {
+  const date = toDate(value);
+  date.setDate(date.getDate() + amount);
+  return date;
+}
+function diffDays(left, right) {
+  return Math.trunc(
+    (toDate(left).getTime() - toDate(right).getTime()) / 864e5
+  );
+}
+function diffHours(left, right) {
+  return Math.trunc(
+    (toDate(left).getTime() - toDate(right).getTime()) / 36e5
+  );
+}
+function fromNow(value, now = /* @__PURE__ */ new Date()) {
+  const diff = toDate(value).getTime() - toDate(now).getTime();
+  const absDiff = Math.abs(diff);
+  const suffix = diff >= 0 ? "\u540E" : "\u524D";
+  if (absDiff < 6e4) return "\u521A\u521A";
+  const units = [
+    ["\u5E74", 31536e6],
+    ["\u4E2A\u6708", 2592e6],
+    ["\u5929", 864e5],
+    ["\u5C0F\u65F6", 36e5],
+    ["\u5206\u949F", 6e4]
+  ];
+  const unit = units.find(([, size]) => absDiff >= size);
+  if (!unit) return "\u521A\u521A";
+  return `${Math.floor(absDiff / unit[1])}${unit[0]}${suffix}`;
+}
+function pad(value, length = 2) {
+  return String(value).padStart(length, "0");
+}
+
+// src/number/index.ts
+function toFixedSafe(value, precision = 2) {
+  const scale = 10 ** precision;
+  const rounded = Math.round((value + Number.EPSILON) * scale) / scale;
+  return rounded.toFixed(precision);
+}
+function formatThousands(value, separator = ",") {
+  const [integer, decimal] = String(value).split(".");
+  const sign = integer.startsWith("-") ? "-" : "";
+  const normalized = sign ? integer.slice(1) : integer;
+  const formatted = normalized.replace(
+    /\B(?=(\d{3})+(?!\d))/g,
+    separator
+  );
+  return `${sign}${formatted}${decimal ? `.${decimal}` : ""}`;
+}
+function formatMoney(value, options = {}) {
+  const {
+    precision = 2,
+    symbol = "\xA5",
+    thousand = ",",
+    decimal = "."
+  } = options;
+  const fixed = toFixedSafe(value, precision);
+  const formatted = formatThousands(fixed, thousand);
+  return `${symbol}${formatted.replace(".", decimal)}`;
+}
+function formatPercent(value, options = {}) {
+  const {
+    precision = 2,
+    multiplier = 100
+  } = options;
+  return `${toFixedSafe(value * multiplier, precision)}%`;
+}
+function formatFileSize(bytes, precision = 2) {
+  if (!Number.isFinite(bytes)) return "";
+  if (bytes <= 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const index = Math.min(
+    Math.floor(Math.log(bytes) / Math.log(1024)),
+    units.length - 1
+  );
+  const value = bytes / 1024 ** index;
+  return `${toFixedSafe(value, index === 0 ? 0 : precision)} ${units[index]}`;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+// src/tree/index.ts
+var defaultTreeOptions = {
+  idKey: "id",
+  parentKey: "parentId",
+  childrenKey: "children"
+};
+function listToTree(list, options = {}) {
+  const config = getTreeOptions(options);
+  const nodeMap = /* @__PURE__ */ new Map();
+  const roots = [];
+  list.forEach((item) => {
+    nodeMap.set(item[config.idKey], {
+      ...item,
+      [config.childrenKey]: []
+    });
+  });
+  nodeMap.forEach((node) => {
+    const parentId = node[config.parentKey];
+    const parent = nodeMap.get(parentId);
+    if (parent) {
+      getChildren(parent, config.childrenKey).push(node);
+      return;
+    }
+    roots.push(node);
+  });
+  return roots;
+}
+function treeToList(tree, options = {}) {
+  const config = getTreeOptions(options);
+  const result = [];
+  walkTree(tree, (node) => {
+    const {
+      [config.childrenKey]: _children,
+      ...rest
+    } = node;
+    result.push(rest);
+  }, config.childrenKey);
+  return result;
+}
+function findTreeNode(tree, predicate, options = {}) {
+  const config = getTreeOptions(options);
+  for (const node of tree) {
+    if (predicate(node)) return node;
+    const found = findTreeNode(
+      getChildren(node, config.childrenKey),
+      predicate,
+      config
+    );
+    if (found) return found;
+  }
+  return void 0;
+}
+function filterTree(tree, predicate, options = {}) {
+  const config = getTreeOptions(options);
+  return tree.reduce((result, node) => {
+    const children = filterTree(
+      getChildren(node, config.childrenKey),
+      predicate,
+      config
+    );
+    if (predicate(node) || children.length > 0) {
+      result.push({
+        ...node,
+        [config.childrenKey]: children
+      });
+    }
+    return result;
+  }, []);
+}
+function getTreePath(tree, predicate, options = {}) {
+  const config = getTreeOptions(options);
+  for (const node of tree) {
+    if (predicate(node)) return [node];
+    const childPath = getTreePath(
+      getChildren(node, config.childrenKey),
+      predicate,
+      config
+    );
+    if (childPath.length > 0) {
+      return [node, ...childPath];
+    }
+  }
+  return [];
+}
+function getTreeLeaves(tree, options = {}) {
+  const config = getTreeOptions(options);
+  const leaves = [];
+  walkTree(tree, (node) => {
+    if (getChildren(node, config.childrenKey).length === 0) {
+      leaves.push(node);
+    }
+  }, config.childrenKey);
+  return leaves;
+}
+function walkTree(tree, visitor, childrenKey) {
+  tree.forEach((node) => {
+    visitor(node);
+    walkTree(
+      getChildren(node, childrenKey),
+      visitor,
+      childrenKey
+    );
+  });
+}
+function getChildren(node, childrenKey) {
+  const children = node[childrenKey];
+  return Array.isArray(children) ? children : [];
+}
+function getTreeOptions(options) {
+  return {
+    ...defaultTreeOptions,
+    ...options
+  };
+}
+
+// src/storage/index.ts
+var defaultNamespace = "szkj:storage:";
+function createStorage(options = {}) {
+  var _a, _b;
+  const namespace = (_a = options.namespace) != null ? _a : defaultNamespace;
+  const storage = (_b = options.storage) != null ? _b : getDefaultStorage("localStorage");
+  const resolveKey = (key) => `${namespace}${key}`;
+  const unresolveKey = (key) => key.startsWith(namespace) ? key.slice(namespace.length) : key;
+  const getExpiresAt = (ttl = options.ttl) => {
+    if (typeof ttl !== "number") return null;
+    return Date.now() + Math.max(0, ttl);
+  };
+  const encode = (value) => options.encrypt ? options.encrypt(value) : value;
+  const decode = (value) => options.decrypt ? options.decrypt(value) : value;
+  const readRecord = (resolvedKey) => {
+    const raw = storage.getItem(resolvedKey);
+    if (!raw) return void 0;
+    try {
+      return JSON.parse(decode(raw));
+    } catch {
+      storage.removeItem(resolvedKey);
+      return void 0;
+    }
+  };
+  const removeResolved = (resolvedKey) => {
+    storage.removeItem(resolvedKey);
+  };
+  const isExpired = (record) => typeof record.expiresAt === "number" && record.expiresAt <= Date.now();
+  const getResolvedKeys = () => {
+    const keys2 = [];
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (key == null ? void 0 : key.startsWith(namespace)) {
+        keys2.push(key);
+      }
+    }
+    return keys2;
+  };
+  const get2 = (key) => {
+    const resolvedKey = resolveKey(key);
+    const record = readRecord(resolvedKey);
+    if (!record) return void 0;
+    if (isExpired(record)) {
+      removeResolved(resolvedKey);
+      return void 0;
+    }
+    return record.value;
+  };
+  const keys = () => getResolvedKeys().reduce((result, key) => {
+    const record = readRecord(key);
+    if (!record || isExpired(record)) {
+      removeResolved(key);
+      return result;
+    }
+    result.push(unresolveKey(key));
+    return result;
+  }, []);
+  return {
+    set(key, value, setOptions = {}) {
+      const record = {
+        value,
+        expiresAt: getExpiresAt(setOptions.ttl)
+      };
+      storage.setItem(
+        resolveKey(key),
+        encode(JSON.stringify(record))
+      );
+    },
+    get: get2,
+    getRaw(key) {
+      const raw = storage.getItem(resolveKey(key));
+      if (!raw) return void 0;
+      return decode(raw);
+    },
+    has(key) {
+      return get2(key) !== void 0;
+    },
+    remove(key) {
+      removeResolved(resolveKey(key));
+    },
+    clear() {
+      getResolvedKeys().forEach(removeResolved);
+    },
+    keys,
+    size() {
+      return keys().length;
+    }
+  };
+}
+var localStore = createStorage({
+  storage: getDefaultStorage("localStorage")
+});
+var sessionStore = createStorage({
+  namespace: "szkj:session:",
+  storage: getDefaultStorage("sessionStorage")
+});
+function getDefaultStorage(type) {
+  if (typeof globalThis !== "undefined" && type in globalThis) {
+    const storage = globalThis[type];
+    if (storage) return storage;
+  }
+  return createMemoryStorage();
+}
+function createMemoryStorage() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get length() {
+      return store.size;
+    },
+    key(index) {
+      var _a;
+      return (_a = Array.from(store.keys())[index]) != null ? _a : null;
+    },
+    getItem(key) {
+      var _a;
+      return (_a = store.get(key)) != null ? _a : null;
+    },
+    setItem(key, value) {
+      store.set(key, value);
+    },
+    removeItem(key) {
+      store.delete(key);
+    },
+    clear() {
+      store.clear();
+    }
+  };
+}
+
+// src/copy/index.ts
+async function copyText(text, options) {
+  var _a, _b;
+  if (typeof navigator !== "undefined" && navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
+    try {
+      await navigator.clipboard.writeText(text);
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options);
+      return true;
+    } catch (error) {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, error);
+      return false;
+    }
+  }
+  return fallbackCopyText(text, options);
+}
+function fallbackCopyText(text, options) {
+  var _a, _b, _c;
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.top = "-9999px";
+  textarea.style.left = "-9999px";
+  textarea.style.opacity = "0";
+  textarea.setAttribute("readonly", "");
+  textarea.setAttribute("aria-hidden", "true");
+  document.body.appendChild(textarea);
+  textarea.focus();
+  textarea.select();
+  let success = false;
+  try {
+    success = document.execCommand("copy");
+    if (success) {
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options);
+    } else {
+      (_b = options == null ? void 0 : options.onError) == null ? void 0 : _b.call(options, new Error('execCommand("copy") returned false'));
+    }
+  } catch (error) {
+    (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, error);
+  } finally {
+    document.body.removeChild(textarea);
+  }
+  return success;
+}
+
+// src/download/index.ts
+function downloadBlob(blob, options = {}) {
+  const { filename = "download", mimeType } = options;
+  const downloadBlob2 = mimeType ? new Blob([blob], { type: mimeType }) : blob;
+  const url = URL.createObjectURL(downloadBlob2);
+  triggerDownload(url, filename);
+  URL.revokeObjectURL(url);
+}
+function downloadText(text, filename = "download.txt") {
+  const blob = new Blob([text], { type: "text/plain;charset=utf-8" });
+  downloadBlob(blob, { filename });
+}
+function downloadJSON(data, filename = "download.json") {
+  const text = JSON.stringify(data, null, 2);
+  const blob = new Blob([text], { type: "application/json;charset=utf-8" });
+  downloadBlob(blob, { filename });
+}
+async function downloadStream(response, options = {}) {
+  var _a;
+  const { filename = "download", onProgress, onError } = options;
+  try {
+    const contentLength = response.headers.get("content-length");
+    const total = contentLength ? parseInt(contentLength, 10) : 0;
+    const reader = (_a = response.body) == null ? void 0 : _a.getReader();
+    if (!reader) {
+      throw new Error("Response body is not readable");
+    }
+    const chunks = [];
+    let loaded = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      loaded += value.length;
+      onProgress == null ? void 0 : onProgress(loaded, total);
+    }
+    const blob = new Blob(chunks);
+    downloadBlob(blob, { filename });
+  } catch (error) {
+    onError == null ? void 0 : onError(error);
+    throw error;
+  }
+}
+function triggerDownload(url, filename) {
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  link.style.display = "none";
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+}
+
+// src/file/index.ts
+function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      var _a;
+      const result = reader.result;
+      const base64 = (_a = result.split(",")[1]) != null ? _a : result;
+      resolve(base64);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+function base64ToBlob(base64, mimeType = "application/octet-stream") {
+  const byteCharacters = atob(base64);
+  const byteNumbers = new Array(byteCharacters.length);
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteNumbers[i] = byteCharacters.charCodeAt(i);
+  }
+  const byteArray = new Uint8Array(byteNumbers);
+  return new Blob([byteArray], { type: mimeType });
+}
+function getFileExtension(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  return lastDot === -1 ? "" : filename.slice(lastDot + 1).toLowerCase();
+}
+
+// src/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 Array) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Object) {
+    const cloned = {};
+    Object.keys(obj).forEach((key) => {
+      cloned[key] = deepClone(obj[key]);
+    });
+    return cloned;
+  }
+  throw new Error("Unable to copy object");
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (!source) return target;
+  for (const key in source) {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      if (!target[key] || typeof target[key] !== "object") {
+        target[key] = {};
+      }
+      deepMerge(
+        target[key],
+        source[key]
+      );
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+function removeEmptyValues(obj, options = {}) {
+  const {
+    removeNull = true,
+    removeUndefined = true,
+    removeEmptyString = false,
+    removeEmptyArray = false,
+    removeEmptyObject = false
+  } = options;
+  const result = {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (removeUndefined && value === void 0) continue;
+    if (removeNull && value === null) continue;
+    if (removeEmptyString && value === "") continue;
+    if (removeEmptyArray && Array.isArray(value) && value.length === 0) continue;
+    if (removeEmptyObject && typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0) continue;
+    result[key] = value;
+  }
+  return result;
+}
+function pick(obj, keys) {
+  const result = {};
+  keys.forEach((key) => {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  keys.forEach((key) => {
+    delete result[key];
+  });
+  return result;
+}
+function flatten(obj, prefix = "", result = {}) {
+  for (const key in obj) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    const value = obj[key];
+    if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+      flatten(value, newKey, result);
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+function unflatten(obj) {
+  const result = {};
+  for (const key in obj) {
+    const keys = key.split(".");
+    let current = result;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const k = keys[i];
+      if (!(k in current)) {
+        current[k] = {};
+      }
+      current = current[k];
+    }
+    current[keys[keys.length - 1]] = obj[key];
+  }
+  return result;
+}
+
+// src/array/index.ts
+function flattenArray(arr, depth = Infinity) {
+  const result = [];
+  for (const item of arr) {
+    if (Array.isArray(item) && depth > 0) {
+      result.push(...flattenArray(item, depth - 1));
+    } else {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function chunk(arr, size) {
+  if (size <= 0) return [];
+  const result = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+}
+function unique(arr) {
+  return [...new Set(arr)];
+}
+function uniqueBy(arr, key) {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    const value = typeof key === "function" ? key(item) : item[key];
+    if (seen.has(value)) return false;
+    seen.add(value);
+    return true;
+  });
+}
+function groupBy(arr, key) {
+  const result = {};
+  arr.forEach((item) => {
+    const value = typeof key === "function" ? key(item) : item[key];
+    const groupKey = String(value);
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    result[groupKey].push(item);
+  });
+  return result;
+}
+function intersection(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return [...new Set(arr1)].filter((item) => set2.has(item));
+}
+function difference(arr1, arr2) {
+  const set2 = new Set(arr2);
+  return [...new Set(arr1)].filter((item) => !set2.has(item));
+}
+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 sortBy(arr, key, order = "asc") {
+  const result = [...arr];
+  return result.sort((a, b) => {
+    const valueA = typeof key === "function" ? key(a) : a[key];
+    const valueB = typeof key === "function" ? key(b) : b[key];
+    if (valueA === valueB) return 0;
+    if (valueA == null) return order === "asc" ? -1 : 1;
+    if (valueB == null) return order === "asc" ? 1 : -1;
+    if (typeof valueA === "string" && typeof valueB === "string") {
+      const comparison = valueA.localeCompare(valueB);
+      return order === "asc" ? comparison : -comparison;
+    }
+    const numA = typeof valueA === "number" ? valueA : 0;
+    const numB = typeof valueB === "number" ? valueB : 0;
+    if (numA < numB) return order === "asc" ? -1 : 1;
+    if (numA > numB) return order === "asc" ? 1 : -1;
+    return 0;
+  });
+}
+function sum(arr) {
+  return arr.reduce((acc, val) => acc + val, 0);
+}
+function average(arr) {
+  if (arr.length === 0) return 0;
+  return sum(arr) / arr.length;
+}
+function maxBy(arr, key) {
+  if (arr.length === 0) return void 0;
+  return arr.reduce((max, item) => {
+    const value = typeof key === "function" ? key(item) : item[key];
+    const maxValue = typeof key === "function" ? key(max) : max[key];
+    return value > maxValue ? item : max;
+  });
+}
+function minBy(arr, key) {
+  if (arr.length === 0) return void 0;
+  return arr.reduce((min, item) => {
+    const value = typeof key === "function" ? key(item) : item[key];
+    const minValue = typeof key === "function" ? key(min) : min[key];
+    return value < minValue ? item : min;
+  });
+}
+function moveItem(arr, fromIndex, toIndex) {
+  if (fromIndex < 0 || fromIndex >= arr.length || toIndex < 0 || toIndex >= arr.length || fromIndex === toIndex) {
+    return [...arr];
+  }
+  const result = [...arr];
+  const [removed] = result.splice(fromIndex, 1);
+  result.splice(toIndex, 0, removed);
+  return result;
+}
+function swapItems(arr, index1, index2) {
+  if (index1 < 0 || index1 >= arr.length || index2 < 0 || index2 >= arr.length || index1 === index2) {
+    return [...arr];
+  }
+  const result = [...arr];
+  [result[index1], result[index2]] = [result[index2], result[index1]];
+  return result;
+}
+
+// src/string/index.ts
+function isEmpty(str) {
+  if (str === null || str === void 0) return true;
+  if (typeof str !== "string") return false;
+  return str.trim().length === 0;
+}
+function isNotEmpty(str) {
+  return !isEmpty(str);
+}
+function capitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function uncapitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function camelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^[A-Z]/, (char) => char.toLowerCase());
+}
+function pascalCase(str) {
+  const camel = camelCase(str);
+  return capitalize(camel);
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function snakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s\-]+/g, "_").toLowerCase();
+}
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+    const random = Math.random() * 16 | 0;
+    const value = char === "x" ? random : random & 3 | 8;
+    return value.toString(16);
+  });
+}
+function escapeHtml(str) {
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+}
+function unescapeHtml(str) {
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => htmlUnescapes[entity]);
+}
+function parseQueryString(url) {
+  const queryString = url.includes("?") ? url.split("?")[1] : url;
+  const params = new URLSearchParams(queryString);
+  const result = {};
+  params.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
+}
+function stringifyQueryString(params) {
+  const searchParams = new URLSearchParams();
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      searchParams.append(key, String(value));
+    }
+  });
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+function buildUrl(baseUrl, params) {
+  const queryString = stringifyQueryString(params);
+  baseUrl.includes("?") ? "&" : queryString.replace("?", "?");
+  return baseUrl + (baseUrl.includes("?") ? queryString.replace("?", "&") : queryString);
+}
+
+// src/function/index.ts
+function debounce(func, options = {}) {
+  const {
+    wait = 0,
+    leading = false,
+    trailing = true
+  } = options;
+  let timer = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  function invokeFunc() {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function debounced(...args) {
+    const shouldCallLeading = leading && timer === null;
+    lastArgs = args;
+    lastThis = this;
+    if (timer !== null) {
+      clearTimeout(timer);
+    }
+    if (shouldCallLeading) {
+      invokeFunc();
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      if (trailing && lastArgs) {
+        invokeFunc();
+        return;
+      }
+      lastArgs = null;
+      lastThis = null;
+    }, wait);
+    return result;
+  }
+  debounced.cancel = function() {
+    if (timer !== null) {
+      clearTimeout(timer);
+    }
+    lastArgs = null;
+    lastThis = null;
+    timer = null;
+  };
+  debounced.flush = function() {
+    if (timer === null) {
+      return result;
+    }
+    clearTimeout(timer);
+    timer = null;
+    if (trailing && lastArgs) {
+      return invokeFunc();
+    }
+    lastArgs = null;
+    lastThis = null;
+    return result;
+  };
+  debounced.pending = function() {
+    return timer !== null;
+  };
+  return debounced;
+}
+function throttle(func, options = {}) {
+  const {
+    wait = 0,
+    leading = true,
+    trailing = true
+  } = options;
+  let timer = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let lastInvokeTime = null;
+  let result;
+  function invokeFunc(time) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastInvoke = time - (lastInvokeTime != null ? lastInvokeTime : 0);
+    return wait - timeSinceLastInvoke;
+  }
+  function startTimer(delay) {
+    timer = setTimeout(() => {
+      timer = null;
+      if (trailing && lastArgs) {
+        invokeFunc(Date.now());
+        return;
+      }
+      lastArgs = null;
+      lastThis = null;
+    }, delay);
+  }
+  function throttled(...args) {
+    const time = Date.now();
+    lastArgs = args;
+    lastThis = this;
+    if (lastInvokeTime === null) {
+      if (leading) {
+        return invokeFunc(time);
+      }
+      lastInvokeTime = time;
+    }
+    const waitRemaining = remainingWait(time);
+    if (waitRemaining <= 0) {
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      return invokeFunc(time);
+    }
+    if (timer === null && trailing) {
+      startTimer(waitRemaining);
+    }
+    return result;
+  }
+  throttled.cancel = function() {
+    if (timer !== null) {
+      clearTimeout(timer);
+    }
+    lastArgs = null;
+    lastThis = null;
+    lastInvokeTime = null;
+    timer = null;
+  };
+  throttled.flush = function() {
+    if (timer === null) {
+      return result;
+    }
+    clearTimeout(timer);
+    timer = null;
+    if (lastArgs) {
+      return invokeFunc(Date.now());
+    }
+    return result;
+  };
+  throttled.pending = function() {
+    return timer !== null;
+  };
+  return throttled;
+}
+
+// src/get/index.ts
+function get(obj, path, defaultValue) {
+  if (obj == null) return defaultValue;
+  const keys = Array.isArray(path) ? path : path.split(".");
+  let result = obj;
+  for (const key of keys) {
+    if (result == null) {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  return result !== void 0 ? result : defaultValue;
+}
+
+exports.REGEXP_AMOUNT = REGEXP_AMOUNT;
+exports.REGEXP_BANK_CARD = REGEXP_BANK_CARD;
+exports.REGEXP_CAR_PLATE = REGEXP_CAR_PLATE;
+exports.REGEXP_CHINESE = REGEXP_CHINESE;
+exports.REGEXP_DECIMAL = REGEXP_DECIMAL;
+exports.REGEXP_EMAIL = REGEXP_EMAIL;
+exports.REGEXP_FIXED_PHONE = REGEXP_FIXED_PHONE;
+exports.REGEXP_ID_CARD = REGEXP_ID_CARD;
+exports.REGEXP_INTEGER = REGEXP_INTEGER;
+exports.REGEXP_IPV4 = REGEXP_IPV4;
+exports.REGEXP_IPV6 = REGEXP_IPV6;
+exports.REGEXP_PASSPORT = REGEXP_PASSPORT;
+exports.REGEXP_PASSWORD = REGEXP_PASSWORD;
+exports.REGEXP_PHONE = REGEXP_PHONE;
+exports.REGEXP_PORT = REGEXP_PORT;
+exports.REGEXP_POSITIVE_INTEGER = REGEXP_POSITIVE_INTEGER;
+exports.REGEXP_POSTAL_CODE = REGEXP_POSTAL_CODE;
+exports.REGEXP_QQ = REGEXP_QQ;
+exports.REGEXP_STRONG_PASSWORD = REGEXP_STRONG_PASSWORD;
+exports.REGEXP_URL = REGEXP_URL;
+exports.REGEXP_USERNAME = REGEXP_USERNAME;
+exports.addDays = addDays;
+exports.average = average;
+exports.base64ToBlob = base64ToBlob;
+exports.buildUrl = buildUrl;
+exports.cache = cache;
+exports.camelCase = camelCase;
+exports.capitalize = capitalize;
+exports.chunk = chunk;
+exports.clamp = clamp;
+exports.copyText = copyText;
+exports.createCache = createCache;
+exports.createCrypto = createCrypto;
+exports.createStorage = createStorage;
+exports.debounce = debounce;
+exports.decrypt = decrypt;
+exports.decryptAes = decryptAes;
+exports.decryptRsa = decryptRsa;
+exports.decryptSm2 = decryptSm2;
+exports.decryptSm4 = decryptSm4;
+exports.deepClone = deepClone;
+exports.deepMerge = deepMerge;
+exports.diffDays = diffDays;
+exports.diffHours = diffHours;
+exports.difference = difference;
+exports.downloadBlob = downloadBlob;
+exports.downloadJSON = downloadJSON;
+exports.downloadStream = downloadStream;
+exports.downloadText = downloadText;
+exports.encrypt = encrypt;
+exports.encryptAes = encryptAes;
+exports.encryptRsa = encryptRsa;
+exports.encryptSm2 = encryptSm2;
+exports.encryptSm4 = encryptSm4;
+exports.endOfDay = endOfDay;
+exports.escapeHtml = escapeHtml;
+exports.fileToBase64 = fileToBase64;
+exports.filterTree = filterTree;
+exports.findTreeNode = findTreeNode;
+exports.flatten = flatten;
+exports.flattenArray = flattenArray;
+exports.formatDate = formatDate;
+exports.formatFileSize = formatFileSize;
+exports.formatMoney = formatMoney;
+exports.formatPercent = formatPercent;
+exports.formatThousands = formatThousands;
+exports.fromBase64 = fromBase64;
+exports.fromNow = fromNow;
+exports.generateUUID = generateUUID;
+exports.get = get;
+exports.getFileExtension = getFileExtension;
+exports.getTreeLeaves = getTreeLeaves;
+exports.getTreePath = getTreePath;
+exports.groupBy = groupBy;
+exports.intersection = intersection;
+exports.isAmount = isAmount;
+exports.isBankCard = isBankCard;
+exports.isCarPlate = isCarPlate;
+exports.isChinese = isChinese;
+exports.isDecimal = isDecimal;
+exports.isEmail = isEmail;
+exports.isEmpty = isEmpty;
+exports.isFixedPhone = isFixedPhone;
+exports.isIdCard = isIdCard;
+exports.isInteger = isInteger;
+exports.isIpv4 = isIpv4;
+exports.isIpv6 = isIpv6;
+exports.isNotEmpty = isNotEmpty;
+exports.isPassport = isPassport;
+exports.isPassword = isPassword;
+exports.isPhone = isPhone;
+exports.isPort = isPort;
+exports.isPositiveInteger = isPositiveInteger;
+exports.isPostalCode = isPostalCode;
+exports.isQq = isQq;
+exports.isStrongPassword = isStrongPassword;
+exports.isUrl = isUrl;
+exports.isUsername = isUsername;
+exports.isValidDate = isValidDate;
+exports.kebabCase = kebabCase;
+exports.listToTree = listToTree;
+exports.localStore = localStore;
+exports.mask = mask;
+exports.maskAccount = maskAccount;
+exports.maskAddress = maskAddress;
+exports.maskBankCard = maskBankCard;
+exports.maskCarPlate = maskCarPlate;
+exports.maskEmail = maskEmail;
+exports.maskFixedPhone = maskFixedPhone;
+exports.maskIdCard = maskIdCard;
+exports.maskIp = maskIp;
+exports.maskName = maskName;
+exports.maskPassport = maskPassport;
+exports.maskPhone = maskPhone;
+exports.maskSecret = maskSecret;
+exports.maxBy = maxBy;
+exports.md5 = md5;
+exports.minBy = minBy;
+exports.moveItem = moveItem;
+exports.omit = omit;
+exports.parseQueryString = parseQueryString;
+exports.pascalCase = pascalCase;
+exports.pick = pick;
+exports.regexp = regexp;
+exports.removeEmptyValues = removeEmptyValues;
+exports.sessionStore = sessionStore;
+exports.sha256 = sha256;
+exports.shuffle = shuffle;
+exports.snakeCase = snakeCase;
+exports.sortBy = sortBy;
+exports.startOfDay = startOfDay;
+exports.stringifyQueryString = stringifyQueryString;
+exports.sum = sum;
+exports.swapItems = swapItems;
+exports.testRegexp = testRegexp;
+exports.throttle = throttle;
+exports.toBase64 = toBase64;
+exports.toDate = toDate;
+exports.toFixedSafe = toFixedSafe;
+exports.treeToList = treeToList;
+exports.truncate = truncate;
+exports.uncapitalize = uncapitalize;
+exports.unescapeHtml = unescapeHtml;
+exports.unflatten = unflatten;
+exports.unique = unique;
+exports.uniqueBy = uniqueBy;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map