gis-common 3.1.1 → 3.1.3

package/dist/gis-common.es.js

@@ -0,0 +1,1751 @@
+var AnimateUtils = {
+  animate(ele, attr_options, callback, timefn = "swing", speed = 5) {
+    for (var attr in attr_options) {
+      attr_options[attr] = {
+        target: attr === "opacity" ? parseInt(attr_options[attr] * 100) : attr_options[attr],
+        iNow: attr === "opacity" ? parseInt(getComputedStyle(ele)[attr] * 100) : parseInt(getComputedStyle(ele)[attr])
+      };
+    }
+    if (timefn === "liner") {
+      speed = attr_options[attr].iNow < attr_options[attr].target ? Math.abs(speed) : -Math.abs(speed);
+    }
+    clearInterval(ele.timer);
+    ele.timer = setInterval(function() {
+      for (var attr2 in attr_options) {
+        var target = attr_options[attr2].target;
+        var iNow = attr_options[attr2].iNow;
+        if (timefn === "swing") {
+          speed = (target - iNow) / 20;
+          speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);
+        }
+        if (Math.abs(target - iNow) <= Math.abs(speed)) {
+          if (attr2 === "opacity") {
+            ele.style[attr2] = target / 100;
+          } else {
+            ele.style[attr2] = target + "px";
+          }
+          delete attr_options[attr2];
+          for (var num in attr_options) {
+            return false;
+          }
+          clearInterval(ele.timer);
+          typeof callback === "function" ? callback() : "";
+        } else {
+          attr_options[attr2].iNow += speed;
+          if (attr2 === "opacity") {
+            ele.style[attr2] = attr_options[attr2].iNow / 100;
+          } else {
+            ele.style[attr2] = attr_options[attr2].iNow + "px";
+          }
+        }
+      }
+    }, 30);
+  }
+};
+var EventType = {
+  MAP_RENDER: "mapRender",
+  MAP_READY: "mapReady",
+  MOUSE_CLICK: "click",
+  MOUSE_DOUBLE_CLICK: "dblclick",
+  MOUSE_MOVE: "mousemove",
+  MOUSE_IN: "mousein",
+  MOUSE_OUT: "mouseout",
+  MOUSE_RIGHT_CLICK: "mouseRightClick",
+  KEY_DOWN: "keyDown",
+  KEY_UP: "keyUp",
+  DRAW_ACTIVE: "drawActive",
+  DRAW_MOVE: "drawMove",
+  DRAW_COMPLETE: "drawComplete",
+  MQTT_CONNECT: "mqttConnect",
+  MQTT_ERROR: "mqttError",
+  MQTT_MESSAGE: "mqttMessage",
+  MQTT_CLOSE: "mqttClose",
+  WEB_SOCKET_CONNECT: "webSocketConnect",
+  WEB_SOCKET_ERROR: "webSocketError",
+  WEB_SOCKET_MESSAGE: "webSocketMessage",
+  WEB_SOCKET_CLOSE: "webSocketClose"
+};
+var ErrorType = {
+  LOGIN_EXPIRED: "\u767B\u5F55\u4FE1\u606F\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55",
+  CROSS_ERROR: "\u8DE8\u57DF\u8BBF\u95EE",
+  UNEXIST_RESOURCE: "\u8D44\u6E90\u4E0D\u5B58\u5728",
+  TIMEOUT: "\u8BF7\u6C42\u8D85\u65F6",
+  INTERNAL_ERROR: "\u5185\u90E8\u9519\u8BEF",
+  NETWORK_ERROR: "\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u662F\u5426\u5DF2\u8FDE\u63A5",
+  PROCESS_FAIL: "\u5904\u7406\u5931\u8D25",
+  AUTH_VERIFY_ERROR: "\u6743\u9650\u9A8C\u8BC1\u5931\u8D25",
+  NO_DATA_FOUND: "\u672A\u627E\u5230\u6570\u636E",
+  DUPLICATE_INSTANCE: "\u5B9E\u4F8B\u4E3A\u5355\u4F8B\u6A21\u5F0F\uFF0C\u4E0D\u5141\u8BB8\u91CD\u590D\u6784\u5EFA",
+  COORDINATE_ERROR: "\u5750\u6807\u9A8C\u8BC1\u5931\u8D25",
+  JSON_PARSE_ERROR: "JSON\u89E3\u6790\u5931\u8D25\uFF0C\u683C\u5F0F\u6709\u8BEF",
+  JSON_VALUE_ERROR: "JSON\u65E0\u6B64\u952E",
+  PARAMETER_ERROR: "\u9A8C\u8BC1\u6570\u636E\u7C7B\u578B\u5931\u8D25",
+  PARAMETER_ERROR_ARRAY: "\u683C\u5F0F\u7C7B\u578B\u9A8C\u8BC1\u5931\u8D25\uFF1A\u5FC5\u987B\u662F\u6570\u7EC4",
+  PARAMETER_ERROR_STRING: "\u683C\u5F0F\u7C7B\u578B\u9A8C\u8BC1\u5931\u8D25\uFF1A\u5FC5\u987B\u662F\u5B57\u7B26",
+  PARAMETER_ERROR_FUNCTION: "\u683C\u5F0F\u7C7B\u578B\u9A8C\u8BC1\u5931\u8D25\uFF1A\u5FC5\u987B\u662F\u51FD\u6570",
+  PARAMETER_ERROR_OBJECT: "\u683C\u5F0F\u7C7B\u578B\u9A8C\u8BC1\u5931\u8D25\uFF1A\u5FC5\u987B\u662F\u5BF9\u8C61",
+  PARAMETER_ERROR_LACK: "\u53C2\u6570\u7F3A\u5931",
+  STRING_CHECK_LOSS: "\u5B57\u7B26\u7F3A\u5C11\u5173\u952E\u5B57"
+};
+var LayerType = {
+  SUPER_MAP_IMAGES: "SuperMapImages",
+  SUPER_MAP_DATA: "SuperMapData",
+  ARC_GIS_MAP_IMAGES: "ArcGisMapImages",
+  ARC_GIS_MAP_DATA: "ArcGisMapData",
+  OSGB_LAYER: "OSGBLayer",
+  S3M_GROUP: "S3MGroup",
+  TERRAIN_LAYER: "TerrainFileLayer"
+};
+const GraphicType = {
+  POINT: "point",
+  POLYLINE: "polyline",
+  POLYGON: "polygon",
+  BILLBOARD: "billboard",
+  CYLINDER: "cylinder",
+  ELLIPSOID: "ellipsoid",
+  LABEL: "label",
+  MODEL: "model",
+  WALL: "wall"
+};
+const MeasureMode = {
+  DISTANCE: "distance",
+  AREA: "area",
+  HEIGHT: "height"
+};
+var CommUtils = {
+  getDataType(data) {
+    return Object.prototype.toString.call(data).slice(8, -1);
+  },
+  isEmpty(value) {
+    if (value == null) {
+      return true;
+    }
+    const type = this.getDataType(value);
+    switch (type) {
+      case "String":
+        return value.trim() === "";
+      case "Array":
+        return !value.length;
+      case "Object":
+        return !Object.keys(value).length;
+      case "Boolean":
+        return !value;
+      default:
+        return false;
+    }
+  },
+  isNotEmpty(val) {
+    return !this.isEmpty(val);
+  },
+  json2form(json) {
+    const formData = new FormData();
+    Object.keys(json).forEach((key) => {
+      formData.append(key, json[key] instanceof Object ? JSON.stringify(json[key]) : json[key]);
+    });
+    return formData;
+  },
+  json2Query(json) {
+    var tempArr = [];
+    for (var i in json) {
+      var key = i;
+      var value = json[i];
+      tempArr.push(key + "=" + value);
+    }
+    var urlParamsStr = tempArr.join("&");
+    return urlParamsStr;
+  },
+  generateGuid() {
+    const S4 = function() {
+      return ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
+    };
+    return S4() + S4() + S4() + S4() + S4() + S4() + S4() + S4();
+  },
+  decodeDict(...args) {
+    let res = "";
+    if (args.length > 1) {
+      const items = args.slice(1, args.length % 2 === 0 ? args.length - 1 : args.length);
+      for (let i = 0; i < items.length; i = i + 2) {
+        const item = items[i];
+        if (args[0] === item) {
+          res = items[i + 1];
+        }
+      }
+      if (!res && args.length % 2 === 0) {
+        res = args[args.length - 1];
+      }
+    } else {
+      res = args[0];
+    }
+    return res;
+  },
+  extend(dest, ...args) {
+    let i, j, len, src;
+    for (j = 0, len = args.length; j < len; j++) {
+      src = args[j];
+      for (i in src) {
+        dest[i] = src[i];
+      }
+    }
+    return dest;
+  },
+  rgb2hex(rgb) {
+    var hex = "#" + ((1 << 24) + (rgb[0] << 16) + (rgb[1] << 8) + rgb[2]).toString(16).slice(1);
+    return hex;
+  },
+  convertToTree2(data, idPropertyName = "id", parentIdPropertyName = "parentId", childrenPropertyName = "children") {
+    const result = [];
+    function buildChildren(item) {
+      const id = item[idPropertyName];
+      const children = data.filter((item2) => item2.hasOwnProperty(parentIdPropertyName) && item2[parentIdPropertyName] === id);
+      if (children.length > 0) {
+        children.forEach(buildChildren);
+        item[childrenPropertyName] = children;
+      }
+    }
+    for (const item of data) {
+      if (data.findIndex((t) => t[idPropertyName] === item[parentIdPropertyName]) === -1) {
+        buildChildren(item);
+        result.push(item);
+      }
+    }
+    return result;
+  },
+  asyncLoadScript(url) {
+    return new Promise((resolve, reject) => {
+      try {
+        var oscript = document.createElement("script");
+        if (oscript.readyState) {
+          oscript.onreadystatechange = function() {
+            if (oscript.readyState === "complete" || oscript.readyState === "loaded") {
+              resolve(oscript);
+            }
+          };
+        } else {
+          oscript.onload = function() {
+            resolve(oscript);
+          };
+        }
+        oscript.type = "text/javascript";
+        oscript.src = url;
+        document.body.appendChild(oscript);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  },
+  loadStyle(urls) {
+    urls.forEach((url) => {
+      const css = document.createElement("link");
+      css.href = url;
+      css.rel = "stylesheet";
+      css.type = "text/css";
+      document.head.appendChild(css);
+    });
+  },
+  template(str, data) {
+    const templateRe = /\{ *([\w_-]+) *\}/g;
+    return str.replace(templateRe, function(str2, key) {
+      var value = data[key];
+      if (value === void 0) {
+        throw new Error(ErrorType.JSON_VALUE_ERROR + str2);
+      } else if (typeof value === "function") {
+        value = value(data);
+      }
+      return value;
+    });
+  },
+  deleteEmptyProperty(data) {
+    return Object.fromEntries(
+      Object.keys(data).filter((d) => !this.isEmpty(data[d])).map((i) => [i, data[i]])
+    );
+  },
+  deepAssign() {
+    let len = arguments.length, target = arguments[0];
+    if (this.getDataType(target) !== "Object") {
+      target = {};
+    }
+    for (let i = 1; i < len; i++) {
+      let source = arguments[i];
+      if (this.getDataType(source) === "Object") {
+        for (let s in source) {
+          if (s === "__proto__" || target === source[s]) {
+            continue;
+          }
+          if (this.getDataType(source[s]) === "Object") {
+            target[s] = this.deepAssign(target[s], source[s]);
+          } else {
+            target[s] = source[s];
+          }
+        }
+      }
+    }
+    return target;
+  },
+  handleCopyValue(text) {
+    if (!navigator.clipboard && window.isSecureContext) {
+      return navigator.clipboard.writeText(text);
+    } else {
+      const textArea = document.createElement("textarea");
+      textArea.style.position = "fixed";
+      textArea.style.top = textArea.style.left = "-100vh";
+      textArea.style.opacity = "0";
+      textArea.value = text;
+      document.body.appendChild(textArea);
+      textArea.focus();
+      textArea.select();
+      return new Promise((resolve, reject) => {
+        document.execCommand("copy") ? resolve() : reject(new Error("copy failed"));
+        textArea.remove();
+      });
+    }
+  }
+};
+Array.prototype.groupBy = function(f) {
+  var groups = {};
+  this.forEach(function(o) {
+    var group = JSON.stringify(f(o));
+    groups[group] = groups[group] || [];
+    groups[group].push(o);
+  });
+  return Object.keys(groups).map((group) => groups[group]);
+};
+Array.prototype.distinct = function(f = (d) => d) {
+  const arr = [], obj = {};
+  this.forEach((item) => {
+    const val = f(item);
+    !obj[val] && (obj[val] = arr.push(item));
+  });
+  return arr;
+};
+Array.prototype.max = function() {
+  return Math.max.apply({}, this);
+};
+Array.prototype.min = function() {
+  return Math.min.apply({}, this);
+};
+Array.prototype.sum = function() {
+  return this.length > 0 ? this.reduce((prev = 0, curr = 0) => prev + curr) : 0;
+};
+Array.prototype.avg = function() {
+  return this.length ? this.sum() / this.length : 0;
+};
+Array.prototype.desc = function(f = (d) => d) {
+  return this.sort((n1, n2) => f(n2) - f(n1));
+};
+Array.prototype.asc = function(f = (d) => d) {
+  return this.sort((n1, n2) => f(n1) - f(n2));
+};
+Array.prototype.clear = function() {
+  this.length = 0;
+  return this;
+};
+var ArrayUtils = {
+  asArray(obj) {
+    return CommUtils.isEmpty(obj) ? [] : Array.isArray(obj) ? obj : [obj];
+  },
+  generateArray(length) {
+    return [...new Array(length).keys()];
+  },
+  union(...args) {
+    let res = [];
+    args.forEach((arg) => {
+      if (Array.isArray(arg)) {
+        res = res.concat(arg.filter((v) => !res.includes(v)));
+      }
+    });
+    return res;
+  },
+  intersection(...args) {
+    let res = args[0] || [];
+    args.forEach((arg) => {
+      if (Array.isArray(arg)) {
+        res = res.filter((v) => arg.includes(v));
+      }
+    });
+    return res;
+  },
+  unionAll(...args) {
+    return [...args].flat().filter((d) => !!d);
+  },
+  difference(...args) {
+    return this.union(...args).filter((d) => !this.intersection(...args).includes(d));
+  }
+};
+var BrowserUtils = {
+  getUrlParams(href = window.location.href, needDecode = true) {
+    const reg = /([^&=]+)=([\w\W]*?)(&|$|#)/g;
+    const { search, hash } = new URL(href);
+    const args = [search, hash];
+    let obj = {};
+    for (let i = 0; i < args.length; i++) {
+      const str = args[i];
+      if (str) {
+        const s = str.replace(/#|\//g, "");
+        const arr = s.split("?");
+        if (arr.length > 1) {
+          for (let i2 = 1; i2 < arr.length; i2++) {
+            let res;
+            while (res = reg.exec(arr[i2])) {
+              obj[res[1]] = needDecode ? decodeURIComponent(res[2]) : res[2];
+            }
+          }
+        }
+      }
+    }
+    return obj;
+  },
+  getExplorer() {
+    var explorer = window.navigator.userAgent;
+    if (explorer.indexOf("MSIE") >= 0) {
+      return "IE";
+    }
+    if (!!window.ActiveXObject || "ActiveXObject" in window) {
+      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) {
+      return "Safari";
+    }
+  },
+  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;
+  },
+  switchFullScreen(status) {
+    if (status) {
+      const element = document.documentElement;
+      if (element.requestFullscreen) {
+        element.requestFullscreen();
+      } else if (element.msRequestFullscreen) {
+        element.msRequestFullscreen();
+      } else if (element.mozRequestFullScreen) {
+        element.mozRequestFullScreen();
+      } else if (element.webkitRequestFullscreen) {
+        element.webkitRequestFullscreen();
+      }
+    } else {
+      if (document.exitFullscreen) {
+        document.exitFullscreen();
+      } else if (document.msExitFullscreen) {
+        document.msExitFullscreen();
+      } else if (document.mozCancelFullScreen) {
+        document.mozCancelFullScreen();
+      } else if (document.webkitExitFullscreen) {
+        document.webkitExitFullscreen();
+      }
+    }
+  },
+  refreshScale() {
+    const baseWidth = document.documentElement.clientWidth;
+    const baseHeight = document.documentElement.clientHeight;
+    const appStyle = document.getElementById("app").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`;
+  },
+  getHtmlFontSize() {
+    const htmlwidth = document.documentElement.clientWidth || document.body.clientWidth;
+    const htmlDom = document.querySelector("html");
+    htmlDom.style.fontSize = htmlwidth / 192 + "px";
+  }
+};
+var Cookie = {
+  set: function(name, value, Days = 30) {
+    var exp = new Date();
+    exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1e3);
+    document.cookie = name + "=" + escape(value) + ";expires=" + exp.toGMTString();
+  },
+  remove: function(name) {
+    var exp = new Date();
+    exp.setTime(exp.getTime() - 1);
+    var cval = this.get(name);
+    if (cval != null) {
+      document.cookie = name + "=" + cval + ";expires=" + exp.toGMTString();
+    }
+  },
+  get: function(name) {
+    var arr = document.cookie.match(new RegExp("(^| )" + name + "=([^;]*)(;|$)"));
+    if (arr != null) {
+      return arr[2];
+    } else {
+      return "";
+    }
+  }
+};
+var CoordsUtils = {
+  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 };
+  },
+  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 };
+  },
+  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 };
+  },
+  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;
+    let wgsLon;
+    let i = 0;
+    while (1) {
+      wgsLat = (mLat + pLat) / 2;
+      wgsLon = (mLon + pLon) / 2;
+      const tmp = this.gcj_encrypt(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 };
+  },
+  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 };
+  },
+  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 };
+  },
+  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 };
+  },
+  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 };
+  },
+  distance(latA, lngA, latB, lngB) {
+    const earthR = 6371e3;
+    const x = Math.cos(latA * this.PI / 180) * Math.cos(latB * this.PI / 180) * Math.cos((lngA - lngB) * this.PI / 180);
+    const y = Math.sin(latA * this.PI / 180) * Math.sin(latB * this.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;
+  },
+  outOfChina(lat, lng) {
+    if (lng < 72.004 || lng > 137.8347) {
+      return true;
+    }
+    if (lat < 0.8293 || lat > 55.8271) {
+      return true;
+    }
+    return false;
+  },
+  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;
+  },
+  randomCoordinate(minX, minY, maxX, maxY) {
+    return {
+      lat: Math.random() * (maxY - minY) + minY,
+      lng: Math.random() * (maxX - minX) + minX
+    };
+  }
+};
+Date.prototype.format = function(fmt) {
+  const o = {
+    "M+": this.getMonth() + 1,
+    "d+": this.getDate(),
+    "h+": this.getHours(),
+    "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))
+      fmt = fmt.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k] : ("00" + o[k]).substr(("" + o[k]).length));
+  }
+  return fmt;
+};
+Date.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;
+};
+var DateUtils = {
+  lastMonthDate: new Date(new Date().getFullYear(), new Date().getMonth() - 1, 1),
+  thisMonthDate: new Date(new Date().getFullYear(), new Date().getMonth(), 1),
+  nextMonthDate: new Date(new Date().getFullYear(), new Date().getMonth() + 1, 1),
+  lastWeekDate: new Date(new Date().getFullYear(), new Date().getMonth(), new Date().getDate() + 1 - 7 - new Date().getDay()),
+  thisWeekDate: new Date(new Date().getFullYear(), new Date().getMonth(), new Date().getDate() + 1 - new Date().getDay()),
+  nextWeekDate: new Date(new Date().getFullYear(), new Date().getMonth(), new Date().getDate() + 1 + 7 - new Date().getDay()),
+  lastDayDate: new Date(new Date().getFullYear(), new Date().getMonth(), new Date().getDate() - 1),
+  thisDayDate: new Date(new Date().setHours(0, 0, 0, 0)),
+  nextDayDate: new Date(new Date().getFullYear(), new Date().getMonth(), 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;
+  },
+  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 + "\u5929";
+    }
+    if (hours > 0) {
+      intervalDes += hours + "\u65F6";
+    }
+    if (minutes > 0) {
+      intervalDes += minutes + "\u5206";
+    }
+    if (seconds > 0) {
+      intervalDes += seconds + "\u79D2";
+    }
+    if (days === 0 && hours === 0 && minutes === 0 && seconds === 0) {
+      intervalDes = "\u5C11\u4E8E1\u79D2";
+    }
+    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+/);
+}
+var DomUtils = {
+  getStyle(el, style) {
+    let value = el.style[style] || el.currentStyle && el.currentStyle[style];
+    if ((!value || value === "auto") && document.defaultView) {
+      const css = document.defaultView.getComputedStyle(el, null);
+      value = css ? css[style] : null;
+    }
+    return value === "auto" ? null : value;
+  },
+  create(tagName, className, container) {
+    const el = document.createElement(tagName);
+    el.className = className || "";
+    if (container) {
+      container.appendChild(el);
+    }
+    return el;
+  },
+  remove(el) {
+    const parent = el.parentNode;
+    if (parent) {
+      parent.removeChild(el);
+    }
+  },
+  empty(el) {
+    while (el.firstChild) {
+      el.removeChild(el.firstChild);
+    }
+  },
+  toFront(el) {
+    const parent = el.parentNode;
+    if (parent && parent.lastChild !== el) {
+      parent.appendChild(el);
+    }
+  },
+  toBack(el) {
+    const parent = el.parentNode;
+    if (parent && parent.firstChild !== el) {
+      parent.insertBefore(el, parent.firstChild);
+    }
+  },
+  getClass(el) {
+    if (el.correspondingElement) {
+      el = el.correspondingElement;
+    }
+    return el.className.baseVal === void 0 ? el.className : el.className.baseVal;
+  },
+  hasClass(el, name) {
+    if (el.classList !== void 0) {
+      return el.classList.contains(name);
+    }
+    const className = this.getClass(el);
+    return className.length > 0 && new RegExp("(^|\\s)" + name + "(\\s|$)").test(className);
+  },
+  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);
+    }
+  },
+  removeClass(el, name) {
+    if (el.classList !== void 0) {
+      const classes = splitWords(name);
+      classes.forEach((name2) => el.classList.remove(name2));
+    } else {
+      this.setClass(el, trim((" " + this.getClass(el) + " ").replace(" " + name + " ", " ")));
+    }
+  },
+  setClass(el, name) {
+    if (el.className.baseVal === void 0) {
+      el.className = name;
+    } else {
+      el.className.baseVal = name;
+    }
+  },
+  parseFromString(str) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(str, "text/xml");
+    return doc.children[0];
+  }
+};
+var MathUtils = {
+  DEG2RAD: Math.PI / 180,
+  RAD2DEG: 180 / Math.PI,
+  randInt(low, high) {
+    return low + Math.floor(Math.random() * (high - low + 1));
+  },
+  randFloat(low, high) {
+    return low + Math.random() * (high - low);
+  },
+  degreesToRadians(degrees) {
+    return degrees * this.DEG2RAD;
+  },
+  toRadians(degrees) {
+    return degrees * this.DEG2RAD;
+  },
+  radiansToDegrees(radians) {
+    return radians * this.RAD2DEG;
+  },
+  toDegrees(radians) {
+    return radians * this.RAD2DEG;
+  },
+  formatFloat(value, n = 2) {
+    return Math.round(value * Math.pow(10, n)) / Math.pow(10, n);
+  }
+};
+var GeoUtils = {
+  toRadian: Math.PI / 180,
+  R: 6371393,
+  isLnglat(lng, lat) {
+    return lng && lat && !!(+lat > -90 && +lat < 90 && +lng > -180 && +lng < 180);
+  },
+  formatLnglat(lng, lat) {
+    let res = "";
+    function format(value) {
+      const a = parseFloat(value);
+      const degree = parseInt(a);
+      let min = parseInt((a - degree) * 60);
+      let sec = (a - degree) * 3600 - min * 60;
+      return degree + "\xB0" + min + "\u2032" + sec.toFixed(2) + "\u2033";
+    }
+    if (lng && lat) {
+      res = format(lng) + "," + format(lat);
+    }
+    return res;
+  },
+  transformLnglat(lng, lat) {
+    function dms2deg(s) {
+      var sw = /[sw]/i.test(s);
+      var f = sw ? -1 : 1;
+      var bits = s.match(/[\d.]+/g);
+      var result = 0;
+      for (var i = 0, iLen = bits.length; i < iLen; i++) {
+        result += bits[i] / f;
+        f *= 60;
+      }
+      return result;
+    }
+    if (lng && lat) {
+      return {
+        lng: dms2deg(lng),
+        lat: dms2deg(lat)
+      };
+    }
+  },
+  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 flag ? "in" : "out";
+  },
+  wgs84PointsDistance(fromPoint, toPoint) {
+    var PI = Math.PI;
+    function getRad(d) {
+      return d * PI / 180;
+    }
+    if (arguments.length != 2) {
+      return 0;
+    }
+    lon1 = fromPoint.x;
+    lat1 = fromPoint.y;
+    lon2 = toPoint.x;
+    lat2 = toPoint.y;
+    var a = 6378137, b = 63567523142e-4, f = 1 / 298.257223563;
+    var L = getRad(lon2 - lon1);
+    var U1 = Math.atan((1 - f) * Math.tan(getRad(lat1)));
+    var U2 = Math.atan((1 - f) * Math.tan(getRad(lat2)));
+    var sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
+    var sinU2 = Math.sin(U2), cosU2 = Math.cos(U2);
+    var lambda = L, lambdaP, iterLimit = 100;
+    do {
+      var sinLambda = Math.sin(lambda), cosLambda = Math.cos(lambda);
+      var sinSigma = Math.sqrt(
+        cosU2 * sinLambda * (cosU2 * sinLambda) + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) * (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)
+      );
+      if (sinSigma == 0)
+        return 0;
+      var cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
+      var sigma = Math.atan2(sinSigma, cosSigma);
+      var sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
+      var cosSqAlpha = 1 - sinAlpha * sinAlpha;
+      var cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cosSqAlpha;
+      if (isNaN(cos2SigmaM))
+        cos2SigmaM = 0;
+      var C = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha));
+      lambdaP = lambda;
+      lambda = L + (1 - C) * f * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
+    } while (Math.abs(lambda - lambdaP) > 1e-12 && --iterLimit > 0);
+    if (iterLimit == 0) {
+      return NaN;
+    }
+    var uSq = cosSqAlpha * (a * a - b * b) / (b * b);
+    var A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+    var B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+    var deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+    var s = b * A * (sigma - deltaSigma);
+    return s;
+  },
+  rotatePoint(p1, p2, \u03B8) {
+    const x = (p1.x - p2.x) * Math.cos(Math.PI / 180 * -\u03B8) - (p1.y - p2.y) * Math.sin(Math.PI / 180 * -\u03B8) + p2.x;
+    const y = (p1.x - p2.x) * Math.sin(Math.PI / 180 * -\u03B8) + (p1.y - p2.y) * Math.cos(Math.PI / 180 * -\u03B8) + p2.y;
+    return { x, y };
+  },
+  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 };
+  },
+  calcBearAndDisByPoints(latlng1, latlng2) {
+    var f1 = parseFloat(latlng1.lat), l1 = parseFloat(latlng1.lng), f2 = parseFloat(latlng2.lat), l2 = parseFloat(latlng2.lng);
+    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
+    };
+  },
+  calcPointByBearAndDis(latlng, angle, distance) {
+    const sLat = MathUtils.toRadians(parseFloat(latlng.lat));
+    const sLng = MathUtils.toRadians(parseFloat(latlng.lng));
+    angle = parseFloat(angle);
+    distance = parseFloat(distance);
+    const d = distance / this.R;
+    angle = MathUtils.toRadians(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.toDegrees(lat),
+      lng: MathUtils.toDegrees(lon)
+    };
+  },
+  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 };
+  },
+  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 };
+  }
+};
+var FileUtils = {
+  convertBase64ToBlob(data) {
+    var mimeString = data.split(",")[0].split(":")[1].split(";")[0];
+    var byteString = window.atob(data.split(",")[1]);
+    var ab = new ArrayBuffer(byteString.length);
+    var ia = new Uint8Array(ab);
+    for (var i = 0; i < byteString.length; i++) {
+      ia[i] = byteString.charCodeAt(i);
+    }
+    var bb = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder;
+    if (bb) {
+      bb = new (window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder)();
+      bb.append(ab);
+      return bb.getBlob(mimeString);
+    } else {
+      bb = new Blob([ab], {
+        type: mimeString
+      });
+      return bb;
+    }
+  },
+  convertUrlToBase64(url, width, height) {
+    return new Promise(function(resolve, reject) {
+      var img = new Image();
+      img.crossOrigin = "Anonymous";
+      img.src = url;
+      img.onload = function() {
+        var canvas = document.createElement("canvas");
+        canvas.width = width || img.width;
+        canvas.height = height || img.height;
+        var ctx = canvas.getContext("2d");
+        ctx.drawImage(img, 0, 0, img.width, img.height);
+        var ext = img.src.substring(img.src.lastIndexOf(".") + 1).toLowerCase();
+        var dataURL = canvas.toDataURL("image/" + ext);
+        var base64 = {
+          dataURL,
+          type: "image/" + ext,
+          ext
+        };
+        resolve(base64);
+      };
+    });
+  },
+  convertBase64ToFile(dataurl, filename) {
+    var arr = dataurl.split(","), mime = arr[0].match(/:(.*?);/)[1], bstr = atob(arr[1]), n = bstr.length, u8arr = new Uint8Array(n);
+    while (n--) {
+      u8arr[n] = bstr.charCodeAt(n);
+    }
+    let file = new File([u8arr], filename, { type: mime });
+    return file;
+  },
+  downloadFromFile(data, saveName) {
+    if (typeof data == "object") {
+      if (data instanceof Blob) {
+        data = URL.createObjectURL(data);
+      } else {
+        const str = JSON.stringify(data);
+        const blob = new Blob([str], { type: "text/json" });
+        data = window.URL.createObjectURL(blob);
+      }
+    } else if (typeof data == "string" && data.indexOf("http") === -1) {
+      const blob = new Blob([data], { type: "text/json" });
+      data = window.URL.createObjectURL(blob);
+    }
+    var link = document.createElement("a");
+    link.href = data;
+    link.download = saveName || "";
+    link.click();
+    window.URL.revokeObjectURL(link.href);
+  }
+};
+var OptimizeUtils = {
+  debounce(func, wait, immediate = true) {
+    let timeout, args, context, timestamp, result;
+    const later = function() {
+      const last = +new Date() - timestamp;
+      if (last < wait && last > 0) {
+        timeout = setTimeout(later, wait - last);
+      } else {
+        timeout = null;
+        if (!immediate) {
+          result = func.apply(context, args);
+          if (!timeout)
+            context = args = null;
+        }
+      }
+    };
+    return function(...args2) {
+      context = this;
+      timestamp = +new Date();
+      const callNow = immediate && !timeout;
+      if (!timeout)
+        timeout = setTimeout(later, wait);
+      if (callNow) {
+        result = func.apply(context, args2);
+        context = args2 = null;
+      }
+      return result;
+    };
+  },
+  throttle(func, wait, type) {
+    if (type === 1) {
+      var previous = 0;
+    } else if (type === 2) {
+      var timeout;
+    }
+    return function() {
+      let context = this;
+      let args = arguments;
+      if (type === 1) {
+        let now = Date.now();
+        if (now - previous > wait) {
+          func.apply(context, args);
+          previous = now;
+        }
+      } else if (type === 2) {
+        if (!timeout) {
+          timeout = setTimeout(() => {
+            timeout = null;
+            func.apply(context, args);
+          }, wait);
+        }
+      }
+    };
+  },
+  recurve(fun, frequency = 500, duration = 5e3) {
+    let timer = 0;
+    setTimeout(function fn() {
+      timer++;
+      if (timer < Math.floor(duration / frequency)) {
+        fun.call(this);
+        setTimeout(fn, frequency);
+      }
+    });
+  }
+};
+var StringUtils = {
+  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;
+    }
+  },
+  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;
+    }
+  },
+  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}`);
+  },
+  getByteLength(str) {
+    return str.replace(/[\u0391-\uFFE5]/g, "aa").length;
+  },
+  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;
+  },
+  asString(value) {
+    if (CommUtils.isEmpty(value)) {
+      return "";
+    } else {
+      switch (CommUtils.getDataType()) {
+        case "Object":
+        case "Array":
+          return JSON.stringify(value);
+        default:
+          return value;
+      }
+    }
+  }
+};
+var AssertUtils = {
+  notNull(data) {
+    if (CommUtils.isEmpty(data)) {
+      throw Error("\u4E0D\u80FD\u4E3A\u7A7A:>>>" + data);
+    }
+  },
+  legalLnglat(lng, lat) {
+    if (!GeoUtils.isLnglat(lng, lat)) {
+      throw Error(ErrorType.COORDINATE_ERROR);
+    }
+  },
+  contain(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);
+    }
+  },
+  verify: {
+    array(data) {
+      if (CommUtils.getDataType(data) !== "Array") {
+        throw Error(ErrorType.PARAMETER_ERROR_ARRAY + ":>>>" + data);
+      }
+    },
+    function(data) {
+      if (CommUtils.getDataType(data) !== "Function") {
+        throw Error(ErrorType.PARAMETER_ERROR_FUNCTION + ":>>>" + data);
+      }
+    },
+    object(data) {
+      if (CommUtils.getDataType(data) !== "Object") {
+        throw Error(ErrorType.PARAMETER_ERROR_OBJECT + ":>>>" + data);
+      }
+    }
+  },
+  legalJSON(data) {
+    try {
+      JSON.parse(data);
+    } catch (err) {
+      throw Error(ErrorType.JSON_PARSE_ERROR + ":>>>" + data);
+    }
+  },
+  legalData(data, type) {
+    const bool = StringUtils.checkStr(data, type);
+    let typename = "";
+    switch (type) {
+      case "phone":
+        typename = "\u7535\u8BDD";
+        break;
+      case "tel":
+        typename = "\u5EA7\u673A";
+        break;
+      case "card":
+        typename = "\u8EAB\u4EFD\u8BC1";
+        break;
+      case "pwd":
+        typename = "\u5BC6\u7801";
+        break;
+      case "postal":
+        typename = "\u90AE\u653F\u7F16\u7801";
+        break;
+      case "QQ":
+        typename = "QQ";
+        break;
+      case "email":
+        typename = "\u90AE\u7BB1";
+        break;
+      case "money":
+        typename = "\u91D1\u989D";
+        break;
+      case "URL":
+        typename = "\u7F51\u5740";
+        break;
+      case "IP":
+        typename = "IP";
+        break;
+      case "date":
+        typename = "\u65E5\u671F\u65F6\u95F4";
+        break;
+      case "number":
+        typename = "\u6570\u5B57";
+        break;
+      case "english":
+        typename = "\u82F1\u6587";
+        break;
+      case "chinese":
+        typename = "\u4E2D\u6587";
+        break;
+      case "lower":
+        typename = "\u5C0F\u5199";
+        break;
+      case "upper":
+        typename = "\u5927\u5199";
+        break;
+      case "HTML":
+        typename = "HTML\u6807\u8BB0";
+        break;
+    }
+    if (!bool) {
+      throw Error(ErrorType.PARAMETER_ERROR + ":>>>\u4E0D\u662F" + typename);
+    }
+  }
+};
+class AudioPlayer {
+  constructor(url) {
+    this.audio = new Audio();
+    this.audio.src = url;
+  }
+  play() {
+    !this.muted && this.audio.play();
+  }
+  pause() {
+    this.audio.pause();
+  }
+  get muted() {
+    return this.audio.muted;
+  }
+  set muted(val) {
+    this.audio.muted = val;
+  }
+}
+class CanvasDrawer {
+  constructor(el) {
+    if (CommUtils.getDataType(el) === "String") {
+      el = document.querySelector("#" + el);
+    }
+    this.ctx = el.getContext("2d");
+  }
+  drawLine(startX, startY, endX, endY, options = {}) {
+    this.cxt.beginPath();
+    const width = options.width || 1;
+    const color = options.color || "#000";
+    this.cxt.lineWidth = width;
+    this.cxt.fillStyle = color;
+    this.cxt.moveTo(startX, startY);
+    this.cxt.lineTo(endX, endY);
+    this.cxt.closePath();
+    this.cxt.fill();
+  }
+  drawArc(x, y, radius, startAngle, endAngle, anticlockwise, isFill, bgColor) {
+    if (isFill) {
+      this.cxt.fillStyle = bgColor;
+      this.cxt.beginPath();
+      this.cxt.arc(x, y, radius, MathUtils.degreesToRadians(startAngle), MathUtils.degreesToRadians(endAngle), anticlockwise);
+      this.cxt.closePath();
+      this.cxt.fill();
+    } else {
+      this.cxt.strokeStyle = bgColor;
+      this.cxt.beginPath();
+      this.cxt.arc(x, y, radius, MathUtils.degreesToRadians(startAngle), MathUtils.degreesToRadians(endAngle), anticlockwise);
+      this.cxt.stroke();
+    }
+  }
+}
+function EventDispatcher() {
+}
+Object.assign(EventDispatcher.prototype, {
+  addEventListener(type, listener, context, mutexStatus = false) {
+    if (this._listeners === void 0)
+      this._listeners = {};
+    this._mutex = this._mutex || {};
+    this._context = context;
+    const mutex = this._mutex;
+    const listeners = this._listeners;
+    if (listeners[type] === void 0) {
+      listeners[type] = [];
+    }
+    if (listeners[type].indexOf(listener) === -1) {
+      if (mutexStatus) {
+        mutex[type] = listener;
+      }
+      listeners[type].push(listener);
+    }
+    return this;
+  },
+  hasEventListener(type, listener) {
+    if (this._listeners === void 0)
+      return false;
+    const listeners = this._listeners;
+    return listeners[type] !== void 0 && listeners[type].indexOf(listener) !== -1;
+  },
+  removeEventListener(type, listener) {
+    if (this._listeners === void 0)
+      return;
+    const listeners = this._listeners;
+    const listenerArray = listeners[type];
+    if (this._mutex[type] === listener) {
+      this._mutex[type] = null;
+    }
+    if (listenerArray !== void 0) {
+      const index = listenerArray.map((d) => d.toString()).indexOf(listener.toString());
+      if (index !== -1) {
+        listenerArray.splice(index, 1);
+      }
+    }
+  },
+  dispatchEvent(event) {
+    if (this._listeners === void 0)
+      return;
+    const listeners = this._listeners;
+    const listenerArray = listeners[event.type];
+    if (listenerArray !== void 0) {
+      event.target = this;
+      const array = listenerArray.slice(0);
+      if (this._mutex[event.type]) {
+        const find = array.find((item) => item === this._mutex[event.type]);
+        find.call(this._context || this, event);
+        return;
+      }
+      for (let i = 0, l = array.length; i < l; i++) {
+        array[i].call(this._context || this, event);
+      }
+    }
+  },
+  removeAllListener() {
+    this._mutex = {};
+    for (const key in this._listeners) {
+      this._listeners[key] = [];
+    }
+  }
+});
+Object.assign(Map.prototype, {
+  isEmpty() {
+    return this.size === 0;
+  },
+  _values() {
+    return Array.from(Map.prototype.values.call(this));
+  },
+  _keys() {
+    return Array.from(Map.prototype.keys.call(this));
+  },
+  _entries() {
+    return Array.from(Map.prototype.entries.call(this));
+  }
+});
+function HashMap() {
+  return /* @__PURE__ */ new Map();
+}
+HashMap.fromEntries = function(array = []) {
+  const hashMap = new HashMap();
+  array.forEach((element) => {
+    if (Array.isArray(element) && element.length === 2) {
+      hashMap.set(element[0], element[1]);
+    }
+  });
+  return hashMap;
+};
+class WebSocketClient extends EventDispatcher {
+  constructor(url = "ws://127.0.0.1:10088") {
+    super();
+    this.maxCheckTimes = 10;
+    this.url = url;
+    this.checkTimes = 0;
+    this.connectStatus = false;
+    this.connect();
+    this.connCheckStatus(this.maxCheckTimes);
+    WebSocketClient.instance = this;
+  }
+  connect() {
+    this.disconnect();
+    if (this.url) {
+      try {
+        console.info("\u521B\u5EFAws\u8FDE\u63A5>>>" + this.url);
+        this.client = new WebSocket(this.url);
+        if (this.client) {
+          const self = this;
+          this.client.onopen = function(message) {
+            self.dispatchEvent({
+              type: EventType.WEB_SOCKET_CONNECT,
+              message
+            });
+          };
+          this.client.onmessage = function(message) {
+            self.connectStatus = true;
+            self.dispatchEvent({
+              type: EventType.WEB_SOCKET_MESSAGE,
+              message
+            });
+          };
+          this.client.onclose = function(message) {
+            self.dispatchEvent({
+              type: EventType.WEB_SOCKET_CLOSE,
+              message
+            });
+          };
+          if (this.checkTimes === this.maxCheckTimes) {
+            this.client.onerror = function(message) {
+              self.dispatchEvent({
+                type: EventType.WEB_SOCKET_ERROR,
+                message
+              });
+            };
+          }
+        }
+      } catch (ex) {
+        console.error("\u521B\u5EFAws\u8FDE\u63A5\u5931\u8D25" + this.url + ":" + ex);
+      }
+    }
+  }
+  disconnect() {
+    if (this.client) {
+      try {
+        console.log("ws\u65AD\u5F00\u8FDE\u63A5" + this.url);
+        this.client.close();
+        this.client = null;
+      } catch (ex) {
+        this.client = null;
+      }
+    }
+  }
+  connCheckStatus(times) {
+    if (this.checkTimes > times)
+      return;
+    setTimeout(() => {
+      this.checkTimes++;
+      if (this.client && this.client.readyState !== 0 && this.client.readyState !== 1) {
+        this.connect();
+      }
+      this.connCheckStatus(times);
+    }, 2e3);
+  }
+  send(message) {
+    if (this.client && this.client.readyState === 1) {
+      this.client.send(message);
+      return true;
+    }
+    console.error(this.url + "\u6D88\u606F\u53D1\u9001\u5931\u8D25\uFF1A" + message);
+    return false;
+  }
+  heartbeat() {
+    setTimeout(() => {
+      if (this.client && this.client.readyState === 1) {
+        this.send("HeartBeat");
+      }
+      console.log("HeartBeat," + this.url);
+      setTimeout(this.heartbeat, 3e4);
+    }, 1e3);
+  }
+  static getInstance() {
+    if (WebSocketClient.instance) {
+      return WebSocketClient.instance;
+    } else {
+      return Object.freeze(new WebSocketClient());
+    }
+  }
+  static get _instance() {
+    return this.getInstance();
+  }
+}
+class WebStorage {
+  constructor(type = 1) {
+    this.cacheType = type;
+    if (type === 1) {
+      this.storage = window.localStorage;
+    } else if (type === 2) {
+      this.storage = window.sessionStorage;
+    } else {
+      throw new Error(ErrorType.PARAMETER_ERROR);
+    }
+  }
+  setItem(key, value, expired) {
+    const tempObj = { key, value };
+    if (this.cacheType === 1) {
+      const currTime = Date.now();
+      if (expired) {
+        tempObj.expired = currTime + expired * 1e3;
+      }
+    }
+    this.storage[key] = JSON.stringify(tempObj);
+    return tempObj;
+  }
+  getItem(key) {
+    const storageData = this.storage.getItem(key) || null;
+    const tempObj = JSON.parse(storageData) || {};
+    if (this.cacheType === 1) {
+      const expired = tempObj.expired || Date.now();
+      if (Date.now() > expired) {
+        this.remove(key);
+        return null;
+      }
+    }
+    return tempObj.value;
+  }
+  remove(keys) {
+    if (keys) {
+      if (keys.indexOf(",") > -1) {
+        keys.split(",").forEach((key) => {
+          this.storage.removeItem(key);
+        });
+      } else {
+        this.storage.removeItem(keys);
+      }
+    }
+  }
+  clear() {
+    this.storage.clear();
+  }
+}
+class DevicePixelRatio {
+  constructor(magnification = 1) {
+    this.magnification = magnification;
+  }
+  _getSystem() {
+    var agent = navigator.userAgent.toLowerCase();
+    if (agent.indexOf("windows") >= 0) {
+      return true;
+    }
+  }
+  _addHandler(element, type, handler) {
+    if (element.addEventListener) {
+      element.addEventListener(type, handler, false);
+    } else if (element.attachEvent) {
+      element.attachEvent("on" + type, handler);
+    } else {
+      element["on" + type] = handler;
+    }
+  }
+  _correct() {
+    let pageWidth = window.innerWidth;
+    if (typeof pageWidth != "number") {
+      if (document.compatMode == "CSS1Compat") {
+        pageWidth = document.documentElement.clientWidth;
+      } else {
+        pageWidth = document.body.clientWidth;
+      }
+    }
+    if (pageWidth <= 750) {
+      const baseSize = 75;
+      const scale = document.documentElement.clientWidth / pageWidth;
+      document.documentElement.style.fontSize = this.magnification * baseSize * Math.min(scale, 2) + "px";
+    } else if (pageWidth > 750 && pageWidth <= 1200) {
+      const baseSize = 85;
+      const scale = document.documentElement.clientWidth / pageWidth;
+      document.documentElement.style.fontSize = this.magnification * baseSize * Math.min(scale, 2) + "px";
+    } else {
+      const baseSize = 100;
+      const scale = document.documentElement.clientWidth / 1920;
+      document.documentElement.style.fontSize = this.magnification * baseSize * Math.min(scale, 2) + "px";
+    }
+  }
+  _watch() {
+    let t = this;
+    t._addHandler(window, "resize", function() {
+      t._correct();
+    });
+  }
+  init() {
+    let t = this;
+    if (t._getSystem()) {
+      t._correct();
+      t._watch();
+    }
+  }
+}
+export { AnimateUtils, ArrayUtils, AssertUtils, AudioPlayer, BrowserUtils, CanvasDrawer, Cookie, CoordsUtils, DateUtils, DevicePixelRatio, DomUtils, ErrorType, EventDispatcher, EventType, FileUtils, GeoUtils, GraphicType, HashMap, LayerType, MathUtils, MeasureMode, OptimizeUtils, StringUtils, CommUtils as Utils, WebSocketClient, WebStorage };