jinbi-utils 1.0.21 → 1.0.22

package/dist/index.umd.js

@@ -0,0 +1,3192 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('axios'), require('pinia')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'axios', 'pinia'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["jinbi-utils"] = {}, global.axios, global.pinia));
+})(this, (function (exports, axios, pinia) { 'use strict';
+
+  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+  var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+
+  var fromTypeMap = {
+      isWxWork: 'wecom',
+      isWeixin: 'wechat',
+      isMobile: 'mobile',
+      isMobileAny: 'mobile',
+  };
+
+  /**
+   * 通用函数
+   * @packageDocumentation
+   * @module Common
+   * @preferred
+   */
+  /**
+   * 延迟函数（Promise 版本）
+   * @param ms - 延迟毫秒数
+   * @returns Promise
+   */
+  function delay(ms) {
+      return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+  }
+  /**
+   * 检测设备是否为移动设备
+   * @returns 是否为移动设备
+   */
+  function deviceDetection() {
+      if (typeof window === 'undefined')
+          return false;
+      var userAgent = navigator.userAgent.toLowerCase();
+      var isMidp = /midp/i.test(userAgent);
+      var isUcweb = /ucweb/i.test(userAgent);
+      var isAndroid = /android/i.test(userAgent);
+      var isIos = /iphone os/i.test(userAgent);
+      var isWinCe = /windows ce/i.test(userAgent);
+      var isWinMobile = /windows mobile/i.test(userAgent);
+      var isRv = /rv:1.2.3.4/i.test(userAgent);
+      return (isMidp || isUcweb || isAndroid || isIos || isWinCe || isWinMobile || isRv);
+  }
+  /**
+   * 判断val 是否是空值
+   #### 使用说明
+   ```
+   isEmpty('') 返回 true
+   isEmpty(null) 返回 true
+   isEmpty(undefined) 返回 true
+   isEmpty(12323) 返回 false
+   ```
+   */
+  function isEmpty(val) {
+      return val === null || val === '' || val === undefined;
+  }
+  // from jinbizhihui
+  // 获取环境变量
+  // export const getEnvValue = (type: string) => {
+  //   return import.meta.env[type]
+  // }
+  var clearLoginData = function () {
+      // 这里做指定的 key 清除 是为了 避免 清除掉 jsapiticket 等一些需要有的字段 防止多次请求
+      localStorage.removeItem('wecom_userinfo');
+      localStorage.removeItem('wecom_token');
+      localStorage.removeItem('projectActive');
+      localStorage.removeItem('loginTime');
+      localStorage.removeItem('projectInfo');
+  };
+  // 获取url中参数
+  var getQueryString = function (url, queryKey) {
+      var reg = new RegExp("&{1}" + queryKey + "\\=[a-zA-Z0-9_-]+", 'g');
+      var matchResult = url.replace(/\?/g, '&').match(reg)[0];
+      return matchResult.substr(matchResult.indexOf('=') + 1);
+  };
+  var getQueryVariable = function (variable) {
+      var query = window.location.search.substring(1);
+      var vars = query.split('&');
+      for (var i = 0; i < vars.length; i++) {
+          var pair = vars[i].split('=');
+          if (pair[0] === variable) {
+              return pair[1];
+          }
+      }
+      return (false);
+  };
+  var getWecomToken = function () {
+      return localStorage.getItem('wecom_token');
+  };
+  // 判断设备类型
+  var getDeviceType = function () {
+      var ua = navigator.userAgent.toLowerCase();
+      var isWxWork = /wxwork/.test(ua); // 企业微信
+      var isWeixin = /micromessenger/.test(ua) && !isWxWork; // 微信，排除企业微信
+      // 使用屏幕宽度判断是否移动设备
+      var isMobileScreen = window.innerWidth <= 768;
+      return {
+          isWxWork: isWxWork,
+          isWeixin: isWeixin,
+          isMobileScreen: isMobileScreen,
+          isMobileAny: isWxWork || isWeixin || isMobileScreen,
+      };
+  };
+  var getFromType = function (res) {
+      var result = 'wecom';
+      for (var key in res) {
+          var value = res[key];
+          if (value) {
+              result = fromTypeMap[key];
+              break;
+          }
+      }
+      return result;
+  };
+  function randomString(e) {
+      e = e || 32;
+      var t = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';
+      var a = t.length;
+      var n = '';
+      for (var i = 0; i < e; i++)
+          n += t.charAt(Math.floor(Math.random() * a));
+      return n;
+  }
+  var getCookie = function (cookieName) {
+      var cookie = '';
+      var cookieArr = document.cookie.split('; ');
+      for (var i = 0; i < cookieArr.length; i++) {
+          var valueArr = cookieArr[i].split('=');
+          if (valueArr[0] === cookieName) {
+              cookie = valueArr[1];
+              break;
+          }
+      }
+      return cookie;
+  };
+  // || 'cc51882c781d8035b98335ccb44787b42dd9d91ba3b85a45ff3e867857a526bfbbddcdc27b8edce9a52882d1838e0b8e6ccf658ed105df9a898b1c977c588bd1'
+  var buildUUID = function () {
+      var hexList = [];
+      for (var i = 0; i <= 15; i++) {
+          hexList[i] = i.toString(16);
+      }
+      var uuid = '';
+      for (var i = 1; i <= 36; i++) {
+          if (i === 9 || i === 14 || i === 19 || i === 24) {
+              uuid += '-';
+          }
+          else if (i === 15) {
+              uuid += 4;
+          }
+          else if (i === 20) {
+              uuid += hexList[(Math.random() * 4) | 8];
+          }
+          else {
+              uuid += hexList[(Math.random() * 16) | 0];
+          }
+      }
+      return uuid.replace(/-/g, '');
+  };
+  var getTicket = function () {
+      return localStorage.getItem('jsapiTicket');
+  };
+  var setTicket = function (jsapiTicket) {
+      return localStorage.setItem('jsapiTicket', jsapiTicket);
+  };
+  var removeTicket = function () {
+      return localStorage.removeItem('jsapiTicket');
+  };
+  var formateTimestamp = function (timestamp, type) {
+      if (type === void 0) { type = 'YYYY年MM月DD日 hh:mm:ss'; }
+      if (!timestamp) {
+          return '-';
+      }
+      var date = new Date(timestamp);
+      var year = date.getFullYear() + '';
+      var month = date.getMonth() + 1;
+      var day = date.getDate();
+      var houre = date.getHours() > 9 ? date.getHours() : '0' + date.getHours();
+      var minute = date.getMinutes() > 9 ? date.getMinutes() : '0' + date.getMinutes();
+      var second = date.getSeconds() > 9 ? date.getSeconds() : '0' + date.getSeconds();
+      var result = type.replace('YYYY', year + '').replace('MM', month + '').replace('DD', day + '').replace('hh', houre + '').replace('mm', minute + '').replace('ss', second + '');
+      return result;
+  };
+  var convertBase64UrlToBlob = function (urlData) {
+      // console.log('urlData', urlData)
+      // 将以base64的图片url数据转换为Blob
+      var bytes = window.atob(urlData.split(',')[1]); // 去掉url的头，并转换为byte
+      // 处理异常,将ascii码小于0的转换为大于0
+      var ab = new ArrayBuffer(bytes.length);
+      var ia = new Uint8Array(ab);
+      for (var i = 0; i < bytes.length; i++) {
+          ia[i] = bytes.charCodeAt(i);
+      }
+      return new Blob([ab], { type: 'image/png' });
+  };
+  var getEnvironment = function () {
+      var isMobile = window.navigator.userAgent.match(/(phone|pad|pod|iPhone|iPod|ios|iPad|Android|Mobile|BlackBerry|IEMobile|MQQBrowser|JUC|Fennec|wOSBrowser|BrowserNG|WebOS|Symbian|Windows Phone)/i); // 是否手机端
+      var isWx = /micromessenger/i.test(navigator.userAgent); // 是否微信
+      var isComWx = /wxwork/i.test(navigator.userAgent); // 是否企业微信
+      if (isComWx && isMobile) { //手机端企业微信
+          return 'com-wx-mobile';
+      }
+      else if (isComWx && !isMobile) { //PC端企业微信
+          return 'com-wx-pc';
+      }
+      else if (isWx && isMobile) { // 手机端微信
+          return 'wx-mobile';
+      }
+      else if (isWx && !isMobile) { // PC端微信
+          return 'wx-pc';
+      }
+      else {
+          return 'other';
+      }
+  };
+  var getIsComWx = function () {
+      var isComWx = /wxwork/i.test(navigator.userAgent); // 是否企业微信
+      return isComWx;
+  };
+  var getIsDevelopment = function () {
+      var result = false;
+      if (location.origin === 'uat2-h5-wecom.hengdayun.com' || location.origin === '127.0.0.1:8081' || location.origin === 'localhost:8081') {
+          result = true;
+      }
+      return result;
+  };
+  // 处理时间，企微不能通过dayjs以及moment处理时间
+  // 过滤数组重复数据
+  var filterRepeat = function (arr, fieldName) {
+      var set = new Set();
+      return arr.filter(function (item) {
+          var key = item[fieldName];
+          if (set.has(key)) {
+              return false;
+          }
+          else {
+              set.add(key);
+              return true;
+          }
+      });
+  };
+  // 将 base64 转换为 Blob
+  var base64ToBlob = function (base64) {
+      var arr = base64.split(","), mime = arr[0].match(/:(.\*?);/)[1], bstr = atob(arr[1]), n = bstr.length, u8arr = new Uint8Array(n);
+      while (n--) {
+          u8arr[n] = bstr.charCodeAt(n);
+      }
+      return new Blob([u8arr], {
+          type: mime,
+      });
+  };
+  // 将 base64 转换为 File
+  var base64ToFile = function (base64, fileName) {
+      var arr = base64.split(",");
+      var mime = arr[0].match(/:(.*);/)[1];
+      var bstr = atob(arr[1]);
+      var n = bstr.length;
+      var u8arr = new Uint8Array(n);
+      while (n--) {
+          u8arr[n] = bstr.charCodeAt(n);
+      }
+      return new File([u8arr], fileName, { type: mime });
+  };
+  // 处理时间，企微不能通过dayjs以及moment处理时间
+  var isImage = function (type) {
+      return /^image\//i.test(type);
+  };
+  // 获取文件数据
+  var getFileData = function (optionName) {
+      var _a = optionName.split(','), _b = _a[0], name = _b === void 0 ? '' : _b, _c = _a[1], url = _c === void 0 ? '' : _c;
+      return {
+          name: decodeURIComponent(name),
+          url: decodeURIComponent(url)
+      };
+  };
+  // 验证是否为数字
+  var validateTwoDecimal = function (v) {
+      if (!v || v === '')
+          return true;
+      return /^(\d+)(\.\d{1,2})?$/.test(v.toString());
+  };
+  // 生成uuid
+  var uuid = function (len, radix) {
+      var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
+      var uuid = [], i;
+      radix = radix || chars.length;
+      if (len) {
+          // Compact form
+          for (i = 0; i < len; i++)
+              uuid[i] = chars[0 | Math.random() * radix];
+      }
+      else {
+          // rfc4122, version 4 form
+          var r = void 0;
+          // rfc4122 requires these characters
+          uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
+          uuid[14] = '4';
+          // Fill in random data.  At i==19 set the high bits of clock sequence as
+          // per rfc4122, sec. 4.1.5
+          for (i = 0; i < 36; i++) {
+              if (!uuid[i]) {
+                  r = 0 | Math.random() * 16;
+                  uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
+              }
+          }
+      }
+      return uuid.join('');
+  };
+  var getToken = function (cacheType, key) {
+      if (key === void 0) { key = 'token'; }
+      var token = '';
+      var cacheTypeToLower = cacheType.toLowerCase();
+      if (cacheTypeToLower === 'localstorage') {
+          token = localStorage.getItem(key) || '';
+      }
+      else if (cacheTypeToLower === 'sessionstorage') {
+          token = sessionStorage.getItem(key) || '';
+      }
+      else {
+          token = localStorage.getItem(key) || sessionStorage.getItem('token') || '';
+      }
+      return token;
+  };
+  var removeToken = function (cacheType, key) {
+      if (key === void 0) { key = 'token'; }
+      var cacheTypeToLower = cacheType.toLowerCase();
+      if (cacheTypeToLower === 'localstorage') {
+          localStorage.removeItem(key);
+      }
+      else if (cacheTypeToLower === 'sessionstorage') {
+          sessionStorage.removeItem(key);
+      }
+      else {
+          localStorage.removeItem(key);
+          sessionStorage.removeItem(key);
+      }
+  };
+
+  /**
+   * 时间处理相关
+   * @packageDocumentation
+   * @module Date
+   * @preferred
+   */
+  /**
+   * 解决ios不支持 new Date('2020-02-02')问题
+   #### 使用说明
+   ```
+    compatibleDate('2020-03-04') 返回 2020/03/04
+    compatibleDate(Date.now()) 返回 Date.now()
+    compatibleDate(new Date()) 返回 new Date()
+    ```
+   */
+  function compatibleDate(date) {
+      if (typeof date === 'string') {
+          return date.replace(/-/g, '/');
+      }
+      return date;
+  }
+  /**
+   * 调用原生 new Date 返回 Date实例 解决ios不支持 yyyy-MM-dd HH:mm:ss 格式new Date
+   #### 使用说明
+   ```
+    newDate() 返回 new Date()
+    newDate('2020-03-04') 返回 new Date('2020-03-04')
+    ```
+   */
+  function newDate(date) {
+      if (!date)
+          return new Date();
+      return new Date(compatibleDate(date));
+  }
+  /**
+   * 格式化时间
+   #### 使用说明
+   ```
+   formatTime() 返回 yyyy-MM-dd HH:mm:ss 格式的当前时间
+   formatTime('2018-02-02 00:00:00') 返回 2018-02-02 00:00:00
+   formatTime('2018-02-02', 'yyyy/MM/dd') 返回 2018/02/02
+   formatTime('2018-02-02 23:50:50', 'yyyy/MM/dd HH:mm:ss') 返回 2018/02/02 23:50:50
+   formatTime('2018-02-02 23:50:50', 'MM/dd HH:mm:ss') 返回 02/02 23:50:50
+   formatTime(new Date('2018-02-02 23:50:50') + 200, 'yyyy/MM/dd HH:mm:ss S') 返回 2018/02/02 23:50:50 200
+   ```
+   */
+  function formatTime(date, fmt) {
+      if (date === void 0) { date = Date.now(); }
+      if (fmt === void 0) { fmt = 'yyyy-MM-dd HH:mm:ss'; }
+      date = compatibleDate(date);
+      date = new Date(date);
+      var o = {
+          'M+': date.getMonth() + 1,
+          'd+': date.getDate(),
+          'h+': date.getHours() % 12 === 0 ? 12 : date.getHours() % 12,
+          'H+': date.getHours(),
+          'm+': date.getMinutes(),
+          's+': date.getSeconds(),
+          'q+': Math.floor((date.getMonth() + 3) / 3),
+          S: date.getMilliseconds(),
+      };
+      if (/(y+)/.test(fmt)) {
+          fmt = fmt.replace(RegExp.$1, ("" + date.getFullYear()).substr(4 - RegExp.$1.length));
+      }
+      Object.keys(o).forEach(function (k) {
+          if (new RegExp("(" + k + ")").test(fmt)) {
+              fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? (o[k]) : (("00" + o[k]).substr(("" + o[k]).length)));
+          }
+      });
+      return fmt;
+  }
+  /**
+   * 格式化相对时间
+   #### 使用说明
+   ```
+   fromNow('') 返回 -
+   fromNow(Date.now() - 2000) 返回 刚刚
+   fromNow(now - 3420 * 1000) 返回 58分钟前面
+   fromNow(now - 3600 * 1000 * 3) 返回 3小时前
+   fromNow(now - 3600 * 1000 * 24 * 1.5) 返回 1天前
+   fromNow(now - day5) 返回 当前时间的5天前日期 格式 yyyy年MM月dd日 HH时mm分ss秒
+   fromNow(Date.now() + 2000) 返回 Date.now() + 2000
+   fromNow('', '', 'defaultValue') 等于 defaultValue
+   ```
+   */
+  function fromNow(time, fmt, defaultValue) {
+      if (fmt === void 0) { fmt = 'yyyy年MM月dd日 HH时mm分ss秒'; }
+      if (defaultValue === void 0) { defaultValue = '-'; }
+      if (isEmpty(time)) {
+          return defaultValue;
+      }
+      time = compatibleDate(time);
+      var d = new Date(time);
+      var now = Date.now();
+      var diff = (now - d.getTime()) / 1000;
+      if (diff < 0) {
+          return time;
+      }
+      if (diff < 30) {
+          return '刚刚';
+      }
+      if (diff < 3600) {
+          return Math.ceil(diff / 60) + "\u5206\u949F\u524D";
+      }
+      if (diff < 3600 * 24) {
+          return Math.floor(diff / 3600) + "\u5C0F\u65F6\u524D";
+      }
+      if (diff < 3600 * 24 * 2) {
+          return '1天前';
+      }
+      return formatTime(time, fmt);
+  }
+  /**
+   * 增加日期天数
+   #### 使用说明
+   ```
+   addDays('') 返回 -
+   addDays('2018-02-02') 返回 2018-02-02
+   addDays('2018-02-02', 2) 返回 2018-02-04
+   addDays('2018-02-02', 2, 'yyyy/MM/dd') 返回 2018/02/04
+   addDays(new Date('2020-03-04'), 2, 'yyyy/MM/dd') 返回 2020/03/06
+   addDays(Date.now(), 2, 'yyyy/MM/dd') 返回 今天 + 2天
+   ```
+   */
+  function addDays(date, days, fmt) {
+      if (days === void 0) { days = 0; }
+      if (fmt === void 0) { fmt = 'yyyy-MM-dd'; }
+      if (isEmpty(date)) {
+          return '-';
+      }
+      date = compatibleDate(date);
+      var d = new Date(date);
+      d.setDate(d.getDate() + Number(days));
+      return formatTime(d, fmt);
+  }
+  // 获取当前时间月份
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+  /* global Reflect, Promise */
+
+  var extendStatics = function(d, b) {
+      extendStatics = Object.setPrototypeOf ||
+          ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+          function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+      return extendStatics(d, b);
+  };
+
+  function __extends(d, b) {
+      extendStatics(d, b);
+      function __() { this.constructor = d; }
+      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  }
+
+  var __assign = function() {
+      __assign = Object.assign || function __assign(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+              s = arguments[i];
+              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+          }
+          return t;
+      };
+      return __assign.apply(this, arguments);
+  };
+
+  function __awaiter(thisArg, _arguments, P, generator) {
+      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+      return new (P || (P = Promise))(function (resolve, reject) {
+          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+          step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+  }
+
+  function __generator(thisArg, body) {
+      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      function step(op) {
+          if (f) throw new TypeError("Generator is already executing.");
+          while (_) try {
+              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+              if (y = 0, t) op = [op[0] & 2, t.value];
+              switch (op[0]) {
+                  case 0: case 1: t = op; break;
+                  case 4: _.label++; return { value: op[1], done: false };
+                  case 5: _.label++; y = op[1]; op = [0]; continue;
+                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                  default:
+                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                      if (t[2]) _.ops.pop();
+                      _.trys.pop(); continue;
+              }
+              op = body.call(thisArg, _);
+          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+      }
+  }
+
+  function __spreadArrays() {
+      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+      for (var r = Array(s), k = 0, i = 0; i < il; i++)
+          for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+              r[k] = a[j];
+      return r;
+  }
+
+  /**
+   * number处理相关
+   * @packageDocumentation
+   * @module Number
+   * @preferred
+   */
+  /**
+   * 格式化字节大小为可读字符串
+   * @param bytes - 字节数
+   * @param decimals - 小数位数，默认为 2
+   * @returns 格式化后的字符串（如 "1.5 MB"）
+   */
+  function formatBytes(bytes, decimals) {
+      if (decimals === void 0) { decimals = 2; }
+      if (bytes === 0)
+          return '0 Bytes';
+      var k = 1024;
+      var dm = decimals < 0 ? 0 : decimals;
+      var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+      var i = Math.floor(Math.log(bytes) / Math.log(k));
+      return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+  }
+  // 默认货币计算选项
+  var DEFAULT_MONEY_OPTIONS = {
+      operation: 'divide',
+      factor: 100,
+      precision: 2,
+      formatAsCurrency: false,
+      currencySymbol: '¥' // 人民币符号
+  };
+  /**
+   * 千分位格式化
+    #### 使用说明
+    ```
+    toThousands(1) => 1
+    toThousands(12345) => 12,345
+    toThousands('12323.12') 返回 '12,323.12'
+    ```
+   */
+  function toThousands(num, defaultValue) {
+      if (defaultValue === void 0) { defaultValue = '-'; }
+      if (isEmpty(num)) {
+          return defaultValue;
+      }
+      var val = num.toString();
+      if (!val.includes('.')) {
+          val += '.';
+      }
+      return val.replace(/\d(?=(\d{3})+\.)/g, function ($0) { return $0 + ","; }).replace(/\.$/, '');
+  }
+  /**
+   * 阿拉伯数组转中文数字
+   #### 使用说明
+   ```
+   convertCurrency(0) 返回 '壹拾贰元壹角贰分'
+   convertCurrency(1234567809) 返回 '壹拾贰亿叁仟肆佰伍拾陆万柒仟捌佰零玖元整'
+   ```
+   * @param {number} money 金额
+   */
+  function convertCurrency(money) {
+      if (money === void 0) { money = ''; }
+      var maxNum = 999999999999999.9999; // 最大处理的数字
+      if (isEmpty(money)) {
+          return '';
+      }
+      if (Number(money) >= maxNum) {
+          // 超出最大处理数字
+          return money;
+      }
+      var cnNums = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
+      var cnIntRadice = ['', '拾', '佰', '仟'];
+      var cnIntUnits = ['', '万', '亿', '兆']; // 对应整数部分扩展单位
+      var cnDecUnits = ['角', '分', '毫', '厘']; // 对应小数部分单位
+      var cnInteger = '整'; // 整数金额时后面跟的字符
+      var cnIntLast = '元'; // 整型完以后的单位
+      var integerNum; // 金额整数部分
+      var decimalNum; // 金额小数部分
+      var chineseStr = ''; // 输出的中文金额字符串
+      var parts; // 分离金额后用的数组，预定义
+      money = parseFloat(money).toString();
+      if (money === '0') {
+          chineseStr = cnNums[0] + cnIntLast + cnInteger;
+          return chineseStr;
+      }
+      // 转换为字符串
+      money = money.toString();
+      if (money.indexOf('.') === -1) {
+          integerNum = money;
+          decimalNum = '';
+      }
+      else {
+          parts = money.split('.');
+          integerNum = parts[0];
+          decimalNum = parts[1].substr(0, 4);
+      }
+      // 获取整型部分转换
+      if (parseInt(integerNum, 10) > 0) {
+          var zeroCount = 0;
+          var intLen = integerNum.length;
+          for (var i = 0; i < intLen; i += 1) {
+              var n = integerNum.substr(i, 1);
+              var p = intLen - i - 1;
+              var q = p / 4;
+              var m = p % 4;
+              if (n === '0') {
+                  zeroCount += 1;
+              }
+              else {
+                  if (zeroCount > 0) {
+                      chineseStr += cnNums[0];
+                  }
+                  // 归零
+                  zeroCount = 0;
+                  chineseStr += cnNums[parseInt(n, 10)] + cnIntRadice[m];
+              }
+              if (m === 0 && zeroCount < 4) {
+                  chineseStr += cnIntUnits[q];
+              }
+          }
+          chineseStr += cnIntLast;
+      }
+      // 小数部分
+      if (decimalNum !== '') {
+          var decLen = decimalNum.length;
+          for (var i = 0; i < decLen; i += 1) {
+              var dn = decimalNum.substr(i, 1);
+              if (dn !== '0') {
+                  chineseStr += cnNums[Number(dn)] + cnDecUnits[i];
+              }
+          }
+      }
+      if (chineseStr === '') {
+          chineseStr += cnNums[0] + cnIntLast + cnInteger;
+      }
+      else if (decimalNum === '') {
+          chineseStr += cnInteger;
+      }
+      return chineseStr;
+  }
+  /**
+   * 格式化小数位
+   #### 使用说明
+   ```
+   formatFloat('1.2345') 返回 '1.23'
+   formatFloat('1.2345', 3) 返回 '1.235'
+   formatFloat('1', 3) 返回 '1.000'
+   ```
+   * @param {*} val 小数
+   * @param {number} [pos=2] 保留的小数位
+   */
+  function formatFloat(val, pos) {
+      if (pos === void 0) { pos = 2; }
+      var f = parseFloat(String(val));
+      if (Number.isNaN(f)) {
+          return '';
+      }
+      f = Math.round(Number(val) * Math.pow(10, pos)) / Math.pow(10, pos); // pow 幂
+      var s = f.toString();
+      var rs = s.indexOf('.');
+      if (rs < 0) {
+          rs = s.length;
+          s += '.';
+      }
+      while (s.length <= rs + pos) {
+          s += '0';
+      }
+      return s;
+  }
+  /**
+   * 向上取整
+   #### 使用说明
+   ```
+   ceil('1.23') 返回 2
+   ceil('1.234', 2) 返回 1.24
+   ceil('1.230', 2) 返回 1.23
+   ```
+   * @param {*} val
+   * @param {number} [pos=2] 保留的小数位
+   */
+  function ceil(val, pos) {
+      if (pos === void 0) { pos = 0; }
+      if (isEmpty(val)) {
+          return val;
+      }
+      var swell = Math.pow(10, pos);
+      var swellVal = Number(val) * swell;
+      var newVal = Math.ceil(swellVal) / swell;
+      return newVal;
+  }
+  /**
+   * 向下取整
+   #### 使用说明
+   ```
+   floor('1.23') 返回 1
+   floor('1.234', 2) 返回 1.23
+   floor('1.230', 2) 返回 1.23
+   ```
+   * @param {*} val
+   * @param {number} [pos=2] 保留的小数位
+   */
+  function floor(val, pos) {
+      if (pos === void 0) { pos = 0; }
+      if (isEmpty(val)) {
+          return val;
+      }
+      var swell = Math.pow(10, pos);
+      var swellVal = Number(val) * swell;
+      return Math.floor(swellVal) / swell;
+  }
+  /**
+   * 格式化货币数字
+   #### 使用说明
+   ```
+   formatMoney(1234) 返回 '12.34'
+   formatMoney(1234, { operation: 'multiply', factor: 100 }) 返回 '123400.00'
+   formatMoney(1234, { formatAsCurrency: true }) 返回 '¥12.34'
+   formatMoney(1234, { formatAsCurrency: true, currencySymbol: '$' }) 返回 '$12.34'
+   formatMoney(1234.567, { precision: 3 }) 返回 '12.346'
+   formatMoney('1,234.56', { operation: 'multiply', factor: 1 }) 返回 '1234.56'
+   ```
+   * @param value 要格式化的值
+   * @param options 格式化选项
+   * @returns 格式化后的字符串
+   */
+  function formatMoney(value, options) {
+      // 先计算值
+      var numericResult = computeMoney(value, options);
+      // 合并选项
+      var mergedOptions = __assign(__assign({}, DEFAULT_MONEY_OPTIONS), options);
+      // 格式化
+      if (mergedOptions.formatter) {
+          // 使用自定义格式化函数
+          return mergedOptions.formatter(numericResult);
+      }
+      // 货币格式化
+      if (mergedOptions.formatAsCurrency) {
+          var formattedNumber = numericResult.toFixed(mergedOptions.precision);
+          // 如果数字超过1000，使用千分位格式化
+          var formattedWithThousands = numericResult >= 1000 ? toThousands(formattedNumber) : formattedNumber;
+          return "" + mergedOptions.currencySymbol + formattedWithThousands;
+      }
+      // 默认格式化
+      return numericResult.toFixed(mergedOptions.precision);
+  }
+  /**
+   * 执行货币计算
+   #### 使用说明
+   ```
+   分转元（除法）
+   computeMoney(1234) 返回 12.34
+   元转分（乘法）
+   computeMoney(12.34, { operation: 'multiply', factor: 100 }) 返回 1234
+   自定义精度
+   computeMoney(1234.567, { precision: 3 }) 返回 12.346
+   处理带有千分位的字符串
+   computeMoney('1,234.56', { operation: 'multiply', factor: 1 }) 返回 1234.56
+   处理空值
+   computeMoney(null) 返回 0
+   ```
+   * @param value 要计算的值
+   * @param options 计算选项
+   * @returns 计算结果
+   */
+  function computeMoney(value, options) {
+      // 合并选项
+      var mergedOptions = __assign(__assign({}, DEFAULT_MONEY_OPTIONS), options);
+      // 处理输入值
+      var numericValue;
+      // 处理可能的各种输入类型
+      if (value === null || value === undefined || value === '') {
+          return 0;
+      }
+      else if (typeof value === 'string') {
+          // 尝试将字符串转换为数字，移除非数字字符（保留小数点和负号）
+          var cleanedStr = value.replace(/[^\d.-]/g, '');
+          numericValue = cleanedStr ? parseFloat(cleanedStr) : 0;
+      }
+      else {
+          numericValue = value;
+      }
+      if (isNaN(numericValue)) {
+          return 0;
+      }
+      // 执行计算
+      var result;
+      if (mergedOptions.operation === 'multiply') {
+          result = numericValue * mergedOptions.factor;
+      }
+      else {
+          // 防止除以0
+          result = mergedOptions.factor !== 0 ? numericValue / mergedOptions.factor : 0;
+      }
+      // 处理精度
+      if (mergedOptions.precision !== undefined) {
+          var multiplier = Math.pow(10, mergedOptions.precision);
+          result = Math.round(result * multiplier) / multiplier;
+      }
+      return result;
+  }
+  /**
+   * 将分转换为元并格式化为货币格式
+   #### 使用说明
+   ```
+   formatCentsToYuan(1234) 返回 '¥12.34'
+   formatCentsToYuan(123456) 返回 '¥1,234.56'
+   formatCentsToYuan(1234, { currencySymbol: '$' }) 返回 '$12.34'
+   formatCentsToYuan('1,234', { precision: 3 }) 返回 '¥12.340'
+   formatCentsToYuan(null) 返回 '¥0.00'
+   ```
+   * @param cents 分值
+   * @param options 格式化选项
+   * @returns 格式化后的字符串
+   */
+  function formatCentsToYuan(cents, options) {
+      return formatMoney(cents, __assign({ operation: 'divide', factor: 100, formatAsCurrency: true }, options));
+  }
+
+  /**
+   * 文件处理相关
+   * @packageDocumentation
+   * @module File
+   * @preferred
+   */
+  /**
+   * 计算文件大小
+   #### 使用说明
+   ```
+   calcFileSize(100) 返回 { size: 100, unit: 'B' }
+   calcFileSize(1024) 返回 { size: 1, unit: 'KB' }
+   calcFileSize(1024, 'KB') 返回 { size: 1, unit: 'MB' }
+   calcFileSize(1126.4, 'mb') 返回 { size: 1.1, unit: 'GB' }
+   calcFileSize(Math.pow(1024, 2), 'kb') 返回 { size: 1, unit: 'GB' }
+   ```
+   * @param size 单位 k
+   * @returns number
+   */
+  function calcFileSize(size, unit) {
+      if (unit === void 0) { unit = 'B'; }
+      var unitList = ['B', 'KB', 'MB', 'GB', 'TB'];
+      var currentUnitIndex = unitList.indexOf(unit.toUpperCase());
+      currentUnitIndex = currentUnitIndex === -1 ? 0 : currentUnitIndex;
+      // todo 单位换算。
+      while (size >= 1024 && currentUnitIndex < unitList.length) {
+          size = size / 1024;
+          currentUnitIndex += 1;
+      }
+      return {
+          size: size,
+          unit: unitList[currentUnitIndex],
+      };
+  }
+  /**
+   * 文件大小转换
+   #### 使用说明
+   ```
+   fileSizeFormat('') 返回 -
+   fileSizeFormat('1024') 返回 1KB
+   fileSizeFormat('1024', 'KB') 返回 1MB
+   fileSizeFormat('2645', 'B') 返回 ceil(2645 / 1024, 2)MB
+   ```
+   * @param {string} str 字符串 单位k
+   */
+  function fileSizeFormat(str, unit, defaultValue) {
+      if (unit === void 0) { unit = 'B'; }
+      if (defaultValue === void 0) { defaultValue = '-'; }
+      if (isEmpty(str)) {
+          return defaultValue;
+      }
+      var o = calcFileSize(parseFloat(str.toString()), unit);
+      return "" + ceil(o.size, 2) + o.unit;
+  }
+  /**
+   * base64转换为file
+   * dataurl base64图片
+   * */
+  function dataURLtoBlob(dataurl) {
+      var mime = dataurl.match(/:(.*?);/)[1];
+      var bytes = window.atob(dataurl.split(',')[1]); // 去掉url的头，并转换为byte
+      // 处理异常,将ascii码小于0的转换为大于0
+      var ab = new ArrayBuffer(bytes.length);
+      var ia = new Uint8Array(ab);
+      for (var i = 0; i < bytes.length; i += 1) {
+          ia[i] = bytes.charCodeAt(i);
+      }
+      return new Blob([ab], { type: mime });
+  }
+  function blobToDataURL(blob) {
+      return new Promise(function (resolve, reject) {
+          var reader = new FileReader();
+          reader.onload = function (e) {
+              if (!e || !e.target) {
+                  reject(e);
+              }
+              else {
+                  resolve(e.target.result);
+              }
+          };
+          reader.onerror = function (err) {
+              reject(err);
+          };
+          reader.readAsDataURL(blob);
+      });
+  }
+  /**
+   * 压缩图片方法
+   * @param file 图片
+   * @param scaleCallback 宽高 压缩规则
+   * @param qualityCallback 质量 压缩规则
+   */
+  function compressImg(file, scaleCallback, qualityCallback) {
+      return new Promise(function (resolve, reject) {
+          var fileSize = parseFloat((file.size / 1024 / 1024).toString());
+          var read = new FileReader();
+          read.onload = function (e) {
+              var img = new Image();
+              img.onload = function () {
+                  // 读取图片宽高
+                  var w = img.width;
+                  var h = img.height;
+                  // 生成canvas
+                  var canvas = document.createElement('canvas');
+                  var ctx = canvas.getContext('2d');
+                  // 处理函数返回的不是 number & NaN 类型的情况
+                  var scale = scaleCallback ? scaleCallback(w, h) : 1;
+                  if (Number.isNaN(scale) || typeof scale !== 'number') {
+                      scale = 1;
+                  }
+                  var quality = qualityCallback ? qualityCallback(fileSize, scale, w, h) : 1;
+                  if (Number.isNaN(quality) || typeof quality !== 'number') {
+                      quality = 1;
+                  }
+                  // 图片 缩放规则
+                  if (ctx) {
+                      var scaleW = parseInt((w * scale).toString(), 10);
+                      var scaleH = parseInt((h * scale).toString(), 10);
+                      // 创建属性节点
+                      canvas.setAttribute('width', scaleW.toString());
+                      canvas.setAttribute('height', scaleH.toString());
+                      ctx.drawImage(img, 0, 0, scaleW, scaleH);
+                  }
+                  // 图片质量 压缩
+                  var base64 = canvas.toDataURL(file.type, quality);
+                  resolve(dataURLtoBlob(base64));
+              };
+              img.onerror = function (evt) {
+                  reject(evt);
+              };
+              if (e.target) {
+                  img.src = e.target.result;
+              }
+          };
+          read.onerror = function (e) {
+              reject(e);
+          };
+          read.readAsDataURL(file);
+      });
+  }
+  /**
+   * 生成导出函数
+   */
+  function genExportByBlob(_a) {
+      var axiosRequest = _a.axiosRequest, _b = _a.notWithCredentials, notWithCredentials = _b === void 0 ? [] : _b;
+      return function exportByBlob(config) {
+          var _this = this;
+          var filename = config.filename;
+          var url = config.url, _a = config.data, data = _a === void 0 ? {} : _a, _b = config.params, params = _b === void 0 ? {} : _b, _c = config.method, method = _c === void 0 ? 'post' : _c;
+          return new Promise(function (resolve, reject) {
+              axiosRequest({
+                  method: method,
+                  url: url,
+                  data: data,
+                  params: params,
+                  responseType: 'blob',
+                  config: {
+                      withCredentials: notWithCredentials.some(function (str) {
+                          return !url.includes(str);
+                      }),
+                  },
+              }).then(function (res) { return __awaiter(_this, void 0, void 0, function () {
+                  var response, reader_1, headers, contentDisposition, responseFilename, splitFileName, suffix, blob, downloadElement, href;
+                  return __generator(this, function (_a) {
+                      switch (_a.label) {
+                          case 0:
+                              response = res === null || res === void 0 ? void 0 : res.data;
+                              if (!(response.type === 'application/json')) return [3 /*break*/, 1];
+                              reader_1 = new FileReader();
+                              reader_1.readAsText(response, 'utf-8');
+                              reader_1.onload = function () {
+                                  var result = {};
+                                  try {
+                                      result = JSON.parse(reader_1.result);
+                                  }
+                                  catch (e) {
+                                      result = response;
+                                  }
+                                  // Message.error((result && result.message) || '导出失败');
+                                  reject(result);
+                              };
+                              return [3 /*break*/, 3];
+                          case 1:
+                              try {
+                                  headers = res.headers;
+                                  contentDisposition = headers['content-disposition'];
+                                  responseFilename = decodeURIComponent(contentDisposition.split(';')[1].split('filename=')[1]);
+                                  // 有传文件名称&不带后缀 使用服务端的文件拓展名
+                                  if (filename && !filename.includes('.')) {
+                                      splitFileName = responseFilename.split('.');
+                                      suffix = splitFileName[splitFileName.length - 1];
+                                      filename += "." + suffix;
+                                  }
+                                  else if (!filename) {
+                                      filename = responseFilename;
+                                  }
+                              }
+                              catch (e) {
+                                  // 默认名称
+                                  if (!filename) {
+                                      filename = 'download.xlsx';
+                                  }
+                              }
+                              blob = new Blob([res.data]);
+                              downloadElement = document.createElement('a');
+                              return [4 /*yield*/, blobToDataURL(blob)];
+                          case 2:
+                              href = _a.sent();
+                              downloadElement.href = href;
+                              downloadElement.download = filename;
+                              document.body.appendChild(downloadElement);
+                              downloadElement.click(); // 点击下载
+                              document.body.removeChild(downloadElement); // 下载完成移除元素
+                              // window.URL.revokeObjectURL(href);
+                              resolve(res);
+                              _a.label = 3;
+                          case 3: return [2 /*return*/];
+                      }
+                  });
+              }); }).catch(function (e) {
+                  reject(e);
+              });
+          });
+      };
+  }
+  /**
+   * 将 base64 字符串转换为 File 或 Blob
+   * @param {string} base64 - 带有 data URI 的 base64 字符串
+   * @param {string} [filename] - 如果提供了，则返回 File；否则返回 Blob
+   * @returns {File|Blob}
+   */
+  function base64ToFileOrBlob(base64, filename) {
+      return __awaiter(this, void 0, void 0, function () {
+          var _a, meta, content, mime, bstr, len, u8arr, i;
+          return __generator(this, function (_b) {
+              _a = base64.split(','), meta = _a[0], content = _a[1];
+              mime = meta.match(/:(.*?);/)[1];
+              bstr = atob(content);
+              len = bstr.length;
+              u8arr = new Uint8Array(len);
+              for (i = 0; i < len; i++) {
+                  u8arr[i] = bstr.charCodeAt(i);
+              }
+              if (filename) {
+                  return [2 /*return*/, new File([u8arr], filename, { type: mime })];
+              }
+              else {
+                  return [2 /*return*/, new Blob([u8arr], { type: mime })];
+              }
+          });
+      });
+  }
+
+  /**
+   * object处理相关
+   * @packageDocumentation
+   * @module Object
+   * @preferred
+   */
+  /**
+   * 比较两者的值是否相等
+   #### 使用说明
+   ```
+   deepEqual({a: 10}, {a: 10}) 返回 true
+   deepEqual({a: 10}, {a: 10, b: 20}) 返回 false
+   ```
+   * @param {*} x 用来比较的值
+   * @param {*} y 另一个用来比较的值
+   */
+  function deepEqual(x, y) {
+      var ok = Object.keys, tx = typeof x, ty = typeof y;
+      return x && y && tx === 'object' && tx === ty
+          ? ok(x).length === ok(y).length && ok(x).every(function (key) { return deepEqual(x[key], y[key]); })
+          : x === y;
+  }
+  function getNodePath(node, nodeValue, nodeKey, childrenKey, path) {
+      if (path === void 0) { path = []; }
+      path.push(node);
+      if (node[nodeKey] === nodeValue) {
+          throw 'GOT IT!';
+      }
+      if (node[childrenKey] && node[childrenKey].length > 0) {
+          for (var i = 0; i < node[childrenKey].length; i++) {
+              getNodePath(node[childrenKey][i], nodeValue, nodeKey, childrenKey, path);
+          }
+      }
+      path.pop();
+  }
+  /**
+   * 查找树结构节点路径
+   * @param {*} nodeValue 节点值
+   * @param {string} nodeKey 节点键
+   * @param {Array} treeArray 树数据
+   * @param {string} children 子集键
+   */
+  function findNodePath(nodeValue, nodeKey, treeArray, childrenKey) {
+      var path = [];
+      try {
+          for (var i = 0; i < treeArray.length; i++) {
+              getNodePath(treeArray[i], nodeValue, nodeKey, childrenKey, path);
+          }
+      }
+      catch (e) {
+          return path;
+      }
+  }
+
+  /**
+   * validate处理相关
+   * @packageDocumentation
+   * @module Validate
+   * @preferred
+   */
+  /** 是否是外部网址
+   * @param {string} path
+   * @returns {Boolean}
+   */
+  function isExternal(path) {
+      return /^(https?:|mailto:|tel:)/.test(path);
+  }
+  /**
+   * 去掉前后空格
+   * @param {*} str
+   */
+  function trimVal(str) {
+      if (!str) {
+          return str;
+      }
+      var reg = /^\s+|\s+$/g;
+      return str.replace(reg, '');
+  }
+  /**
+   * 校验 手机
+   * @param {*} val
+   */
+  function isMobile(val) {
+      var reg = /^0?(13[0-9]|14[5-9]|15[012356789]|166|17[0-8]|18[0-9]|19[8-9])[0-9]{8}$/;
+      return reg.test(val.toString());
+  }
+  /**
+   * 校验 手机
+   * 规则: 以1为开头，总共11位数
+   * @export
+   * @param {*} val
+   * @returns
+   */
+  function isMobileSimple(val) {
+      var reg = /^1/;
+      val = val.toString();
+      return reg.test(val) && val.length === 11;
+  }
+  /**
+   * 校验 固定电话
+   * 规则: 必须带区号
+   * @param {*} val
+   */
+  function isTelephone(val) {
+      var reg = /^0[1-9][0-9]{1,2}-[2-8][0-9]{6,7}$/;
+      return reg.test(String(val));
+  }
+  /**
+   * 校验 邮箱
+   * @param {*} val
+   */
+  function isEmail(val) {
+      /* eslint-disable no-useless-escape */
+      var reg = /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/;
+      return reg.test(val);
+  }
+  /**
+   * 校验 QQ
+   * @param {*} val
+   */
+  function isQQ(val) {
+      var reg = /^[1-9][0-9]{4,9}$/gim;
+      return reg.test(String(val));
+  }
+  /**
+   * 校验是否为有效的中国大陆手机号（精确版）
+   * @param value - 待验证的字符串
+   * @returns 是否为有效手机号
+   */
+  function isPhone(value) {
+      return /^[1](([3][0-9])|([4][0,1,4-9])|([5][0-3,5-9])|([6][2,5,6,7])|([7][0-8])|([8][0-9])|([9][0-3,5-9]))[0-9]{8}$/.test(value);
+  }
+  /**
+   * 验证是否为有效的 URL
+   * @param value - 待验证的字符串
+   * @returns 是否为有效 URL
+   */
+  function isUrl(value) {
+      var pattern = '^(?:(https?|ftp|rtsp|mms|ws|wss):\\/\\/)?(?:\\S+(?::\\S*)?@)?(?:(?:localhost)|(?:[1-9]\\d{0,2}(?:\\.\\d{1,3}){3})|(?:$[0-9a-fA-F:]+$)|(?:(?:[a-zA-Z0-9-_]+\\.)+[a-zA-Z]{2,63}))(?::\\d{1,5})?(?:[/?#]\\S*)?$';
+      return new RegExp(pattern, 'i').test(value);
+  }
+
+  /**
+   * string处理相关
+   * @packageDocumentation
+   * @module String
+   * @preferred
+   */
+  /**
+   * 空值处理
+   */
+  function formatEmptyValue(value, defaultValue) {
+      if (defaultValue === void 0) { defaultValue = '-'; }
+      if (isEmpty(value)) {
+          return defaultValue;
+      }
+      return value;
+  }
+  /**
+   * 格式化手机
+   #### 使用说明
+   * ```
+   * formatPhone('18211572781') => '182 1157 2781'
+   * formatPhone('18211572781', '-') => '182-1157-2781'
+   * ```
+   * @param {string | number} phone 手机号
+   * @param {string} [separator=' '] 连接符
+   */
+  function formatPhone(phone, separator, defaultValue) {
+      if (separator === void 0) { separator = ' '; }
+      if (defaultValue === void 0) { defaultValue = '-'; }
+      if (isEmpty(phone)) {
+          return defaultValue;
+      }
+      if (phone.toString().length !== 11) {
+          return phone;
+      }
+      var val = phone.toString().replace(/[^\d]/g, '');
+      var arr = val.split('');
+      var str = '';
+      arr.forEach(function (v, index) {
+          if (index === 3 || index === 7) {
+              str += separator;
+          }
+          str += v;
+      });
+      return str;
+  }
+  /**
+   * 隐藏手机号
+   #### 使用说明
+   * ```
+   * formatPhoneHide('18211572781') => '182****2781'
+   * formatPhoneHide('', '-') => '-'
+   * ```
+   * @param {string | number} phone 手机号
+   * @param {string} defaultValue 没有值放回的默认值
+   */
+  function formatPhoneHide(phone, defaultValue) {
+      if (defaultValue === void 0) { defaultValue = ''; }
+      if (isEmpty(phone)) {
+          return defaultValue;
+      }
+      if (phone.toString().length !== 11) {
+          return phone;
+      }
+      var phoneNumber = phone.toString();
+      return phoneNumber.substr(0, 3) + "****" + phoneNumber.substr(7, 11);
+  }
+  /**
+   * 格式化银行卡 (4位一空格)
+   #### 使用说明
+   * ```
+   * formatBank('6282356862823568123') => '6282 3568 6282 3568 123'
+   * formatBank('', '-') => '-'
+   * ```
+   * @param {strubg | number} val 银行卡号
+   * @param {string} defaultValue 没有值放回的默认值
+   */
+  function formatBank(val, defaultValue) {
+      if (defaultValue === void 0) { defaultValue = ''; }
+      if (isEmpty(val)) {
+          return defaultValue;
+      }
+      return val.toString().replace(/\s/g, '').replace(/(.{4})/g, '$1 ');
+  }
+  /**
+   * 生成26个字母列表
+   #### 使用说明
+   * ```
+   *  generateEnglishLetters() => ['A', ..., 'Z'];
+   * ```
+   */
+  function generateEnglishLetters() {
+      var englishLettersList = [];
+      for (var i = 65; i < 91; i += 1) {
+          englishLettersList.push(String.fromCharCode(i));
+      }
+      return englishLettersList;
+  }
+  /**
+   * 驼峰式命名转短横线命名
+   *
+   * @export
+   * @param {*} [string='']
+   * @returns
+   */
+  function humpTurnDashed(string) {
+      if (string === void 0) { string = ''; }
+      var rE = /\B([A-Z])/g;
+      return string.replace(rE, '-$1').toLowerCase();
+  }
+  /**
+   * 获取指定分隔符之前的子字符串
+   * @param str - 源字符串
+   * @param delimiter - 分隔符
+   * @returns 分隔符之前的字符串
+   */
+  function subBefore(str, delimiter) {
+      if (!str || typeof delimiter !== 'string')
+          return '';
+      return str.substring(0, str.indexOf(delimiter));
+  }
+  /**
+   * 解析 URL 查询参数为对象
+   * @param url - URL 字符串
+   * @returns 查询参数对象
+   */
+  function getQueryMap(url) {
+      var pattern = /^(?:(https?|ftp|rtsp|mms|ws|wss):\/\/)?/i;
+      if (!pattern.test(url)) {
+          console.error(url + "\u4E0D\u7B26\u5408\u8D85\u94FE\u63A5\u89C4\u8303");
+          return {};
+      }
+      var queryIndex = url.indexOf('?');
+      if (queryIndex === -1)
+          return {};
+      var queryString = url.slice(queryIndex + 1);
+      var params = queryString.split('&');
+      var result = {};
+      for (var _i = 0, params_1 = params; _i < params_1.length; _i++) {
+          var param = params_1[_i];
+          var _a = param.split('='), key = _a[0], value = _a[1];
+          if (key) {
+              result[key] = value || '';
+          }
+      }
+      return result;
+  }
+  /**
+   * 隐藏字符串中指定位置的字符
+   * @param text - 源字符串或数字
+   * @param indexes - 要隐藏的位置索引数组或位置对象数组
+   * @param mask - 掩码字符，默认为 '*'
+   * @returns 处理后的字符串
+   */
+  function hideTextAtIndex(text, indexes, mask) {
+      if (mask === void 0) { mask = '*'; }
+      if (typeof text === 'number') {
+          text = text.toString();
+      }
+      if (!Array.isArray(indexes)) {
+          indexes = [indexes];
+      }
+      var chars = text.split('');
+      for (var _i = 0, indexes_1 = indexes; _i < indexes_1.length; _i++) {
+          var index = indexes_1[_i];
+          if (typeof index === 'object' && !Array.isArray(index)) {
+              var start = index.start, end = index.end;
+              if (start >= 0 && start < end && end < chars.length) {
+                  chars.fill(mask, start, end + 1);
+              }
+          }
+          else if (typeof index === 'number' && Number.isInteger(index) && index >= 0) {
+              if (index < chars.length) {
+                  chars[index] = mask;
+              }
+          }
+      }
+      return chars.join('');
+  }
+
+  var httpEnum = {
+      // http响应状态码
+      HTTP_STATUS: {
+          // 1xx，临时响应
+          TEMP_RESPOND: {
+              Continue: 100,
+              SwitchingProtocal: 101 // 针对请求头的Upgrade返回的信息。表明服务器正在切换到指定的协议
+          },
+          // 2xx，成功
+          SUCCESS: {
+              Ok: 200,
+              Created: 201,
+              Accepted: 202,
+              NoAuthoritativeInformation: 203,
+              NoContent: 204,
+              ResetContent: 205,
+              ParticalContent: 206 // 客户端使用Range请求头时，返回该状态码
+          },
+          // 3xx，重定向
+          REDIRECT: {
+              MultipleChoice: 300,
+              MovedPermanently: 301,
+              Found: 302,
+              SeeOther: 303,
+              NotModified: 304,
+              TemporaryRedirect: 307,
+              PermanentRedirect: 308 // 永久重定向。基本和301相同。但是严格禁止修改请求方式和请求体。
+          },
+          // 4xx，请求错误
+          REQUEST_ERROR: {
+              BadRequest: 400,
+              UnAuthorized: 401,
+              Forbidden: 403,
+              NotFound: 404,
+              MethodNotAllowed: 405,
+              NotAccepted: 406,
+              ProxyAuthorizationRequired: 407,
+              RequestTimeout: 408,
+              UpgradeRequired: 426,
+              TokenUnAuthorized: 499,
+          },
+          // 5xx，服务器错误
+          SERVER_ERROR: {
+              InternalServerError: 500,
+              BadGateway: 502,
+              ServiceUnavailable: 503,
+              GateTimeout: 504,
+              HttpVersionNotSupported: 505 // 发出的请求http版本服务器不支持。如果请求通过http2发送，服务器不支持http2.0，就会返回该状态码。
+          }
+      },
+      // http状态码
+      CODES: {
+          Success: '00000',
+          UnAuthorized: '00099',
+          UnAuthorizedPhone: '11001',
+          UnAuthorizedWecom: '11000',
+          UnAuthorizedHavePhone: '11002',
+      },
+      // http状态码白名单，在具体业务中处理
+      ERR_CODE_WHITE_LIST: []
+  };
+
+  var request = axios__default["default"].create({
+      timeout: 15000,
+      headers: {
+          // 'Authorization': getToken(),
+          "Content-Type": "application/json",
+      },
+  });
+  // const requestArr = [request];
+  /**
+   * @param cacheType localStorage | sessionStorage | both
+   * @param currentMode local | dev | test | prod 等自定义mode
+   * @param errorCb 错误回调
+   * @param getTokenCb 获取token的回调
+   * @param tokenKey
+   * */
+  var http = function (_a) {
+      var cacheType = _a.cacheType, currentMode = _a.currentMode, errorCb = _a.errorCb, getTokenCb = _a.getTokenCb, tokenKey = _a.tokenKey;
+      request.interceptors.request.use(function (config) { return __awaiter(void 0, void 0, void 0, function () {
+          var token, deviceType;
+          return __generator(this, function (_a) {
+              token = getToken(cacheType, tokenKey);
+              deviceType = getDeviceType();
+              config.headers.Authorization = token;
+              config.headers.token = token;
+              config.headers.FrontType = getFromType(deviceType);
+              return [2 /*return*/, config];
+          });
+      }); }, function (error) {
+          // do something with request error
+          return Promise.reject(error);
+      });
+      // response interceptor
+      request.interceptors.response.use(function (response) { return __awaiter(void 0, void 0, void 0, function () {
+          var res, statusCode, errMsg;
+          return __generator(this, function (_a) {
+              res = response.data;
+              statusCode = res.code || response.status;
+              // blob文件流
+              if (res instanceof Blob) {
+                  return [2 /*return*/, res];
+              }
+              // 成功
+              if (statusCode === httpEnum.CODES.Success) {
+                  return [2 /*return*/, res];
+              }
+              // token失效
+              if (statusCode === httpEnum.CODES.UnAuthorized) {
+                  if (currentMode !== "local" && currentMode !== "dev" && currentMode !== 'development') {
+                      removeToken(cacheType, tokenKey);
+                      if (getTokenCb && typeof getTokenCb === "function") {
+                          getTokenCb();
+                      }
+                  }
+                  return [2 /*return*/, Promise.reject(new Error("token过期！"))];
+              }
+              errMsg = res.message || res.msg;
+              return [2 /*return*/, Promise.reject(new Error(errMsg || "Error"))];
+          });
+      }); }, function (error) { return __awaiter(void 0, void 0, void 0, function () {
+          return __generator(this, function (_a) {
+              if (errorCb && typeof errorCb === "function") {
+                  errorCb(error);
+              }
+              return [2 /*return*/, Promise.reject(error)];
+          });
+      }); });
+      return request;
+  };
+
+  /**
+   * API 请求参数构建工具
+   * @description 用于快速组装后端 JSON 格式请求参数
+   */
+  /**
+   * API 构建器基类
+   */
+  var BaseBuilder = /** @class */ (function () {
+      function BaseBuilder(fieldCatalog) {
+          this.fieldCatalog = fieldCatalog;
+          // 只有传入 fieldCatalog 时才添加到 params
+          this.params = (fieldCatalog ? { field_catalog: fieldCatalog } : {});
+      }
+      /**
+       * 获取构建的参数
+       */
+      BaseBuilder.prototype.build = function () {
+          return this.params;
+      };
+      return BaseBuilder;
+  }());
+  /**
+   * API 构建器主类
+   */
+  var ApiBuilder = /** @class */ (function () {
+      function ApiBuilder(fieldCatalog) {
+          this.fieldCatalog = fieldCatalog;
+      }
+      /**
+       * 创建查询请求构建器
+       */
+      ApiBuilder.prototype.query = function () {
+          return new QueryBuilder(this.fieldCatalog);
+      };
+      /**
+       * 创建新增请求构建器
+       */
+      ApiBuilder.prototype.insert = function () {
+          return new InsertBuilder(this.fieldCatalog);
+      };
+      /**
+       * 创建更新请求构建器
+       */
+      ApiBuilder.prototype.update = function () {
+          return new UpdateBuilder(this.fieldCatalog);
+      };
+      // 静态方法保持向后兼容
+      ApiBuilder.query = function (fieldCatalog) {
+          return new QueryBuilder(fieldCatalog);
+      };
+      ApiBuilder.insert = function (fieldCatalog) {
+          return new InsertBuilder(fieldCatalog);
+      };
+      ApiBuilder.update = function (fieldCatalog) {
+          return new UpdateBuilder(fieldCatalog);
+      };
+      return ApiBuilder;
+  }());
+  /**
+   * 嵌套查询构建器类
+   * 用于构建嵌套的过滤条件
+   */
+  var NestedQueryBuilder = /** @class */ (function () {
+      function NestedQueryBuilder(logic, parent) {
+          this.parent = parent;
+          this.nestedFilters = {
+              logic: logic,
+              filters: []
+          };
+      }
+      NestedQueryBuilder.prototype.where = function (fieldOrConditions, opOrValue, value) {
+          var _this = this;
+          // 对象形式: where({ user_id: 10086, status: 1 })
+          if (typeof fieldOrConditions === 'object') {
+              Object.entries(fieldOrConditions).forEach(function (_a) {
+                  var field = _a[0], val = _a[1];
+                  _this.nestedFilters.filters.push({ field: field, op: '=', value: val });
+              });
+              return this;
+          }
+          // 两参数形式: where('user_id', 10086) - 默认 =
+          if (value === undefined) {
+              this.nestedFilters.filters.push({ field: fieldOrConditions, op: '=', value: opOrValue });
+              return this;
+          }
+          // 三参数形式: where('user_id', '=', 10086)
+          this.nestedFilters.filters.push({ field: fieldOrConditions, op: opOrValue, value: value });
+          return this;
+      };
+      /**
+       * 在嵌套查询中添加另一个嵌套组
+       */
+      NestedQueryBuilder.prototype.group = function (logic) {
+          if (logic === void 0) { logic = 'and'; }
+          return new NestedQueryBuilder(logic, this);
+      };
+      /**
+       * 结束当前嵌套组并返回父查询构建器或父嵌套构建器
+       */
+      NestedQueryBuilder.prototype.endGroup = function () {
+          if (this.parent instanceof NestedQueryBuilder) {
+              this.parent.addNestedFilters(this.nestedFilters);
+              return this.parent;
+          }
+          else {
+              this.parent.whereNested(this.nestedFilters);
+              return this.parent;
+          }
+      };
+      /**
+       * 添加嵌套过滤条件到当前嵌套组
+       */
+      NestedQueryBuilder.prototype.addNestedFilters = function (nestedFilters) {
+          this.nestedFilters.filters.push(nestedFilters);
+      };
+      /**
+       * 获取构建的嵌套过滤条件
+       */
+      NestedQueryBuilder.prototype.build = function () {
+          return this.nestedFilters;
+      };
+      return NestedQueryBuilder;
+  }());
+  /**
+   * 查询构建器
+   */
+  var QueryBuilder = /** @class */ (function (_super) {
+      __extends(QueryBuilder, _super);
+      function QueryBuilder(fieldCatalog) {
+          var _this = _super.call(this, fieldCatalog) || this;
+          _this.params = __assign(__assign({}, _this.params), { filters: { logic: 'and', filters: [] }, order_by: [], limit: 100, offset: 0 });
+          return _this;
+      }
+      QueryBuilder.prototype.where = function (fieldOrConditions, opOrValue, value) {
+          var _this = this;
+          // 对象形式: where({ user_id: 10086, status: 1 })
+          if (typeof fieldOrConditions === 'object') {
+              Object.entries(fieldOrConditions).forEach(function (_a) {
+                  var field = _a[0], val = _a[1];
+                  _this.params.filters.filters.push({ field: field, op: '=', value: val });
+              });
+              return this;
+          }
+          // 两参数形式: where('user_id', 10086) - 默认 =
+          if (value === undefined) {
+              this.params.filters.filters.push({ field: fieldOrConditions, op: '=', value: opOrValue });
+              return this;
+          }
+          // 三参数形式: where('user_id', '=', 10086)
+          this.params.filters.filters.push({ field: fieldOrConditions, op: opOrValue, value: value });
+          return this;
+      };
+      /**
+       * 添加嵌套的 WHERE 条件
+       * @param nestedFilters 嵌套的过滤条件
+       */
+      QueryBuilder.prototype.whereNested = function (nestedFilters) {
+          this.params.filters.filters.push(nestedFilters);
+          return this;
+      };
+      /**
+       * 创建并返回一个嵌套查询构建器，用于构建复杂的嵌套条件
+       */
+      QueryBuilder.prototype.group = function (logic) {
+          if (logic === void 0) { logic = 'and'; }
+          return new NestedQueryBuilder(logic, this);
+      };
+      QueryBuilder.prototype.orWhere = function (fieldOrConditions, opOrValue, value) {
+          var _a;
+          // 创建一个新的 OR 组
+          var orGroup = {
+              logic: 'or',
+              filters: []
+          };
+          // 对象形式: orWhere({ user_id: 10086, status: 1 })
+          if (typeof fieldOrConditions === 'object') {
+              Object.entries(fieldOrConditions).forEach(function (_a) {
+                  var field = _a[0], val = _a[1];
+                  orGroup.filters.push({ field: field, op: '=', value: val });
+              });
+          }
+          // 两参数形式: orWhere('user_id', 10086) - 默认 =
+          else if (value === undefined) {
+              orGroup.filters.push({ field: fieldOrConditions, op: '=', value: opOrValue });
+          }
+          // 三参数形式: orWhere('user_id', '=', 10086)
+          else {
+              orGroup.filters.push({ field: fieldOrConditions, op: opOrValue, value: value });
+          }
+          // 如果当前 filters 为空或者已经是 OR 逻辑，则直接添加
+          if (this.params.filters.filters.length === 0 || this.params.filters.logic === 'or') {
+              (_a = this.params.filters.filters).push.apply(_a, orGroup.filters);
+              this.params.filters.logic = 'or';
+          }
+          else {
+              // 否则将当前所有条件包装成一个 AND 组，然后与新的 OR 组一起放在顶层
+              var andGroup = {
+                  logic: 'and',
+                  filters: __spreadArrays(this.params.filters.filters)
+              };
+              this.params.filters.filters = [andGroup, orGroup];
+              this.params.filters.logic = 'and';
+          }
+          return this;
+      };
+      /**
+       * WHERE IN
+       */
+      QueryBuilder.prototype.whereIn = function (field, values) {
+          this.params.filters.filters.push({ field: field, op: 'in', value: values });
+          return this;
+      };
+      /**
+       * WHERE NOT IN
+       */
+      QueryBuilder.prototype.whereNotIn = function (field, values) {
+          this.params.filters.filters.push({ field: field, op: 'not in', value: values });
+          return this;
+      };
+      /**
+       * WHERE LIKE
+       */
+      QueryBuilder.prototype.whereLike = function (field, value) {
+          this.params.filters.filters.push({ field: field, op: 'like', value: value });
+          return this;
+      };
+      /**
+       * WHERE BETWEEN
+       */
+      QueryBuilder.prototype.whereBetween = function (field, min, max) {
+          this.params.filters.filters.push({ field: field, op: 'between', value: [min, max] });
+          return this;
+      };
+      /**
+       * WHERE NULL
+       */
+      QueryBuilder.prototype.whereNull = function (field) {
+          this.params.filters.filters.push({ field: field, op: 'is null', value: null });
+          return this;
+      };
+      /**
+       * WHERE NOT NULL
+       */
+      QueryBuilder.prototype.whereNotNull = function (field) {
+          this.params.filters.filters.push({ field: field, op: 'is not null', value: null });
+          return this;
+      };
+      /**
+       * 设置逻辑运算符（不推荐直接使用，建议用 orWhere）
+       */
+      QueryBuilder.prototype.logic = function (logic) {
+          this.params.filters.logic = logic;
+          return this;
+      };
+      /**
+       * 添加排序
+       */
+      QueryBuilder.prototype.orderBy = function (field, direction) {
+          if (direction === void 0) { direction = 'asc'; }
+          this.params.order_by.push({ field: field, direction: direction });
+          return this;
+      };
+      /**
+       * 设置 LIMIT
+       */
+      QueryBuilder.prototype.limit = function (limit) {
+          this.params.limit = limit;
+          return this;
+      };
+      /**
+       * 设置 OFFSET
+       */
+      QueryBuilder.prototype.offset = function (offset) {
+          this.params.offset = offset;
+          return this;
+      };
+      /**
+       * 设置分页（便捷方法）
+       */
+      QueryBuilder.prototype.paginate = function (limit, offset) {
+          if (offset === void 0) { offset = 0; }
+          this.params.limit = limit;
+          this.params.offset = offset;
+          return this;
+      };
+      return QueryBuilder;
+  }(BaseBuilder));
+  /**
+   * 新增构建器
+   */
+  var InsertBuilder = /** @class */ (function (_super) {
+      __extends(InsertBuilder, _super);
+      function InsertBuilder(fieldCatalog) {
+          var _this = _super.call(this, fieldCatalog) || this;
+          _this.params = __assign(__assign({}, _this.params), { insert: [] });
+          return _this;
+      }
+      /**
+       * 添加一条记录
+       */
+      InsertBuilder.prototype.add = function (data) {
+          this.params.insert.push(data);
+          return this;
+      };
+      /**
+       * 批量添加记录
+       */
+      InsertBuilder.prototype.addBatch = function (dataList) {
+          var _a;
+          (_a = this.params.insert).push.apply(_a, dataList);
+          return this;
+      };
+      return InsertBuilder;
+  }(BaseBuilder));
+  /**
+   * 更新构建器
+   */
+  var UpdateBuilder = /** @class */ (function (_super) {
+      __extends(UpdateBuilder, _super);
+      function UpdateBuilder(fieldCatalog) {
+          var _this = _super.call(this, fieldCatalog) || this;
+          _this.currentUpdate = null;
+          _this.params = __assign(__assign({}, _this.params), { update: [] });
+          return _this;
+      }
+      /**
+       * 设置要更新的字段和值
+       */
+      UpdateBuilder.prototype.set = function (fields) {
+          this.currentUpdate = { set: fields, where: {} };
+          return this;
+      };
+      UpdateBuilder.prototype.where = function (fieldOrConditions, value) {
+          if (!this.currentUpdate) {
+              throw new Error('必须先调用 set() 方法');
+          }
+          if (typeof fieldOrConditions === 'object') {
+              this.currentUpdate.where = __assign(__assign({}, this.currentUpdate.where), fieldOrConditions);
+          }
+          else {
+              this.currentUpdate.where[fieldOrConditions] = value;
+          }
+          return this;
+      };
+      /**
+       * 完成当前更新操作，开始下一个
+       */
+      UpdateBuilder.prototype.and = function () {
+          if (this.currentUpdate) {
+              this.params.update.push(this.currentUpdate);
+              this.currentUpdate = null;
+          }
+          return this;
+      };
+      /**
+       * 批量添加更新操作
+       */
+      UpdateBuilder.prototype.setBatch = function (updates) {
+          var _a;
+          (_a = this.params.update).push.apply(_a, updates);
+          return this;
+      };
+      /**
+       * 构建最终参数
+       */
+      UpdateBuilder.prototype.build = function () {
+          if (this.currentUpdate) {
+              this.params.update.push(this.currentUpdate);
+              this.currentUpdate = null;
+          }
+          return this.params;
+      };
+      return UpdateBuilder;
+  }(BaseBuilder));
+
+  function normalizeHeaders(headers) {
+      return __assign({}, (headers || {}));
+  }
+  function lowerCaseHeaderMap(resHeaders) {
+      var out = {};
+      resHeaders.forEach(function (value, key) {
+          out[key.toLowerCase()] = value;
+      });
+      return out;
+  }
+  function safeJsonParse(text) {
+      try {
+          return JSON.parse(text);
+      }
+      catch (_a) {
+          return undefined;
+      }
+  }
+  var CurlClient = /** @class */ (function () {
+      function CurlClient() {
+      }
+      CurlClient.prototype.request = function (opts) {
+          return __awaiter(this, void 0, void 0, function () {
+              var method, timeoutMs, headers, hasBody, body, hasContentType, controller, timeoutId, res, text, resHeaders, ct, json;
+              return __generator(this, function (_a) {
+                  switch (_a.label) {
+                      case 0:
+                          method = (opts.method || 'GET').toUpperCase();
+                          timeoutMs = typeof opts.timeoutMs === 'number' && opts.timeoutMs > 0 ? opts.timeoutMs : 15000;
+                          headers = normalizeHeaders(opts.headers);
+                          hasBody = opts.data !== undefined && opts.data !== null;
+                          body = undefined;
+                          if (hasBody) {
+                              if (typeof opts.data === 'string') {
+                                  body = opts.data;
+                              }
+                              else if (typeof FormData !== 'undefined' && opts.data instanceof FormData ||
+                                  typeof Blob !== 'undefined' && opts.data instanceof Blob ||
+                                  typeof ArrayBuffer !== 'undefined' && opts.data instanceof ArrayBuffer) {
+                                  body = opts.data;
+                              }
+                              else {
+                                  hasContentType = Object.keys(headers).some(function (k) { return k.toLowerCase() === 'content-type'; });
+                                  if (!hasContentType)
+                                      headers['Content-Type'] = 'application/json';
+                                  body = JSON.stringify(opts.data);
+                              }
+                          }
+                          controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+                          timeoutId = controller ? setTimeout(function () { return controller.abort(); }, timeoutMs) : null;
+                          _a.label = 1;
+                      case 1:
+                          _a.trys.push([1, , 4, 5]);
+                          return [4 /*yield*/, fetch(opts.url, {
+                                  method: method,
+                                  headers: headers,
+                                  body: body,
+                                  redirect: opts.followRedirects === false ? 'manual' : 'follow',
+                                  signal: controller ? controller.signal : undefined,
+                              })];
+                      case 2:
+                          res = _a.sent();
+                          return [4 /*yield*/, res.text()];
+                      case 3:
+                          text = _a.sent();
+                          resHeaders = lowerCaseHeaderMap(res.headers);
+                          ct = resHeaders['content-type'] || '';
+                          json = ct.includes('application/json') ? safeJsonParse(text) : undefined;
+                          return [2 /*return*/, {
+                                  status: res.status,
+                                  headers: resHeaders,
+                                  body: text,
+                                  json: json,
+                              }];
+                      case 4:
+                          if (timeoutId)
+                              clearTimeout(timeoutId);
+                          return [7 /*endfinally*/];
+                      case 5: return [2 /*return*/];
+                  }
+              });
+          });
+      };
+      CurlClient.prototype.get = function (url, opts) {
+          return __awaiter(this, void 0, void 0, function () {
+              return __generator(this, function (_a) {
+                  return [2 /*return*/, this.request(__assign(__assign({}, (opts || {})), { url: url, method: 'GET' }))];
+              });
+          });
+      };
+      CurlClient.prototype.post = function (url, data, opts) {
+          return __awaiter(this, void 0, void 0, function () {
+              return __generator(this, function (_a) {
+                  return [2 /*return*/, this.request(__assign(__assign({}, (opts || {})), { url: url, method: 'POST', data: data }))];
+              });
+          });
+      };
+      return CurlClient;
+  }());
+  var curl = new CurlClient();
+
+  // ==================== 通用工具函数 ====================
+  function getNowTime() {
+      var d = new Date();
+      var y = String(d.getFullYear());
+      var m = String(d.getMonth() + 1);
+      var day = String(d.getDate());
+      var h = String(d.getHours());
+      var min = String(d.getMinutes());
+      return y + "\u5E74" + m + "\u6708" + day + "\u65E5" + h + ":" + min;
+  }
+  function sendLog(logData) {
+      return __awaiter(this, void 0, void 0, function () {
+          var LOG_HOST, result, err_1;
+          return __generator(this, function (_a) {
+              switch (_a.label) {
+                  case 0:
+                      _a.trys.push([0, 2, , 3]);
+                      LOG_HOST = "https://fe-log-producer.jinbizhihui.com";
+                      return [4 /*yield*/, curl.post(LOG_HOST + "/log/save", logData)];
+                  case 1:
+                      result = _a.sent();
+                      console.log("[RequestLogger] 远程日志发送成功, result", result);
+                      return [3 /*break*/, 3];
+                  case 2:
+                      err_1 = _a.sent();
+                      console.error("[RequestLogger] \u8FDC\u7A0B\u65E5\u5FD7\u53D1\u9001\u5931\u8D25:", (err_1 === null || err_1 === void 0 ? void 0 : err_1.message) || err_1);
+                      return [3 /*break*/, 3];
+                  case 3: return [2 /*return*/];
+              }
+          });
+      });
+  }
+  // ==================== Hono 相关处理 ====================
+  function readHonoRequestBody(c) {
+      return __awaiter(this, void 0, void 0, function () {
+          var ct, raw, cloned, t;
+          return __generator(this, function (_b) {
+              switch (_b.label) {
+                  case 0:
+                      ct = c.req.header("content-type") || "";
+                      _b.label = 1;
+                  case 1:
+                      _b.trys.push([1, 4, , 5]);
+                      raw = c.req.raw;
+                      if (!(raw && typeof raw.clone === "function")) return [3 /*break*/, 3];
+                      cloned = raw.clone();
+                      return [4 /*yield*/, cloned.text()];
+                  case 2:
+                      t = _b.sent();
+                      if (!t)
+                          return [2 /*return*/, undefined];
+                      if (ct.includes("application/json")) {
+                          try {
+                              return [2 /*return*/, JSON.parse(t)];
+                          }
+                          catch (_c) {
+                              return [2 /*return*/, t];
+                          }
+                      }
+                      return [2 /*return*/, t];
+                  case 3: return [3 /*break*/, 5];
+                  case 4:
+                      _b.sent();
+                      return [3 /*break*/, 5];
+                  case 5: return [2 /*return*/, undefined];
+              }
+          });
+      });
+  }
+  function readHonoRequestHeaders(c) {
+      var out = {};
+      try {
+          var raw = c.req.raw;
+          var hs = raw === null || raw === void 0 ? void 0 : raw.headers;
+          if (hs) {
+              hs.forEach(function (v, k) {
+                  out[k] = v;
+              });
+          }
+      }
+      catch (_a) { }
+      return out;
+  }
+  function readHonoResponseHeaders(c) {
+      var out = {};
+      try {
+          c.res.headers.forEach(function (v, k) {
+              out[k] = v;
+          });
+      }
+      catch (_a) { }
+      return out;
+  }
+  function handleHono(c, next, systemName) {
+      return __awaiter(this, void 0, void 0, function () {
+          var ip, method, url, query, headers, body, timeToString, start, duration, result, logData;
+          return __generator(this, function (_a) {
+              switch (_a.label) {
+                  case 0:
+                      ip = c.req.header("x-forwarded-for") || c.req.header("x-real-ip") || "unknown";
+                      method = c.req.method;
+                      url = c.req.url;
+                      query = c.req.query();
+                      headers = readHonoRequestHeaders(c);
+                      return [4 /*yield*/, readHonoRequestBody(c)];
+                  case 1:
+                      body = _a.sent();
+                      timeToString = getNowTime();
+                      start = Date.now();
+                      return [4 /*yield*/, next()];
+                  case 2:
+                      _a.sent();
+                      duration = Date.now() - start;
+                      result = {
+                          status: c.res.status,
+                          headers: readHonoResponseHeaders(c),
+                          duration: duration,
+                      };
+                      logData = {
+                          system: systemName,
+                          ip: ip,
+                          path: url,
+                          method: method,
+                          time: timeToString,
+                          params: { method: method, url: url, query: query, body: body },
+                          headers: headers,
+                          result: result,
+                      };
+                      return [4 /*yield*/, sendLog(logData)];
+                  case 3:
+                      _a.sent();
+                      return [2 /*return*/];
+              }
+          });
+      });
+  }
+  // ==================== Koa/Midway 相关处理 ====================
+  function readKoaRequestHeaders(ctx) {
+      var _a;
+      var out = {};
+      try {
+          var headers = ctx.headers || ((_a = ctx.request) === null || _a === void 0 ? void 0 : _a.headers) || {};
+          for (var _i = 0, _b = Object.entries(headers); _i < _b.length; _i++) {
+              var _c = _b[_i], k = _c[0], v = _c[1];
+              out[k] = String(v);
+          }
+      }
+      catch (_d) { }
+      return out;
+  }
+  function readKoaResponseHeaders(ctx) {
+      var _a;
+      var out = {};
+      try {
+          var headers = ((_a = ctx.response) === null || _a === void 0 ? void 0 : _a.headers) || {};
+          for (var _i = 0, _b = Object.entries(headers); _i < _b.length; _i++) {
+              var _c = _b[_i], k = _c[0], v = _c[1];
+              out[k] = String(v);
+          }
+      }
+      catch (_d) { }
+      return out;
+  }
+  function handleKoa(ctx, next, systemName) {
+      var _a, _b, _c, _d, _e, _f;
+      return __awaiter(this, void 0, void 0, function () {
+          var ip, path, method, url, query, body, headers, timeToString, start, duration, result, logData;
+          return __generator(this, function (_g) {
+              switch (_g.label) {
+                  case 0:
+                      ip = ctx.ip || ((_a = ctx.request) === null || _a === void 0 ? void 0 : _a.ip) || "unknown";
+                      path = ctx.path || ((_b = ctx.request) === null || _b === void 0 ? void 0 : _b.path) || "";
+                      method = ctx.method || ((_c = ctx.request) === null || _c === void 0 ? void 0 : _c.method) || "";
+                      url = ctx.url || ((_d = ctx.request) === null || _d === void 0 ? void 0 : _d.url) || "";
+                      query = ctx.query || ((_e = ctx.request) === null || _e === void 0 ? void 0 : _e.query) || {};
+                      body = ((_f = ctx.request) === null || _f === void 0 ? void 0 : _f.body) || {};
+                      headers = readKoaRequestHeaders(ctx);
+                      timeToString = getNowTime();
+                      start = Date.now();
+                      return [4 /*yield*/, next()];
+                  case 1:
+                      _g.sent();
+                      duration = Date.now() - start;
+                      result = {
+                          status: ctx.status,
+                          body: ctx.body,
+                          headers: readKoaResponseHeaders(ctx),
+                          duration: duration,
+                      };
+                      logData = {
+                          system: systemName,
+                          ip: ip,
+                          path: path,
+                          method: method,
+                          time: timeToString,
+                          params: { method: method, url: url, query: query, body: body },
+                          headers: headers,
+                          result: result,
+                      };
+                      return [4 /*yield*/, sendLog(logData)];
+                  case 2:
+                      _g.sent();
+                      return [2 /*return*/];
+              }
+          });
+      });
+  }
+  // ==================== Fastify 相关处理 ====================
+  function readFastifyRequestHeaders(request) {
+      var out = {};
+      try {
+          var headers = request.headers || {};
+          for (var _i = 0, _a = Object.entries(headers); _i < _a.length; _i++) {
+              var _b = _a[_i], k = _b[0], v = _b[1];
+              out[k] = String(v);
+          }
+      }
+      catch (_c) { }
+      return out;
+  }
+  function readFastifyResponseHeaders(reply) {
+      var _a;
+      var out = {};
+      try {
+          var headers = ((_a = reply.getHeaders) === null || _a === void 0 ? void 0 : _a.call(reply)) || {};
+          for (var _i = 0, _b = Object.entries(headers); _i < _b.length; _i++) {
+              var _c = _b[_i], k = _c[0], v = _c[1];
+              if (v !== undefined) {
+                  out[k] = String(v);
+              }
+          }
+      }
+      catch (_d) { }
+      return out;
+  }
+  function handleFastify(request, reply, systemName) {
+      return __awaiter(this, void 0, void 0, function () {
+          var ip, path, method, query, body, headers, timeToString, start, duration, result, logData;
+          return __generator(this, function (_a) {
+              switch (_a.label) {
+                  case 0:
+                      ip = request.headers["x-forwarded-for"] ||
+                          request.headers["x-real-ip"] ||
+                          request.ip ||
+                          "unknown";
+                      path = request.url || "";
+                      method = request.method || "";
+                      query = request.query || {};
+                      body = request.body || {};
+                      headers = readFastifyRequestHeaders(request);
+                      timeToString = getNowTime();
+                      start = Date.now();
+                      duration = Date.now() - start;
+                      result = {
+                          status: reply.statusCode,
+                          headers: readFastifyResponseHeaders(reply),
+                          duration: duration,
+                      };
+                      logData = {
+                          system: systemName,
+                          ip: ip,
+                          path: path,
+                          method: method,
+                          time: timeToString,
+                          params: { method: method, url: path, query: query, body: body },
+                          headers: headers,
+                          result: result,
+                      };
+                      return [4 /*yield*/, sendLog(logData)];
+                  case 1:
+                      _a.sent();
+                      return [2 /*return*/];
+              }
+          });
+      });
+  }
+  /**
+   * 检测 Fastify 请求对象
+   * Fastify 的 request 对象有特定的属性如 routerPath, routeOptions 等
+   */
+  function isFastifyRequest(obj) {
+      var _a, _b;
+      return (obj &&
+          typeof obj.method === "string" &&
+          typeof obj.url === "string" &&
+          obj.headers &&
+          (obj.routerPath !== undefined ||
+              obj.routeOptions !== undefined ||
+              typeof obj.getValidationFunction === "function" ||
+              ((_b = (_a = obj.raw) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name) === "IncomingMessage"));
+  }
+  function detectFramework(context, secondArg) {
+      var _a;
+      // Fastify: 检查第一个参数是否是 Fastify request 对象
+      // Fastify hook 签名: (request, reply) => void
+      if (isFastifyRequest(context) && (secondArg === null || secondArg === void 0 ? void 0 : secondArg.statusCode) !== undefined) {
+          return "fastify";
+      }
+      // Hono: 检查是否有 c.req.raw 和 c.res 等 Hono 特有属性
+      if (context &&
+          context.req &&
+          typeof context.req.header === "function" &&
+          typeof context.req.query === "function" &&
+          context.req.raw !== undefined) {
+          return "hono";
+      }
+      // Koa/Midway: 检查是否有 ctx.request, ctx.response 等 Koa 特有属性
+      if (context &&
+          context.request &&
+          context.response &&
+          typeof context.throw === "function") {
+          // 进一步区分 Midway 和 Koa
+          // Midway 通常会有 requestContext 或特定的装饰器注入
+          if (context.requestContext || ((_a = context.app) === null || _a === void 0 ? void 0 : _a.getApplicationContext)) {
+              return "midway";
+          }
+          return "koa";
+      }
+      return "unknown";
+  }
+  // ==================== 统一中间件入口 ====================
+  /**
+   * 统一请求日志中间件
+   * 自动检测运行时框架类型，支持 Hono、Koa、Midway、Fastify
+   *
+   * @param systemName 系统名称，用于日志标识
+   * @returns 返回适配不同框架的中间件函数
+   */
+  function recordLogMiddleware(systemName) {
+      var _this = this;
+      return function (contextOrC, nextOrReply) { return __awaiter(_this, void 0, void 0, function () {
+          var framework;
+          return __generator(this, function (_a) {
+              framework = detectFramework(contextOrC, nextOrReply);
+              switch (framework) {
+                  case "hono":
+                      return [2 /*return*/, handleHono(contextOrC, nextOrReply, systemName)];
+                  case "fastify":
+                      return [2 /*return*/, handleFastify(contextOrC, nextOrReply, systemName)];
+                  case "koa":
+                  case "midway":
+                      return [2 /*return*/, handleKoa(contextOrC, nextOrReply, systemName)];
+                  default:
+                      // 未知框架，尝试 Koa 风格作为回退
+                      console.warn("[requestLoggerUnified] Unknown framework detected, falling back to Koa-style handling");
+                      return [2 /*return*/, handleKoa(contextOrC, nextOrReply, systemName)];
+              }
+              return [2 /*return*/];
+          });
+      }); };
+  }
+  // ==================== 针对特定框架的导出 ====================
+  /**
+   * Hono 专用中间件
+   */
+  function recordLogMiddlewareHono(systemName) {
+      var _this = this;
+      return function (c, next) { return __awaiter(_this, void 0, void 0, function () {
+          return __generator(this, function (_a) {
+              return [2 /*return*/, handleHono(c, next, systemName)];
+          });
+      }); };
+  }
+  /**
+   * Koa 专用中间件
+   */
+  function recordLogMiddlewareKoa(systemName) {
+      var _this = this;
+      return function (ctx, next) { return __awaiter(_this, void 0, void 0, function () {
+          return __generator(this, function (_a) {
+              return [2 /*return*/, handleKoa(ctx, next, systemName)];
+          });
+      }); };
+  }
+  /**
+   * Midway 专用中间件（本质与 Koa 相同，因为 Midway 基于 Koa）
+   */
+  function recordLogMiddlewareMidway(systemName) {
+      var _this = this;
+      return function (ctx, next) { return __awaiter(_this, void 0, void 0, function () {
+          return __generator(this, function (_a) {
+              return [2 /*return*/, handleKoa(ctx, next, systemName)];
+          });
+      }); };
+  }
+  /**
+   * Fastify 专用插件
+   * 使用方式：fastify.addHook('onResponse', recordLogMiddlewareFastify('systemName'))
+   */
+  function recordLogMiddlewareFastify(systemName) {
+      var _this = this;
+      return function (request, reply) { return __awaiter(_this, void 0, void 0, function () {
+          return __generator(this, function (_a) {
+              return [2 /*return*/, handleFastify(request, reply, systemName)];
+          });
+      }); };
+  }
+
+  /**
+   * 扁平化 state 字段
+   * @param state 需要扁平化的 state 字段
+   * @param keyName 需要剥离的 key 名称
+   * @returns 扁平化后的 state 字段
+   */
+  function flattenStateRecursive(state, keyName) {
+      if (keyName === void 0) { keyName = 'state'; }
+      var result = state;
+      var lastResult;
+      // 递归解码和解析
+      while (typeof result === 'string') {
+          try {
+              lastResult = result;
+              result = decodeURIComponent(result);
+              result = JSON.parse(result);
+          }
+          catch (_a) {
+              result = lastResult;
+              break;
+          }
+      }
+      // 递归剥离 state 字段
+      while (result &&
+          typeof result === 'object' &&
+          keyName in result &&
+          (typeof result[keyName] === 'string' || typeof result[keyName] === 'object')) {
+          result = result[keyName];
+          if (typeof result === 'string') {
+              try {
+                  result = decodeURIComponent(result);
+                  result = JSON.parse(result);
+              }
+              catch (_b) {
+                  break;
+              }
+          }
+      }
+      return result;
+  }
+  var handleFlatStr = function (keyName, value) {
+      // return `${key}=${value}`
+      if (keyName === void 0) { keyName = 'state'; }
+      var flat = flattenStateRecursive(value, keyName);
+      var flatStr = typeof flat === 'object' ? JSON.stringify(flat) : String(flat);
+      return flatStr;
+  };
+
+  /**
+   * 颜色处理相关
+   * @packageDocumentation
+   * @module Color
+   * @preferred
+   */
+  /**
+   * 将 Hex 颜色转换为 RGB 数组
+   * @param hex - Hex 格式颜色值（如 #ffffff）
+   * @returns RGB 数组 [r, g, b]
+   */
+  function hexToRgb(hex) {
+      var result = hex.replace('#', '').match(/../g);
+      return result ? result.map(function (val) { return parseInt(val, 16); }) : [0, 0, 0];
+  }
+  /**
+   * 将 RGB 值转换为 Hex 颜色
+   * @param r - 红色值 (0-255)
+   * @param g - 绿色值 (0-255)
+   * @param b - 蓝色值 (0-255)
+   * @returns Hex 格式颜色值（如 #ffffff）
+   */
+  function rgbToHex(r, g, b) {
+      var toHex = function (n) {
+          var hex = n.toString(16);
+          return hex.length === 1 ? '0' + hex : hex;
+      };
+      return "#" + toHex(r) + toHex(g) + toHex(b);
+  }
+  /**
+   * 颜色加深
+   * 使用 RGB 线性计算：color * (1 - level)
+   * @param color - Hex 格式颜色值
+   * @param level - 加深程度 (0-1)
+   * @returns 加深后的 Hex 颜色值
+   */
+  function darken(color, level) {
+      var rgb = hexToRgb(color);
+      var darkened = rgb.map(function (val) { return Math.floor(val * (1 - level)); });
+      return rgbToHex(darkened[0], darkened[1], darkened[2]);
+  }
+  /**
+   * 颜色变浅
+   * 使用 RGB 线性计算：(255 - color) * level + color
+   * @param color - Hex 格式颜色值
+   * @param level - 变浅程度 (0-1)
+   * @returns 变浅后的 Hex 颜色值
+   */
+  function lighten(color, level) {
+      var rgb = hexToRgb(color);
+      var lightened = rgb.map(function (val) { return Math.floor((255 - val) * level + val); });
+      return rgbToHex(lightened[0], lightened[1], lightened[2]);
+  }
+
+  /**
+   * 数组处理相关
+   * @packageDocumentation
+   * @module Array
+   * @preferred
+   */
+  /**
+   * 从对象数组中提取指定 key 的值，组成新数组
+   * @param arr - 对象数组
+   * @param key - 要提取的键名
+   * @returns 提取的值数组
+   */
+  function getKeyList(arr, key) {
+      if (!Array.isArray(arr))
+          return [];
+      var result = [];
+      for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
+          var item = arr_1[_i];
+          if (item && item[key] !== undefined && item[key] !== null) {
+              result.push(item[key]);
+          }
+      }
+      return result;
+  }
+  /**
+   * 判断父数组是否包含子数组的所有元素（深度比较）
+   * 注意：此函数需要配合深度比较工具使用
+   * @param parent - 父数组
+   * @param children - 子数组
+   * @param compareFn - 比较函数，用于判断两个元素是否相等
+   * @returns 是否包含所有子元素
+   */
+  function isIncludeAllChildren(parent, children, compareFn) {
+      if (!Array.isArray(parent) || !Array.isArray(children))
+          return false;
+      var defaultCompareFn = function (a, b) { return JSON.stringify(a) === JSON.stringify(b); };
+      var compare = compareFn || defaultCompareFn;
+      return children.every(function (child) { return parent.some(function (item) { return compare(item, child); }); });
+  }
+  /**
+   * 判断数组或对象是否为空
+   * @param value - 待检查的值
+   * @returns 是否为空
+   */
+  function isAllEmpty(value) {
+      if (value === null || value === undefined)
+          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;
+  }
+  /**
+   * 计算两个数组的交集
+   * @param arr1 - 数组1
+   * @param arr2 - 数组2
+   * @returns 交集数组
+   */
+  function intersection(arr1, arr2) {
+      if (!Array.isArray(arr1) || !Array.isArray(arr2))
+          return [];
+      return arr1.filter(function (item) { return arr2.includes(item); });
+  }
+  /**
+   * 数组求和
+   * @param arr - 数字数组
+   * @returns 数组元素之和
+   */
+  function sum(arr) {
+      return Array.isArray(arr) && arr.length > 0
+          ? arr.reduce(function (acc, val) { return acc + val; }, 0)
+          : 0;
+  }
+
+  /**
+   * DOM 操作相关
+   * @packageDocumentation
+   * @module DOM
+   * @preferred
+   */
+  /**
+   * 检查元素是否包含指定的 class
+   * @param el - DOM 元素
+   * @param cls - class 名称
+   * @returns 是否包含该 class
+   */
+  function hasClass(el, cls) {
+      if (typeof window === 'undefined' || !el)
+          return false;
+      return !!el.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
+  }
+  /**
+   * 添加 class 到元素
+   * @param el - DOM 元素
+   * @param cls - class 名称
+   */
+  function addClass(el, cls) {
+      if (typeof window === 'undefined' || !el)
+          return;
+      if (!hasClass(el, cls)) {
+          el.className += ' ' + cls;
+      }
+  }
+  /**
+   * 从元素移除 class
+   * @param el - DOM 元素
+   * @param cls - class 名称
+   */
+  function removeClass(el, cls) {
+      if (typeof window === 'undefined' || !el)
+          return;
+      if (hasClass(el, cls)) {
+          var reg = new RegExp('(\\s|^)' + cls + '(\\s|$)');
+          el.className = el.className.replace(reg, ' ').trim();
+      }
+  }
+  /**
+   * 切换元素的 class
+   * @param flag - 是否添加 class
+   * @param clsName - class 名称
+   * @param target - 目标元素，默认为 document.body
+   */
+  function toggleClass(flag, clsName, target) {
+      if (typeof window === 'undefined')
+          return;
+      var targetEl = target || document.body;
+      var className = targetEl.className;
+      className = className.replace(clsName, '').trim();
+      targetEl.className = flag ? (className + " " + clsName).trim() : className;
+  }
+  /**
+   * 打开链接
+   * @param url - URL 地址
+   * @param target - 打开方式，默认 "_blank"
+   */
+  function openLink(url, target) {
+      if (target === void 0) { target = '_blank'; }
+      if (typeof window === 'undefined')
+          return;
+      var link = document.createElement('a');
+      link.setAttribute('href', url);
+      link.setAttribute('target', target);
+      link.setAttribute('rel', 'noreferrer noopener');
+      link.setAttribute('id', 'external');
+      var existingLink = document.getElementById('external');
+      if (existingLink) {
+          document.body.removeChild(existingLink);
+      }
+      document.body.appendChild(link);
+      link.click();
+      link.remove();
+  }
+  /**
+   * 复制文本到剪贴板
+   * @param text - 要复制的文本
+   * @returns 是否复制成功
+   */
+  function copyTextToClipboard(text) {
+      if (typeof window === 'undefined' || typeof document === 'undefined') {
+          return false;
+      }
+      // 创建临时文本框
+      var textarea = document.createElement('textarea');
+      var activeElement = document.activeElement;
+      textarea.value = text;
+      textarea.setAttribute('readonly', '');
+      textarea.style.position = 'absolute';
+      textarea.style.left = '-9999px';
+      textarea.style.fontSize = '12pt';
+      textarea.style.border = '0';
+      textarea.style.padding = '0';
+      textarea.style.margin = '0';
+      // 保存当前选区
+      var selection = document.getSelection();
+      var originalRange = null;
+      if (selection && selection.rangeCount > 0) {
+          originalRange = selection.getRangeAt(0);
+      }
+      // 添加到 DOM 并选中
+      document.body.appendChild(textarea);
+      textarea.select();
+      textarea.selectionStart = 0;
+      textarea.selectionEnd = text.length;
+      // 执行复制
+      var success = false;
+      try {
+          success = document.execCommand('copy');
+      }
+      catch (err) {
+          console.error('复制失败:', err);
+      }
+      // 清理
+      textarea.remove();
+      // 恢复原选区
+      if (originalRange && selection) {
+          selection.removeAllRanges();
+          selection.addRange(originalRange);
+      }
+      // 恢复焦点
+      if (activeElement) {
+          activeElement.focus();
+      }
+      return success;
+  }
+  /**
+   * 解析 SVG 字符串，提取宽度、高度和 body 内容
+   * @param svg - SVG 字符串
+   * @returns SVG 信息对象或原字符串
+   */
+  function getSvgInfo(svg) {
+      if (typeof window === 'undefined' || typeof DOMParser === 'undefined') {
+          return svg;
+      }
+      try {
+          var parser = new DOMParser();
+          var doc = parser.parseFromString(svg, 'image/svg+xml');
+          var svgElement = doc.querySelector('svg');
+          if (!svgElement) {
+              return svg;
+          }
+          var viewBox = svgElement.getAttribute('viewBox');
+          if (!viewBox) {
+              throw new Error('Invalid SVG string: Missing viewBox attribute.');
+          }
+          var viewBoxParts = viewBox.split(' ');
+          var width = parseInt(viewBoxParts[2], 10);
+          var height = parseInt(viewBoxParts[3], 10);
+          var paths = Array.from(svgElement.querySelectorAll('path'));
+          var body = paths.map(function (path) { return path.outerHTML; }).join(' ');
+          return {
+              width: width,
+              height: height,
+              body: body,
+          };
+      }
+      catch (error) {
+          console.error('解析 SVG 失败:', error);
+          return svg;
+      }
+  }
+
+  var WebsocketManager = /** @class */ (function () {
+      function WebsocketManager(options) {
+          this.ws = null;
+          this.reconnectAttempts = 0;
+          this.heartbeatTimer = null;
+          this.listeners = new Map();
+          this.opts = {
+              url: options.url,
+              reconnectAttemptsLimit: options.reconnectAttemptsLimit || 5,
+              reconnectInterval: options.reconnectInterval || 5000,
+              heartbeatInterval: options.heartbeatInterval || 30000,
+              registerMessage: options.registerMessage
+          };
+      }
+      Object.defineProperty(WebsocketManager.prototype, "url", {
+          get: function () {
+              return this.opts.url;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      WebsocketManager.prototype.on = function (event, handler) {
+          if (!this.listeners.has(event)) {
+              this.listeners.set(event, new Set());
+          }
+          var set = this.listeners.get(event);
+          set.add(handler);
+          return function () { return set.delete(handler); };
+      };
+      WebsocketManager.prototype.emit = function (event, payload) {
+          var set = this.listeners.get(event);
+          if (!set)
+              return;
+          set.forEach(function (fn) {
+              try {
+                  fn(payload);
+              }
+              catch (_a) { }
+          });
+      };
+      WebsocketManager.prototype.connect = function () {
+          try {
+              this.ws = new WebSocket(this.opts.url);
+              this.setupEventListeners();
+          }
+          catch (err) {
+              this.emit('error', { message: 'WebSocket create failed' });
+          }
+      };
+      WebsocketManager.prototype.setupEventListeners = function () {
+          var _this = this;
+          if (!this.ws)
+              return;
+          this.ws.onopen = function () {
+              _this.reconnectAttempts = 0;
+              if (_this.opts.registerMessage) {
+                  _this.send(_this.opts.registerMessage);
+              }
+              _this.startHeartbeat();
+              _this.emit('connected', true);
+          };
+          this.ws.onmessage = function (event) {
+              try {
+                  var data = JSON.parse(event.data);
+                  _this.emit('message', data);
+              }
+              catch (_a) {
+                  _this.emit('error', { message: 'Message parse failed' });
+              }
+          };
+          this.ws.onclose = function () {
+              _this.stopHeartbeat();
+              _this.emit('connected', false);
+              _this.emit('closed', undefined);
+              _this.reconnect();
+          };
+          this.ws.onerror = function () {
+              _this.emit('error', { message: 'WebSocket error' });
+          };
+      };
+      WebsocketManager.prototype.send = function (data) {
+          if (this.ws && this.ws.readyState === 1) {
+              try {
+                  this.ws.send(JSON.stringify(data));
+              }
+              catch (_a) { }
+          }
+      };
+      WebsocketManager.prototype.startHeartbeat = function () {
+          var _this = this;
+          this.stopHeartbeat();
+          this.heartbeatTimer = setInterval(function () {
+              _this.send({ type: 'ping' });
+          }, this.opts.heartbeatInterval);
+      };
+      WebsocketManager.prototype.stopHeartbeat = function () {
+          if (this.heartbeatTimer != null) {
+              clearInterval(this.heartbeatTimer);
+              this.heartbeatTimer = null;
+          }
+      };
+      WebsocketManager.prototype.reconnect = function () {
+          var _this = this;
+          if (this.reconnectAttempts < this.opts.reconnectAttemptsLimit) {
+              this.reconnectAttempts++;
+              setTimeout(function () {
+                  _this.connect();
+              }, this.opts.reconnectInterval);
+          }
+      };
+      WebsocketManager.prototype.disconnect = function () {
+          this.stopHeartbeat();
+          if (this.ws) {
+              try {
+                  this.ws.close();
+              }
+              catch (_a) { }
+          }
+          this.ws = null;
+      };
+      Object.defineProperty(WebsocketManager.prototype, "isConnected", {
+          get: function () {
+              return !!this.ws && this.ws.readyState === 1;
+          },
+          enumerable: false,
+          configurable: true
+      });
+      return WebsocketManager;
+  }());
+
+  var WebSocketService = /** @class */ (function () {
+      function WebSocketService() {
+          this.initialized = false;
+          this.manager = null;
+      }
+      WebSocketService.getInstance = function () {
+          if (!WebSocketService.instance) {
+              WebSocketService.instance = new WebSocketService();
+          }
+          return WebSocketService.instance;
+      };
+      WebSocketService.prototype.init = function (options) {
+          return __awaiter(this, void 0, void 0, function () {
+              return __generator(this, function (_a) {
+                  if (this.initialized)
+                      return [2 /*return*/];
+                  this.manager = new WebsocketManager(options);
+                  this.manager.connect();
+                  this.initialized = true;
+                  return [2 /*return*/];
+              });
+          });
+      };
+      WebSocketService.prototype.destroy = function () {
+          this.manager && this.manager.disconnect();
+          this.manager = null;
+          this.initialized = false;
+      };
+      WebSocketService.prototype.getManager = function () {
+          return this.manager;
+      };
+      return WebSocketService;
+  }());
+  var websocketService = WebSocketService.getInstance();
+
+  var Emitter = /** @class */ (function () {
+      function Emitter() {
+          this.listeners = new Map();
+      }
+      Emitter.prototype.on = function (event, handler) {
+          if (!this.listeners.has(event)) {
+              this.listeners.set(event, new Set());
+          }
+          var set = this.listeners.get(event);
+          set.add(handler);
+          return function () { return set.delete(handler); };
+      };
+      Emitter.prototype.off = function (event, handler) {
+          var set = this.listeners.get(event);
+          if (!set)
+              return;
+          set.delete(handler);
+      };
+      Emitter.prototype.emit = function (event, payload) {
+          var set = this.listeners.get(event);
+          if (!set)
+              return;
+          set.forEach(function (fn) {
+              try {
+                  fn(payload);
+              }
+              catch (_a) { }
+          });
+      };
+      return Emitter;
+  }());
+  var emitter = new Emitter();
+
+  var createWebSocketStore = function (storeId) {
+      if (storeId === void 0) { storeId = 'websocket'; }
+      return pinia.defineStore(storeId, {
+          state: function () { return ({
+              isConnected: false,
+              wsManager: null,
+              messages: [],
+              connectionError: null
+          }); },
+          getters: {
+              connectionStatus: function (state) { return (state.isConnected ? '已连接' : '未连接'); },
+              lastMessage: function (state) { return state.messages[state.messages.length - 1] || null; }
+          },
+          actions: {
+              connect: function (options) {
+                  var _a;
+                  return __awaiter(this, void 0, void 0, function () {
+                      return __generator(this, function (_b) {
+                          if ((_a = this.wsManager) === null || _a === void 0 ? void 0 : _a.isConnected)
+                              return [2 /*return*/];
+                          this.wsManager = new WebsocketManager(options);
+                          this.setupEventListeners();
+                          this.wsManager.connect();
+                          return [2 /*return*/];
+                      });
+                  });
+              },
+              setupEventListeners: function () {
+                  var _this = this;
+                  if (!this.wsManager)
+                      return;
+                  this.wsManager.on('connected', function (status) {
+                      _this.isConnected = status;
+                      if (status)
+                          _this.connectionError = null;
+                      emitter.emit('websocket-connected', status);
+                  });
+                  this.wsManager.on('message', function (data) {
+                      _this.addMessage(data);
+                      emitter.emit('websocket-message', data);
+                  });
+                  this.wsManager.on('error', function (error) {
+                      _this.connectionError = (error === null || error === void 0 ? void 0 : error.message) || 'WebSocket error';
+                      emitter.emit('websocket-error', { message: _this.connectionError });
+                  });
+                  this.wsManager.on('closed', function () {
+                      _this.isConnected = false;
+                      emitter.emit('websocket-closed', undefined);
+                  });
+              },
+              sendMessage: function (data) {
+                  var _a;
+                  (_a = this.wsManager) === null || _a === void 0 ? void 0 : _a.send(data);
+              },
+              addMessage: function (message) {
+                  var msg = __assign(__assign({}, message), { timestamp: Date.now(), id: Math.random().toString(36).substring(2, 11) });
+                  this.messages.push(msg);
+                  if (this.messages.length > 100) {
+                      this.messages.shift();
+                  }
+              },
+              clearMessages: function () {
+                  this.messages = [];
+              },
+              disconnect: function () {
+                  var _a;
+                  (_a = this.wsManager) === null || _a === void 0 ? void 0 : _a.disconnect();
+                  this.wsManager = null;
+                  this.isConnected = false;
+                  this.connectionError = null;
+              },
+              reset: function () {
+                  this.disconnect();
+                  this.clearMessages();
+              }
+          }
+      });
+  };
+
+  exports.ApiBuilder = ApiBuilder;
+  exports.InsertBuilder = InsertBuilder;
+  exports.QueryBuilder = QueryBuilder;
+  exports.UpdateBuilder = UpdateBuilder;
+  exports.WebsocketManager = WebsocketManager;
+  exports.addClass = addClass;
+  exports.addDays = addDays;
+  exports.base64ToBlob = base64ToBlob;
+  exports.base64ToFile = base64ToFile;
+  exports.base64ToFileOrBlob = base64ToFileOrBlob;
+  exports.blobToDataURL = blobToDataURL;
+  exports.buildUUID = buildUUID;
+  exports.calcFileSize = calcFileSize;
+  exports.ceil = ceil;
+  exports.clearLoginData = clearLoginData;
+  exports.compatibleDate = compatibleDate;
+  exports.compressImg = compressImg;
+  exports.computeMoney = computeMoney;
+  exports.convertBase64UrlToBlob = convertBase64UrlToBlob;
+  exports.convertCurrency = convertCurrency;
+  exports.copyTextToClipboard = copyTextToClipboard;
+  exports.createWebSocketStore = createWebSocketStore;
+  exports.darken = darken;
+  exports.dataURLtoBlob = dataURLtoBlob;
+  exports.deepEqual = deepEqual;
+  exports.delay = delay;
+  exports.deviceDetection = deviceDetection;
+  exports.emitter = emitter;
+  exports.fileSizeFormat = fileSizeFormat;
+  exports.filterRepeat = filterRepeat;
+  exports.findNodePath = findNodePath;
+  exports.floor = floor;
+  exports.formatBank = formatBank;
+  exports.formatBytes = formatBytes;
+  exports.formatCentsToYuan = formatCentsToYuan;
+  exports.formatEmptyValue = formatEmptyValue;
+  exports.formatFloat = formatFloat;
+  exports.formatMoney = formatMoney;
+  exports.formatPhone = formatPhone;
+  exports.formatPhoneHide = formatPhoneHide;
+  exports.formatTime = formatTime;
+  exports.formateTimestamp = formateTimestamp;
+  exports.fromNow = fromNow;
+  exports.genExportByBlob = genExportByBlob;
+  exports.generateEnglishLetters = generateEnglishLetters;
+  exports.getCookie = getCookie;
+  exports.getDeviceType = getDeviceType;
+  exports.getEnvironment = getEnvironment;
+  exports.getFileData = getFileData;
+  exports.getFromType = getFromType;
+  exports.getIsComWx = getIsComWx;
+  exports.getIsDevelopment = getIsDevelopment;
+  exports.getKeyList = getKeyList;
+  exports.getQueryMap = getQueryMap;
+  exports.getQueryString = getQueryString;
+  exports.getQueryVariable = getQueryVariable;
+  exports.getSvgInfo = getSvgInfo;
+  exports.getTicket = getTicket;
+  exports.getToken = getToken;
+  exports.getWecomToken = getWecomToken;
+  exports.handleFlatStr = handleFlatStr;
+  exports.hasClass = hasClass;
+  exports.hexToRgb = hexToRgb;
+  exports.hideTextAtIndex = hideTextAtIndex;
+  exports.http = http;
+  exports.httpEnum = httpEnum;
+  exports.humpTurnDashed = humpTurnDashed;
+  exports.intersection = intersection;
+  exports.isAllEmpty = isAllEmpty;
+  exports.isEmail = isEmail;
+  exports.isEmpty = isEmpty;
+  exports.isExternal = isExternal;
+  exports.isImage = isImage;
+  exports.isIncludeAllChildren = isIncludeAllChildren;
+  exports.isMobile = isMobile;
+  exports.isMobileSimple = isMobileSimple;
+  exports.isPhone = isPhone;
+  exports.isQQ = isQQ;
+  exports.isTelephone = isTelephone;
+  exports.isUrl = isUrl;
+  exports.lighten = lighten;
+  exports.newDate = newDate;
+  exports.openLink = openLink;
+  exports.randomString = randomString;
+  exports.recordLogMiddleware = recordLogMiddleware;
+  exports.recordLogMiddlewareFastify = recordLogMiddlewareFastify;
+  exports.recordLogMiddlewareHono = recordLogMiddlewareHono;
+  exports.recordLogMiddlewareKoa = recordLogMiddlewareKoa;
+  exports.recordLogMiddlewareMidway = recordLogMiddlewareMidway;
+  exports.removeClass = removeClass;
+  exports.removeTicket = removeTicket;
+  exports.removeToken = removeToken;
+  exports.rgbToHex = rgbToHex;
+  exports.sendLog = sendLog;
+  exports.setTicket = setTicket;
+  exports.subBefore = subBefore;
+  exports.sum = sum;
+  exports.toThousands = toThousands;
+  exports.toggleClass = toggleClass;
+  exports.trimVal = trimVal;
+  exports.uuid = uuid;
+  exports.validateTwoDecimal = validateTwoDecimal;
+  exports.websocketService = websocketService;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));