gis-common 4.2.18 → 4.2.20

package/dist/gis-common.es.js

@@ -150,141 +150,528 @@ class Cookie {
     }
   }
 }
-const CommUtils = {
+const MathUtil = {
+  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);
+  },
   /**
-   * 获取数据类型
+   * 角度转弧度
    *
-   * @param data 待判断的数据
-   * @returns 返回数据类型字符串
+   * @param {*} degrees
+   * @returns {*}
    */
-  getDataType(data) {
-    return Object.prototype.toString.call(data).slice(8, -1);
-  },
-  asArray(obj) {
-    return this.isEmpty(obj) ? [] : Array.isArray(obj) ? obj : [obj];
-  },
-  asNumber(a) {
-    return Number.isNaN(Number(a)) ? 0 : Number(a);
+  deg2Rad(degrees) {
+    return degrees * this.DEG2RAD;
   },
   /**
-   * 将值转换为字符串
+   * 弧度转角度
    *
-   * @param value 要转换的值
-   * @returns 转换后的字符串，如果值为空，则返回空字符串
+   * @param {*} radians
+   * @returns {*}
    */
-  asString(value) {
-    if (this.isEmpty(value)) {
-      return "";
-    } else {
-      switch (this.getDataType(value)) {
-        case "Object":
-        case "Array":
-          return JSON.stringify(value);
-        default:
-          return value;
-      }
-    }
+  rad2Deg(radians) {
+    return radians * this.RAD2DEG;
+  },
+  round(value, n = 2) {
+    return Math.round(value * Math.pow(10, n)) / Math.pow(10, n);
   },
   /**
-   * 判断传入的值是否为空
+   * 将数值限制在指定范围内
    *
-   * @param value 待判断的值
-   * @returns 返回布尔值，表示是否为空
+   * @param val 需要限制的数值
+   * @param min 最小值
+   * @param max 最大值
+   * @returns 返回限制后的数值
    */
-  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;
+  clamp(val, min, max) {
+    return Math.max(min, Math.min(max, val));
+  }
+};
+var ColorName = /* @__PURE__ */ ((ColorName2) => {
+  ColorName2["white"] = "rgba(255, 255, 255, 1)";
+  ColorName2["black"] = "rgba(0, 0, 0, 1)";
+  ColorName2["red"] = "rgba(255, 0, 0, 1)";
+  ColorName2["green"] = "rgba(0, 255, 0, 1)";
+  ColorName2["blue"] = "rgba(0, 0, 255, 1)";
+  ColorName2["yellow"] = "rgba(255, 255, 0, 1)";
+  ColorName2["cyan"] = "rgba(0, 255, 255, 1)";
+  ColorName2["magenta"] = "rgba(255, 0, 255, 1)";
+  ColorName2["purple"] = "rgba(128, 0, 128, 1)";
+  ColorName2["brown"] = "rgba(165, 42, 42, 1)";
+  ColorName2["gray"] = "rgba(128, 128, 128, 1)";
+  ColorName2["orange"] = "rgba(255, 165, 0, 1)";
+  ColorName2["golden"] = "rgba(255, 215, 0, 1)";
+  ColorName2["silvery"] = "rgba(192, 192, 192, 1)";
+  ColorName2["transparent"] = "rgba(0, 0, 0, 0)";
+  return ColorName2;
+})(ColorName || {});
+class Color {
+  constructor(r, g, b, a) {
+    __publicField(this, "_r");
+    __publicField(this, "_g");
+    __publicField(this, "_b");
+    __publicField(this, "_alpha");
+    this._validateColorChannel(r);
+    this._validateColorChannel(g);
+    this._validateColorChannel(b);
+    this._r = r;
+    this._g = g;
+    this._b = b;
+    this._alpha = MathUtil.clamp(a || 1, 0, 1);
+  }
+  _validateColorChannel(channel) {
+    if (channel < 0 || channel > 255) {
+      throw new Error("Color channel must be between 0 and 255.");
     }
-  },
+  }
+  toString() {
+    return `rgba(${this._r}, ${this._g}, ${this._b}, ${this._alpha})`;
+  }
+  toJson() {
+    return { r: this._r, g: this._g, b: this._b, a: this._alpha };
+  }
+  get rgba() {
+    return `rgba(${this._r}, ${this._g}, ${this._b}, ${this._alpha})`;
+  }
+  get hex() {
+    return Color.rgb2hex(this._r, this._g, this._b, this._alpha);
+  }
+  setAlpha(a) {
+    this._alpha = MathUtil.clamp(a, 0, 1);
+    return this;
+  }
+  // 设置颜色的RGB值
+  setRgb(r, g, b) {
+    this._validateColorChannel(r);
+    this._validateColorChannel(g);
+    this._validateColorChannel(b);
+    this._r = r;
+    this._g = g;
+    this._b = b;
+    return this;
+  }
   /**
-   * 将JSON对象转换为FormData对象
+   * 从RGBA字符串创建Color对象
    *
-   * @param json 待转换的JSON对象，其属性值为字符串或Blob类型
-   * @returns 转换后的FormData对象
+   * @param rgbaValue RGBA颜色值字符串，格式为"rgba(r,g,b,a)"或"rgb(r,g,b)"
+   * @returns 返回Color对象
+   * @throws 如果rgbaValue不是有效的RGBA颜色值，则抛出错误
    */
-  json2form(json) {
-    const formData = new FormData();
-    if (this.isEmpty(json)) return formData;
-    Object.keys(json).forEach((key) => {
-      formData.append(key, json[key] instanceof Object ? JSON.stringify(json[key]) : json[key]);
-    });
-    return formData;
-  },
+  static fromRgba(rgbaValue) {
+    const rgbaMatch = rgbaValue.match(/^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([\d.]+))?\s*\)$/);
+    if (!rgbaMatch) throw new Error("Invalid RGBA color value");
+    const r = parseInt(rgbaMatch[1], 10);
+    const g = parseInt(rgbaMatch[2], 10);
+    const b = parseInt(rgbaMatch[3], 10);
+    const a = rgbaMatch[5] ? parseFloat(rgbaMatch[5]) : 1;
+    return new Color(r, g, b, a);
+  }
   /**
-   * 生成GUID
+   * 将十六进制颜色值转换为颜色对象
    *
-   * @returns 返回一个由8个16进制数组成的GUID字符串
+   * @param hexValue 十六进制颜色值，可带或不带#前缀，支持3位和6位表示
+   * @returns 返回颜色对象
    */
-  guid() {
-    const S4 = function() {
-      return ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
-    };
-    return S4() + S4() + S4() + S4() + S4() + S4() + S4() + S4();
-  },
+  static fromHex(hexValue, a = 1) {
+    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) {
+      throw new Error("Invalid HEX color value");
+    }
+    const r = parseInt(rgb[1], 16);
+    const g = parseInt(rgb[2], 16);
+    const b = parseInt(rgb[3], 16);
+    return new Color(r, g, b, a);
+  }
   /**
-   * 将参数进行解码并返回解码后的字符串
+   * 从 HSL 字符串创建颜色对象
    *
-   * @param args 参数
-   * @returns 解码后的字符串
+   * @param hsl HSL 字符串，格式为 hsl(h, s%, l%) 或 hsla(h, s%, l%, a)
+   * @returns 返回颜色对象，如果 hsl 字符串无效则返回 null
    */
