gis-common 4.2.2 → 4.2.4

package/dist/gis-common.es.js

@@ -37,16 +37,20 @@ var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
   ErrorType2["AUTH_VERIFY_ERROR"] = "权限验证失败";
   ErrorType2["NO_DATA_FOUND"] = "未找到数据";
   ErrorType2["DUPLICATE_INSTANCE"] = "实例为单例模式，不允许重复构建";
-  ErrorType2["COORDINATE_ERROR"] = "坐标验证失败";
   ErrorType2["JSON_PARSE_ERROR"] = "JSON解析失败，格式有误";
   ErrorType2["JSON_VALUE_ERROR"] = "JSON无此键";
-  ErrorType2["PARAMETER_ERROR"] = "验证数据类型失败";
-  ErrorType2["PARAMETER_ERROR_ARRAY"] = "格式类型验证失败：必须是数组";
-  ErrorType2["PARAMETER_ERROR_STRING"] = "格式类型验证失败：必须是字符";
-  ErrorType2["PARAMETER_ERROR_FUNCTION"] = "格式类型验证失败：必须是函数";
-  ErrorType2["PARAMETER_ERROR_OBJECT"] = "格式类型验证失败：必须是对象";
-  ErrorType2["PARAMETER_ERROR_LACK"] = "参数缺失";
   ErrorType2["STRING_CHECK_LOSS"] = "字符缺少关键字";
+  ErrorType2["PARAMETER_ERROR"] = "验证数据类型失败";
+  ErrorType2["PARAMETER_ERROR_ARRAY"] = "验证数据类型失败，必须是数组";
+  ErrorType2["PARAMETER_ERROR_STRING"] = "验证数据类型失败，必须是字符";
+  ErrorType2["PARAMETER_ERROR_FUNCTION"] = "验证数据类型失败，必须是函数";
+  ErrorType2["PARAMETER_ERROR_OBJECT"] = "验证数据类型失败，必须是对象";
+  ErrorType2["PARAMETER_ERROR_NUMBER"] = "验证数据类型失败，必须是数值";
+  ErrorType2["PARAMETER_ERROR_LACK"] = "验证数据类型失败，必须非空";
+  ErrorType2["DATA_ERROR"] = "格式类型验证失败";
+  ErrorType2["DATA_ERROR_COORDINATE"] = "格式类型验证失败，必须是坐标";
+  ErrorType2["DATA_ERROR_COLOR"] = "格式类型验证失败，必须是颜色代码";
+  ErrorType2["DATA_ERROR_GEOJSON"] = "格式类型验证失败，必须是GeoJSON";
   return ErrorType2;
 })(ErrorType || {});
 var LayerType = /* @__PURE__ */ ((LayerType2) => {
@@ -274,17 +278,14 @@ class CanvasDrawer {
     }
   }
   static createCanvas(width = 1, height = 1) {
-    let canvas;
-    if (typeof document !== "undefined") {
-      canvas = document.createElement("canvas");
-      if (width) {
-        canvas.width = width;
-      }
-      if (height) {
-        canvas.height = height;
-      }
-      return canvas;
+    const canvas = document.createElement("canvas");
+    if (width) {
+      canvas.width = width;
+    }
+    if (height) {
+      canvas.height = height;
     }
+    return canvas;
   }
 }
 class EventDispatcher {
@@ -476,7 +477,7 @@ class WebSocketClient extends EventDispatcher {
     }, 1e3);
   }
 }
