@ganwei-web/gw-base-components-plus 1.0.27 → 1.0.29

package/equip-select-vue3-java/dist/index.es.js

@@ -0,0 +1,4723 @@
+import { computed as Tt, createBlock as oe, createCommentVNode as L, createElementBlock as T, createElementVNode as x, createTextVNode as be, createVNode as S, defineComponent as Ie, mergeProps as Mt, normalizeClass as Ve, normalizeStyle as Se, onActivated as Nt, onBeforeMount as Ot, onMounted as et, onUnmounted as tt, onUpdated as xt, openBlock as E, ref as W, resolveComponent as G, toDisplayString as H, toHandlers as At, watch as Q, withCtx as P, withModifiers as _e } from "vue";
+
+import "./style.css";
+function Ke(i, e) {
+  let t = Object.keys(i);
+  if (Object.getOwnPropertySymbols) {
+    let s = Object.getOwnPropertySymbols(i);
+    e && (s = s.filter(function(n) {
+      return Object.getOwnPropertyDescriptor(i, n).enumerable;
+    })), t.push.apply(t, s);
+  }
+  return t;
+}
+function Z(i) {
+  for (let e = 1; e < arguments.length; e++) {
+    var t = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? Ke(Object(t), !0).forEach(function(s) {
+      Rt(i, s, t[s]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(i, Object.getOwnPropertyDescriptors(t)) : Ke(Object(t)).forEach(function(s) {
+      Object.defineProperty(i, s, Object.getOwnPropertyDescriptor(t, s));
+    });
+  }
+  return i;
+}
+function It(i, e) {
+  if (!(i instanceof e)) { throw new TypeError("Cannot call a class as a function"); }
+}
+function We(i, e) {
+  for (let t = 0; t < e.length; t++) {
+    let s = e[t];
+    s.enumerable = s.enumerable || !1, s.configurable = !0, "value" in s && (s.writable = !0), Object.defineProperty(i, s.key, s);
+  }
+}
+function jt(i, e, t) {
+  return e && We(i.prototype, e), t && We(i, t), i;
+}
+function Rt(i, e, t) {
+  return e in i ? Object.defineProperty(i, e, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : i[e] = t, i;
+}
+function Lt(i) {
+  return Gt(i) || Bt(i) || $t(i) || Pt();
+}
+function Gt(i) {
+  if (Array.isArray(i)) { return qe(i); }
+}
+function Bt(i) {
+  if (typeof Symbol < "u" && i[Symbol.iterator] != null || i["@@iterator"] != null) { return Array.from(i); }
+}
+function $t(i, e) {
+  if (i) {
+    if (typeof i == "string") { return qe(i, e); }
+    let t = Object.prototype.toString.call(i).slice(8, -1);
+    if (t === "Object" && i.constructor && (t = i.constructor.name), t === "Map" || t === "Set") { return Array.from(i); }
+    if (t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t)) { return qe(i, e); }
+  }
+}
+function qe(i, e) {
+  (e == null || e > i.length) && (e = i.length);
+  for (var t = 0, s = new Array(e); t < e; t++) { s[t] = i[t]; }
+  return s;
+}
+function Pt() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+let z = {
+  FRONT: "FRONT",
+  // scroll up or left
+  BEHIND: "BEHIND"
+  // scroll down or right
+}, R = {
+  INIT: "INIT",
+  FIXED: "FIXED",
+  DYNAMIC: "DYNAMIC"
+}, He = 2, zt = /* @__PURE__ */ (function() {
+  function i(e, t) {
+    It(this, i), this.init(e, t);
+  }
+  return jt(i, [{
+    key: "init",
+    value: function(t, s) {
+      this.param = t, this.callUpdate = s, this.sizes = /* @__PURE__ */ new Map(), this.firstRangeTotalSize = 0, this.firstRangeAverageSize = 0, this.lastCalcIndex = 0, this.fixedSizeValue = 0, this.calcType = R.INIT, this.offset = 0, this.direction = "", this.range = /* @__PURE__ */ Object.create(null), t && this.checkRange(0, t.keeps - 1);
+    }
+  }, {
+    key: "destroy",
+    value: function() {
+      this.init(null, null);
+    }
+    // return current render range
+  }, {
+    key: "getRange",
+    value: function() {
+      let t = /* @__PURE__ */ Object.create(null);
+      return t.start = this.range.start, t.end = this.range.end, t.padFront = this.range.padFront, t.padBehind = this.range.padBehind, t;
+    }
+  }, {
+    key: "isBehind",
+    value: function() {
+      return this.direction === z.BEHIND;
+    }
+  }, {
+    key: "isFront",
+    value: function() {
+      return this.direction === z.FRONT;
+    }
+    // return start index offset
+  }, {
+    key: "getOffset",
+    value: function(t) {
+      return (t < 1 ? 0 : this.getIndexOffset(t)) + this.param.slotHeaderSize;
+    }
+  }, {
+    key: "updateParam",
+    value: function(t, s) {
+      let n = this;
+      this.param && t in this.param && (t === "uniqueIds" && this.sizes.forEach(function(r, o) {
+        s.includes(o) || n.sizes.delete(o);
+      }), this.param[t] = s);
+    }
+    // save each size map by id
+  }, {
+    key: "saveSize",
+    value: function(t, s) {
+      this.sizes.set(t, s), this.calcType === R.INIT ? (this.fixedSizeValue = s, this.calcType = R.FIXED) : this.calcType === R.FIXED && this.fixedSizeValue !== s && (this.calcType = R.DYNAMIC, delete this.fixedSizeValue), this.calcType !== R.FIXED && typeof this.firstRangeTotalSize < "u" && (this.sizes.size < Math.min(this.param.keeps, this.param.uniqueIds.length) ? (this.firstRangeTotalSize = Lt(this.sizes.values()).reduce(function(n, r) {
+        return n + r;
+      }, 0), this.firstRangeAverageSize = Math.round(this.firstRangeTotalSize / this.sizes.size)) : delete this.firstRangeTotalSize);
+    }
+    // in some special situation (e.g. length change) we need to update in a row
+    // try goiong to render next range by a leading buffer according to current direction
+  }, {
+    key: "handleDataSourcesChange",
+    value: function() {
+      let t = this.range.start;
+      this.isFront() ? t = t - He : this.isBehind() && (t = t + He), t = Math.max(t, 0), this.updateRange(this.range.start, this.getEndByStart(t));
+    }
+    // when slot size change, we also need force update
+  }, {
+    key: "handleSlotSizeChange",
+    value: function() {
+      this.handleDataSourcesChange();
+    }
+    // calculating range on scroll
+  }, {
+    key: "handleScroll",
+    value: function(t) {
+      this.direction = t < this.offset ? z.FRONT : z.BEHIND, this.offset = t, this.param && (this.direction === z.FRONT ? this.handleFront() : this.direction === z.BEHIND && this.handleBehind());
+    }
+    // ----------- public method end -----------
+  }, {
+    key: "handleFront",
+    value: function() {
+      let t = this.getScrollOvers();
+      if (!(t > this.range.start)) {
+        let s = Math.max(t - this.param.buffer, 0);
+        this.checkRange(s, this.getEndByStart(s));
+      }
+    }
+  }, {
+    key: "handleBehind",
+    value: function() {
+      let t = this.getScrollOvers();
+      t < this.range.start + this.param.buffer || this.checkRange(t, this.getEndByStart(t));
+    }
+    // return the pass overs according to current scroll offset
+  }, {
+    key: "getScrollOvers",
+    value: function() {
+      let t = this.offset - this.param.slotHeaderSize;
+      if (t <= 0) { return 0; }
+      if (this.isFixedType()) { return Math.floor(t / this.fixedSizeValue); }
+      for (var s = 0, n = 0, r = 0, o = this.param.uniqueIds.length; s <= o;) {
+        if (n = s + Math.floor((o - s) / 2), r = this.getIndexOffset(n), r === t) { return n; }
+        r < t ? s = n + 1 : r > t && (o = n - 1);
+      }
+      return s > 0 ? --s : 0;
+    }
+    // return a scroll offset from given index, can efficiency be improved more here?
+    // although the call frequency is very high, its only a superposition of numbers
+  }, {
+    key: "getIndexOffset",
+    value: function(t) {
+      if (!t) { return 0; }
+      for (var s = 0, n = 0, r = 0; r < t; r++) { n = this.sizes.get(this.param.uniqueIds[r]), s = s + (typeof n == "number" ? n : this.getEstimateSize()); }
+      return this.lastCalcIndex = Math.max(this.lastCalcIndex, t - 1), this.lastCalcIndex = Math.min(this.lastCalcIndex, this.getLastIndex()), s;
+    }
+    // is fixed size type
+  }, {
+    key: "isFixedType",
+    value: function() {
+      return this.calcType === R.FIXED;
+    }
+    // return the real last index
+  }, {
+    key: "getLastIndex",
+    value: function() {
+      return this.param.uniqueIds.length - 1;
+    }
+    // in some conditions range is broke, we need correct it
+    // and then decide whether need update to next range
+  }, {
+    key: "checkRange",
+    value: function(t, s) {
+      let n = this.param.keeps, r = this.param.uniqueIds.length;
+      r <= n ? (t = 0, s = this.getLastIndex()) : s - t < n - 1 && (t = s - n + 1), this.range.start !== t && this.updateRange(t, s);
+    }
+    // setting to a new range and rerender
+  }, {
+    key: "updateRange",
+    value: function(t, s) {
+      this.range.start = t, this.range.end = s, this.range.padFront = this.getPadFront(), this.range.padBehind = this.getPadBehind(), this.callUpdate(this.getRange());
+    }
+    // return end base on start
+  }, {
+    key: "getEndByStart",
+    value: function(t) {
+      let s = t + this.param.keeps - 1, n = Math.min(s, this.getLastIndex());
+      return n;
+    }
+    // return total front offset
+  }, {
+    key: "getPadFront",
+    value: function() {
+      return this.isFixedType() ? this.fixedSizeValue * this.range.start : this.getIndexOffset(this.range.start);
+    }
+    // return total behind offset
+  }, {
+    key: "getPadBehind",
+    value: function() {
+      let t = this.range.end, s = this.getLastIndex();
+      return this.isFixedType() ? (s - t) * this.fixedSizeValue : this.lastCalcIndex === s ? this.getIndexOffset(s) - this.getIndexOffset(t) : (s - t) * this.getEstimateSize();
+    }
+    // get the item estimate size
+  }, {
+    key: "getEstimateSize",
+    value: function() {
+      return this.isFixedType() ? this.fixedSizeValue : this.firstRangeAverageSize || this.param.estimateSize;
+    }
+  }]), i;
+})(), Dt = {
+  dataKey: {
+    type: [String, Function],
+    required: !0
+  },
+  dataSources: {
+    type: Array,
+    required: !0,
+    default: function() {
+      return [];
+    }
+  },
+  dataComponent: {
+    type: [Object, Function],
+    required: !0
+  },
+  keeps: {
+    type: Number,
+    default: 30
+  },
+  extraProps: {
+    type: Object
+  },
+  estimateSize: {
+    type: Number,
+    default: 50
+  },
+  direction: {
+    type: String,
+    default: "vertical"
+    // the other value is horizontal
+  },
+  start: {
+    type: Number,
+    default: 0
+  },
+  offset: {
+    type: Number,
+    default: 0
+  },
+  topThreshold: {
+    type: Number,
+    default: 0
+  },
+  bottomThreshold: {
+    type: Number,
+    default: 0
+  },
+  pageMode: {
+    type: Boolean,
+    default: !1
+  },
+  rootTag: {
+    type: String,
+    default: "div"
+  },
+  wrapTag: {
+    type: String,
+    default: "div"
+  },
+  wrapClass: {
+    type: String,
+    default: "wrap"
+  },
+  wrapStyle: {
+    type: Object
+  },
+  itemTag: {
+    type: String,
+    default: "div"
+  },
+  itemClass: {
+    type: String,
+    default: ""
+  },
+  itemClassAdd: {
+    type: Function
+  },
+  itemStyle: {
+    type: Object
+  },
+  headerTag: {
+    type: String,
+    default: "div"
+  },
+  headerClass: {
+    type: String,
+    default: ""
+  },
+  headerStyle: {
+    type: Object
+  },
+  footerTag: {
+    type: String,
+    default: "div"
+  },
+  footerClass: {
+    type: String,
+    default: ""
+  },
+  footerStyle: {
+    type: Object
+  },
+  itemScopedSlots: {
+    type: Object
+  }
+}, Ft = {
+  index: {
+    type: Number
+  },
+  event: {
+    type: String
+  },
+  tag: {
+    type: String
+  },
+  horizontal: {
+    type: Boolean
+  },
+  source: {
+    type: Object
+  },
+  component: {
+    type: [Object, Function]
+  },
+  uniqueKey: {
+    type: [String, Number]
+  },
+  extraProps: {
+    type: Object
+  },
+  scopedSlots: {
+    type: Object
+  }
+}, Ut = {
+  event: {
+    type: String
+  },
+  uniqueKey: {
+    type: String
+  },
+  tag: {
+    type: String
+  },
+  horizontal: {
+    type: Boolean
+  }
+}, st = function(e, t, s) {
+  let n = null, r = Tt(function() {
+    return e.horizontal ? "offsetWidth" : "offsetHeight";
+  }), o = function() {
+    return t.value ? t.value[r.value] : 0;
+  }, a = function() {
+    let c = e.event, h = e.uniqueKey, l = e.hasInitial;
+    s(c, h, o(), l);
+  };
+  et(function() {
+    typeof ResizeObserver < "u" && (n = new ResizeObserver(function() {
+      a();
+    }), t.value && n.observe(t.value));
+  }), xt(function() {
+    a();
+  }), tt(function() {
+    n && (n.disconnect(), n = null);
+  });
+}, Vt = Ie({
+  name: "VirtualListItem",
+  props: Ft,
+  emits: ["itemResize"],
+  setup: function(e, t) {
+    let s = t.emit, n = W(null);
+    return st(e, n, s), function() {
+      let r = e.tag, o = e.component, a = e.extraProps, u = a === void 0 ? {} : a, c = e.index, h = e.source, l = e.scopedSlots, m = l === void 0 ? {} : l, w = e.uniqueKey, v = Z(Z({}, u), {}, {
+        source: h,
+        index: c
+      });
+      return S(r, {
+        key: w,
+        ref: n
+      }, {
+        default: function() {
+          return [S(o, Z(Z({}, v), {}, {
+            scopedSlots: m
+          }), null)];
+        }
+      });
+    };
+  }
+}), Je = Ie({
+  name: "VirtualListSlot",
+  props: Ut,
+  emits: ["slotResize"],
+  setup: function(e, t) {
+    let s = t.slots, n = t.emit, r = W(null);
+    return st(e, r, n), function() {
+      let o, a = e.tag, u = e.uniqueKey;
+      return S(a, {
+        ref: r,
+        key: u
+      }, {
+        default: function() {
+          return [(o = s.default) === null || o === void 0 ? void 0 : o.call(s)];
+        }
+      });
+    };
+  }
+}), J;
+(function(i) {
+  i.ITEM = "itemResize", i.SLOT = "slotResize";
+})(J || (J = {}));
+let D;
+(function(i) {
+  i.HEADER = "thead", i.FOOTER = "tfoot";
+})(D || (D = {}));
+let Kt = Ie({
+  name: "VirtualList",
+  props: Dt,
+  setup: function(e, t) {
+    let s = t.emit, n = t.slots, r = t.expose, o = e.direction === "horizontal", a = o ? "scrollLeft" : "scrollTop", u = W(null), c = W(), h = W(null), l;
+    Q(function() {
+      return e.dataSources.length;
+    }, function() {
+      l.updateParam("uniqueIds", $e()), l.handleDataSourcesChange();
+    }), Q(function() {
+      return e.keeps;
+    }, function(f) {
+      l.updateParam("keeps", f), l.handleSlotSizeChange();
+    }), Q(function() {
+      return e.start;
+    }, function(f) {
+      pe(f);
+    }), Q(function() {
+      return e.offset;
+    }, function(f) {
+      return B(f);
+    });
+    var m = function(d) {
+      return l.sizes.get(d);
+    }, w = function() {
+      return e.pageMode ? document.documentElement[a] || document.body[a] : c.value ? Math.ceil(c.value[a]) : 0;
+    }, v = function() {
+      let d = o ? "clientWidth" : "clientHeight";
+      return e.pageMode ? document.documentElement[d] || document.body[d] : c.value ? Math.ceil(c.value[d]) : 0;
+    }, I = function() {
+      let d = o ? "scrollWidth" : "scrollHeight";
+      return e.pageMode ? document.documentElement[d] || document.body[d] : c.value ? Math.ceil(c.value[d]) : 0;
+    }, St = function(d, g, b, C) {
+      s("scroll", C, l.getRange()), l.isFront() && e.dataSources.length && d - e.topThreshold <= 0 ? s("totop") : l.isBehind() && d + g + e.bottomThreshold >= b && s("tobottom");
+    }, de = function(d) {
+      let g = w(), b = v(), C = I();
+      g < 0 || g + b > C + 1 || !C || (l.handleScroll(g), St(g, b, C, d));
+    }, $e = function() {
+      let d = e.dataKey, g = e.dataSources, b = g === void 0 ? [] : g;
+      return b.map(function(C) {
+        return typeof d == "function" ? d(C) : C[d];
+      });
+    }, Ct = function(d) {
+      u.value = d;
+    }, Et = function() {
+      l = new zt({
+        slotHeaderSize: 0,
+        slotFooterSize: 0,
+        keeps: e.keeps,
+        estimateSize: e.estimateSize,
+        buffer: Math.round(e.keeps / 3),
+        // recommend for a third of keeps
+        uniqueIds: $e()
+      }, Ct), u.value = l.getRange();
+    }, pe = function(d) {
+      if (d >= e.dataSources.length - 1) { ze(); } else {
+        let g = l.getOffset(d);
+        B(g);
+      }
+    }, B = function(d) {
+      e.pageMode ? (document.body[a] = d, document.documentElement[a] = d) : c.value && (c.value[a] = d);
+    }, kt = function() {
+      for (var d = [], g = u.value, b = g.start, C = g.end, fe = e.dataSources, $ = e.dataKey, ge = e.itemClass, me = e.itemTag, ye = e.itemStyle, we = e.extraProps, Y = e.dataComponent, X = e.itemScopedSlots, N = b; N <= C; N++) {
+        let j = fe[N];
+        if (j) {
+          let U = typeof $ == "function" ? $(j) : j[$];
+          typeof U == "string" || typeof U == "number" ? d.push(S(Vt, {
+            index: N,
+            tag: me,
+            event: J.ITEM,
+            horizontal: o,
+            uniqueKey: U,
+            source: j,
+            extraProps: we,
+            component: Y,
+            scopedSlots: X,
+            style: ye,
+            class: "".concat(ge).concat(e.itemClassAdd ? " " + e.itemClassAdd(N) : ""),
+            onItemResize: vt
+          }, null)) : console.warn("Cannot get the data-key '".concat($, "' from data-sources."));
+        } else { console.warn("Cannot get the index '".concat(N, "' from data-sources.")); }
+      }
+      return d;
+    }, vt = function(d, g) {
+      l.saveSize(d, g), s("resized", d, g);
+    }, Pe = function(d, g, b) {
+      d === D.HEADER ? l.updateParam("slotHeaderSize", g) : d === D.FOOTER && l.updateParam("slotFooterSize", g), b && l.handleSlotSizeChange();
+    }, ze = function f() {
+      if (h.value) {
+        let d = h.value[o ? "offsetLeft" : "offsetTop"];
+        B(d), setTimeout(function() {
+          w() + v() < I() && f();
+        }, 3);
+      }
+    }, _t = function() {
+      if (c.value) {
+        let d = c.value.getBoundingClientRect(), g = c.value.ownerDocument.defaultView, b = o ? d.left + g.pageXOffset : d.top + g.pageYOffset;
+        l.updateParam("slotHeaderSize", b);
+      }
+    }, qt = function() {
+      return l.sizes.size;
+    };
+    return Ot(function() {
+      Et();
+    }), Nt(function() {
+      B(l.offset);
+    }), et(function() {
+      e.start ? pe(e.start) : e.offset && B(e.offset), e.pageMode && (_t(), document.addEventListener("scroll", de, {
+        passive: !1
+      }));
+    }), tt(function() {
+      l.destroy(), e.pageMode && document.removeEventListener("scroll", de);
+    }), r({
+      scrollToBottom: ze,
+      getSizes: qt,
+      getSize: m,
+      getOffset: w,
+      getScrollSize: I,
+      getClientSize: v,
+      scrollToOffset: B,
+      scrollToIndex: pe
+    }), function() {
+      let f = e.pageMode, d = e.rootTag, g = e.wrapTag, b = e.wrapClass, C = e.wrapStyle, fe = e.headerTag, $ = e.headerClass, ge = e.headerStyle, me = e.footerTag, ye = e.footerClass, we = e.footerStyle, Y = u.value, X = Y.padFront, N = Y.padBehind, j = {
+        padding: o ? "0px ".concat(N, "px 0px ").concat(X, "px") : "".concat(X, "px 0px ").concat(N, "px")
+      }, U = C ? Object.assign({}, C, j) : j, De = n.header, Fe = n.footer;
+      return S(d, {
+        ref: c,
+        onScroll: !f && de
+      }, {
+        default: function() {
+          return [De && S(Je, {
+            class: $,
+            style: ge,
+            tag: fe,
+            event: J.SLOT,
+            uniqueKey: D.HEADER,
+            onSlotResize: Pe
+          }, {
+            default: function() {
+              return [De()];
+            }
+          }), S(g, {
+            class: b,
+            style: U
+          }, {
+            default: function() {
+              return [kt()];
+            }
+          }), Fe && S(Je, {
+            class: ye,
+            style: we,
+            tag: me,
+            event: J.SLOT,
+            uniqueKey: D.FOOTER,
+            onSlotResize: Pe
+          }, {
+            default: function() {
+              return [Fe()];
+            }
+          }), S("div", {
+            ref: h,
+            style: {
+              width: o ? "0px" : "100%",
+              height: o ? "100%" : "0px"
+            }
+          }, null)];
+        }
+      });
+    };
+  }
+});
+class Wt {
+  // 分组节点扁平化对象、设备扁平化对象、window缓存设备扁平化对象
+  constructor(e, t, s) {
+    this.groupNodeObject = e, this.nodesMap = t, this.controlObject = s;
+  }
+  // 增加映射
+  addNodesMap(e) {
+    e && e.forEach((t) => {
+      this.nodesMap[t.key] = t;
+    });
+  }
+  // 移除映射
+  removeNodesMap(e) {
+    e && e.forEach((t) => {
+      delete this.nodesMap[t.key];
+    });
+  }
+  // 回收所有分组节点缓存
+  recycleAllNodeCache(e) {
+    for (let t in this.groupNodeObject) { this.groupNodeObject[t].expand = !1, this.groupNodeObject[t].count = 0, this.recycleGroupCache(this.groupNodeObject[t].key), e && delete this.groupNodeObject[t]; }
+  }
+  // 回收分组节点内存
+  recycleGroupCache(e) {
+    if (this.groupNodeObject[e]) {
+      this.groupNodeObject[e].children = [], this.removeNodesMap(this.groupNodeObject[e].equips), this.groupNodeObject[e].equips = [], this.groupNodeObject[e].equips.length = 0, this.groupNodeObject[e].expand = !1;
+      for (let t in this.groupNodeObject) { this.groupNodeObject[t].groupId == e && this.recycleGroupCache(this.groupNodeObject[t].key); }
+    }
+  }
+  // 关闭兄弟分组节点及回收内存
+  closeBrotherNode(e) {
+    if (e && this.groupNodeObject[e]) {
+      let t = this.groupNodeObject[e].groupId;
+      for (let s in this.groupNodeObject) { this.groupNodeObject[s].groupId == t && this.groupNodeObject[s].key != e && this.groupNodeObject[s].expand && (this.groupNodeObject[s].expand = !1, this.recycleGroupCache(this.groupNodeObject[s].key)); }
+    }
+  }
+}
+class ue {
+  constructor() {
+    this.window = window;
+    try {
+      window.top.equipGroup, this.window = window.top;
+    } catch {
+      this.window = window;
+    }
+  }
+}
+const it = {
+  data() {
+    return {
+      window: null
+    };
+  },
+  created() {
+    this.window = window;
+    try {
+      window.top.equipGroup, this.window = window.top;
+    } catch {
+      this.window = window;
+    }
+  }
+};
+class Ht extends ue {
+  constructor(e, t, s, n, r, o) {
+    super(), this.equipControllObject = s, this.groupNodeObject = e, this.nodesMap = t, this.controlObject = n, this.equipCheckObject = r, this.isSearchStatus = !1, this.searchStatusGroupObject = {}, this.aliasName = o;
+  }
+  resetCheckedStatus() {
+    Object.values(this.nodesMap).forEach((e) => {
+      this.setCheckStatus(e.key, !1, !1);
+    }), Object.keys(this.equipCheckObject).forEach((e) => delete this.equipCheckObject[e]), this.updateGroupCheckStatus();
+  }
+
+  /**
+   * 搜索状态下,更新分组选中状态
+   * 新方案：直接调用 updateGroupCheckStatus 重新计算
+   */
+  reComputedCheckNum(e) {
+    this.isSearchStatus = e, this.updateGroupCheckStatus();
+  }
+  // 根据传过来的设备选中数据、回显选中状态
+  /**
+   * 支持两种数据格式：
+   *   格式1：纯 equipNo 数组，如 [1, 2, 3]，选中该设备在所有分组下的实例
+   *   格式2：{ groupId: [equipNo1, equipNo2] } 对象，如 { 2: [1, 2], 3: [5] }，只选中指定分组下的设备
+   *
+   * 注意：此方法只负责将选中状态写入 equipCheckObject，不调用 updateGroupCheckStatus。
+   * 分组状态的更新由调用方在合适的时机（数据就绪后）统一调用。
+   */
+  updateCheckedStatusWithEquips(e) {
+    Object.keys(this.equipCheckObject).forEach((s) => {
+      s.split("-").length === 2 && delete this.equipCheckObject[s];
+    });
+    let t = [];
+    Array.isArray(e) ? t = e.map((s) => ({ equipNo: s, groupId: null })) : e !== null && typeof e == "object" && Object.keys(e).forEach((s) => {
+      Array.isArray(e[s]) && e[s].forEach((n) => {
+        t.push({ equipNo: n, groupId: Number(s) });
+      });
+    });
+    for (let s = 0, n = t.length; s < n; s++) {
+      const { equipNo: r, groupId: o } = t[s];
+      if (o != null) {
+        const a = `${o}-${r}`;
+        this.setEquipCheckObject(a, !0, !1, o), this.setCheckStatus(a, !0, !1), this.updateExpandControlCheckStatus(o, r);
+      } else {
+        const a = this.window.equipCache && this.window.equipCache[r];
+        a && (a.groupIds || (a.groupId ? [a.groupId] : [])).forEach((c) => {
+          const h = `${c}-${r}`;
+          this.setEquipCheckObject(h, !0, !1, c), this.setCheckStatus(h, !0, !1), this.updateExpandControlCheckStatus(c, r);
+        });
+      }
+    }
+  }
+  // 更新展开的设备控制项选中状态
+  updateExpandControlCheckStatus(e, t) {
+    let s = this.nodesMap[`${e}-${t}`];
+    s && s.settings && s.settings.length && s.settings.forEach((n) => {
+      this.nodesMap[`${e}-${t}-${n.setNo}`] && this.setCheckStatus(`${e}-${t}-${n.setNo}`, !0, !1);
+    });
+  }
+  // 根据传过来的设备控制项，回显设备分组选中状态
+  /**
+   * 注意：此方法只负责将控制项状态写入 equipControllObject/equipCheckObject，不调用 updateGroupCheckStatus。
+   * 分组状态的更新由调用方在合适的时机（数据就绪后）统一调用。
+   */
+  updateCheckedStatusWithControls(e) {
+    for (let t = 0, s = e.length; t < s; t++) {
+      let n = e[t], r, o, a;
+      if (n !== null && typeof n == "object" && !Array.isArray(n)) { r = n.equipNo, o = n.setNo, a = n.groupId; } else {
+        let c = n.split(".");
+        r = c[0], o = c[1], a = null;
+      }
+      this.equipControllObject[r] || (this.equipControllObject[r] = []), this.equipControllObject[r].push(Number(o));
+      const u = this.window.equipCache && this.window.equipCache[r];
+      u && (a != null ? [a] : u.groupIds || (u.groupId ? [u.groupId] : [])).forEach((h) => {
+        const l = `${h}-${r}`, m = `${h}-${r}-${o}`;
+        this.nodesMap[m] && this.setCheckStatus(m, !0, !1), this.nodesMap[l] && this.setCheckStatus(l, !1, !0), this.setEquipCheckObject(l, !1, !0, h);
+      });
+    }
+  }
+  // 更新分组选中状态------------------------------------------------------------------------------------
+  /**
+   * 新方案：基于 equipCheckObject 实时计算分组状态，而不是依赖中间状态
+   * 优点：状态判断准确，不会累积误差
+   */
+  updateGroupCheckStatus() {
+    this.getSortedGroupsByLevel().forEach((t) => {
+      const s = this.computeGroupStatus(t.key);
+      this.setCheckStatus(t.key, s.checked, s.indeterminate), t.equipSelectCount = s.selectCount;
+    });
+  }
+  // 按层级排序分组（从深到浅，确保子分组先处理）
+  getSortedGroupsByLevel() {
+    return Object.values(this.groupNodeObject).sort((e, t) => t.level - e.level);
+  }
+  // 计算单个分组的选中状态
+  /**
+   * @returns {Object} { checked, indeterminate, selectCount }
+   */
+  computeGroupStatus(e) {
+    const t = this.groupNodeObject[e];
+    if (!t) { return { checked: !1, indeterminate: !1, selectCount: 0 }; }
+    let s = this.isSearchStatus ? this.window[`group-${e}-search`] || [] : this.window[`group-${e}${this.aliasName}`] || [];
+    !this.isSearchStatus && s.length === 0 && this.aliasName && (s = this.window[`group-${e}`] || []);
+    let n = 0, r = s.length || t.equipCount || 0;
+    if (s.length > 0) {
+ s.forEach((m) => {
+        const w = m.equipNo || m.id, v = `${e}-${w}`;
+        this.equipCheckObject[v] && this.equipCheckObject[v].checked && n++;
+      }); 
+} else {
+      const m = `${e}-`;
+      Object.keys(this.equipCheckObject).forEach((w) => {
+        w.startsWith(m) && w.split("-").length === 2 && this.equipCheckObject[w].checked && n++;
+      });
+    }
+    let o = 0, a = 0, u = !1, c = !1;
+    t.groups && t.groups.length > 0 && t.groups.forEach((m) => {
+      const w = this.nodesMap[m.key], v = this.groupNodeObject[m.key];
+      if (w) {
+        const I = w.count || (v ? v.equipCount : 0) || 0;
+        a += I, w.checked ? (o += I, u = !0) : w.indeterminate ? (c = !0, u = !0) : c = !0;
+      }
+    });
+    const h = n + o;
+    let l = t.count || 0;
+    return l === 0 && (l = r + a), h === 0 && !u ? { checked: !1, indeterminate: !1, selectCount: 0 } : l === 0 ? h > 0 ? { checked: !1, indeterminate: !0, selectCount: h } : { checked: !1, indeterminate: !1, selectCount: 0 } : h === 0 ? u ? { checked: !1, indeterminate: !0, selectCount: h } : { checked: !1, indeterminate: !1, selectCount: 0 } : h === l && !c ? { checked: !0, indeterminate: !1, selectCount: h } : { checked: !1, indeterminate: !0, selectCount: h };
+  }
+  // 设置设备控制项状态
+  setControlStatus(e, t, s, n) {
+    e && e.forEach((r) => {
+      this.nodesMap[`${t}-${s}-${r.setNo}`] && this.setCheckStatus(`${t}-${s}-${r.setNo}`, n, !1);
+    });
+  }
+  // 更新设备控制项选中状态
+  /**
+   *  改造点：controlObject 键格式统一为 ${groupId}-${equipNo}
+   *  */
+  updateControlCheckStatus() {
+    Object.keys(this.controlObject).forEach((e) => {
+      const [t, s] = e.split("-");
+      let n = this.nodesMap[e];
+      if (n) {
+ if (n.checked) {
+          let r = n.settings;
+          this.setControlStatus(r, t, s, !0);
+        } else if (!n.checked && !n.indeterminate) {
+          let r = n.settings;
+          this.setControlStatus(r, t, s, !1);
+        } else {
+ this.equipControllObject[s] && this.equipControllObject[s].forEach((r) => {
+            let o = `${t}-${s}-${r}`;
+            this.nodesMap[o] && this.setCheckStatus(o, !0, !1);
+          }); 
+} 
+}
+    });
+  }
+  // 获取选中的分组
+  getGroupChecked() {
+    let e = [];
+    return Object.keys(this.groupNodeObject).forEach((t) => {
+      this.groupNodeObject[t].checked && e.push(t);
+    }), e;
+  }
+  // 获取选中设备
+  getEquipSelectd() {
+    let e = [], t = /* @__PURE__ */ new Set();
+    return Object.keys(this.equipCheckObject).forEach((s) => {
+      if (this.equipCheckObject[s].checked) {
+ try {
+          t.add(Number(s.split("-")[1]));
+        } catch (n) {
+          console.log(n);
+        } 
+}
+    }), e = Array.from(t), e;
+  }
+  // 获取选中设备（携带分组）
+  getEquipGroupSelectd() {
+    let e = Object.keys(this.equipCheckObject);
+    return e.length > 0 && (e = this.returnArray(e)), e;
+  }
+  returnArray(e) {
+    const t = [];
+    return e.forEach((s) => {
+      const n = s.split("-");
+      if (n.length >= 2) {
+        const r = parseInt(n[0]), o = parseInt(n[1]);
+        !isNaN(r) && !isNaN(o) && t.push({ groupId: r, equipNo: o });
+      }
+    }), t;
+  }
+  // 解析设备数组为分组格式
+  parseEquipArrayToGroupFormat(e) {
+    const t = {};
+    return e.forEach((s) => {
+      const [n, r] = s.split("-"), o = parseInt(n);
+      isNaN(o) || (t[o] || (t[o] = []), t[o].push(parseInt(r)));
+    }), t;
+  }
+  // 获取选中的设备控制项
+  getControlSelected() {
+    let e = [];
+    return Object.keys(this.equipControllObject).forEach((t) => {
+      e.push(...this.equipControllObject[t].map((s) => `${t}.${s}`));
+    }), e;
+  }
+  // 点击选中
+  /**
+   *  1:如果是分组选择，触发分组选中事件
+   *  2:如果是设备选择，触发设备选中事件
+   *  3:如果是设备控制项选择，触发设备控制项选中事件
+   *  */
+  onChecked(e, t) {
+    this.isSearchStatus = t || !1, e.isGroup && !e.isEquip ? this.selectGroup(e) : e.isEquip ? this.selectEquip(e) : e.isSetting && this.selectControl(e);
+  }
+  // 从全局映射中，设置节点选中状态
+  setCheckStatus(e, t, s, n) {
+    this.nodesMap[e] && (this.nodesMap[e].checked = t, this.nodesMap[e].isGroup && (this.nodesMap[e].indeterminate = s));
+  }
+  // 保存全局设备选中状态
+  setEquipCheckObject(e, t, s, n) {
+    this.equipCheckObject[e] || (this.equipCheckObject[e] = {}), this.equipCheckObject[e].checked = t, this.equipCheckObject[e].indeterminate = s, this.equipCheckObject[e].groupId = n, !t && !s && delete this.equipCheckObject[e];
+  }
+  // 触发分组选择
+  selectGroup(e) {
+    this.updateAllEquipStatus(e.key, e.checked), this.updateControlCheckStatus(), this.updateGroupCheckStatus();
+  }
+  // 更新分组下所有设备的选中状态
+  updateAllEquipStatus(e, t) {
+    const s = this.groupNodeObject[e];
+    if (!s) { return; }
+    let n = this.isSearchStatus ? this.window[`group-${e}-search`] || [] : this.window[`group-${e}${this.aliasName}`] || [];
+    !this.isSearchStatus && n.length === 0 && this.aliasName && (n = this.window[`group-${e}`] || []), n.forEach((r) => {
+      const o = r.equipNo || r.id, a = `${e}-${o}`;
+      this.setEquipCheckObject(a, t, !1, e), this.nodesMap[a] && this.setCheckStatus(a, t, !1);
+    }), s.groups && s.groups.length > 0 && s.groups.forEach((r) => {
+      this.updateAllEquipStatus(r.key, t);
+    });
+  }
+  // 触发设备选择
+  /**
+   * 新方案：简化逻辑，只更新设备状态，分组状态由 updateGroupCheckStatus 统一计算
+   */
+  selectEquip(e) {
+    const t = `${e.groupId}-${e.equipNo}`;
+    this.setEquipCheckObject(t, e.checked, !1, e.groupId), this.nodesMap[t] && this.setCheckStatus(t, e.checked, !1), this.updateControlCheckStatus(), this.updateGroupCheckStatus();
+  }
+  // 更新设备控制项存储
+  updateEquipControl(e, t, s) {
+    this.equipControllObject[e] || (this.equipControllObject[e] = []), s ? this.equipControllObject[e].push(t) : this.equipControllObject[e] = this.equipControllObject[e].filter((n) => n != t);
+  }
+  // 触发控制项选择
+  /**
+   * 新方案：简化逻辑，只更新控制项和设备状态，分组状态由 updateGroupCheckStatus 统一计算
+   */
+  selectControl(e) {
+    const t = `${e.groupId}-${e.equipNo}`, s = `${e.groupId}-${e.equipNo}-${e.setNo}`, n = this.nodesMap[t];
+    if (!n) { return; }
+    this.updateEquipControl(e.equipNo, e.setNo, e.checked), this.setCheckStatus(s, e.checked, !1);
+    const r = n.settings || [], o = this.equipControllObject[e.equipNo] || [], a = r.length, u = o.length;
+    e.checked ? u === a ? (delete this.equipControllObject[e.equipNo], this.setEquipCheckObject(t, !0, !1, e.groupId), this.setCheckStatus(t, !0, !1)) : (this.setEquipCheckObject(t, !1, !0, e.groupId), this.setCheckStatus(t, !1, !0)) : u === 0 ? (this.setEquipCheckObject(t, !1, !1, e.groupId), this.setCheckStatus(t, !1, !1)) : (this.setEquipCheckObject(t, !1, !0, e.groupId), this.setCheckStatus(t, !1, !0)), this.updateGroupCheckStatus();
+  }
+}
+class Jt extends ue {
+  // 分组节点扁平化对象、设备扁平化对象、window缓存设备扁平化对象
+  constructor(e, t) {
+    super(), this.aliasName = t, this.groupNodeObject = e;
+  }
+  // 重新计算分组设备数量
+  resetGroupNum(e, t, s) {
+    this.clearAllEquipNum();
+    const n = Object.keys(this.groupNodeObject).sort((r, o) => (this.groupNodeObject[o].level || 0) - (this.groupNodeObject[r].level || 0));
+    for (let r of n) {
+      let o = [];
+      e ? o = this.window[`group-${r}-search`] : o = this.window[`group-${r}${this.aliasName}`], t && o && o.length && (o = o.filter((u) => s[u.equipNo] === 2));
+      let a = o ? o.length : 0;
+      this.groupNodeObject[r].equipCount = a, this.setGroupNum(r, a);
+    }
+  }
+  clearAllEquipNum() {
+    for (let e in this.groupNodeObject) { this.groupNodeObject[e].equipCount = 0, this.groupNodeObject[e].count = 0; }
+  }
+  // 设置分组设备数量
+  setGroupNum(e, t) {
+    this.groupNodeObject[e] && (this.groupNodeObject[e].count = Number(this.groupNodeObject[e].count) + Number(t), this.setGroupNum(this.groupNodeObject[e].groupId, t));
+  }
+  // 获取设备总数
+  getAllEquipsNum() {
+    let e = 0;
+    for (let t in this.groupNodeObject) { this.window[`group-${this.groupNodeObject[t].key}${this.aliasName}`] && (e = e + this.window[`group-${this.groupNodeObject[t].key}${this.aliasName}`].length); }
+    return e;
+  }
+}
+const O = /* @__PURE__ */ Object.create(null);
+O.open = "0";
+O.close = "1";
+O.ping = "2";
+O.pong = "3";
+O.message = "4";
+O.upgrade = "5";
+O.noop = "6";
+const se = /* @__PURE__ */ Object.create(null);
+Object.keys(O).forEach((i) => {
+  se[O[i]] = i;
+});
+const Oe = { type: "error", data: "parser error" }, nt = typeof Blob == "function" || typeof Blob < "u" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]", rt = typeof ArrayBuffer == "function", ot = (i) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(i) : i && i.buffer instanceof ArrayBuffer, je = ({ type: i, data: e }, t, s) => nt && e instanceof Blob ? t ? s(e) : Ye(e, s) : rt && (e instanceof ArrayBuffer || ot(e)) ? t ? s(e) : Ye(new Blob([e]), s) : s(O[i] + (e || "")), Ye = (i, e) => {
+  const t = new FileReader();
+  return t.onload = function() {
+    const s = t.result.split(",")[1];
+    e("b" + (s || ""));
+  }, t.readAsDataURL(i);
+};
+function Xe(i) {
+  return i instanceof Uint8Array ? i : i instanceof ArrayBuffer ? new Uint8Array(i) : new Uint8Array(i.buffer, i.byteOffset, i.byteLength);
+}
+let Ce;
+function Yt(i, e) {
+  if (nt && i.data instanceof Blob) { return i.data.arrayBuffer().then(Xe).then(e); }
+  if (rt && (i.data instanceof ArrayBuffer || ot(i.data))) { return e(Xe(i.data)); }
+  je(i, !1, (t) => {
+    Ce || (Ce = new TextEncoder()), e(Ce.encode(t));
+  });
+}
+const Qe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", K = typeof Uint8Array > "u" ? [] : new Uint8Array(256);
+for (let i = 0; i < Qe.length; i++) { K[Qe.charCodeAt(i)] = i; }
+const Xt = (i) => {
+  let e = i.length * 0.75, t = i.length, s, n = 0, r, o, a, u;
+  i[i.length - 1] === "=" && (e--, i[i.length - 2] === "=" && e--);
+  const c = new ArrayBuffer(e), h = new Uint8Array(c);
+  for (s = 0; s < t; s += 4) { r = K[i.charCodeAt(s)], o = K[i.charCodeAt(s + 1)], a = K[i.charCodeAt(s + 2)], u = K[i.charCodeAt(s + 3)], h[n++] = r << 2 | o >> 4, h[n++] = (o & 15) << 4 | a >> 2, h[n++] = (a & 3) << 6 | u & 63; }
+  return c;
+}, Qt = typeof ArrayBuffer == "function", Re = (i, e) => {
+  if (typeof i != "string") {
+ return {
+      type: "message",
+      data: at(i, e)
+    }; 
+}
+  const t = i.charAt(0);
+  return t === "b" ? {
+    type: "message",
+    data: Zt(i.substring(1), e)
+  } : se[t] ? i.length > 1 ? {
+    type: se[t],
+    data: i.substring(1)
+  } : {
+    type: se[t]
+  } : Oe;
+}, Zt = (i, e) => {
+  if (Qt) {
+    const t = Xt(i);
+    return at(t, e);
+  } return { base64: !0, data: i };
+}, at = (i, e) => {
+  switch (e) {
+    case "blob":
+      return i instanceof Blob ? i : new Blob([i]);
+    case "arraybuffer":
+    default:
+      return i instanceof ArrayBuffer ? i : i.buffer;
+  }
+}, ut = String.fromCharCode(30), es = (i, e) => {
+  const t = i.length, s = new Array(t);
+  let n = 0;
+  i.forEach((r, o) => {
+    je(r, !1, (a) => {
+      s[o] = a, ++n === t && e(s.join(ut));
+    });
+  });
+}, ts = (i, e) => {
+  const t = i.split(ut), s = [];
+  for (let n = 0; n < t.length; n++) {
+    const r = Re(t[n], e);
+    if (s.push(r), r.type === "error") { break; }
+  }
+  return s;
+};
+function ss() {
+  return new TransformStream({
+    transform(i, e) {
+      Yt(i, (t) => {
+        const s = t.length;
+        let n;
+        if (s < 126) { n = new Uint8Array(1), new DataView(n.buffer).setUint8(0, s); } else if (s < 65536) {
+          n = new Uint8Array(3);
+          const r = new DataView(n.buffer);
+          r.setUint8(0, 126), r.setUint16(1, s);
+        } else {
+          n = new Uint8Array(9);
+          const r = new DataView(n.buffer);
+          r.setUint8(0, 127), r.setBigUint64(1, BigInt(s));
+        }
+        i.data && typeof i.data != "string" && (n[0] |= 128), e.enqueue(n), e.enqueue(t);
+      });
+    }
+  });
+}
+let Ee;
+function ee(i) {
+  return i.reduce((e, t) => e + t.length, 0);
+}
+function te(i, e) {
+  if (i[0].length === e) { return i.shift(); }
+  const t = new Uint8Array(e);
+  let s = 0;
+  for (let n = 0; n < e; n++) { t[n] = i[0][s++], s === i[0].length && (i.shift(), s = 0); }
+  return i.length && s < i[0].length && (i[0] = i[0].slice(s)), t;
+}
+function is(i, e) {
+  Ee || (Ee = new TextDecoder());
+  const t = [];
+  let s = 0, n = -1, r = !1;
+  return new TransformStream({
+    transform(o, a) {
+      for (t.push(o); ;) {
+        if (s === 0) {
+          if (ee(t) < 1) { break; }
+          const u = te(t, 1);
+          r = (u[0] & 128) === 128, n = u[0] & 127, n < 126 ? s = 3 : n === 126 ? s = 1 : s = 2;
+        } else if (s === 1) {
+          if (ee(t) < 2) { break; }
+          const u = te(t, 2);
+          n = new DataView(u.buffer, u.byteOffset, u.length).getUint16(0), s = 3;
+        } else if (s === 2) {
+          if (ee(t) < 8) { break; }
+          const u = te(t, 8), c = new DataView(u.buffer, u.byteOffset, u.length), h = c.getUint32(0);
+          if (h > Math.pow(2, 53 - 32) - 1) {
+            a.enqueue(Oe);
+            break;
+          }
+          n = h * Math.pow(2, 32) + c.getUint32(4), s = 3;
+        } else {
+          if (ee(t) < n) { break; }
+          const u = te(t, n);
+          a.enqueue(Re(r ? u : Ee.decode(u), e)), s = 0;
+        }
+        if (n === 0 || n > i) {
+          a.enqueue(Oe);
+          break;
+        }
+      }
+    }
+  });
+}
+const ht = 4;
+function y(i) {
+  if (i) { return ns(i); }
+}
+function ns(i) {
+  for (let e in y.prototype) { i[e] = y.prototype[e]; }
+  return i;
+}
+y.prototype.on = y.prototype.addEventListener = function(i, e) {
+  return this._callbacks = this._callbacks || {}, (this._callbacks["$" + i] = this._callbacks["$" + i] || []).push(e), this;
+};
+y.prototype.once = function(i, e) {
+  function t() {
+    this.off(i, t), e.apply(this, arguments);
+  }
+  return t.fn = e, this.on(i, t), this;
+};
+y.prototype.off = y.prototype.removeListener = y.prototype.removeAllListeners = y.prototype.removeEventListener = function(i, e) {
+  if (this._callbacks = this._callbacks || {}, arguments.length == 0) { return this._callbacks = {}, this; }
+  let t = this._callbacks["$" + i];
+  if (!t) { return this; }
+  if (arguments.length == 1) { return delete this._callbacks["$" + i], this; }
+  for (var s, n = 0; n < t.length; n++) {
+ if (s = t[n], s === e || s.fn === e) {
+      t.splice(n, 1);
+      break;
+    } 
+}
+  return t.length === 0 && delete this._callbacks["$" + i], this;
+};
+y.prototype.emit = function(i) {
+  this._callbacks = this._callbacks || {};
+  for (var e = new Array(arguments.length - 1), t = this._callbacks["$" + i], s = 1; s < arguments.length; s++) { e[s - 1] = arguments[s]; }
+  if (t) {
+    t = t.slice(0);
+    for (var s = 0, n = t.length; s < n; ++s) { t[s].apply(this, e); }
+  }
+  return this;
+};
+y.prototype.emitReserved = y.prototype.emit;
+y.prototype.listeners = function(i) {
+  return this._callbacks = this._callbacks || {}, this._callbacks["$" + i] || [];
+};
+y.prototype.hasListeners = function(i) {
+  return !!this.listeners(i).length;
+};
+const he = (() => typeof Promise == "function" && typeof Promise.resolve == "function" ? (e) => Promise.resolve().then(e) : (e, t) => t(e, 0))(), k = (() => typeof self < "u" ? self : typeof window < "u" ? window : Function("return this")())(), rs = "arraybuffer";
+function ct(i, ...e) {
+  return e.reduce((t, s) => (i.hasOwnProperty(s) && (t[s] = i[s]), t), {});
+}
+const os = k.setTimeout, as = k.clearTimeout;
+function ce(i, e) {
+  e.useNativeTimers ? (i.setTimeoutFn = os.bind(k), i.clearTimeoutFn = as.bind(k)) : (i.setTimeoutFn = k.setTimeout.bind(k), i.clearTimeoutFn = k.clearTimeout.bind(k));
+}
+const us = 1.33;
+function hs(i) {
+  return typeof i == "string" ? cs(i) : Math.ceil((i.byteLength || i.size) * us);
+}
+function cs(i) {
+  let e = 0, t = 0;
+  for (let s = 0, n = i.length; s < n; s++) { e = i.charCodeAt(s), e < 128 ? t += 1 : e < 2048 ? t += 2 : e < 55296 || e >= 57344 ? t += 3 : (s++, t += 4); }
+  return t;
+}
+function lt() {
+  return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
+}
+function ls(i) {
+  let e = "";
+  for (let t in i) { i.hasOwnProperty(t) && (e.length && (e += "&"), e += encodeURIComponent(t) + "=" + encodeURIComponent(i[t])); }
+  return e;
+}
+function ds(i) {
+  let e = {}, t = i.split("&");
+  for (let s = 0, n = t.length; s < n; s++) {
+    let r = t[s].split("=");
+    e[decodeURIComponent(r[0])] = decodeURIComponent(r[1]);
+  }
+  return e;
+}
+class ps extends Error {
+  constructor(e, t, s) {
+    super(e), this.description = t, this.context = s, this.type = "TransportError";
+  }
+}
+class Le extends y {
+
+  /**
+   * Transport abstract constructor.
+   *
+   * @param {Object} opts - options
+   * @protected
+   */
+  constructor(e) {
+    super(), this.writable = !1, ce(this, e), this.opts = e, this.query = e.query, this.socket = e.socket, this.supportsBinary = !e.forceBase64;
+  }
+
+  /**
+   * Emits an error.
+   *
+   * @param {String} reason
+   * @param description
+   * @param context - the error context
+   * @return {Transport} for chaining
+   * @protected
+   */
+  onError(e, t, s) {
+    return super.emitReserved("error", new ps(e, t, s)), this;
+  }
+
+  /**
+   * Opens the transport.
+   */
+  open() {
+    return this.readyState = "opening", this.doOpen(), this;
+  }
+
+  /**
+   * Closes the transport.
+   */
+  close() {
+    return (this.readyState === "opening" || this.readyState === "open") && (this.doClose(), this.onClose()), this;
+  }
+
+  /**
+   * Sends multiple packets.
+   *
+   * @param {Array} packets
+   */
+  send(e) {
+    this.readyState === "open" && this.write(e);
+  }
+
+  /**
+   * Called upon open
+   *
+   * @protected
+   */
+  onOpen() {
+    this.readyState = "open", this.writable = !0, super.emitReserved("open");
+  }
+
+  /**
+   * Called with data.
+   *
+   * @param {String} data
+   * @protected
+   */
+  onData(e) {
+    const t = Re(e, this.socket.binaryType);
+    this.onPacket(t);
+  }
+
+  /**
+   * Called with a decoded packet.
+   *
+   * @protected
+   */
+  onPacket(e) {
+    super.emitReserved("packet", e);
+  }
+
+  /**
+   * Called upon close.
+   *
+   * @protected
+   */
+  onClose(e) {
+    this.readyState = "closed", super.emitReserved("close", e);
+  }
+
+  /**
+   * Pauses the transport, in order not to lose packets during an upgrade.
+   *
+   * @param onPause
+   */
+  pause(e) {
+  }
+  createUri(e, t = {}) {
+    return e + "://" + this._hostname() + this._port() + this.opts.path + this._query(t);
+  }
+  _hostname() {
+    const e = this.opts.hostname;
+    return e.indexOf(":") === -1 ? e : "[" + e + "]";
+  }
+  _port() {
+    return this.opts.port && (this.opts.secure && Number(this.opts.port) !== 443 || !this.opts.secure && Number(this.opts.port) !== 80) ? ":" + this.opts.port : "";
+  }
+  _query(e) {
+    const t = ls(e);
+    return t.length ? "?" + t : "";
+  }
+}
+class fs extends Le {
+  constructor() {
+    super(...arguments), this._polling = !1;
+  }
+  get name() {
+    return "polling";
+  }
+
+  /**
+   * Opens the socket (triggers polling). We write a PING message to determine
+   * when the transport is open.
+   *
+   * @protected
+   */
+  doOpen() {
+    this._poll();
+  }
+
+  /**
+   * Pauses polling.
+   *
+   * @param {Function} onPause - callback upon buffers are flushed and transport is paused
+   * @package
+   */
+  pause(e) {
+    this.readyState = "pausing";
+    const t = () => {
+      this.readyState = "paused", e();
+    };
+    if (this._polling || !this.writable) {
+      let s = 0;
+      this._polling && (s++, this.once("pollComplete", function() {
+        --s || t();
+      })), this.writable || (s++, this.once("drain", function() {
+        --s || t();
+      }));
+    } else { t(); }
+  }
+
+  /**
+   * Starts polling cycle.
+   *
+   * @private
+   */
+  _poll() {
+    this._polling = !0, this.doPoll(), this.emitReserved("poll");
+  }
+
+  /**
+   * Overloads onData to detect payloads.
+   *
+   * @protected
+   */
+  onData(e) {
+    const t = (s) => {
+      if (this.readyState === "opening" && s.type === "open" && this.onOpen(), s.type === "close") { return this.onClose({ description: "transport closed by the server" }), !1; }
+      this.onPacket(s);
+    };
+    ts(e, this.socket.binaryType).forEach(t), this.readyState !== "closed" && (this._polling = !1, this.emitReserved("pollComplete"), this.readyState === "open" && this._poll());
+  }
+
+  /**
+   * For polling, send a close packet.
+   *
+   * @protected
+   */
+  doClose() {
+    const e = () => {
+      this.write([{ type: "close" }]);
+    };
+    this.readyState === "open" ? e() : this.once("open", e);
+  }
+
+  /**
+   * Writes a packets payload.
+   *
+   * @param {Array} packets - data packets
+   * @protected
+   */
+  write(e) {
+    this.writable = !1, es(e, (t) => {
+      this.doWrite(t, () => {
+        this.writable = !0, this.emitReserved("drain");
+      });
+    });
+  }
+
+  /**
+   * Generates uri for connection.
+   *
+   * @private
+   */
+  uri() {
+    const e = this.opts.secure ? "https" : "http", t = this.query || {};
+    return this.opts.timestampRequests !== !1 && (t[this.opts.timestampParam] = lt()), !this.supportsBinary && !t.sid && (t.b64 = 1), this.createUri(e, t);
+  }
+}
+let dt = !1;
+try {
+  dt = typeof XMLHttpRequest < "u" && "withCredentials" in new XMLHttpRequest();
+} catch {
+}
+const gs = dt;
+function ms() {
+}
+class ys extends fs {
+
+  /**
+   * XHR Polling constructor.
+   *
+   * @param {Object} opts
+   * @package
+   */
+  constructor(e) {
+    if (super(e), typeof location < "u") {
+      const t = location.protocol === "https:";
+      let s = location.port;
+      s || (s = t ? "443" : "80"), this.xd = typeof location < "u" && e.hostname !== location.hostname || s !== e.port;
+    }
+  }
+
+  /**
+   * Sends data.
+   *
+   * @param {String} data - data to send.
+   * @param {Function} fn - called upon flush.
+   * @private
+   */
+  doWrite(e, t) {
+    const s = this.request({
+      method: "POST",
+      data: e
+    });
+    s.on("success", t), s.on("error", (n, r) => {
+      this.onError("xhr post error", n, r);
+    });
+  }
+
+  /**
+   * Starts a poll cycle.
+   *
+   * @private
+   */
+  doPoll() {
+    const e = this.request();
+    e.on("data", this.onData.bind(this)), e.on("error", (t, s) => {
+      this.onError("xhr poll error", t, s);
+    }), this.pollXhr = e;
+  }
+}
+class q extends y {
+
+  /**
+   * Request constructor
+   *
+   * @param {Object} options
+   * @package
+   */
+  constructor(e, t, s) {
+    super(), this.createRequest = e, ce(this, s), this._opts = s, this._method = s.method || "GET", this._uri = t, this._data = s.data !== void 0 ? s.data : null, this._create();
+  }
+
+  /**
+   * Creates the XHR object and sends the request.
+   *
+   * @private
+   */
+  _create() {
+    let e;
+    const t = ct(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+    t.xdomain = !!this._opts.xd;
+    const s = this._xhr = this.createRequest(t);
+    try {
+      s.open(this._method, this._uri, !0);
+      try {
+        if (this._opts.extraHeaders) {
+          s.setDisableHeaderCheck && s.setDisableHeaderCheck(!0);
+          for (let n in this._opts.extraHeaders) { this._opts.extraHeaders.hasOwnProperty(n) && s.setRequestHeader(n, this._opts.extraHeaders[n]); }
+        }
+      } catch {
+      }
+      if (this._method === "POST") {
+ try {
+          s.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+        } catch {
+        } 
+}
+      try {
+        s.setRequestHeader("Accept", "*/*");
+      } catch {
+      }
+      (e = this._opts.cookieJar) === null || e === void 0 || e.addCookies(s), "withCredentials" in s && (s.withCredentials = this._opts.withCredentials), this._opts.requestTimeout && (s.timeout = this._opts.requestTimeout), s.onreadystatechange = () => {
+        let n;
+        s.readyState === 3 && ((n = this._opts.cookieJar) === null || n === void 0 || n.parseCookies(
+          // @ts-ignore
+          s.getResponseHeader("set-cookie")
+        )), s.readyState === 4 && (s.status === 200 || s.status === 1223 ? this._onLoad() : this.setTimeoutFn(() => {
+          this._onError(typeof s.status == "number" ? s.status : 0);
+        }, 0));
+      }, s.send(this._data);
+    } catch (n) {
+      this.setTimeoutFn(() => {
+        this._onError(n);
+      }, 0);
+      return;
+    }
+    typeof document < "u" && (this._index = q.requestsCount++, q.requests[this._index] = this);
+  }
+
+  /**
+   * Called upon error.
+   *
+   * @private
+   */
+  _onError(e) {
+    this.emitReserved("error", e, this._xhr), this._cleanup(!0);
+  }
+
+  /**
+   * Cleans up house.
+   *
+   * @private
+   */
+  _cleanup(e) {
+    if (!(typeof this._xhr > "u" || this._xhr === null)) {
+      if (this._xhr.onreadystatechange = ms, e) {
+ try {
+          this._xhr.abort();
+        } catch {
+        } 
+}
+      typeof document < "u" && delete q.requests[this._index], this._xhr = null;
+    }
+  }
+
+  /**
+   * Called upon load.
+   *
+   * @private
+   */
+  _onLoad() {
+    const e = this._xhr.responseText;
+    e !== null && (this.emitReserved("data", e), this.emitReserved("success"), this._cleanup());
+  }
+
+  /**
+   * Aborts the request.
+   *
+   * @package
+   */
+  abort() {
+    this._cleanup();
+  }
+}
+q.requestsCount = 0;
+q.requests = {};
+if (typeof document < "u") {
+  if (typeof attachEvent == "function") { attachEvent("onunload", Ze); } else if (typeof addEventListener == "function") {
+    const i = "onpagehide" in k ? "pagehide" : "unload";
+    addEventListener(i, Ze, !1);
+  }
+}
+function Ze() {
+  for (let i in q.requests) { q.requests.hasOwnProperty(i) && q.requests[i].abort(); }
+}
+const ws = (function() {
+  const i = pt({
+    xdomain: !1
+  });
+  return i && i.responseType !== null;
+})();
+class bs extends ys {
+  constructor(e) {
+    super(e);
+    const t = e && e.forceBase64;
+    this.supportsBinary = ws && !t;
+  }
+  request(e = {}) {
+    return Object.assign(e, { xd: this.xd }, this.opts), new q(pt, this.uri(), e);
+  }
+}
+function pt(i) {
+  const e = i.xdomain;
+  try {
+    if (typeof XMLHttpRequest < "u" && (!e || gs)) { return new XMLHttpRequest(); }
+  } catch {
+  }
+  if (!e) {
+ try {
+      return new k[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+    } catch {
+    } 
+}
+}
+const ft = typeof navigator < "u" && typeof navigator.product == "string" && navigator.product.toLowerCase() === "reactnative";
+class Ss extends Le {
+  get name() {
+    return "websocket";
+  }
+  doOpen() {
+    const e = this.uri(), t = this.opts.protocols, s = ft ? {} : ct(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
+    this.opts.extraHeaders && (s.headers = this.opts.extraHeaders);
+    try {
+      this.ws = this.createSocket(e, t, s);
+    } catch (n) {
+      return this.emitReserved("error", n);
+    }
+    this.ws.binaryType = this.socket.binaryType, this.addEventListeners();
+  }
+
+  /**
+   * Adds event listeners to the socket
+   *
+   * @private
+   */
+  addEventListeners() {
+    this.ws.onopen = () => {
+      this.opts.autoUnref && this.ws._socket.unref(), this.onOpen();
+    }, this.ws.onclose = (e) => this.onClose({
+      description: "websocket connection closed",
+      context: e
+    }), this.ws.onmessage = (e) => this.onData(e.data), this.ws.onerror = (e) => this.onError("websocket error", e);
+  }
+  write(e) {
+    this.writable = !1;
+    for (let t = 0; t < e.length; t++) {
+      const s = e[t], n = t === e.length - 1;
+      je(s, this.supportsBinary, (r) => {
+        try {
+          this.doWrite(s, r);
+        } catch {
+        }
+        n && he(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    typeof this.ws < "u" && (this.ws.onerror = () => {
+    }, this.ws.close(), this.ws = null);
+  }
+
+  /**
+   * Generates uri for connection.
+   *
+   * @private
+   */
+  uri() {
+    const e = this.opts.secure ? "wss" : "ws", t = this.query || {};
+    return this.opts.timestampRequests && (t[this.opts.timestampParam] = lt()), this.supportsBinary || (t.b64 = 1), this.createUri(e, t);
+  }
+}
+const ke = k.WebSocket || k.MozWebSocket;
+class Cs extends Ss {
+  createSocket(e, t, s) {
+    return ft ? new ke(e, t, s) : t ? new ke(e, t) : new ke(e);
+  }
+  doWrite(e, t) {
+    this.ws.send(t);
+  }
+}
+class Es extends Le {
+  get name() {
+    return "webtransport";
+  }
+  doOpen() {
+    try {
+      this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+    } catch (e) {
+      return this.emitReserved("error", e);
+    }
+    this._transport.closed.then(() => {
+      this.onClose();
+    }).catch((e) => {
+      this.onError("webtransport error", e);
+    }), this._transport.ready.then(() => {
+      this._transport.createBidirectionalStream().then((e) => {
+        const t = is(Number.MAX_SAFE_INTEGER, this.socket.binaryType), s = e.readable.pipeThrough(t).getReader(), n = ss();
+        n.readable.pipeTo(e.writable), this._writer = n.writable.getWriter();
+        const r = () => {
+          s.read().then(({ done: a, value: u }) => {
+            a || (this.onPacket(u), r());
+          }).catch((a) => {
+          });
+        };
+        r();
+        const o = { type: "open" };
+        this.query.sid && (o.data = `{"sid":"${this.query.sid}"}`), this._writer.write(o).then(() => this.onOpen());
+      });
+    });
+  }
+  write(e) {
+    this.writable = !1;
+    for (let t = 0; t < e.length; t++) {
+      const s = e[t], n = t === e.length - 1;
+      this._writer.write(s).then(() => {
+        n && he(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    let e;
+    (e = this._transport) === null || e === void 0 || e.close();
+  }
+}
+const ks = {
+  websocket: Cs,
+  webtransport: Es,
+  polling: bs
+}, vs = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/, _s = [
+  "source",
+  "protocol",
+  "authority",
+  "userInfo",
+  "user",
+  "password",
+  "host",
+  "port",
+  "relative",
+  "path",
+  "directory",
+  "file",
+  "query",
+  "anchor"
+];
+function Ne(i) {
+  if (i.length > 8e3) { throw "URI too long"; }
+  const e = i, t = i.indexOf("["), s = i.indexOf("]");
+  t != -1 && s != -1 && (i = i.substring(0, t) + i.substring(t, s).replace(/:/g, ";") + i.substring(s, i.length));
+  let n = vs.exec(i || ""), r = {}, o = 14;
+  for (; o--;) { r[_s[o]] = n[o] || ""; }
+  return t != -1 && s != -1 && (r.source = e, r.host = r.host.substring(1, r.host.length - 1).replace(/;/g, ":"), r.authority = r.authority.replace("[", "").replace("]", "").replace(/;/g, ":"), r.ipv6uri = !0), r.pathNames = qs(r, r.path), r.queryKey = Os(r, r.query), r;
+}
+function qs(i, e) {
+  const t = /\/{2,9}/g, s = e.replace(t, "/").split("/");
+  return (e.slice(0, 1) == "/" || e.length === 0) && s.splice(0, 1), e.slice(-1) == "/" && s.splice(s.length - 1, 1), s;
+}
+function Os(i, e) {
+  const t = {};
+  return e.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function(s, n, r) {
+    n && (t[n] = r);
+  }), t;
+}
+const Te = typeof addEventListener == "function" && typeof removeEventListener == "function", ie = [];
+Te && addEventListener("offline", () => {
+  ie.forEach((i) => i());
+}, !1);
+class A extends y {
+
+  /**
+   * Socket constructor.
+   *
+   * @param {String|Object} uri - uri or options
+   * @param {Object} opts - options
+   */
+  constructor(e, t) {
+    if (super(), this.binaryType = rs, this.writeBuffer = [], this._prevBufferLen = 0, this._pingInterval = -1, this._pingTimeout = -1, this._maxPayload = -1, this._pingTimeoutTime = 1 / 0, e && typeof e == "object" && (t = e, e = null), e) {
+      const s = Ne(e);
+      t.hostname = s.host, t.secure = s.protocol === "https" || s.protocol === "wss", t.port = s.port, s.query && (t.query = s.query);
+    } else { t.host && (t.hostname = Ne(t.host).host); }
+    ce(this, t), this.secure = t.secure != null ? t.secure : typeof location < "u" && location.protocol === "https:", t.hostname && !t.port && (t.port = this.secure ? "443" : "80"), this.hostname = t.hostname || (typeof location < "u" ? location.hostname : "localhost"), this.port = t.port || (typeof location < "u" && location.port ? location.port : this.secure ? "443" : "80"), this.transports = [], this._transportsByName = {}, t.transports.forEach((s) => {
+      const n = s.prototype.name;
+      this.transports.push(n), this._transportsByName[n] = s;
+    }), this.opts = Object.assign({
+      path: "/engine.io",
+      agent: !1,
+      withCredentials: !1,
+      upgrade: !0,
+      timestampParam: "t",
+      rememberUpgrade: !1,
+      addTrailingSlash: !0,
+      rejectUnauthorized: !0,
+      perMessageDeflate: {
+        threshold: 1024
+      },
+      transportOptions: {},
+      closeOnBeforeunload: !1
+    }, t), this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : ""), typeof this.opts.query == "string" && (this.opts.query = ds(this.opts.query)), Te && (this.opts.closeOnBeforeunload && (this._beforeunloadEventListener = () => {
+      this.transport && (this.transport.removeAllListeners(), this.transport.close());
+    }, addEventListener("beforeunload", this._beforeunloadEventListener, !1)), this.hostname !== "localhost" && (this._offlineEventListener = () => {
+      this._onClose("transport close", {
+        description: "network connection lost"
+      });
+    }, ie.push(this._offlineEventListener))), this.opts.withCredentials && (this._cookieJar = void 0), this._open();
+  }
+
+  /**
+   * Creates transport of the given type.
+   *
+   * @param {String} name - transport name
+   * @return {Transport}
+   * @private
+   */
+  createTransport(e) {
+    const t = Object.assign({}, this.opts.query);
+    t.EIO = ht, t.transport = e, this.id && (t.sid = this.id);
+    const s = Object.assign({}, this.opts, {
+      query: t,
+      socket: this,
+      hostname: this.hostname,
+      secure: this.secure,
+      port: this.port
+    }, this.opts.transportOptions[e]);
+    return new this._transportsByName[e](s);
+  }
+
+  /**
+   * Initializes transport to use and starts probe.
+   *
+   * @private
+   */
+  _open() {
+    if (this.transports.length === 0) {
+      this.setTimeoutFn(() => {
+        this.emitReserved("error", "No transports available");
+      }, 0);
+      return;
+    }
+    const e = this.opts.rememberUpgrade && A.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0];
+    this.readyState = "opening";
+    const t = this.createTransport(e);
+    t.open(), this.setTransport(t);
+  }
+
+  /**
+   * Sets the current transport. Disables the existing one (if any).
+   *
+   * @private
+   */
+  setTransport(e) {
+    this.transport && this.transport.removeAllListeners(), this.transport = e, e.on("drain", this._onDrain.bind(this)).on("packet", this._onPacket.bind(this)).on("error", this._onError.bind(this)).on("close", (t) => this._onClose("transport close", t));
+  }
+
+  /**
+   * Called when connection is deemed open.
+   *
+   * @private
+   */
+  onOpen() {
+    this.readyState = "open", A.priorWebsocketSuccess = this.transport.name === "websocket", this.emitReserved("open"), this.flush();
+  }
+
+  /**
+   * Handles a packet.
+   *
+   * @private
+   */
+  _onPacket(e) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") {
+ switch (this.emitReserved("packet", e), this.emitReserved("heartbeat"), e.type) {
+        case "open":
+          this.onHandshake(JSON.parse(e.data));
+          break;
+        case "ping":
+          this._sendPacket("pong"), this.emitReserved("ping"), this.emitReserved("pong"), this._resetPingTimeout();
+          break;
+        case "error":
+          const t = new Error("server error");
+          t.code = e.data, this._onError(t);
+          break;
+        case "message":
+          this.emitReserved("data", e.data), this.emitReserved("message", e.data);
+          break;
+      } 
+}
+  }
+
+  /**
+   * Called upon handshake completion.
+   *
+   * @param {Object} data - handshake obj
+   * @private
+   */
+  onHandshake(e) {
+    this.emitReserved("handshake", e), this.id = e.sid, this.transport.query.sid = e.sid, this._pingInterval = e.pingInterval, this._pingTimeout = e.pingTimeout, this._maxPayload = e.maxPayload, this.onOpen(), this.readyState !== "closed" && this._resetPingTimeout();
+  }
+
+  /**
+   * Sets and resets ping timeout timer based on server pings.
+   *
+   * @private
+   */
+  _resetPingTimeout() {
+    this.clearTimeoutFn(this._pingTimeoutTimer);
+    const e = this._pingInterval + this._pingTimeout;
+    this._pingTimeoutTime = Date.now() + e, this._pingTimeoutTimer = this.setTimeoutFn(() => {
+      this._onClose("ping timeout");
+    }, e), this.opts.autoUnref && this._pingTimeoutTimer.unref();
+  }
+
+  /**
+   * Called on `drain` event
+   *
+   * @private
+   */
+  _onDrain() {
+    this.writeBuffer.splice(0, this._prevBufferLen), this._prevBufferLen = 0, this.writeBuffer.length === 0 ? this.emitReserved("drain") : this.flush();
+  }
+
+  /**
+   * Flush write buffers.
+   *
+   * @private
+   */
+  flush() {
+    if (this.readyState !== "closed" && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
+      const e = this._getWritablePackets();
+      this.transport.send(e), this._prevBufferLen = e.length, this.emitReserved("flush");
+    }
+  }
+
+  /**
+   * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
+   * long-polling)
+   *
+   * @private
+   */
+  _getWritablePackets() {
+    if (!(this._maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1)) { return this.writeBuffer; }
+    let t = 1;
+    for (let s = 0; s < this.writeBuffer.length; s++) {
+      const n = this.writeBuffer[s].data;
+      if (n && (t += hs(n)), s > 0 && t > this._maxPayload) { return this.writeBuffer.slice(0, s); }
+      t += 2;
+    }
+    return this.writeBuffer;
+  }
+
+  /**
+   * Checks whether the heartbeat timer has expired but the socket has not yet been notified.
+   *
+   * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
+   * `write()` method then the message would not be buffered by the Socket.IO client.
+   *
+   * @return {boolean}
+   * @private
+   */
+  /* private */
+  _hasPingExpired() {
+    if (!this._pingTimeoutTime) { return !0; }
+    const e = Date.now() > this._pingTimeoutTime;
+    return e && (this._pingTimeoutTime = 0, he(() => {
+      this._onClose("ping timeout");
+    }, this.setTimeoutFn)), e;
+  }
+
+  /**
+   * Sends a message.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @return {Socket} for chaining.
+   */
+  write(e, t, s) {
+    return this._sendPacket("message", e, t, s), this;
+  }
+
+  /**
+   * Sends a message. Alias of {@link Socket#write}.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @return {Socket} for chaining.
+   */
+  send(e, t, s) {
+    return this._sendPacket("message", e, t, s), this;
+  }
+
+  /**
+   * Sends a packet.
+   *
+   * @param {String} type - packet type.
+   * @param {String} data.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @private
+   */
+  _sendPacket(e, t, s, n) {
+    if (typeof t == "function" && (n = t, t = void 0), typeof s == "function" && (n = s, s = null), this.readyState === "closing" || this.readyState === "closed") { return; }
+    s = s || {}, s.compress = s.compress !== !1;
+    const r = {
+      type: e,
+      data: t,
+      options: s
+    };
+    this.emitReserved("packetCreate", r), this.writeBuffer.push(r), n && this.once("flush", n), this.flush();
+  }
+
+  /**
+   * Closes the connection.
+   */
+  close() {
+    const e = () => {
+      this._onClose("forced close"), this.transport.close();
+    }, t = () => {
+      this.off("upgrade", t), this.off("upgradeError", t), e();
+    }, s = () => {
+      this.once("upgrade", t), this.once("upgradeError", t);
+    };
+    return (this.readyState === "opening" || this.readyState === "open") && (this.readyState = "closing", this.writeBuffer.length ? this.once("drain", () => {
+      this.upgrading ? s() : e();
+    }) : this.upgrading ? s() : e()), this;
+  }
+
+  /**
+   * Called upon transport error
+   *
+   * @private
+   */
+  _onError(e) {
+    if (A.priorWebsocketSuccess = !1, this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening") { return this.transports.shift(), this._open(); }
+    this.emitReserved("error", e), this._onClose("transport error", e);
+  }
+
+  /**
+   * Called upon transport close.
+   *
+   * @private
+   */
+  _onClose(e, t) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") {
+      if (this.clearTimeoutFn(this._pingTimeoutTimer), this.transport.removeAllListeners("close"), this.transport.close(), this.transport.removeAllListeners(), Te && (this._beforeunloadEventListener && removeEventListener("beforeunload", this._beforeunloadEventListener, !1), this._offlineEventListener)) {
+        const s = ie.indexOf(this._offlineEventListener);
+        s !== -1 && ie.splice(s, 1);
+      }
+      this.readyState = "closed", this.id = null, this.emitReserved("close", e, t), this.writeBuffer = [], this._prevBufferLen = 0;
+    }
+  }
+}
+A.protocol = ht;
+class Ns extends A {
+  constructor() {
+    super(...arguments), this._upgrades = [];
+  }
+  onOpen() {
+    if (super.onOpen(), this.readyState === "open" && this.opts.upgrade) {
+ for (let e = 0; e < this._upgrades.length; e++) { this._probe(this._upgrades[e]); } 
+}
+  }
+
+  /**
+   * Probes a transport.
+   *
+   * @param {String} name - transport name
+   * @private
+   */
+  _probe(e) {
+    let t = this.createTransport(e), s = !1;
+    A.priorWebsocketSuccess = !1;
+    const n = () => {
+      s || (t.send([{ type: "ping", data: "probe" }]), t.once("packet", (l) => {
+        if (!s) {
+ if (l.type === "pong" && l.data === "probe") {
+            if (this.upgrading = !0, this.emitReserved("upgrading", t), !t) { return; }
+            A.priorWebsocketSuccess = t.name === "websocket", this.transport.pause(() => {
+              s || this.readyState !== "closed" && (h(), this.setTransport(t), t.send([{ type: "upgrade" }]), this.emitReserved("upgrade", t), t = null, this.upgrading = !1, this.flush());
+            });
+          } else {
+            const m = new Error("probe error");
+            m.transport = t.name, this.emitReserved("upgradeError", m);
+          } 
+}
+      }));
+    };
+    function r() {
+      s || (s = !0, h(), t.close(), t = null);
+    }
+    const o = (l) => {
+      const m = new Error("probe error: " + l);
+      m.transport = t.name, r(), this.emitReserved("upgradeError", m);
+    };
+    function a() {
+      o("transport closed");
+    }
+    function u() {
+      o("socket closed");
+    }
+    function c(l) {
+      t && l.name !== t.name && r();
+    }
+    const h = () => {
+      t.removeListener("open", n), t.removeListener("error", o), t.removeListener("close", a), this.off("close", u), this.off("upgrading", c);
+    };
+    t.once("open", n), t.once("error", o), t.once("close", a), this.once("close", u), this.once("upgrading", c), this._upgrades.indexOf("webtransport") !== -1 && e !== "webtransport" ? this.setTimeoutFn(() => {
+      s || t.open();
+    }, 200) : t.open();
+  }
+  onHandshake(e) {
+    this._upgrades = this._filterUpgrades(e.upgrades), super.onHandshake(e);
+  }
+
+  /**
+   * Filters upgrades, returning only those matching client transports.
+   *
+   * @param {Array} upgrades - server upgrades
+   * @private
+   */
+  _filterUpgrades(e) {
+    const t = [];
+    for (let s = 0; s < e.length; s++) { ~this.transports.indexOf(e[s]) && t.push(e[s]); }
+    return t;
+  }
+}
+let Ts = class extends Ns {
+  constructor(e, t = {}) {
+    const s = typeof e == "object" ? e : t;
+    (!s.transports || s.transports && typeof s.transports[0] == "string") && (s.transports = (s.transports || ["polling", "websocket", "webtransport"]).map((n) => ks[n]).filter((n) => !!n)), super(e, s);
+  }
+};
+function xs(i, e = "", t) {
+  let s = i;
+  t = t || typeof location < "u" && location, i == null && (i = t.protocol + "//" + t.host), typeof i == "string" && (i.charAt(0) === "/" && (i.charAt(1) === "/" ? i = t.protocol + i : i = t.host + i), /^(https?|wss?):\/\//.test(i) || (typeof t < "u" ? i = t.protocol + "//" + i : i = "https://" + i), s = Ne(i)), s.port || (/^(http|ws)$/.test(s.protocol) ? s.port = "80" : /^(http|ws)s$/.test(s.protocol) && (s.port = "443")), s.path = s.path || "/";
+  const r = s.host.indexOf(":") !== -1 ? "[" + s.host + "]" : s.host;
+  return s.id = s.protocol + "://" + r + ":" + s.port + e, s.href = s.protocol + "://" + r + (t && t.port === s.port ? "" : ":" + s.port), s;
+}
+const Ms = typeof ArrayBuffer == "function", As = (i) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(i) : i.buffer instanceof ArrayBuffer, gt = Object.prototype.toString, Is = typeof Blob == "function" || typeof Blob < "u" && gt.call(Blob) === "[object BlobConstructor]", js = typeof File == "function" || typeof File < "u" && gt.call(File) === "[object FileConstructor]";
+function Ge(i) {
+  return Ms && (i instanceof ArrayBuffer || As(i)) || Is && i instanceof Blob || js && i instanceof File;
+}
+function ne(i, e) {
+  if (!i || typeof i != "object") { return !1; }
+  if (Array.isArray(i)) {
+    for (let t = 0, s = i.length; t < s; t++) {
+ if (ne(i[t])) { return !0; } 
+}
+    return !1;
+  }
+  if (Ge(i)) { return !0; }
+  if (i.toJSON && typeof i.toJSON == "function" && arguments.length === 1) { return ne(i.toJSON(), !0); }
+  for (const t in i) {
+ if (Object.prototype.hasOwnProperty.call(i, t) && ne(i[t])) { return !0; } 
+}
+  return !1;
+}
+function Rs(i) {
+  const e = [], t = i.data, s = i;
+  return s.data = xe(t, e), s.attachments = e.length, { packet: s, buffers: e };
+}
+function xe(i, e) {
+  if (!i) { return i; }
+  if (Ge(i)) {
+    const t = { _placeholder: !0, num: e.length };
+    return e.push(i), t;
+  } else if (Array.isArray(i)) {
+    const t = new Array(i.length);
+    for (let s = 0; s < i.length; s++) { t[s] = xe(i[s], e); }
+    return t;
+  } else if (typeof i == "object" && !(i instanceof Date)) {
+    const t = {};
+    for (const s in i) { Object.prototype.hasOwnProperty.call(i, s) && (t[s] = xe(i[s], e)); }
+    return t;
+  }
+  return i;
+}
+function Ls(i, e) {
+  return i.data = Me(i.data, e), delete i.attachments, i;
+}
+function Me(i, e) {
+  if (!i) { return i; }
+  if (i && i._placeholder === !0) {
+    if (typeof i.num == "number" && i.num >= 0 && i.num < e.length) { return e[i.num]; }
+    throw new Error("illegal attachments");
+  } else if (Array.isArray(i)) {
+ for (let t = 0; t < i.length; t++) { i[t] = Me(i[t], e); } 
+} else if (typeof i == "object") {
+ for (const t in i) { Object.prototype.hasOwnProperty.call(i, t) && (i[t] = Me(i[t], e)); } 
+}
+  return i;
+}
+const mt = [
+  "connect",
+  // used on the client side
+  "connect_error",
+  // used on the client side
+  "disconnect",
+  // used on both sides
+  "disconnecting",
+  // used on the server side
+  "newListener",
+  // used by the Node.js EventEmitter
+  "removeListener"
+  // used by the Node.js EventEmitter
+], Gs = 5;
+let p;
+(function(i) {
+  i[i.CONNECT = 0] = "CONNECT", i[i.DISCONNECT = 1] = "DISCONNECT", i[i.EVENT = 2] = "EVENT", i[i.ACK = 3] = "ACK", i[i.CONNECT_ERROR = 4] = "CONNECT_ERROR", i[i.BINARY_EVENT = 5] = "BINARY_EVENT", i[i.BINARY_ACK = 6] = "BINARY_ACK";
+})(p || (p = {}));
+class Bs {
+
+  /**
+   * Encoder constructor
+   *
+   * @param {function} replacer - custom replacer to pass down to JSON.parse
+   */
+  constructor(e) {
+    this.replacer = e;
+  }
+
+  /**
+   * Encode a packet as a single string if non-binary, or as a
+   * buffer sequence, depending on packet type.
+   *
+   * @param {Object} obj - packet object
+   */
+  encode(e) {
+    return (e.type === p.EVENT || e.type === p.ACK) && ne(e) ? this.encodeAsBinary({
+      type: e.type === p.EVENT ? p.BINARY_EVENT : p.BINARY_ACK,
+      nsp: e.nsp,
+      data: e.data,
+      id: e.id
+    }) : [this.encodeAsString(e)];
+  }
+
+  /**
+   * Encode packet as string.
+   */
+  encodeAsString(e) {
+    let t = "" + e.type;
+    return (e.type === p.BINARY_EVENT || e.type === p.BINARY_ACK) && (t += e.attachments + "-"), e.nsp && e.nsp !== "/" && (t += e.nsp + ","), e.id != null && (t += e.id), e.data != null && (t += JSON.stringify(e.data, this.replacer)), t;
+  }
+
+  /**
+   * Encode packet as 'buffer sequence' by removing blobs, and
+   * deconstructing packet into object with placeholders and
+   * a list of buffers.
+   */
+  encodeAsBinary(e) {
+    const t = Rs(e), s = this.encodeAsString(t.packet), n = t.buffers;
+    return n.unshift(s), n;
+  }
+}
+class Be extends y {
+
+  /**
+   * Decoder constructor
+   */
+  constructor(e) {
+    super(), this.opts = Object.assign({
+      reviver: void 0,
+      maxAttachments: 10
+    }, typeof e == "function" ? { reviver: e } : e);
+  }
+
+  /**
+   * Decodes an encoded packet string into packet JSON.
+   *
+   * @param {String} obj - encoded packet
+   */
+  add(e) {
+    let t;
+    if (typeof e == "string") {
+      if (this.reconstructor) { throw new Error("got plaintext data when reconstructing a packet"); }
+      t = this.decodeString(e);
+      const s = t.type === p.BINARY_EVENT;
+      s || t.type === p.BINARY_ACK ? (t.type = s ? p.EVENT : p.ACK, this.reconstructor = new $s(t), t.attachments === 0 && super.emitReserved("decoded", t)) : super.emitReserved("decoded", t);
+    } else if (Ge(e) || e.base64) {
+ if (this.reconstructor) { t = this.reconstructor.takeBinaryData(e), t && (this.reconstructor = null, super.emitReserved("decoded", t)); } else { throw new Error("got binary data when not reconstructing a packet"); } 
+} else { throw new Error("Unknown type: " + e); }
+  }
+
+  /**
+   * Decode a packet String (JSON data)
+   *
+   * @param {String} str
+   * @return {Object} packet
+   */
+  decodeString(e) {
+    let t = 0;
+    const s = {
+      type: Number(e.charAt(0))
+    };
+    if (p[s.type] === void 0) { throw new Error("unknown packet type " + s.type); }
+    if (s.type === p.BINARY_EVENT || s.type === p.BINARY_ACK) {
+      const r = t + 1;
+      for (; e.charAt(++t) !== "-" && t != e.length;) { }
+      const o = e.substring(r, t);
+      if (o != Number(o) || e.charAt(t) !== "-") { throw new Error("Illegal attachments"); }
+      const a = Number(o);
+      if (!yt(a) || a < 0) { throw new Error("Illegal attachments"); }
+      if (a > this.opts.maxAttachments) { throw new Error("too many attachments"); }
+      s.attachments = a;
+    }
+    if (e.charAt(t + 1) === "/") {
+      const r = t + 1;
+      for (; ++t && !(e.charAt(t) === "," || t === e.length);) { }
+      s.nsp = e.substring(r, t);
+    } else { s.nsp = "/"; }
+    const n = e.charAt(t + 1);
+    if (n !== "" && Number(n) == n) {
+      const r = t + 1;
+      for (; ++t;) {
+        const o = e.charAt(t);
+        if (o == null || Number(o) != o) {
+          --t;
+          break;
+        }
+        if (t === e.length) { break; }
+      }
+      s.id = Number(e.substring(r, t + 1));
+    }
+    if (e.charAt(++t)) {
+      const r = this.tryParse(e.substr(t));
+      if (Be.isPayloadValid(s.type, r)) { s.data = r; } else { throw new Error("invalid payload"); }
+    }
+    return s;
+  }
+  tryParse(e) {
+    try {
+      return JSON.parse(e, this.opts.reviver);
+    } catch {
+      return !1;
+    }
+  }
+  static isPayloadValid(e, t) {
+    switch (e) {
+      case p.CONNECT:
+        return ae(t);
+      case p.DISCONNECT:
+        return t === void 0;
+      case p.CONNECT_ERROR:
+        return typeof t == "string" || ae(t);
+      case p.EVENT:
+      case p.BINARY_EVENT:
+        return Array.isArray(t) && (typeof t[0] == "number" || typeof t[0] == "string" && mt.indexOf(t[0]) === -1);
+      case p.ACK:
+      case p.BINARY_ACK:
+        return Array.isArray(t);
+    }
+  }
+
+  /**
+   * Deallocates a parser's resources
+   */
+  destroy() {
+    this.reconstructor && (this.reconstructor.finishedReconstruction(), this.reconstructor = null);
+  }
+}
+class $s {
+  constructor(e) {
+    this.packet = e, this.buffers = [], this.reconPack = e;
+  }
+
+  /**
+   * Method to be called when binary data received from connection
+   * after a BINARY_EVENT packet.
+   *
+   * @param {Buffer | ArrayBuffer} binData - the raw binary data received
+   * @return {null | Object} returns null if more binary data is expected or
+   *   a reconstructed packet object if all buffers have been received.
+   */
+  takeBinaryData(e) {
+    if (this.buffers.push(e), this.buffers.length === this.reconPack.attachments) {
+      const t = Ls(this.reconPack, this.buffers);
+      return this.finishedReconstruction(), t;
+    }
+    return null;
+  }
+
+  /**
+   * Cleans up binary packet reconstruction variables.
+   */
+  finishedReconstruction() {
+    this.reconPack = null, this.buffers = [];
+  }
+}
+function Ps(i) {
+  return typeof i == "string";
+}
+const yt = Number.isInteger || function(i) {
+  return typeof i == "number" && isFinite(i) && Math.floor(i) === i;
+};
+function zs(i) {
+  return i === void 0 || yt(i);
+}
+function ae(i) {
+  return Object.prototype.toString.call(i) === "[object Object]";
+}
+function Ds(i, e) {
+  switch (i) {
+    case p.CONNECT:
+      return e === void 0 || ae(e);
+    case p.DISCONNECT:
+      return e === void 0;
+    case p.EVENT:
+      return Array.isArray(e) && (typeof e[0] == "number" || typeof e[0] == "string" && mt.indexOf(e[0]) === -1);
+    case p.ACK:
+      return Array.isArray(e);
+    case p.CONNECT_ERROR:
+      return typeof e == "string" || ae(e);
+    default:
+      return !1;
+  }
+}
+function Fs(i) {
+  return Ps(i.nsp) && zs(i.id) && Ds(i.type, i.data);
+}
+const Us = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Decoder: Be,
+  Encoder: Bs,
+  get PacketType() {
+    return p;
+  },
+  isPacketValid: Fs,
+  protocol: Gs
+}, Symbol.toStringTag, { value: "Module" }));
+function _(i, e, t) {
+  return i.on(e, t), function() {
+    i.off(e, t);
+  };
+}
+const Vs = Object.freeze({
+  connect: 1,
+  connect_error: 1,
+  disconnect: 1,
+  disconnecting: 1,
+  // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
+  newListener: 1,
+  removeListener: 1
+});
+class wt extends y {
+
+  /**
+   * `Socket` constructor.
+   */
+  constructor(e, t, s) {
+    super(), this.connected = !1, this.recovered = !1, this.receiveBuffer = [], this.sendBuffer = [], this._queue = [], this._queueSeq = 0, this.ids = 0, this.acks = {}, this.flags = {}, this.io = e, this.nsp = t, s && s.auth && (this.auth = s.auth), this._opts = Object.assign({}, s), this.io._autoConnect && this.open();
+  }
+
+  /**
+   * Whether the socket is currently disconnected
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("connect", () => {
+   *   console.log(socket.disconnected); // false
+   * });
+   *
+   * socket.on("disconnect", () => {
+   *   console.log(socket.disconnected); // true
+   * });
+   */
+  get disconnected() {
+    return !this.connected;
+  }
+
+  /**
+   * Subscribe to open, close and packet events
+   *
+   * @private
+   */
+  subEvents() {
+    if (this.subs) { return; }
+    const e = this.io;
+    this.subs = [
+      _(e, "open", this.onopen.bind(this)),
+      _(e, "packet", this.onpacket.bind(this)),
+      _(e, "error", this.onerror.bind(this)),
+      _(e, "close", this.onclose.bind(this))
+    ];
+  }
+
+  /**
+   * Whether the Socket will try to reconnect when its Manager connects or reconnects.
+   *
+   * @example
+   * const socket = io();
+   *
+   * console.log(socket.active); // true
+   *
+   * socket.on("disconnect", (reason) => {
+   *   if (reason === "io server disconnect") {
+   *     // the disconnection was initiated by the server, you need to manually reconnect
+   *     console.log(socket.active); // false
+   *   }
+   *   // else the socket will automatically try to reconnect
+   *   console.log(socket.active); // true
+   * });
+   */
+  get active() {
+    return !!this.subs;
+  }
+
+  /**
+   * "Opens" the socket.
+   *
+   * @example
+   * const socket = io({
+   *   autoConnect: false
+   * });
+   *
+   * socket.connect();
+   */
+  connect() {
+    return this.connected ? this : (this.subEvents(), this.io._reconnecting || this.io.open(), this.io._readyState === "open" && this.onopen(), this);
+  }
+
+  /**
+   * Alias for {@link connect()}.
+   */
+  open() {
+    return this.connect();
+  }
+
+  /**
+   * Sends a `message` event.
+   *
+   * This method mimics the WebSocket.send() method.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+   *
+   * @example
+   * socket.send("hello");
+   *
+   * // this is equivalent to
+   * socket.emit("message", "hello");
+   *
+   * @return self
+   */
+  send(...e) {
+    return e.unshift("message"), this.emit.apply(this, e), this;
+  }
+
+  /**
+   * Override `emit`.
+   * If the event is in `events`, it's emitted normally.
+   *
+   * @example
+   * socket.emit("hello", "world");
+   *
+   * // all serializable datastructures are supported (no need to call JSON.stringify)
+   * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+   *
+   * // with an acknowledgement from the server
+   * socket.emit("hello", "world", (val) => {
+   *   // ...
+   * });
+   *
+   * @return self
+   */
+  emit(e, ...t) {
+    let s, n, r;
+    if (Vs.hasOwnProperty(e)) { throw new Error('"' + e.toString() + '" is a reserved event name'); }
+    if (t.unshift(e), this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) { return this._addToQueue(t), this; }
+    const o = {
+      type: p.EVENT,
+      data: t
+    };
+    if (o.options = {}, o.options.compress = this.flags.compress !== !1, typeof t[t.length - 1] == "function") {
+      const h = this.ids++, l = t.pop();
+      this._registerAckCallback(h, l), o.id = h;
+    }
+    const a = (n = (s = this.io.engine) === null || s === void 0 ? void 0 : s.transport) === null || n === void 0 ? void 0 : n.writable, u = this.connected && !(!((r = this.io.engine) === null || r === void 0) && r._hasPingExpired());
+    return this.flags.volatile && !a || (u ? (this.notifyOutgoingListeners(o), this.packet(o)) : this.sendBuffer.push(o)), this.flags = {}, this;
+  }
+
+  /**
+   * @private
+   */
+  _registerAckCallback(e, t) {
+    let s;
+    const n = (s = this.flags.timeout) !== null && s !== void 0 ? s : this._opts.ackTimeout;
+    if (n === void 0) {
+      this.acks[e] = t;
+      return;
+    }
+    const r = this.io.setTimeoutFn(() => {
+      delete this.acks[e];
+      for (let a = 0; a < this.sendBuffer.length; a++) { this.sendBuffer[a].id === e && this.sendBuffer.splice(a, 1); }
+      t.call(this, new Error("operation has timed out"));
+    }, n), o = (...a) => {
+      this.io.clearTimeoutFn(r), t.apply(this, a);
+    };
+    o.withError = !0, this.acks[e] = o;
+  }
+
+  /**
+   * Emits an event and waits for an acknowledgement
+   *
+   * @example
+   * // without timeout
+   * const response = await socket.emitWithAck("hello", "world");
+   *
+   * // with a specific timeout
+   * try {
+   *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
+   * } catch (err) {
+   *   // the server did not acknowledge the event in the given delay
+   * }
+   *
+   * @return a Promise that will be fulfilled when the server acknowledges the event
+   */
+  emitWithAck(e, ...t) {
+    return new Promise((s, n) => {
+      const r = (o, a) => o ? n(o) : s(a);
+      r.withError = !0, t.push(r), this.emit(e, ...t);
+    });
+  }
+
+  /**
+   * Add the packet to the queue.
+   * @param args
+   * @private
+   */
+  _addToQueue(e) {
+    let t;
+    typeof e[e.length - 1] == "function" && (t = e.pop());
+    const s = {
+      id: this._queueSeq++,
+      tryCount: 0,
+      pending: !1,
+      args: e,
+      flags: Object.assign({ fromQueue: !0 }, this.flags)
+    };
+    e.push((n, ...r) => (this._queue[0], n !== null ? s.tryCount > this._opts.retries && (this._queue.shift(), t && t(n)) : (this._queue.shift(), t && t(null, ...r)), s.pending = !1, this._drainQueue())), this._queue.push(s), this._drainQueue();
+  }
+
+  /**
+   * Send the first packet of the queue, and wait for an acknowledgement from the server.
+   * @param force - whether to resend a packet that has not been acknowledged yet
+   *
+   * @private
+   */
+  _drainQueue(e = !1) {
+    if (!this.connected || this._queue.length === 0) { return; }
+    const t = this._queue[0];
+    t.pending && !e || (t.pending = !0, t.tryCount++, this.flags = t.flags, this.emit.apply(this, t.args));
+  }
+
+  /**
+   * Sends a packet.
+   *
+   * @param packet
+   * @private
+   */
+  packet(e) {
+    e.nsp = this.nsp, this.io._packet(e);
+  }
+
+  /**
+   * Called upon engine `open`.
+   *
+   * @private
+   */
+  onopen() {
+    typeof this.auth == "function" ? this.auth((e) => {
+      this._sendConnectPacket(e);
+    }) : this._sendConnectPacket(this.auth);
+  }
+
+  /**
+   * Sends a CONNECT packet to initiate the Socket.IO session.
+   *
+   * @param data
+   * @private
+   */
+  _sendConnectPacket(e) {
+    this.packet({
+      type: p.CONNECT,
+      data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, e) : e
+    });
+  }
+
+  /**
+   * Called upon engine or manager `error`.
+   *
+   * @param err
+   * @private
+   */
+  onerror(e) {
+    this.connected || this.emitReserved("connect_error", e);
+  }
+
+  /**
+   * Called upon engine `close`.
+   *
+   * @param reason
+   * @param description
+   * @private
+   */
+  onclose(e, t) {
+    this.connected = !1, delete this.id, this.emitReserved("disconnect", e, t), this._clearAcks();
+  }
+
+  /**
+   * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
+   * the server.
+   *
+   * @private
+   */
+  _clearAcks() {
+    Object.keys(this.acks).forEach((e) => {
+      if (!this.sendBuffer.some((s) => String(s.id) === e)) {
+        const s = this.acks[e];
+        delete this.acks[e], s.withError && s.call(this, new Error("socket has been disconnected"));
+      }
+    });
+  }
+
+  /**
+   * Called with socket packet.
+   *
+   * @param packet
+   * @private
+   */
+  onpacket(e) {
+    if (e.nsp === this.nsp) {
+ switch (e.type) {
+        case p.CONNECT:
+          e.data && e.data.sid ? this.onconnect(e.data.sid, e.data.pid) : this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+          break;
+        case p.EVENT:
+        case p.BINARY_EVENT:
+          this.onevent(e);
+          break;
+        case p.ACK:
+        case p.BINARY_ACK:
+          this.onack(e);
+          break;
+        case p.DISCONNECT:
+          this.ondisconnect();
+          break;
+        case p.CONNECT_ERROR:
+          this.destroy();
+          const s = new Error(e.data.message);
+          s.data = e.data.data, this.emitReserved("connect_error", s);
+          break;
+      } 
+}
+  }
+
+  /**
+   * Called upon a server event.
+   *
+   * @param packet
+   * @private
+   */
+  onevent(e) {
+    const t = e.data || [];
+    e.id != null && t.push(this.ack(e.id)), this.connected ? this.emitEvent(t) : this.receiveBuffer.push(Object.freeze(t));
+  }
+  emitEvent(e) {
+    if (this._anyListeners && this._anyListeners.length) {
+      const t = this._anyListeners.slice();
+      for (const s of t) { s.apply(this, e); }
+    }
+    super.emit.apply(this, e), this._pid && e.length && typeof e[e.length - 1] == "string" && (this._lastOffset = e[e.length - 1]);
+  }
+
+  /**
+   * Produces an ack callback to emit with an event.
+   *
+   * @private
+   */
+  ack(e) {
+    const t = this;
+    let s = !1;
+    return function(...n) {
+      s || (s = !0, t.packet({
+        type: p.ACK,
+        id: e,
+        data: n
+      }));
+    };
+  }
+
+  /**
+   * Called upon a server acknowledgement.
+   *
+   * @param packet
+   * @private
+   */
+  onack(e) {
+    const t = this.acks[e.id];
+    typeof t == "function" && (delete this.acks[e.id], t.withError && e.data.unshift(null), t.apply(this, e.data));
+  }
+
+  /**
+   * Called upon server connect.
+   *
+   * @private
+   */
+  onconnect(e, t) {
+    this.id = e, this.recovered = t && this._pid === t, this._pid = t, this.connected = !0, this.emitBuffered(), this._drainQueue(!0), this.emitReserved("connect");
+  }
+
+  /**
+   * Emit buffered events (received and emitted).
+   *
+   * @private
+   */
+  emitBuffered() {
+    this.receiveBuffer.forEach((e) => this.emitEvent(e)), this.receiveBuffer = [], this.sendBuffer.forEach((e) => {
+      this.notifyOutgoingListeners(e), this.packet(e);
+    }), this.sendBuffer = [];
+  }
+
+  /**
+   * Called upon server disconnect.
+   *
+   * @private
+   */
+  ondisconnect() {
+    this.destroy(), this.onclose("io server disconnect");
+  }
+
+  /**
+   * Called upon forced client/server side disconnections,
+   * this method ensures the manager stops tracking us and
+   * that reconnections don't get triggered for this.
+   *
+   * @private
+   */
+  destroy() {
+    this.subs && (this.subs.forEach((e) => e()), this.subs = void 0), this.io._destroy(this);
+  }
+
+  /**
+   * Disconnects the socket manually. In that case, the socket will not try to reconnect.
+   *
+   * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("disconnect", (reason) => {
+   *   // console.log(reason); prints "io client disconnect"
+   * });
+   *
+   * socket.disconnect();
+   *
+   * @return self
+   */
+  disconnect() {
+    return this.connected && this.packet({ type: p.DISCONNECT }), this.destroy(), this.connected && this.onclose("io client disconnect"), this;
+  }
+
+  /**
+   * Alias for {@link disconnect()}.
+   *
+   * @return self
+   */
+  close() {
+    return this.disconnect();
+  }
+
+  /**
+   * Sets the compress flag.
+   *
+   * @example
+   * socket.compress(false).emit("hello");
+   *
+   * @param compress - if `true`, compresses the sending data
+   * @return self
+   */
+  compress(e) {
+    return this.flags.compress = e, this;
+  }
+
+  /**
+   * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
+   * ready to send messages.
+   *
+   * @example
+   * socket.volatile.emit("hello"); // the server may or may not receive it
+   *
+   * @returns self
+   */
+  get volatile() {
+    return this.flags.volatile = !0, this;
+  }
+
+  /**
+   * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+   * given number of milliseconds have elapsed without an acknowledgement from the server:
+   *
+   * @example
+   * socket.timeout(5000).emit("my-event", (err) => {
+   *   if (err) {
+   *     // the server did not acknowledge the event in the given delay
+   *   }
+   * });
+   *
+   * @returns self
+   */
+  timeout(e) {
+    return this.flags.timeout = e, this;
+  }
+
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * @example
+   * socket.onAny((event, ...args) => {
+   *   console.log(`got ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAny(e) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.push(e), this;
+  }
+
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * @example
+   * socket.prependAny((event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAny(e) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.unshift(e), this;
+  }
+
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * }
+   *
+   * socket.onAny(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAny(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAny();
+   *
+   * @param listener
+   */
+  offAny(e) {
+    if (!this._anyListeners) { return this; }
+    if (e) {
+      const t = this._anyListeners;
+      for (let s = 0; s < t.length; s++) {
+ if (e === t[s]) { return t.splice(s, 1), this; } 
+}
+    } else { this._anyListeners = []; }
+    return this;
+  }
+
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAny() {
+    return this._anyListeners || [];
+  }
+
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.onAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAnyOutgoing(e) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.push(e), this;
+  }
+
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.prependAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAnyOutgoing(e) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.unshift(e), this;
+  }
+
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * }
+   *
+   * socket.onAnyOutgoing(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAnyOutgoing(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAnyOutgoing();
+   *
+   * @param [listener] - the catch-all listener (optional)
+   */
+  offAnyOutgoing(e) {
+    if (!this._anyOutgoingListeners) { return this; }
+    if (e) {
+      const t = this._anyOutgoingListeners;
+      for (let s = 0; s < t.length; s++) {
+ if (e === t[s]) { return t.splice(s, 1), this; } 
+}
+    } else { this._anyOutgoingListeners = []; }
+    return this;
+  }
+
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAnyOutgoing() {
+    return this._anyOutgoingListeners || [];
+  }
+
+  /**
+   * Notify the listeners for each packet sent
+   *
+   * @param packet
+   *
+   * @private
+   */
+  notifyOutgoingListeners(e) {
+    if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+      const t = this._anyOutgoingListeners.slice();
+      for (const s of t) { s.apply(this, e.data); }
+    }
+  }
+}
+function F(i) {
+  i = i || {}, this.ms = i.min || 100, this.max = i.max || 1e4, this.factor = i.factor || 2, this.jitter = i.jitter > 0 && i.jitter <= 1 ? i.jitter : 0, this.attempts = 0;
+}
+F.prototype.duration = function() {
+  let i = this.ms * Math.pow(this.factor, this.attempts++);
+  if (this.jitter) {
+    let e = Math.random(), t = Math.floor(e * this.jitter * i);
+    i = Math.floor(e * 10) & 1 ? i + t : i - t;
+  }
+  return Math.min(i, this.max) | 0;
+};
+F.prototype.reset = function() {
+  this.attempts = 0;
+};
+F.prototype.setMin = function(i) {
+  this.ms = i;
+};
+F.prototype.setMax = function(i) {
+  this.max = i;
+};
+F.prototype.setJitter = function(i) {
+  this.jitter = i;
+};
+class Ae extends y {
+  constructor(e, t) {
+    let s;
+    super(), this.nsps = {}, this.subs = [], e && typeof e == "object" && (t = e, e = void 0), t = t || {}, t.path = t.path || "/socket.io", this.opts = t, ce(this, t), this.reconnection(t.reconnection !== !1), this.reconnectionAttempts(t.reconnectionAttempts || 1 / 0), this.reconnectionDelay(t.reconnectionDelay || 1e3), this.reconnectionDelayMax(t.reconnectionDelayMax || 5e3), this.randomizationFactor((s = t.randomizationFactor) !== null && s !== void 0 ? s : 0.5), this.backoff = new F({
+      min: this.reconnectionDelay(),
+      max: this.reconnectionDelayMax(),
+      jitter: this.randomizationFactor()
+    }), this.timeout(t.timeout == null ? 2e4 : t.timeout), this._readyState = "closed", this.uri = e;
+    const n = t.parser || Us;
+    this.encoder = new n.Encoder(), this.decoder = new n.Decoder(), this._autoConnect = t.autoConnect !== !1, this._autoConnect && this.open();
+  }
+  reconnection(e) {
+    return arguments.length ? (this._reconnection = !!e, e || (this.skipReconnect = !0), this) : this._reconnection;
+  }
+  reconnectionAttempts(e) {
+    return e === void 0 ? this._reconnectionAttempts : (this._reconnectionAttempts = e, this);
+  }
+  reconnectionDelay(e) {
+    let t;
+    return e === void 0 ? this._reconnectionDelay : (this._reconnectionDelay = e, (t = this.backoff) === null || t === void 0 || t.setMin(e), this);
+  }
+  randomizationFactor(e) {
+    let t;
+    return e === void 0 ? this._randomizationFactor : (this._randomizationFactor = e, (t = this.backoff) === null || t === void 0 || t.setJitter(e), this);
+  }
+  reconnectionDelayMax(e) {
+    let t;
+    return e === void 0 ? this._reconnectionDelayMax : (this._reconnectionDelayMax = e, (t = this.backoff) === null || t === void 0 || t.setMax(e), this);
+  }
+  timeout(e) {
+    return arguments.length ? (this._timeout = e, this) : this._timeout;
+  }
+
+  /**
+   * Starts trying to reconnect if reconnection is enabled and we have not
+   * started reconnecting yet
+   *
+   * @private
+   */
+  maybeReconnectOnOpen() {
+    !this._reconnecting && this._reconnection && this.backoff.attempts === 0 && this.reconnect();
+  }
+
+  /**
+   * Sets the current transport `socket`.
+   *
+   * @param {Function} fn - optional, callback
+   * @return self
+   * @public
+   */
+  open(e) {
+    if (~this._readyState.indexOf("open")) { return this; }
+    this.engine = new Ts(this.uri, this.opts);
+    const t = this.engine, s = this;
+    this._readyState = "opening", this.skipReconnect = !1;
+    const n = _(t, "open", function() {
+      s.onopen(), e && e();
+    }), r = (a) => {
+      this.cleanup(), this._readyState = "closed", this.emitReserved("error", a), e ? e(a) : this.maybeReconnectOnOpen();
+    }, o = _(t, "error", r);
+    if (this._timeout !== !1) {
+      const a = this._timeout, u = this.setTimeoutFn(() => {
+        n(), r(new Error("timeout")), t.close();
+      }, a);
+      this.opts.autoUnref && u.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(u);
+      });
+    }
+    return this.subs.push(n), this.subs.push(o), this;
+  }
+
+  /**
+   * Alias for open()
+   *
+   * @return self
+   * @public
+   */
+  connect(e) {
+    return this.open(e);
+  }
+
+  /**
+   * Called upon transport open.
+   *
+   * @private
+   */
+  onopen() {
+    this.cleanup(), this._readyState = "open", this.emitReserved("open");
+    const e = this.engine;
+    this.subs.push(
+      _(e, "ping", this.onping.bind(this)),
+      _(e, "data", this.ondata.bind(this)),
+      _(e, "error", this.onerror.bind(this)),
+      _(e, "close", this.onclose.bind(this)),
+      // @ts-ignore
+      _(this.decoder, "decoded", this.ondecoded.bind(this))
+    );
+  }
+
+  /**
+   * Called upon a ping.
+   *
+   * @private
+   */
+  onping() {
+    this.emitReserved("ping");
+  }
+
+  /**
+   * Called with data.
+   *
+   * @private
+   */
+  ondata(e) {
+    try {
+      this.decoder.add(e);
+    } catch (t) {
+      this.onclose("parse error", t);
+    }
+  }
+
+  /**
+   * Called when parser fully decodes a packet.
+   *
+   * @private
+   */
+  ondecoded(e) {
+    he(() => {
+      this.emitReserved("packet", e);
+    }, this.setTimeoutFn);
+  }
+
+  /**
+   * Called upon socket error.
+   *
+   * @private
+   */
+  onerror(e) {
+    this.emitReserved("error", e);
+  }
+
+  /**
+   * Creates a new socket for the given `nsp`.
+   *
+   * @return {Socket}
+   * @public
+   */
+  socket(e, t) {
+    let s = this.nsps[e];
+    return s ? this._autoConnect && !s.active && s.connect() : (s = new wt(this, e, t), this.nsps[e] = s), s;
+  }
+
+  /**
+   * Called upon a socket close.
+   *
+   * @param socket
+   * @private
+   */
+  _destroy(e) {
+    const t = Object.keys(this.nsps);
+    for (const s of t) {
+ if (this.nsps[s].active) { return; } 
+}
+    this._close();
+  }
+
+  /**
+   * Writes a packet.
+   *
+   * @param packet
+   * @private
+   */
+  _packet(e) {
+    const t = this.encoder.encode(e);
+    for (let s = 0; s < t.length; s++) { this.engine.write(t[s], e.options); }
+  }
+
+  /**
+   * Clean up transport subscriptions and packet buffer.
+   *
+   * @private
+   */
+  cleanup() {
+    this.subs.forEach((e) => e()), this.subs.length = 0, this.decoder.destroy();
+  }
+
+  /**
+   * Close the current socket.
+   *
+   * @private
+   */
+  _close() {
+    this.skipReconnect = !0, this._reconnecting = !1, this.onclose("forced close");
+  }
+
+  /**
+   * Alias for close()
+   *
+   * @private
+   */
+  disconnect() {
+    return this._close();
+  }
+
+  /**
+   * Called when:
+   *
+   * - the low-level engine is closed
+   * - the parser encountered a badly formatted packet
+   * - all sockets are disconnected
+   *
+   * @private
+   */
+  onclose(e, t) {
+    let s;
+    this.cleanup(), (s = this.engine) === null || s === void 0 || s.close(), this.backoff.reset(), this._readyState = "closed", this.emitReserved("close", e, t), this._reconnection && !this.skipReconnect && this.reconnect();
+  }
+
+  /**
+   * Attempt a reconnection.
+   *
+   * @private
+   */
+  reconnect() {
+    if (this._reconnecting || this.skipReconnect) { return this; }
+    const e = this;
+    if (this.backoff.attempts >= this._reconnectionAttempts) { this.backoff.reset(), this.emitReserved("reconnect_failed"), this._reconnecting = !1; } else {
+      const t = this.backoff.duration();
+      this._reconnecting = !0;
+      const s = this.setTimeoutFn(() => {
+        e.skipReconnect || (this.emitReserved("reconnect_attempt", e.backoff.attempts), !e.skipReconnect && e.open((n) => {
+          n ? (e._reconnecting = !1, e.reconnect(), this.emitReserved("reconnect_error", n)) : e.onreconnect();
+        }));
+      }, t);
+      this.opts.autoUnref && s.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(s);
+      });
+    }
+  }
+
+  /**
+   * Called upon successful reconnect.
+   *
+   * @private
+   */
+  onreconnect() {
+    const e = this.backoff.attempts;
+    this._reconnecting = !1, this.backoff.reset(), this.emitReserved("reconnect", e);
+  }
+}
+const V = {};
+function re(i, e) {
+  typeof i == "object" && (e = i, i = void 0), e = e || {};
+  const t = xs(i, e.path || "/socket.io"), s = t.source, n = t.id, r = t.path, o = V[n] && r in V[n].nsps, a = e.forceNew || e["force new connection"] || e.multiplex === !1 || o;
+  let u;
+  return a ? u = new Ae(s, e) : (V[n] || (V[n] = new Ae(s, e)), u = V[n]), t.query && !e.query && (e.query = t.queryKey), u.socket(t.path, e);
+}
+Object.assign(re, {
+  Manager: Ae,
+  Socket: wt,
+  io: re,
+  connect: re
+});
+class bt {
+  constructor(e, t, s = {}) {
+    this.url = e, this.socket = null, this.reconnect = t, this.query = s, this.eventListeners = {}, this.errorCount = 0, this.isErrorShown = !1, this.maxReconnectAttempts = 5, this.currentReconnectAttempt = 0, this.reconnectDelay = 3e3;
+  }
+  openConnect() {
+    return this.socket && (this.socket.disconnect(), this.socket = null), this.socket = re(this.url, {
+      transports: ["websocket"],
+      // 使用websocket协议
+      autoConnect: !1,
+      reconnection: this.reconnect || !1,
+      timeout: 5e5,
+      forceNew: !0,
+      query: this.query,
+      // 动态查询参数，由调用处传入
+      withCredentials: !0
+      // 跨域时携带 Cookie
+    }), new Promise((e, t) => {
+      this.socket.on("connect", () => {
+        this.errorCount = 0, this.isErrorShown = !1, this.currentReconnectAttempt = 0, console.log("Socket.IO 连接成功"), e(this.socket);
+      }), this.socket.on("connect_error", (s) => {
+        this.errorCount++, this.isErrorShown || (console.error("Socket.IO 连接失败"), console.error("错误详情:", s.message), this.isErrorShown = !0), this.errorCount === 1 && (this.disconnect(), t(new Error(`Socket.IO 连接失败: ${s.message}`)));
+      }), this.socket.on("disconnect", (s) => {
+        console.log("Socket.IO 连接已断开，原因:", s), this.isErrorShown = !1, this.reconnect && s !== "io client disconnect" && (this.currentReconnectAttempt < this.maxReconnectAttempts ? (this.currentReconnectAttempt++, console.log(`准备第 ${this.currentReconnectAttempt} 次重连...`), setTimeout(() => {
+          this.socket.connect();
+        }, this.reconnectDelay)) : console.log("已达到最大重连次数，停止重连"));
+      }), this.socket.connect();
+    });
+  }
+  // 添加事件监听器
+  on(e, t) {
+    if (!this.socket) {
+      console.error("Socket未初始化，请先调用openConnect()");
+      return;
+    }
+    this.socket.on(e, t);
+  }
+  // 移除事件监听器
+  off(e, t) {
+    if (!this.socket) {
+      console.error("Socket未初始化，请先调用openConnect()");
+      return;
+    }
+    this.socket.off(e, t);
+  }
+  // 发送自定义事件
+  emit(e, t) {
+    if (!this.socket) {
+      console.error("Socket未初始化，请先调用openConnect()");
+      return;
+    }
+    this.socket.emit(e, t);
+  }
+  // 断开连接
+  disconnect() {
+    if (!this.socket) {
+      console.error("Socket未初始化，请先调用openConnect()");
+      return;
+    }
+    this.socket.disconnect(), this.socket = null;
+  }
+}
+class Ks extends ue {
+  constructor(e, t, s, n, r) {
+    super(), this.equipStatusObject = t, this.groupNodeObject = s, this.aleadyUpdateStatus = {}, this.isGetAllEquipStatus = !1, this.nodesMap = e, this.statusChange = n, this.openSignlr(), this.aliasName = r;
+  }
+  openSignlr() {
+    const t = `${location.protocol === "https:" ? "https" : "http"}://${location.hostname}:9600`;
+    this.equipStatusSignlr = new bt(
+      t,
+      !0,
+      { hub: "equipStatusMonitor", userName: sessionStorage.userName }
+    ), this.equipStatusSignlr.openConnect().then((s) => {
+      s.on("connect", () => {
+        try {
+          s.emit("invoke", { method: "GetAllEquipStatus", data: {} }), s.emit("invoke", { method: "GetEquipChangeStatus", data: {} });
+        } catch (n) {
+          console.log(n);
+        }
+      });
+      try {
+        s.emit("invoke", { method: "GetAllEquipStatus", data: {} });
+      } catch (n) {
+        console.log(n);
+      }
+      this.subscribeTo(s, "GetAllEquipStatus");
+      try {
+        s.emit("invoke", { method: "GetEquipChangeStatus", data: {} });
+      } catch (n) {
+        console.log(n);
+      }
+      this.subscribeTo(s, "GetEquipChangeStatus");
+    }).catch((s) => {
+      console.error(s);
+    });
+  }
+  subscribeTo(e, t) {
+    e.off(t), e.on(t, (s) => {
+      const n = s == null ? void 0 : s.data;
+      n && n.isSuccess && n.data && (this[t] ? this[t](n.data) : this.notice({ func: t, data: n.data, key: n.groupId }));
+    });
+  }
+  GetAllEquipStatus(e) {
+    this.isGetAllEquipStatus = !0, this.resetGroupStatus(), this.aleadyUpdateStatus = {}, Object.keys(e).forEach((t) => {
+      this.equipStatusObject[t] = e[t];
+    }), Object.keys(this.groupNodeObject).forEach((t) => {
+      this.updateByGroup(t);
+    });
+  }
+  updateByGroup(e) {
+    if (!this.aleadyUpdateStatus[e]) {
+      let t = this.window[`group-${e}${this.aliasName}`] || [];
+      if (t.length) {
+        this.aleadyUpdateStatus[e] = !0;
+        let s = !1, n = !0;
+        t.forEach((r) => {
+          const o = this.equipStatusObject[r.equipNo];
+          o === 1 ? (s = !0, n = !1) : o !== 0 && (n = !1);
+        }), n && this.setOfflineStatus(e), t.forEach((r) => {
+          this.equipStatusObject[r.equipNo] == 2 ? this.setGroupStatus(e, !0, 2) : this.equipStatusObject[r.equipNo] == 6 && this.setGroupStatus(e, !0, 6), this.nodesMap[`${e}-${r.equipNo}`] && (this.nodesMap[`${e}-${r.equipNo}`].status = this.equipStatusObject[r.equipNo]);
+        }), this.nodesMap[e].alarmCounts === 0 && this.nodesMap[e].backUpCounts === 0 && s && (this.nodesMap[e].status = 1, this.nodesMap[e].groupId && this.setNormalStatus(this.nodesMap[e].groupId));
+      }
+    }
+  }
+  updateGroupStatus(e) {
+    this.isGetAllEquipStatus && this.updateByGroup(e);
+  }
+  GetEquipChangeStatus(e) {
+    this.setStatus(e);
+  }
+  // 设置分组状态 key:扁平化数据中节点索引；type:类型（增加，减少）；status:状态（报警2、双机热备6）
+  setGroupStatus(e, t, s) {
+    t ? s == 2 ? (this.nodesMap[e].alarmCounts = this.nodesMap[e].alarmCounts + 1, this.nodesMap[e].alarmCounts > 0 && (this.nodesMap[e].status = 2)) : (this.nodesMap[e].backUpCounts = this.nodesMap[e].backUpCounts + 1, this.nodesMap[e].alarmCounts == 0 && this.nodesMap[e].backUpCounts > 0 && (this.nodesMap[e].status = 6)) : s == 2 ? (this.nodesMap[e].alarmCounts = this.nodesMap[e].alarmCounts - 1, this.nodesMap[e].alarmCounts == 0 && (this.nodesMap[e].status = 1)) : (this.nodesMap[e].backUpCounts = this.nodesMap[e].backUpCounts - 1, this.nodesMap[e].alarmCounts == 0 && (this.nodesMap[e].backUpCounts == 0 ? this.nodesMap[e].status = 1 : this.nodesMap[e].status = 6)), this.nodesMap[e].groupId && this.setGroupStatus(this.nodesMap[e].groupId, t, s);
+  }
+  // 设置分组离线状态并向上冒泡（不覆盖正常、报警、双机热备状态）
+  setOfflineStatus(e) {
+    this.nodesMap[e].status !== 2 && this.nodesMap[e].status !== 6 && this.nodesMap[e].status !== 1 && (this.nodesMap[e].status = 0, this.nodesMap[e].groupId && this.setOfflineStatus(this.nodesMap[e].groupId));
+  }
+  // 设置分组正常状态并向上冒泡（不覆盖报警和双机热备状态）
+  setNormalStatus(e) {
+    this.nodesMap[e].status !== 2 && this.nodesMap[e].status !== 6 && (this.nodesMap[e].status = 1, this.nodesMap[e].groupId && this.setNormalStatus(this.nodesMap[e].groupId));
+  }
+  // 获取设备所属的所有分组ID
+  // 优先从 groupCache 反查（按分组隔离存储，数据准确），兜底从 equipCache 获取
+  getEquipGroupIds(e) {
+    const t = [];
+    if (this.window.groupCache && Object.keys(this.window.groupCache).forEach((s) => {
+      this.window.groupCache[s] && this.window.groupCache[s][e] && t.push(Number(s));
+    }), t.length === 0) {
+      const s = this.window.equipCache && this.window.equipCache[e];
+      if (s) {
+        if (s.groupIds && s.groupIds.length > 0) { return s.groupIds; }
+        s.groupId && t.push(s.groupId);
+      }
+    }
+    return t;
+  }
+  setStatus(e) {
+    let t = this.equipStatusObject[e.equipNo];
+    const s = this.getEquipGroupIds(e.equipNo);
+    e.status != 3 && s.length > 0 && (s.forEach((n) => {
+      switch (e.status) {
+        case 0:
+          t == 6 && this.setGroupStatus(n, !1, 6);
+          break;
+        case 1:
+          t == 6 ? this.setGroupStatus(n, !1, 6) : t == 2 && this.setGroupStatus(n, !1, 2);
+          break;
+        case 2:
+          t != 2 && this.setGroupStatus(n, !0, 2), t == 6 && this.setGroupStatus(n, !1, 6);
+          break;
+        case 6:
+          t == 2 && this.setGroupStatus(n, !1, 2), t != 6 && this.setGroupStatus(n, !0, 6);
+          break;
+      }
+      let r = `${n}-${e.equipNo}`;
+      this.nodesMap[r] && (this.nodesMap[r].status = e.status);
+    }), this.equipStatusObject[e.equipNo] = e.status, this.statusChange(s[0], e.equipNo, e.status));
+  }
+  // 重置分组状态
+  resetGroupStatus() {
+    for (let e in this.groupNodeObject) { this.groupNodeObject[e].alarmCounts = 0, this.groupNodeObject[e].backUpCount = 0; }
+  }
+  // 断开 Socket.IO 连接
+  disconnect() {
+    this.equipStatusSignlr && (this.equipStatusSignlr.disconnect(), this.equipStatusSignlr = null);
+  }
+}
+const Ws = {
+  getSetParm(i) {
+    if (window.AxiosBuilder.axios) {
+ return window.AxiosBuilder.axios({
+        method: "post",
+        url: "/IoT/api/v3/EquipList/GetFullSetParmByEquipNo",
+        params: i,
+        data: i,
+        headers: {
+          "Content-Type": "application/json;charset=UTF-8",
+          "Accept-Language": window.sessionStorage.languageType || "zh-CN"
+        }
+      }); 
+}
+  }
+}, Hs = Object.assign(
+  {},
+  Ws
+);
+class Js {
+  constructor(e, t) {
+    this.nodesMap = e, this.equipControllObject = t;
+  }
+  // 获取设备控制项
+  async getSetting(e, t, s, n) {
+    let [r, o] = String(e).split("-"), a = {
+      equipNo: o
+    };
+    await Hs.getSetParm(a).then((u) => {
+      if (u.data.code == 200) {
+        let c = u && u.data && u.data.data && u.data.data.rows || [];
+        this.nodesMap[e].settings || (this.nodesMap[e].settings = []), c && c.length > 0 && this.nodesMap[e] && (c.forEach((h) => {
+          h.title = h.setNm, h.key = `${r}-${o}-${h.setNo}`, h.level = Number(s) + 1, h.checked = n || this.equipControllObject[o] && this.equipControllObject[o].includes(h.setNo), h.isSetting = !0, h.equipNo = o, h.groupId = r, h.setNo = h.setNo, h.equipName = t;
+        }), this.nodesMap[e].settings = [...c]);
+      }
+    });
+  }
+}
+class M {
+  static formateList(e, t) {
+    let s = [];
+    for (const n of e) {
+      let r = {};
+      r.count = 0, r.equipSelectCount = 0, r.controlSelectCount = 0, r.equipCount = n.equipCount || 0, r.title = n.name, r.key = n.id, r.isGroup = !0, r.children = [], r.status = 1, r.level = t || 1, r.expand = !t, r.equips = [], r.groupId = n.parentId, r.groups = [], r.alarmCounts = 0, r.backUpCounts = 0, r.indeterminate = !1, r.checked = !1, r.visible = !0, r.nodeEquipSelectCount = 0, r.checkedEquips = [], r.halfCheckedEquips = [], r.selectControlCount = 0, n.children && n.children.length > 0 && (r.groups = [
+        ...this.formateList(n.children, t ? t + 1 : 2)
+      ]), s.push(r);
+    }
+    return s;
+  }
+  static deepClone(e, t, s, n, r, o) {
+    let a = [];
+    if (e) {
+ for (let u = 0, c = e.length; u < c; u++) {
+        const h = e[u].id || e[u].equipNo, l = `${n}-${h}`;
+        a.push(
+          {
+            isGroup: s,
+            key: l,
+            status: o[h] || 0,
+            title: e[u].title,
+            level: t,
+            expand: !1,
+            isEquip: !0,
+            loading: !1,
+            indeterminate: r[l] && r[l].indeterminate || !1,
+            checked: r[l] && r[l].checked || !1,
+            groupId: n,
+            equipNo: h,
+            visible: !0,
+            settings: []
+          }
+        );
+      } 
+}
+    return a;
+  }
+  static copyOrigin(e) {
+    let t = [];
+    return e.forEach((s) => {
+      t.push({ ...s });
+    }), t;
+  }
+  // 获取分组位置
+  static getPosition(e, t) {
+    let s = 0;
+    for (let n = 0, r = t.length; n < r; n++) {
+ if (t[n].key == e) {
+        s = n - 30;
+        break;
+      } 
+}
+    return s;
+  }
+  // 扁平化
+  static flattern(e, t) {
+    e.forEach((s) => {
+      if (s.isGroup) {
+        const n = t[`${s.key}`];
+        t[`${s.key}`] = s, n && (s.alarmCounts = n.alarmCounts, s.backUpCounts = n.backUpCounts, s.status = n.status);
+      }
+      s.groups && s.groups.length && this.flattern(s.groups, t);
+    });
+  }
+
+  /**
+    * @description 生成唯一Id
+    * @param {}  不用传参
+    * @return {string}
+  */
+  static generateUUID() {
+    let e = (/* @__PURE__ */ new Date()).getTime();
+    return window.performance && typeof window.performance.now == "function" && (e += performance.now()), "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(s) {
+      let n = (e + Math.random() * 16) % 16 | 0;
+      return e = Math.floor(e / 16), (s === "x" ? n : n & 3 | 8).toString(16);
+    });
+  }
+
+  /**
+     * @description  将普通列表转换为树结构的列表
+     * @param {list} 可构建树形结构的普通列表  
+     * @return {string}
+  */
+  static listToTreeList(e) {
+    const t = e, s = [], n = {};
+    return t.forEach((r) => {
+      n[r.id] = r;
+    }), t.forEach((r) => {
+      const o = n[r.parentId];
+      o ? (o.children || (o.children = [])).push(r) : s.push(r);
+    }), s;
+  }
+}
+class Ys extends ue {
+  // 分组节点扁平化对象、设备扁平化对象、window缓存设备扁平化对象
+  constructor(e, t, s) {
+    super(), this.showSettings = t, this.groupNodeObject = e, this.aliasName = s;
+  }
+  // 触发搜索
+  filterMethod(e) {
+    for (let t in this.groupNodeObject) { e && this.updateBySearch(t, e); }
+  }
+  // 搜索状态将搜索的结果存放缓存中
+  updateBySearch(e, t) {
+    let s = this.window[`group-${this.groupNodeObject[e].key}${this.aliasName}`];
+    s && (s = s.filter((n) => n.title.includes(t)), this.window[`group-${this.groupNodeObject[e].key}-search`] = M.copyOrigin(s));
+  }
+}
+const le = (i, e) => {
+  const t = i.__vccOpts || i;
+  for (const [s, n] of e) { t[s] = n; }
+  return t;
+}, Xs = {
+  props: {
+    source: {
+      type: Object,
+      default: () => {
+      }
+    },
+    groupEditAndNew: {
+      type: Function,
+      default: () => {
+      }
+    },
+    deleteGroup: {
+      type: Function,
+      default: () => {
+      }
+    }
+  }
+}, Qs = { class: "operates" };
+function Zs(i, e, t, s, n, r) {
+  const o = G("el-button"), a = G("el-button-group"), u = G("el-popover");
+  return E(), T("div", Qs, [
+    S(u, {
+      placement: "bottom",
+      trigger: "hover"
+    }, {
+      reference: P(() => e[6] || (e[6] = [
+        x("i", { class: "iconfont icon-_gengduo" }, null, -1)
+      ])),
+      default: P(() => [
+        S(a, { class: "new-button-group setModule" }, {
+          default: P(() => [
+            S(o, {
+              type: "text",
+              size: "small",
+              class: "elBtn",
+              onClick: e[0] || (e[0] = _e((c) => t.groupEditAndNew(!1, t.source), ["stop"]))
+            }, {
+              default: P(() => [
+                e[3] || (e[3] = x("i", { class: "iconfont icon-tubiao20_bianji" }, null, -1)),
+                be(" " + H(i.$t("equipInfo.poverTips.rename")), 1)
+              ]),
+              _: 1,
+              __: [3]
+            }),
+            S(o, {
+              type: "text",
+              size: "small",
+              class: "elBtn",
+              onClick: e[1] || (e[1] = (c) => t.groupEditAndNew(!0, t.source))
+            }, {
+              default: P(() => [
+                e[4] || (e[4] = x("i", { class: "iconfont icon-tubiao20_tianjiashebei" }, null, -1)),
+                be(" " + H(i.$t("equipInfo.poverTips.newChildGroup")), 1)
+              ]),
+              _: 1,
+              __: [4]
+            }),
+            t.source.level != 1 ? (E(), oe(o, {
+              key: 0,
+              type: "text",
+              size: "small",
+              class: "delete-btn",
+              onClick: e[2] || (e[2] = _e((c) => t.deleteGroup(t.source), ["stop"]))
+            }, {
+              default: P(() => [
+                e[5] || (e[5] = x("i", { class: "iconfont icon-tubiao20_shanchu" }, null, -1)),
+                be(" " + H(i.$t("publics.button.deletes")), 1)
+              ]),
+              _: 1,
+              __: [5]
+            })) : L("", !0)
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    })
+  ]);
+}
+const ei = /* @__PURE__ */ le(Xs, [["render", Zs]]), ti = {
+  name: "ElTreeVirtualNode",
+  componentName: "ElTreeVirtualNode",
+  props: {
+    searchName: {
+      type: String,
+      default: ""
+    },
+    expanding: {
+      type: Boolean,
+      default: !1
+    },
+    aleadyLoadAll: {
+      type: Boolean,
+      default: !1
+    },
+    groupLoading: {
+      type: Boolean,
+      default: !1
+    },
+    source: {
+      type: Object,
+      default() {
+        return {};
+      }
+    },
+    showCheckbox: {
+      type: Boolean,
+      default: !1
+    },
+    showStatus: {
+      type: Boolean,
+      default: !1
+    },
+    showOperate: {
+      type: Boolean,
+      default: !1
+    },
+    currentSelect: {
+      type: [Number, String],
+      default: -1
+    },
+    nodeClick: {
+      type: Function
+    },
+    onChecked: {
+      type: Function
+    },
+    groupEditAndNew: {
+      type: Function
+    },
+    deleteGroup: {
+      type: Function
+    },
+    childrenResetGroupNum: {
+      type: Function
+    },
+    getEquipStatus: {
+      type: Function
+    },
+    colorConfig: {
+      type: Object,
+      default: () => {
+      }
+    },
+    index: {
+      type: Number,
+      default: -1
+    }
+  },
+  components: {
+    oparate: ei
+  },
+  computed: {
+    getColor() {
+      return function(i) {
+        this.colorConfig || (this.colorConfig = {
+          noComm: "#a0a0a0",
+          normal: "#63e03f",
+          alarm: "#f22433",
+          lsSet: "#bebcaa",
+          initialize: "#289ac0",
+          withdraw: "#ffc0cb",
+          BackUp: "#f8901c"
+        });
+        let e;
+        switch (i) {
+          case 0:
+            e = this.colorConfig.noComm;
+            break;
+          case 1:
+            e = this.colorConfig.normal;
+            break;
+          case 2:
+            e = this.colorConfig.alarm;
+            break;
+          case 3:
+            e = this.colorConfig.lsSet;
+            break;
+          case 4:
+            e = this.colorConfig.initialize;
+            break;
+          case 5:
+            e = this.colorConfig.withdraw;
+            break;
+          case 6:
+            e = this.colorConfig.BackUp;
+            break;
+          default:
+            e = this.colorConfig.noComm;
+            break;
+        }
+        return e;
+      };
+    }
+  },
+  data() {
+    return {
+      indent: 13
+    };
+  },
+  methods: {
+    clickFunction() {
+      this.source.expand = !this.source.expand, this.nodeClick(this.source, this.index, this.source.level, this.source.checked);
+    },
+    checkedChange(i) {
+      this.onChecked(this.source);
+    }
+  }
+}, si = { class: "el-tree-node__content" }, ii = { class: "nodeContent" }, ni = {
+  key: 1,
+  class: "circle"
+}, ri = { class: "label" }, oi = {
+  key: 2,
+  class: "equipNumber"
+}, ai = {
+  key: 4,
+  class: "el-tree-node__loading-icon el-icon-loading"
+};
+function ui(i, e, t, s, n, r) {
+  const o = G("el-checkbox"), a = G("oparate");
+  return E(), T("div", {
+    class: Ve(["el-tree-node", {
+      parent_tag: t.source.isGroup,
+      child_tags: !t.source.isGroup,
+      selectedColor: t.currentSelect === t.source.key && !t.source.isGroup
+    }]),
+    onClick: e[2] || (e[2] = (...u) => r.clickFunction && r.clickFunction(...u))
+  }, [
+    x("div", si, [
+      x("span", {
+        class: "el-tree__indent",
+        "aria-hidden": "true",
+        style: Se({ width: (t.source.level - 1) * n.indent + "px" })
+      }, null, 4),
+      t.source.isGroup ? (E(), T("span", {
+        key: 0,
+        class: Ve([
+          {
+            "is-leaf": !t.source.isGroup,
+            expanded: t.source.isGroup && t.source.expand
+          },
+          "el-tree-node__expand-icon",
+          "iconfont icon-fangxiangL"
+        ])
+      }, null, 2)) : L("", !0),
+      x("div", ii, [
+        t.showCheckbox ? (E(), oe(o, {
+          key: 0,
+          onClick: e[0] || (e[0] = _e(() => {
+          }, ["stop"])),
+          modelValue: t.source.checked,
+          "onUpdate:modelValue": e[1] || (e[1] = (u) => t.source.checked = u),
+          indeterminate: t.source.indeterminate,
+          onChange: r.checkedChange
+        }, null, 8, ["modelValue", "indeterminate", "onChange"])) : L("", !0),
+        t.showStatus ? (E(), T("span", ni, [
+          t.source.status != 6 ? (E(), T("span", {
+            key: 0,
+            class: "yd",
+            style: Se({ backgroundColor: r.getColor(t.source.status) })
+          }, null, 4)) : (E(), T("i", {
+            key: 1,
+            style: Se({ color: t.colorConfig.BackUp }),
+            class: "iconfont icon-gw-icon-beiji2"
+          }, null, 4))
+        ])) : L("", !0),
+        x("span", ri, H(t.source.title), 1),
+        t.source.isGroup && !t.source.isEquip || t.source.isGroup && !t.source.isEquip ? (E(), T("span", oi, H(t.source.count), 1)) : L("", !0),
+        t.source.isGroup && t.showOperate ? (E(), oe(a, {
+          key: 3,
+          source: t.source,
+          groupEditAndNew: t.groupEditAndNew,
+          deleteGroup: t.deleteGroup
+        }, null, 8, ["source", "groupEditAndNew", "deleteGroup"])) : L("", !0),
+        t.source.loading ? (E(), T("span", ai)) : L("", !0)
+      ])
+    ])
+  ], 2);
+}
+const hi = /* @__PURE__ */ le(ti, [["render", ui]]), ci = {
+  components: {
+    VirtualList: Kt
+  },
+  mixins: [it],
+  data() {
+    return {
+      itemComponent: hi,
+      //节点组件
+      visibleList: [],
+      //虚拟滚动所需要的列表
+      currentSelect: -1,
+      //当前选中的节点（不包含分组节点）
+      equipStatusManage: null,
+      //设备状态管理工具
+      cacheManage: null,
+      //内存管理工具
+      searchManage: null,
+      //搜索管理工具
+      equipNumManage: null,
+      //设备数量管理工具
+      requestManage: null,
+      //请求管理工具
+      checkStatusManage: null,
+      //请求管理工具
+      groupNodeObject: {},
+      //所有分组扁平化所保存的存储的地方
+      nodesMap: {},
+      //所有实例化对象映射
+      equipCheckObject: {},
+      //设备选中状态记录 equipCheckObject：{xxx设备号：{indeterminate: false,checked: false,groupId:xxx}}
+      equipStatusObject: {},
+      //记录设备状态,从后台推送的初始化全量状态,增量更新需要实时维护
+      controlObject: {},
+      //展开的控制项,controlObject:{xxx设备号：{groupId:xxx}}用于设置当前展开设置选中，如果依赖与equipControlObject筛选设置选中，性能差
+      isSearchStatus: !1,
+      //是否是搜索状态
+      equipControllObject: {},
+      //绑定所有的已选中的设备控制项
+      expandGroup: [],
+      //记录已展开的分组
+      updateJob: null,
+      filterEquipList: []
+      //过滤条件下新增的设备列表，由于设备开始状态都是0，因而需要单独维护
+    };
+  },
+  props: {
+    data: {
+      //分组列表
+      type: Array
+    },
+    selectEquips: {
+      //设备选中列表，用于回显，如权限管理。支持数组格式 [equipNo] 或对象格式 { groupId: [equipNo] }
+      type: [Array, Object],
+      default: () => []
+    },
+    controllList: {
+      //控制项选中列表，用于回显，如权限管理
+      type: Array,
+      default: () => []
+    },
+    showSettings: {
+      //是否需要加载设备控制项，如权限管理
+      type: Boolean,
+      default: !1
+    },
+    showSelectNum: {
+      //是否在树形结构顶部展示已选设备数量，如设备管理
+      type: Boolean,
+      default() {
+        return !1;
+      }
+    },
+    showCheckbox: {
+      //是否展示checkbox
+      type: Boolean,
+      default: !1
+    },
+    showStatus: {
+      //是否展示设备状态
+      type: Boolean,
+      default: !1
+    },
+    filterEquip: {
+      //是否过滤
+      type: Boolean,
+      default: !1
+    },
+    showOperate: {
+      // 是否展示操作按钮
+      type: Boolean,
+      default: !1
+    },
+    defaultExpandAll: {
+      type: Boolean,
+      default: !1
+    },
+    currentNodeKey: [String, Number],
+    colorConfig: {
+      type: Object,
+      default: () => ({
+        noComm: "#a0a0a0",
+        normal: "#63e03f",
+        alarm: "#f22433",
+        lsSet: "#bebcaa",
+        initialize: "#289ac0",
+        withdraw: "#ffc0cb",
+        BackUp: "#f8901c"
+      })
+    },
+    treeType: {
+      type: String,
+      default: ""
+    },
+    buildTree: {
+      type: Function,
+      default: () => {
+      }
+    },
+    filterData: {
+      type: Function,
+      default: () => {
+      }
+    },
+    alias: {
+      type: String,
+      default: ""
+    }
+  },
+  watch: {
+    data(i) {
+      i && i.length && (M.flattern(this.data, this.groupNodeObject), this.cacheManage.addNodesMap(Object.values(this.groupNodeObject).map((e) => e)), this.init());
+    },
+    controllList(i) {
+      this.updateCheckedStatusWithControls();
+    },
+    selectEquips(i) {
+      this.updateCheckedStatusWithEquips(), this.$nextTick(() => {
+        this.checkStatusManage && this.checkStatusManage.updateGroupCheckStatus();
+      });
+    },
+    filterEquip(i) {
+      this.$nextTick(() => {
+        this.visibleList = [], this.$refs.virtualList.scrollToIndex(0), this.updateTreeList(this.data), this.equipNumManage.resetGroupNum(this.isSearchStatus, i, this.equipStatusObject);
+      });
+    }
+  },
+  computed: {
+    aliasName() {
+      return this.alias ? `-${this.alias}` : "";
+    }
+  },
+  created() {
+    this.showCheckbox && (this.checkStatusManage = new Ht(this.groupNodeObject, this.nodesMap, this.equipControllObject, this.controlObject, this.equipCheckObject, this.aliasName)), this.cacheManage = new Wt(this.groupNodeObject, this.nodesMap, this.controlObject, this.equipCheckObject), this.searchManage = new Ys(this.groupNodeObject, this.showSettings, this.aliasName), this.equipNumManage = new Jt(this.groupNodeObject, this.aliasName), this.requestManage = new Js(this.nodesMap, this.equipControllObject);
+  },
+  mounted() {
+    this.updateCheckedStatusWithControls(), this.updateCheckedStatusWithEquips(), window.addEventListener("message", (i) => {
+      i.data.type && this[i.data.type] && this[i.data.type](i.data.data);
+    });
+  },
+  methods: {
+    // 初始化
+    init() {
+      this.data[0].expand = !0, this.updateTreeList(), setTimeout(() => {
+        Object.values(this.groupNodeObject).forEach((i, e) => {
+          !i.expand && this.expandGroup.includes(i.key) && (i.expand = !0), this.filterWithAlias(i.key), this.updateGroupEquips(i.key, !0);
+        }), this.showCheckbox && this.checkStatusManage && this.checkStatusManage.updateGroupCheckStatus(), this.showStatus && !this.equipStatusManage && (this.equipStatusManage = new Ks(this.nodesMap, this.equipStatusObject, this.groupNodeObject, this.statusChange, this.aliasName));
+      }, 500);
+    },
+    // 根据条件过滤
+    filterWithAlias(i) {
+      if (this.aliasName) {
+        let e = this.window[`group-${i}`] || [];
+        this.window[`group-${i}${this.aliasName}`] = this.filterData(e);
+      }
+    },
+    // 更新当前选中
+    updateCurrentSelect() {
+      this.window.equipCache && this.window.equipCache[this.currentNodeKey] && (this.currentSelect = `${this.window.equipCache[this.currentNodeKey].groupId}-${this.currentNodeKey}`);
+    },
+    // 设备状态变化
+    statusChange(i, e, t) {
+      this.currentSelect == `${i}-${e}` && this.$emit("statusChange", e, t);
+    },
+    // 更新checkbox选中状态
+    updateCheckWidthJob() {
+      this.showCheckbox && (this.checkStatusManage.resetCheckedStatus(), this.updateCheckedStatusWithControls(), this.updateCheckedStatusWithEquips(), this.checkStatusManage && this.checkStatusManage.updateGroupCheckStatus());
+    },
+    // 通过外框更新设备
+    updateGroupEquips(i, e) {
+      if (!this.isSearchStatus && this.groupNodeObject[i]) {
+        let t = this.equipNumManage.getAllEquipsNum();
+        this.$emit("getTotal", t);
+      }
+      this.equipNumManage.resetGroupNum(this.isSearchStatus, this.filterEquip, this.equipStatusObject), this.groupNodeObject[i].expand && this.updateList(i, this.groupNodeObject[i].level, null, !1);
+    },
+    // 展开的时候从缓存中拿设备数据到equips中并更新视图
+    updateList(i) {
+      if (this.groupNodeObject[i]) {
+        let e = [];
+        this.isSearchStatus ? (e = this.window[`group-${i}-search`], this.groupNodeObject[i].equips = [...M.deepClone(e, Number(this.groupNodeObject[i].level) + 1, this.showSettings, i, this.equipCheckObject, this.equipStatusObject)]) : (e = this.window[`group-${i}${this.aliasName}`], this.groupNodeObject[i].equips = [...M.deepClone(e, Number(this.groupNodeObject[i].level) + 1, this.showSettings, i, this.equipCheckObject, this.equipStatusObject)]), this.cacheManage.addNodesMap(this.groupNodeObject[i].equips), this.cacheManage.closeBrotherNode(i), this.visibleList = [], this.updateTreeList(this.data), this.showCheckbox && this.checkStatusManage && e && e.length && this.checkStatusManage.updateGroupCheckStatus(), this.showStatus && this.equipStatusManage && this.equipStatusManage.updateGroupStatus(i), this.updateCurrentSelect();
+      }
+    },
+    // 更新整个树形结构
+    updateTreeList(i) {
+      i && i.length > 0 && i.forEach((e) => {
+        this.filterEquip && e.status === 2 ? this.filterEquipList.includes(e.equipNo) || this.visibleList.push(e) : this.filterEquip || this.visibleList.push(e), e.expand ? e.isEquip ? (e.children || (e.children = []), e.settings && (e.children = [...e.settings || []])) : e.children = [...e.equips || [], ...e.groups || []] : e.children = [], this.updateTreeList(e.children || []);
+      });
+    },
+    // 节点点击事件
+    nodeClick(i, e, t, s) {
+      this.$emit("node-click", { ...i, key: i.isEquip ? i.equipNo : i.key }), i.isGroup ? i.isEquip ? this.equipClick(i, e, s) : this.groupClick(i, e, s) : this.currentSelect = i.key;
+    },
+    groupClick(i, e, t) {
+      i.expand ? this.updateList(i.key, i.level, e, t) : (this.cacheManage.recycleGroupCache(i.key), this.visibleList = [], this.updateTreeList(this.data));
+    },
+    async equipClick(i, e, t) {
+      this.showSettings && (i.expand ? (i.loading = !0, await this.requestManage.getSetting(i.key, i.title, i.level, t), this.controlObject[`${i.groupId}-${i.equipNo}`] = { groupId: i.groupId }, i.loading = !1, this.visibleList.splice(e + 1, 0, ...this.nodesMap[i.key].settings), this.cacheManage.addNodesMap(this.nodesMap[i.key].settings)) : (this.visibleList.splice(e + 1, this.nodesMap[i.key].settings.length), this.cacheManage.removeNodesMap(this.nodesMap[i.key].settings), this.nodesMap[i.key].settings = [], delete this.controlObject[`${i.groupId}-${i.equipNo}`]));
+    },
+    onChecked(i) {
+      this.checkStatusManage && this.checkStatusManage.onChecked(i, this.isSearchStatus), this.$emit("onCheck");
+    },
+    groupEditAndNew(i, e) {
+      this.$emit("groupEditAndNew", { isGroupNew: i, node: e });
+    },
+    deleteGroup(i) {
+      this.$emit("deleteGroup", i);
+    },
+    updateCheckedStatusWithControls() {
+      this.controllList && this.controllList.length && this.checkStatusManage && this.checkStatusManage && this.checkStatusManage.updateCheckedStatusWithControls(this.controllList);
+    },
+    updateCheckedStatusWithEquips() {
+      if (!this.checkStatusManage || !this.selectEquips) { return; }
+      (Array.isArray(this.selectEquips) ? this.selectEquips.length > 0 : Object.keys(this.selectEquips).length > 0) && (this.checkStatusManage.updateCheckedStatusWithEquips(this.selectEquips), this.checkStatusManage.updateGroupCheckStatus());
+    },
+    resetCheckedStatus() {
+      this.checkStatusManage && this.checkStatusManage.resetCheckedStatus();
+    },
+
+    /**
+     * @description 获取选择的设备
+     *  @return Array
+     */
+    getEquipSelectd() {
+      return this.checkStatusManage && this.checkStatusManage.getEquipSelectd();
+    },
+
+    /**
+     * @description 获取选择的设备(携带分组)
+     *  @return Array
+     */
+    getEquipGroupSelectd() {
+      return this.checkStatusManage && this.checkStatusManage.getEquipGroupSelectd();
+    },
+
+    /**
+     * @description 获取选择的设备控制项
+     *  @return Array
+     */
+    getControlSelected() {
+      return this.checkStatusManage && this.checkStatusManage.getControlSelected();
+    },
+
+    /**
+     * @description 记录已展开的分组
+     *  @return 无
+     */
+    recordExpandGroup() {
+      this.expandGroup = [], Object.values(this.groupNodeObject).forEach((i) => {
+        i.expand && this.expandGroup.push(i.key);
+      });
+    },
+
+    /**
+     * @description 清除已展开的分组
+     *  @return
+     */
+    removeExpandGroup() {
+      this.$nextTick(() => {
+        this.expandGroup = [];
+      });
+    },
+
+    /**
+     * @description 搜索设备
+     *    1：清除所有节点缓存
+          2: 设置搜索状态为true,搜索状态下所有操作全部不更新
+          3: 非搜索状态，需要清除搜索缓存
+     * @param {searchName}  搜索名称
+     *  @return 无返回值
+     */
+    filterMethod(i) {
+      this.visibleList = [], this.cacheManage.recycleAllNodeCache(), i ? (this.isSearchStatus = !0, this.searchManage.filterMethod(i)) : this.isSearchStatus = !1, this.init(), this.$nextTick(() => {
+        this.$refs.virtualList.scrollToIndex(0);
+      }), this.equipNumManage.resetGroupNum(this.isSearchStatus, this.filterEquip, this.equipStatusObject), this.showCheckbox && (this.checkStatusManage && this.checkStatusManage.reComputedCheckNum(this.isSearchStatus), this.checkStatusManage && this.checkStatusManage.updateGroupCheckStatus());
+    },
+    // 重新构建树
+    rebuildTree() {
+      this.recordExpandGroup(), this.checkStatusManage && this.checkStatusManage.resetCheckedStatus(), this.cacheManage.recycleAllNodeCache(!0), this.$nextTick(() => {
+        this.buildTree(), this.removeExpandGroup();
+      });
+    },
+    // 树形结构销毁
+    destroyTree() {
+      this.cacheManage.recycleAllNodeCache(!0), this.visibleList = [], this.updateTreeList(this.data);
+    },
+    // 通过外框事件更新树形结构数据--start
+    /**
+     * @description 获取分组设备
+     * @param {data}  {分组Id}
+     *  @return 无返回值
+     */
+    GetGroupEquips(i) {
+      i.groupId && this.groupNodeObject[i.groupId] && !this.isSearchStatus && (this.updateGroupEquips(i.groupId, !0), this.updateJob && clearTimeout(this.updateJob), this.updateJob = setTimeout(() => {
+        this.equipNumManage.resetGroupNum(this.isSearchStatus, this.filterEquip, this.equipStatusObject), this.updateCheckWidthJob();
+      }, 500));
+    },
+
+    /**
+      * @description 删除设备
+      * @param {data}  {groupId,equips}
+      *  @return 无返回值
+    */
+    DeleteEquip(i) {
+      const { groupId: e, equips: t } = i || {};
+      e && this.groupNodeObject[e] && (this.updateGroupEquips(i.groupId), this.equipNumManage.resetGroupNum(), this.checkStatusManage && this.checkStatusManage.resetCheckedStatus()), t.length && t.forEach((s) => {
+        let n = this.nodesMap[`${e}-${s.id}`];
+        n && (this.currentSelect.toString().includes(s.id) && this.$emit("currentDelete"), this.showStatus && (n.status == 2 ? this.equipStatusManage.setGroupStatus(e, !1, 2) : n.status == 6 && this.equipStatusManage.setGroupStatus(e, !1, 6)), delete this.nodesMap[`${e}-${s.id}`], delete this.equipCheckObject[s.id]), delete this.equipStatusObject[s.id];
+      });
+    },
+
+    /**
+      * @description 移动设备
+      * @param {data} {updateGroups} 需要更新的分组列表
+      *  @return 无返回值
+    */
+    MoveEquips(i) {
+      const { updateGroups: e, buildTree: t } = i || {};
+      !t && e ? e.forEach((s) => {
+        s && this.groupNodeObject[s] && (this.updateGroupEquips(s), this.equipNumManage.resetGroupNum(), this.checkStatusManage && this.checkStatusManage.resetCheckedStatus());
+      }) : t && this.rebuildTree();
+    },
+
+    /**
+       * @description 删除分组
+       * @param {data}  {groupId,parentGroupId}
+       * @return 无返回值
+    */
+    DeleteEquipGroup(i) {
+      i.forEach((e) => {
+        e.groupId && this.nodesMap[e.groupId] && (this.isSearchStatus || this.rebuildTree());
+      });
+    },
+
+    /**
+       * @description 新增分组
+       * @param {data}  {groupId,parentGroupId}
+       * @return 无返回值
+    */
+    AddEquipGroup(i) {
+      const { parentGroupId: e, groupId: t } = i || {};
+      t && this.nodesMap[e] && this.treeType && (this.isSearchStatus || this.rebuildTree());
+    },
+
+    /** 编辑分组
+       * @description 新增分组
+       * @param {data}  {groupId,parentGroupId}
+       * @return 无返回值
+    */
+    EditEquipGroup(i) {
+      const { groupId: e, groupName: t } = i;
+      this.nodesMap[e] && (this.nodesMap[e].title = t);
+    },
+
+    /**
+     * @description 新增分组设备
+     * @param {data}  {分组Id,设备}
+     *  @return 无返回值
+     */
+    AddEquip(i) {
+      const { groupId: e } = i || {};
+      this.filterEquip && (this.filterEquipList = i == null ? void 0 : i.equips.map((t) => t.id)), e && this.groupNodeObject[e] && !this.isSearchStatus ? (this.updateGroupEquips(e, !0), this.updateJob && clearTimeout(this.updateJob), this.updateJob = setTimeout(() => {
+        this.updateCheckWidthJob();
+      }, 500)) : e && !this.isSearchStatus && this.rebuildTree();
+    },
+
+    /**
+    * @description 新增分组设备
+    * @param {data}  {分组Id,设备}
+    * @return 无返回值
+    */
+    EditEquip(i) {
+      const { equipNo: e, groupId: t, equipName: s } = i || {};
+      this.nodesMap[`${t}-${e}`] && (this.isSearchStatus || (this.nodesMap[`${t}-${e}`].title = s));
+    },
+
+    /**
+        * @description 重置分组数量
+        * @param {isSearchStatus}  {是否查询状态}
+        * @return 无返回值
+    */
+    childrenResetGroupNum(i) {
+      this.equipNumManage.resetGroupNum(i, this.filterEquip, this.equipStatusObject);
+    },
+
+    /**
+     * @description 获取设备状态
+     * @param {data}  {equipNo}
+     * @return arry[equipNo]
+     */
+    getEquipStatus(i) {
+      return this.equipStatusManage.equipStatusObject[i];
+    }
+    // 通过外框事件更新树形结构数据--end
+  }
+}, li = {
+  class: "gw-tree",
+  style: { height: "100%" }
+}, di = {
+  class: "tree",
+  style: { height: "100%" }
+};
+function pi(i, e, t, s, n, r) {
+  const o = G("virtual-list", !0);
+  return E(), T("div", li, [
+    x("div", di, [
+      S(o, {
+        ref: "virtualList",
+        class: "virtualList",
+        "data-key": "key",
+        "data-sources": n.visibleList,
+        "data-component": n.itemComponent,
+        keeps: 40,
+        "extra-props": {
+          currentSelect: n.currentSelect,
+          nodeClick: r.nodeClick,
+          showStatus: t.showStatus,
+          filterEquip: t.filterEquip,
+          showSettings: t.showSettings,
+          showCheckbox: t.showCheckbox,
+          onChecked: r.onChecked,
+          showOperate: t.showOperate,
+          groupEditAndNew: r.groupEditAndNew,
+          deleteGroup: r.deleteGroup,
+          colorConfig: t.colorConfig,
+          childrenResetGroupNum: r.childrenResetGroupNum,
+          getEquipStatus: r.getEquipStatus
+        }
+      }, null, 8, ["data-sources", "data-component", "extra-props"])
+    ])
+  ]);
+}
+const fi = /* @__PURE__ */ le(ci, [["render", pi]]);
+class gi {
+  constructor() {
+    const t = `${location.protocol === "https:" ? "https" : "http"}://${location.hostname}:9600`;
+    this.eGroupNotify = new bt(
+      t,
+      !0,
+      { hub: "eGroupNotify", userName: sessionStorage.userName }
+    ), this.alreadyUpdate = {}, this.notify = null, this.window = window;
+    try {
+      window.top.equipGroup, this.window = window.top;
+    } catch {
+      this.window = window;
+    }
+  }
+  stop() {
+    this.notify && this.notify.disconnect();
+  }
+  Init() {
+    this.eGroupNotify.openConnect().then((e) => {
+      this.notify = e;
+      try {
+        e.emit("invoke", { method: "GetEquipGroupTree", data: {} }), e.emit("invoke", { method: "GetAllEquipGroupTree", data: {} });
+      } catch (t) {
+        console.log(t);
+      }
+      this.subscribeTo(e, "GetEquipGroupTree"), this.subscribeTo(e, "AddEquipGroup"), this.subscribeTo(e, "EditEquipGroup"), this.subscribeTo(e, "DeleteEquipGroup");
+      try {
+        e.emit("invoke", { method: "GetGroupEquips", data: {} });
+      } catch (t) {
+        console.log(t);
+      }
+      this.subscribeTo(e, "GetGroupEquips"), this.subscribeTo(e, "AddEquip"), this.subscribeTo(e, "DeleteEquip"), this.subscribeTo(e, "EditEquip"), this.subscribeTo(e, "MoveEquips"), this.subscribeTo(e, "CopyEquips"), this.subscribeTo(e, "GetAllEquipGroupTree");
+    }).catch((e) => {
+      console.error(e);
+    });
+  }
+  subscribeTo(e, t) {
+    e.off(t), e.on(t, (s) => {
+      const n = s == null ? void 0 : s.data;
+      n && n.isSuccess && (this[t] ? this[t](n.data) : this.notice({ func: t, data: n.data, key: n.groupId }));
+    });
+  }
+  // 获取分组---无权限管理的分组列表--空设备分组不展示
+  GetEquipGroupTree(e) {
+    this.window.groupList || (this.window.groupList = e, this.notice({ type: "GetEquipGroupTree" }));
+  }
+  // 获取全量分组---设备管理使用
+  GetAllEquipGroupTree(e) {
+    this.window.groupList_manageMent || (this.window.groupList_manageMent = e, this.notice({ type: "GetEquipGroupTreeWidthTreeType" }));
+  }
+  // 新增分组
+  AddEquipGroup(e) {
+    const { parentGroupId: t, groupId: s, groupName: n } = e || {};
+    s && (this.window.groupList_manageMent || (this.window.groupList_manageMent = []), this.window.groupList_manageMent.push({
+      parentId: t,
+      id: s,
+      name: n,
+      equipCount: 0
+    }), this.notice({ type: "AddEquipGroup", data: e }));
+  }
+  // 编辑分组
+  EditEquipGroup(e) {
+    const { groupId: t, groupName: s } = e;
+    this.window.groupList && window.groupList.forEach((n) => {
+      n.id == t && (n.name = s);
+    }), this.window.groupList_manageMent && window.groupList_manageMent.forEach((n) => {
+      n.id == t && (n.name = s);
+    }), this.notice({ type: "EditEquipGroup", data: e });
+  }
+  deleteChildGroup(e, t) {
+    let s = [];
+    t.forEach((n) => {
+      n.parentId == e && s.push(n.id);
+    }), s.forEach((n) => {
+      let r = t.findIndex((o) => o.id == n);
+      r > -1 && t.splice(r, 1), this.deleteChildGroup(n, t);
+    });
+  }
+  // 删除分组
+  DeleteEquipGroup(e) {
+    e.forEach((t) => {
+      if (this.window.groupList) {
+        let s = this.window.groupList.findIndex((n) => n.id == t.groupId);
+        s > -1 && this.window.groupList.splice(s, 1), this.deleteChildGroup(t.groupId, this.window.groupList);
+      }
+      if (this.window.groupList_manageMent) {
+        let s = this.window.groupList_manageMent.findIndex((n) => n.id == t.groupId);
+        s > -1 && this.window.groupList_manageMent.splice(s, 1), this.deleteChildGroup(t.groupId, this.window.groupList_manageMent);
+      }
+    }), this.notice({ type: "DeleteEquipGroup", data: e });
+  }
+  // 获取设备
+  GetGroupEquips(e) {
+    const { groupId: t, equips: s } = e || {};
+    this.alreadyUpdate[t] || (this.window.groupCache || (this.window.groupCache = {}), this.window.groupCache[t] = {}, t && s && s instanceof Array && (s.forEach((n) => {
+      n.title = n.name, n.groupId = t, n.equipNo = n.id, this.window.equipCache || (this.window.equipCache = {}), this.window.equipCache[n.id] = n, this.window.groupCache[t][n.id] = n;
+    }), this.window[`group-${t}`] = s, this.notice({ type: "GetGroupEquips", data: { groupId: t } }), this.alreadyUpdate[t] = !0));
+  }
+  // 新增设备
+  AddEquip(e) {
+    const { groupId: t, equips: s } = e || {};
+    this.window[`group-${t}`] || (this.window[`group-${t}`] = []), this.window.groupCache || (this.window.groupCache = {}), this.window.groupCache[t] || (this.window.groupCache[t] = {}), this.window.equipCache || (this.window.equipCache = {});
+    let n = this.window[`group-${t}`].length;
+    if (t && s) {
+      if (s.forEach((r, o) => {
+        this.window[`group-${t}`].push(
+          {
+            equipNo: r.id,
+            groupId: t,
+            id: r.id,
+            title: r.name
+          }
+        ), this.window.equipCache[r.id] = this.window[`group-${t}`][n + o], this.window.groupCache[t][r.id] = this.window[`group-${t}`][n + o];
+      }), !this.exist(t, this.window.groupList)) {
+        let r = this.findParentList(t, this.window.groupList_manageMent);
+        this.window.groupList.push(...r);
+      }
+      this.notice({ type: "AddEquip", data: e });
+    }
+  }
+  MoveEquips(e) {
+    let t = [], s = !0, n = [];
+    const { sourceGroup: r, targetGroupId: o } = e || {};
+    o && t.push(o), r.forEach((a) => {
+      if (t.push(a.groupId), (!this.window[`group-${o}`] || !this.window[`group-${o}`].length) && (this.window[`group-${o}`] = [], n.push(o)), this.window.groupCache || (this.window.groupCache = {}), this.window.groupCache[o] || (this.window.groupCache[o] = {}), a.equips.forEach((u) => {
+        if (!u.name && this.window.equipCache && this.window.equipCache[u.id] && (u.name = this.window.equipCache[u.id].title || this.window.equipCache[u.id].name), u.title = u.name || "", u.groupId = o, u.equipNo = u.id, this.window[`group-${a.groupId}`]) {
+          let c = this.window[`group-${a.groupId}`].findIndex((h) => h.id == u.id);
+          c > -1 && this.window[`group-${a.groupId}`].splice(c, 1);
+        }
+        this.window.equipCache || (this.window.equipCache = {}), this.window.equipCache[u.id] = u, this.window.groupCache[o][u.id] = u, this.window[`group-${o}`].push(u);
+      }), !this.window[`group-${a.groupId}`].length) {
+        let u = this.window.groupList.findIndex((c) => c.id == a.groupId);
+        u > -1 && this.window.groupList.splice(u, 1), this.deleteChildGroup(a.groupId, this.window.groupList);
+      }
+    }), n.forEach((a) => {
+      if (!this.exist(a, this.window.groupList)) {
+        let u = this.findParentList(a, this.window.groupList_manageMent);
+        this.window.groupList.push(...u);
+      }
+    }), this.notice({ type: "MoveEquips", data: { updateGroups: t, buildTree: s } });
+  }
+  // 复制设备（纯复制，不删除源设备）
+  CopyEquips(e) {
+    const { targetGroupId: t, equips: s } = e || {};
+    if (!t || !s || !Array.isArray(s)) {
+      console.warn("CopyEquips: 无效的数据格式", e);
+      return;
+    }
+    let n = [t], r = [];
+    this.window[`group-${t}`] || (this.window[`group-${t}`] = [], r.push(t)), this.window.groupCache || (this.window.groupCache = {}), this.window.groupCache[t] || (this.window.groupCache[t] = {}), this.window.equipCache || (this.window.equipCache = {}), s.forEach((o) => {
+      !o.name && this.window.equipCache && this.window.equipCache[o.id] && (o.name = this.window.equipCache[o.id].title || this.window.equipCache[o.id].name);
+      const a = {
+        id: o.id,
+        equipNo: o.id,
+        groupId: t,
+        title: o.name || "",
+        name: o.name || ""
+      };
+      this.window.equipCache[o.id] = a, this.window.groupCache[t][o.id] = a, this.window[`group-${t}`].push(a);
+    }), r.forEach((o) => {
+      if (!this.exist(o, this.window.groupList)) {
+        let a = this.findParentList(o, this.window.groupList_manageMent);
+        this.window.groupList.push(...a);
+      }
+    }), this.notice({
+      type: "MoveEquips",
+      data: {
+        updateGroups: n,
+        buildTree: !1,
+        targetGroupId: t,
+        equipCount: s.length
+      }
+    });
+  }
+  exist(e, t) {
+    return t ? t.some((s) => s.id == e) : !1;
+  }
+  findParentList(e, t) {
+    let s = [];
+    if (t) {
+      let n = t.findIndex((r) => r.id == e);
+      n > -1 && s.push({ ...t[n] }), t[n].parentId && !this.exist(t[n].parentId, this.window.groupList) && s.push(...this.findParentList(t[n].parentId, this.window.groupList_manageMent));
+    }
+    return s;
+  }
+  // 删除设备
+  DeleteEquip(e) {
+    const { groupId: t, equips: s } = e || {};
+    if (t && s && s instanceof Array) {
+      if (this.window[`group-${t}`]) {
+ for (let n = 0, r = s.length; n < r; n++) {
+          let o = this.window[`group-${t}`].findIndex((a) => a.id == s[n].id);
+          o > -1 && this.window[`group-${t}`].splice(o, 1), delete this.window.equipCache[s[n].id], delete this.window.groupCache[t][s[n].id];
+        } 
+}
+      this.notice({ type: "DeleteEquip", data: e });
+    }
+  }
+  // 编辑设备
+  EditEquip(e) {
+    const { equipNo: t, groupId: s, equipName: n } = e || {};
+    s && t && (window[`group-${s}`] && (this.window.equipCache[t] = n), this.notice({ type: "EditEquip", data: e }));
+  }
+  notice(e) {
+    if (this.window.hasIframe) {
+      let t = document.getElementsByTagName("iframe");
+      for (let s of t) { s.contentWindow.postMessage(e); }
+    } else { window.postMessage(e, "*"); }
+  }
+}
+const mi = {
+  name: "treeV2",
+  components: {
+    tree: fi
+  },
+  mixins: [it],
+  data() {
+    return {
+      list: [],
+      refId: M.generateUUID(),
+      treeKey: null,
+      listKey: null,
+      hasBuildTree: !1
+    };
+  },
+  props: {
+    treeType: {
+      type: String,
+      default: ""
+    }
+  },
+  mounted() {
+    this.treeKey = `equipGroup${this.treeType}`, this.listKey = `groupList${this.treeType}`, this.window[this.treeKey] ? this.list = M.formateList(JSON.parse(JSON.stringify(this.window[this.treeKey]))) : this.window[this.listKey] && this.buildTree(), window.executeQueue || (window.executeQueues = {}), window.executeQueues[this.refId] = this.destroyTree, window.addEventListener("message", (i) => {
+      i && i.data && i.data.type && this[i.data.type] && this[i.data.type](i.data.data);
+    });
+    try {
+      this.window.hasIframe || this.selfRequest();
+    } catch {
+      this.selfRequest();
+    }
+  },
+  methods: {
+    selfRequest() {
+      new gi().Init();
+    },
+    GetEquipGroupTreeWidthTreeType() {
+      this.treeType && this.window[this.listKey] && this.buildTree();
+    },
+    GetEquipGroupTree() {
+      !this.treeType && this.window[this.listKey] && this.buildTree();
+    },
+    AddEquip(i) {
+      const { groupId: e } = i || {};
+      this.window[this.listKey] && (!e || !this.$refs[this.refId] || !this.$refs[this.refId].groupNodeObject[e]) && this.buildTree();
+    },
+    buildTree() {
+      if (this.window[this.listKey]) {
+        let i = M.listToTreeList(JSON.parse(JSON.stringify(this.window[this.listKey])));
+        this.list = M.formateList(JSON.parse(JSON.stringify(i))), this.window[`equipGroup${this.treeType}`] = i, this.hasBuildTree = !0;
+      }
+    },
+    filterMethod(i) {
+      this.$refs[this.refId].filterMethod(i);
+    },
+    resetCheckedStatus() {
+      this.$refs[this.refId].resetCheckedStatus();
+    },
+    getEquipSelectd() {
+      return this.$refs[this.refId].getEquipSelectd();
+    },
+    getEquipGroupSelectd() {
+      return this.$refs[this.refId].getEquipGroupSelectd();
+    },
+    getControlSelected() {
+      return this.$refs[this.refId].getControlSelected();
+    },
+    destroyTree() {
+      this.$refs[this.refId].destroyTree();
+    }
+  }
+};
+function yi(i, e, t, s, n, r) {
+  const o = G("tree");
+  return E(), oe(o, Mt({
+    ref: n.refId,
+    data: n.list
+  }, { ...i.$attrs, ...i.$props }, At(i.$listeners), { buildTree: r.buildTree }), null, 16, ["data", "buildTree"]);
+}
+const ve = /* @__PURE__ */ le(mi, [["render", yi]]);
+ve.install = function(i) {
+  i.component(ve.name, ve);
+};
+export {
+  ve as default
+};