-  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];
-      }
+  static fromHsl(hslValue) {
+    const hsl = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(hslValue) || /hsla\((\d+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)/g.exec(hslValue);
+    if (!hsl) {
+      throw new Error("Invalid HSL color value");
+    }
+    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 {
-      res = args[0];
+      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 res;
-  },
+    return new Color(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);
+  }
+  static fromName(str) {
+    const rgba = ColorName[str];
+    return this.fromRgba(rgba);
+  }
   /**
-   * 将一个或多个对象的所有可枚举属性复制到目标对象。
+   * 从字符串中创建颜色对象
    *
-   * @param dest 目标对象，用于接收复制的属性。
-   * @param args 一个或多个源对象，用于提供要复制的属性。
-   * @returns 返回目标对象，包含所有复制的属性。
+   * @param str 字符串类型的颜色值，支持rgba、hex、hsl格式
+   * @returns 返回创建的颜色对象
+   * @throws 当颜色值无效时，抛出错误
    */
-  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];
-      }
+  static from(str) {
+    if (this.isRgb(str)) {
+      return this.fromRgba(str);
+    } else if (this.isHex(str)) {
+      return this.fromHex(str);
+    } else if (this.isHsl(str)) {
+      return this.fromHsl(str);
+    } else if (Object.values(ColorName).map((value) => value.toString()).includes(str)) {
+      return this.fromName(str);
+    } else {
+      throw new Error("Invalid color value");
     }
-    return dest;
-  },
+  }
   /**
-   * 将扁平化数组转换为树形结构数组
+   * 将RGB颜色值转换为十六进制颜色值
    *
-   * @param data 扁平化数组
-   * @param idPropertyName 数据中标识id的字段名，默认为'id'
-   * @param parentIdPropertyName 数据中标识父节点id的字段名，默认为'parentId'
-   * @param childrenPropertyName 树形结构中标识子节点的字段名，默认为'children'
-   * @returns 转换后的树形结构数组
+   * @param r 红色分量值，取值范围0-255
+   * @param g 绿色分量值，取值范围0-255
+   * @param b 蓝色分量值，取值范围0-255
+   * @param a 可选参数，透明度分量值，取值范围0-1
+   * @returns 十六进制颜色值，格式为#RRGGBB或#RRGGBBAA
    */