-const CommUtils = {
+const CommUtil = {
   /**
    * 获取数据类型
    *
@@ -535,9 +536,6 @@ const CommUtils = {
         return false;
     }
   },
-  isNotEmpty(val) {
-    return !this.isEmpty(val);
-  },
   /**
    * 将JSON对象转换为FormData对象
    *
@@ -937,10 +935,10 @@ const _MqttClient = class _MqttClient extends EventDispatcher {
     __publicField(this, "options");
     __publicField(this, "client");
     __publicField(this, "topics");
-    this.context = CommUtils.extend(_MqttClient.defaultContext, config);
+    this.context = CommUtil.extend(_MqttClient.defaultContext, config);
     this.options = {
       connectTimeout: this.context.MQTT_TIMEOUTM,
-      clientId: CommUtils.guid(),
+      clientId: CommUtil.guid(),
       username: this.context.MQTT_USERNAME,
       password: this.context.MQTT_PASSWORD,
       clean: true
@@ -1247,7 +1245,7 @@ const AjaxUtil = {
    * @param callback  - callback function when completed
    */
   jsonp(url, callback) {
-    const name = "_jsonp_" + CommUtils.guid();
+    const name = "_jsonp_" + CommUtil.guid();
     const head = document.getElementsByTagName("head")[0];
     if (url.includes("?")) {
       url += "&callback=" + name;
@@ -1286,7 +1284,7 @@ const AjaxUtil = {
    * );
    */
   get(url, options, cb) {
-    if (CommUtils.isFunction(options)) {
+    if (CommUtil.isFunction(options)) {
       const t = cb;
       cb = options;
       options = t;
@@ -1418,7 +1416,7 @@ const AjaxUtil = {
    * );
    */
   getArrayBuffer(url, options, cb) {
-    if (CommUtils.isFunction(options)) {
+    if (CommUtil.isFunction(options)) {
       const t = cb;
       cb = options;
       options = t;
@@ -1471,7 +1469,7 @@ const AjaxUtil = {
    * );
    */
   getJSON(url, options, cb) {
-    if (CommUtils.isFunction(options)) {
+    if (CommUtil.isFunction(options)) {
       const t = cb;
       cb = options;
       options = t;
@@ -1488,691 +1486,519 @@ const AjaxUtil = {
     return this.get(url, options, callback);
   }
 };
-const BrowserUtil = {
+const GeoUtil = {
+  toRadian: Math.PI / 180,
+  R: 6371393,
   /**
-   * 获取浏览器类型
+   * 判断给定的经纬度是否合法
    *
-   * @returns 返回浏览器类型字符串，可能的值为 'IE'、'Firefox'、'Chrome'、'Opera'、'Safari' 或 'Unknown'
+   * @param lng 经度值
+   * @param lat 纬度值
+   * @returns 如果经纬度合法，返回true；否则返回false
    */
-  getExplorer() {
-    var explorer = window.navigator.userAgent;
-    if (explorer.indexOf("MSIE") >= 0 || /Trident\//.test(explorer)) {
-      return "IE";
-    } else if (explorer.indexOf("Firefox") >= 0) {
-      return "Firefox";
-    } else if (explorer.indexOf("Chrome") >= 0) {
-      return "Chrome";
-    } else if (explorer.indexOf("Opera") >= 0) {
-      return "Opera";
-    } else if (explorer.indexOf("Safari") >= 0 && explorer.indexOf("Chrome") === -1) {
-      return "Safari";
-    }
-    return "Unknown";
+  isLnglat(lng, lat) {
+    return !isNaN(lng) && !isNaN(lat) && !!(+lat > -90 && +lat < 90 && +lng > -180 && +lng < 180);
   },
   /**
-   * 检测操作系统类型
+   * 计算两哥平面坐标点间的距离
    *
-   * @returns 返回操作系统类型字符串，可能的值有：'MS Windows'、'Apple mac'、'Linux'、'Unix'
+   * @param p1 坐标点1，包含x和y属性
+   * @param p2 坐标点2，包含x和y属性
+   * @returns 返回两点间的欧几里得距离
    */
-  detectOS() {
-    let os_type = "";
-    const windows = navigator.userAgent.indexOf("Windows", 0) != -1 ? 1 : 0;
-    const mac = navigator.userAgent.indexOf("mac", 0) != -1 ? 1 : 0;
-    const linux = navigator.userAgent.indexOf("Linux", 0) != -1 ? 1 : 0;
-    const unix = navigator.userAgent.indexOf("X11", 0) != -1 ? 1 : 0;
-    if (windows) os_type = "MS Windows";
-    else if (mac) os_type = "Apple mac";
-    else if (linux) os_type = "Linux";
-    else if (unix) os_type = "Unix";
-    return os_type;
+  distance(p1, p2) {
+    return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
   },
   /**
-   * 切换全屏状态
+   * 计算两个经纬度点之间的距离
    *
-   * @param status 是否全屏
+   * @param A 经纬度点A，包含lng（经度）和lat（纬度）两个属性
+   * @param B 经纬度点B，包含lng（经度）和lat（纬度）两个属性
+   * @returns 返回两点之间的距离，单位为米
    */
-  switchFullScreen(status) {
-    if (status) {
-      const element = document.documentElement;
-      if (element.requestFullscreen) {
-        element.requestFullscreen();
-      } else if ("msRequestFullscreen" in element) {
-        element.msRequestFullscreen();
-      } else if ("mozRequestFullScreen" in element) {
-        element.mozRequestFullScreen();
-      } else if ("webkitRequestFullscreen" in element) {
-        element.webkitRequestFullscreen();
-      }
-    } else {
-      if (document.exitFullscreen) {
-        document.exitFullscreen();
-      } else if ("msExitFullscreen" in document) {
-        document.msExitFullscreen();
-      } else if ("mozCancelFullScreen" in document) {
-        document.mozCancelFullScreen();
-      } else if ("webkitExitFullscreen" in document) {
-        document.webkitExitFullscreen();
-      }
-    }
+  distanceByPoints(A, B) {
+    const { lng: lngA, lat: latA } = A;
+    const { lng: lngB, lat: latB } = B;
+    const earthR = 6371e3;
+    const x = Math.cos(latA * Math.PI / 180) * Math.cos(latB * Math.PI / 180) * Math.cos((lngA - lngB) * Math.PI / 180);
+    const y = Math.sin(latA * Math.PI / 180) * Math.sin(latB * Math.PI / 180);
+    let s = x + y;
+    if (s > 1) s = 1;
+    if (s < -1) s = -1;
+    const alpha = Math.acos(s);
+    const distance = alpha * earthR;
+    return distance;
   },
   /**
-   * 刷新缩放比例
+   * 格式化经纬度为度分秒格式
    *
-   * @returns 无返回值
+   * @param lng 经度
+   * @param lat 纬度
+   * @returns 返回格式化后的经纬度字符串，格式为：经度度分秒,纬度度分秒
    */
-  refreshScale() {
-    const baseWidth = document.documentElement.clientWidth || 0;
-    const baseHeight = document.documentElement.clientHeight || 0;
-    const appElement = document.getElementById("app");
-    if (!appElement) return;
-    const appStyle = appElement.style;
-    const realRatio = baseWidth / baseHeight;
-    const designRatio = 16 / 9;
-    let scaleRate = baseWidth / 1920;
-    if (realRatio > designRatio) {
-      scaleRate = baseHeight / 1080;
+  formatLnglat(lng, lat) {
+    let res = "";
+    function formatDegreeToDMS(valueInDegrees) {
+      const degree = Math.floor(valueInDegrees);
+      const minutes = Math.floor((valueInDegrees - degree) * 60);
+      const seconds = (valueInDegrees - degree) * 3600 - minutes * 60;
+      return `${degree}°${minutes}′${seconds.toFixed(2)}″`;
     }
-    appStyle.transformOrigin = "left top";
-    appStyle.transform = `scale(${scaleRate}) translateX(-49.99%)`;
-    appStyle.width = `${baseWidth / scaleRate}px`;
+    if (this.isLnglat(lng, lat)) {
+      res = formatDegreeToDMS(lng) + "," + formatDegreeToDMS(lat);
+    } else if (!isNaN(lng)) {
+      res = formatDegreeToDMS(lng);
+    } else if (!isNaN(lat)) {
+      res = formatDegreeToDMS(lat);
+    }
+    return res;
   },
   /**
-   * 获取HTML字体大小
+   * 将经纬度字符串转换为度
    *
-   * @returns 无返回值，该函数会直接修改HTML元素的字体大小
+   * @param lng 经度字符串
+   * @param lat 纬度字符串
+   * @returns 转换后的经纬度对象
    */
-  getHtmlFontSize() {
-    const htmlwidth = document.documentElement.clientWidth || document.body.clientWidth;
-    const htmlDom = document.querySelector("html");
-    if (htmlDom) {
-      htmlDom.style.fontSize = htmlwidth / 192 + "px";
+  transformLnglat(lng, lat) {
+    function dms2deg(dmsString) {
+      const isNegative = /[sw]/i.test(dmsString);
+      let factor = isNegative ? -1 : 1;
+      const numericParts = dmsString.match(/[\d.]+/g) || [];
+      let degrees = 0;
+      for (let i = 0; i < numericParts.length; i++) {
+        degrees += parseFloat(numericParts[i]) / factor;
+        factor *= 60;
+      }
+      return degrees;
+    }
+    if (lng && lat) {
+      return {
+        lng: dms2deg(lng),
+        lat: dms2deg(lat)
+      };
     }
-  }
-};
-const CoordsUtil = {
-  PI: 3.141592653589793,
-  XPI: 3.141592653589793 * 3e3 / 180,
-  delta(lat, lng) {
-    const a = 6378245;
-    const ee = 0.006693421622965943;
-    let dLat = this.transformLat(lng - 105, lat - 35);
-    let dLon = this.transformLon(lng - 105, lat - 35);
-    const radLat = lat / 180 * this.PI;
-    let magic = Math.sin(radLat);
-    magic = 1 - ee * magic * magic;
-    const sqrtMagic = Math.sqrt(magic);
-    dLat = dLat * 180 / (a * (1 - ee) / (magic * sqrtMagic) * this.PI);
-    dLon = dLon * 180 / (a / sqrtMagic * Math.cos(radLat) * this.PI);
-    return { lat: dLat, lng: dLon };
   },
   /**
-   * 判断经纬度是否不在中国境内
+   * 射线法判断点是否在多边形内
    *
-   * @param lng 经度
-   * @param lat 纬度
-   * @returns 如果经纬度不在中国境内则返回true，否则返回false
+   * @param p 点对象，包含x和y属性
+   * @param poly 多边形顶点数组，可以是字符串数组或对象数组
+   * @returns 返回字符串，表示点相对于多边形的位置：'in'表示在多边形内，'out'表示在多边形外，'on'表示在多边形上
    */
-  outOfChina(lng, lat) {
-    if (lng < 72.004 || lng > 137.8347) {
-      return true;
-    }
-    if (lat < 0.8293 || lat > 55.8271) {
-      return true;
+  rayCasting(p, poly) {
+    var px = p.x, py = p.y, flag = false;
+    for (var i = 0, l = poly.length, j = l - 1; i < l; j = i, i++) {
+      var sx = poly[i].x, sy = poly[i].y, tx = poly[j].x, ty = poly[j].y;
+      if (sx === px && sy === py || tx === px && ty === py) {
+        return "on";
+      }
+      if (sy < py && ty >= py || sy >= py && ty < py) {
+        var x = sx + (py - sy) * (tx - sx) / (ty - sy);
+        if (x === px) {
+          return "on";
+        }
+        if (x > px) {
+          flag = !flag;
+        }
+      }
     }
-    return false;
+    return flag ? "in" : "out";
   },
-  // WGS-84 to GCJ-02
-  gcjEncrypt(wgsLat, wgsLon) {
-    if (this.outOfChina(wgsLat, wgsLon)) {
-      return { lat: wgsLat, lng: wgsLon };
-    }
-    const d = this.delta(wgsLat, wgsLon);
-    return { lat: wgsLat + d.lat, lng: wgsLon + d.lng };
+  /**
+   * 旋转点
+   *
+   * @param p1 旋转前点坐标
+   * @param p2 旋转中心坐标
+   * @param θ 旋转角度（顺时针旋转为正）
+   * @returns 旋转后点坐标
+   */
+  rotatePoint(p1, p2, θ) {
+    const x = (p1.x - p2.x) * Math.cos(Math.PI / 180 * -θ) - (p1.y - p2.y) * Math.sin(Math.PI / 180 * -θ) + p2.x;
+    const y = (p1.x - p2.x) * Math.sin(Math.PI / 180 * -θ) + (p1.y - p2.y) * Math.cos(Math.PI / 180 * -θ) + p2.y;
+    return { x, y };
   },
-  // GCJ-02 to WGS-84
-  gcjDecrypt(gcjLat, gcjLon) {
-    if (this.outOfChina(gcjLat, gcjLon)) {
-      return { lat: gcjLat, lng: gcjLon };
-    }
-    const d = this.delta(gcjLat, gcjLon);
-    return { lat: gcjLat - d.lat, lng: gcjLon - d.lng };
-  },
-  // GCJ-02 to WGS-84 exactly
-  gcjDecryptExact(gcjLat, gcjLon) {
-    const initDelta = 0.01;
-    const threshold = 1e-9;
-    let dLat = initDelta;
-    let dLon = initDelta;
-    let mLat = gcjLat - dLat;
-    let mLon = gcjLon - dLon;
-    let pLat = gcjLat + dLat;
-    let pLon = gcjLon + dLon;
-    let wgsLat = 0;
-    let wgsLon = 0;
-    let i = 0;
-    while (1) {
-      wgsLat = (mLat + pLat) / 2;
-      wgsLon = (mLon + pLon) / 2;
-      const tmp = this.gcjEncrypt(wgsLat, wgsLon);
-      dLat = tmp.lat - gcjLat;
-      dLon = tmp.lng - gcjLon;
-      if (Math.abs(dLat) < threshold && Math.abs(dLon) < threshold) {
-        break;
-      }
-      if (dLat > 0) pLat = wgsLat;
-      else mLat = wgsLat;
-      if (dLon > 0) pLon = wgsLon;
-      else mLon = wgsLon;
-      if (++i > 1e4) break;
-    }
-    return { lat: wgsLat, lng: wgsLon };
-  },
-  // GCJ-02 to BD-09
-  bdEncrypt(gcjLat, gcjLon) {
-    const x = gcjLon;
-    const y = gcjLat;
-    const z = Math.sqrt(x * x + y * y) + 2e-5 * Math.sin(y * this.XPI);
-    const theta = Math.atan2(y, x) + 3e-6 * Math.cos(x * this.XPI);
-    const bdLon = z * Math.cos(theta) + 65e-4;
-    const bdLat = z * Math.sin(theta) + 6e-3;
-    return { lat: bdLat, lng: bdLon };
-  },
-  // BD-09 to GCJ-02
-  bdDecrypt(bdLat, bdLon) {
-    const x = bdLon - 65e-4;
-    const y = bdLat - 6e-3;
-    const z = Math.sqrt(x * x + y * y) - 2e-5 * Math.sin(y * this.XPI);
-    const theta = Math.atan2(y, x) - 3e-6 * Math.cos(x * this.XPI);
-    const gcjLon = z * Math.cos(theta);
-    const gcjLat = z * Math.sin(theta);
-    return { lat: gcjLat, lng: gcjLon };
-  },
-  // WGS-84 to Web mercator
-  // mercatorLat -> y mercatorLon -> x
-  mercatorEncrypt(wgsLat, wgsLon) {
-    const x = wgsLon * 2003750834e-2 / 180;
-    let y = Math.log(Math.tan((90 + wgsLat) * this.PI / 360)) / (this.PI / 180);
-    y = y * 2003750834e-2 / 180;
-    return { lat: y, lng: x };
-  },
-  // Web mercator to WGS-84
-  // mercatorLat -> y mercatorLon -> x
-  mercatorDecrypt(mercatorLat, mercatorLon) {
-    const x = mercatorLon / 2003750834e-2 * 180;
-    let y = mercatorLat / 2003750834e-2 * 180;
-    y = 180 / this.PI * (2 * Math.atan(Math.exp(y * this.PI / 180)) - this.PI / 2);
-    return { lat: y, lng: x };
-  },
-  transformLat(x, y) {
-    let ret = -100 + 2 * x + 3 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
-    ret += (20 * Math.sin(6 * x * this.PI) + 20 * Math.sin(2 * x * this.PI)) * 2 / 3;
-    ret += (20 * Math.sin(y * this.PI) + 40 * Math.sin(y / 3 * this.PI)) * 2 / 3;
-    ret += (160 * Math.sin(y / 12 * this.PI) + 320 * Math.sin(y * this.PI / 30)) * 2 / 3;
-    return ret;
-  },
-  transformLon(x, y) {
-    let ret = 300 + x + 2 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
-    ret += (20 * Math.sin(6 * x * this.PI) + 20 * Math.sin(2 * x * this.PI)) * 2 / 3;
-    ret += (20 * Math.sin(x * this.PI) + 40 * Math.sin(x / 3 * this.PI)) * 2 / 3;
-    ret += (150 * Math.sin(x / 12 * this.PI) + 300 * Math.sin(x / 30 * this.PI)) * 2 / 3;
-    return ret;
+  /**
+   * 根据两个平面坐标点计算方位角和距离
+   *
+   * @param p1 第一个点的坐标对象
+   * @param p2 第二个点的坐标对象
+   * @returns 返回一个对象，包含angle和distance属性，分别表示两点之间的角度（以度为单位，取值范围为0~359）和距离
+   */
+  calcBearAndDis(p1, p2) {
+    const { x: x1, y: y1 } = p1;
+    const { x: x2, y: y2 } = p2;
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    const angleInRadians = Math.atan2(dy, dx);
+    const angle = (angleInRadians * (180 / Math.PI) + 360 + 90) % 360;
+    return { angle, distance };
   },
   /**
-   * 生成指定范围内的随机经纬度坐标
+   * 根据两个经纬度点计算方位角和距离
    *
-   * @param min 最小坐标，包含属性 x 和 y，分别表示最小经度和最小纬度
-   * @param max 最大坐标，包含属性 x 和 y，分别表示最大经度和最大纬度
-   * @returns 返回生成的随机经纬度坐标，包含属性 lat 和 lng，分别表示纬度和经度
+   * @param latlng1 第一个经纬度点
+   * @param latlng2 第二个经纬度点
+   * @returns 包含方位角和距离的对象
    */
-  random({ x: minX, y: minY }, { x: maxX, y: maxY }) {
+  calcBearAndDisByPoints(latlng1, latlng2) {
+    var f1 = latlng1.lat * 1, l1 = latlng1.lng * 1, f2 = latlng2.lat * 1, l2 = latlng2.lng * 1;
+    var y = Math.sin((l2 - l1) * this.toRadian) * Math.cos(f2 * this.toRadian);
+    var x = Math.cos(f1 * this.toRadian) * Math.sin(f2 * this.toRadian) - Math.sin(f1 * this.toRadian) * Math.cos(f2 * this.toRadian) * Math.cos((l2 - l1) * this.toRadian);
+    var angle = Math.atan2(y, x) * (180 / Math.PI);
+    var deltaF = (f2 - f1) * this.toRadian;
+    var deltaL = (l2 - l1) * this.toRadian;
+    var a = Math.sin(deltaF / 2) * Math.sin(deltaF / 2) + Math.cos(f1 * this.toRadian) * Math.cos(f2 * this.toRadian) * Math.sin(deltaL / 2) * Math.sin(deltaL / 2);
+    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    var distance = this.R * c;
     return {
-      lat: Math.random() * (maxY - minY) + minY,
-      lng: Math.random() * (maxX - minX) + minX
+      angle,
+      distance
     };
   },
-  deCompose(arr, fn, context) {
-    if (!Array.isArray(arr)) {
-      return context ? fn.call(context, arr) : fn(arr);
+  /**
+   * 计算点P到线段P1P2的最短距离
+   *
+   * @param p 点P的坐标
+   * @param p1 线段起点P1的坐标
+   * @param p2 线段终点P2的坐标
+   * @returns 点P到线段P1P2的最短距离
+   */
+  distanceToSegment(p, p1, p2) {
+    const x = p.x, y = p.y, x1 = p1.x, y1 = p1.y, x2 = p2.x, y2 = p2.y;
+    const cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
+    if (cross <= 0) {
+      return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
     }
-    const result = [];
-    let p, pp;
-    for (let i = 0, len = arr.length; i < len; i++) {
-      p = arr[i];
-      if (CommUtils.isNil(p)) {
-        result.push(null);
-        continue;
-      }
-      if (Array.isArray(p)) {
-        result.push(this.deCompose(p, fn, context));
-      } else {
-        pp = context ? fn.call(context, p) : fn(p);
-        result.push(pp);
-      }
+    const d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+    if (cross >= d2) {
+      return Math.sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
     }
-    return result;
-  }
-};
-const ColorUtil = {
-  random() {
-    let r = Math.floor(Math.random() * 256).toString(16);
-    let g = Math.floor(Math.random() * 256).toString(16);
-    let b = Math.floor(Math.random() * 256).toString(16);
-    r = r.length === 1 ? "0" + r : r;
-    g = g.length === 1 ? "0" + g : g;
-    b = b.length === 1 ? "0" + b : b;
-    return "#" + r + g + b;
+    const r = cross / d2;
+    const px = x1 + (x2 - x1) * r;
+    const py = y1 + (y2 - y1) * r;
+    return Math.sqrt((x - px) * (x - px) + (y - py) * (y - py));
   },
   /**
-   * 将RGB颜色值转换为十六进制颜色值
+   * 根据给定的经纬度、角度和距离计算新的经纬度点
    *
-   * @param rgb RGB颜色值数组，包含三个0-255之间的整数
-   * @returns 转换后的十六进制颜色值，以#开头
+   * @param latlng 给定的经纬度点，类型为LngLat
+   * @param angle 角度值，单位为度，表示从当前点出发的方向
+   * @param distance 距离值，单位为米，表示从当前点出发的距离
+   * @returns 返回计算后的新经纬度点，类型为{lat: number, lng: number}
    */
-  rgb2hex(rgb) {
-    var hex = "#" + ((1 << 24) + (rgb[0] << 16) + (rgb[1] << 8) + rgb[2]).toString(16).slice(1);
-    return hex;
+  calcPointByBearAndDis(latlng, angle, distance) {
+    const sLat = MathUtils.deg2Rad(latlng.lat * 1);
+    const sLng = MathUtils.deg2Rad(latlng.lng * 1);
+    const d = distance / this.R;
+    angle = MathUtils.deg2Rad(angle);
+    const lat = Math.asin(Math.sin(sLat) * Math.cos(d) + Math.cos(sLat) * Math.sin(d) * Math.cos(angle));
+    const lon = sLng + Math.atan2(Math.sin(angle) * Math.sin(d) * Math.cos(sLat), Math.cos(d) - Math.sin(sLat) * Math.sin(lat));
+    return {
+      lat: MathUtils.rad2Deg(lat),
+      lng: MathUtils.rad2Deg(lon)
+    };
   },
   /**
-   * 将RGB颜色值转换为RGBA颜色值，并返回转换后的颜色值。
+   * 将墨卡托坐标转换为经纬度坐标
    *
-   * @param rgbValue RGB颜色值，格式为"rgb(r, g, b)"。
-   * @returns 转换后的RGBA颜色值，格式为"rgba(r, g, b, 1)"。如果输入值不符合RGB格式，则返回原值。
+   * @param x 墨卡托坐标的x值
+   * @param y 墨卡托坐标的y值
+   * @returns 返回包含转换后的经度lng和纬度lat的对象
    */
-  rgbToRgba(rgbValue) {
-    const rgb = /rgb\((\d+,\s*[\d]+,\s*[\d]+)\)/g.exec(rgbValue);
-    return rgb ? `rgba(${rgb[1]}, 1)` : rgbValue;
+  mercatorTolonlat(x, y) {
+    const lng = x / 2003750834e-2 * 180;
+    var mmy = y / 2003750834e-2 * 180;
+    const lat = 180 / Math.PI * (2 * Math.atan(Math.exp(mmy * Math.PI / 180)) - Math.PI / 2);
+    return { lng, lat };
   },
   /**
-   * 将十六进制颜色值转换为rgba格式的颜色值
+   * 将经纬度坐标转换为墨卡托坐标
    *
-   * @param hexValue 十六进制颜色值，可带或不带#前缀，支持3位和6位表示
-   * @returns 返回rgba格式的颜色值，格式为rgba(r,g,b,1)
+   * @param lng 经度值
+   * @param lat 纬度值
+   * @returns 墨卡托坐标对象，包含x和y属性
    */
-  hexToRgba(hexValue) {
-    const rgxShort = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
-    const hex = hexValue.replace(rgxShort, (m, r2, g2, b2) => r2 + r2 + g2 + g2 + b2 + b2);
-    const rgx = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i;
-    const rgb = rgx.exec(hex);
-    if (!rgb) {
-      return hexValue;
-    }
-    const r = parseInt(rgb[1], 16);
-    const g = parseInt(rgb[2], 16);
-    const b = parseInt(rgb[3], 16);
-    return `rgba(${r},${g},${b},1)`;
+  lonlatToMercator(lng, lat) {
+    var earthRad = 6378137;
+    const x = lng * Math.PI / 180 * earthRad;
+    var a = lat * Math.PI / 180;
+    const y = earthRad / 2 * Math.log((1 + Math.sin(a)) / (1 - Math.sin(a)));
+    return { x, y };
   },
   /**
-   * 将 HSL 颜色值转换为 RGBA 颜色值
+   * 根据百分比获取坐标
    *
-   * @param hslValue HSL 颜色值字符串，格式为 "hsl(h, s%, l%)" 或 "hsla(h, s%, l%, a)"，其中 h 为色相，s 为饱和度，l 为亮度，a 为透明度（可选）。
-   * @returns 转换后的 RGBA 颜色值字符串，格式为 "rgba(r, g, b, a)"，其中 r、g、b 为红绿蓝分量，a 为透明度。若输入为空或无效，则返回 null。
+   * @param start 起点坐标
+   * @param end 终点坐标
+   * @param percent 百分比，取值范围0-1
+   * @returns 返回插值后的坐标
    */
-  hslToRgba(hslValue) {
-    if (!hslValue) {
-      return null;
-    }
-    const hsl = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(hslValue) || /hsla\((\d+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)/g.exec(hslValue);
-    if (!hsl) {
-      return null;
-    }
-    const h = parseInt(hsl[1], 10) / 360;
-    const s = parseInt(hsl[2], 10) / 100;
-    const l = parseInt(hsl[3], 10) / 100;
-    const a = hsl[4] ? parseFloat(hsl[4]) : 1;
-    function hue2rgb(p, q, t) {
-      if (t < 0) t += 1;
-      if (t > 1) t -= 1;
-      if (t < 1 / 6) return p + (q - p) * 6 * t;
-      if (t < 1 / 2) return q;
-      if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
-      return p;
-    }
-    let r, g, b;
-    if (s === 0) {
-      r = g = b = l;
-    } else {
-      const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-      const p = 2 * l - q;
-      r = hue2rgb(p, q, h + 1 / 3);
-      g = hue2rgb(p, q, h);
-      b = hue2rgb(p, q, h - 1 / 3);
-    }
-    return `rgba(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)},${a})`;
-  },
-  isHex(a) {
-    return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a);
-  },
-  isRgb(a) {
-    return /^rgb/.test(a);
-  },
-  isHsl(a) {
-    return /^hsl/.test(a);
-  },
-  isColor(a) {
-    return this.isHex(a) || this.isRgb(a) || this.isHsl(a);
-  },
-  colorToRgb(val) {
-    if (this.isRgb(val)) return this.rgbToRgba(val);
-    if (this.isHex(val)) return this.hexToRgba(val);
-    if (this.isHsl(val)) return this.hslToRgba(val);
-  }
-};
-const myDate = Object.create(Date);
-myDate.prototype.format = function(fmt = "yyyy-MM-dd hh:mm:ss") {
-  const o = {
-    "M+": this.getMonth() + 1,
-    // 月份
-    "d+": this.getDate(),
-    // 日
-    "h+": this.getHours() % 12,
-    // 小时
-    "H+": this.getHours(),
-    // 小时 (24小时制)
-    "m+": this.getMinutes(),
-    // 分
-    "s+": this.getSeconds(),
-    // 秒
-    "q+": Math.floor((this.getMonth() + 3) / 3),
-    // 季度
-    S: this.getMilliseconds()
-    // 毫秒
-  };
-  if (/(y+)/.test(fmt)) {
-    fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
-  }
-  for (const k in o) {
-    if (new RegExp("(" + k + ")").test(fmt)) {
-      const len = k.length === 1 ? 1 : Number(k.slice(1));
-      fmt = fmt.replace(RegExp.$1, ("00" + o[k]).substr(("" + o[k]).length + len - (o[k] + "").length));
-    }
-  }
-  return fmt;
-};
-myDate.prototype.addDate = function(interval, number) {
-  const date = new Date(this);
-  switch (interval) {
-    case "y":
-      date.setFullYear(this.getFullYear() + number);
-      break;
-    case "q":
-      date.setMonth(this.getMonth() + number * 3);
-      break;
-    case "M":
-      date.setMonth(this.getMonth() + number);
-      break;
-    case "w":
-      date.setDate(this.getDate() + number * 7);
-      break;
-    case "d":
-      date.setDate(this.getDate() + number);
-      break;
-    case "h":
-      date.setHours(this.getHours() + number);
-      break;
-    case "m":
-      date.setMinutes(this.getMinutes() + number);
-      break;
-    case "s":
-      date.setSeconds(this.getSeconds() + number);
-      break;
-    default:
-      date.setDate(this.getDate() + number);
-      break;
+  interpolate({ x: x1, y: y1, z: z1 = 0 }, { x: x2, y: y2, z: z2 = 0 }, percent) {
+    const dx = x2 - x1, dy = y2 - y1, dz = z2 - z1;
+    return { x: x1 + dx * percent, y: y1 + dy * percent, z: z1 + dz * percent };
   }
-  return date;
 };
-const DateUtil = {
-  lastMonthDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth() - 1, 1),
-  thisMonthDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
-  nextMonthDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth() + 1, 1),
-  lastWeekDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1 - 7 - (/* @__PURE__ */ new Date()).getDay()),
-  thisWeekDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1 - (/* @__PURE__ */ new Date()).getDay()),
-  nextWeekDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1 + 7 - (/* @__PURE__ */ new Date()).getDay()),
-  lastDayDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() - 1),
-  thisDayDate: new Date((/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0)),
-  nextDayDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1),
-  parseDate(str) {
-    if (typeof str == "string") {
-      var results = str.match(/^ *(\d{4})-(\d{1,2})-(\d{1,2}) *$/);
-      if (results && results.length > 3) return new Date(parseInt(results[1]), parseInt(results[2]) - 1, parseInt(results[3]));
-      results = str.match(/^ *(\d{4})-(\d{1,2})-(\d{1,2}) +(\d{1,2}):(\d{1,2}):(\d{1,2}) *$/);
-      if (results && results.length > 6)
-        return new Date(
-          parseInt(results[1]),
-          parseInt(results[2]) - 1,
-          parseInt(results[3]),
-          parseInt(results[4]),
-          parseInt(results[5]),
-          parseInt(results[6])
-        );
-      results = str.match(/^ *(\d{4})-(\d{1,2})-(\d{1,2}) +(\d{1,2}):(\d{1,2}):(\d{1,2})\.(\d{1,9}) *$/);
-      if (results && results.length > 7)
-        return new Date(
-          parseInt(results[1]),
-          parseInt(results[2]) - 1,
-          parseInt(results[3]),
-          parseInt(results[4]),
-          parseInt(results[5]),
-          parseInt(results[6]),
-          parseInt(results[7])
-        );
-    }
-    return null;
-  },
+const StringUtil = {
   /**
-   * 格式化时间间隔
+   * 校验字符串是否符合指定类型
    *
-   * @param startTime 开始时间，可以是字符串、数字或日期类型
-   * @param endTime 结束时间，可以是字符串、数字或日期类型
-   * @returns 返回格式化后的时间间隔字符串，格式为"天数 天 小时 时 分钟 分 秒 秒"或"少于1秒"
+   * @param str 待校验字符串
+   * @param type 校验类型，可选值包括：
+   *   - 'phone': 手机号码
+   *   - 'tel': 座机
+   *   - 'card': 身份证
+   *   - 'pwd': 密码（以字母开头，长度在6~18之间，只能包含字母、数字和下划线）
+   *   - 'postal': 邮政编码
+   *   - 'QQ': QQ号
+   *   - 'email': 邮箱
+   *   - 'money': 金额（小数点2位）
+   *   - 'URL': 网址
+   *   - 'IP': IP地址
+   *   - 'date': 日期时间
+   *   - 'number': 数字
+   *   - 'english': 英文
+   *   - 'chinese': 中文
+   *   - 'lower': 小写字母
+   *   - 'upper': 大写字母
+   *   - 'HTML': HTML标记
+   * @returns 校验结果，符合返回true，否则返回false
    */
-  formatDateInterval(startTime, endTime) {
-    const dateCreateTime = new Date(startTime);
-    const dateFinishTime = new Date(endTime);
-    const dateInterval = dateFinishTime.getTime() - dateCreateTime.getTime();
-    const days = Math.floor(dateInterval / (24 * 3600 * 1e3));
-    const leave1 = dateInterval % (24 * 3600 * 1e3);
-    const hours = Math.floor(leave1 / (3600 * 1e3));
-    const leave2 = leave1 % (3600 * 1e3);
-    const minutes = Math.floor(leave2 / (60 * 1e3));
-    const leave3 = leave2 % (60 * 1e3);
-    const seconds = Math.round(leave3 / 1e3);
-    let intervalDes = "";
-    if (days > 0) {
-      intervalDes += days + "天";
-    }
-    if (hours > 0) {
-      intervalDes += hours + "时";
-    }
-    if (minutes > 0) {
-      intervalDes += minutes + "分";
-    }
-    if (seconds > 0) {
-      intervalDes += seconds + "秒";
-    }
-    if (days === 0 && hours === 0 && minutes === 0 && seconds === 0) {
-      intervalDes = "少于1秒";
+  checkStr(str, type) {
+    switch (type) {
+      case "phone":
+        return /^1[3|4|5|6|7|8|9][0-9]{9}$/.test(str);
+      case "tel":
+        return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str);
+      case "card":
+        return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(str);
+      case "pwd":
+        return /^[a-zA-Z]\w{5,17}$/.test(str);
+      case "postal":
+        return /[1-9]\d{5}(?!\d)/.test(str);
+      case "QQ":
+        return /^[1-9][0-9]{4,9}$/.test(str);
+      case "email":
+        return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);
+      case "money":
+        return /^\d*(?:\.\d{0,2})?$/.test(str);
+      case "URL":
+        return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str);
+      case "IP":
+        return /((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))/.test(str);
+      case "date":
+        return /^(\d{4})\-(\d{2})\-(\d{2}) (\d{2})(?:\:\d{2}|:(\d{2}):(\d{2}))$/.test(str) || /^(\d{4})\-(\d{2})\-(\d{2})$/.test(str);
+      case "number":
+        return /^[0-9]$/.test(str);
+      case "english":
+        return /^[a-zA-Z]+$/.test(str);
+      case "chinese":
+        return /^[\u4E00-\u9FA5]+$/.test(str);
+      case "lower":
+        return /^[a-z]+$/.test(str);
+      case "upper":
+        return /^[A-Z]+$/.test(str);
+      case "HTML":
+        return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str);
+      default:
+        return true;
     }
-    return intervalDes;
   },
-  formatterCounter(times) {
-    const checked = function(j) {
-      return (j > 10 ? "" : "0") + (j || 0);
-    };
-    const houres = checked(Math.floor(times / 3600));
-    const level1 = times % 3600;
-    const minutes = checked(Math.floor(level1 / 60));
-    const leave2 = level1 % 60;
-    const seconds = checked(Math.round(leave2));
-    return `${houres}:${minutes}:${seconds}`;
-  },
-  sleep(d) {
-  }
-};
-function trim(str) {
-  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
-}
-function splitWords(str) {
-  return trim(str).split(/\s+/);
-}
-const DomUtil = {
   /**
-   * 获取元素的样式值
+   * 转换字符串大小写
    *
-   * @param el 元素对象
-   * @param style 样式属性名称
-   * @returns 元素的样式值，如果获取不到则返回 null
+   * @param str 待转换的字符串
+   * @param type 转换类型，可选值为 1-5，默认为 4
+   * 1：首字母大写，其余小写
+   * 2：首字母小写，其余大写
+   * 3：字母大小写反转
+   * 4：全部大写
+   * 5：全部小写
+   * @returns 转换后的字符串
    */
-  getStyle(el, style) {
-    var _a;
-    let value = el.style[style];
-    if (!value || value === "auto") {
-      const css = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(el, null);
-      value = css ? css[style] : null;
-      if (value === "auto") value = null;
+  changeCase(str, type) {
+    type = type || 4;
+    switch (type) {
+      case 1:
+        return str.replace(/\b\w+\b/g, function(word) {
+          return word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase();
+        });
+      case 2:
+        return str.replace(/\b\w+\b/g, function(word) {
+          return word.substring(0, 1).toLowerCase() + word.substring(1).toUpperCase();
+        });
+      case 3:
+        return str.split("").map(function(word) {
+          if (/[a-z]/.test(word)) {
+            return word.toUpperCase();
+          } else {
+            return word.toLowerCase();
+          }
+        }).join("");
+      case 4:
+        return str.toUpperCase();
+      case 5:
+        return str.toLowerCase();
+      default:
+        return str;
     }
-    return value;
   },
   /**
-   * 创建一个HTML元素
+   * 根据字符串数组和参数生成新的字符串
    *
-   * @param tagName 元素标签名
-   * @param className 元素类名
-   * @param container 父容器，若传入，则新创建的元素会被添加到该容器中
-   * @returns 返回新创建的HTML元素
+   * @param strArray 字符串数组
+   * @param args 可变参数列表，支持 Object、Array 类型和任意其他类型，若为 null 或 undefined，则按类型默认转换为 '{}'、'[]' 或 ''
+   * @returns 返回生成的新字符串
    */
-  create(tagName, className, container) {
-    const el = document.createElement(tagName);
-    el.className = className || "";
-    if (container) {
-      container.appendChild(el);
-    }
-    return el;
+  tag(strArray, ...args) {
+    args = args.map((val) => {
+      switch (CommUtil.getDataType(val)) {
+        case "Object":
+          return val || "{}";
+        case "Array":
+          return val || "[]";
+        default:
+          return val || "";
+      }
+    });
+    return strArray.reduce((prev, next, index) => `${prev}${args[index - 1]}${next}`);
   },
   /**
-   * 从父节点中移除指定元素。
+   * 计算字符串的字节长度
    *
-   * @param el 要移除的元素对象，必须包含parentNode属性。
+   * @param str 需要计算字节长度的字符串
+   * @returns 返回字符串的字节长度
    */
-  remove(el) {
-    const parent = el.parentNode;
-    if (parent) {
-      parent.removeChild(el);
-    }
+  getByteLength(str) {
+    return str.replace(/[\u0391-\uFFE5]/g, "aa").length;
   },
   /**
-   * 清空给定元素的子节点
+   * 截取字符串中指定字节长度的子串
    *
-   * @param el 要清空子节点的元素，包含firstChild和removeChild属性
+   * @param str 字符串对象，包含replace、length和substring方法
+   * @param start 截取起始位置
+   * @param n 截取字节长度
+   * @returns 返回截取后的子串
    */
-  empty(el) {
-    while (el.firstChild) {
-      el.removeChild(el.firstChild);
+  subStringByte(str, start, n) {
+    var r = /[^\x00-\xff]/g;
+    if (str.replace(r, "mm").length <= n) {
+      return str;
     }
-  },
-  /**
-   * 将元素移到父节点的最前面
-   *
-   * @param el 要移动的元素，需要包含 parentNode 属性
-   */
-  toFront(el) {
-    const parent = el.parentNode;
-    if (parent && parent.lastChild !== el) {
-      parent.appendChild(el);
+    var m = Math.floor(n / 2);
+    for (var i = m; i < str.length; i++) {
+      let sub = str.substring(start, i);
+      if (sub.replace(r, "mm").length >= n) {
+        return sub;
+      }
     }
+    return str;
+  }
+};
+const ColorUtil = {
+  random() {
+    let r = Math.floor(Math.random() * 256).toString(16);
+    let g = Math.floor(Math.random() * 256).toString(16);
+    let b = Math.floor(Math.random() * 256).toString(16);
+    r = r.length === 1 ? "0" + r : r;
+    g = g.length === 1 ? "0" + g : g;
+    b = b.length === 1 ? "0" + b : b;
+    return "#" + r + g + b;
   },
   /**
-   * 将元素移动到其父节点的最前面
+   * 将RGB颜色值转换为十六进制颜色值
    *
-   * @param el 要移动的元素，需要包含parentNode属性
+   * @param rgb RGB颜色值数组，包含三个0-255之间的整数
+   * @returns 转换后的十六进制颜色值，以#开头
    */
-  toBack(el) {
-    const parent = el.parentNode;
-    if (parent && parent.firstChild !== el) {
-      parent.insertBefore(el, parent.firstChild);
-    }
+  rgb2hex(rgb) {
+    var hex = "#" + ((1 << 24) + (rgb[0] << 16) + (rgb[1] << 8) + rgb[2]).toString(16).slice(1);
+    return hex;
   },
   /**
-   * 获取元素的类名
+   * 将RGB颜色值转换为RGBA颜色值，并返回转换后的颜色值。
    *
-   * @param el 包含对应元素和类名的对象
-   * @param el.correspondingElement 对应的元素
-   * @param el.className 类名对象
-   * @param el.className.baseVal 类名字符串
-   * @returns 返回元素的类名字符串
+   * @param rgbValue RGB颜色值，格式为"rgb(r, g, b)"。
+   * @returns 转换后的RGBA颜色值，格式为"rgba(r, g, b, 1)"。如果输入值不符合RGB格式，则返回原值。
    */
-  getClass(el) {
-    const shadowElement = (el == null ? void 0 : el.host) || el;
-    return shadowElement.className.toString();
+  rgbToRgba(rgbValue) {
+    const rgb = /rgb\((\d+,\s*[\d]+,\s*[\d]+)\)/g.exec(rgbValue);
+    return rgb ? `rgba(${rgb[1]}, 1)` : rgbValue;
   },
   /**
-   * 判断元素是否包含指定类名
+   * 将十六进制颜色值转换为rgba格式的颜色值
    *
-   * @param el 元素对象，包含classList属性，classList属性包含contains方法
-   * @param name 要判断的类名
-   * @returns 返回一个布尔值，表示元素是否包含指定类名
+   * @param hexValue 十六进制颜色值，可带或不带#前缀，支持3位和6位表示
+   * @returns 返回rgba格式的颜色值，格式为rgba(r,g,b,1)
    */
-  hasClass(el, name) {
-    var _a;
-    if ((_a = el.classList) == null ? void 0 : _a.contains(name)) {
-      return true;
+  hexToRgba(hexValue) {
+    const rgxShort = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+    const hex = hexValue.replace(rgxShort, (m, r2, g2, b2) => r2 + r2 + g2 + g2 + b2 + b2);
+    const rgx = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i;
+    const rgb = rgx.exec(hex);
+    if (!rgb) {
+      return hexValue;
     }
-    const className = this.getClass(el);
-    return className.length > 0 && new RegExp(`(^|\\s)${name}(\\s|$)`).test(className);
+    const r = parseInt(rgb[1], 16);
+    const g = parseInt(rgb[2], 16);
+    const b = parseInt(rgb[3], 16);
+    return `rgba(${r},${g},${b},1)`;
   },
   /**
-   * 给指定的 HTML 元素添加类名
+   * 将 HSL 颜色值转换为 RGBA 颜色值
    *
-   * @param el 要添加类名的 HTML 元素
-   * @param name 要添加的类名，多个类名之间用空格分隔
+   * @param hslValue HSL 颜色值字符串，格式为 "hsl(h, s%, l%)" 或 "hsla(h, s%, l%, a)"，其中 h 为色相，s 为饱和度，l 为亮度，a 为透明度（可选）。
+   * @returns 转换后的 RGBA 颜色值字符串，格式为 "rgba(r, g, b, a)"，其中 r、g、b 为红绿蓝分量，a 为透明度。若输入为空或无效，则返回 null。
    */
-  addClass(el, name) {
-    if (el.classList !== void 0) {
-      const classes = splitWords(name);
-      for (let i = 0, len = classes.length; i < len; i++) {
-        el.classList.add(classes[i]);
-      }
-    } else if (!this.hasClass(el, name)) {
-      const className = this.getClass(el);
-      this.setClass(el, (className ? className + " " : "") + name);
+  hslToRgba(hslValue) {
+    if (!hslValue) {
+      return null;
     }
-  },
-  /**
-   * 从元素中移除指定类名
-   *
-   * @param el 要移除类名的元素
-   * @param name 要移除的类名，多个类名用空格分隔
-   */
-  removeClass(el, name) {
-    if (el.classList !== void 0) {
-      const classes = splitWords(name);
-      classes.forEach((className) => el.classList.remove(className));
+    const hsl = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(hslValue) || /hsla\((\d+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)/g.exec(hslValue);
+    if (!hsl) {
+      return null;
+    }
+    const h = parseInt(hsl[1], 10) / 360;
+    const s = parseInt(hsl[2], 10) / 100;
+    const l = parseInt(hsl[3], 10) / 100;
+    const a = hsl[4] ? parseFloat(hsl[4]) : 1;
+    function hue2rgb(p, q, t) {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p + (q - p) * 6 * t;
+      if (t < 1 / 2) return q;
+      if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+      return p;
+    }
+    let r, g, b;
+    if (s === 0) {
+      r = g = b = l;
     } else {
-      this.setClass(el, (" " + this.getClass(el) + " ").replace(" " + name + " ", " ").trim());
+      const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+      const p = 2 * l - q;
+      r = hue2rgb(p, q, h + 1 / 3);
+      g = hue2rgb(p, q, h);
+      b = hue2rgb(p, q, h - 1 / 3);
     }
+    return `rgba(${Math.round(r * 255)},${Math.round(g * 255)},${Math.round(b * 255)},${a})`;
   },
-  /**
-   * 设置元素的 CSS 类名
-   *
-   * @param el HTML 或 SVG 元素
-   * @param name 要设置的类名，多个类名之间用空格分隔
-   */
-  setClass(el, name) {
-    if ("classList" in el) {
-      el.classList.value = "";
-      name.split(" ").forEach((className) => el.classList.add(className));
-    }
+  isHex(a) {
+    return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a);
   },
-  /**
-   * 从字符串中解析XML文档，并返回根节点
-   *
-   * @param str 要解析的XML字符串
-   * @returns 解析后的XML文档的根节点
-   */
-  parseFromString(str) {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(str, "text/xml");
-    return doc.children[0];
+  isRgb(a) {
+    return /^rgb/.test(a);
+  },
+  isHsl(a) {
+    return /^hsl/.test(a);
+  },
+  isColor(a) {
+    return this.isHex(a) || this.isRgb(a) || this.isHsl(a);
+  },
+  colorToRgb(val) {
+    if (this.isRgb(val)) return this.rgbToRgba(val);
+    if (this.isHex(val)) return this.hexToRgba(val);
+    if (this.isHsl(val)) return this.hslToRgba(val);
   }
 };
 const TYPES = ["Point", "MultiPoint", "LineString", "MultiLineString", "Polygon", "MultiPolygon"];
@@ -2365,309 +2191,772 @@ const GeoJsonUtil = {
         break;
       }
     }
-    if (fType) {
-      for (let i = 0, len = coordinates.length; i < len; i++) {
-        features.push({
-          type: "Feature",
-          geometry: {
-            type: fType,
-            coordinates: coordinates[i]
-          },
-          properties
-        });
+    if (fType) {
+      for (let i = 0, len = coordinates.length; i < len; i++) {
+        features.push({
+          type: "Feature",
+          geometry: {
+            type: fType,
+            coordinates: coordinates[i]
+          },
+          properties
+        });
+      }
+    } else {
+      features.push(feature);
+    }
+    return features;
+  },
+  /**
+   * 根据坐标数组生成GeoJSON要素
+   *
+   * @param coordinates 坐标数组
+   * @returns GeoJSONFeature 生成的GeoJSON要素
+   * @throws Error 如果coordinates参数格式错误
+   */
+  getGeoJsonByCoordinates(coordinates) {
+    if (!Array.isArray(coordinates)) {
+      throw Error("coordinates 参数格式错误");
+    }
+    let type;
+    if (coordinates.length === 2 && typeof coordinates[0] === "number" && typeof coordinates[1] === "number") {
+      type = "Point";
+    } else if (Array.isArray(coordinates[0]) && coordinates[0].length === 2) {
+      type = "LineString";
+    } else if (Array.isArray(coordinates[0]) && Array.isArray(coordinates[0][0])) {
+      const outerRing = coordinates[0];
+      const isClosed = outerRing[0].join(",") === outerRing[outerRing.length - 1].join(",");
+      if (isClosed) {
+        type = "Polygon";
+      } else if (coordinates.length > 1) {
+        type = "MultiPolygon";
+      } else {
+        throw Error("coordinates 参数格式错误");
+      }
+    } else {
+      throw Error("coordinates 参数格式错误");
+    }
+    return {
+      type: "Feature",
+      geometry: { type, coordinates }
+    };
+  }
+};
+const AssertUtil = {
+  assertEmpty(...arg) {
+    arg.forEach((a) => {
+      if (CommUtil.isEmpty(a)) {
+        throw Error(ErrorType.PARAMETER_ERROR_LACK + " -> " + a);
+      }
+    });
+  },
+  assertNumber(...arg) {
+    arg.forEach((a) => {
+      if (!CommUtil.isNumber(a)) {
+        throw Error(ErrorType.PARAMETER_ERROR_NUMBER + " -> " + a);
+      }
+    });
+  },
+  assertArray(...arg) {
+    arg.forEach((a) => {
+      if (!CommUtil.isArray(a)) {
+        throw Error(ErrorType.PARAMETER_ERROR_ARRAY + " -> " + a);
+      }
+    });
+  },
+  assertFunction(...arg) {
+    arg.forEach((a) => {
+      if (!CommUtil.isFunction(a)) {
+        throw Error(ErrorType.PARAMETER_ERROR_FUNCTION + " -> " + a);
+      }
+    });
+  },
+  assertObject(...arg) {
+    arg.forEach((a) => {
+      if (!CommUtil.isObject(a)) {
+        throw Error(ErrorType.PARAMETER_ERROR_OBJECT + " -> " + a);
+      }
+    });
+  },
+  assertColor(...arg) {
+    arg.forEach((a) => {
+      if (!ColorUtil.isColor(a)) {
+        throw Error(ErrorType.DATA_ERROR_COLOR + " -> " + a);
+      }
+    });
+  },
+  assertLnglat(...arg) {
+    arg.forEach((a) => {
+      if (!GeoUtil.isLnglat(a.lng, a.lat)) {
+        throw Error(ErrorType.DATA_ERROR_COORDINATE + " -> " + a);
+      }
+    });
+  },
+  assertGeoJson(...arg) {
+    arg.forEach((a) => {
+      if (!GeoJsonUtil.isGeoJson(a)) {
+        throw Error(ErrorType.DATA_ERROR_GEOJSON + " -> " + a);
+      }
+    });
+  },
+  assertContain(str, ...args) {
+    let res = false;
+    const len = args.length || 0;
+    for (let i = 0, l = len; i < l; i++) {
+      res = str.indexOf(args[i]) >= 0;
+    }
+    if (res) {
+      throw Error(ErrorType.STRING_CHECK_LOSS + " -> " + str);
+    }
+  },
+  /**
+   * 判断字符串是否合法
+   *
+   * @param value 待判断的字符串
+   * @param type 字符串类型
+   * @throws 当字符串不合法时，抛出错误，错误信息为“参数错误 -> 不是{typename}”
+   */
+  assertLegal(value, type) {
+    const bool = StringUtil.checkStr(value, type);
+    let typename = "";
+    switch (type) {
+      case "phone":
+        typename = "电话";
+        break;
+      case "tel":
+        typename = "座机";
+        break;
+      case "card":
+        typename = "身份证";
+        break;
+      case "pwd":
+        typename = "密码";
+        break;
+      case "postal":
+        typename = "邮政编码";
+        break;
+      case "QQ":
+        typename = "QQ";
+        break;
+      case "email":
+        typename = "邮箱";
+        break;
+      case "money":
+        typename = "金额";
+        break;
+      case "URL":
+        typename = "网址";
+        break;
+      case "IP":
+        typename = "IP";
+        break;
+      case "date":
+        typename = "日期时间";
+        break;
+      case "number":
+        typename = "数字";
+        break;
+      case "english":
+        typename = "英文";
+        break;
+      case "chinese":
+        typename = "中文";
+        break;
+      case "lower":
+        typename = "小写";
+        break;
+      case "upper":
+        typename = "大写";
+        break;
+      case "HTML":
+        typename = "HTML标记";
+        break;
+    }
+    if (!bool) {
+      throw Error(ErrorType.DATA_ERROR + " -> 不是" + typename);
+    }
+  }
+};
+const BrowserUtil = {
+  /**
+   * 获取浏览器类型
+   *
+   * @returns 返回浏览器类型字符串，可能的值为 'IE'、'Firefox'、'Chrome'、'Opera'、'Safari' 或 'Unknown'
+   */
+  getExplorer() {
+    var explorer = window.navigator.userAgent;
+    if (explorer.indexOf("MSIE") >= 0 || /Trident\//.test(explorer)) {
+      return "IE";
+    } else if (explorer.indexOf("Firefox") >= 0) {
+      return "Firefox";
+    } else if (explorer.indexOf("Chrome") >= 0) {
+      return "Chrome";
+    } else if (explorer.indexOf("Opera") >= 0) {
+      return "Opera";
+    } else if (explorer.indexOf("Safari") >= 0 && explorer.indexOf("Chrome") === -1) {
+      return "Safari";
+    }
+    return "Unknown";
+  },
+  /**
+   * 检测操作系统类型
+   *
+   * @returns 返回操作系统类型字符串，可能的值有：'MS Windows'、'Apple mac'、'Linux'、'Unix'
+   */
+  detectOS() {
+    let os_type = "";
+    const windows = navigator.userAgent.indexOf("Windows", 0) != -1 ? 1 : 0;
+    const mac = navigator.userAgent.indexOf("mac", 0) != -1 ? 1 : 0;
+    const linux = navigator.userAgent.indexOf("Linux", 0) != -1 ? 1 : 0;
+    const unix = navigator.userAgent.indexOf("X11", 0) != -1 ? 1 : 0;
+    if (windows) os_type = "MS Windows";
+    else if (mac) os_type = "Apple mac";
+    else if (linux) os_type = "Linux";
+    else if (unix) os_type = "Unix";
+    return os_type;
+  },
+  /**
+   * 切换全屏状态
+   *
+   * @param status 是否全屏
+   */
+  switchFullScreen(status) {
+    if (status) {
+      const element = document.documentElement;
+      if (element.requestFullscreen) {
+        element.requestFullscreen();
+      } else if ("msRequestFullscreen" in element) {
+        element.msRequestFullscreen();
+      } else if ("mozRequestFullScreen" in element) {
+        element.mozRequestFullScreen();
+      } else if ("webkitRequestFullscreen" in element) {
+        element.webkitRequestFullscreen();
+      }
+    } else {
+      if (document.exitFullscreen) {
+        document.exitFullscreen();
+      } else if ("msExitFullscreen" in document) {
+        document.msExitFullscreen();
+      } else if ("mozCancelFullScreen" in document) {
+        document.mozCancelFullScreen();
+      } else if ("webkitExitFullscreen" in document) {
+        document.webkitExitFullscreen();
+      }
+    }
+  },
+  /**
+   * 刷新缩放比例
+   *
+   * @returns 无返回值
+   */
+  refreshScale() {
+    const baseWidth = document.documentElement.clientWidth || 0;
+    const baseHeight = document.documentElement.clientHeight || 0;
+    const appElement = document.getElementById("app");
+    if (!appElement) return;
+    const appStyle = appElement.style;
+    const realRatio = baseWidth / baseHeight;
+    const designRatio = 16 / 9;
+    let scaleRate = baseWidth / 1920;
+    if (realRatio > designRatio) {
+      scaleRate = baseHeight / 1080;
+    }
+    appStyle.transformOrigin = "left top";
+    appStyle.transform = `scale(${scaleRate}) translateX(-49.99%)`;
+    appStyle.width = `${baseWidth / scaleRate}px`;
+  },
+  /**
+   * 获取HTML字体大小
+   *
+   * @returns 无返回值，该函数会直接修改HTML元素的字体大小
+   */
+  getHtmlFontSize() {
+    const htmlwidth = document.documentElement.clientWidth || document.body.clientWidth;
+    const htmlDom = document.querySelector("html");
+    if (htmlDom) {
+      htmlDom.style.fontSize = htmlwidth / 192 + "px";
+    }
+  }
+};
+const CoordsUtil = {
+  PI: 3.141592653589793,
+  XPI: 3.141592653589793 * 3e3 / 180,
+  delta(lat, lng) {
+    const a = 6378245;
+    const ee = 0.006693421622965943;
+    let dLat = this.transformLat(lng - 105, lat - 35);
+    let dLon = this.transformLon(lng - 105, lat - 35);
+    const radLat = lat / 180 * this.PI;
+    let magic = Math.sin(radLat);
+    magic = 1 - ee * magic * magic;
+    const sqrtMagic = Math.sqrt(magic);
+    dLat = dLat * 180 / (a * (1 - ee) / (magic * sqrtMagic) * this.PI);
+    dLon = dLon * 180 / (a / sqrtMagic * Math.cos(radLat) * this.PI);
+    return { lat: dLat, lng: dLon };
+  },
+  /**
+   * 判断经纬度是否不在中国境内
+   *
+   * @param lng 经度
+   * @param lat 纬度
+   * @returns 如果经纬度不在中国境内则返回true，否则返回false
+   */
+  outOfChina(lng, lat) {
+    if (lng < 72.004 || lng > 137.8347) {
+      return true;
+    }
+    if (lat < 0.8293 || lat > 55.8271) {
+      return true;
+    }
+    return false;
+  },
+  // WGS-84 to GCJ-02
+  gcjEncrypt(wgsLat, wgsLon) {
+    if (this.outOfChina(wgsLat, wgsLon)) {
+      return { lat: wgsLat, lng: wgsLon };
+    }
+    const d = this.delta(wgsLat, wgsLon);
+    return { lat: wgsLat + d.lat, lng: wgsLon + d.lng };
+  },
+  // GCJ-02 to WGS-84
+  gcjDecrypt(gcjLat, gcjLon) {
+    if (this.outOfChina(gcjLat, gcjLon)) {
+      return { lat: gcjLat, lng: gcjLon };
+    }
+    const d = this.delta(gcjLat, gcjLon);
+    return { lat: gcjLat - d.lat, lng: gcjLon - d.lng };
+  },
+  // GCJ-02 to WGS-84 exactly
+  gcjDecryptExact(gcjLat, gcjLon) {
+    const initDelta = 0.01;
+    const threshold = 1e-9;
+    let dLat = initDelta;
+    let dLon = initDelta;
+    let mLat = gcjLat - dLat;
+    let mLon = gcjLon - dLon;
+    let pLat = gcjLat + dLat;
+    let pLon = gcjLon + dLon;
+    let wgsLat = 0;
+    let wgsLon = 0;
+    let i = 0;
+    while (1) {
+      wgsLat = (mLat + pLat) / 2;
+      wgsLon = (mLon + pLon) / 2;
+      const tmp = this.gcjEncrypt(wgsLat, wgsLon);
+      dLat = tmp.lat - gcjLat;
+      dLon = tmp.lng - gcjLon;
+      if (Math.abs(dLat) < threshold && Math.abs(dLon) < threshold) {
+        break;
       }
-    } else {
-      features.push(feature);
+      if (dLat > 0) pLat = wgsLat;
+      else mLat = wgsLat;
+      if (dLon > 0) pLon = wgsLon;
+      else mLon = wgsLon;
+      if (++i > 1e4) break;
     }
-    return features;
+    return { lat: wgsLat, lng: wgsLon };
+  },
+  // GCJ-02 to BD-09
+  bdEncrypt(gcjLat, gcjLon) {
+    const x = gcjLon;
+    const y = gcjLat;
+    const z = Math.sqrt(x * x + y * y) + 2e-5 * Math.sin(y * this.XPI);
+    const theta = Math.atan2(y, x) + 3e-6 * Math.cos(x * this.XPI);
+    const bdLon = z * Math.cos(theta) + 65e-4;
+    const bdLat = z * Math.sin(theta) + 6e-3;
+    return { lat: bdLat, lng: bdLon };
+  },
+  // BD-09 to GCJ-02
+  bdDecrypt(bdLat, bdLon) {
+    const x = bdLon - 65e-4;
+    const y = bdLat - 6e-3;
+    const z = Math.sqrt(x * x + y * y) - 2e-5 * Math.sin(y * this.XPI);
+    const theta = Math.atan2(y, x) - 3e-6 * Math.cos(x * this.XPI);
+    const gcjLon = z * Math.cos(theta);
+    const gcjLat = z * Math.sin(theta);
+    return { lat: gcjLat, lng: gcjLon };
+  },
+  // WGS-84 to Web mercator
+  // mercatorLat -> y mercatorLon -> x
+  mercatorEncrypt(wgsLat, wgsLon) {
+    const x = wgsLon * 2003750834e-2 / 180;
+    let y = Math.log(Math.tan((90 + wgsLat) * this.PI / 360)) / (this.PI / 180);
+    y = y * 2003750834e-2 / 180;
+    return { lat: y, lng: x };
+  },
+  // Web mercator to WGS-84
+  // mercatorLat -> y mercatorLon -> x
+  mercatorDecrypt(mercatorLat, mercatorLon) {
+    const x = mercatorLon / 2003750834e-2 * 180;
+    let y = mercatorLat / 2003750834e-2 * 180;
+    y = 180 / this.PI * (2 * Math.atan(Math.exp(y * this.PI / 180)) - this.PI / 2);
+    return { lat: y, lng: x };
+  },
+  transformLat(x, y) {
+    let ret = -100 + 2 * x + 3 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
+    ret += (20 * Math.sin(6 * x * this.PI) + 20 * Math.sin(2 * x * this.PI)) * 2 / 3;
+    ret += (20 * Math.sin(y * this.PI) + 40 * Math.sin(y / 3 * this.PI)) * 2 / 3;
+    ret += (160 * Math.sin(y / 12 * this.PI) + 320 * Math.sin(y * this.PI / 30)) * 2 / 3;
+    return ret;
+  },
+  transformLon(x, y) {
+    let ret = 300 + x + 2 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
+    ret += (20 * Math.sin(6 * x * this.PI) + 20 * Math.sin(2 * x * this.PI)) * 2 / 3;
+    ret += (20 * Math.sin(x * this.PI) + 40 * Math.sin(x / 3 * this.PI)) * 2 / 3;
+    ret += (150 * Math.sin(x / 12 * this.PI) + 300 * Math.sin(x / 30 * this.PI)) * 2 / 3;
+    return ret;
   },
   /**
-   * 根据坐标数组生成GeoJSON要素
+   * 生成指定范围内的随机经纬度坐标
    *
-   * @param coordinates 坐标数组
-   * @returns GeoJSONFeature 生成的GeoJSON要素
-   * @throws Error 如果coordinates参数格式错误
+   * @param min 最小坐标，包含属性 x 和 y，分别表示最小经度和最小纬度
+   * @param max 最大坐标，包含属性 x 和 y，分别表示最大经度和最大纬度
+   * @returns 返回生成的随机经纬度坐标，包含属性 lat 和 lng，分别表示纬度和经度
    */
-  getGeoJsonByCoordinates(coordinates) {
-    if (!Array.isArray(coordinates)) {
-      throw Error("coordinates 参数格式错误");
+  random({ x: minX, y: minY }, { x: maxX, y: maxY }) {
+    return {
+      lat: Math.random() * (maxY - minY) + minY,
+      lng: Math.random() * (maxX - minX) + minX
+    };
+  },
+  deCompose(arr, fn, context) {
+    if (!Array.isArray(arr)) {
+      return context ? fn.call(context, arr) : fn(arr);
     }
-    let type;
-    if (coordinates.length === 2 && typeof coordinates[0] === "number" && typeof coordinates[1] === "number") {
-      type = "Point";
-    } else if (Array.isArray(coordinates[0]) && coordinates[0].length === 2) {
-      type = "LineString";
-    } else if (Array.isArray(coordinates[0]) && Array.isArray(coordinates[0][0])) {
-      const outerRing = coordinates[0];
-      const isClosed = outerRing[0].join(",") === outerRing[outerRing.length - 1].join(",");
-      if (isClosed) {
-        type = "Polygon";
-      } else if (coordinates.length > 1) {
-        type = "MultiPolygon";
+    const result = [];
+    let p, pp;
+    for (let i = 0, len = arr.length; i < len; i++) {
+      p = arr[i];
+      if (CommUtil.isNil(p)) {
+        result.push(null);
+        continue;
+      }
+      if (Array.isArray(p)) {
+        result.push(this.deCompose(p, fn, context));
       } else {
-        throw Error("coordinates 参数格式错误");
+        pp = context ? fn.call(context, p) : fn(p);
+        result.push(pp);
       }
-    } else {
-      throw Error("coordinates 参数格式错误");
     }
-    return {
-      type: "Feature",
-      geometry: { type, coordinates }
-    };
+    return result;
   }
 };
-const GeoUtil = {
-  toRadian: Math.PI / 180,
-  R: 6371393,
-  /**
-   * 判断给定的经纬度是否合法
-   *
-   * @param lng 经度值
-   * @param lat 纬度值
-   * @returns 如果经纬度合法，返回true；否则返回false
-   */
-  isLnglat(lng, lat) {
-    return !isNaN(lng) && !isNaN(lat) && !!(+lat > -90 && +lat < 90 && +lng > -180 && +lng < 180);
+const myDate = Object.create(Date);
+myDate.prototype.format = function(fmt = "yyyy-MM-dd hh:mm:ss") {
+  const o = {
+    "M+": this.getMonth() + 1,
+    // 月份
+    "d+": this.getDate(),
+    // 日
+    "h+": this.getHours() % 12,
+    // 小时
+    "H+": this.getHours(),
+    // 小时 (24小时制)
+    "m+": this.getMinutes(),
+    // 分
+    "s+": this.getSeconds(),
+    // 秒
+    "q+": Math.floor((this.getMonth() + 3) / 3),
+    // 季度
+    S: this.getMilliseconds()
+    // 毫秒
+  };
+  if (/(y+)/.test(fmt)) {
+    fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
+  }
+  for (const k in o) {
+    if (new RegExp("(" + k + ")").test(fmt)) {
+      const len = k.length === 1 ? 1 : Number(k.slice(1));
+      fmt = fmt.replace(RegExp.$1, ("00" + o[k]).substr(("" + o[k]).length + len - (o[k] + "").length));
+    }
+  }
+  return fmt;
+};
+myDate.prototype.addDate = function(interval, number) {
+  const date = new Date(this);
+  switch (interval) {
+    case "y":
+      date.setFullYear(this.getFullYear() + number);
+      break;
+    case "q":
+      date.setMonth(this.getMonth() + number * 3);
+      break;
+    case "M":
+      date.setMonth(this.getMonth() + number);
+      break;
+    case "w":
+      date.setDate(this.getDate() + number * 7);
+      break;
+    case "d":
+      date.setDate(this.getDate() + number);
+      break;
+    case "h":
+      date.setHours(this.getHours() + number);
+      break;
+    case "m":
+      date.setMinutes(this.getMinutes() + number);
+      break;
+    case "s":
+      date.setSeconds(this.getSeconds() + number);
+      break;
+    default:
+      date.setDate(this.getDate() + number);
+      break;
+  }
+  return date;
+};
+const DateUtil = {
+  lastMonthDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth() - 1, 1),
+  thisMonthDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), 1),
+  nextMonthDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth() + 1, 1),
+  lastWeekDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1 - 7 - (/* @__PURE__ */ new Date()).getDay()),
+  thisWeekDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1 - (/* @__PURE__ */ new Date()).getDay()),
+  nextWeekDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1 + 7 - (/* @__PURE__ */ new Date()).getDay()),
+  lastDayDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() - 1),
+  thisDayDate: new Date((/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0)),
+  nextDayDate: new Date((/* @__PURE__ */ new Date()).getFullYear(), (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate() + 1),
+  parseDate(str) {
+    if (typeof str == "string") {
+      var results = str.match(/^ *(\d{4})-(\d{1,2})-(\d{1,2}) *$/);
+      if (results && results.length > 3) return new Date(parseInt(results[1]), parseInt(results[2]) - 1, parseInt(results[3]));
+      results = str.match(/^ *(\d{4})-(\d{1,2})-(\d{1,2}) +(\d{1,2}):(\d{1,2}):(\d{1,2}) *$/);
+      if (results && results.length > 6)
+        return new Date(
+          parseInt(results[1]),
+          parseInt(results[2]) - 1,
+          parseInt(results[3]),
+          parseInt(results[4]),
+          parseInt(results[5]),
+          parseInt(results[6])
+        );
+      results = str.match(/^ *(\d{4})-(\d{1,2})-(\d{1,2}) +(\d{1,2}):(\d{1,2}):(\d{1,2})\.(\d{1,9}) *$/);
+      if (results && results.length > 7)
+        return new Date(
+          parseInt(results[1]),
+          parseInt(results[2]) - 1,
+          parseInt(results[3]),
+          parseInt(results[4]),
+          parseInt(results[5]),
+          parseInt(results[6]),
+          parseInt(results[7])
+        );
+    }
+    return null;
   },
   /**
-   * 计算两哥平面坐标点间的距离
+   * 格式化时间间隔
    *
-   * @param p1 坐标点1，包含x和y属性
-   * @param p2 坐标点2，包含x和y属性
-   * @returns 返回两点间的欧几里得距离
+   * @param startTime 开始时间，可以是字符串、数字或日期类型
+   * @param endTime 结束时间，可以是字符串、数字或日期类型
+   * @returns 返回格式化后的时间间隔字符串，格式为"天数 天 小时 时 分钟 分 秒 秒"或"少于1秒"
    */
-  distance(p1, p2) {
-    return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2));
+  formatDateInterval(startTime, endTime) {
+    const dateCreateTime = new Date(startTime);
+    const dateFinishTime = new Date(endTime);
+    const dateInterval = dateFinishTime.getTime() - dateCreateTime.getTime();
+    const days = Math.floor(dateInterval / (24 * 3600 * 1e3));
+    const leave1 = dateInterval % (24 * 3600 * 1e3);
+    const hours = Math.floor(leave1 / (3600 * 1e3));
+    const leave2 = leave1 % (3600 * 1e3);
+    const minutes = Math.floor(leave2 / (60 * 1e3));
+    const leave3 = leave2 % (60 * 1e3);
+    const seconds = Math.round(leave3 / 1e3);
+    let intervalDes = "";
+    if (days > 0) {
+      intervalDes += days + "天";
+    }
+    if (hours > 0) {
+      intervalDes += hours + "时";
+    }
+    if (minutes > 0) {
+      intervalDes += minutes + "分";
+    }
+    if (seconds > 0) {
+      intervalDes += seconds + "秒";
+    }
+    if (days === 0 && hours === 0 && minutes === 0 && seconds === 0) {
+      intervalDes = "少于1秒";
+    }
+    return intervalDes;
+  },
+  formatterCounter(times) {
+    const checked = function(j) {
+      return (j > 10 ? "" : "0") + (j || 0);
+    };
+    const houres = checked(Math.floor(times / 3600));
+    const level1 = times % 3600;
+    const minutes = checked(Math.floor(level1 / 60));
+    const leave2 = level1 % 60;
+    const seconds = checked(Math.round(leave2));
+    return `${houres}:${minutes}:${seconds}`;
   },
+  sleep(d) {
+  }
+};
+function trim(str) {
+  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+}
+function splitWords(str) {
+  return trim(str).split(/\s+/);
+}
+const DomUtil = {
   /**
-   * 计算两个经纬度点之间的距离
+   * 获取元素的样式值
    *
-   * @param A 经纬度点A，包含lng（经度）和lat（纬度）两个属性
-   * @param B 经纬度点B，包含lng（经度）和lat（纬度）两个属性
-   * @returns 返回两点之间的距离，单位为米
+   * @param el 元素对象
+   * @param style 样式属性名称
+   * @returns 元素的样式值，如果获取不到则返回 null
    */
-  distanceByPoints(A, B) {
-    const { lng: lngA, lat: latA } = A;
-    const { lng: lngB, lat: latB } = B;
-    const earthR = 6371e3;
-    const x = Math.cos(latA * Math.PI / 180) * Math.cos(latB * Math.PI / 180) * Math.cos((lngA - lngB) * Math.PI / 180);
-    const y = Math.sin(latA * Math.PI / 180) * Math.sin(latB * Math.PI / 180);
-    let s = x + y;
-    if (s > 1) s = 1;
-    if (s < -1) s = -1;
-    const alpha = Math.acos(s);
-    const distance = alpha * earthR;
-    return distance;
+  getStyle(el, style) {
+    var _a;
+    let value = el.style[style];
+    if (!value || value === "auto") {
+      const css = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(el, null);
+      value = css ? css[style] : null;
+      if (value === "auto") value = null;
+    }
+    return value;
   },
   /**
-   * 格式化经纬度为度分秒格式
+   * 创建一个HTML元素
    *
-   * @param lng 经度
-   * @param lat 纬度
-   * @returns 返回格式化后的经纬度字符串，格式为：经度度分秒,纬度度分秒
+   * @param tagName 元素标签名
+   * @param className 元素类名
+   * @param container 父容器，若传入，则新创建的元素会被添加到该容器中
+   * @returns 返回新创建的HTML元素
    */
-  formatLnglat(lng, lat) {
-    let res = "";
-    function formatDegreeToDMS(valueInDegrees) {
-      const degree = Math.floor(valueInDegrees);
-      const minutes = Math.floor((valueInDegrees - degree) * 60);
-      const seconds = (valueInDegrees - degree) * 3600 - minutes * 60;
-      return `${degree}°${minutes}′${seconds.toFixed(2)}″`;
-    }
-    if (this.isLnglat(lng, lat)) {
-      res = formatDegreeToDMS(lng) + "," + formatDegreeToDMS(lat);
-    } else if (!isNaN(lng)) {
-      res = formatDegreeToDMS(lng);
-    } else if (!isNaN(lat)) {
-      res = formatDegreeToDMS(lat);
+  create(tagName, className, container) {
+    const el = document.createElement(tagName);
+    el.className = className || "";
+    if (container) {
+      container.appendChild(el);
     }
-    return res;
+    return el;
   },
   /**
-   * 将经纬度字符串转换为度
+   * 从父节点中移除指定元素。
    *
-   * @param lng 经度字符串
-   * @param lat 纬度字符串
-   * @returns 转换后的经纬度对象
+   * @param el 要移除的元素对象，必须包含parentNode属性。
    */
-  transformLnglat(lng, lat) {
-    function dms2deg(dmsString) {
-      const isNegative = /[sw]/i.test(dmsString);
-      let factor = isNegative ? -1 : 1;
-      const numericParts = dmsString.match(/[\d.]+/g) || [];
-      let degrees = 0;
-      for (let i = 0; i < numericParts.length; i++) {
-        degrees += parseFloat(numericParts[i]) / factor;
-        factor *= 60;
-      }
-      return degrees;
-    }
-    if (lng && lat) {
-      return {
-        lng: dms2deg(lng),
-        lat: dms2deg(lat)
-      };
+  remove(el) {
+    const parent = el.parentNode;
+    if (parent) {
+      parent.removeChild(el);
     }
   },
   /**
-   * 射线法判断点是否在多边形内
+   * 清空给定元素的子节点
    *
-   * @param p 点对象，包含x和y属性
-   * @param poly 多边形顶点数组，可以是字符串数组或对象数组
-   * @returns 返回字符串，表示点相对于多边形的位置：'in'表示在多边形内，'out'表示在多边形外，'on'表示在多边形上
+   * @param el 要清空子节点的元素，包含firstChild和removeChild属性
    */
-  rayCasting(p, poly) {
-    var px = p.x, py = p.y, flag = false;
-    for (var i = 0, l = poly.length, j = l - 1; i < l; j = i, i++) {
-      var sx = poly[i].x, sy = poly[i].y, tx = poly[j].x, ty = poly[j].y;
-      if (sx === px && sy === py || tx === px && ty === py) {
-        return "on";
-      }
-      if (sy < py && ty >= py || sy >= py && ty < py) {
-        var x = sx + (py - sy) * (tx - sx) / (ty - sy);
-        if (x === px) {
-          return "on";
-        }
-        if (x > px) {
-          flag = !flag;
-        }
-      }
+  empty(el) {
+    while (el.firstChild) {
+      el.removeChild(el.firstChild);
     }
-    return flag ? "in" : "out";
   },
   /**
-   * 旋转点
+   * 将元素移到父节点的最前面
    *
-   * @param p1 旋转前点坐标
-   * @param p2 旋转中心坐标
-   * @param θ 旋转角度（顺时针旋转为正）
-   * @returns 旋转后点坐标
+   * @param el 要移动的元素，需要包含 parentNode 属性
    */
-  rotatePoint(p1, p2, θ) {
-    const x = (p1.x - p2.x) * Math.cos(Math.PI / 180 * -θ) - (p1.y - p2.y) * Math.sin(Math.PI / 180 * -θ) + p2.x;
-    const y = (p1.x - p2.x) * Math.sin(Math.PI / 180 * -θ) + (p1.y - p2.y) * Math.cos(Math.PI / 180 * -θ) + p2.y;
-    return { x, y };
+  toFront(el) {
+    const parent = el.parentNode;
+    if (parent && parent.lastChild !== el) {
+      parent.appendChild(el);
+    }
   },
   /**
-   * 根据两个平面坐标点计算方位角和距离
+   * 将元素移动到其父节点的最前面
    *
-   * @param p1 第一个点的坐标对象
-   * @param p2 第二个点的坐标对象
-   * @returns 返回一个对象，包含angle和distance属性，分别表示两点之间的角度（以度为单位，取值范围为0~359）和距离
+   * @param el 要移动的元素，需要包含parentNode属性
    */
-  calcBearAndDis(p1, p2) {
-    const { x: x1, y: y1 } = p1;
-    const { x: x2, y: y2 } = p2;
-    const dx = x2 - x1;
-    const dy = y2 - y1;
-    const distance = Math.sqrt(dx * dx + dy * dy);
-    const angleInRadians = Math.atan2(dy, dx);
-    const angle = (angleInRadians * (180 / Math.PI) + 360 + 90) % 360;
-    return { angle, distance };
+  toBack(el) {
+    const parent = el.parentNode;
+    if (parent && parent.firstChild !== el) {
+      parent.insertBefore(el, parent.firstChild);
+    }
   },
   /**
-   * 根据两个经纬度点计算方位角和距离
+   * 获取元素的类名
    *
-   * @param latlng1 第一个经纬度点
-   * @param latlng2 第二个经纬度点
-   * @returns 包含方位角和距离的对象
+   * @param el 包含对应元素和类名的对象
+   * @param el.correspondingElement 对应的元素
+   * @param el.className 类名对象
+   * @param el.className.baseVal 类名字符串
+   * @returns 返回元素的类名字符串
    */
-  calcBearAndDisByPoints(latlng1, latlng2) {
-    var f1 = latlng1.lat * 1, l1 = latlng1.lng * 1, f2 = latlng2.lat * 1, l2 = latlng2.lng * 1;
-    var y = Math.sin((l2 - l1) * this.toRadian) * Math.cos(f2 * this.toRadian);
-    var x = Math.cos(f1 * this.toRadian) * Math.sin(f2 * this.toRadian) - Math.sin(f1 * this.toRadian) * Math.cos(f2 * this.toRadian) * Math.cos((l2 - l1) * this.toRadian);
-    var angle = Math.atan2(y, x) * (180 / Math.PI);
-    var deltaF = (f2 - f1) * this.toRadian;
-    var deltaL = (l2 - l1) * this.toRadian;
-    var a = Math.sin(deltaF / 2) * Math.sin(deltaF / 2) + Math.cos(f1 * this.toRadian) * Math.cos(f2 * this.toRadian) * Math.sin(deltaL / 2) * Math.sin(deltaL / 2);
-    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
-    var distance = this.R * c;
-    return {
-      angle,
-      distance
-    };
+  getClass(el) {
+    const shadowElement = (el == null ? void 0 : el.host) || el;
+    return shadowElement.className.toString();
   },
   /**
-   * 计算点P到线段P1P2的最短距离
+   * 判断元素是否包含指定类名
    *
-   * @param p 点P的坐标
-   * @param p1 线段起点P1的坐标
-   * @param p2 线段终点P2的坐标
-   * @returns 点P到线段P1P2的最短距离
+   * @param el 元素对象，包含classList属性，classList属性包含contains方法
+   * @param name 要判断的类名
+   * @returns 返回一个布尔值，表示元素是否包含指定类名
    */
-  distanceToSegment(p, p1, p2) {
-    const x = p.x, y = p.y, x1 = p1.x, y1 = p1.y, x2 = p2.x, y2 = p2.y;
-    const cross = (x2 - x1) * (x - x1) + (y2 - y1) * (y - y1);
-    if (cross <= 0) {
-      return Math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1));
-    }
-    const d2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
-    if (cross >= d2) {
-      return Math.sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2));
+  hasClass(el, name) {
+    var _a;
+    if ((_a = el.classList) == null ? void 0 : _a.contains(name)) {
+      return true;
     }
-    const r = cross / d2;
-    const px = x1 + (x2 - x1) * r;
-    const py = y1 + (y2 - y1) * r;
-    return Math.sqrt((x - px) * (x - px) + (y - py) * (y - py));
+    const className = this.getClass(el);
+    return className.length > 0 && new RegExp(`(^|\\s)${name}(\\s|$)`).test(className);
   },
   /**
-   * 根据给定的经纬度、角度和距离计算新的经纬度点
+   * 给指定的 HTML 元素添加类名
    *
-   * @param latlng 给定的经纬度点，类型为LngLat
-   * @param angle 角度值，单位为度，表示从当前点出发的方向
-   * @param distance 距离值，单位为米，表示从当前点出发的距离
-   * @returns 返回计算后的新经纬度点，类型为{lat: number, lng: number}
+   * @param el 要添加类名的 HTML 元素
+   * @param name 要添加的类名，多个类名之间用空格分隔
    */
-  calcPointByBearAndDis(latlng, angle, distance) {
-    const sLat = MathUtils.deg2Rad(latlng.lat * 1);
-    const sLng = MathUtils.deg2Rad(latlng.lng * 1);
-    const d = distance / this.R;
-    angle = MathUtils.deg2Rad(angle);
-    const lat = Math.asin(Math.sin(sLat) * Math.cos(d) + Math.cos(sLat) * Math.sin(d) * Math.cos(angle));
-    const lon = sLng + Math.atan2(Math.sin(angle) * Math.sin(d) * Math.cos(sLat), Math.cos(d) - Math.sin(sLat) * Math.sin(lat));
-    return {
-      lat: MathUtils.rad2Deg(lat),
-      lng: MathUtils.rad2Deg(lon)
-    };
+  addClass(el, name) {
+    if (el.classList !== void 0) {
+      const classes = splitWords(name);
+      for (let i = 0, len = classes.length; i < len; i++) {
+        el.classList.add(classes[i]);
+      }
+    } else if (!this.hasClass(el, name)) {
+      const className = this.getClass(el);
+      this.setClass(el, (className ? className + " " : "") + name);
+    }
   },
   /**
-   * 将墨卡托坐标转换为经纬度坐标
+   * 从元素中移除指定类名
    *
-   * @param x 墨卡托坐标的x值
-   * @param y 墨卡托坐标的y值
-   * @returns 返回包含转换后的经度lng和纬度lat的对象
+   * @param el 要移除类名的元素
+   * @param name 要移除的类名，多个类名用空格分隔
    */
-  mercatorTolonlat(x, y) {
-    const lng = x / 2003750834e-2 * 180;
-    var mmy = y / 2003750834e-2 * 180;
-    const lat = 180 / Math.PI * (2 * Math.atan(Math.exp(mmy * Math.PI / 180)) - Math.PI / 2);
-    return { lng, lat };
+  removeClass(el, name) {
+    if (el.classList !== void 0) {
+      const classes = splitWords(name);
+      classes.forEach((className) => el.classList.remove(className));
+    } else {
+      this.setClass(el, (" " + this.getClass(el) + " ").replace(" " + name + " ", " ").trim());
+    }
   },
   /**
-   * 将经纬度坐标转换为墨卡托坐标
+   * 设置元素的 CSS 类名
    *
-   * @param lng 经度值
-   * @param lat 纬度值
-   * @returns 墨卡托坐标对象，包含x和y属性
+   * @param el HTML 或 SVG 元素
+   * @param name 要设置的类名，多个类名之间用空格分隔
    */
-  lonlatToMercator(lng, lat) {
-    var earthRad = 6378137;
-    const x = lng * Math.PI / 180 * earthRad;
-    var a = lat * Math.PI / 180;
-    const y = earthRad / 2 * Math.log((1 + Math.sin(a)) / (1 - Math.sin(a)));
-    return { x, y };
+  setClass(el, name) {
+    if ("classList" in el) {
+      el.classList.value = "";
+      name.split(" ").forEach((className) => el.classList.add(className));
+    }
   },
   /**
-   * 根据百分比获取坐标
+   * 从字符串中解析XML文档，并返回根节点
    *
-   * @param start 起点坐标
-   * @param end 终点坐标
-   * @param percent 百分比，取值范围0-1
-   * @returns 返回插值后的坐标
+   * @param str 要解析的XML字符串
+   * @returns 解析后的XML文档的根节点
    */
-  interpolate({ x: x1, y: y1, z: z1 = 0 }, { x: x2, y: y2, z: z2 = 0 }, percent) {
-    const dx = x2 - x1, dy = y2 - y1, dz = z2 - z1;
-    return { x: x1 + dx * percent, y: y1 + dy * percent, z: z1 + dz * percent };
+  parseFromString(str) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(str, "text/xml");
+    return doc.children[0];
   }
 };
 const FileUtil = {
@@ -2861,162 +3150,6 @@ const OptimizeUtil = {
     };
   }
 };
-const StringUtil = {
-  /**
-   * 校验字符串是否符合指定类型
-   *
-   * @param str 待校验字符串
-   * @param type 校验类型，可选值包括：
-   *   - 'phone': 手机号码
-   *   - 'tel': 座机
-   *   - 'card': 身份证
-   *   - 'pwd': 密码（以字母开头，长度在6~18之间，只能包含字母、数字和下划线）
-   *   - 'postal': 邮政编码
-   *   - 'QQ': QQ号
-   *   - 'email': 邮箱
-   *   - 'money': 金额（小数点2位）
-   *   - 'URL': 网址
-   *   - 'IP': IP地址
-   *   - 'date': 日期时间
-   *   - 'number': 数字
-   *   - 'english': 英文
-   *   - 'chinese': 中文
-   *   - 'lower': 小写字母
-   *   - 'upper': 大写字母
-   *   - 'HTML': HTML标记
-   * @returns 校验结果，符合返回true，否则返回false
-   */
-  checkStr(str, type) {
-    switch (type) {
-      case "phone":
-        return /^1[3|4|5|6|7|8|9][0-9]{9}$/.test(str);
-      case "tel":
-        return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str);
-      case "card":
-        return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(str);
-      case "pwd":
-        return /^[a-zA-Z]\w{5,17}$/.test(str);
-      case "postal":
-        return /[1-9]\d{5}(?!\d)/.test(str);
-      case "QQ":
-        return /^[1-9][0-9]{4,9}$/.test(str);
-      case "email":
-        return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);
-      case "money":
-        return /^\d*(?:\.\d{0,2})?$/.test(str);
-      case "URL":
-        return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str);
-      case "IP":
-        return /((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))/.test(str);
-      case "date":
-        return /^(\d{4})\-(\d{2})\-(\d{2}) (\d{2})(?:\:\d{2}|:(\d{2}):(\d{2}))$/.test(str) || /^(\d{4})\-(\d{2})\-(\d{2})$/.test(str);
-      case "number":
-        return /^[0-9]$/.test(str);
-      case "english":
-        return /^[a-zA-Z]+$/.test(str);
-      case "chinese":
-        return /^[\u4E00-\u9FA5]+$/.test(str);
-      case "lower":
-        return /^[a-z]+$/.test(str);
-      case "upper":
-        return /^[A-Z]+$/.test(str);
-      case "HTML":
-        return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str);
-      default:
-        return true;
-    }
-  },
-  /**
-   * 转换字符串大小写
-   *
-   * @param str 待转换的字符串
-   * @param type 转换类型，可选值为 1-5，默认为 4
-   * 1：首字母大写，其余小写
-   * 2：首字母小写，其余大写
-   * 3：字母大小写反转
-   * 4：全部大写
-   * 5：全部小写
-   * @returns 转换后的字符串
-   */
-  changeCase(str, type) {
-    type = type || 4;
-    switch (type) {
-      case 1:
-        return str.replace(/\b\w+\b/g, function(word) {
-          return word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase();
-        });
-      case 2:
-        return str.replace(/\b\w+\b/g, function(word) {
-          return word.substring(0, 1).toLowerCase() + word.substring(1).toUpperCase();
-        });
-      case 3:
-        return str.split("").map(function(word) {
-          if (/[a-z]/.test(word)) {
-            return word.toUpperCase();
-          } else {
-            return word.toLowerCase();
-          }
-        }).join("");
-      case 4:
-        return str.toUpperCase();
-      case 5:
-        return str.toLowerCase();
-      default:
-        return str;
-    }
-  },
-  /**
-   * 根据字符串数组和参数生成新的字符串
-   *
-   * @param strArray 字符串数组
-   * @param args 可变参数列表，支持 Object、Array 类型和任意其他类型，若为 null 或 undefined，则按类型默认转换为 '{}'、'[]' 或 ''
-   * @returns 返回生成的新字符串
-   */
-  tag(strArray, ...args) {
-    args = args.map((val) => {
-      switch (CommUtils.getDataType(val)) {
-        case "Object":
-          return val || "{}";
-        case "Array":
-          return val || "[]";
-        default:
-          return val || "";
-      }
-    });
-    return strArray.reduce((prev, next, index) => `${prev}${args[index - 1]}${next}`);
-  },
-  /**
-   * 计算字符串的字节长度
-   *
-   * @param str 需要计算字节长度的字符串
-   * @returns 返回字符串的字节长度
-   */
-  getByteLength(str) {
-    return str.replace(/[\u0391-\uFFE5]/g, "aa").length;
-  },
-  /**
-   * 截取字符串中指定字节长度的子串
-   *
-   * @param str 字符串对象，包含replace、length和substring方法
-   * @param start 截取起始位置
-   * @param n 截取字节长度
-   * @returns 返回截取后的子串
-   */
-  subStringByte(str, start, n) {
-    var r = /[^\x00-\xff]/g;
-    if (str.replace(r, "mm").length <= n) {
-      return str;
-    }
-    var m = Math.floor(n / 2);
-    for (var i = m; i < str.length; i++) {
-      let sub = str.substring(start, i);
-      if (sub.replace(r, "mm").length >= n) {
-        return sub;
-      }
-    }
-    return str;
-  }
-};
 const UrlUtil = {
   /**
    * 将json对象转换为查询字符串
@@ -3069,6 +3202,7 @@ const UrlUtil = {
 export {
   AjaxUtil,
   ArrayUtil,
+  AssertUtil,
   AudioPlayer,
   BrowserUtil,
   CanvasDrawer,
@@ -3097,6 +3231,6 @@ export {
   Storage,
   StringUtil,
   UrlUtil,
-  CommUtils as Util,
+  CommUtil as Util,
   WebSocketClient
 };