@yh-kit/utils 1.15.0 → 1.16.0

package/dist/utils.js

@@ -1,139 +1,302 @@
-const w = (e, n = "value") => {
-  if (!e || !e.length) return {};
-  const t = {};
-  return e.forEach((r) => {
-    const o = Object.assign({ label: r.label, text: r.label }, r);
-    t[r[n]] = o;
-  }), t;
-}, b = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  toEnumObj: w
-}, Symbol.toStringTag, { value: "Module" })), A = Object.assign(
-  {
-    /**
-     * 数组去重
-     * @param arr 数组
-     * @returns 去重后的数组
-     */
-    unique(e) {
-      return e ? Array.from(new Set(e)) : [];
-    },
-    /**
-     * 判断某元素是否在数组中
-     * @param arr 数组
-     * @param element 查询元素
-     * @returns 是否存在。true 存在；false 不存在
-     */
-    isExist(e, n) {
-      return !e || !n ? !1 : e.indexOf(n) !== -1;
-    },
-    /**
-     * 统计数组中某元素出现的次数：对于大型数组，手动循环的性能略优于 filter 和 reduce。
-     * @param arr 数组
-     * @param target 目标元素
-     * @returns 出现次数
-     */
-    countOfAppear(e, n) {
-      let t = 0;
-      for (const r of e)
-        r === n && t++;
-      return t;
-    },
-    /**
-     * 查找某个元素在数组中重复出现的位置
-     * @param array 数组
-     * @param element 元素
-     * @returns 位置数组
-     */
-    indexsOfAppear(e, n) {
-      let t = -1;
-      const r = [];
-      do
-        t = e.indexOf(n, t + 1), t !== -1 && r.push(t);
-      while (t !== -1);
-      return r;
-    },
-    /**
-     * 数组排序-默认升序
-     * @param arr 数组
-     * @param order 排序方式：asc 升序；desc 降序
-     * @returns 排序后的数组
-     */
-    sort(e, n = "asc") {
-      return e ? e.sort((t, r) => n === "asc" ? t > r ? 1 : -1 : t < r ? 1 : -1) : [];
-    },
-    /**
-     * 数组乱序（洗牌算法）
-     * 1. 从数组的最后一个元素开始，将其与随机位置的元素交换位置。
-     * 2. 然后，从倒数第二个元素开始，将其与随机位置的元素交换位置。
-     * 3. 以此类推，直到第一个元素。
-     * 4. 这样，数组中的元素就会被随机打乱顺序。
-     * 5. 注意，这个算法会改变原数组。如果不想改变原数组，可以先复制一份再进行操作。
-     * 6. 时间复杂度：O(n)
-     * @param arr 数组
-     * @returns
-     */
-    shuffle(e) {
-      if (!e)
-        return [];
-      for (let n = e.length - 1; n > 0; n--) {
-        const t = Math.floor(Math.random() * (n + 1));
-        [e[n], e[t]] = [e[t], e[n]];
-      }
-      return e;
-    },
-    /**
-     * 获取数组中的最大值
-     * @param arr 数组
-     * @returns 最大值
-     */
-    getMaxValue(e) {
-      return e ? Math.max(...e) : 0;
-    },
-    /**
-     * 获取数组中的最小值
-     * @param arr 数组
-     * @returns 最小值
-     */
-    getMinValue(e) {
-      return e ? Math.min(...e) : 0;
-    },
-    /**
-     * 获取数组中的最小值和索引
-     * @param array 数组
-     * @returns 最小值和索引
-     */
-    getMinValueAndIndex(e) {
-      if (e.length === 0) return { value: 0, index: 0 };
-      const n = {
-        /** 最小值 */
-        value: e[0],
-        /** 最小值索引 */
-        index: 0
-      };
-      for (let t = 1, r = e.length; t < r; t++) {
-        const o = e[t];
-        n.value > o && (n.value = o, n.index = t);
-      }
-      return n;
-    },
-    /**
-     * 获取数组中的最大值和索引
-     * @param arr 数组
-     * @returns 最大值和索引
-     */
-    getMaxValueAndIndex(e) {
-      return e.length === 0 ? { value: 0, index: 0 } : e.reduce(
-        (n, t, r) => t < n.value ? { value: t, index: r } : n,
-        { value: e[0], index: 0 }
-      );
+const m = {
+  /**
+   * 统计数组中某元素出现的次数：对于大型数组，手动循环的性能略优于 filter 和 reduce。
+   * @param arr 数组
+   * @param target 目标元素
+   * @returns 出现次数
+   */
+  countOfAppear(e, n) {
+    let t = 0;
+    for (const r of e)
+      r === n && t++;
+    return t;
+  },
+  /**
+   * 查找某个元素在数组中重复出现的位置
+   * @param array 数组
+   * @param element 元素
+   * @returns 位置数组
+   */
+  indexsOfAppear(e, n) {
+    let t = -1;
+    const r = [];
+    do
+      t = e.indexOf(n, t + 1), t !== -1 && r.push(t);
+    while (t !== -1);
+    return r;
+  }
+}, A = {
+  // toEnumObj: handleArrTansferEnumObj,
+  /**
+   * 数组转枚举对象
+   * @param arr 数组
+   * @param valueKey 值键名。不传，默认值为"value"。
+   * @returns 枚举对象。键为数组元素的valueKey值，值为数组元素。
+   */
+  toEnumObj(e, n = "value") {
+    if (!e || !e.length) return {};
+    const t = {};
+    return e.forEach((r) => {
+      const o = Object.assign({ label: r.label, text: r.label }, r);
+      t[r[n]] = o;
+    }), t;
+  }
+}, b = {
+  /**
+   * 判断某元素是否在存在于数组中（indexOf方法）
+   * @param arr 数组
+   * @param element 查询元素
+   * @returns 是否存在。true 存在；false 不存在
+   */
+  isExistByIndexOf(e, n) {
+    return !e || !n ? !1 : e.indexOf(n) !== -1;
+  },
+  /**
+   * 判断某元素是否在存在于数组中（includes方法）
+   * @param arr 数组
+   * @param element 查询元素
+   * @returns 是否存在。true 存在；false 不存在
+   */
+  isExistByIncludes(e, n) {
+    return !e || !n ? !1 : e.includes(n);
+  }
+}, S = {
+  /**
+   * 获取数组中的最大值
+   * @param arr 数组
+   * @returns 最大值
+   */
+  getMaxValue(e) {
+    return e ? Math.max(...e) : 0;
+  },
+  /**
+   * 获取数组中的最小值
+   * @param arr 数组
+   * @returns 最小值
+   */
+  getMinValue(e) {
+    return e ? Math.min(...e) : 0;
+  },
+  /**
+   * 获取数组中的最小值和索引
+   * @param array 数组
+   * @returns 最小值和索引
+   */
+  getMinValueAndIndex(e) {
+    if (e.length === 0) return { value: 0, index: 0 };
+    const n = {
+      /** 最小值 */
+      value: e[0],
+      /** 最小值索引 */
+      index: 0
+    };
+    for (let t = 1, r = e.length; t < r; t++) {
+      const o = e[t];
+      n.value > o && (n.value = o, n.index = t);
+    }
+    return n;
+  },
+  /**
+   * 获取数组中的最大值和索引
+   * @param arr 数组
+   * @returns 最大值和索引
+   */
+  getMaxValueAndIndex(e) {
+    return e.length === 0 ? { value: 0, index: 0 } : e.reduce(
+      (n, t, r) => t < n.value ? { value: t, index: r } : n,
+      { value: e[0], index: 0 }
+    );
+  }
+}, M = {
+  /**
+   * 数组随机打乱-Fisher-Yates算法
+   * @param arr 数组
+   * @returns 随机打乱后的数组
+   *
+   * 注意，这个算法会改变原数组。如果不想改变原数组，可以先复制一份再进行操作。
+   * 时间复杂度：O(n)
+   * 空间复杂度：O(1)
+   */
+  shuffle(e) {
+    if (!e)
+      return [];
+    const n = [...e];
+    for (let t = n.length - 1; t > 0; t--) {
+      const r = Math.floor(Math.random() * (t + 1));
+      [n[t], n[r]] = [n[r], n[t]];
+    }
+    return n;
+  },
+  /**
+   * 数组随机抽样-Fisher-Yates算法前k次迭代，再取前k个元素
+   * @param arr 数组
+   * @param k 抽样次数
+   * @returns 抽样后的数组
+   */
+  sample(e, n) {
+    if (!e)
+      return [];
+    if (n <= 0 || n > e.length)
+      throw new Error("抽样次数必须在1次到数组长度之间");
+    const t = [...e];
+    for (let r = 0; r < n; r++) {
+      const o = Math.floor(Math.random() * (e.length - r));
+      [t[r], t[o]] = [t[o], t[r]];
     }
+    return t.slice(0, n);
+  }
+}, E = {
+  /**
+   * 数组排序-默认升序
+   * @param arr 数组
+   * @param order 排序方式：asc 升序；desc 降序
+   * @returns 排序后的数组
+   */
+  sort(e, n = "asc") {
+    return e ? e.sort((t, r) => n === "asc" ? t > r ? 1 : -1 : t < r ? 1 : -1) : [];
+  }
+}, x = {
+  /**
+   * 数组去重：针对简单类型数据s
+   * 性能	O(n)
+   * @param arr 数组
+   * @returns 去重后的数组
+   */
+  uniqueBySet(e) {
+    if (!e)
+      throw new Error("数组不能为空");
+    const n = e;
+    return Array.from(new Set(n));
+  },
+  /**
+   * 双重循环之 filter + indexOf 数组去重：
+   * 此方法不能去重 NaN 值，也不能去重对象类型数据。
+   * 性能	O(n²)，每次 indexOf 都是 O(n) 操作
+   * @param arr 数组
+   * @returns 去重后的数组
+   */
+  uniqueByFilter(e) {
+    if (!e)
+      throw new Error("数组不能为空");
+    return e.filter((t, r, o) => r === o.indexOf(t));
+  },
+  /**
+   * 双重循环之 reduce + includes 数组去重：
+   * 适用于基本类型数据（string、number、boolean），能去重 NaN 值，但不能去重对象类型数据。
+   * 性能	O(n²)，每次 includes 都是 O(n) 操作
+   * @param arr 数组
+   * @returns 去重后的数组
+   */
+  uniqueByReduce(e) {
+    if (!e)
+      throw new Error("数组不能为空");
+    return e.reduce((t, r) => (t.includes(r) || t.push(r), t), []);
   },
-  {
-    ...b
+  /**
+   * 双重循环之 forEach + includes 数组去重：
+   * 适用于基本类型数据（string、number、boolean），能去重 NaN 值，但不能去重对象类型数据。
+   * 性能	O(n²)，每次 includes 都是 O(n) 操作
+   * @param arr 数组
+   * @returns 去重后的数组
+   */
+  uniqueByIncludes(e) {
+    if (!e)
+      throw new Error("数组不能为空");
+    const n = e, t = [];
+    return n.forEach((r) => {
+      t.includes(r) || t.push(r);
+    }), t;
+  },
+  /**
+   * 双重循环之 for + includes 数组去重：
+   * 适用于基本类型数据（string、number、boolean），能去重 NaN 值，但不能去重对象类型数据。
+   * 性能	O(n²)，每次 includes 都是 O(n) 操作
+   * @param arr 数组
+   * @returns 去重后的数组
+   */
+  uniqueByFor(e) {
+    if (!e)
+      throw new Error("数组不能为空");
+    const n = e, t = [];
+    for (let r = 0; r < n.length; r++)
+      t.includes(n[r]) || t.push(n[r]);
+    return t;
+  },
+  /**
+   * Map + 根据指定键去重
+   * 适用类型	对象数组（通过指定键进行去重）
+   * 键值类型	支持 string、number、boolean、Symbol
+   * NaN 处理	✅ 支持（Map 支持 NaN 作为键）
+   * 性能	O(n)，Map 的 has 和 set 操作都是 O(1)
+   * @param arr 数组
+   * @param key 对象的键名
+   * @returns 去重后的数组
+   */
+  uniqueByKey(e, n) {
+    if (!e || !n)
+      throw new Error("数组不能为空或键名不能为空");
+    const t = e, r = /* @__PURE__ */ new Map();
+    return t.filter((o) => r.has(o[n]) ? !1 : (r.set(o[n], !0), !0));
+  },
+  /**
+   * 通用数组去重函数 - 根据选项自动选择去重策略
+   *
+   * @template T - 数组元素类型
+   * @param {T[]} _arr - 待去重的数组
+   * @param {TUniqueOptions<T>} [options={}] - 去重选项
+   * @param {(keyof T)[]} [options.keys] - 按指定键组合去重（适用于对象数组）
+   * @param {(a: T, b: T) => boolean} [options.compareFn] - 自定义比较函数
+   * @returns {T[]} 去重后的数组
+   *
+   * @example
+   * // 基本类型数组（默认使用 Set 去重）
+   * unique([1, 2, 2, 3, 1]); // [1, 2, 3]
+   *
+   * @example
+   * // 对象数组按多个键去重
+   * const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }, { id: 1, name: 'Alice' }];
+   * unique(users, { keys: ['id', 'name'] }); // [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+   *
+   * @example
+   * // 使用自定义比较函数
+   * unique(arr, { compareFn: (a, b) => a.x === b.x && a.y === b.y });
+   *
+   * @throws {Error} 当输入数组为空时抛出错误
+   */
+  unique(e, n = {}) {
+    const { keys: t, compareFn: r } = n;
+    if (!e)
+      throw new Error("数组不能为空");
+    const o = e;
+    if (!t && !r)
+      return this.uniqueBySet(o);
+    if (t) {
+      const s = /* @__PURE__ */ new Map();
+      return o.filter((c) => {
+        const l = t.map((i) => c[i]).join("|");
+        return s.has(l) ? !1 : (s.set(l, !0), !0);
+      });
+    }
+    if (r)
+      return o.filter((s, c, l) => c === l.findIndex((i) => r(s, i)));
   }
-);
-class _ {
+}, B = {
+  // 数组转对象
+  ...A,
+  // 数组去重
+  ...x,
+  // 判断元素是否存在
+  ...b,
+  // 数组排序
+  ...E,
+  // 获取极值
+  ...S,
+  // 统计出现次数
+  ...m,
+  // 数组随机打乱-Fisher-Yates算法
+  ...M
+};
+class k {
   /** Base64 编码表 */
   static BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   /**
@@ -287,7 +450,7 @@ class _ {
     return s;
   }
 }
-const S = {
+const C = {
   /**
    * 检查是否为空字符串
    * @param str 要检查的字符串
@@ -431,7 +594,7 @@ const S = {
   isMobile() {
     return /Mobi|Android|iPhone/i.test(navigator.userAgent);
   }
-}, O = {
+}, H = {
   /**
    * 获取变量的类型
    * @param val 任意变量
@@ -440,7 +603,7 @@ const S = {
   getType(e) {
     return Object.prototype.toString.call(e).replace(/\[object\s(\w+)\]/, "$1");
   }
-}, T = {
+}, $ = {
   /**
    * 通过传入的name获取cookie的值
    * @param name cookie的name
@@ -470,7 +633,7 @@ const S = {
   deleteCookie(e) {
     this.setCookie(e, "", -1);
   }
-}, L = {
+}, j = {
   /**
    * 获取当前时间字符串
    * @param locales 区域设置。如：'zh-CN'，'en-US'，"chinese"。默认'zh-CN'。
@@ -518,7 +681,7 @@ const S = {
           r += 31;
           break;
         case 2:
-          S.isLeapYear(e) ? r += 29 : r += 28;
+          C.isLeapYear(e) ? r += 29 : r += 28;
           break;
         default:
           r += 30;
@@ -543,10 +706,10 @@ const S = {
       else {
         const g = /* @__PURE__ */ new Date();
         g.setDate(g.getDate() - 1);
-        const m = /* @__PURE__ */ new Date();
-        if (m.setDate(m.getDate() - 2), i === g.getMonth() + 1 && h === g.getDate())
+        const w = /* @__PURE__ */ new Date();
+        if (w.setDate(w.getDate() - 2), i === g.getMonth() + 1 && h === g.getDate())
           a = "昨天" + u;
-        else if (i === m.getMonth() + 1 && h === m.getDate())
+        else if (i === w.getMonth() + 1 && h === w.getDate())
           a = "前天" + u;
         else if (f / 36e5 <= 7 * 24) {
           const y = new Array(7);
@@ -585,7 +748,7 @@ const S = {
       new RegExp("(" + r + ")").test(n) && (n = n.replace(RegExp.$1, RegExp.$1.length === 1 ? t[r] : ("00" + t[r]).substr(("" + t[r]).length)));
     return n;
   }
-}, I = {
+}, F = {
   /**
    * 获取元素相对于文档顶部的偏移量（距离）
    * 处理了SVG元素的特殊情况。
@@ -656,7 +819,7 @@ const S = {
   getViewportHeight() {
     return window.innerHeight || document.documentElement.clientHeight || document.body.clientHeight;
   }
-}, k = {
+}, N = {
   /**
    * 将blob对象转化成文件并导出到本地
    * @param blob blob对象
@@ -675,7 +838,7 @@ const S = {
     const t = document.createElement("a");
     t.href = e, t.download = n, document.body.appendChild(t), t.click(), URL.revokeObjectURL(e), document.body.removeChild(t);
   }
-}, j = {
+}, P = {
   /**
    * echarts动画函数
    * @param option echarts配置
@@ -707,7 +870,7 @@ const S = {
       });
     });
   }
-}, H = {
+}, q = {
   /**
    * 将选中的字母数组从A-Z排序：用于试题选择答案的排序实例
    * @param arr 字母数组
@@ -719,7 +882,7 @@ const S = {
       return o < s ? -1 : o > s ? 1 : 0;
     }) : void 0;
   }
-}, $ = {
+}, V = {
   /**
    * 角度（度数）转弧度
    * 在数学和编程里，角度有两种常用单位，分别是度（°）和弧度（rad）。
@@ -805,7 +968,7 @@ const S = {
     return { segments: r, total: o };
   }
 };
-class N {
+class W {
   /**
    * 转换为标准金额格式（带千分位和两位小数）
    * @param num 要转换的数字
@@ -860,7 +1023,7 @@ class N {
     }
   }
 }
-const P = {
+const Y = {
   /**
    * 中文姓名脱敏
    * @param name 姓名
@@ -903,15 +1066,15 @@ const P = {
     }
     return `${e.slice(0, c)}${"*".repeat(e.length - c)}`;
   }
-}, M = (e) => e > 25 || e < 0 ? "" : "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[e], x = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+}, D = (e) => e > 25 || e < 0 ? "" : "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[e], R = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  toLetter: M
-}, Symbol.toStringTag, { value: "Module" })), E = (e) => e.toFixed(2).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ","), C = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  toLetter: D
+}, Symbol.toStringTag, { value: "Module" })), U = (e) => e.toFixed(2).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ","), v = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  toMoney: E
-}, Symbol.toStringTag, { value: "Module" })), F = {
-  ...x,
-  ...C,
+  toMoney: U
+}, Symbol.toStringTag, { value: "Module" })), z = {
+  ...R,
+  ...v,
   /**
    * 判断是否为数字
    * @param val 待判断的值
@@ -920,7 +1083,7 @@ const P = {
   isNumber(e) {
     return typeof e == "number" && !isNaN(e);
   }
-}, V = {
+}, Z = {
   /**
    * 判断对象是否为空
    * @param obj 对象
@@ -951,7 +1114,7 @@ const P = {
       r instanceof Object ? (n[t] = {}, this.deepCopy(r, n[t])) : r instanceof Array ? (n[t] = [], this.deepCopy(r, n[t])) : n[t] = e[t];
     }
   }
-}, W = {
+}, J = {
   /**
    * 脱敏
    * @param phone 电话号码/手机号码
@@ -960,7 +1123,7 @@ const P = {
   desensitize(e) {
     return e ? e.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2") || e.slice(0, 3) + "****" + e.slice(7) : "";
   }
-}, Y = {
+}, X = {
   /**
    * 生成随机颜色
    * @returns 随机颜色值
@@ -984,7 +1147,7 @@ const P = {
   uniqueId() {
     return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
   }
-}, z = {
+}, G = {
   /**
    * 验证手机号
    */
@@ -1021,7 +1184,7 @@ const P = {
    * 验证0.01~0.99正则：最多两位小数。0.1、0.10、0.9、0.90
    */
   decimal: /^0\.(0[1-9]|[1-9][0-9]*)$/
-}, q = {
+}, K = {
   /**
    * 通过key值获取 localStorage 中存储的某个值
    * @param key 获取的key
@@ -1068,7 +1231,7 @@ const P = {
   removeSession(e) {
     sessionStorage.removeItem(e);
   }
-}, Z = {
+}, Q = {
   /**
    * 判断某元素是否在字符串中-比includes()方法更兼容，includes为ES6新增方法，IE不支持。小程序也不支持
    * @param str 字符串
@@ -1151,19 +1314,19 @@ const P = {
       throw new Error("开始位置小于0或结束位置超出字符串长度或开始位置大于结束位置");
     return e.slice(0, n) + "*".repeat(t - n + 1) + e.slice(t);
   }
-}, B = (e) => {
-  const t = new RegExp("[?&]" + e + "=([^&#]*)", "i").exec(window.location.href);
+}, O = (e) => {
+  const t = new RegExp("[?&]" + e + "=([^&#]*)", "gi").exec(window.location.href);
   return t ? decodeURIComponent(t[1]) : null;
 };
-function D(e) {
+function L(e) {
   return new URLSearchParams(window.location.search).get(e);
 }
-const R = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const T = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  getQueryInfoByName: B,
-  getQueryParam: D
-}, Symbol.toStringTag, { value: "Module" })), J = {
-  ...R,
+  getQueryInfoByName: O,
+  getQueryParam: L
+}, Symbol.toStringTag, { value: "Module" })), ee = {
+  ...T,
   /**
    * 获取当前域名
    * @returns 当前url链接的host信息
@@ -1178,7 +1341,7 @@ const R = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   getPath() {
     return window.location.pathname;
   }
-}, X = {
+}, te = {
   /**
    * 处理瀑布流数据，使其竖向瀑布流布局呈现横向瀑布流的展现形式。适用于 column-gap: 20rpx; column-count: 2; 布局的瀑布流
    * @param list 瀑布流数据-数组
@@ -1209,33 +1372,33 @@ const R = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
       if (i < s)
         a.style.left = (o + c) * i + "px", l[i] = a.offsetHeight;
       else {
-        const { index: u, value: d } = A.getMinValueAndIndex(l);
+        const { index: u, value: d } = B.getMinValueAndIndex(l);
         a.style.left = (o + c) * u + "px", a.style.top = d + t + "px", l[u] = a.offsetHeight + t + d;
       }
     }
   }
 };
 export {
-  _ as Base64Utils,
-  N as MoneyFormatter,
-  A as arrayUtils,
-  S as booleanUtils,
-  O as commonUtils,
-  T as cookieUtils,
-  L as dateUtils,
-  I as documentUtils,
-  k as downloadUtils,
-  j as echartsUtils,
-  H as letterUtils,
-  $ as mapUtils,
-  P as nameUtils,
-  F as numberUtils,
-  V as objectUtils,
-  W as phoneUtils,
-  Y as randomUtils,
-  z as regexpUtils,
-  q as storageUtils,
-  Z as stringUtils,
-  J as urlUtils,
-  X as waterfallUtils
+  k as Base64Utils,
+  W as MoneyFormatter,
+  B as arrayUtils,
+  C as booleanUtils,
+  H as commonUtils,
+  $ as cookieUtils,
+  j as dateUtils,
+  F as documentUtils,
+  N as downloadUtils,
+  P as echartsUtils,
+  q as letterUtils,
+  V as mapUtils,
+  Y as nameUtils,
+  z as numberUtils,
+  Z as objectUtils,
+  J as phoneUtils,
+  X as randomUtils,
+  G as regexpUtils,
+  K as storageUtils,
+  Q as stringUtils,
+  ee as urlUtils,
+  te as waterfallUtils
 };