-  convertToTree2(data, idPropertyName = "id", parentIdPropertyName = "parentId", childrenPropertyName = "children") {
+  static rgb2hex(r, g, b, a) {
+    var hex = "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
+    if (a !== void 0) {
+      const alpha = Math.round(a * 255).toString(16).padStart(2, "0");
+      return hex + alpha;
+    }
+    return hex;
+  }
+  static isHex(a) {
+    return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a);
+  }
+  static isRgb(a) {
+    return /^rgba?\s*\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(,\s*[\d.]+)?\s*\)$/.test(a);
+  }
+  static isHsl(a) {
+    return /^(hsl|hsla)\(\d+,\s*[\d.]+%,\s*[\d.]+%(,\s*[\d.]+)?\)$/.test(a);
+  }
+  static isColor(a) {
+    return this.isHex(a) || this.isRgb(a) || this.isHsl(a);
+  }
+  static random() {
+    let r = Math.floor(Math.random() * 256);
+    let g = Math.floor(Math.random() * 256);
+    let b = Math.floor(Math.random() * 256);
+    let a = Math.random();
+    return new Color(r, g, b, a);
+  }
+}
+class CanvasDrawer {
+  constructor(el) {
+    __publicField(this, "context", null);
+    if (typeof el === "string") {
+      el = document.querySelector("#" + el);
+      if (!el) {
+        throw new Error("Element not found");
+      }
+    }
+    if (el instanceof HTMLElement) {
+      const canvas = el;
+      if (canvas.getContext) {
+        this.context = canvas.getContext("2d");
+      } else {
+        throw new Error("getContext is not available on this element");
+      }
+    } else {
+      throw new Error("Element is not an HTMLElement");
+    }
+  }
+  /**
+   * 绘制线条
+   *
+   * @param start 起始坐标点
+   * @param end 终止坐标点
+   * @param options 绘制选项，包括线条宽度和颜色
+   * @throws 当画布上下文不存在时抛出错误
+   */
+  drawLine({ x: startX, y: startY }, { x: endX, y: endY }, options = {}) {
+    if (!this.context) {
+      throw new Error("Canvas context is null or undefined");
+    }
+    this.context.beginPath();
+    const width = options.width || 1;
+    const color = options.color || "#000";
+    this.context.lineWidth = width;
+    this.context.strokeStyle = color;
+    this.context.moveTo(startX, startY);
+    this.context.lineTo(endX, endY);
+    this.context.stroke();
+  }
+  /**
+   * 绘制圆弧
+   *
+   * @param x 圆心x坐标
+   * @param y 圆心y坐标
+   * @param radius 半径
+   * @param startAngle 起始角度（度）
+   * @param endAngle 结束角度（度）
+   * @param anticlockwise 是否逆时针绘制
+   * @param isFill 是否填充
+   * @param bgColor 背景颜色
+   * @throws 当Canvas context为null或undefined时抛出错误
+   */
+  drawArc({ x, y }, radius, startAngle, endAngle, anticlockwise, isFill, bgColor) {
+    if (!this.context) {
+      throw new Error("Canvas context is null or undefined");
+    }
+    if (isFill) {
+      this.context.fillStyle = bgColor;
+      this.context.beginPath();
+      this.context.arc(x, y, radius, MathUtil.deg2Rad(startAngle), MathUtil.deg2Rad(endAngle), anticlockwise);
+      this.context.fill();
+    } else {
+      this.context.strokeStyle = bgColor;
+      this.context.beginPath();
+      this.context.arc(x, y, radius, MathUtil.deg2Rad(startAngle), MathUtil.deg2Rad(endAngle), anticlockwise);
+      this.context.stroke();
+    }
+  }
+  static createCanvas(width = 1, height = 1) {
+    const canvas = document.createElement("canvas");
+    if (width) {
+      canvas.width = width;
+    }
+    if (height) {
+      canvas.height = height;
+    }
+    return canvas;
+  }
+}
+class EventDispatcher {
+  constructor() {
+    __publicField(this, "_listeners");
+    __publicField(this, "_mutex", {});
+    __publicField(this, "_context");
+  }
+  addEventListener(type, listener, context, mutexStatus) {
+    if (this._listeners === void 0) this._listeners = {};
+    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 === null || 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] !== void 0) {
+        const find = array.find((item) => item === this._mutex[event.type]);
+        if (find) {
+          find.call(this._context || this, event);
+          return;
+        }
+      }
+      for (let i = 0, l = array.length; i < l; i++) {
+        const item = array[i];
+        if (typeof item === "function") {
+          item.call(this._context || this, event);
+        }
+      }
+    }
+  }
+  removeAllListener() {
+    this._mutex = {};
+    for (const key in this._listeners) {
+      this._listeners[key] = [];
+    }
+  }
+}
+const Util = {
+  /**
+   * 获取数据类型
+   *
+   * @param data 待判断的数据
+   * @returns 返回数据类型字符串
+   */
+  getDataType(data) {
+    return Object.prototype.toString.call(data).slice(8, -1);
+  },
+  asArray(obj) {
+    return this.isEmpty(obj) ? [] : Array.isArray(obj) ? obj : [obj];
+  },
+  asNumber(a) {
+    return Number.isNaN(Number(a)) ? 0 : Number(a);
+  },
+  /**
+   * 将值转换为字符串
+   *
+   * @param value 要转换的值
+   * @returns 转换后的字符串，如果值为空，则返回空字符串
+   */
+  asString(value) {
+    if (this.isEmpty(value)) {
+      return "";
+    } else {
+      switch (this.getDataType(value)) {
+        case "Object":
+        case "Array":
+          return JSON.stringify(value);
+        default:
+          return value;
+      }
+    }
+  },
+  /**
+   * 判断传入的值是否为空
+   *
+   * @param value 待判断的值
+   * @returns 返回布尔值，表示是否为空
+   */
+  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;
+    }
+  },
+  /**
+   * 将JSON对象转换为FormData对象
+   *
+   * @param json 待转换的JSON对象，其属性值为字符串或Blob类型
+   * @returns 转换后的FormData对象
+   */
+  json2form(json) {
+    const formData = new FormData();
+    if (this.isEmpty(json)) return formData;
+    Object.keys(json).forEach((key) => {
+      formData.append(key, json[key] instanceof Object ? JSON.stringify(json[key]) : json[key]);
+    });
+    return formData;
+  },
+  /**
+   * 生成GUID
+   *
+   * @returns 返回一个由8个16进制数组成的GUID字符串
+   */
+  guid() {
+    const S4 = function() {
+      return ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
+    };
+    return S4() + S4() + S4() + S4() + S4() + S4() + S4() + S4();
+  },
+  /**
+   * 将参数进行解码并返回解码后的字符串
+   *
+   * @param args 参数
+   * @returns 解码后的字符串
+   */
+  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;
+  },
+  /**
+   * 将一个或多个对象的所有可枚举属性复制到目标对象。
+   *
+   * @param dest 目标对象，用于接收复制的属性。
+   * @param args 一个或多个源对象，用于提供要复制的属性。
+   * @returns 返回目标对象，包含所有复制的属性。
+   */
+  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;
+  },
+  /**
+   * 将扁平化数组转换为树形结构数组
+   *
+   * @param data 扁平化数组
+   * @param idPropertyName 数据中标识id的字段名，默认为'id'
+   * @param parentIdPropertyName 数据中标识父节点id的字段名，默认为'parentId'
+   * @param childrenPropertyName 树形结构中标识子节点的字段名，默认为'children'
+   * @returns 转换后的树形结构数组
+   */
+  convertToTree2(data, idPropertyName = "id", parentIdPropertyName = "parentId", childrenPropertyName = "children") {
     const result = [];
     function buildChildren(item) {
       const children = data.filter((item2) => item2[parentIdPropertyName] === item[idPropertyName]).map((child) => {
@@ -490,10 +877,143 @@ const ObjectUtil = {
   },
   parse(str) {
     if (typeof str === "string" && str.startsWith("{") && str.endsWith("}")) return JSON.parse(str);
-    if (CommUtils.isEmpty(str)) return {};
-    if (CommUtils.isObject(str)) return str;
+    if (Util.isEmpty(str)) return {};
+    if (Util.isObject(str)) return str;
+  }
+};
+class HashMap extends Map {
+  isEmpty() {
+    return this.size === 0;
+  }
+  _values() {
+    return Array.from(this.values());
+  }
+  _keys() {
+    return Array.from(this.keys());
+  }
+  _entries() {
+    return Array.from(this.entries());
+  }
+  /**
+   * 从键值对数组创建一个HashMap对象
+   *
+   * @param array 键值对数组，默认为空数组
+   * @returns 返回一个新的HashMap对象
+   */
+  static fromEntries(array = []) {
+    const hashMap = new HashMap();
+    array.forEach((element) => {
+      if (Array.isArray(element) && element.length === 2) {
+        hashMap.set(element[0], element[1]);
+      }
+    });
+    return hashMap;
+  }
+  /**
+   * 从JSON字符串创建HashMap实例
+   *
+   * @param str JSON字符串
+   * @returns HashMap实例
+   */
+  static fromJson(str) {
+    const json = ObjectUtil.parse(str);
+    return new HashMap(Object.entries(json));
+  }
+}
+class WebSocketClient extends EventDispatcher {
+  constructor(url = "ws://127.0.0.1:10088") {
+    super();
+    __publicField(this, "maxCheckTimes", 10);
+    __publicField(this, "url");
+    __publicField(this, "checkTimes", 0);
+    __publicField(this, "connectStatus", false);
+    __publicField(this, "client", null);
+    this.maxCheckTimes = 10;
+    this.url = url;
+    this.checkTimes = 0;
+    this.connect();
+    this.connCheckStatus(this.maxCheckTimes);
+  }
+  connect() {
+    this.disconnect();
+    if (this.url) {
+      try {
+        console.info("创建ws连接>>>" + 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("创建ws连接失败" + this.url + ":" + ex);
+      }
+    }
+  }
+  disconnect() {
+    if (this.client) {
+      try {
+        console.log("ws断开连接" + 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 + "消息发送失败：" + message);
+    return this;
   }
-};
+  heartbeat() {
+    setTimeout(() => {
+      if (this.client && this.client.readyState === 1) {
+        this.send("HeartBeat");
+      }
+      console.log("HeartBeat," + this.url);
+      setTimeout(this.heartbeat, 3e4);
+    }, 1e3);
+  }
+}
 const ImageUtil = {
   emptyImageUrl: "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7",
   /**
@@ -606,7 +1126,7 @@ const AjaxUtil = {
    * @param callback  - callback function when completed
    */
   jsonp(url, callback) {
-    const name = "_jsonp_" + CommUtils.guid();
+    const name = "_jsonp_" + Util.guid();
     const head = document.getElementsByTagName("head")[0];
     if (url.includes("?")) {
       url += "&callback=" + name;
@@ -645,7 +1165,7 @@ const AjaxUtil = {
    * );
    */
   get(url, options = {}, cb) {
-    if (CommUtils.isFunction(options)) {
+    if (Util.isFunction(options)) {
       const t = cb;
       cb = options;
       options = t;
@@ -777,7 +1297,7 @@ const AjaxUtil = {
    * );
    */
   getArrayBuffer(url, options, cb) {
-    if (CommUtils.isFunction(options)) {
+    if (Util.isFunction(options)) {
       const t = cb;
       cb = options;
       options = t;
@@ -830,7 +1350,7 @@ const AjaxUtil = {
    * );
    */
   getJSON(url, options, cb) {
-    if (CommUtils.isFunction(options)) {
+    if (Util.isFunction(options)) {
       const t = cb;
       cb = options;
       options = t;
@@ -847,48 +1367,6 @@ const AjaxUtil = {
     return this.get(url, options, callback);
   }
 };
-const 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);
-  },
-  /**
-   * 角度转弧度
-   *
-   * @param {*} degrees
-   * @returns {*}
-   */
-  deg2Rad(degrees) {
-    return degrees * this.DEG2RAD;
-  },
-  /**
-   * 弧度转角度
-   *
-   * @param {*} radians
-   * @returns {*}
-   */
-  rad2Deg(radians) {
-    return radians * this.RAD2DEG;
-  },
-  round(value, n = 2) {
-    return Math.round(value * Math.pow(10, n)) / Math.pow(10, n);
-  },
-  /**
-   * 将数值限制在指定范围内
-   *
-   * @param val 需要限制的数值
-   * @param min 最小值
-   * @param max 最大值
-   * @returns 返回限制后的数值
-   */
-  clamp(val, min, max) {
-    return Math.max(min, Math.min(max, val));
-  }
-};
 class GeoUtil {
   /**
    * 判断给定的经纬度是否合法
@@ -898,7 +1376,7 @@ class GeoUtil {
    * @returns 如果经纬度合法，返回true；否则返回false
    */
   static isLnglat(lng, lat) {
-    return !isNaN(lng) && !isNaN(lat) && !!(+lat > -90 && +lat < 90 && +lng > -180 && +lng < 180);
+    return Util.isNumber(lng) && Util.isNumber(lat) && !!(+lat > -90 && +lat < 90 && +lng > -180 && +lng < 180);
   }
   /**
    * 计算两哥平面坐标点间的距离
@@ -1090,15 +1568,15 @@ class GeoUtil {
    * @returns 返回计算后的新经纬度点，类型为{lat: number, lng: number}
    */
   static calcPointByBearAndDis(latlng, angle, distance) {
-    const sLat = MathUtils.deg2Rad(latlng.lat * 1);
-    const sLng = MathUtils.deg2Rad(latlng.lng * 1);
+    const sLat = MathUtil.deg2Rad(latlng.lat * 1);
+    const sLng = MathUtil.deg2Rad(latlng.lng * 1);
     const d = distance / this.R;
-    angle = MathUtils.deg2Rad(angle);
+    angle = MathUtil.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)
+      lat: MathUtil.rad2Deg(lat),
+      lng: MathUtil.rad2Deg(lon)
     };
   }
   /**
@@ -1247,26 +1725,6 @@ const StringUtil = {
         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}`);
-  },
   /**
    * 计算字符串的字节长度
    *
@@ -1589,42 +2047,42 @@ const GeoJsonUtil = {
 const AssertUtil = {
   assertEmpty(...arg) {
     arg.forEach((a) => {
-      if (CommUtils.isEmpty(a)) {
+      if (Util.isEmpty(a)) {
         throw Error(ErrorType.PARAMETER_ERROR_LACK + " -> " + a);
       }
     });
   },
   assertInteger(...arg) {
     arg.forEach((a) => {
-      if (!CommUtils.isInteger(a)) {
+      if (!Util.isInteger(a)) {
         throw Error(ErrorType.PARAMETER_ERROR_INTEGER + " -> " + a);
       }
     });
   },
   assertNumber(...arg) {
     arg.forEach((a) => {
-      if (!CommUtils.isNumber(a)) {
+      if (!Util.isNumber(a)) {
         throw Error(ErrorType.PARAMETER_ERROR_NUMBER + " -> " + a);
       }
     });
   },
   assertArray(...arg) {
     arg.forEach((a) => {
-      if (!CommUtils.isArray(a)) {
+      if (!Util.isArray(a)) {
         throw Error(ErrorType.PARAMETER_ERROR_ARRAY + " -> " + a);
       }
     });
   },
   assertFunction(...arg) {
     arg.forEach((a) => {
-      if (!CommUtils.isFunction(a)) {
+      if (!Util.isFunction(a)) {
         throw Error(ErrorType.PARAMETER_ERROR_FUNCTION + " -> " + a);
       }
     });
   },
   assertObject(...arg) {
     arg.forEach((a) => {
-      if (!CommUtils.isObject(a)) {
+      if (!Util.isObject(a)) {
         throw Error(ErrorType.PARAMETER_ERROR_OBJECT + " -> " + a);
       }
     });
@@ -2328,7 +2786,7 @@ class CoordsUtil {
     let p, pp;
     for (let i = 0, len = arr.length; i < len; i++) {
       p = arr[i];
-      if (CommUtils.isNil(p)) {
+      if (Util.isNil(p)) {
         result.push(null);
         continue;
       }
@@ -2518,940 +2976,486 @@ 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
-   */
-  getStyle(el, style) {
-    var _a2;
-    let value = el.style[style];
-    if (!value || value === "auto") {
-      const css = (_a2 = document.defaultView) == null ? void 0 : _a2.getComputedStyle(el, null);
-      value = css ? css[style] : null;
-      if (value === "auto") value = null;
-    }
-    return value;
-  },
-  /**
-   * 创建一个HTML元素
-   *
-   * @param tagName 元素标签名
-   * @param className 元素类名
-   * @param container 父容器，若传入，则新创建的元素会被添加到该容器中
-   * @returns 返回新创建的HTML元素
-   */
-  create(tagName, className, container) {
-    const el = document.createElement(tagName);
-    el.className = className || "";
-    if (container) {
-      container.appendChild(el);
-    }
-    return el;
-  },
-  /**
-   * 从父节点中移除指定元素。
-   *
-   * @param el 要移除的元素对象，必须包含parentNode属性。
-   */
-  remove(el) {
-    const parent = el.parentNode;
-    if (parent) {
-      parent.removeChild(el);
-    }
-  },
-  /**
-   * 清空给定元素的子节点
-   *
-   * @param el 要清空子节点的元素，包含firstChild和removeChild属性
-   */
-  empty(el) {
-    while (el.firstChild) {
-      el.removeChild(el.firstChild);
-    }
-  },
-  /**
-   * 将元素移到父节点的最前面
-   *
-   * @param el 要移动的元素，需要包含 parentNode 属性
-   */
-  toFront(el) {
-    const parent = el.parentNode;
-    if (parent && parent.lastChild !== el) {
-      parent.appendChild(el);
-    }
-  },
-  /**
-   * 将元素移动到其父节点的最前面
-   *
-   * @param el 要移动的元素，需要包含parentNode属性
-   */
-  toBack(el) {
-    const parent = el.parentNode;
-    if (parent && parent.firstChild !== el) {
-      parent.insertBefore(el, parent.firstChild);
-    }
-  },
-  /**
-   * 获取元素的类名
-   *
-   * @param el 包含对应元素和类名的对象
-   * @param el.correspondingElement 对应的元素
-   * @param el.className 类名对象
-   * @param el.className.baseVal 类名字符串
-   * @returns 返回元素的类名字符串
-   */
-  getClass(el) {
-    const shadowElement = (el == null ? void 0 : el.host) || el;
-    return shadowElement.className.toString();
-  },
-  /**
-   * 判断元素是否包含指定类名
-   *
-   * @param el 元素对象，包含classList属性，classList属性包含contains方法
-   * @param name 要判断的类名
-   * @returns 返回一个布尔值，表示元素是否包含指定类名
-   */
-  hasClass(el, name) {
-    var _a2;
-    if ((_a2 = el.classList) == null ? void 0 : _a2.contains(name)) {
-      return true;
-    }
-    const className = this.getClass(el);
-    return className.length > 0 && new RegExp(`(^|\\s)${name}(\\s|$)`).test(className);
-  },
-  /**
-   * 给指定的 HTML 元素添加类名
-   *
-   * @param el 要添加类名的 HTML 元素
-   * @param name 要添加的类名，多个类名之间用空格分隔
-   */
-  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 el 要移除类名的元素
-   * @param name 要移除的类名，多个类名用空格分隔
-   */
-  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 el HTML 或 SVG 元素
-   * @param name 要设置的类名，多个类名之间用空格分隔
-   */
-  setClass(el, name) {
-    if ("classList" in el) {
-      el.classList.value = "";
-      name.split(" ").forEach((className) => el.classList.add(className));
-    }
-  },
-  /**
-   * 从字符串中解析XML文档，并返回根节点
-   *
-   * @param str 要解析的XML字符串
-   * @returns 解析后的XML文档的根节点
-   */
-  parseFromString(str) {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(str, "text/xml");
-    return doc.children[0];
-  }
-};
-const FileUtil = {
-  /**
-   * 将Base64编码的字符串转换为Blob对象
-   *
-   * @param data Base64编码的字符串
-   * @returns 转换后的Blob对象
-   */
-  convertBase64ToBlob(data) {
-    const mimeString = data.split(",")[0].split(":")[1].split(";")[0];
-    const byteCharacters = atob(data.split(",")[1]);
-    const byteNumbers = new Array(byteCharacters.length);
-    for (let i = 0; i < byteCharacters.length; i++) {
-      byteNumbers[i] = byteCharacters.charCodeAt(i);
-    }
-    const byteArray = new Uint8Array(byteNumbers);
-    const blob = new Blob([byteArray], { type: mimeString });
-    return blob;
-  },
-  /**
-   * 将图片的URL转换为Base64编码
-   *
-   * @param url 图片的URL地址
-   * @param width 图片的宽度，默认为图片原始宽度
-   * @param height 图片的高度，默认为图片原始高度
-   * @returns 返回Promise对象，解析后得到包含Base64编码数据的对象
-   */
+  return trim(str).split(/\s+/);
+}
+const DomUtil = {
   /**
-   * 将base64字符串转换为文件对象
+   * 获取元素的样式值
    *
-   * @param dataurl 包含base64字符串的数据URL
-   * @param filename 文件的名称
-   * @returns 返回文件对象
+   * @param el 元素对象
+   * @param style 样式属性名称
+   * @returns 元素的样式值，如果获取不到则返回 null
    */
-  convertBase64ToFile(dataurl, filename) {
-    const arr = dataurl.split(",");
-    const mimeMatch = arr[0].match(/:(.*?);/);
-    const mime = mimeMatch ? mimeMatch[1] : "image/png";
-    const bstr = atob(arr[1]);
-    const u8arr = new Uint8Array(bstr.length);
-    for (let i = 0; i < bstr.length; i++) {
-      u8arr[i] = bstr.charCodeAt(i);
+  getStyle(el, style) {
+    var _a2;
+    let value = el.style[style];
+    if (!value || value === "auto") {
+      const css = (_a2 = document.defaultView) == null ? void 0 : _a2.getComputedStyle(el, null);
+      value = css ? css[style] : null;
+      if (value === "auto") value = null;
     }
-    const file = new File([u8arr], filename, { type: mime });
-    return file;
+    return value;
   },
   /**
-   * 从文件下载数据
+   * 创建一个HTML元素
    *
-   * @param data 要下载的数据，可以是字符串数组、BlobPart 或 MediaSource
-   * @param saveName 下载后文件的保存名称
+   * @param tagName 元素标签名
+   * @param className 元素类名
+   * @param container 父容器，若传入，则新创建的元素会被添加到该容器中
+   * @returns 返回新创建的HTML元素
    */
-  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);
-  }
-};
-class MessageUtil {
-  static resetWarned() {
-    this.warned = {};
-  }
-  static changeVoice() {
-    this.isMute = !!Number(!this.isMute);
-    localStorage.setItem("mute", Number(this.isMute).toString());
-  }
-  static _call(method, message) {
-    if (!this.warned[message]) {
-      method(message);
-      this.warned[message] = true;
+  create(tagName, className, container) {
+    const el = document.createElement(tagName);
+    el.className = className || "";
+    if (container) {
+      container.appendChild(el);
     }
-  }
+    return el;
+  },
   /**
-   * 播放消息提示音和文字朗读
+   * 从父节点中移除指定元素。
    *
-   * @param type 消息类型
-   * @param message 消息内容
-   * @param options 配置选项，可选参数，包括语言、音量、语速和音高
-   * @returns 无返回值
+   * @param el 要移除的元素对象，必须包含parentNode属性。
    */
-  static msg(type, message, options = {}) {
-    Message({ type, message });
-    if (this.isMute) return;
-    const typename = CommUtils.decodeDict(type, "success", "恭喜：", "error", "发生错误：", "warning", "警告：", "info", "友情提示：") + "：";
-    this.speechSynthesisUtterance.text = typename + message;
-    this.speechSynthesisUtterance.lang = options.lang || "zh-CN";
-    this.speechSynthesisUtterance.volume = options.volume || 1;
-    this.speechSynthesisUtterance.rate = options.rate || 1;
-    this.speechSynthesisUtterance.pitch = options.pitch || 1;
-    this.speechSynthesis.speak(this.speechSynthesisUtterance);
-  }
-  static stop(e) {
-    this.speechSynthesisUtterance.text = e;
-    this.speechSynthesis.cancel();
-  }
-  static warning(message) {
-    if (process.env.NODE_ENV === "development" && console !== void 0) {
-      console.warn(`Warning: ${message}`);
-    }
-    this.msg("warning", message);
-  }
-  static warningOnce(message) {
-    this._call(this.warning.bind(this), message);
-  }
-  static info(message) {
-    if (process.env.NODE_ENV === "development" && console !== void 0) {
-      console.info(`Info: ${message}`);
-    }
-    this.msg("info", message);
-  }
-  static infoOnce(message) {
-    this._call(this.info.bind(this), message);
-  }
-  static error(message) {
-    if (process.env.NODE_ENV === "development" && console !== void 0) {
-      console.error(`Error: ${message}`);
-    }
-    this.msg("error", message);
-  }
-  static errorOnce(message) {
-    this._call(this.error.bind(this), message);
-  }
-  static success(message) {
-    if (process.env.NODE_ENV === "development" && console !== void 0) {
-      console.log(`Success: ${message}`);
+  remove(el) {
+    const parent = el.parentNode;
+    if (parent) {
+      parent.removeChild(el);
     }
-    this.msg("success", message);
-  }
-  static successOnce(message) {
-    this._call(this.success.bind(this), message);
-  }
-}
-__publicField(MessageUtil, "warned", {});
-__publicField(MessageUtil, "isMute", !!Number(localStorage.getItem("mute")) || false);
-__publicField(MessageUtil, "speechSynthesis", window.speechSynthesis);
-__publicField(MessageUtil, "speechSynthesisUtterance", new SpeechSynthesisUtterance());
-const OptimizeUtil = {
+  },
   /**
-   * 防抖函数，在指定的等待时间内，如果连续触发事件，则只在最后一次触发后执行函数。适用于像搜索输入框这种需要用户停止输入后才调用的场景
+   * 清空给定元素的子节点
    *
-   * @param func 需要防抖的函数。
-   * @param wait 等待时间，单位毫秒。
-   * @param immediate 是否立即执行函数，默认为true。
-   * @returns 返回防抖后的函数。
+   * @param el 要清空子节点的元素，包含firstChild和removeChild属性
    */
-  debounce(func, wait, immediate = true) {
-    let timeout = null;
-    let args;
-    let timestamp;
-    let result;
-    const later = () => {
-      const last = Date.now() - timestamp;
-      if (last < wait && last > 0) {
-        timeout = setTimeout(later, wait - last);
-      } else {
-        timeout = null;
-        if (!immediate) {
-          result = func.apply(this, args);
-        }
-      }
-    };
-    return (...args2) => {
-      timestamp = Date.now();
-      const callNow = immediate && !timeout;
-      if (!timeout) {
-        timeout = setTimeout(later, wait);
-      }
-      if (callNow) {
-        result = func.apply(this, args2);
-        if (!timeout) {
-          args2 = null;
-        }
-      }
-      return result;
-    };
+  empty(el) {
+    while (el.firstChild) {
+      el.removeChild(el.firstChild);
+    }
   },
   /**
-   * 节流函数，适用于像滚动事件、窗口resize事件这种需要限制调用频率的场景
+   * 将元素移到父节点的最前面
    *
-   * @param func 需要节流的函数
-   * @param wait 节流间隔，单位为毫秒
-   * @param type 节流类型，1表示时间戳方式，2表示定时器方式
-   * @returns 返回一个新的函数，该函数在节流控制下执行传入的函数
+   * @param el 要移动的元素，需要包含 parentNode 属性
    */
-  throttle(func, wait, type = 1) {
-    let previous = 0;
-    let timeout = null;
-    return (...args) => {
-      if (type === 1) {
-        const now = Date.now();
-        if (now - previous >= wait) {
-          func.apply(this, args);
-          previous = now;
-        }
-      } else if (type === 2) {
-        if (!timeout) {
-          timeout = setTimeout(() => {
-            timeout = null;
-            func.apply(this, args);
-          }, wait);
-        }
-      }
-    };
+  toFront(el) {
+    const parent = el.parentNode;
+    if (parent && parent.lastChild !== el) {
+      parent.appendChild(el);
+    }
   },
   /**
-   * 缓存函数，将传入的函数fn的计算结果缓存，提高重复计算的效率
+   * 将元素移动到其父节点的最前面
    *
-   * @param fn 传入待缓存的函数
-   * @returns 返回缓存后的函数
+   * @param el 要移动的元素，需要包含parentNode属性
    */
-  memoize(fn) {
-    const cache = /* @__PURE__ */ new Map();
-    return (...args) => {
-      const argsString = JSON.stringify(args);
-      if (cache.has(argsString)) {
-        return cache.get(argsString);
-      } else {
-        const result = fn.apply(this, args);
-        cache.set(argsString, result);
-        return result;
-      }
-    };
+  toBack(el) {
+    const parent = el.parentNode;
+    if (parent && parent.firstChild !== el) {
+      parent.insertBefore(el, parent.firstChild);
+    }
   },
   /**
-   * 递归调用函数，以一定的频率和持续时间执行。
+   * 获取元素的类名
    *
-   * @param fun 要递归调用的函数。
-   * @param frequency 每次调用函数之间的时间间隔，单位为毫秒，默认为500毫秒。
-   * @param duration 函数递归调用的总时长，单位为毫秒，默认为5000毫秒。
-   */
-  recurve(fun, frequency = 500, duration = 5e3) {
-    let timer = 0;
-    setTimeout(() => {
-      timer++;
-      if (timer < Math.floor(duration / frequency)) {
-        fun.call(this);
-        setTimeout(this.recurve.bind(this, fun, frequency, duration), frequency);
-      }
-    }, frequency);
+   * @param el 包含对应元素和类名的对象
+   * @param el.correspondingElement 对应的元素
+   * @param el.className 类名对象
+   * @param el.className.baseVal 类名字符串
+   * @returns 返回元素的类名字符串
+   */
+  getClass(el) {
+    const shadowElement = (el == null ? void 0 : el.host) || el;
+    return shadowElement.className.toString();
   },
   /**
-   * 确保函数只被调用一次
+   * 判断元素是否包含指定类名
    *
-   * @param func 要被调用的函数
-   * @returns 返回一个新的函数，该函数在被首次调用时会执行传入的函数，之后再次调用将不再执行
+   * @param el 元素对象，包含classList属性，classList属性包含contains方法
+   * @param name 要判断的类名
+   * @returns 返回一个布尔值，表示元素是否包含指定类名
    */
-  once(func) {
-    let called = false;
-    return function(...args) {
-      if (!called) {
-        called = true;
-        return func(...args);
-      }
-    };
-  }
-};
-const UrlUtil = {
+  hasClass(el, name) {
+    var _a2;
+    if ((_a2 = el.classList) == null ? void 0 : _a2.contains(name)) {
+      return true;
+    }
+    const className = this.getClass(el);
+    return className.length > 0 && new RegExp(`(^|\\s)${name}(\\s|$)`).test(className);
+  },
   /**
-   * 将json对象转换为查询字符串
+   * 给指定的 HTML 元素添加类名
    *
-   * @param json 待转换的json对象
-   * @returns 转换后的查询字符串
+   * @param el 要添加类名的 HTML 元素
+   * @param name 要添加的类名，多个类名之间用空格分隔
    */
-  json2Query(json) {
-    var tempArr = [];
-    for (var i in json) {
-      if (json.hasOwnProperty(i)) {
-        var key = i;
-        var value = json[i];
-        tempArr.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
+  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);
     }
-    var urlParamsStr = tempArr.join("&");
-    return urlParamsStr;
   },
   /**
-   * 从 URL 中解析出查询参数和哈希参数，并以对象的形式返回
+   * 从元素中移除指定类名
    *
-   * @param href 需要解析的 URL 链接，默认为当前窗口的 URL
-   * @param needDecode 是否需要解码参数值，默认为 true
-   * @returns 返回一个包含解析后参数的对象，其中键为参数名，值为参数值
+   * @param el 要移除类名的元素
+   * @param name 要移除的类名，多个类名用空格分隔
    */
-  query2Json(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 j = 1; j < arr.length; j++) {
-            let res;
-            while (res = reg.exec(arr[j])) {
-              obj[res[1]] = needDecode ? decodeURIComponent(res[2]) : res[2];
-            }
-          }
-        }
-      }
+  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());
     }
-    return obj;
-  }
-};
-class Color {
-  constructor(r, g, b, a) {
-    __publicField(this, "_r");
-    __publicField(this, "_g");
-    __publicField(this, "_b");
-    __publicField(this, "_alpha");
-    this._validateColorChannel(r);
-    this._validateColorChannel(g);
-    this._validateColorChannel(b);
-    this._r = r;
-    this._g = g;
-    this._b = b;
-    this._alpha = MathUtils.clamp(a || 1, 0, 1);
-  }
-  _validateColorChannel(channel) {
-    if (channel < 0 || channel > 255) {
-      throw new Error("Color channel must be between 0 and 255.");
+  },
+  /**
+   * 设置元素的 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));
     }
-  }
-  toString() {
-    return `rgba(${this._r}, ${this._g}, ${this._b}, ${this._alpha})`;
-  }
-  toJson() {
-    return { r: this._r, g: this._g, b: this._b, a: this._alpha };
-  }
-  get rgba() {
-    return `rgba(${this._r}, ${this._g}, ${this._b}, ${this._alpha})`;
-  }
-  get hex() {
-    return Color.rgb2hex(this._r, this._g, this._b, this._alpha);
-  }
-  setAlpha(a) {
-    this._alpha = MathUtils.clamp(a, 0, 1);
-    return this;
-  }
-  // 设置颜色的RGB值
-  setRgb(r, g, b) {
-    this._validateColorChannel(r);
-    this._validateColorChannel(g);
-    this._validateColorChannel(b);
-    this._r = r;
-    this._g = g;
-    this._b = b;
-    return this;
-  }
+  },
   /**
-   * 从RGBA字符串创建Color对象
+   * 从字符串中解析XML文档，并返回根节点
    *
-   * @param rgbaValue RGBA颜色值字符串，格式为"rgba(r,g,b,a)"或"rgb(r,g,b)"
-   * @returns 返回Color对象
-   * @throws 如果rgbaValue不是有效的RGBA颜色值，则抛出错误
+   * @param str 要解析的XML字符串
+   * @returns 解析后的XML文档的根节点
    */
-  static fromRgba(rgbaValue) {
-    const rgbaMatch = rgbaValue.match(/^rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([\d.]+))?\s*\)$/);
-    if (!rgbaMatch) throw new Error("Invalid RGBA color value");
-    const r = parseInt(rgbaMatch[1], 10);
-    const g = parseInt(rgbaMatch[2], 10);
-    const b = parseInt(rgbaMatch[3], 10);
-    const a = rgbaMatch[5] ? parseFloat(rgbaMatch[5]) : 1;
-    return new Color(r, g, b, a);
+  parseFromString(str) {
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(str, "text/xml");
+    return doc.children[0];
   }
+};
+const FileUtil = {
   /**
-   * 将十六进制颜色值转换为颜色对象
+   * 将Base64编码的字符串转换为Blob对象
    *
-   * @param hexValue 十六进制颜色值，可带或不带#前缀，支持3位和6位表示
-   * @returns 返回颜色对象
+   * @param data Base64编码的字符串
+   * @returns 转换后的Blob对象
    */
-  static fromHex(hexValue, a = 1) {
-    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) {
-      throw new Error("Invalid HEX color value");
+  convertBase64ToBlob(data) {
+    const mimeString = data.split(",")[0].split(":")[1].split(";")[0];
+    const byteCharacters = atob(data.split(",")[1]);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0; i < byteCharacters.length; i++) {
+      byteNumbers[i] = byteCharacters.charCodeAt(i);
     }
-    const r = parseInt(rgb[1], 16);
-    const g = parseInt(rgb[2], 16);
-    const b = parseInt(rgb[3], 16);
-    return new Color(r, g, b, a);
-  }
+    const byteArray = new Uint8Array(byteNumbers);
+    const blob = new Blob([byteArray], { type: mimeString });
+    return blob;
+  },
   /**
-   * 从 HSL 字符串创建颜色对象
+   * 将图片的URL转换为Base64编码
    *
-   * @param hsl HSL 字符串，格式为 hsl(h, s%, l%) 或 hsla(h, s%, l%, a)
-   * @returns 返回颜色对象，如果 hsl 字符串无效则返回 null
+   * @param url 图片的URL地址
+   * @param width 图片的宽度，默认为图片原始宽度
+   * @param height 图片的高度，默认为图片原始高度
+   * @returns 返回Promise对象，解析后得到包含Base64编码数据的对象
    */
-  static fromHsl(hslValue) {
-    const hsl = /hsl\((\d+),\s*([\d.]+)%,\s*([\d.]+)%\)/g.exec(hslValue) || /hsla\((\d+),\s*([\d.]+)%,\s*([\d.]+)%,\s*([\d.]+)\)/g.exec(hslValue);
-    if (!hsl) {
-      throw new Error("Invalid HSL color value");
-    }
-    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 new Color(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);
-  }
   /**
-   * 从字符串中创建颜色对象
+   * 将base64字符串转换为文件对象
    *
-   * @param str 字符串类型的颜色值，支持rgba、hex、hsl格式
-   * @returns 返回创建的颜色对象
-   * @throws 当颜色值无效时，抛出错误
+   * @param dataurl 包含base64字符串的数据URL
+   * @param filename 文件的名称
+   * @returns 返回文件对象
    */
-  static from(str) {
-    if (this.isRgb(str)) {
-      return this.fromRgba(str);
-    } else if (this.isHex(str)) {
-      return this.fromHex(str);
-    } else if (this.isHsl(str)) {
-      return this.fromHsl(str);
-    } else {
-      throw new Error("Invalid color value");
+  convertBase64ToFile(dataurl, filename) {
+    const arr = dataurl.split(",");
+    const mimeMatch = arr[0].match(/:(.*?);/);
+    const mime = mimeMatch ? mimeMatch[1] : "image/png";
+    const bstr = atob(arr[1]);
+    const u8arr = new Uint8Array(bstr.length);
+    for (let i = 0; i < bstr.length; i++) {
+      u8arr[i] = bstr.charCodeAt(i);
     }
-  }
+    const file = new File([u8arr], filename, { type: mime });
+    return file;
+  },
   /**
-   * 将RGB颜色值转换为十六进制颜色值
+   * 从文件下载数据
    *
-   * @param r 红色分量值，取值范围0-255
-   * @param g 绿色分量值，取值范围0-255
-   * @param b 蓝色分量值，取值范围0-255
-   * @param a 可选参数，透明度分量值，取值范围0-1
-   * @returns 十六进制颜色值，格式为#RRGGBB或#RRGGBBAA
+   * @param data 要下载的数据，可以是字符串数组、BlobPart 或 MediaSource
+   * @param saveName 下载后文件的保存名称
    */
-  static rgb2hex(r, g, b, a) {
-    var hex = "#" + ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);
-    if (a !== void 0) {
-      const alpha = Math.round(a * 255).toString(16).padStart(2, "0");
-      return hex + alpha;
+  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);
     }
-    return hex;
-  }
-  static isHex(a) {
-    return /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(a);
-  }
-  static isRgb(a) {
-    return /^rgba?\s*\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(,\s*[\d.]+)?\s*\)$/.test(a);
-  }
-  static isHsl(a) {
-    return /^(hsl|hsla)\(\d+,\s*[\d.]+%,\s*[\d.]+%(,\s*[\d.]+)?\)$/.test(a);
+    var link = document.createElement("a");
+    link.href = data;
+    link.download = saveName || "";
+    link.click();
+    window.URL.revokeObjectURL(link.href);
   }
-  static isColor(a) {
-    return this.isHex(a) || this.isRgb(a) || this.isHsl(a);
+};
+class MessageUtil {
+  static resetWarned() {
+    this.warned = {};
   }
-  static random() {
-    let r = Math.floor(Math.random() * 256);
-    let g = Math.floor(Math.random() * 256);
-    let b = Math.floor(Math.random() * 256);
-    let a = Math.random();
-    return new Color(r, g, b, a);
+  static changeVoice() {
+    this.isMute = !!Number(!this.isMute);
+    localStorage.setItem("mute", Number(this.isMute).toString());
   }
-}
-class CanvasDrawer {
-  constructor(el) {
-    __publicField(this, "context", null);
-    if (typeof el === "string") {
-      el = document.querySelector("#" + el);
-      if (!el) {
-        throw new Error("Element not found");
-      }
-    }
-    if (el instanceof HTMLElement) {
-      const canvas = el;
-      if (canvas.getContext) {
-        this.context = canvas.getContext("2d");
-      } else {
-        throw new Error("getContext is not available on this element");
-      }
-    } else {
-      throw new Error("Element is not an HTMLElement");
+  static _call(method, message) {
+    if (!this.warned[message]) {
+      method(message);
+      this.warned[message] = true;
     }
   }
   /**
-   * 绘制线条
+   * 播放消息提示音和文字朗读
    *
-   * @param start 起始坐标点
-   * @param end 终止坐标点
-   * @param options 绘制选项，包括线条宽度和颜色
-   * @throws 当画布上下文不存在时抛出错误
+   * @param type 消息类型
+   * @param message 消息内容
+   * @param options 配置选项，可选参数，包括语言、音量、语速和音高
+   * @returns 无返回值
    */
-  drawLine({ x: startX, y: startY }, { x: endX, y: endY }, options = {}) {
-    if (!this.context) {
-      throw new Error("Canvas context is null or undefined");
-    }
-    this.context.beginPath();
-    const width = options.width || 1;
-    const color = options.color || "#000";
-    this.context.lineWidth = width;
-    this.context.strokeStyle = color;
-    this.context.moveTo(startX, startY);
-    this.context.lineTo(endX, endY);
-    this.context.stroke();
+  static msg(type, message, options = {}) {
+    Message({ type, message });
+    if (this.isMute) return;
+    const typename = Util.decodeDict(type, "success", "恭喜：", "error", "发生错误：", "warning", "警告：", "info", "友情提示：") + "：";
+    this.speechSynthesisUtterance.text = typename + message;
+    this.speechSynthesisUtterance.lang = options.lang || "zh-CN";
+    this.speechSynthesisUtterance.volume = options.volume || 1;
+    this.speechSynthesisUtterance.rate = options.rate || 1;
+    this.speechSynthesisUtterance.pitch = options.pitch || 1;
+    this.speechSynthesis.speak(this.speechSynthesisUtterance);
   }
-  /**
-   * 绘制圆弧
-   *
-   * @param x 圆心x坐标
-   * @param y 圆心y坐标
-   * @param radius 半径
-   * @param startAngle 起始角度（度）
-   * @param endAngle 结束角度（度）
-   * @param anticlockwise 是否逆时针绘制
-   * @param isFill 是否填充
-   * @param bgColor 背景颜色
-   * @throws 当Canvas context为null或undefined时抛出错误
-   */
-  drawArc({ x, y }, radius, startAngle, endAngle, anticlockwise, isFill, bgColor) {
-    if (!this.context) {
-      throw new Error("Canvas context is null or undefined");
-    }
-    if (isFill) {
-      this.context.fillStyle = bgColor;
-      this.context.beginPath();
-      this.context.arc(x, y, radius, MathUtils.deg2Rad(startAngle), MathUtils.deg2Rad(endAngle), anticlockwise);
-      this.context.fill();
-    } else {
-      this.context.strokeStyle = bgColor;
-      this.context.beginPath();
-      this.context.arc(x, y, radius, MathUtils.deg2Rad(startAngle), MathUtils.deg2Rad(endAngle), anticlockwise);
-      this.context.stroke();
-    }
+  static stop(e) {
+    this.speechSynthesisUtterance.text = e;
+    this.speechSynthesis.cancel();
   }
-  static createCanvas(width = 1, height = 1) {
-    const canvas = document.createElement("canvas");
-    if (width) {
-      canvas.width = width;
-    }
-    if (height) {
-      canvas.height = height;
+  static warning(message) {
+    if (process.env.NODE_ENV === "development" && console !== void 0) {
+      console.warn(`Warning: ${message}`);
     }
-    return canvas;
+    this.msg("warning", message);
   }
-}
-class EventDispatcher {
-  constructor() {
-    __publicField(this, "_listeners");
-    __publicField(this, "_mutex", {});
-    __publicField(this, "_context");
+  static warningOnce(message) {
+    this._call(this.warning.bind(this), message);
   }
-  addEventListener(type, listener, context, mutexStatus) {
-    if (this._listeners === void 0) this._listeners = {};
-    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);
+  static info(message) {
+    if (process.env.NODE_ENV === "development" && console !== void 0) {
+      console.info(`Info: ${message}`);
     }
-    return this;
+    this.msg("info", message);
   }
-  hasEventListener(type, listener) {
-    if (this._listeners === null || this._listeners === void 0) return false;
-    const listeners = this._listeners;
-    return listeners[type] !== void 0 && listeners[type].indexOf(listener) !== -1;
+  static infoOnce(message) {
+    this._call(this.info.bind(this), message);
   }
-  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;
+  static error(message) {
+    if (process.env.NODE_ENV === "development" && console !== void 0) {
+      console.error(`Error: ${message}`);
     }
-    if (listenerArray !== void 0) {
-      const index = listenerArray.map((d) => d.toString()).indexOf(listener.toString());
-      if (index !== -1) {
-        listenerArray.splice(index, 1);
-      }
+    this.msg("error", message);
+  }
+  static errorOnce(message) {
+    this._call(this.error.bind(this), message);
+  }
+  static success(message) {
+    if (process.env.NODE_ENV === "development" && console !== void 0) {
+      console.log(`Success: ${message}`);
     }
+    this.msg("success", message);
   }
-  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] !== void 0) {
-        const find = array.find((item) => item === this._mutex[event.type]);
-        if (find) {
-          find.call(this._context || this, event);
-          return;
+  static successOnce(message) {
+    this._call(this.success.bind(this), message);
+  }
+}
+__publicField(MessageUtil, "warned", {});
+__publicField(MessageUtil, "isMute", !!Number(localStorage.getItem("mute")) || false);
+__publicField(MessageUtil, "speechSynthesis", window.speechSynthesis);
+__publicField(MessageUtil, "speechSynthesisUtterance", new SpeechSynthesisUtterance());
+const OptimizeUtil = {
+  /**
+   * 防抖函数，在指定的等待时间内，如果连续触发事件，则只在最后一次触发后执行函数。适用于像搜索输入框这种需要用户停止输入后才调用的场景
+   *
+   * @param func 需要防抖的函数。
+   * @param wait 等待时间，单位毫秒。
+   * @param immediate 是否立即执行函数，默认为true。
+   * @returns 返回防抖后的函数。
+   */
+  debounce(func, wait, immediate = true) {
+    let timeout = null;
+    let args;
+    let timestamp;
+    let result;
+    const later = () => {
+      const last = Date.now() - timestamp;
+      if (last < wait && last > 0) {
+        timeout = setTimeout(later, wait - last);
+      } else {
+        timeout = null;
+        if (!immediate) {
+          result = func.apply(this, args);
+        }
+      }
+    };
+    return (...args2) => {
+      timestamp = Date.now();
+      const callNow = immediate && !timeout;
+      if (!timeout) {
+        timeout = setTimeout(later, wait);
+      }
+      if (callNow) {
+        result = func.apply(this, args2);
+        if (!timeout) {
+          args2 = null;
         }
       }
-      for (let i = 0, l = array.length; i < l; i++) {
-        const item = array[i];
-        if (typeof item === "function") {
-          item.call(this._context || this, event);
+      return result;
+    };
+  },
+  /**
+   * 节流函数，适用于像滚动事件、窗口resize事件这种需要限制调用频率的场景
+   *
+   * @param func 需要节流的函数
+   * @param wait 节流间隔，单位为毫秒
+   * @param type 节流类型，1表示时间戳方式，2表示定时器方式
+   * @returns 返回一个新的函数，该函数在节流控制下执行传入的函数
+   */
+  throttle(func, wait, type = 1) {
+    let previous = 0;
+    let timeout = null;
+    return (...args) => {
+      if (type === 1) {
+        const now = Date.now();
+        if (now - previous >= wait) {
+          func.apply(this, args);
+          previous = now;
+        }
+      } else if (type === 2) {
+        if (!timeout) {
+          timeout = setTimeout(() => {
+            timeout = null;
+            func.apply(this, args);
+          }, wait);
         }
       }
-    }
-  }
-  removeAllListener() {
-    this._mutex = {};
-    for (const key in this._listeners) {
-      this._listeners[key] = [];
-    }
-  }
-}
-class HashMap extends Map {
-  isEmpty() {
-    return this.size === 0;
-  }
-  _values() {
-    return Array.from(this.values());
-  }
-  _keys() {
-    return Array.from(this.keys());
-  }
-  _entries() {
-    return Array.from(this.entries());
-  }
+    };
+  },
   /**
-   * 从键值对数组创建一个HashMap对象
+   * 缓存函数，将传入的函数fn的计算结果缓存，提高重复计算的效率
    *
-   * @param array 键值对数组，默认为空数组
-   * @returns 返回一个新的HashMap对象
+   * @param fn 传入待缓存的函数
+   * @returns 返回缓存后的函数
    */
-  static fromEntries(array = []) {
-    const hashMap = new HashMap();
-    array.forEach((element) => {
-      if (Array.isArray(element) && element.length === 2) {
-        hashMap.set(element[0], element[1]);
+  memoize(fn) {
+    const cache = /* @__PURE__ */ new Map();
+    return (...args) => {
+      const argsString = JSON.stringify(args);
+      if (cache.has(argsString)) {
+        return cache.get(argsString);
+      } else {
+        const result = fn.apply(this, args);
+        cache.set(argsString, result);
+        return result;
       }
-    });
-    return hashMap;
-  }
+    };
+  },
   /**
-   * 从JSON字符串创建HashMap实例
+   * 递归调用函数，以一定的频率和持续时间执行。
    *
-   * @param str JSON字符串
-   * @returns HashMap实例
+   * @param fun 要递归调用的函数。
+   * @param frequency 每次调用函数之间的时间间隔，单位为毫秒，默认为500毫秒。
+   * @param duration 函数递归调用的总时长，单位为毫秒，默认为5000毫秒。
    */
-  static fromJson(str) {
-    const json = ObjectUtil.parse(str);
-    return new HashMap(Object.entries(json));
-  }
-}
-class WebSocketClient extends EventDispatcher {
-  constructor(url = "ws://127.0.0.1:10088") {
-    super();
-    __publicField(this, "maxCheckTimes", 10);
-    __publicField(this, "url");
-    __publicField(this, "checkTimes", 0);
-    __publicField(this, "connectStatus", false);
-    __publicField(this, "client", null);
-    this.maxCheckTimes = 10;
-    this.url = url;
-    this.checkTimes = 0;
-    this.connect();
-    this.connCheckStatus(this.maxCheckTimes);
-  }
-  connect() {
-    this.disconnect();
-    if (this.url) {
-      try {
-        console.info("创建ws连接>>>" + 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("创建ws连接失败" + this.url + ":" + ex);
+  recurve(fun, frequency = 500, duration = 5e3) {
+    let timer = 0;
+    setTimeout(() => {
+      timer++;
+      if (timer < Math.floor(duration / frequency)) {
+        fun.call(this);
+        setTimeout(this.recurve.bind(this, fun, frequency, duration), frequency);
       }
-    }
-  }
-  disconnect() {
-    if (this.client) {
-      try {
-        console.log("ws断开连接" + this.url);
-        this.client.close();
-        this.client = null;
-      } catch (ex) {
-        this.client = null;
+    }, frequency);
+  },
+  /**
+   * 确保函数只被调用一次
+   *
+   * @param func 要被调用的函数
+   * @returns 返回一个新的函数，该函数在被首次调用时会执行传入的函数，之后再次调用将不再执行
+   */
+  once(func) {
+    let called = false;
+    return function(...args) {
+      if (!called) {
+        called = true;
+        return func(...args);
       }
-    }
+    };
   }
-  connCheckStatus(times) {
-    if (this.checkTimes > times) return;
-    setTimeout(() => {
-      this.checkTimes++;
-      if (this.client && this.client.readyState !== 0 && this.client.readyState !== 1) {
-        this.connect();
+};
+const UrlUtil = {
+  /**
+   * 将json对象转换为查询字符串
+   *
+   * @param json 待转换的json对象
+   * @returns 转换后的查询字符串
+   */
+  json2Query(json) {
+    var tempArr = [];
+    for (var i in json) {
+      if (json.hasOwnProperty(i)) {
+        var key = i;
+        var value = json[i];
+        tempArr.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
       }
-      this.connCheckStatus(times);
-    }, 2e3);
-  }
-  send(message) {
-    if (this.client && this.client.readyState === 1) {
-      this.client.send(message);
-      return true;
     }
-    console.error(this.url + "消息发送失败：" + message);
-    return this;
-  }
-  heartbeat() {
-    setTimeout(() => {
-      if (this.client && this.client.readyState === 1) {
-        this.send("HeartBeat");
+    var urlParamsStr = tempArr.join("&");
+    return urlParamsStr;
+  },
+  /**
+   * 从 URL 中解析出查询参数和哈希参数，并以对象的形式返回
+   *
+   * @param href 需要解析的 URL 链接，默认为当前窗口的 URL
+   * @param needDecode 是否需要解码参数值，默认为 true
+   * @returns 返回一个包含解析后参数的对象，其中键为参数名，值为参数值
+   */
+  query2Json(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 j = 1; j < arr.length; j++) {
+            let res;
+            while (res = reg.exec(arr[j])) {
+              obj[res[1]] = needDecode ? decodeURIComponent(res[2]) : res[2];
+            }
+          }
+        }
       }
-      console.log("HeartBeat," + this.url);
-      setTimeout(this.heartbeat, 3e4);
-    }, 1e3);
+    }
+    return obj;
   }
-}
+};
 const _MqttClient = class _MqttClient extends EventDispatcher {
   constructor(url = `ws://${window.document.domain}:20007/mqtt`, config = {}) {
     super();
@@ -3461,10 +3465,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 = Util.extend(_MqttClient.defaultContext, config);
     this.options = {
       connectTimeout: this.context.MQTT_TIMEOUTM,
-      clientId: CommUtils.guid(),
+      clientId: Util.guid(),
       username: this.context.MQTT_USERNAME,
       password: this.context.MQTT_PASSWORD,
       clean: true
@@ -3657,7 +3661,7 @@ const _Storage = class _Storage {
     }
   }
 };
-__publicField(_Storage, "store", window.localStorage);
+__publicField(_Storage, "store", window.sessionStorage);
 __publicField(_Storage, "prefix", "");
 __publicField(_Storage, "_getPrefixedKey", function(key, options) {
   options = options || {};
@@ -3691,7 +3695,7 @@ export {
   ImageUtil,
   LayerType,
   LineSymbol,
-  MathUtils as MathUtil,
+  MathUtil,
   MeasureMode,
   MessageUtil,
   MqttClient,
@@ -3701,6 +3705,6 @@ export {
   Storage,
   StringUtil,
   UrlUtil,
-  CommUtils as Util,
+  Util,
   WebSocketClient
 };